@kage-core/kage-graph-mcp 1.1.14 → 1.1.15

package/README.md

@@ -9,6 +9,20 @@ This package exposes two surfaces:
 
 ## Latest Release
 
+`1.1.15` hardens the npm release path and memory-only review flow:
+
+- `npm run release:npm:dry-run` runs the guarded release checks without
+  publishing.
+- `npm run release:npm` builds the release helper, requires a clean worktree,
+  fetches the remote branch, verifies local `HEAD` contains `origin/<branch>`,
+  runs tests and `npm pack --dry-run`, pushes the branch before publishing,
+  publishes with `--access public`, verifies npm registry metadata, and performs
+  a smoke install.
+- all git steps run with `GIT_EDITOR=true` so agent sessions cannot get stuck in
+  an interactive commit or rebase editor.
+- `kage propose --from-diff` now includes repo memory packet-only changes from
+  `.agent_memory/packets/*.json` and `.agent_memory/pending/*.json`.
+
 `1.1.14` publishes the memory/code graph trust and retrieval pass:
 
 - recall now uses vectorless BM25 lexical ranking with graph, path/type/tag,
@@ -40,8 +54,20 @@ This package exposes two surfaces:
 ```bash
 npm install
 npm run build
+npm run release:npm:dry-run
+```
+
+Publishing from the repo should use the guarded release script after the release
+commit is ready:
+
+```bash
+npm run release:npm
 ```
 
