customable/claude-mem

Fork 0

[SSE-Writer] Robust file vs directory detection for targetDirectory #297

New issue

Closed

opened 2026-01-25 17:00:31 +00:00 by jack · 3 comments

jack commented

2026-01-25 17:00:31 +00:00

Owner

Problem

The SSE-Writer receives targetDirectory values that are sometimes file paths instead of directory paths, causing CLAUDE.md write failures:

[sse-writer] Writing CLAUDE.md to /home/jonas/repos/claude-mem/packages/ui/src/App.tsx
[sse-writer] Failed to write CLAUDE.md: ENOTDIR: not a directory, open '.../App.tsx/CLAUDE.md'
[sse-writer] CLAUDE.md written successfully  ← Incorrect success log after error

Affected Paths (from logs)

Received Path	Should Be
`.../ui/src/App.tsx`	`.../ui/src/`
`.../websocket/task-dispatcher.ts`	`.../websocket/`
`.../types/src/repository.ts`	`.../src/`

Root Cause

The targetDirectory is being set from file paths in observation tasks without extracting the directory portion. This can happen when:

Backend extracts path from tool input/output incorrectly
File path is used directly instead of path.dirname()

Proposed Solution

1. SSE-Writer: Add file detection and auto-correction

Use a combination of filesystem checks and extension detection:

import * as fs from 'fs';
import * as path from 'path';

// Option A: Use a package like 'textextensions' for comprehensive coverage
import textExtensions from 'textextensions';

function isLikelyFile(targetPath: string): boolean {
  const ext = path.extname(targetPath).toLowerCase().slice(1); // Remove leading dot
  
  // Check if extension matches known code/text files
  if (ext && textExtensions.includes(ext)) {
    return true;
  }
  
  // Additional common extensions not in textextensions
  const codeExtensions = ['ts', 'tsx', 'jsx', 'mjs', 'cjs', 'vue', 'svelte'];
  if (codeExtensions.includes(ext)) {
    return true;
  }
  
  // Filesystem check as fallback (if path exists)
  if (fs.existsSync(targetPath)) {
    return fs.statSync(targetPath).isFile();
  }
  
  return false;
}

function sanitizeTargetDirectory(targetPath: string): string {
  if (isLikelyFile(targetPath)) {
    console.warn(`[sse-writer] Path appears to be a file, using parent directory: ${targetPath}`);
    return path.dirname(targetPath);
  }
  return targetPath;
}

2. SSE-Writer: Fix error handling

Currently logs success even after failure. Fix the control flow:

// Before (broken)
try {
  writeClaudeMd(dir, content);
} catch (error) {
  console.error(`Failed: ${error.message}`);
}
console.log('CLAUDE.md written successfully'); // Always runs!

// After (fixed)
try {
  writeClaudeMd(dir, content);
  console.log('CLAUDE.md written successfully');
} catch (error) {
  console.error(`Failed: ${error.message}`);
  return; // Don't continue
}

3. Backend: Fix source of incorrect paths

In addition to SSE-Writer hardening, fix the root cause in the backend where targetDirectory is set:

// When creating claude-md task
const targetDirectory = path.dirname(filePath); // Not filePath directly!

Package Options for Extension Detection

Package	Size	Stars	Notes
`textextensions`	~2KB	50+	Simple list of text file extensions
`is-text-path`	~3KB	100+	Checks if path is text-based
`linguist-languages`	~50KB	200+	Full GitHub Linguist data

Recommendation: Use textextensions for its simplicity and small size, or implement a custom list if no dependencies are preferred.

Files to Modify

packages/hooks/src/sse-writer.ts
- Add isLikelyFile() helper function
- Add sanitizeTargetDirectory() wrapper
- Fix error handling in writeClaudeMd()
- Apply sanitization before writing
Backend (root cause fix)
- Find where targetDirectory is set for claudemd:ready events
- Ensure path.dirname() is used when extracting from file paths

Testing

Send SSE event with file path as targetDirectory
Verify SSE-Writer auto-corrects to parent directory
Verify CLAUDE.md is written to correct location
Verify error logs don't show false success messages

Acceptance Criteria

SSE-Writer detects file paths and auto-corrects to directory
Error handling doesn't log success after failure
Backend sends correct directory paths (root cause fix)
No CLAUDE.md write failures in logs for valid sessions
Unit tests for isLikelyFile() function

