@meetless/mla 0.1.4

package/dist/commands/internal-session-nudge.js

@@ -0,0 +1,120 @@
+"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.runInternalSessionNudge = runInternalSessionNudge;
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const workspace_1 = require("../lib/workspace");
+function defaultIsGitRepo(dir) {
+    const r = (0, child_process_1.spawnSync)("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], { encoding: "utf8" });
+    return r.status === 0 && r.stdout.trim() === "true";
+}
+function parseCwd(argv, fallback) {
+    const i = argv.indexOf("--cwd");
+    if (i >= 0 && argv[i + 1])
+        return path.resolve(argv[i + 1]);
+    return fallback;
+}
+// Claude Code reads a SessionStart hook's stdout and, when it is this shape,
+// injects `additionalContext` into the session.
+function additionalContext(message) {
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "SessionStart",
+            additionalContext: message,
+        },
+    });
+}
+const NOT_ACTIVATED_MSG = "Meetless is installed but inactive in this repository. No Meetless context is being injected. " +
+    "Run `mla activate` to enable it, or `mla doctor` for details.";
+const INVALID_MARKER_MSG = "Meetless activation is incomplete in this repository. No Meetless context is being injected. " +
+    "Run `mla doctor`, then rerun `mla activate` to repair it.";
+const LOGGED_OUT_MSG = "Meetless is activated in this repository but you are signed out, so no Meetless context is being injected. " +
+    "Run `mla login` to resume, or `mla doctor` for details.";
+function runInternalSessionNudge(argv, deps = {}) {
+    const readCfg = deps.readConfig ?? config_1.readConfig;
+    const resolveWs = deps.resolveWorkspaceContext ?? workspace_1.resolveWorkspaceContext;
+    const isGitRepo = deps.isGitRepo ?? defaultIsGitRepo;
+    const log = deps.log ?? ((m) => process.stdout.write(m + "\n"));
+    const env = deps.env ?? process.env;
+    const cwd = parseCwd(argv, env.MEETLESS_PROJECT_DIR ?? env.CLAUDE_PROJECT_DIR ?? process.cwd());
+    // Read auth, but do NOT use it to short-circuit: an activated repo that the user
+    // has since logged out of still deserves a visible login nudge. Auth only gates
+    // the no-marker case below. Any config-read failure -> silent (never break a hook).
+    let loggedIn = false;
+    try {
+        loggedIn = readCfg().auth.mode !== "none";
+    }
+    catch {
+        return 0;
+    }
+    // Git repositories only: suppress scratch dirs and $HOME, regardless of auth.
+    if (!isGitRepo(cwd))
+        return 0;
+    // Resolve the marker FIRST, then branch on (marker-state x auth). Reusing the
+    // MCP's resolver keeps "activated?" meaning EXACTLY the same thing in both
+    // surfaces. The key distinction this enables: "logged out in a repo the user
+    // activated" (nudge login) vs "logged out in an unrelated repo" (stay silent).
+    try {
+        resolveWs(cwd);
+        // Valid marker: this repo is activated. Logged in -> the active hook path
+        // injects context, so we stay silent. Logged out -> governance is dark in a
+        // repo the user chose, so surface the login path.
+        if (!loggedIn) {
+            log(additionalContext(LOGGED_OUT_MSG));
+        }
+        return 0;
+    }
+    catch (e) {
+        if (e instanceof workspace_1.NotActivatedError) {
+            // No marker: only nudge a logged-in user. A logged-out user in an unrelated
+            // repo has never expressed intent here; silence is correct.
+            if (loggedIn) {
+                log(additionalContext(NOT_ACTIVATED_MSG));
+            }
+            return 0;
+        }
+        if (e instanceof workspace_1.MarkerMissingWorkspaceIdError) {
+            // A present-but-broken marker is durable evidence of intent to use Meetless
+            // here, so surface the repair path regardless of auth.
+            log(additionalContext(INVALID_MARKER_MSG));
+            return 0;
+        }
+        // Unanticipated resolver failure: stay silent rather than emit a confusing
+        // message into a fresh session.
+        return 0;
+    }
+}

