@meetless/mla 0.1.4

package/dist/lib/governance-cache.js

@@ -0,0 +1,77 @@
+"use strict";
+// A-0c (A4 surface 2): the pending-count hand-off the `mla kb pending` command
+// writes for the user-prompt-submit hook to read.
+//
+// The hook nudges the coding agent when relationship candidates are pending review,
+// but Patch 8 forbids it from adding a synchronous hot-path network call to learn
+// the count. So the count travels OUT OF BAND: `mla kb pending` already fetched the
+// queue (it knows the count for free), and drops it in a tiny local cache here; the
+// hook reads that cache with zero network. The tradeoff is proactivity: the cache
+// only refreshes when someone runs `mla kb pending`, which is accepted for v1.
+//
+// This path + shape MUST stay byte-identical to the bash reader (common.sh
+// governance_count_file): $MEETLESS_HOME/logs/governance/pending-count-<ws>.json,
+// workspace id sanitized with the SAME rule as `tr -c 'A-Za-z0-9_.-' '_'`, body
+// {count, ts} with ts in epoch SECONDS (bash compares against `date +%s`). The
+// governance-cache.spec pins this contract.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pendingCountCachePath = pendingCountCachePath;
+exports.writePendingCountCache = writePendingCountCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+// Mirror of bash `tr -c 'A-Za-z0-9_.-' '_'`: every char OUTSIDE the allowed set
+// becomes a single '_' (one-for-one, no collapsing), so the writer and reader
+// always resolve the identical filename for a given workspace id.
+function sanitizeWorkspaceId(workspaceId) {
+    return workspaceId.replace(/[^A-Za-z0-9_.-]/g, "_");
+}
+function pendingCountCachePath(workspaceId, home = config_1.HOME) {
+    return path.join(home, "logs", "governance", `pending-count-${sanitizeWorkspaceId(workspaceId)}.json`);
+}
+// Best-effort: a failure to write the cache must never break the `mla kb pending`
+// command itself (the human still got their listing). The worst case is the hook
+// keeps reading the previous count until the next successful write.
+function writePendingCountCache(workspaceId, count, home = config_1.HOME) {
+    try {
+        const file = pendingCountCachePath(workspaceId, home);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ count, ts: Math.floor(Date.now() / 1000) }));
+    }
+    catch {
+        /* non-fatal: the listing already succeeded; the nudge just reads a staler count */
+    }
+}

package/dist/lib/governed-path-cache.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.governedPathCacheKey = governedPathCacheKey;
+exports.writeGovernedPath = writeGovernedPath;
+exports.readGovernedPath = readGovernedPath;
+exports.governedPathEntryForReceipt = governedPathEntryForReceipt;
+// Owner+workspace+repo+path keyed cache mapping a governed path to its KB doc id,
+// with separate personal/shared namespaces. A bare-path key would cross owners and
+// repos once Personal KB exists; this never uses one. 3-day TTL. See spec test 33.
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const TTL_MS = 3 * 24 * 3600 * 1000;
+function governedPathCacheKey(k) {
+    return [k.namespace, k.workspaceId, k.ownerUserId, k.repoRootHash, k.canonicalPath].join("|");
+}
+function cacheFile(k, home) {
+    const dir = (0, path_1.join)(home, "logs", "governed-path", k.namespace);
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    const h = (0, crypto_1.createHash)("sha256").update(governedPathCacheKey(k)).digest("hex").slice(0, 24);
+    return (0, path_1.join)(dir, `${h}.json`);
+}
+function writeGovernedPath(k, docId, home) {
+    (0, fs_1.writeFileSync)(cacheFile(k, home), JSON.stringify({ key: governedPathCacheKey(k), docId, ts: 0, written: Date.now() }));
+}
+function readGovernedPath(k, home) {
+    const f = cacheFile(k, home);
+    if (!(0, fs_1.existsSync)(f))
+        return null;
+    try {
+        const body = JSON.parse((0, fs_1.readFileSync)(f, "utf8"));
+        if (body.key !== governedPathCacheKey(k))
+            return null; // hash-collision guard
+        if (Date.now() - body.written > TTL_MS)
+            return null; // TTL
+        return body.docId;
+    }
+    catch {
+        return null;
+    }
+}
+// Reuse of kb_add.ts receiptEnqueuesExtraction: only a body-changing FILE ingest
+// (a minted, activated revision) produced a live doc body worth caching. A corpus
+// rollup, a noop_unchanged delivery, or a failed ingest produced nothing, so it
+// must not be cached.
+//
+// NOTE (posture removal): the born-PENDING model dropped posture from the receipt,
+// so `receipt.posture` is now always absent and namespace routing below degrades
+// to the "personal" namespace for every entry. This is graceful (the cache is
+// best-effort and never gated on; a miss just costs a server round-trip), but the
+// shared/personal split is no longer meaningful here. Re-key on document scope
+// (WORKSPACE vs PERSON) in a follow-up if the split needs to be honored.
+function receiptProducedLiveBody(r) {
+    return r.mode === "file" && r.outcome === "ingested";
+}
+function governedPathEntryForReceipt(receipt, ctx) {
+    if (!receiptProducedLiveBody(receipt))
+        return null;
+    if (!receipt.documentId || !receipt.canonicalPath)
+        return null;
+    // Effective posture from the receipt; fall back to ctx.defaultPosture (then
+    // "SHADOW" -> personal) when the receipt carries no posture. Only an explicit
+    // LIVE doc goes to the shared namespace; everything else is owner-private.
+    const posture = (receipt.posture || ctx.defaultPosture || "SHADOW").toUpperCase();
+    const namespace = posture === "LIVE" ? "shared" : "personal";
+    return {
+        key: {
+            namespace,
+            workspaceId: ctx.workspaceId,
+            ownerUserId: ctx.ownerUserId,
+            repoRootHash: ctx.repoRootHash,
+            canonicalPath: receipt.canonicalPath,
+        },
+        docId: receipt.documentId,
+    };
+}