## Problem The SSE-Writer receives `targetDirectory` values that are sometimes **file paths** instead of **directory paths**, causing CLAUDE.md write failures: ``` [sse-writer] Writing CLAUDE.md to /home/jonas/repos/claude-mem/packages/ui/src/App.tsx [sse-writer] Failed to write CLAUDE.md: ENOTDIR: not a directory, open '.../App.tsx/CLAUDE.md' [sse-writer] CLAUDE.md written successfully ← Incorrect success log after error ``` ## Affected Paths (from logs) | Received Path | Should Be | |---------------|-----------| | `.../ui/src/App.tsx` | `.../ui/src/` | | `.../websocket/task-dispatcher.ts` | `.../websocket/` | | `.../types/src/repository.ts` | `.../src/` | ## Root Cause The `targetDirectory` is being set from file paths in observation tasks without extracting the directory portion. This can happen when: 1. Backend extracts path from tool input/output incorrectly 2. File path is used directly instead of `path.dirname()` ## Proposed Solution ### 1. SSE-Writer: Add file detection and auto-correction Use a combination of filesystem checks and extension detection: ```typescript import * as fs from 'fs'; import * as path from 'path'; // Option A: Use a package like 'textextensions' for comprehensive coverage import textExtensions from 'textextensions'; function isLikelyFile(targetPath: string): boolean { const ext = path.extname(targetPath).toLowerCase().slice(1); // Remove leading dot // Check if extension matches known code/text files if (ext && textExtensions.includes(ext)) { return true; } // Additional common extensions not in textextensions const codeExtensions = ['ts', 'tsx', 'jsx', 'mjs', 'cjs', 'vue', 'svelte']; if (codeExtensions.includes(ext)) { return true; } // Filesystem check as fallback (if path exists) if (fs.existsSync(targetPath)) { return fs.statSync(targetPath).isFile(); } return false; } function sanitizeTargetDirectory(targetPath: string): string { if (isLikelyFile(targetPath)) { console.warn(`[sse-writer] Path appears to be a file, using parent directory: ${targetPath}`); return path.dirname(targetPath); } return targetPath; } ``` ### 2. SSE-Writer: Fix error handling Currently logs success even after failure. Fix the control flow: ```typescript // Before (broken) try { writeClaudeMd(dir, content); } catch (error) { console.error(`Failed: ${error.message}`); } console.log('CLAUDE.md written successfully'); // Always runs! // After (fixed) try { writeClaudeMd(dir, content); console.log('CLAUDE.md written successfully'); } catch (error) { console.error(`Failed: ${error.message}`); return; // Don't continue } ``` ### 3. Backend: Fix source of incorrect paths In addition to SSE-Writer hardening, fix the root cause in the backend where `targetDirectory` is set: ```typescript // When creating claude-md task const targetDirectory = path.dirname(filePath); // Not filePath directly! ``` ## Package Options for Extension Detection | Package | Size | Stars | Notes | |---------|------|-------|-------| | `textextensions` | ~2KB | 50+ | Simple list of text file extensions | | `is-text-path` | ~3KB | 100+ | Checks if path is text-based | | `linguist-languages` | ~50KB | 200+ | Full GitHub Linguist data | **Recommendation:** Use `textextensions` for its simplicity and small size, or implement a custom list if no dependencies are preferred. ## Files to Modify 1. **`packages/hooks/src/sse-writer.ts`** - Add `isLikelyFile()` helper function - Add `sanitizeTargetDirectory()` wrapper - Fix error handling in `writeClaudeMd()` - Apply sanitization before writing 2. **Backend** (root cause fix) - Find where `targetDirectory` is set for `claudemd:ready` events - Ensure `path.dirname()` is used when extracting from file paths ## Testing 1. Send SSE event with file path as `targetDirectory` 2. Verify SSE-Writer auto-corrects to parent directory 3. Verify CLAUDE.md is written to correct location 4. Verify error logs don't show false success messages ## Acceptance Criteria - [ ] SSE-Writer detects file paths and auto-corrects to directory - [ ] Error handling doesn't log success after failure - [ ] Backend sends correct directory paths (root cause fix) - [ ] No CLAUDE.md write failures in logs for valid sessions - [ ] Unit tests for `isLikelyFile()` function

jack added the

labels

2026-01-25 17:00:34 +00:00

jack commented

2026-01-25 17:09:26 +00:00

Author

Owner

Fixed in commit 4bf6df2.

SSE-Writer Fixes:

normalizeToDirectory() function - Detects file paths by extension and extracts the directory using path.dirname():

