gitnexus 1.6.4-rc.61 → 1.6.4-rc.63

package/dist/core/run-analyze.js

@@ -14,7 +14,7 @@ import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
 import { createSearchFTSIndexes } from './search/fts-indexes.js';
 import { getStoragePaths, saveMeta, loadMeta, ensureGitNexusIgnored, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
-import { getCurrentCommit, getRemoteUrl, hasGitDir, getInferredRepoName } from '../storage/git.js';
+import { getCurrentCommit, getRemoteUrl, hasGitDir, getInferredRepoName, resolveRepoIdentityRoot, } from '../storage/git.js';
 import { generateAIContextFiles } from '../cli/ai-context.js';
 import { EMBEDDING_TABLE_NAME } from './lbug/schema.js';
 import { STALE_HASH_SENTINEL } from './lbug/schema.js';
@@ -71,7 +71,12 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         if (currentCommit !== '') {
             await ensureGitNexusIgnored(repoPath);
             return {
-                repoName: options.registryName ?? getInferredRepoName(repoPath) ?? path.basename(repoPath),
+                // `resolveRepoIdentityRoot` collapses worktree roots to the
+                // canonical repo basename (#1259) but leaves arbitrary subdirs
+                // and `--skip-git` paths unchanged (#1232/#1233 intent preserved).
+                repoName: options.registryName ??
+                    getInferredRepoName(repoPath) ??
+                    path.basename(resolveRepoIdentityRoot(repoPath)),
                 repoPath,
                 stats: existingMeta.stats ?? {},
                 alreadyUpToDate: true,
@@ -219,7 +224,18 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 }
             }
             const { readServerMapping } = await import('./embeddings/server-mapping.js');
-            const projectName = path.basename(repoPath);
+            // Mirror the registry's name-resolution chain so the server-mapping
+            // lookup key stays aligned with the final registry name (#1259):
+            //   --name → remote-derived → canonical-root basename
+            // (preserved-alias is intentionally NOT consulted here — server
+            // mappings are addressed by the operationally-meaningful name the
+            // user configures, not by a sticky registry-only alias they may not
+            // know about. The previous canonical-only logic ignored both --name
+            // and remote-derived names, silently breaking server-mapping for
+            // anyone with a `--name` alias or remote-named repo.)
+            const projectName = options.registryName ??
+                getInferredRepoName(repoPath) ??
+                path.basename(resolveRepoIdentityRoot(repoPath));
             const serverName = await readServerMapping(projectName);
             const embeddingResult = await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (p) => {
                 const scaled = 90 + Math.round((p.percent / 100) * 8);

package/dist/server/api.js

@@ -1190,7 +1190,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
     });
     // ── Analyze API ──────────────────────────────────────────────────────
     // POST /api/analyze — start a new analysis job
