fix: resolve encoded project paths with underscores via DFS backtracking (#17)

ithiria894 · claude · ithiria894 · commit 9588e8acea08 · 2026-03-29T14:31:29.000-07:00
Replace greedy path resolver with DFS + backtracking that lists actual
directory entries and normalizes underscores before comparing. Fixes
silent disappearance of projects whose paths contain underscores.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@mcpware/claude-code-organizer",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Organize all your Claude Code memories, skills, MCP servers, commands, agents, rules, and hooks — view by scope hierarchy, move between scopes via drag-and-drop",
   "type": "module",
   "files": [
diff --git a/src/scanner.mjs b/src/scanner.mjs
@@ -159,45 +159,63 @@ async function getSettingsOverrides() {
  * at each level by consuming segments from the encoded name.
  */
 async function resolveEncodedProjectPath(encoded) {
-  // Remove leading dash, split by dash
   const segments = encoded.replace(/^-/, "").split("-");
-  let currentPath = "/";
-  let i = 0;
+  let rootPath = "/";
+  let startIdx = 0;
 
   // Windows: encoded paths look like "c--Users-user-Desktop-project"
   // The drive letter "c" becomes the first segment, followed by empty string from "--"
   // Need to detect and convert to "C:\"
   if (platform() === "win32" && segments.length >= 2 && segments[0].length === 1 && segments[1] === "") {
-    currentPath = segments[0].toUpperCase() + ":\\";
-    i = 2; // skip drive letter + empty segment
+    rootPath = segments[0].toUpperCase() + ":\\";
+    startIdx = 2;
   }
 
-  while (i < segments.length) {
-    // Try longest match first: join remaining segments and check if directory exists
-    let matched = false;
+  // Normalize for comparison: lowercase, replace _ with -
+  // Claude Code's encoding replaces both / and _ with -, making it lossy.
+  // By normalizing both sides we can match "My_Projects" against "My-Projects".
+  const norm = (s) => s.toLowerCase().replace(/_/g, "-");
+
+  // DFS resolver with backtracking — lists actual directory entries at each
+  // level instead of guessing paths, so underscore/hyphen ambiguity is handled.
+  async function resolve(currentPath, i) {
+    if (i >= segments.length) {
+      return (await exists(currentPath)) ? currentPath : null;
+    }
+
+    let entries;
+    try {
+      entries = await readdir(currentPath, { withFileTypes: true });
+      entries = entries.filter(e => e.isDirectory());
+    } catch {
+      return null;
+    }
+
+    // Map normalized directory names → actual names on disk
+    const entryMap = new Map();
+    for (const e of entries) {
+      const key = norm(e.name);
+      if (!entryMap.has(key)) entryMap.set(key, []);
+      entryMap.get(key).push(e.name);
+    }
+
+    // Try longest match first, backtrack on failure
     for (let end = segments.length; end > i; end--) {
-      const candidate = segments.slice(i, end).join("-");
-      const testPath = join(currentPath, candidate);
-      if (await exists(testPath)) {
-        const s = await safeStat(testPath);
-        if (s && s.isDirectory()) {
-          currentPath = testPath;
-          i = end;
-          matched = true;
-          break;
+      const candidate = norm(segments.slice(i, end).join("-"));
+      const matches = entryMap.get(candidate);
+      if (matches) {
+        for (const actualName of matches) {
+          const nextPath = join(currentPath, actualName);
+          const result = await resolve(nextPath, end);
+          if (result) return result;
         }
       }
     }
-    if (!matched) {
-      // Try single segment
-      currentPath = join(currentPath, segments[i]);
-      i++;
-    }
+
+    return null;
   }
 
-  // Verify the resolved path exists
-  if (await exists(currentPath)) return currentPath;
-  return null;
+  return resolve(rootPath, startIdx);
 }
 
 // ── Scope discovery ──────────────────────────────────────────────────
diff --git a/tests/e2e/dashboard.spec.mjs b/tests/e2e/dashboard.spec.mjs
@@ -2942,3 +2942,144 @@ test.describe('Security Scanner UI', () => {
     env.cleanup();
   });
 });
+
+// ── Path Resolution — underscore/hyphen ambiguity (#17) ────────────
+
+test.describe('Path Resolution', () => {
+
+  test('project with underscores in path is resolved and visible (#17)', async () => {
+    // Claude Code encodes both "/" and "_" as "-", making the encoding lossy.
+    // E.g. /tmp/cco-test-xyz/My_Projects/ai_repo → encoded as -tmp-cco-test-xyz-My-Projects-ai-repo
+    // The resolver must match "My-Projects" back to "My_Projects" on disk.
+    const port = PORT_COUNTER++;
+    const tmpDir = await mkdtemp(join(tmpdir(), 'cco-test-'));
+    const claudeDir = join(tmpDir, '.claude');
+
+    // Create a project dir with underscores
+    const projectDir = join(tmpDir, 'My_Projects', 'ai_repo');
+    await mkdir(projectDir, { recursive: true });
+
+    // Claude Code's encoding: replace both / and _ with -
+    const encodedProject = projectDir.replace(/[/_]/g, '-');
+    const projectMemDir = join(claudeDir, 'projects', encodedProject, 'memory');
+    await mkdir(projectMemDir, { recursive: true });
+    await writeFile(join(projectMemDir, 'MEMORY.md'), '# Memory Index\n');
+    await writeFile(join(projectMemDir, 'test_note.md'),
+      `---\nname: test_note\ndescription: Test note in underscore project\ntype: project\n---\nThis project has underscores in path.`);
+
+    // Need at least one global memory for warmup check
+    await mkdir(join(claudeDir, 'memory'), { recursive: true });
+    await writeFile(join(claudeDir, 'memory', 'MEMORY.md'), '# Memory Index\n');
+    await writeFile(join(claudeDir, 'memory', 'dummy.md'),
+      `---\nname: dummy\ndescription: dummy\ntype: user\n---\ndummy`);
+
+    // Start server using cli.mjs (same as createTestEnv)
+    let actualPort = port;
+    const srv = await new Promise((resolve, reject) => {
+      const proc = spawn(NODE_BIN, [join(PROJECT_ROOT, 'bin', 'cli.mjs'), '--port', String(port)], {
+        env: { ...process.env, HOME: tmpDir },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      const timeout = setTimeout(() => reject(new Error('Server start timeout')), 10000);
+      proc.stdout.on('data', (data) => {
+        const msg = data.toString();
+        if (msg.includes('running at')) {
+          clearTimeout(timeout);
+          const match = msg.match(/localhost:(\d+)/);
+          if (match) actualPort = parseInt(match[1], 10);
+          resolve(proc);
+        }
+      });
+      proc.on('error', (err) => { clearTimeout(timeout); reject(err); });
+    });
+    const baseURL = `http://localhost:${actualPort}`;
+
+    // Warmup
+    for (let i = 0; i < 10; i++) {
+      try { const r = await (await fetch(`${baseURL}/api/scan`)).json(); if (r.items?.length > 0) break; } catch {}
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    const scanRes = await fetch(`${baseURL}/api/scan`);
+    const data = await scanRes.json();
+
+    // The underscore project should be resolved — look for its memory item
+    const underscoreItems = data.items.filter(i =>
+      i.scopeId !== 'global' && i.name === 'test_note'
+    );
+    expect(underscoreItems.length).toBe(1);
+
+    // The scope should show the real path with underscores, not hyphens
+    const scope = data.scopes.find(s => s.repoDir && s.repoDir.includes('My_Projects'));
+    expect(scope).toBeTruthy();
+    expect(scope.repoDir).toContain('My_Projects');
+    expect(scope.repoDir).toContain('ai_repo');
+
+    srv.kill('SIGKILL');
+    await new Promise(r => setTimeout(r, 500));
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  test('project with hyphens in path still resolves correctly', async () => {
+    // Ensure the fix for underscores doesn't break normal hyphenated paths
+    const port = PORT_COUNTER++;
+    const tmpDir = await mkdtemp(join(tmpdir(), 'cco-test-'));
+    const claudeDir = join(tmpDir, '.claude');
+
+    const projectDir = join(tmpDir, 'my-company', 'my-repo');
+    await mkdir(projectDir, { recursive: true });
+
+    // Normal encoding: only / replaced with -
+    const encodedProject = projectDir.replace(/\//g, '-');
+    const projectMemDir = join(claudeDir, 'projects', encodedProject, 'memory');
+    await mkdir(projectMemDir, { recursive: true });
+    await writeFile(join(projectMemDir, 'MEMORY.md'), '# Memory Index\n');
+    await writeFile(join(projectMemDir, 'hyphen_note.md'),
+      `---\nname: hyphen_note\ndescription: Test note in hyphenated project\ntype: project\n---\nThis project has hyphens in path.`);
+
+    await mkdir(join(claudeDir, 'memory'), { recursive: true });
+    await writeFile(join(claudeDir, 'memory', 'MEMORY.md'), '# Memory Index\n');
+    await writeFile(join(claudeDir, 'memory', 'dummy.md'),
+      `---\nname: dummy\ndescription: dummy\ntype: user\n---\ndummy`);
+
+    let actualPort = port;
+    const srv = await new Promise((resolve, reject) => {
+      const proc = spawn(NODE_BIN, [join(PROJECT_ROOT, 'bin', 'cli.mjs'), '--port', String(port)], {
+        env: { ...process.env, HOME: tmpDir },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      const timeout = setTimeout(() => reject(new Error('Server start timeout')), 10000);
+      proc.stdout.on('data', (data) => {
+        const msg = data.toString();
+        if (msg.includes('running at')) {
+          clearTimeout(timeout);
+          const match = msg.match(/localhost:(\d+)/);
+          if (match) actualPort = parseInt(match[1], 10);
+          resolve(proc);
+        }
+      });
+      proc.on('error', (err) => { clearTimeout(timeout); reject(err); });
+    });
+    const baseURL = `http://localhost:${actualPort}`;
+
+    for (let i = 0; i < 10; i++) {
+      try { const r = await (await fetch(`${baseURL}/api/scan`)).json(); if (r.items?.length > 0) break; } catch {}
+      await new Promise(r => setTimeout(r, 300));
+    }
+
+    const scanRes = await fetch(`${baseURL}/api/scan`);
+    const data = await scanRes.json();
+
+    const hyphenItems = data.items.filter(i =>
+      i.scopeId !== 'global' && i.name === 'hyphen_note'
+    );
+    expect(hyphenItems.length).toBe(1);
+
+    const scope = data.scopes.find(s => s.repoDir && s.repoDir.includes('my-company'));
+    expect(scope).toBeTruthy();
+
+    srv.kill('SIGKILL');
+    await new Promise(r => setTimeout(r, 500));
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+});

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@mcpware/claude-code-organizer",`
`3`		`- "version": "0.10.3",`
	`3`	`+ "version": "0.10.4",`
`4`	`4`	`"description": "Organize all your Claude Code memories, skills, MCP servers, commands, agents, rules, and hooks — view by scope hierarchy, move between scopes via drag-and-drop",`
`5`	`5`	`"type": "module",`
`6`	`6`	`"files": [`