kibi-mcp 0.14.0 → 0.14.1

package/bin/kibi-mcp

@@ -18,6 +18,59 @@
 */
 const args = globalThis.Bun?.argv?.slice(2) ?? process.argv.slice(2);
 
+async function importStartupResolution() {
+  try {
+    return await import("../dist/startup-resolution.js");
+  } catch {
+    return await import("../src/startup-resolution.ts");
+  }
+}
+
+async function serverEntrypointUrl() {
+  const { existsSync } = await import("node:fs");
+  const distUrl = new URL("../dist/server.js", import.meta.url);
+  if (existsSync(distUrl)) {
+    return distUrl.href;
+  }
+  return new URL("../src/server.ts", import.meta.url).href;
+}
+
+async function buildResolution() {
+  const {
+    compareMcpResolution,
+    formatResolutionJson,
+    readRunningPackageInfo,
+    resolveProjectLocalMcp,
+  } = await importStartupResolution();
+  const running = readRunningPackageInfo(await serverEntrypointUrl());
+  const projectLocal = resolveProjectLocalMcp(process.cwd());
+  const comparison = compareMcpResolution(running, projectLocal);
+  const result = {
+    packageName: "kibi-mcp",
+    packageVersion: running.version,
+    version: running.version,
+    resolved: running.entrypoint,
+    cwd: process.cwd(),
+    running,
+    projectLocal,
+    ...comparison,
+  };
+
+  return { result, json: formatResolutionJson(result) };
+}
+
+async function importServer(entrypoint) {
+  if (entrypoint) {
+    const { pathToFileURL } = await import("node:url");
+    return await import(pathToFileURL(entrypoint).href);
+  }
+  try {
+    return await import("../dist/server.js");
+  } catch {
+    return await import("../src/server.ts");
+  }
+}
+
 function printHelp() {
   process.stdout.write(`Usage: kibi-mcp [options]
 
@@ -25,6 +78,7 @@ Starts the Kibi MCP server over stdio.
 
 Options:
   --diagnostic-mode  enable diagnostic logging to .kb/usage.log
+  --print-resolution print kibi-mcp startup resolution JSON and exit
   -h, --help         show help
 `);
 }
@@ -33,6 +87,11 @@ if (args.includes("-h") || args.includes("--help")) {
   printHelp();
   process.exitCode = 0;
 } else {
+  if (args.includes("--print-resolution")) {
+    const { json } = await buildResolution();
+    process.stdout.write(json);
+    process.exitCode = 0;
+  } else {
   if (args.includes("--diagnostic-mode") && !process.argv.includes("--diagnostic-mode")) {
     process.argv.push("--diagnostic-mode");
   }
@@ -43,7 +102,31 @@ if (args.includes("-h") || args.includes("--help")) {
     process.env.KIBI_MCP_DIAGNOSTIC_MODE = "1";
   }
 
-  const { startServer } = await import("../dist/server.js");
+  const { result, json } = await buildResolution();
+  if (process.env.KIBI_MCP_DEBUG === "1" || args.includes("--diagnostic-mode")) {
+    process.stderr.write(json);
+  }
+
+  if (result.stale) {
+    if (result.projectLocal && process.env.KIBI_MCP_PROJECT_LOCAL_REENTRY !== "1") {
+      process.env.KIBI_MCP_PROJECT_LOCAL_REENTRY = "1";
+      process.stderr.write(
+        `[KIBI-MCP] Re-entering project-local kibi-mcp at ${result.projectLocal.entrypoint}; stale running path was ${result.running.entrypoint}\n`,
+      );
+      const { startServer } = await importServer(result.projectLocal.entrypoint);
+      startServer().catch((error) => {
+        console.error("Fatal error:", error);
+        process.exit(1);
+      });
+    } else {
+      const localEntrypoint = result.projectLocal?.entrypoint ?? "<not resolved>";
+      console.error(
+        `[KIBI-MCP] Refusing stale kibi-mcp startup. project-local entrypoint: ${localEntrypoint}; running entrypoint: ${result.running.entrypoint}`,
+      );
+      process.exit(1);
+    }
+  } else {
+  const { startServer } = await importServer();
 
   if (process.env.KIBI_MCP_DEBUG) {
   const originalStdoutWrite = process.stdout.write.bind(process.stdout);
@@ -84,4 +167,6 @@ if (args.includes("-h") || args.includes("--help")) {
     console.error("Fatal error:", error);
     process.exit(1);
   });
+  }
+  }
 }

package/dist/startup-resolution.js

@@ -0,0 +1,110 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const PACKAGE_NAME = "kibi-mcp";
+const FORBIDDEN_VERSION = "0.13.0";
+function toEntrypointPath(entrypointUrl) {
+    if (entrypointUrl.startsWith("file:")) {
+        return fileURLToPath(entrypointUrl);
+    }
+    return path.resolve(entrypointUrl);
+}
+function readJson(filePath) {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function nearestPackageJson(startPath) {
+    let current = path.dirname(startPath);
+    while (true) {
+        const candidate = path.join(current, "package.json");
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error(`Unable to find package.json for ${startPath}`);
+        }
+        current = parent;
+    }
+}
+function packageInfoFromEntrypoint(entrypoint) {
+    const normalizedEntrypoint = path.resolve(entrypoint);
+    const packageJsonPath = nearestPackageJson(normalizedEntrypoint);
+    const packageJson = readJson(packageJsonPath);
+    if (packageJson.name && packageJson.name !== PACKAGE_NAME) {
+        throw new Error(`Resolved package ${packageJson.name} for ${normalizedEntrypoint}; expected ${PACKAGE_NAME}`);
+    }
+    return {
+        packageRoot: path.dirname(packageJsonPath),
+        version: packageJson.version ?? "unknown",
+        entrypoint: normalizedEntrypoint,
+    };
+}
+export function readRunningPackageInfo(entrypointUrl) {
+    return packageInfoFromEntrypoint(toEntrypointPath(entrypointUrl));
+}
+export function resolveProjectLocalMcp(cwd) {
+    try {
+        const projectRequire = createRequire(path.join(path.resolve(cwd), "package.json"));
+        const resolved = projectRequire.resolve(PACKAGE_NAME);
+        const entrypoint = realpathSync.native?.(resolved) ?? realpathSync(resolved);
+        return packageInfoFromEntrypoint(entrypoint);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+            return null;
+        }
+        return null;
+    }
+}
+export function compareMcpResolution(running, projectLocal) {
+    const diagnosticText = JSON.stringify({ running, projectLocal });
+    const forbiddenVersionObserved = diagnosticText.includes(FORBIDDEN_VERSION);
+    if (!projectLocal) {
+        return {
+            stale: false,
+            reason: "no project-local kibi-mcp resolved",
+            forbiddenVersionObserved,
+        };
+    }
+    if (running.version !== projectLocal.version) {
+        return {
+            stale: true,
+            reason: `version mismatch: running ${running.version}, project-local ${projectLocal.version}`,
+            forbiddenVersionObserved,
+        };
+    }
+    if (path.resolve(running.packageRoot) !== path.resolve(projectLocal.packageRoot)) {
+        return {
+            stale: true,
+            reason: `package root mismatch: running ${running.packageRoot}, project-local ${projectLocal.packageRoot}`,
+            forbiddenVersionObserved,
+        };
+    }
+    return {
+        stale: false,
+        reason: "running kibi-mcp matches project-local kibi-mcp",
+        forbiddenVersionObserved,
+    };
+}
+export function formatResolutionJson(result) {
+    return `${JSON.stringify(result, null, 2)}\n`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-mcp",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ajv": "^8.18.0",