gitnexus 1.6.12-rc.17 → 1.6.12-rc.19

package/dist/cli/doctor.js

@@ -237,10 +237,12 @@ export const doctorCommand = async () => {
             console.log(`  ${padDisplayEnd('', 18)}${remedy}`);
         }
     }
-    // Semantic mode follows the probe, not the platform: without a loadable
-    // VECTOR extension the index can be neither built nor queried, so search is
-    // really on exact scan no matter what the platform would allow.
-    console.log(`  ${label('doctor.labels.semanticMode', 18)}${vectorProbe.loaded ? capabilities.semanticMode : 'exact-scan'}`);
+    // Doctor has no repository target, so this probe can report only whether the
+    // runtime can load VECTOR. It cannot claim that a repository has built the
+    // named HNSW index. Keep the capability and repository state distinct.
+    console.log(`  ${label('doctor.labels.semanticMode', 18)}${t(vectorProbe.loaded
+        ? 'doctor.vectorCapability.indexUnverified'
+        : 'doctor.vectorCapability.exactScanOnly')}`);
     // Surface the optional-extension install policy so offline users can see
     // whether analyze/query will reach the network (extension.ladybugdb.com).
     // Literal label (like the 'native' line) to avoid adding i18n keys.

package/dist/cli/i18n/en.d.ts