+The script fetches the current branch and blocks if the remote branch is not an
+ancestor of local `HEAD`, which prevents publishing an npm version from a branch
+that cannot be pushed cleanly.
+
 ## CLI
 
 ```bash

package/dist/kernel.js

@@ -911,7 +911,12 @@ const NOISE_PATH_PREFIXES = [
     ".pub-cache/",
     "elm-stuff/",
 ];
+function isReviewableMemoryPath(filePath) {
+    return /^\.agent_memory\/(?:packets|pending)\/[^/]+\.json$/.test(filePath);
+}
 function isNoisePath(filePath) {
+    if (isReviewableMemoryPath(filePath))
+        return false;
     return NOISE_PATH_PREFIXES.some((prefix) => filePath.startsWith(prefix));
 }
 function parsePorcelainStatus(status) {
@@ -926,7 +931,26 @@ function parsePorcelainPath(line) {
     const raw = line.length > 2 && line[2] === " " ? line.slice(3) : line.slice(2);
     return raw.trim();
 }
+function branchDiffStat(projectDir, changedFiles) {
+    const diffStats = [
+        readGit(projectDir, ["diff", "--stat"]),
+        readGit(projectDir, ["diff", "--cached", "--stat"]),
+    ].filter(Boolean).join("\n").trim();
+    const untracked = new Set((readGit(projectDir, ["ls-files", "--others", "--exclude-standard"]) ?? "")
+        .split(/\r?\n/)
+        .map((path) => path.trim())
+        .filter(Boolean)
+        .filter((path) => changedFiles.includes(path)));
+    const untrackedStats = [...untracked]
+        .filter((file) => !diffStats.includes(file))
+        .map((file) => `${file} | untracked`)
+        .join("\n");
+    return [diffStats, untrackedStats].filter(Boolean).join("\n").trim()
+        || changedFiles.map((file) => `${file} | changed`).join("\n");
+}
 function shouldSkipRepoMemoryPath(relativePath) {
+    if (isReviewableMemoryPath(relativePath))
+        return false;
     return isNoisePath(relativePath) || shouldSkipCodePath(relativePath);
 }
 function migrateLegacyMarkdown(projectDir) {
@@ -4822,7 +4846,7 @@ function proposeFromDiff(projectDir) {
     const changedFiles = parsePorcelainStatus(status);
     if (changedFiles.length === 0)
         return { ok: false, changedFiles: [], errors: ["No changed files found."] };
-    const stat = readGit(projectDir, ["diff", "--stat"]) || "Untracked or staged files changed; inspect git status for details.";
+    const stat = branchDiffStat(projectDir, changedFiles);
     const branch = gitBranch(projectDir);
     const summary = {
         schema_version: 1,

package/dist/release.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReleaseArgs = parseReleaseArgs;
+exports.buildNpmReleasePlan = buildNpmReleasePlan;
+exports.runNpmRelease = runNpmRelease;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const DEFAULT_CACHE = "/private/tmp/kage-npm-cache";
+function parseReleaseArgs(argv) {
+    const options = {
+        publish: false,
+        push: false,
+        smoke: false,
+        cache: DEFAULT_CACHE,
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--publish")
+            options.publish = true;
+        else if (arg === "--dry-run")
+            options.publish = false;
+        else if (arg === "--push")
+            options.push = true;
+        else if (arg === "--smoke")
+            options.smoke = true;
+        else if (arg === "--cache") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("--cache requires a path");
+            options.cache = value;
+            index += 1;
+        }
+        else {
+            throw new Error(`Unknown release option: ${arg}`);
+        }
+    }
+    return options;
+}
+function buildNpmReleasePlan(context) {
+    const gitEnv = { GIT_EDITOR: "true" };
+    const steps = [
+        { name: "ensure clean worktree", command: "git", args: ["status", "--porcelain", "-uall"], env: gitEnv, expectEmptyStdout: true },
+        { name: "fetch remote branch", command: "git", args: ["fetch", "origin", context.branch], env: gitEnv },
+        { name: "ensure branch contains remote", command: "git", args: ["merge-base", "--is-ancestor", `origin/${context.branch}`, "HEAD"], env: gitEnv },
+        { name: "run package tests", command: "npm", args: ["test"] },
+        { name: "pack dry run", command: "npm", args: ["--cache", context.cache, "pack", "--dry-run"] },
+    ];
+    if (context.push) {
+        steps.push({ name: "push branch", command: "git", args: ["push", "origin", context.branch], env: gitEnv });
+    }
+    if (context.publish) {
+        steps.push({ name: "publish package", command: "npm", args: ["--cache", context.cache, "publish", "--access", "public"] }, { name: "verify npm version", command: "npm", args: ["view", `${context.packageName}@${context.version}`, "version"] });
+        if (context.smoke) {
+            steps.push({
+                name: "smoke install published package",
+                command: "npm",
+                args: ["--cache", context.cache, "install", "--prefix", smokeInstallDir(context.version), `${context.packageName}@${context.version}`],
+            });
+        }
+    }
+    return steps;
+}
+function smokeInstallDir(version) {
+    return (0, node_path_1.join)((0, node_os_1.tmpdir)(), `kage-npm-smoke-${version}`);
+}
+function stdout(command, args, cwd) {
+    return (0, node_child_process_1.execFileSync)(command, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function packageMetadata(packageDir) {
+    const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(packageDir, "package.json"), "utf8"));
+    if (typeof pkg.name !== "string" || typeof pkg.version !== "string") {
+        throw new Error("package.json must contain string name and version");
+    }
+    return { name: pkg.name, version: pkg.version };
+}
+function runStep(step, cwd) {
+    console.log(`release:npm: ${step.name}`);
+    if (step.expectEmptyStdout) {
+        const output = (0, node_child_process_1.execFileSync)(step.command, step.args, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "inherit"],
+            env: { ...process.env, ...step.env },
+        }).trim();
+        if (output)
+            throw new Error(`release:npm: ${step.name} failed because output was not empty:\n${output}`);
+        return;
+    }
+    (0, node_child_process_1.execFileSync)(step.command, step.args, {
+        cwd,
+        stdio: "inherit",
+        env: { ...process.env, ...step.env },
+    });
+}
+function runNpmRelease(argv = process.argv.slice(2), packageDir = process.cwd()) {
+    const options = parseReleaseArgs(argv);
+    const repoRoot = stdout("git", ["rev-parse", "--show-toplevel"], packageDir);
+    const branch = stdout("git", ["branch", "--show-current"], repoRoot);
+    if (!branch)
+        throw new Error("npm release requires a named git branch");
+    (0, node_fs_1.mkdirSync)(options.cache, { recursive: true });
+    if (options.smoke)
+        (0, node_fs_1.mkdirSync)(smokeInstallDir(packageMetadata(packageDir).version), { recursive: true });
+    const metadata = packageMetadata(packageDir);
+    const plan = buildNpmReleasePlan({ ...options, branch, packageName: metadata.name, version: metadata.version });
+    console.log(`release:npm: package ${metadata.name}@${metadata.version}`);
+    console.log(`release:npm: mode ${options.publish ? "publish" : "dry-run"}`);
+    for (const step of plan)
+        runStep(step, repoRoot === (0, node_path_1.resolve)(packageDir, "..") ? packageDir : repoRoot);
+}
+if (process.argv[1] && process.argv[1].endsWith("release.js")) {
+    try {
+        runNpmRelease();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(2);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kage-core/kage-graph-mcp",
-  "version": "1.1.14",
+  "version": "1.1.15",
   "description": "Local-first repo memory, code graph, and recall MCP server for coding agents",
   "main": "dist/index.js",
   "files": [
@@ -21,7 +21,9 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "ts-node index.ts",
-    "test": "npm run build && node --test dist/**/*.test.js"
+    "test": "npm run build && node --test dist/**/*.test.js",
+    "release:npm:dry-run": "npm run build && node dist/release.js --dry-run",
+    "release:npm": "npm run build && node dist/release.js --publish --push --smoke"
   },
   "keywords": [
     "mcp",