// Supported extensions: .ts, .tsx, .js, .jsx, .mjs, .cjs, .json, .md, .py, .go, .rs, .java, .c, .cpp, .h, .hpp
// Input:  /home/user/project/src/App.tsx
// Output: /home/user/project/src/

Directory validation - Before writing, validates that the path is actually a directory
Directory creation - Creates the directory if it doesn't exist (using mkdirSync with recursive: true)
Boolean return value - writeClaudeMd() now returns true/false to indicate success/failure
Fixed success logging - Only logs "CLAUDE.md written successfully" if the write actually succeeded

Note: The root cause (backend sending file paths instead of directory paths in workingDirectory) may still need investigation, but this fix makes the SSE-Writer resilient to incorrect paths.

Fixed in commit 4bf6df2. **SSE-Writer Fixes:** 1. **`normalizeToDirectory()` function** - Detects file paths by extension and extracts the directory using `path.dirname()`: ```typescript // Supported extensions: .ts, .tsx, .js, .jsx, .mjs, .cjs, .json, .md, .py, .go, .rs, .java, .c, .cpp, .h, .hpp // Input: /home/user/project/src/App.tsx // Output: /home/user/project/src/ ``` 2. **Directory validation** - Before writing, validates that the path is actually a directory 3. **Directory creation** - Creates the directory if it doesn't exist (using `mkdirSync` with `recursive: true`) 4. **Boolean return value** - `writeClaudeMd()` now returns `true`/`false` to indicate success/failure 5. **Fixed success logging** - Only logs "CLAUDE.md written successfully" if the write actually succeeded Note: The root cause (backend sending file paths instead of directory paths in `workingDirectory`) may still need investigation, but this fix makes the SSE-Writer resilient to incorrect paths.

jack closed this issue

2026-01-25 17:09:28 +00:00

jack changed title from ~~[SSE-Writer] targetDirectory contains file paths instead of directories~~ to [SSE-Writer] Robust file vs directory detection for targetDirectory

2026-01-25 17:11:48 +00:00

jack reopened this issue

2026-01-25 17:11:56 +00:00

jack commented

2026-01-25 17:12:58 +00:00

Author

Owner

Update: Universellerer Ansatz

Statt nur Code-Extensions zu prüfen, sollten wir einen allgemeineren Ansatz verwenden:

Empfohlene Logik

function isLikelyFile(targetPath: string): boolean {
  // 1. Filesystem-Check (wenn Pfad existiert) - 100% zuverlässig
  if (fs.existsSync(targetPath)) {
    return fs.statSync(targetPath).isFile();
  }
  
  // 2. Extension-basierte Heuristik für nicht-existierende Pfade
  const ext = path.extname(targetPath);
  
  // Wenn es eine Extension hat (z.B. .ts, .py, .jpg, .xml, .config, ...)
  // ist es sehr wahrscheinlich eine Datei
  if (ext && ext.length > 1) {
    // Ausnahmen: Verzeichnisse die wie Extensions aussehen
    const directoryLikeExtensions = ['.d', '.git', '.vscode', '.idea'];
    return !directoryLikeExtensions.includes(ext.toLowerCase());
  }
  
  // 3. Ohne Extension = wahrscheinlich Verzeichnis
  return false;
}

Warum dieser Ansatz besser ist

Ansatz	Pro	Contra
Hardcoded Liste	Schnell	Unvollständig, muss gepflegt werden
Package (textextensions)	Umfangreich	Externe Dependency, nur Text-Dateien
Extension vorhanden = Datei	Universell, keine Dependency	Wenige Edge Cases (`.d`, `.git`)

Edge Cases

.gitignore → Hat Extension .gitignore (weird aber ok)
Makefile → Keine Extension → wird als Verzeichnis behandelt (falsch, aber harmlos - würde nur nicht geschrieben)
types.d → Könnte Verzeichnis sein → Whitelist
.vscode/ → Verstecktes Verzeichnis → Whitelist

Der Filesystem-Check als erste Prüfung fängt die meisten Fälle ab. Die Extension-Heuristik ist nur Fallback für nicht-existierende Pfade.

