@meetless/mla 0.1.4

package/dist/commands/adoption.js

@@ -0,0 +1,130 @@
+"use strict";
+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.parseReportCitations = exports.parseMcpCalls = exports.parseInjectTurns = exports.computeFollowthrough = exports.buildAdoption = void 0;
+exports.parseAdoptionArgs = parseAdoptionArgs;
+exports.runAdoption = runAdoption;
+const path = __importStar(require("path"));
+const followthrough_1 = require("../lib/analytics/followthrough");
+Object.defineProperty(exports, "buildAdoption", { enumerable: true, get: function () { return followthrough_1.buildAdoption; } });
+Object.defineProperty(exports, "computeFollowthrough", { enumerable: true, get: function () { return followthrough_1.computeFollowthrough; } });
+Object.defineProperty(exports, "parseInjectTurns", { enumerable: true, get: function () { return followthrough_1.parseInjectTurns; } });
+Object.defineProperty(exports, "parseMcpCalls", { enumerable: true, get: function () { return followthrough_1.parseMcpCalls; } });
+Object.defineProperty(exports, "parseReportCitations", { enumerable: true, get: function () { return followthrough_1.parseReportCitations; } });
+const logs_1 = require("../lib/analytics/logs");
+function parseAdoptionArgs(argv) {
+    const out = { last: 50, json: false, all: false, window: 1 };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--json")
+            out.json = true;
+        else if (a === "--all")
+            out.all = true;
+        else if (a === "--last") {
+            const v = argv[++i];
+            const parsed = Number(v);
+            if (!v || !Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error(`--last requires a positive integer (got: ${v ?? "(none)"})`);
+            }
+            out.last = parsed;
+        }
+        else if (a === "--window") {
+            const v = argv[++i];
+            const parsed = Number(v);
+            if (v === undefined || !Number.isInteger(parsed) || parsed < 0) {
+                throw new Error(`--window requires a non-negative integer (got: ${v ?? "(none)"})`);
+            }
+            out.window = parsed;
+        }
+        else
+            throw new Error(`Unknown flag for \`mla adoption\`: ${a}`);
+    }
+    return out;
+}
+function renderAdoption(a) {
+    const pct = (r) => (r * 100).toFixed(0) + "%";
+    const frac = (x) => `${x}/${a.inject_turns}`;
+    return [
+        `Evidence-followthrough (A1) over ${a.inject_turns} high-value inject turn(s):`,
+        `  A1c any followthrough:    ${frac(a.a1c_any)} (${pct(a.a1c_rate)})`,
+        `  A1a pull-followthrough:   ${frac(a.a1a_pull)} (${pct(a.a1a_rate)})`,
+        `  A1b push-reference:       ${frac(a.a1b_push_reference)} (${pct(a.a1b_rate)})`,
+        `  No followthrough:         ${frac(a.no_followthrough)} (${pct(a.inject_turns ? a.no_followthrough / a.inject_turns : 0)})`,
+    ].join("\n");
+}
+function runAdoption(argv) {
+    let args;
+    try {
+        args = parseAdoptionArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    let injects = (0, followthrough_1.parseInjectTurns)((0, logs_1.readLogJsonl)("ask-traces.jsonl"));
+    const calls = (0, followthrough_1.parseMcpCalls)((0, logs_1.readLogJsonl)("mcp-calls.jsonl"));
+    const citations = (0, followthrough_1.parseReportCitations)((0, logs_1.readLogJsonl)("report-citations.jsonl"));
+    // Auto-scope to the current live session (same contract as `mla summary`).
+    // Scope the inject denominator BEFORE --last so the window is "last N inject
+    // turns of this session". The pull/report sides are matched per-session in the
+    // join, so scoping only the inject side is sufficient.
+    const session = (process.env.CLAUDE_CODE_SESSION_ID || "").trim();
+    const scoped = !args.all && session.length > 0;
+    if (scoped)
+        injects = injects.filter((t) => t.session_id === session);
+    if (injects.length === 0) {
+        const at = path.join((0, logs_1.logsDir)(), "ask-traces.jsonl");
+        console.error(scoped
+            ? `No high-value inject turns for the current session (${session}) in ${at}. Use --all for every session.`
+            : `No high-value inject turns found in ${at}.`);
+        return 1;
+    }
+    // Stable per-session turn order, then keep the most recent N inject turns.
+    injects.sort((a, b) => a.session_id === b.session_id
+        ? a.turn_index - b.turn_index
+        : a.session_id < b.session_id
+            ? -1
+            : 1);
+    injects = injects.slice(-args.last);
+    const rows = (0, followthrough_1.computeFollowthrough)(injects, calls, citations, args.window);
+    const agg = (0, followthrough_1.buildAdoption)(rows);
+    if (args.json) {
+        console.log(JSON.stringify(agg, null, 2));
+    }
+    else {
+        console.log(renderAdoption(agg));
+    }
+    return 0;
+}

package/dist/commands/ask.js

@@ -0,0 +1,290 @@
+"use strict";
+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.parseArgs = parseArgs;
+exports.runAsk = runAsk;
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+const temporal_1 = require("../lib/temporal");
+const packaged_1 = require("../lib/packaged");
+const MODES = ["answer", "search", "canonical", "compare"];
+function parseArgs(argv) {
+    const out = { query: "", mode: "answer", json: true };
+    let sawQuery = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--mode") {
+            const v = argv[++i];
+            if (!MODES.includes(v)) {
+                throw new Error(`Unknown mode '${v ?? ""}'. Valid: ${MODES.join(", ")}.`);
+            }
+            out.mode = v;
+        }
+        else if (a === "--workspace" || a === "--workspace-id") {
+            out.workspaceId = argv[++i];
+        }
+        else if (a === "--max") {
+            out.maxResults = Number(argv[++i]);
+        }
+        else if (a === "--min") {
+            out.minResults = Number(argv[++i]);
+        }
+        else if (a === "--as-of") {
+            // parseAsOf throws on a malformed date; the throw propagates out of
+            // parseArgs and runAsk maps it to exit 2, so a typo never silently
+            // answers as-of "now".
+            out.asOf = (0, temporal_1.parseAsOf)(argv[++i] ?? "");
+        }
+        else if (a === "--plain") {
+            out.json = false;
+        }
+        else if (a === "--json") {
+            out.json = true;
+        }
+        else if (a.startsWith("--")) {
+            throw new Error(`Unknown flag for \`mla ask\`: ${a}`);
+        }
+        else if (!sawQuery) {
+            out.query = a;
+            sawQuery = true;
+        }
+        else {
+            throw new Error(`Unexpected positional argument: ${a} (quote the query as a single argument).`);
+        }
+    }
+    if (!out.query.trim()) {
+        throw new Error(`Usage: mla ask "<query>" [--mode answer|search|canonical|compare] [--workspace <id>] [--as-of <date>] [--max <n>] [--min <n>] [--plain]`);
+    }
+    return out;
+}
+// ask-core is plain ESM; `mla` compiles to CommonJS. A literal dynamic import()
+// would be downleveled by tsc to require(), which cannot load an ESM-only
+// package on Node < 22. The Function constructor preserves a TRUE runtime
+// import() so it works on every supported Node (>=18.18). Used only by the dev
+// fallback below (ts-node, no built dist). Resolve ask-core as a sibling package
+// directory (packages/ask-core), three levels up from the compiled commands dir
+// (dist/commands -> dist -> cli -> packages).
+const trueDynamicImport = new Function("u", "return import(u)");
+function askCoreDir() {
+    return path.resolve(__dirname, "..", "..", "..", "ask-core");
+}
+// The CJS bundle the build emits (scripts/bundle-esm.js -> dist/bundles/). It
+// sits a sibling level up from the compiled commands dir: dist/commands -> dist
+// -> dist/bundles.
+function bundlePath(name) {
+    return path.resolve(__dirname, "..", "bundles", name);
+}
+function notesRoot() {
+    if (process.env.MEETLESS_NOTES_ROOT)
+        return process.env.MEETLESS_NOTES_ROOT;
+    // Best-effort: the standalone notes repo is a sibling of the code repo. A
+    // missing INDEX.md degrades to retrieval, so an imperfect guess here is
+    // non-fatal.
+    return path.resolve(__dirname, "..", "..", "..", "..", "..", "notes");
+}
+// Load ask-core from its ESM source files (the original path). Kept as the dev
+// fallback for `pnpm dev` (ts-node), where no dist/bundles exists. Never reached
+// inside the pkg binary: a true import() throws there (no ESM dynamic-import
+// callback in the V8 snapshot), which is exactly why the bundle exists.
+async function loadAskCoreFromSource() {
+    const dir = askCoreDir();
+    const askModes = (await trueDynamicImport((0, url_1.pathToFileURL)(path.join(dir, "ask_modes.js")).href));
+    const sf = (await trueDynamicImport((0, url_1.pathToFileURL)(path.join(dir, "status_fallback.js")).href));
+    const mc = (await trueDynamicImport((0, url_1.pathToFileURL)(path.join(dir, "match_canonical.js")).href));
+    return { ...askModes, ...sf, ...mc };
+}
+// Prefer the bundled CJS: require() works inside the pkg snapshot, unlike a true
+// import(). On a source/npm install the bundle is present after `pnpm build`.
+// The dev fallback covers ts-node (`pnpm dev`), where no dist exists yet.
+async function loadAskCore() {
+    try {
+        return require(bundlePath("ask-core.js"));
+    }
+    catch (e) {
+        // Inside the binary there is no source tree to fall back to, and require of
+        // an embedded bundle should never fail; surface the real error rather than
+        // attempting a true import() that the snapshot cannot host.
+        if ((0, packaged_1.isPackagedBinary)())
+            throw e;
+        // Dev/source without a built dist (ts-node): only fall through on a genuine
+        // "module not found"; a real load error inside the bundle must surface.
+        const code = e?.code;
+        if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND")
+            throw e;
+        return loadAskCoreFromSource();
+    }
+}
+// A citation field is "meaningful" only if it's a non-empty string that isn't
+// the "UNKNOWN" sentinel ask-core stamps when intel returns no value. Used to
+// keep noise (`[UNKNOWN]`) out of the --plain footer.
+function meaningful(v) {
+    if (typeof v !== "string")
+        return null;
+    const t = v.trim();
+    if (!t || t.toUpperCase() === "UNKNOWN")
+        return null;
+    return t;
+}
+// The bracketed metadata after a citation path: the doc KIND (docType, which
+// ask-core always sets -- defaulting to "note") and, when present, the
+// lifecycle STATUS (SHIPPED/PROPOSED/...). Before this, the footer rendered
+// r.status alone, so every grounded note printed a useless `[UNKNOWN]` (notes
+// carry a docType but no status) even though the inline `[NT:...]` citation
+// already knew the kind. Kind-first, status-when-real.
+function citationMeta(r) {
+    const parts = [meaningful(r.docType), meaningful(r.status)].filter((x) => x !== null);
+    return parts.length > 0 ? ` [${parts.join(", ")}]` : "";
+}
+function renderPlain(result) {
+    const lines = [];
+    const answer = result.answer;
+    if (typeof answer === "string" && answer.trim()) {
+        lines.push(answer.trim());
+        lines.push("");
+    }
+    const results = Array.isArray(result.results) ? result.results : [];
+    if (results.length > 0) {
+        lines.push(`Citations (${results.length}):`);
+        for (const r of results) {
+            const p = r.path ?? r.title ?? "(unknown)";
+            lines.push(`  - ${String(p)}${citationMeta(r)}`);
+        }
+    }
+    const warnings = Array.isArray(result.warnings) ? result.warnings : [];
+    if (warnings.length > 0) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const w of warnings)
+            lines.push(`  ! ${String(w)}`);
+    }
+    lines.push("");
+    lines.push(`(workspace: ${String(result.workspace ?? "")}, mode: ${String(result.mode ?? "")}, confidence: ${String(result.confidence ?? "")})`);
+    return lines.join("\n");
+}
+// The ask-core loader is injectable so the glue (workspace resolution, mode
+// routing, render, error->exit-code mapping) can be unit-tested without the
+// true runtime import(): jest's VM sandbox rejects native dynamic import
+// unless run with --experimental-vm-modules, and ask-core is ESM-only. The
+// REAL dynamic import is proven by a runtime smoke against the built binary,
+// not by jest. cli.ts always calls the single-arg form, so the seam never
+// reaches the shipped path.
+async function runAsk(argv, deps = {}) {
+    let args;
+    try {
+        args = parseArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    // Folder = workspace (T1.1): resolve the workspace from the nearest marker,
+    // honoring `--workspace <id>` as an explicit override so an operator can ask
+    // against another workspace from an unbound directory without tripping the
+    // "not activated" guard. Loading after parseArgs is what lets the override
+    // short-circuit marker resolution.
+    const cfg = (0, config_1.loadWorkspaceConfig)(args.workspaceId);
+    const intelUrl = cfg.intelUrl || http_1.DEFAULT_INTEL_URL;
+    // cfg.controlToken IS intel's INTERNAL_API_KEY in the dogfood config (same
+    // bearer the hook uses for /v1/ask; see lib/http.ts).
+    const apiKey = cfg.controlToken;
+    const effectiveWorkspace = cfg.workspaceId;
+    let core;
+    try {
+        core = await (deps.loadCore ?? loadAskCore)();
+    }
+    catch (e) {
+        console.error(`failed to load @meetless/ask-core: ${e.message}`);
+        return 1;
+    }
+    const intelAsk = core.makeIntelAsk({ intelBaseUrl: intelUrl, apiKey });
+    const matchCanonical = core.makeMatchCanonical({ notesRoot: notesRoot() });
+    const modes = core.makeAskModes({
+        intelAsk,
+        defaultWorkspaceId: effectiveWorkspace,
+        matchCanonical,
+        statusFallback: core.statusFallback,
+    });
+    const callArgs = {
+        query: args.query,
+        workspace_id: effectiveWorkspace,
+    };
+    if (args.maxResults !== undefined)
+        callArgs.maxResults = args.maxResults;
+    if (args.minResults !== undefined)
+        callArgs.minResults = args.minResults;
+    // B9: forward the valid-time cutoff ONLY when the operator set it, so the live
+    // (no --as-of) path stays byte-identical to today. The one-line banner goes to
+    // stderr so `mla ask` stdout stays pure JSON for piping.
+    if (args.asOf) {
+        callArgs.as_of = args.asOf;
+        console.error(`Point-in-time answer as of ${args.asOf} (relations not yet valid at that instant are excluded).`);
+    }
+    const handler = args.mode === "search"
+        ? modes.runSearch
+        : args.mode === "canonical"
+            ? modes.runCanonical
+            : args.mode === "compare"
+                ? modes.runCompare
+                : modes.runAnswer;
+    let result;
+    try {
+        result = await handler(callArgs);
+    }
+    catch (e) {
+        const msg = e.message || String(e);
+        if (/ECONNREFUSED|fetch failed|ENOTFOUND/i.test(msg)) {
+            console.error(`intel not reachable at ${intelUrl}. Is it running? Try \`mla doctor\`.`);
+        }
+        else {
+            console.error(`mla ask failed: ${msg}`);
+        }
+        return 1;
+    }
+    // Echo the effective workspace so the caller always sees which corpus
+    // answered (mirrors the MCP's server.js behavior; makes ingest/answer drift
+    // impossible to miss).
+    if (result && typeof result === "object") {
+        result.workspace = effectiveWorkspace;
+    }
+    if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(renderPlain(result));
+    }
+    return 0;
+}