@@ -102,8 +102,10 @@ export declare const en: {
     readonly 'doctor.labels.onnx': "ONNX:";
     readonly 'doctor.labels.graphStore': "Graph store:";
     readonly 'doctor.labels.fullTextSearch': "Full-text search:";
-    readonly 'doctor.labels.vectorIndex': "VECTOR index:";
-    readonly 'doctor.labels.semanticMode': "Semantic mode:";
+    readonly 'doctor.labels.vectorIndex': "VECTOR extension:";
+    readonly 'doctor.labels.semanticMode': "Semantic support:";
+    readonly 'doctor.vectorCapability.indexUnverified': "vector-index capable (repository index not checked)";
+    readonly 'doctor.vectorCapability.exactScanOnly': "exact-scan only (VECTOR extension unavailable)";
     readonly 'doctor.labels.exactScanLimit': "Exact scan limit:";
     readonly 'doctor.labels.note': "Note:";
     readonly 'doctor.labels.backend': "Backend:";

package/dist/cli/i18n/en.js

@@ -104,8 +104,10 @@ export const en = {
     'doctor.labels.onnx': 'ONNX:',
     'doctor.labels.graphStore': 'Graph store:',
     'doctor.labels.fullTextSearch': 'Full-text search:',
-    'doctor.labels.vectorIndex': 'VECTOR index:',
-    'doctor.labels.semanticMode': 'Semantic mode:',
+    'doctor.labels.vectorIndex': 'VECTOR extension:',
+    'doctor.labels.semanticMode': 'Semantic support:',
+    'doctor.vectorCapability.indexUnverified': 'vector-index capable (repository index not checked)',
+    'doctor.vectorCapability.exactScanOnly': 'exact-scan only (VECTOR extension unavailable)',
     'doctor.labels.exactScanLimit': 'Exact scan limit:',
     'doctor.labels.note': 'Note:',
     'doctor.labels.backend': 'Backend:',

package/dist/cli/i18n/resources.d.ts

@@ -103,8 +103,10 @@ export declare const cliResources: {
         readonly 'doctor.labels.onnx': "ONNX:";
         readonly 'doctor.labels.graphStore': "Graph store:";
         readonly 'doctor.labels.fullTextSearch': "Full-text search:";
-        readonly 'doctor.labels.vectorIndex': "VECTOR index:";
-        readonly 'doctor.labels.semanticMode': "Semantic mode:";
+        readonly 'doctor.labels.vectorIndex': "VECTOR extension:";
+        readonly 'doctor.labels.semanticMode': "Semantic support:";
+        readonly 'doctor.vectorCapability.indexUnverified': "vector-index capable (repository index not checked)";
+        readonly 'doctor.vectorCapability.exactScanOnly': "exact-scan only (VECTOR extension unavailable)";
         readonly 'doctor.labels.exactScanLimit': "Exact scan limit:";
         readonly 'doctor.labels.note': "Note:";
         readonly 'doctor.labels.backend': "Backend:";
@@ -384,6 +386,8 @@ export declare const cliResources: {
         'doctor.labels.fullTextSearch': string;
         'doctor.labels.vectorIndex': string;
         'doctor.labels.semanticMode': string;
+        'doctor.vectorCapability.indexUnverified': string;
+        'doctor.vectorCapability.exactScanOnly': string;
         'doctor.labels.exactScanLimit': string;
         'doctor.labels.note': string;
         'doctor.labels.backend': string;

package/dist/cli/i18n/zh-CN.d.ts

@@ -104,6 +104,8 @@ export declare const zhCN: {
     'doctor.labels.fullTextSearch': string;
     'doctor.labels.vectorIndex': string;
     'doctor.labels.semanticMode': string;
+    'doctor.vectorCapability.indexUnverified': string;
+    'doctor.vectorCapability.exactScanOnly': string;
     'doctor.labels.exactScanLimit': string;
     'doctor.labels.note': string;
     'doctor.labels.backend': string;

package/dist/cli/i18n/zh-CN.js

@@ -102,8 +102,10 @@ export const zhCN = {
     'doctor.labels.onnx': 'ONNX：',
     'doctor.labels.graphStore': '图存储：',
     'doctor.labels.fullTextSearch': '全文搜索：',
-    'doctor.labels.vectorIndex': '向量索引：',
-    'doctor.labels.semanticMode': '语义模式：',
+    'doctor.labels.vectorIndex': 'VECTOR 扩展：',
+    'doctor.labels.semanticMode': '语义支持：',
+    'doctor.vectorCapability.indexUnverified': '支持向量索引（未检查仓库索引）',
+    'doctor.vectorCapability.exactScanOnly': '仅精确扫描（VECTOR 扩展不可用）',
     'doctor.labels.exactScanLimit': '精确扫描上限：',
     'doctor.labels.note': '说明：',
     'doctor.labels.backend': '后端：',

package/dist/core/git-staleness.js

@@ -8,6 +8,12 @@ import path from 'path';
 import { readRegistry } from '../storage/repo-manager.js';
 import { findGitRootByDotGit, getCurrentCommit, getRemoteUrl } from '../storage/git.js';
 const execFileAsync = promisify(execFile);
+/**
+ * Ceiling for one `git rev-list` staleness probe. Generous for the local
+ * history walk this is, and short enough that an unresponsive working tree
+ * degrades to "not stale" quickly rather than holding a request open.
+ */
+const STALENESS_TIMEOUT_MS = 5_000;
 /**
  * Check how many commits the index is behind HEAD (synchronous; uses git CLI).
  */
@@ -46,6 +52,14 @@ export async function checkStalenessAsync(repoPath, lastCommit) {
             cwd: repoPath,
             encoding: 'utf-8',
             windowsHide: true,
+            // The catch below fails closed on every git ERROR, but a hang is not an
+            // error — it is silence, and without a bound this await never settles.
+            // A working tree on a disconnected network mount or behind a stuck lock
+            // does exactly that, and `/api/repos` fans this out once per registered
+            // repo, so one unreachable mount could hold the whole listing open
+            // (#3232 review). The timeout kills the child and rejects, which routes
+            // a hang into the same fail-closed "not stale" answer as a bad SHA.
+            timeout: STALENESS_TIMEOUT_MS,
         });
         const commitsBehind = parseInt(stdout.trim(), 10) || 0;
         if (commitsBehind > 0) {

package/dist/server/api.js

@@ -31,6 +31,8 @@ import { parseGrepQuery, GREP_TIME_BUDGET_MS } from './grep-params.js';
 import { runGrepScanInWorker } from './grep-scan.js';
 import { analyzeCloneOptions, extractWebRepoName, getCloneDir, cloneOrPull, warnIfInsecureAzureConfig, GITHUB_TOKEN_HOSTS, } from './git-clone.js';
 import { createAnalyzeUploadHandler } from './analyze-upload.js';
+import { checkStalenessAsync } from '../core/git-staleness.js';
+import { projectRepoDetail, projectRepoListEntry, resolveLastCommit } from './repo-projection.js';
 // Shared with the CLI's `--branch` (via the analyze-config wrapper) so both
 // entry points accept the same refs. Imported from core — not cli/ — so
 // createServer does not close a cycle with cli/serve.ts.
@@ -809,17 +811,19 @@ export const createServer = async (port, host = '127.0.0.1') => {
         res.json(buildServerInfo(updateController.snapshot()));
     });
     // List all registered repos
-    app.get('/api/repos', async (_req, res) => {
+    // Rate-limited (CodeQL js/missing-rate-limiting) because this route now spawns
+    // one `git rev-list` per registered repo to answer freshness: an unauthenticated
+    // GET that costs N subprocesses is worth the same 60 rpm/IP ceiling `/api/repo`
+    // already carries. Web callers hit this on connect/switch, never in a loop.
+    app.get('/api/repos', createRouteLimiter(), async (_req, res) => {
         try {
             const repos = await listRegisteredRepos();
-            res.json(repos.map((r) => ({
-                name: r.name,
-                path: r.path,
-                repoPath: r.path,
-                indexedAt: r.indexedAt,
-                lastCommit: r.lastCommit,
-                stats: r.stats,
-            })));
+            // Checked in parallel, for the reason `list_repos` already does it that
+            // way: each check spawns an async `git rev-list`, and the sequential
+            // variant took ~50s across 200 repos (#1363). Projecting inside the map
+            // keeps the entry and its own check together — an index-matched second
+            // array is the shape that silently mispairs them if either is reordered.
+            res.json(await Promise.all(repos.map(async (r) => projectRepoListEntry(r, await checkStalenessAsync(r.path, r.lastCommit)))));
         }
         catch (err) {
             res.status(500).json({ error: err.message || 'Failed to list repos' });
@@ -845,12 +849,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
                 return;
             }
             const meta = await loadMeta(entry.storagePath);
-            res.json({
-                name: entry.name,
-                repoPath: entry.path,
-                indexedAt: meta?.indexedAt ?? entry.indexedAt,
-                stats: meta?.stats ?? entry.stats ?? {},
-            });
+            const staleness = await checkStalenessAsync(entry.path, resolveLastCommit(entry, meta));
+            res.json(projectRepoDetail(entry, meta, staleness));
         }
         catch (err) {
             res.status(500).json({ error: err.message || 'Failed to get repo info' });

package/dist/server/repo-projection.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Response projections for the `serve` repo routes.
+ *
+ * Extracted from the route bodies so the field list is assertable. Inline, the
+ * projections were only reachable by booting a server and indexing a real
+ * repository, which is how `branch` came to sit on `RegistryEntry` unexposed
+ * over HTTP while `gitnexus list` printed it, with no test to notice (#3226).
+ *
+ * These are pure: the caller resolves the registry entry, the on-disk metadata
+ * and the staleness check, and passes the results in.
+ */
+import type { StalenessInfo } from '../core/git-staleness.js';
+import type { RegistryEntry } from '../storage/repo-manager.js';
+import type { RepoMeta } from '../storage/repo-meta.js';
+/**
+ * Staleness in the shape MCP `list_repos` already returns
+ * (`mcp/local/local-backend.ts`): the key is present only when the index is
+ * actually behind, so "fresh" stays the absence of a field rather than a second
+ * thing for a client to interpret. Deliberately identical across the two
+ * surfaces — the same fact should not have two shapes.
+ *
+ * `checkStalenessAsync` self-catches and reports 0 commits behind when the
+ * commit cannot be resolved, so an unanswerable check degrades to "not stale"
+ * rather than failing the request that carries it.
+ *
+ * That makes the field meaningful mainly for `path`-registered repositories,
+ * where an operator commits into the working tree the index was built from.
+ * A `url` repository is cloned `--depth 1` and is re-analyzed by the same run
+ * that pulls it, so its recorded commit is HEAD; and were the two ever to
+ * diverge, `git rev-list <old>..HEAD` cannot walk a shallow history and fails
+ * closed to "not stale". Reporting fresh there is not a claim that the remote
+ * has not moved — this measures the index against the local working tree, the
+ * same thing `gitnexus status` and MCP `list_repos` measure.
+ */
+export declare const stalenessField: (info: StalenessInfo) => {
+    staleness?: {
+        commitsBehind: number;
+        hint?: string;
+    };
+};
+/** One entry of `GET /api/repos`. */
+export declare const projectRepoListEntry: (entry: RegistryEntry, staleness: StalenessInfo) => {
+    staleness?: {
+        commitsBehind: number;
+        hint?: string;
+    };
+    name: string;
+    path: string;
+    repoPath: string;
+    indexedAt: string;
+    lastCommit: string;
+    stats: {
+        files?: number;
+        nodes?: number;
+        edges?: number;
+        communities?: number;
+        processes?: number;
+        embeddings?: number;
+    };
+    branch: string;
+    branches: import("../storage/branch-index.js").BranchSummary[];
+};
+/**
+ * `GET /api/repo`. `meta ?? entry` throughout, for the reason `indexedAt`
+ * already did it: the on-disk metadata is the fresher record when the two
+ * disagree, and the entry is the fallback for a repo whose meta cannot be read.
+ */
+export declare const projectRepoDetail: (entry: RegistryEntry, meta: RepoMeta | null | undefined, staleness: StalenessInfo) => {
+    staleness?: {
+        commitsBehind: number;
+        hint?: string;
+    };
+    name: string;
+    repoPath: string;
+    indexedAt: string;
+    stats: {
+        files?: number;
+        nodes?: number;
+        edges?: number;
+        communities?: number;
+        processes?: number;
+        embeddings?: number;
+    };
+    lastCommit: string;
+    branch: string;
+};
+/** The commit a `/api/repo` staleness check should be measured against. */
+export declare const resolveLastCommit: (entry: RegistryEntry, meta: RepoMeta | null | undefined) => string;

package/dist/server/repo-projection.js

@@ -0,0 +1,53 @@
+/**
+ * Staleness in the shape MCP `list_repos` already returns
+ * (`mcp/local/local-backend.ts`): the key is present only when the index is
+ * actually behind, so "fresh" stays the absence of a field rather than a second
+ * thing for a client to interpret. Deliberately identical across the two
+ * surfaces — the same fact should not have two shapes.
+ *
+ * `checkStalenessAsync` self-catches and reports 0 commits behind when the
+ * commit cannot be resolved, so an unanswerable check degrades to "not stale"
+ * rather than failing the request that carries it.
+ *
+ * That makes the field meaningful mainly for `path`-registered repositories,
+ * where an operator commits into the working tree the index was built from.
+ * A `url` repository is cloned `--depth 1` and is re-analyzed by the same run
+ * that pulls it, so its recorded commit is HEAD; and were the two ever to
+ * diverge, `git rev-list <old>..HEAD` cannot walk a shallow history and fails
+ * closed to "not stale". Reporting fresh there is not a claim that the remote
+ * has not moved — this measures the index against the local working tree, the
+ * same thing `gitnexus status` and MCP `list_repos` measure.
+ */
+export const stalenessField = (info) => info.isStale ? { staleness: { commitsBehind: info.commitsBehind, hint: info.hint } } : {};
+/** One entry of `GET /api/repos`. */
+export const projectRepoListEntry = (entry, staleness) => ({
+    name: entry.name,
+    path: entry.path,
+    repoPath: entry.path,
+    indexedAt: entry.indexedAt,
+    lastCommit: entry.lastCommit,
+    stats: entry.stats,
+    // The registry has carried these since #2106; #3199 made them load-bearing
+    // over HTTP, because a branch-pinned analyze now gets its own entry and the
+    // only other way to tell two entries apart is to parse the clone-directory
+    // slug — a layout detail, not an API contract.
+    branch: entry.branch,
+    branches: entry.branches,
+    ...stalenessField(staleness),
+});
+/**
+ * `GET /api/repo`. `meta ?? entry` throughout, for the reason `indexedAt`
+ * already did it: the on-disk metadata is the fresher record when the two
+ * disagree, and the entry is the fallback for a repo whose meta cannot be read.
+ */
+export const projectRepoDetail = (entry, meta, staleness) => ({
+    name: entry.name,
+    repoPath: entry.path,
+    indexedAt: meta?.indexedAt ?? entry.indexedAt,
+    stats: meta?.stats ?? entry.stats ?? {},
+    lastCommit: meta?.lastCommit ?? entry.lastCommit,
+    branch: meta?.branch ?? entry.branch,
+    ...stalenessField(staleness),
+});
+/** The commit a `/api/repo` staleness check should be measured against. */
+export const resolveLastCommit = (entry, meta) => meta?.lastCommit ?? entry.lastCommit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.12-rc.17",
+  "version": "1.6.12-rc.19",
   "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",