gitnexus 1.6.6-rc.33 → 1.6.6-rc.35

package/dist/mcp/local/local-backend.d.ts

@@ -73,6 +73,12 @@ interface RepoHandle {
  * and cannot be changed mid-process.
  */
 export declare function resolveWorktreeCwd(repoPath: string, launchCwd: string): string;
+/**
+ * Length of the base64url path hash appended to a colliding repo id.
+ * Exported so tests can pin the suffix shape without re-deriving the
+ * literal; see `repoId()` and the hashed-id resolution tier (#1658).
+ */
+export declare const REPO_ID_HASH_LENGTH = 6;
 export declare class LocalBackend {
     private repos;
     private contextCache;
@@ -128,8 +134,20 @@ export declare class LocalBackend {
     resolveRepo(repoParam?: string): Promise<RepoHandle>;
     /**
      * Try to resolve a repo from the in-memory cache. Returns null on miss.
+     * Throws {@link RegistryAmbiguousTargetError} when `repoParam` matches
+     * multiple handles by name and cwd cannot disambiguate (#1658).
      */
     private resolveRepoFromCache;
+    /**
+     * Prefer the indexed repo whose path matches the git root of process.cwd().
+     *
+     * In MCP stdio server mode, `process.cwd()` is the server's launch directory,
+     * not the agent client's cwd. If the server was started from an unrelated
+     * directory, `getGitRoot` returns null and duplicate-name resolution throws
+     * {@link RegistryAmbiguousTargetError} — callers should pass an absolute path.
+     */
+    private pickRepoHandleForCwd;
+    private handleToRegistryEntry;
     private ensureInitialized;
     /**
      * Get context for a specific repo (or the single repo if only one).

package/dist/mcp/local/local-backend.js

@@ -16,7 +16,7 @@ import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/l
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
 import { parseDiffHunks, getCanonicalRepoRoot, getGitRoot, } from '../../storage/git.js';
 import { realpathSync } from 'fs';
-import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-manager.js';
+import { listRegisteredRepos, cleanupOldKuzuFiles, canonicalizePath, RegistryAmbiguousTargetError, } from '../../storage/repo-manager.js';
 import { GroupService } from '../../core/group/service.js';
 import { resolveAtGroupMemberRepoPath } from '../../core/group/resolve-at-member.js';
 import { collectBestChunks } from '../../core/embeddings/types.js';
@@ -233,6 +233,12 @@ export function resolveWorktreeCwd(repoPath, launchCwd) {
     }
     return repoPath;
 }
+/**
+ * Length of the base64url path hash appended to a colliding repo id.
+ * Exported so tests can pin the suffix shape without re-deriving the
+ * literal; see `repoId()` and the hashed-id resolution tier (#1658).
+ */
+export const REPO_ID_HASH_LENGTH = 6;
 export class LocalBackend {
     repos = new Map();
     contextCache = new Map();
@@ -345,7 +351,13 @@ export class LocalBackend {
         for (const [id, handle] of this.repos) {
             if (id === base && handle.repoPath !== path.resolve(repoPath)) {
                 // Collision — use path hash
-                const hash = Buffer.from(repoPath).toString('base64url').slice(0, 6);
+                // Lowercase the hash so it survives the `paramLower` lookup in
+                // resolveRepoFromCache — base64url retains mixed case, but the id
+                // tier compares against `repoParam.toLowerCase()` (#1658 follow-up).
+                const hash = Buffer.from(repoPath)
+                    .toString('base64url')
+                    .slice(0, REPO_ID_HASH_LENGTH)
+                    .toLowerCase();
                 return `${base}-${hash}`;
             }
         }
@@ -362,7 +374,20 @@ export class LocalBackend {
      * while the MCP server was running.
      */
     async resolveRepo(repoParam) {
-        const result = this.resolveRepoFromCache(repoParam);
+        let refreshedAfterAmbiguity = false;
+        let result;
+        try {
+            result = this.resolveRepoFromCache(repoParam);
+        }
+        catch (err) {
+            if (!(err instanceof RegistryAmbiguousTargetError))
+                throw err;
+            // Stale in-memory duplicate siblings can linger after unregister; refresh
+            // once before re-throwing so a resolved registry can disambiguate (#1658).
+            await this.refreshRepos();
+            refreshedAfterAmbiguity = true;
+            result = this.resolveRepoFromCache(repoParam);
+        }
         if (result) {
             // Issue: silent graph drift across sibling clones.
             // If the caller's cwd lives in a *different* on-disk clone of
@@ -375,8 +400,10 @@ export class LocalBackend {
             });
             return result;
         }
-        // Miss — refresh registry and try once more
-        await this.refreshRepos();
+        // Miss — refresh registry and try once more (skip if already refreshed above)
+        if (!refreshedAfterAmbiguity) {
+            await this.refreshRepos();
+        }
         const retried = this.resolveRepoFromCache(repoParam);
         if (retried) {
             this.maybeWarnSiblingDrift(retried).catch(() => { });
@@ -403,31 +430,57 @@ export class LocalBackend {
     }
     /**
      * Try to resolve a repo from the in-memory cache. Returns null on miss.
+     * Throws {@link RegistryAmbiguousTargetError} when `repoParam` matches
+     * multiple handles by name and cwd cannot disambiguate (#1658).
      */
     resolveRepoFromCache(repoParam) {
         if (this.repos.size === 0)
             return null;
         if (repoParam) {
             const paramLower = repoParam.toLowerCase();
-            // Match by id
+            const looksLikePath = path.isAbsolute(repoParam) || repoParam.includes(path.sep) || repoParam.includes('/');
+            const resolvePathMatch = () => {
+                const canonicalTarget = canonicalizePath(repoParam);
+                return [...this.repos.values()].find((handle) => {
+                    const stored = canonicalizePath(handle.repoPath);
+                    return process.platform === 'win32'
+                        ? stored.toLowerCase() === canonicalTarget.toLowerCase()
+                        : stored === canonicalTarget;
+                });
+            };
+            // Path-like params first (absolute or contains separators) — aligns with
+            // resolveRegistryEntry (#829). Bare aliases such as ".tmp-repro-mini" must
+            // not be resolved via path.resolve(cwd) before duplicate-name handling.
+            if (looksLikePath) {
+                const pathMatch = resolvePathMatch();
+                if (pathMatch)
+                    return pathMatch;
+            }
+            // Exact name before id — the first duplicate sibling keeps id === name
+            // (e.g. id "shared"), so a name lookup must not be captured by the id tier.
+            const nameMatches = [...this.repos.values()].filter((handle) => handle.name.toLowerCase() === paramLower);
+            if (nameMatches.length === 1)
+                return nameMatches[0];
+            if (nameMatches.length > 1) {
+                const cwdPick = this.pickRepoHandleForCwd(nameMatches);
+                if (cwdPick)
+                    return cwdPick;
+                throw new RegistryAmbiguousTargetError(repoParam, nameMatches.map((h) => this.handleToRegistryEntry(h)));
+            }
+            // Stable hashed id (e.g. "shared-abc123") from repoId() collision suffix
             if (this.repos.has(paramLower))
                 return this.repos.get(paramLower);
-            // Match by name (case-insensitive)
-            for (const handle of this.repos.values()) {
-                if (handle.name.toLowerCase() === paramLower)
-                    return handle;
-            }
-            // Match by path (substring)
-            const resolved = path.resolve(repoParam);
-            for (const handle of this.repos.values()) {
-                if (handle.repoPath === resolved)
-                    return handle;
-            }
-            // Match by partial name
-            for (const handle of this.repos.values()) {
-                if (handle.name.toLowerCase().includes(paramLower))
-                    return handle;
-            }
+            // Bare name resolved as a cwd-relative path (e.g. "myrepo" against process.cwd()),
+            // after name/id tiers. Path-like strings with separators were handled at the top.
+            if (!looksLikePath) {
+                const pathMatch = resolvePathMatch();
+                if (pathMatch)
+                    return pathMatch;
+            }
+            // Partial name — only when unambiguous
+            const partialMatches = [...this.repos.values()].filter((handle) => handle.name.toLowerCase().includes(paramLower));
+            if (partialMatches.length === 1)
+                return partialMatches[0];
             return null;
         }
         if (this.repos.size === 1) {
@@ -435,6 +488,38 @@ export class LocalBackend {
         }
         return null; // Multiple repos, no param — ambiguous
     }
+    /**
+     * Prefer the indexed repo whose path matches the git root of process.cwd().
+     *
+     * In MCP stdio server mode, `process.cwd()` is the server's launch directory,
+     * not the agent client's cwd. If the server was started from an unrelated
+     * directory, `getGitRoot` returns null and duplicate-name resolution throws
+     * {@link RegistryAmbiguousTargetError} — callers should pass an absolute path.
+     */
+    pickRepoHandleForCwd(candidates) {
+        const cwdRoot = getGitRoot(process.cwd());
+        if (!cwdRoot)
+            return null;
+        const canonicalCwd = canonicalizePath(cwdRoot);
+        const cwdMatches = candidates.filter((handle) => {
+            const stored = canonicalizePath(handle.repoPath);
+            return process.platform === 'win32'
+                ? stored.toLowerCase() === canonicalCwd.toLowerCase()
+                : stored === canonicalCwd;
+        });
+        return cwdMatches.length === 1 ? cwdMatches[0] : null;
+    }
+    handleToRegistryEntry(handle) {
+        return {
+            name: handle.name,
+            path: handle.repoPath,
+            storagePath: handle.storagePath,
+            indexedAt: handle.indexedAt,
+            lastCommit: handle.lastCommit,
+            stats: handle.stats,
+            remoteUrl: handle.remoteUrl,
+        };
+    }
     // ─── Lazy LadybugDB Init ────────────────────────────────────────────
     async ensureInitialized(repoId) {
         // If a reinit is already in progress for this repo, wait for it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.33",
+  "version": "1.6.6-rc.35",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",