gitnexus 1.6.5 → 1.6.6-rc.10

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

@@ -7,14 +7,15 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
-import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, isWriteQuery, } from '../../core/lbug/pool-adapter.js';
+import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, } from '../../core/lbug/pool-adapter.js';
+import { isValidQueryParams } from '../../core/lbug/query-params.js';
 import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/lbug-config.js';
-export { isWriteQuery };
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
-import { parseDiffHunks } 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 { GroupService } from '../../core/group/service.js';
 import { resolveAtGroupMemberRepoPath } from '../../core/group/resolve-at-member.js';
@@ -141,6 +142,7 @@ function logQueryError(context, err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.error({ context, err: msg }, 'GitNexus query failed');
 }
+const isReadOnlyDbError = (err) => /read-only database/i.test(err instanceof Error ? err.message : String(err));
 /**
  * Per-query latency telemetry for production aggregation (#553).
  *
@@ -160,6 +162,55 @@ function logQueryTiming(query, phases) {
     const truncated = query.length > 80 ? `${query.slice(0, 80)}…` : query;
     logger.debug({ query: truncated, totalMs, phases }, 'GitNexus query timing');
 }
+/** Resolve symlinks for path comparison; falls back to path.resolve on error.
+ * Uses `realpathSync.native` (not the pure-JS `realpathSync`) so that Windows
+ * 8.3 short names (e.g. RUNNER~1 → runneradmin) are expanded to long form,
+ * matching the output of `git rev-parse --show-toplevel`. */
+function tryRealpath(p) {
+    try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+/**
+ * Resolve the git diff cwd for detect_changes, auto-detecting linked worktrees.
+ *
+ * When `launchCwd` is a linked worktree of the same canonical repository as
+ * `repoPath` (i.e. `getGitRoot(launchCwd)` differs from `repoPath` but both
+ * share the same `getCanonicalRepoRoot`), returns the worktree's git root so
+ * that `git diff` sees the correct working directory and index.
+ *
+ * Returns `repoPath` unchanged in all other cases (non-worktree, git
+ * unavailable, unrelated repo).
+ *
+ * Extracted as a module-level export so tests can pass any `launchCwd` instead
+ * of relying on `process.cwd()`, which is fixed to the server launch directory
+ * and cannot be changed mid-process.
+ */
+export function resolveWorktreeCwd(repoPath, launchCwd) {
+    try {
+        const launchGitRoot = getGitRoot(launchCwd);
+        if (launchGitRoot) {
+            // Normalise via realpathSync before comparing so macOS /var → /private/var
+            // symlinks (and Windows 8.3 short names) don't create false mismatches.
+            const realLaunch = tryRealpath(launchGitRoot);
+            const realRepo = tryRealpath(repoPath);
+            if (realLaunch !== realRepo) {
+                const launchCanonical = getCanonicalRepoRoot(launchCwd);
+                const repoCanonical = getCanonicalRepoRoot(repoPath);
+                if (launchCanonical && repoCanonical && launchCanonical === repoCanonical) {
+                    return launchGitRoot;
+                }
+            }
+        }
+    }
+    catch {
+        // Best-effort; fall through to repoPath.
+    }
+    return repoPath;
+}
 export class LocalBackend {
     repos = new Map();
     contextCache = new Map();
@@ -1017,27 +1068,31 @@ export class LocalBackend {
             return [];
         }
     }
-    async executeCypher(repoName, query) {
+    async executeCypher(repoName, query, params = {}) {
         const repo = await this.resolveRepo(repoName);
-        return this.cypher(repo, { query });
+        return this.cypher(repo, { query, params });
     }
-    async cypher(repo, params) {
+    async cypher(repo, request) {
         await this.ensureInitialized(repo.id);
         if (!isLbugReady(repo.id)) {
             return { error: 'LadybugDB not ready. Index may be corrupted.' };
         }
-        // Block write operations (defense-in-depth — DB is already read-only)
-        if (isWriteQuery(params.query)) {
+        if (request.params !== undefined && !isValidQueryParams(request.params)) {
             return {
-                error: 'Write operations (CREATE, DELETE, SET, MERGE, REMOVE, DROP, ALTER, COPY, DETACH) are not allowed. The knowledge graph is read-only.',
+                error: '"params" must be a plain object with scalar values (string/number/boolean/null).',
             };
         }
         try {
-            const result = await executeQuery(repo.id, params.query);
+            const result = await executeParameterized(repo.id, request.query, request.params ?? {});
             return result;
         }
         catch (err) {
             const msg = err.message || 'Query failed';
+            if (isReadOnlyDbError(err)) {
+                return {
+                    error: 'Write operations (CREATE, DELETE, SET, MERGE, REMOVE, DROP, ALTER, COPY, DETACH) are not allowed. The knowledge graph is read-only.',
+                };
+            }
             if (isWalCorruptionError(err)) {
                 return {
                     error: msg,
@@ -1770,11 +1825,50 @@ export class LocalBackend {
         }
         let diffOutput;
         try {
+            // Resolve the cwd for git diff.
+            //
+            // In a linked worktree (e.g. /repo/wt-feature/), the user's staged and
+            // unstaged changes live in that worktree's separate working directory and
+            // index. Running `git diff` from the canonical repo root sees a different
+            // working tree and returns empty output.
+            //
+            // Resolution order (see resolveWorktreeCwd for details):
+            //   1. params.worktree — explicit override, validated against the
+            //      registered repo's canonical root.
+            //   2. Auto-detect — if the server's launch cwd (process.cwd()) is a
+            //      linked worktree of the same canonical repo, use its git root.
+            //   3. repo.repoPath — fallback (original behaviour, handled inside
+            //      resolveWorktreeCwd when no worktree is detected).
+            //
+            // Start with the auto-detected value; override with the validated
+            // explicit param when provided. This avoids a dead initial assignment.
+            let diffCwd = resolveWorktreeCwd(repo.repoPath, process.cwd());
+            if (params.worktree) {
+                if (!path.isAbsolute(params.worktree)) {
+                    return {
+                        error: `worktree must be an absolute path, got: "${params.worktree}"`,
+                    };
+                }
+                const providedResolved = path.resolve(params.worktree);
+                const repoCanonical = getCanonicalRepoRoot(repo.repoPath);
+                if (!repoCanonical) {
+                    return {
+                        error: `Could not determine canonical root for repo "${repo.repoPath}". Is git available?`,
+                    };
+                }
+                const worktreeCanonical = getCanonicalRepoRoot(providedResolved);
+                if (!worktreeCanonical || tryRealpath(worktreeCanonical) !== tryRealpath(repoCanonical)) {
+                    return {
+                        error: `worktree "${params.worktree}" is not a worktree of repo "${repo.repoPath}". Ensure the path is inside the same git repository.`,
+                    };
+                }
+                diffCwd = providedResolved;
+            }
             // maxBuffer raised from Node's 1MB default to 256MB to avoid ENOBUFS on
             // repos with large unstaged/untracked diffs (e.g. unignored build folders).
             // See issue: spawnSync git ENOBUFS in detect_changes(scope="unstaged").
             diffOutput = execFileSync('git', diffArgs, {
-                cwd: repo.repoPath,
+                cwd: diffCwd,
                 encoding: 'utf-8',
                 maxBuffer: 256 * 1024 * 1024,
             });

package/dist/mcp/tools.js

@@ -155,6 +155,10 @@ TIPS:
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Cypher query to execute' },
+                params: {
+                    type: 'object',
+                    description: 'Optional query parameters for placeholders (e.g. $name) to execute via prepared statement binding.',
+                },
                 repo: {
                     type: 'string',
                     description: 'Repository name or path. Omit if only one repo is indexed.',
@@ -218,6 +222,8 @@ Maps git diff hunks to indexed symbols, then traces which processes are impacted
 WHEN TO USE: Before committing — to understand what your changes affect. Pre-commit review, PR preparation.
 AFTER THIS: Review affected processes. Use context() on high-risk symbols. READ gitnexus://repo/{name}/process/{name} for full traces.
 
+GIT WORKTREE SUPPORT: GitNexus automatically detects when the MCP server was launched from inside a linked git worktree and runs git diff against that worktree — no extra parameters needed in the common case. Pass "worktree" explicitly only when the server was started from a different directory than the worktree you are editing (e.g., the server runs from the canonical root but your changes are in a linked worktree at a different path).
+
 Returns: changed symbols, affected processes, and a risk summary.`,
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
         inputSchema: {
@@ -233,6 +239,10 @@ Returns: changed symbols, affected processes, and a risk summary.`,
                     type: 'string',
                     description: 'Branch/commit for "compare" scope (e.g., "main")',
                 },
+                worktree: {
+                    type: 'string',
+                    description: 'Absolute path to a linked git worktree. Pass this when your changes are in a worktree (the .git entry at that path is a file, not a directory). GitNexus will run git diff from that worktree so staged/unstaged changes are correctly detected.',
+                },
                 repo: {
                     type: 'string',
                     description: 'Repository name or path. Omit if only one repo is indexed.',

package/dist/server/api.d.ts

@@ -68,5 +68,8 @@ export declare const handleFileRequest: (req: {
     };
     json: (body: any) => void;
 }, repoPath: string) => Promise<void>;
+export declare const handleQueryRequest: (req: express.Request, res: express.Response, resolveRepo: (repoName?: string) => Promise<{
+    storagePath: string;
+} | undefined>) => Promise<void>;
 export declare const createServer: (port: number, host?: string) => Promise<void>;
 export {};

package/dist/server/api.js

@@ -13,8 +13,8 @@ import path from 'path';
 import fs from 'fs/promises';
 import { createRequire } from 'node:module';
 import { loadMeta, listRegisteredRepos, getStoragePath } from '../storage/repo-manager.js';
-import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, flushWAL, closeLbug, withLbugDb, } from '../core/lbug/lbug-adapter.js';
-import { isWriteQuery } from '../core/lbug/pool-adapter.js';
+import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, flushWAL, closeLbug, withLbugDb, isReadOnlyDbError, } from '../core/lbug/lbug-adapter.js';
+import { isValidQueryParams } from '../core/lbug/query-params.js';
 import { NODE_TABLES } from '../_shared/index.js';
 import { searchFTSFromLbug } from '../core/search/bm25-index.js';
 import { hybridSearch } from '../core/search/hybrid-search.js';
@@ -533,6 +533,39 @@ export const handleFileRequest = async (req, res, repoPath) => {
         }
     }
 };
+export const handleQueryRequest = async (req, res, resolveRepo) => {
+    try {
+        const cypher = req.body.cypher;
+        if (!cypher) {
+            res.status(400).json({ error: 'Missing "cypher" in request body' });
+            return;
+        }
+        const queryParams = req.body.params;
+        if (queryParams !== undefined && !isValidQueryParams(queryParams)) {
+            res.status(400).json({
+                error: '"params" must be a plain object with scalar values (string/number/boolean/null)',
+            });
+            return;
+        }
+        const entry = await resolveRepo(requestedRepo(req));
+        if (!entry) {
+            res.status(404).json({ error: 'Repository not found' });
+            return;
+        }
+        const lbugPath = path.join(entry.storagePath, 'lbug');
+        const result = await withLbugDb(lbugPath, () => executePrepared(cypher, queryParams ?? {}), {
+            readOnly: true,
+        });
+        res.json({ result });
+    }
+    catch (err) {
+        if (isReadOnlyDbError(err)) {
+            res.status(403).json({ error: 'Write queries are not allowed via the HTTP API' });
+            return;
+        }
+        res.status(500).json({ error: err.message || 'Query failed' });
+    }
+};
 export const createServer = async (port, host = '127.0.0.1') => {
     const app = express();
     app.disable('x-powered-by');
@@ -892,28 +925,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
     });
     // Execute Cypher query
     app.post('/api/query', async (req, res) => {
-        try {
-            const cypher = req.body.cypher;
-            if (!cypher) {
-                res.status(400).json({ error: 'Missing "cypher" in request body' });
-                return;
-            }
-            if (isWriteQuery(cypher)) {
-                res.status(403).json({ error: 'Write queries are not allowed via the HTTP API' });
-                return;
-            }
-            const entry = await resolveRepo(requestedRepo(req));
-            if (!entry) {
-                res.status(404).json({ error: 'Repository not found' });
-                return;
-            }
-            const lbugPath = path.join(entry.storagePath, 'lbug');
-            const result = await withLbugDb(lbugPath, () => executeQuery(cypher));
-            res.json({ result });
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || 'Query failed' });
-        }
+        await handleQueryRequest(req, res, resolveRepo);
     });
     // Search (supports mode: 'hybrid' | 'semantic' | 'bm25', and optional enrichment)
     app.post('/api/search', async (req, res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5",
+  "version": "1.6.6-rc.10",
   "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",