package/dist/commands/context.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyContextVerdict = applyContextVerdict;
+exports.advisoryLines = advisoryLines;
+exports.latestReviewCardItems = latestReviewCardItems;
+exports.runContext = runContext;
+// src/commands/context.ts
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const cache_1 = require("../lib/scanner/cache");
+const workspace_1 = require("../lib/workspace");
+const scan_context_1 = require("./scan-context");
+// Pure verdict bookkeeping (no rescan); the command wrapper triggers the rescan.
+function applyContextVerdict(args) {
+    const v = (0, cache_1.readVerdicts)(args.home, args.workspaceId);
+    const add = (list, id) => (list.includes(id) ? list : [...list, id]);
+    const drop = (list, id) => list.filter((x) => x !== id);
+    if (args.action === "accept") {
+        v.accepted = add(v.accepted, args.id);
+        v.dismissed = drop(v.dismissed, args.id);
+    }
+    else {
+        v.dismissed = add(v.dismissed, args.id);
+        v.accepted = drop(v.accepted, args.id);
+    }
+    (0, cache_1.writeVerdicts)(args.home, args.workspaceId, v);
+}
+// Read-only view of the advisory agent-memory rules captured in the scan cache.
+// These are machine_inferred (untracked, per-machine, agent-distilled), so they are
+// NEVER auto-injected as must-follow; this list is a human review surface only.
+// `?? []` guards a pre-M1 on-disk cache that predates the advisoryDirectives field.
+function advisoryLines(home, workspaceId) {
+    const cache = (0, cache_1.readScanCache)(home, workspaceId);
+    const advisory = cache?.advisoryDirectives ?? [];
+    return advisory.map((d) => `${d.id}  [${d.strength}]  ${d.text}  (${d.source})`);
+}
+function latestReviewCardItems(home, workspaceId) {
+    const path = (0, node_path_1.join)(home, ".meetless", "workspaces", workspaceId, "review-cards.jsonl");
+    let lines;
+    try {
+        lines = (0, node_fs_1.readFileSync)(path, "utf8").split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+            const row = JSON.parse(lines[i]);
+            if (row.event === "review_card" && Array.isArray(row.items))
+                return row.items;
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return [];
+}
+async function runContext(argv) {
+    const [sub, id] = argv;
+    const workspaceId = (0, workspace_1.resolveWorkspaceIdWithEnv)();
+    if (!workspaceId) {
+        console.error("context: run inside an activated workspace (MEETLESS_WORKSPACE_ID unset and no .meetless.json marker found).");
+        return 2;
+    }
+    const home = (0, node_os_1.homedir)();
+    if (sub === "list") {
+        const cache = (0, cache_1.readScanCache)(home, workspaceId);
+        if (cache && cache.staleSignals.length) {
+            for (const s of cache.staleSignals)
+                console.log(`${s.id}  ${s.detail}`);
+            return 0;
+        }
+        if (!cache) {
+            // No live scan cache (workspace not scanned yet, or cache cleared). Fall back to
+            // the last session's review card as a degraded, clearly-labelled view.
+            const card = latestReviewCardItems(home, workspaceId);
+            if (card.length) {
+                console.log("No current scan cache; showing the last session's review card. Run `mla activate` to refresh.");
+                for (const item of card)
+                    console.log(`${item.id}  ${item.detail}`);
+                return 0;
+            }
+        }
+        console.log("No pending review items.");
+        return 0;
+    }
+    if (sub === "advisory") {
+        const lines = advisoryLines(home, workspaceId);
+        if (!lines.length) {
+            console.log("No advisory agent-memory rules.");
+            return 0;
+        }
+        // Advisory rules are machine_inferred and never injected; this is review-only.
+        // accept/dismiss is deliberately NOT wired here: promoting a machine_inferred rule
+        // to attested is a state transition that belongs to a human attestation flow.
+        console.log("Advisory rules from agent memory (machine_inferred; NOT injected; review only):");
+        for (const l of lines)
+            console.log(`  ${l}`);
+        return 0;
+    }
+    if ((sub === "accept" || sub === "dismiss") && id) {
+        applyContextVerdict({ home, workspaceId, action: sub, id });
+        // Anchor the refresh to the marker dir, not cwd: a dismiss/accept from a
+        // package subdir must rescan the WHOLE workspace, or the cache loses every
+        // rule outside the subdir and the just-dismissed signal resurfaces under a
+        // new (path-relative) id. See resolveScanRoot.
+        void (0, scan_context_1.rescanAndCache)({ cwd: (0, scan_context_1.resolveScanRoot)(process.cwd()), workspaceId, home });
+        console.log(`${sub === "accept" ? "Accepted" : "Dismissed"} ${id}. Next session's context updated.`);
+        return 0;
+    }
+    console.error("usage: mla context <accept|dismiss> <id> | mla context list | mla context advisory");
+    return 2;
+}