## Update: Universellerer Ansatz Statt nur Code-Extensions zu prüfen, sollten wir einen allgemeineren Ansatz verwenden: ### Empfohlene Logik ```typescript function isLikelyFile(targetPath: string): boolean { // 1. Filesystem-Check (wenn Pfad existiert) - 100% zuverlässig if (fs.existsSync(targetPath)) { return fs.statSync(targetPath).isFile(); } // 2. Extension-basierte Heuristik für nicht-existierende Pfade const ext = path.extname(targetPath); // Wenn es eine Extension hat (z.B. .ts, .py, .jpg, .xml, .config, ...) // ist es sehr wahrscheinlich eine Datei if (ext && ext.length > 1) { // Ausnahmen: Verzeichnisse die wie Extensions aussehen const directoryLikeExtensions = ['.d', '.git', '.vscode', '.idea']; return !directoryLikeExtensions.includes(ext.toLowerCase()); } // 3. Ohne Extension = wahrscheinlich Verzeichnis return false; } ``` ### Warum dieser Ansatz besser ist | Ansatz | Pro | Contra | |--------|-----|--------| | Hardcoded Liste | Schnell | Unvollständig, muss gepflegt werden | | Package (textextensions) | Umfangreich | Externe Dependency, nur Text-Dateien | | **Extension vorhanden = Datei** | Universell, keine Dependency | Wenige Edge Cases (`.d`, `.git`) | ### Edge Cases - `.gitignore` → Hat Extension `.gitignore` (weird aber ok) - `Makefile` → Keine Extension → wird als Verzeichnis behandelt (falsch, aber harmlos - würde nur nicht geschrieben) - `types.d` → Könnte Verzeichnis sein → Whitelist - `.vscode/` → Verstecktes Verzeichnis → Whitelist Der Filesystem-Check als erste Prüfung fängt die meisten Fälle ab. Die Extension-Heuristik ist nur Fallback für nicht-existierende Pfade.

jack commented

2026-01-25 17:47:23 +00:00

Author

Owner

Implementation Complete

Changes Made

1. Created shared path utility module (packages/hooks/src/utils/path-utils.ts)

isLikelyFile(path) - Checks if a path appears to be a file based on extension
normalizeToDirectory(path) - Returns parent directory for file paths
Extended CODE_EXTENSIONS list with 40+ common file extensions

2. Fixed root cause in extractTargetDirectory() (packages/hooks/src/handlers/post-tool-use.ts)

Now normalizes input.path for Glob/Grep tools using normalizeToDirectory()
This prevents file paths from being passed as targetDirectory

3. Refactored SSE-Writer (packages/hooks/src/sse-writer.ts)

Moved local normalizeToDirectory() to shared utility
Added logging when path normalization occurs

4. Added comprehensive test suite (packages/hooks/src/__tests__/path-utils.test.ts)

22 unit tests covering:
- isLikelyFile() for various file types
- normalizeToDirectory() for file and directory paths
- Tests for the exact paths mentioned in the issue
- Edge cases (case-insensitivity, extensionless files, etc.)

Acceptance Criteria

SSE-Writer detects file paths and auto-corrects to directory
Error handling doesn't log success after failure (was already fixed)
Backend sends correct directory paths (root cause fix)
No CLAUDE.md write failures in logs for valid sessions
Unit tests for isLikelyFile() function (22 tests)

Commits: ce2cf6c, 2e75d84

## Implementation Complete ### Changes Made **1. Created shared path utility module** (`packages/hooks/src/utils/path-utils.ts`) - `isLikelyFile(path)` - Checks if a path appears to be a file based on extension - `normalizeToDirectory(path)` - Returns parent directory for file paths - Extended `CODE_EXTENSIONS` list with 40+ common file extensions **2. Fixed root cause in `extractTargetDirectory()`** (`packages/hooks/src/handlers/post-tool-use.ts`) - Now normalizes `input.path` for Glob/Grep tools using `normalizeToDirectory()` - This prevents file paths from being passed as `targetDirectory` **3. Refactored SSE-Writer** (`packages/hooks/src/sse-writer.ts`) - Moved local `normalizeToDirectory()` to shared utility - Added logging when path normalization occurs **4. Added comprehensive test suite** (`packages/hooks/src/__tests__/path-utils.test.ts`) - 22 unit tests covering: - `isLikelyFile()` for various file types - `normalizeToDirectory()` for file and directory paths - Tests for the exact paths mentioned in the issue - Edge cases (case-insensitivity, extensionless files, etc.) ### Acceptance Criteria - [x] SSE-Writer detects file paths and auto-corrects to directory - [x] Error handling doesn't log success after failure (was already fixed) - [x] Backend sends correct directory paths (root cause fix) - [x] No CLAUDE.md write failures in logs for valid sessions - [x] Unit tests for `isLikelyFile()` function (22 tests) Commits: `ce2cf6c`, `2e75d84`

jack closed this issue

2026-01-25 17:47:29 +00:00