package/dist/commands/internal-steer-sync.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.runInternalSteerSync = runInternalSteerSync;
+const config_1 = require("../lib/config");
+const http_1 = require("../lib/http");
+const active_conflict_cache_1 = require("../lib/active-conflict-cache");
+const steer_cache_1 = require("../lib/steer-cache");
+function realTransport(cfg) {
+    return {
+        pull: async (sessionId) => {
+            const res = await (0, http_1.post)(cfg, `/internal/v1/session-steers/by-session/${encodeURIComponent(sessionId)}/pull`, { workspaceId: cfg.workspaceId }, 8000);
+            return res.steers ?? [];
+        },
+        markInjected: async (id) => {
+            await (0, http_1.post)(cfg, `/internal/v1/session-steers/${encodeURIComponent(id)}/injected`, { workspaceId: cfg.workspaceId }, 8000);
+        },
+        fetchActiveConflicts: async (sessionId) => {
+            const res = await (0, http_1.get)(cfg, `/internal/v1/session-conflicts/by-session/${encodeURIComponent(sessionId)}/active` +
+                `?workspaceId=${encodeURIComponent(cfg.workspaceId)}`, 8000);
+            return res.conflicts ?? [];
+        },
+    };
+}
+function stubTransport(stubJson) {
+    return {
+        pull: async () => {
+            const parsed = JSON.parse(stubJson);
+            return Array.isArray(parsed) ? parsed : [];
+        },
+        markInjected: async () => {
+            /* stub: no network */
+        },
+        fetchActiveConflicts: async () => {
+            const raw = process.env.MEETLESS_CONFLICT_SYNC_STUB;
+            if (!raw || raw.length === 0)
+                return [];
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        },
+    };
+}
+function parseArgs(argv) {
+    let sessionId = null;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--session") {
+            sessionId = argv[i + 1] ?? null;
+            i++;
+            continue;
+        }
+        if (a.startsWith("-")) {
+            throw new Error(`Unknown flag: ${a}. \`mla _internal steer-sync\` takes only --session <sid>.`);
+        }
+        throw new Error(`Unexpected positional argument: ${a}. \`mla _internal steer-sync\` takes only --session <sid>.`);
+    }
+    if (!sessionId) {
+        throw new Error("`mla _internal steer-sync` requires --session <sid>.");
+    }
+    return { sessionId };
+}
+async function runInternalSteerSync(argv) {
+    let sessionId;
+    try {
+        ({ sessionId } = parseArgs(argv));
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    try {
+        const stub = process.env.MEETLESS_STEER_SYNC_STUB_PULL;
+        const transport = stub && stub.length > 0 ? stubTransport(stub) : realTransport((0, config_1.loadWorkspaceConfig)());
+        // 1) Pull and cache the authoritative deliverable set (overwrite: the server
+        //    returns the full not-yet-injected set, so the cache is never a stale delta).
+        const steers = await transport.pull(sessionId);
+        (0, steer_cache_1.writeSteerCache)(sessionId, steers);
+        // 2) Mark-injected what the hook already surfaced. The hook dedups injection
+        //    via its own inject-state, so a one-turn overlap (a just-injected steer
+        //    still in the freshly written cache) never re-injects; the next pull drops
+        //    it once it is flipped to INJECTED.
+        let injected = 0;
+        if (!stub) {
+            for (const id of (0, steer_cache_1.readInjectedIds)(sessionId)) {
+                try {
+                    await transport.markInjected(id);
+                    injected++;
+                }
+                catch {
+                    /* best-effort: a failed mark-injected retries next flush */
+                }
+            }
+        }
+        // 3) Snapshot the session's open cross-session conflicts for the PreToolUse soft
+        //    warning. Isolated from the steer pull: a conflict-fetch failure must not
+        //    zero the pull or the flush. On a SUCCESSFUL fetch (even an empty set) we
+        //    overwrite the snapshot so a resolved conflict clears the warning at once;
+        //    on a FAILURE we leave the prior snapshot in place and let the hook's TTL
+        //    staleness guard fail it open. -1 means "fetch did not complete this turn".
+        let conflicts = -1;
+        try {
+            const active = await transport.fetchActiveConflicts(sessionId);
+            (0, active_conflict_cache_1.writeActiveConflictCache)(sessionId, active);
+            conflicts = active.length;
+        }
+        catch {
+            /* best-effort: leave the prior snapshot; TTL fails it open if the sync stays down */
+        }
+        console.log(JSON.stringify({ pulled: steers.length, injected, conflicts }));
+        return 0;
+    }
+    catch {
+        // Best-effort: never break the flush this hop rides on.
+        console.log(JSON.stringify({ pulled: 0, injected: 0, conflicts: -1 }));
+        return 0;
+    }
+}

package/dist/commands/internal-turn-recap.js

@@ -0,0 +1,140 @@
+"use strict";
+// `mla _internal turn-recap` -- the machine-facing per-turn assist recap reader
+// (Layer B of notes/20260609-mla-per-turn-assist-recap-plan.md). Two callers shell
+// out to it:
+//   - user-prompt-submit.sh (Layer C-lite): `--style block-context` for the prior
+//     turn, injected into the next prompt's context. Best-effort; a slow or empty
+//     recap must produce nothing, never an error.
+//   - stop.sh (Layer D): `--emit-langfuse` detached at turn-end, to attach the
+//     mla_ran / mla_assist scores to the turn's Langfuse trace.
+//
+// It computes the recap (Layer A computeTurnRecap) for one (session, turn) and
+// prints one of three render styles or the raw JSON. Like the other `_internal`
+// subcommands it skips analytics capture and is fail-soft: a strict argv parse
+// error exits 2; any other failure prints nothing and exits 0 so it can never
+// disturb the hook that spawned it.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTurnRecapArgs = parseTurnRecapArgs;
+exports.renderStyle = renderStyle;
+exports.runInternalTurnRecap = runInternalTurnRecap;
+const config_1 = require("../lib/config");
+const turn_recap_emit_1 = require("../lib/turn-recap-emit");
+const turn_recap_1 = require("../lib/analytics/turn-recap");
+const STYLES = ["footer", "block", "block-context"];
+function parseTurnRecapArgs(argv) {
+    const out = {
+        session: null,
+        turn: null,
+        style: "footer",
+        json: false,
+        emitLangfuse: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case "--session":
+                out.session = argv[++i] ?? "";
+                if (!out.session)
+                    throw new Error("--session requires a value");
+                break;
+            case "--turn": {
+                const v = argv[++i];
+                if (!v || !/^[0-9]+$/.test(v) || Number(v) < 1) {
+                    throw new Error(`--turn requires a positive integer: ${v ?? "(missing)"}`);
+                }
+                out.turn = Number(v);
+                break;
+            }
+            case "--style": {
+                const v = argv[++i];
+                if (!STYLES.includes(v))
+                    throw new Error(`--style must be one of ${STYLES.join("|")}: ${v ?? "(missing)"}`);
+                out.style = v;
+                break;
+            }
+            case "--json":
+                out.json = true;
+                break;
+            case "--emit-langfuse":
+                out.emitLangfuse = true;
+                break;
+            default:
+                throw new Error(`Unknown flag for \`mla _internal turn-recap\`: ${a}`);
+        }
+    }
+    return out;
+}
+function renderStyle(recap, style) {
+    switch (style) {
+        case "block":
+            return (0, turn_recap_1.renderBlock)(recap);
+        case "block-context":
+            return (0, turn_recap_1.renderBlockContext)(recap);
+        default:
+            return (0, turn_recap_1.renderFooter)(recap);
+    }
+}
+// A recap with no usable content to inject: the turn left no trace and we cannot
+// even name why (a true "nothing happened" gap, distinct from a known muted /
+// suppressed / NO_OFFER turn, all of which carry signal worth surfacing).
+function isEmptyRecap(r) {
+    return !r.ran && r.not_run_reason === null;
+}
+async function runInternalTurnRecap(argv, deps = {}) {
+    let args;
+    try {
+        args = parseTurnRecapArgs(argv);
+    }
+    catch (e) {
+        console.error(e.message);
+        return 2;
+    }
+    const env = deps.env ?? process.env;
+    const log = deps.log ?? ((line) => console.log(line));
+    try {
+        const session = args.session ?? env.CLAUDE_CODE_SESSION_ID ?? "";
+        if (!session || args.turn === null) {
+            // Nothing to compute against. Silent, fail-soft (the hook ignores this).
+            return 0;
+        }
+        const compute = deps.compute ?? ((s, t) => (0, turn_recap_1.computeTurnRecap)(s, t));
+        const recap = compute(session, args.turn);
+        if (args.json) {
+            log(JSON.stringify(recap));
+        }
+        else if (args.style === "block-context" && isEmptyRecap(recap)) {
+            // C-lite: inject nothing when there is genuinely nothing to say.
+        }
+        else {
+            log(renderStyle(recap, args.style));
+        }
+        // Layer D emission: detached, best-effort, never blocks the agent.
+        // No-op when no trace id (nothing to attach a score to).
+        if (args.emitLangfuse && recap.trace_id) {
+            const readCfg = deps.readCfg ??
+                (() => {
+                    try {
+                        return (0, config_1.readConfig)();
+                    }
+                    catch {
+                        return null;
+                    }
+                });
+            const postTurnRecap = deps.postTurnRecap ?? turn_recap_emit_1.postTurnRecapToIntel;
+            const cfg = readCfg();
+            if (cfg) {
+                try {
+                    await postTurnRecap(cfg, recap);
+                }
+                catch {
+                    // Langfuse/intel outage must degrade to "no score this turn", nothing more.
+                }
+            }
+        }
+        return 0;
+    }
+    catch {
+        // Fail-soft: never throw into the hook that spawned us.
+        return 0;
+    }
+}