@remnic/core 9.3.692 → 9.3.693

package/dist/{chunk-V56S3A23.js → chunk-MQTPUPLP.js}

@@ -23,13 +23,15 @@ import {
 import {
   clusterByKey,
   combineNamespaces,
+  defaultGitInvoker,
   expandScopeProfileReadNamespaces,
   lcmSessionKeyForNamespace,
   projectTagProjectId,
   resolveCodingNamespaceOverlay,
   resolveGitContext,
-  resolveScopeProfilePlan
-} from "./chunk-7MOTEVAA.js";
+  resolveScopeProfilePlan,
+  sanitizeFragment
+} from "./chunk-HRUULBBV.js";
 import {
   getTrustZoneStoreStatus,
   isTrustZoneName,
@@ -1137,12 +1139,12 @@ async function findArchitectureCardMemory(storage) {
   });
   return cards[0] ?? null;
 }
-function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDir, memoryDir, readFile3, writeVersion) {
+function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDir, memoryDir, readFile4, writeVersion) {
   return {
     async snapshotIfExists(memory) {
       if (!enabled) return;
       try {
-        const fullContent = await readFile3(memory.path);
+        const fullContent = await readFile4(memory.path);
         await writeVersion(
           memory.path,
           fullContent,
@@ -1158,10 +1160,251 @@ function createArchitectureVersioningHook(enabled, maxVersionsPerPage, sidecarDi
   };
 }
 
+// src/coding/session-delta.ts
+import { readFile as readFile2, writeFile, mkdir, rename } from "fs/promises";
+import path2 from "path";
+var MAX_DELTA_COMMITS = 20;
+var MAX_DELTA_FILES = 50;
+function computeSessionDelta(lastSeen, current) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nextState = { head: current.currentHead, at: now };
+  if (lastSeen === null) {
+    return { ok: true, kind: "first_run", nextState };
+  }
+  if (lastSeen.head === current.currentHead) {
+    return { ok: true, kind: "unchanged", nextState };
+  }
+  if (current.commits.length === 0) {
+    return {
+      ok: false,
+      code: "unreachable_head",
+      detail: `prior head ${lastSeen.head} is not an ancestor of current ${current.currentHead}`,
+      nextState
+    };
+  }
+  const commits = capCommits(current.commits, MAX_DELTA_COMMITS);
+  const touchedFiles = capFiles(current.touchedFiles, MAX_DELTA_FILES);
+  return {
+    ok: true,
+    kind: "changed",
+    delta: {
+      commits,
+      touchedFiles,
+      summaryLine: buildSummaryLine(commits.length, touchedFiles.length, lastSeen.at)
+    },
+    nextState
+  };
+}
+function capCommits(commits, max) {
+  if (!Number.isFinite(max) || max <= 0) return [];
+  if (commits.length <= max) return commits;
+  return commits.slice(-max);
+}
+function capFiles(files, max) {
+  if (!Number.isFinite(max) || max <= 0) return [];
+  if (files.length <= max) return files;
+  return files.slice(0, max);
+}
+function buildSummaryLine(commitCount, fileCount, sinceIso) {
+  const since = formatSinceDate(sinceIso);
+  const commitWord = commitCount === 1 ? "commit" : "commits";
+  const fileWord = fileCount === 1 ? "file" : "files";
+  return `Since ${since}: ${commitCount} ${commitWord}, ${fileCount} ${fileWord} touched.`;
+}
+function formatSinceDate(iso) {
+  const match = /^(\d{4}-\d{2}-\d{2})/.exec(iso);
+  return match ? match[1] : iso;
+}
+var CODING_KNOWLEDGE_STATE_DIR = path2.join("state", "coding-knowledge");
+function sessionDeltaStatePath(memoryDir, namespace) {
+  const safe = sanitizeFragment(namespace) || "default";
+  return path2.join(memoryDir, CODING_KNOWLEDGE_STATE_DIR, `${safe}.json`);
+}
+async function readLastSeenState(statePath) {
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const obj = parsed;
+    const head = typeof obj.head === "string" ? obj.head : null;
+    const at = typeof obj.at === "string" ? obj.at : null;
+    if (!head || !at) return null;
+    return { head, at };
+  } catch {
+    return null;
+  }
+}
+async function writeLastSeenState(statePath, state) {
+  if (!state.head || !state.at) {
+    throw new Error(
+      `writeLastSeenState: invalid state (head=${JSON.stringify(state.head)}, at=${JSON.stringify(state.at)})`
+    );
+  }
+  const dir = path2.dirname(statePath);
+  await mkdir(dir, { recursive: true });
+  const tmp = `${statePath}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile(tmp, JSON.stringify(state, null, 2), "utf8");
+  await rename(tmp, statePath);
+}
+function resolveSlice(repoRoot, sinceHead, invoker) {
+  const headResult = invoker(repoRoot, ["rev-parse", "HEAD"]);
+  if (headResult.exitCode !== 0) {
+    return {
+      ok: false,
+      code: headResult.stdout.trim().length === 0 ? "no_head" : "git_failed",
+      detail: `rev-parse HEAD exited ${headResult.exitCode}`
+    };
+  }
+  const currentHead = headResult.stdout.trim();
+  if (!currentHead) {
+    return { ok: false, code: "no_head", detail: "rev-parse HEAD returned empty" };
+  }
+  if (!sinceHead) {
+    return { ok: true, slice: { commits: [], touchedFiles: [], currentHead } };
+  }
+  if (sinceHead === currentHead) {
+    return { ok: true, slice: { commits: [], touchedFiles: [], currentHead } };
+  }
+  const SEP = "";
+  const logResult = invoker(repoRoot, [
+    "log",
+    "--reverse",
+    `--pretty=format:%H${SEP}%s`,
+    "--name-only",
+    `${sinceHead}..${currentHead}`
+  ]);
+  if (logResult.exitCode !== 0) {
+    if (logResult.exitCode === 128) {
+      return { ok: true, slice: { commits: [], touchedFiles: [], currentHead } };
+    }
+    return {
+      ok: false,
+      code: "git_failed",
+      detail: "git log exited " + logResult.exitCode + " (transient \u2014 state marker preserved)"
+    };
+  }
+  const { commits, touchedFiles } = parseLogOutput(logResult.stdout, SEP);
+  return { ok: true, slice: { commits, touchedFiles, currentHead } };
+}
+function parseLogOutput(stdout, sep2) {
+  const commits = [];
+  const fileSet = /* @__PURE__ */ new Set();
+  const blocks = stdout.split(/\n\s*\n/);
+  for (const block of blocks) {
+    const lines = block.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+    if (lines.length === 0) continue;
+    const header = lines[0];
+    const sepIdx = header.indexOf(sep2);
+    if (sepIdx >= 0) {
+      const sha = header.slice(0, sepIdx);
+      const subject = header.slice(sepIdx + sep2.length);
+      commits.push({ sha, subject });
+      for (let i = 1; i < lines.length; i += 1) {
+        if (lines[i]) fileSet.add(lines[i]);
+      }
+    } else {
+      for (const line of lines) fileSet.add(line);
+    }
+  }
+  const touchedFiles = [...fileSet].sort((a, b) => a.localeCompare(b));
+  return { commits, touchedFiles };
+}
+
+// src/coding/session-delta-surfaces.ts
+var DELTA_SUBCOMMANDS = ["get"];
+function isSessionDeltaSurfaceEnabled(config, codingContext) {
+  return config.enabled === true && config.sessionDelta === true && codingContext !== null && codingContext !== void 0;
+}
+async function handleCodingDelta(request, ctx) {
+  const codingContext = request.sessionKey ? ctx.getCodingContext(request.sessionKey) : null;
+  if (codingContext === null || !isSessionDeltaSurfaceEnabled(ctx.codingKnowledge, codingContext)) {
+    ctx.throwInputError(
+      "coding_delta requires codingKnowledge.enabled, codingKnowledge.sessionDelta, and an attached coding context"
+    );
+  }
+  switch (request.subcommand) {
+    case "get":
+      return deltaGet(request, ctx, codingContext);
+  }
+}
+async function deltaGet(request, ctx, codingContext) {
+  const storage = await ctx.resolveStorage(request);
+  const statePath = sessionDeltaStatePath(storage.memoryDir, storage.namespace);
+  const lastSeen = await readLastSeenState(statePath);
+  const repoRoot = codingContext.rootPath ?? codingContext.projectId;
+  const sliceResult = resolveSlice(
+    repoRoot,
+    lastSeen?.head ?? null,
+    ctx.gitInvoker
+  );
+  if (!sliceResult.ok) {
+    log.warn(
+      `coding_delta/get: slice resolution failed (code=${sliceResult.code}): ${sliceResult.detail}`
+    );
+    return {
+      subcommand: "get",
+      ok: false,
+      code: "git_failed",
+      detail: sliceResult.detail
+    };
+  }
+  const result = computeSessionDelta(lastSeen, sliceResult.slice);
+  let nextState = null;
+  if (result.ok) {
+    nextState = result.nextState;
+  } else if (result.code === "unreachable_head") {
+    nextState = result.nextState;
+  }
+  if (nextState) {
+    try {
+      await writeLastSeenState(statePath, nextState);
+    } catch (err) {
+      log.warn(
+        `coding_delta/get: state write failed for ${statePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (!result.ok) {
+    if (result.code === "unreachable_head") {
+      return {
+        subcommand: "get",
+        ok: false,
+        code: result.code,
+        detail: result.detail,
+        nextState: result.nextState
+      };
+    }
+    return {
+      subcommand: "get",
+      ok: false,
+      code: result.code,
+      detail: result.detail
+    };
+  }
+  switch (result.kind) {
+    case "first_run":
+      return { subcommand: "get", ok: true, kind: "first_run", nextState: result.nextState };
+    case "unchanged":
+      return { subcommand: "get", ok: true, kind: "unchanged", nextState: result.nextState };
+    case "changed":
+      return {
+        subcommand: "get",
+        ok: true,
+        kind: "changed",
+        delta: {
+          commits: result.delta.commits,
+          touchedFiles: result.delta.touchedFiles,
+          summaryLine: result.delta.summaryLine
+        },
+        nextState: result.nextState
+      };
+  }
+}
+
 // src/procedural/procedure-miner.ts
 import { createHash } from "crypto";
-import { mkdir, rm, stat } from "fs/promises";
-import path2 from "path";
+import { mkdir as mkdir2, rm, stat } from "fs/promises";
+import path3 from "path";
 var PROCEDURE_CLUSTER_ATTR_MAX = 500;
 var PROCEDURE_CLUSTER_LOCK_STALE_MS = 12e4;
 var PROCEDURE_CLUSTER_LOCK_TIMEOUT_MS = 3e4;
@@ -1181,14 +1424,14 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function acquireClusterWriteLock(memoryDir, clusterHash) {
-  const lockRoot = path2.join(path2.resolve(memoryDir), "state", "procedure-miner-locks");
-  const lockDir = path2.join(lockRoot, `${clusterHash}.lock`);
-  await mkdir(lockRoot, { recursive: true });
+  const lockRoot = path3.join(path3.resolve(memoryDir), "state", "procedure-miner-locks");
+  const lockDir = path3.join(lockRoot, `${clusterHash}.lock`);
+  await mkdir2(lockRoot, { recursive: true });
   const startedAt = Date.now();
   let attempts = 0;
   while (true) {
     try {
-      await mkdir(lockDir);
+      await mkdir2(lockDir);
       return async () => {
         await rm(lockDir, { recursive: true, force: true });
       };
@@ -1213,7 +1456,7 @@ async function acquireClusterWriteLock(memoryDir, clusterHash) {
   }
 }
 async function withClusterWriteLock(memoryDir, clusterHash, fn) {
-  const inProcessKey = `${path2.resolve(memoryDir)}:${clusterHash}`;
+  const inProcessKey = `${path3.resolve(memoryDir)}:${clusterHash}`;
   const previous = inProcessClusterWriteLocks.get(inProcessKey) ?? Promise.resolve();
   let releaseInProcess;
   const current = previous.catch(() => void 0).then(
@@ -3849,6 +4092,42 @@ var EngramAccessService = class {
       }
     });
   }
+  /** Whether the coding_delta tool should appear in tools/list (rule 39). */
+  get sessionDeltaSurfaceVisible() {
+    return this.orchestrator.config.codingKnowledge?.enabled === true && this.orchestrator.config.codingKnowledge?.sessionDelta === true;
+  }
+  /**
+   * Thin delegate — handler logic in coding/session-delta-surfaces.ts (#1548 PR4).
+   * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+   * Namespace resolution uses the SAME coding-scoped read path as the other
+   * coding surfaces; the delta state file lives under
+   * `<memoryDir>/state/coding-knowledge/<namespace>.json`.
+   */
+  async codingDelta(request, authenticatedPrincipal) {
+    return handleCodingDelta(request, {
+      codingKnowledge: this.orchestrator.config.codingKnowledge,
+      getCodingContext: (sk) => this.orchestrator.getCodingContextForSession(sk),
+      resolveStorage: async (req) => {
+        const ns = await this.resolveCodingScopedReadableNamespace({
+          namespace: req.namespace,
+          sessionKey: req.sessionKey,
+          authenticatedPrincipal
+        });
+        const storage = await this.orchestrator.getStorage(ns);
+        return {
+          memoryDir: storage.dir,
+          namespace: ns
+        };
+      },
+      gitInvoker: (cwd, args) => {
+        const invoker = defaultGitInvoker();
+        return invoker(cwd, args);
+      },
+      throwInputError: (msg) => {
+        throw new EngramAccessInputError(msg);
+      }
+    });
+  }
   async memoryBrowse(request = {}) {
     const resolvedNamespace = this.resolveReadableNamespace(
       request.namespace,
@@ -5911,7 +6190,7 @@ ${next}`);
     const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
-    const { writeFile, mkdir: mkdir2 } = await import("fs/promises");
+    const { writeFile: writeFile2, mkdir: mkdir3 } = await import("fs/promises");
     const { join: join2, resolve: resolve2 } = await import("path");
     const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
     if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
@@ -5920,10 +6199,10 @@ ${next}`);
     if (!resolved.startsWith(resolve2(storageDir))) {
       throw new EngramAccessInputError("Invalid sessionKey");
     }
-    await mkdir2(checkpointDir, { recursive: true });
+    await mkdir3(checkpointDir, { recursive: true });
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = join2(checkpointDir, `checkpoint-${ts}.md`);
-    await writeFile(filePath, request.context, "utf-8");
+    await writeFile2(filePath, request.context, "utf-8");
     return { saved: true };
   }
   async lcmStatus() {
@@ -6653,6 +6932,7 @@ ${next}`);
 
 export {
   DECISION_SUBCOMMANDS,
+  DELTA_SUBCOMMANDS,
   computeProcedureStats,
   formatProcedureStatsText,
   EngramAccessInputError,
@@ -6660,4 +6940,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-V56S3A23.js.map
+//# sourceMappingURL=chunk-MQTPUPLP.js.map