-    app.post('/api/analyze', async (req, res) => {
+    app.post('/api/analyze', createRouteLimiter({ limit: 10 }), async (req, res) => {
         try {
             const { url: repoUrl, path: repoLocalPath, force, embeddings, dropEmbeddings } = req.body;
             // Input type validation
@@ -1433,7 +1433,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
     // ── Embedding endpoints ────────────────────────────────────────────
     const embedJobManager = new JobManager();
     // POST /api/embed — trigger server-side embedding generation
-    app.post('/api/embed', async (req, res) => {
+    app.post('/api/embed', createRouteLimiter({ limit: 20 }), async (req, res) => {
         try {
             const entry = await resolveRepo(requestedRepo(req));
             if (!entry) {

package/dist/storage/git.d.ts

@@ -28,6 +28,56 @@ export declare const getRemoteUrl: (repoPath: string) => string | undefined;
  * Find the git repository root from any path inside the repo
  */
 export declare const getGitRoot: (fromPath: string) => string | null;
+/**
+ * Get the *canonical* repository root, dereferencing git worktrees.
+ *
+ * Unlike `getGitRoot` (which uses `git rev-parse --show-toplevel` and
+ * returns the WORKTREE's root when called inside a linked worktree),
+ * this uses `git rev-parse --git-common-dir` — the shared `.git`
+ * directory, identical for the main checkout and every linked
+ * worktree — and returns its parent.
+ *
+ * Why it matters (#1259): when `gitnexus analyze` runs inside a
+ * worktree (e.g. `/repo/wt-feature/`), deriving `repoName` from
+ * `path.basename(getGitRoot(cwd))` registers the project under the
+ * worktree's directory slug (`wt-feature`) instead of the canonical
+ * repo's basename (`repo`). Each worktree then re-registers as a
+ * "different" project, AGENTS.md is rewritten with the wrong MCP URI,
+ * and Claude-Code-style worktree workflows silently accumulate
+ * duplicate registry entries.
+ *
+ * Returns `null` when the path is not inside a git repository or
+ * `git` is not available, so callers can chain safely:
+ * `getCanonicalRepoRoot(p) ?? getGitRoot(p) ?? p`.
+ *
+ * `--path-format=absolute` is required because `--git-common-dir`
+ * returns a path *relative to cwd* by default (e.g. `../.git` when
+ * called from a worktree), which would resolve to the wrong absolute
+ * path if the caller later resolved it from a different directory.
+ */
+export declare const getCanonicalRepoRoot: (fromPath: string) => string | null;
+/**
+ * Resolve `fromPath` to the directory whose basename should drive the
+ * registry name (#1259) — the *identity root*. Three outcomes:
+ *
+ *   1. `fromPath` IS the canonical checkout root → returns it unchanged.
+ *   2. `fromPath` is a linked-worktree root (has its own `.git` entry, but
+ *      `git rev-parse --git-common-dir` points at a different `.git`) →
+ *      returns the canonical repo root.
+ *   3. `fromPath` is anything else — an arbitrary subdir under a git repo,
+ *      a non-git folder, a `--skip-git` subdir of an unrelated parent
+ *      checkout — returns `fromPath` unchanged.
+ *
+ * Why not just use `getCanonicalRepoRoot` directly? Because `git rev-parse
+ * --git-common-dir` resolves the same canonical root for ANY path inside
+ * a git repo, including unrelated subdirs. Using it for registry-name
+ * derivation would silently re-key a `--skip-git` subdir analyze under
+ * the parent git's basename, defeating the user's `--skip-git` intent
+ * (regressing the #1232/#1233 fix). The "is this path a tree root"
+ * gate confines the canonical-root collapse to exactly the cases where
+ * #1259 matters: main checkouts and linked worktrees.
+ */
+export declare const resolveRepoIdentityRoot: (fromPath: string) => string;
 /**
  * Find a git root by checking only `.git` entries on the ancestor chain.
  *

package/dist/storage/git.js

@@ -91,6 +91,83 @@ export const getGitRoot = (fromPath) => {
         return null;
     }
 };
+/**
+ * Get the *canonical* repository root, dereferencing git worktrees.
+ *
+ * Unlike `getGitRoot` (which uses `git rev-parse --show-toplevel` and
+ * returns the WORKTREE's root when called inside a linked worktree),
+ * this uses `git rev-parse --git-common-dir` — the shared `.git`
+ * directory, identical for the main checkout and every linked
+ * worktree — and returns its parent.
+ *
+ * Why it matters (#1259): when `gitnexus analyze` runs inside a
+ * worktree (e.g. `/repo/wt-feature/`), deriving `repoName` from
+ * `path.basename(getGitRoot(cwd))` registers the project under the
+ * worktree's directory slug (`wt-feature`) instead of the canonical
+ * repo's basename (`repo`). Each worktree then re-registers as a
+ * "different" project, AGENTS.md is rewritten with the wrong MCP URI,
+ * and Claude-Code-style worktree workflows silently accumulate
+ * duplicate registry entries.
+ *
+ * Returns `null` when the path is not inside a git repository or
+ * `git` is not available, so callers can chain safely:
+ * `getCanonicalRepoRoot(p) ?? getGitRoot(p) ?? p`.
+ *
+ * `--path-format=absolute` is required because `--git-common-dir`
+ * returns a path *relative to cwd* by default (e.g. `../.git` when
+ * called from a worktree), which would resolve to the wrong absolute
+ * path if the caller later resolved it from a different directory.
+ */
+export const getCanonicalRepoRoot = (fromPath) => {
+    try {
+        const commonDir = execSync('git rev-parse --path-format=absolute --git-common-dir', {
+            cwd: fromPath,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })
+            .toString()
+            .trim();
+        if (!commonDir)
+            return null;
+        // Common dir is `<repo>/.git` for both the main checkout and all
+        // linked worktrees. Its parent is the canonical repo root.
+        return path.dirname(path.resolve(commonDir));
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Resolve `fromPath` to the directory whose basename should drive the
+ * registry name (#1259) — the *identity root*. Three outcomes:
+ *
+ *   1. `fromPath` IS the canonical checkout root → returns it unchanged.
+ *   2. `fromPath` is a linked-worktree root (has its own `.git` entry, but
+ *      `git rev-parse --git-common-dir` points at a different `.git`) →
+ *      returns the canonical repo root.
+ *   3. `fromPath` is anything else — an arbitrary subdir under a git repo,
+ *      a non-git folder, a `--skip-git` subdir of an unrelated parent
+ *      checkout — returns `fromPath` unchanged.
+ *
+ * Why not just use `getCanonicalRepoRoot` directly? Because `git rev-parse
+ * --git-common-dir` resolves the same canonical root for ANY path inside
+ * a git repo, including unrelated subdirs. Using it for registry-name
+ * derivation would silently re-key a `--skip-git` subdir analyze under
+ * the parent git's basename, defeating the user's `--skip-git` intent
+ * (regressing the #1232/#1233 fix). The "is this path a tree root"
+ * gate confines the canonical-root collapse to exactly the cases where
+ * #1259 matters: main checkouts and linked worktrees.
+ */
+export const resolveRepoIdentityRoot = (fromPath) => {
+    const resolved = path.resolve(fromPath);
+    const canonical = getCanonicalRepoRoot(resolved);
+    if (!canonical)
+        return resolved; // non-git → use as-is
+    if (canonical === resolved)
+        return canonical; // canonical checkout
+    if (hasGitDir(resolved))
+        return canonical; // linked worktree (has .git file)
+    return resolved; // arbitrary subdir under a git repo → preserve as-is
+};
 /**
  * Find a git root by checking only `.git` entries on the ancestor chain.
  *

package/dist/storage/repo-manager.js

@@ -9,7 +9,7 @@ import fs from 'fs/promises';
 import { realpathSync } from 'fs';
 import path from 'path';
 import os from 'os';
-import { getInferredRepoName } from './git.js';
+import { getInferredRepoName, resolveRepoIdentityRoot } from './git.js';
 /**
  * Normalise a repo path for registry comparison across platforms
  * (#664 review feedback from @evander-wang).
@@ -296,6 +296,18 @@ const hasCustomAlias = (entry, inferredName) => {
     const resolved = path.resolve(entry.path);
     if (entry.name === path.basename(resolved))
         return false;
+    // Canonical-root-derived names are not user aliases either (#1259):
+    // a worktree registered under the canonical repo's basename
+    // (e.g. `{name: 'repo', path: '/repo/wt-feature'}`) must re-register
+    // cleanly without firing the duplicate-name collision guard. Without
+    // this check `entry.name = 'repo'` !== `path.basename('/repo/wt-feature') = 'wt-feature'`,
+    // so the prior check returns true → `isPreservedAlias = true` → guard
+    // throws `RegistryNameCollisionError` against the also-registered
+    // canonical checkout entry. The Claude-Code per-task worktree workflow
+    // — analyze canonical, then analyze worktree, then re-analyze worktree
+    // — would break on the third call.
+    if (entry.name === path.basename(resolveRepoIdentityRoot(resolved)))
+        return false;
     if (inferredName && entry.name === inferredName)
         return false;
     return true;
@@ -372,7 +384,13 @@ export const registerRepo = async (repoPath, meta, opts) => {
             isPreservedAlias = true;
         }
         else {
-            name = inferred ?? path.basename(resolved);
+            // Canonical-root fallback: when `resolved` is a worktree root,
+            // derive the registry name from the canonical repo's basename, not
+            // the worktree slug — see #1259. `resolveRepoIdentityRoot` confines
+            // the collapse to canonical checkouts and linked worktree roots only,
+            // so `--skip-git` subdirs of unrelated parent git repos keep using
+            // their own basename (preserves the #1232/#1233 fix's intent).
+            name = inferred ?? path.basename(resolveRepoIdentityRoot(resolved));
         }
     }
     // Duplicate-name guard: only fire when the user EXPLICITLY asked for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.61",
+  "version": "1.6.4-rc.63",
   "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",