knodin 0.7.3 → 0.7.5

package/dist/src/server.js

@@ -14,6 +14,49 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprot
 import { recordDiagnosticFailure } from "./diagnostics.js";
 import { getKnodinTools, handleKnodinTool } from "./tools/knodin-tools.js";
 import { KNODIN_VERSION } from "./version.js";
+const RETRY_SAFE_OPERATIONS = new Set([
+    "architecture_overview",
+    "context",
+    "docs",
+    "explain",
+    "map",
+    "query",
+    "review",
+    "search",
+    "status",
+]);
+class GatewayRequestQueue {
+    tail = Promise.resolve();
+    pending = 0;
+    async run(signal, task) {
+        const position = this.pending++;
+        const predecessor = this.tail;
+        let release;
+        this.tail = new Promise((resolve) => {
+            release = resolve;
+        });
+        try {
+            await predecessor;
+            if (signal.aborted)
+                throw Object.assign(new Error("MCP request cancelled before dispatch"), {
+                    code: "KNODIN_REQUEST_CANCELLED",
+                });
+            return await task(position);
+        }
+        finally {
+            this.pending--;
+            release();
+        }
+    }
+}
+function ignoreNotificationFailure() {
+    // Progress is advisory; a client that stops accepting it must not fail the tool call.
+}
+function startHeartbeat(notify, operation, startedAt) {
+    return setInterval(() => {
+        void notify(`${operation} still running (${Math.round((Date.now() - startedAt) / 1000)}s)`).catch(ignoreNotificationFailure);
+    }, 10_000);
+}
 export function recordMcpDiagnosticFailure(args, error, defaultRepo = process.cwd()) {
     const effectiveRepo = typeof args?.repoPath === "string" ? args.repoPath : defaultRepo;
     const diagnostic = recordDiagnosticFailure(effectiveRepo, {
@@ -26,7 +69,8 @@ export function recordMcpDiagnosticFailure(args, error, defaultRepo = process.cw
         ? new Error(`${error instanceof Error ? error.message : String(error)} [diagnostic ${diagnostic.correlationId}]`, { cause: error })
         : error;
 }
-export function createServer() {
+export function createServer(dispatch = handleKnodinTool) {
+    const queue = new GatewayRequestQueue();
     const server = new Server({ name: "knodin", version: KNODIN_VERSION }, {
         capabilities: { tools: {} },
         instructions: "Use knodin first for cold or unfamiliar codebase work: context to orient, explain for source-evidenced symbol context, query impact before meaningful edits, and review before handoff. Prefer direct reads for exact literals, non-code files, or files just edited this turn. If status reports repair-needed, follow its typed repair steps: repair graph damage or init displaced lifecycle routing before relying on graph evidence.",
@@ -34,22 +78,77 @@ export function createServer() {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: getKnodinTools(),
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
         if (name !== "knodin") {
             throw new Error(`unknown tool: ${name}`);
         }
-        let result;
+        const values = args;
+        const operation = typeof values?.operation === "string" ? values.operation : "unknown";
+        const progressToken = extra._meta?.progressToken;
+        const requestId = String(extra.requestId);
+        const startedAt = Date.now();
+        let heartbeat;
         try {
-            result = await handleKnodinTool(args);
+            const result = await queue.run(extra.signal, async (position) => {
+                const notify = async (message) => {
+                    if (progressToken === undefined)
+                        return;
+                    await extra.sendNotification({
+                        method: "notifications/progress",
+                        params: {
+                            progressToken,
+                            progress: Date.now() - startedAt,
+                            message,
+                        },
+                    });
+                };
+                await notify(position > 0
+                    ? `Starting ${operation} after waiting behind ${position} earlier request(s)`
+                    : `Starting ${operation}`);
+                heartbeat = startHeartbeat(notify, operation, startedAt);
+                // Keep the production handler explicit: knodin's own source-evidence
+                // extractor maps this low-level MCP registration to its dispatcher.
+                return dispatch === handleKnodinTool ? await handleKnodinTool(args) : await dispatch(args);
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
         }
         catch (error) {
-            const values = args;
-            throw recordMcpDiagnosticFailure(values, error);
+            const recorded = recordMcpDiagnosticFailure(values, error);
+            const message = recorded instanceof Error ? recorded.message : String(recorded);
+            const traceId = /\[diagnostic ([a-f0-9]{16})\]/.exec(message)?.[1] ?? `mcp-${requestId}`;
+            const retrySafe = RETRY_SAFE_OPERATIONS.has(operation);
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            code: error?.code === "KNODIN_REQUEST_CANCELLED"
+                                ? "KNODIN_REQUEST_CANCELLED"
+                                : "KNODIN_OPERATION_FAILED",
+                            message,
+                            traceId,
+                            requestId,
+                            operation,
+                            repository: typeof values?.repoPath === "string" ? values.repoPath : process.cwd(),
+                            phase: "dispatch",
+                            retrySafe,
+                            diagnosticLog: ".knodin/diagnostics/events.jsonl (only when opt-in diagnostics are enabled)",
+                            recovery: retrySafe
+                                ? "Retry once. If the transport closes, restart the MCP client and run `knodin doctor`; include `knodin diagnostics export` when diagnostics are enabled."
+                                : "Do not retry automatically. Run `knodin doctor`, inspect repository state, and include `knodin diagnostics export` when diagnostics are enabled.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
         }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
     });
     return server;
 }

package/dist/src/structural-fast-path.js

@@ -54,6 +54,43 @@ function lexicalEndLine(lines, startIndex, python) {
     }
     return startIndex + 1;
 }
+function genericFunctionSymbol(line) {
+    const opening = line.indexOf("(");
+    if (opening <= 0)
+        return null;
+    let depth = 0;
+    let closing = -1;
+    for (let index = opening; index < line.length; index += 1) {
+        if (line[index] === "(")
+            depth += 1;
+        if (line[index] !== ")")
+            continue;
+        depth -= 1;
+        if (depth === 0) {
+            closing = index;
+            break;
+        }
+    }
+    if (closing < 0)
+        return null;
+    const suffix = line.slice(closing + 1).trimStart();
+    if (!suffix.startsWith("{") && !suffix.startsWith("=>"))
+        return null;
+    const prefix = line.slice(0, opening).trim();
+    if (/[=;{}()]/.test(prefix))
+        return null;
+    const tokens = prefix.split(/\s+/);
+    const symbol = tokens.at(-1) ?? "";
+    return tokens.length >= 2 && /^[A-Za-z_$][\w$]*$/.test(symbol) ? symbol : null;
+}
+function firstPatternSymbol(line, patterns) {
+    for (const { kind, expression } of patterns) {
+        const match = expression.exec(line);
+        if (match)
+            return { kind, symbol: match[1] };
+    }
+    return null;
+}
 function directSymbols(filePath, content) {
     const extension = path.extname(filePath).toLowerCase();
     const python = extension === ".py";
@@ -73,21 +110,20 @@ function directSymbols(filePath, content) {
                 kind: "function",
                 expression: /^\s*(?:(?:export|public|private|protected|internal|async|static|final|pub(?:\([^)]*\))?)\s+)*(?:func|fn|function)\s+([A-Za-z_$][\w$]*)\s*\(/,
             },
-            {
-                kind: "function",
-                expression: /^\s*(?:(?:export|public|private|protected|internal|async|static|final)\s+)*(?:[A-Za-z_$][\w$<>,.?[\]\s:*&]+\s+)+([A-Za-z_$][\w$]*)\s*\([^;]*\)\s*(?:\{|=>)/,
-            },
             {
                 kind: "function",
                 expression: /^\s*(?:(?:export|const|let|var|public|private|protected|static|readonly)\s+)*([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/,
             },
         ];
     for (const [index, line] of lines.entries()) {
-        for (const { kind, expression } of patterns) {
-            const match = expression.exec(line);
-            if (!match)
-                continue;
-            const symbol = match[1];
+        let found = firstPatternSymbol(line, patterns);
+        if (!found && !python) {
+            const symbol = genericFunctionSymbol(line);
+            if (symbol)
+                found = { kind: "function", symbol };
+        }
+        if (found) {
+            const { kind, symbol } = found;
             const visibility = line.match(/\b(public|private|protected|internal)\b/)?.[1] ??
                 (python && symbol.startsWith("_") ? "private" : "default");
             symbols.push({
@@ -104,7 +140,6 @@ function directSymbols(filePath, content) {
                 exported: /\bexport\b/.test(line) || /\bpub\b/.test(line),
                 evidenceQuality: "lexical-structural-fallback",
             });
-            break;
         }
     }
     return symbols;

package/docs/releases/0.7.4.md

@@ -0,0 +1,17 @@
+# knodin 0.7.4
+
+This patch release preserves the opt-in diagnostics and support-bundle workflow
+introduced in 0.7.3 while hardening the structural cold-start parser.
+
+- Replaces a potentially super-linear declaration-matching expression with a
+  bounded, linear parser for typed function declarations.
+- Handles balanced parameter lists without mistaking calls or control-flow
+  statements for declarations.
+- Adds regression coverage for typed declarations, nested calls, and negative
+  structural matches.
+
+Diagnostics remain local and disabled until a user enables them. Knodin never
+uploads a diagnostics bundle automatically; the user must inspect and
+deliberately share it for troubleshooting.
+
+This remains an ordinary 0.x release, not a dogfood-only build and not GA.

package/docs/releases/0.7.5.md

@@ -0,0 +1,20 @@
+# knodin 0.7.5
+
+This patch release makes the one-tool MCP gateway more resilient and corrects
+the immutable-package handoff used by internal Artifactory publication.
+
+- Serializes parallel gateway operations so expensive graph requests do not
+  compete for the same local engine and database resources.
+- Emits MCP progress notifications for queued and long-running operations when
+  the client supplies a progress token.
+- Returns stable, actionable tool-error details while keeping the MCP transport
+  available for subsequent requests.
+- On release retries, downloads npm's immutable archive, verifies its registry
+  integrity, proves its unpacked content matches the release build, and uses
+  those exact bytes for attestations and downstream publication.
+
+Diagnostics remain local and disabled until a user enables them. Knodin never
+uploads a diagnostics bundle automatically; the user must inspect and
+deliberately share it for troubleshooting.
+
+This remains an ordinary 0.x release, not a dogfood-only build and not GA.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "knodin",
-	"version": "0.7.3",
+	"version": "0.7.5",
 	"description": "knodin — source-evidenced local code intelligence with known bounds. Stable identity, fresh evidence, truthful budgets, and recoverable bounded views.",
 	"license": "MIT",
 	"repository": {
@@ -49,6 +49,8 @@
 		"docs/releases/0.7.1.md",
 		"docs/releases/0.7.2.md",
 		"docs/releases/0.7.3.md",
+		"docs/releases/0.7.4.md",
+		"docs/releases/0.7.5.md",
 		"docs/assets/knodin-favicon.svg",
 		"docs/SYSTEMS-AND-RELATIONSHIPS.md",
 		"docs/TELEMETRY.md",