muonroi-cli 1.8.5 → 1.9.0

package/dist/src/cli/bw-vault.js

@@ -1,133 +0,0 @@
-import { spawnSync } from "node:child_process";
-const defaultRunner = (cmd, args, input) => spawnSync(cmd, args, { encoding: "utf8", input });
-function ensureUnlocked(session, run) {
-    const status = run("bw", ["status", "--session", session]);
-    if (status.status !== 0) {
-        return { ok: false, error: `bw status failed: ${status.stderr || status.stdout}` };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(status.stdout);
-    }
-    catch {
-        parsed = {};
-    }
-    if (parsed.status !== "unlocked") {
-        return { ok: false, error: `Bitwarden vault is not unlocked (status: ${parsed.status ?? "unknown"})` };
-    }
-    return { ok: true };
-}
-function findExistingItem(name, session, run) {
-    const list = run("bw", ["list", "items", "--search", name, "--session", session]);
-    if (list.status !== 0)
-        return null;
-    let items;
-    try {
-        items = JSON.parse(list.stdout);
-    }
-    catch {
-        return null;
-    }
-    return items.find((it) => it.name === name) ?? null;
-}
-/**
- * Write `notes` into a vault item named `name`. Creates a Secure Note if
- * absent; updates the notes field if present. Calls `bw sync` after a write
- * so subsequent `bw get` calls see the new value.
- */
-export async function writeBwSecureNote(name, notes, options = {}) {
-    const run = options.runner ?? defaultRunner;
-    const which = run("bw", ["--version"]);
-    if (which.status !== 0) {
-        return { ok: false, error: "Bitwarden CLI ('bw') not found in PATH. Install: https://bitwarden.com/help/cli/" };
-    }
-    const session = process.env.BW_SESSION;
-    if (!session) {
-        return { ok: false, error: "BW_SESSION not set. Run: export BW_SESSION=$(bw unlock --raw)" };
-    }
-    const unlock = ensureUnlocked(session, run);
-    if (!unlock.ok)
-        return { ok: false, error: unlock.error };
-    const existing = findExistingItem(name, session, run);
-    if (existing) {
-        const updated = { ...existing, notes };
-        const encoded = run("bw", ["encode"], JSON.stringify(updated));
-        if (encoded.status !== 0) {
-            return { ok: false, error: `bw encode failed: ${encoded.stderr || encoded.stdout}` };
-        }
-        const edit = run("bw", ["edit", "item", existing.id, encoded.stdout.trim(), "--session", session]);
-        if (edit.status !== 0) {
-            return { ok: false, error: `bw edit failed: ${edit.stderr || edit.stdout}` };
-        }
-        run("bw", ["sync", "--session", session]);
-        return { ok: true, action: "updated" };
-    }
-    // Create a new Secure Note. Type 2 = secure note; secureNote.type 0 = generic.
-    const item = {
-        type: 2,
-        name,
-        notes,
-        secureNote: { type: 0 },
-    };
-    const encoded = run("bw", ["encode"], JSON.stringify(item));
-    if (encoded.status !== 0) {
-        return { ok: false, error: `bw encode failed: ${encoded.stderr || encoded.stdout}` };
-    }
-    const create = run("bw", ["create", "item", encoded.stdout.trim(), "--session", session]);
-    if (create.status !== 0) {
-        return { ok: false, error: `bw create failed: ${create.stderr || create.stdout}` };
-    }
-    run("bw", ["sync", "--session", session]);
-    return { ok: true, action: "created" };
-}
-/**
- * Unlock the BW vault with a master password and return the session token
- * in-memory only. Caller passes the returned session to subsequent calls;
- * we never write to BW_SESSION env or persist it to disk.
- */
-export async function unlockWithPassword(password, options = {}) {
-    const run = options.runner ?? defaultRunner;
-    const which = run("bw", ["--version"]);
-    if (which.status !== 0) {
-        return { ok: false, error: "Bitwarden CLI ('bw') not found in PATH. Install: https://bitwarden.com/help/cli/" };
-    }
-    // `bw unlock --raw` reads the password from stdin and prints the session
-    // token to stdout. Exit code != 0 on wrong password.
-    const res = run("bw", ["unlock", "--raw", "--passwordenv", "BW_PASSWORD_PIPE"]);
-    // Fallback to stdin if --passwordenv isn't supported by this bw version.
-    if (res.status !== 0) {
-        const r2 = spawnSync("bw", ["unlock", "--raw"], { encoding: "utf8", input: `${password}\n` });
-        if (r2.status !== 0) {
-            const msg = (r2.stderr || r2.stdout || "").trim();
-            return { ok: false, error: `bw unlock failed: ${msg || "wrong master password?"}` };
-        }
-        return { ok: true, session: r2.stdout.trim() };
-    }
-    return { ok: true, session: res.stdout.trim() };
-}
-/**
- * List Secure Notes whose name starts with `prefix`. Used by the in-TUI
- * sync flow to discover which providers have keys stored in the vault.
- */
-export async function listSecureNotesByPrefix(session, prefix, options = {}) {
-    const run = options.runner ?? defaultRunner;
-    const unlock = ensureUnlocked(session, run);
-    if (!unlock.ok)
-        return { ok: false, error: unlock.error };
-    const list = run("bw", ["list", "items", "--search", prefix, "--session", session]);
-    if (list.status !== 0) {
-        return { ok: false, error: `bw list failed: ${list.stderr || list.stdout}` };
-    }
-    let items;
-    try {
-        items = JSON.parse(list.stdout);
-    }
-    catch {
-        return { ok: false, error: "bw list returned non-JSON output" };
-    }
-    const matched = items
-        .filter((it) => it.type === 2 && it.name.startsWith(prefix) && typeof it.notes === "string")
-        .map((it) => ({ name: it.name, notes: it.notes }));
-    return { ok: true, items: matched };
-}
-//# sourceMappingURL=bw-vault.js.map

package/dist/src/mcp/ee-tools.d.ts

@@ -1,46 +0,0 @@
-/**
- * src/mcp/ee-tools.ts
- *
- * EE (Experience Engine) MCP tools: ee_query (semantic recall) + ee_health +
- * ee_feedback (rate a recalled entry). Read-mostly; ee_feedback POSTs a verdict.
- *
- * Anti-mù: ee_query supports explicit "recent task checkpoint" / "Progress DONE" queries
- * so the agent (or sub-agent) can deliberately confirm finished subtasks after compactions.
- * collections: prefer "experience-behavioral" for compaction checkpoints (see layer3).
- *
- * Feedback gate: ee_query stamps every returned `[id col]` into a session-scoped
- * pending ledger (recall-ledger.ts). Subsequent ee_query calls surface (soft) or
- * refuse on (hard) accumulated unrated debt, so useful recalls actually get a
- * verdict via ee_feedback — the signal the brain needs to keep the good entries
- * and prune the rest. Mode via EXPERIENCE_RECALL_FEEDBACK_GATE = off|soft|hard
- * (default soft); hard-mode threshold via EXPERIENCE_RECALL_FEEDBACK_THRESHOLD.
- *
- * Dependencies are injected (deps) so unit tests never touch the network/singleton.
- */
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type RecallLedger } from "../ee/recall-ledger.js";
-import { type FeedbackResult, type FeedbackVerdict, type NoiseReason } from "../ee/search.js";
-import type { EERecallResponse } from "../ee/types.js";
-export interface EEToolDeps {
-    recall?: (query: string, opts: {
-        project?: string;
-    }) => Promise<EERecallResponse | null>;
-    health?: () => Promise<{
-        ok: boolean;
-        status: number;
-    }>;
-    feedback?: (pointId: string, collection: string, verdict: FeedbackVerdict, reason?: NoiseReason) => Promise<FeedbackResult>;
-    write?: (lesson: string, opts: {
-        collection?: string;
-        title?: string;
-        projectSlug?: string;
-        confidence?: number;
-    }) => Promise<{
-        ok: boolean;
-        id?: string;
-        error?: string;
-    }>;
-    /** Session pending-recall ledger. Defaults to the process singleton. */
-    ledger?: RecallLedger;
-}
-export declare function registerEETools(server: McpServer, deps?: EEToolDeps): void;

package/dist/src/mcp/ee-tools.js

@@ -1,194 +0,0 @@
-/**
- * src/mcp/ee-tools.ts
- *
- * EE (Experience Engine) MCP tools: ee_query (semantic recall) + ee_health +
- * ee_feedback (rate a recalled entry). Read-mostly; ee_feedback POSTs a verdict.
- *
- * Anti-mù: ee_query supports explicit "recent task checkpoint" / "Progress DONE" queries
- * so the agent (or sub-agent) can deliberately confirm finished subtasks after compactions.
- * collections: prefer "experience-behavioral" for compaction checkpoints (see layer3).
- *
- * Feedback gate: ee_query stamps every returned `[id col]` into a session-scoped
- * pending ledger (recall-ledger.ts). Subsequent ee_query calls surface (soft) or
- * refuse on (hard) accumulated unrated debt, so useful recalls actually get a
- * verdict via ee_feedback — the signal the brain needs to keep the good entries
- * and prune the rest. Mode via EXPERIENCE_RECALL_FEEDBACK_GATE = off|soft|hard
- * (default soft); hard-mode threshold via EXPERIENCE_RECALL_FEEDBACK_THRESHOLD.
- *
- * Dependencies are injected (deps) so unit tests never touch the network/singleton.
- */
-import { z } from "zod";
-import { sessionRecallLedger } from "../ee/recall-ledger.js";
-import { formatRecallForAgent, healthEE, recallEE, } from "../ee/search.js";
-function ok(data) {
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
-}
-function okText(text) {
-    return { content: [{ type: "text", text }] };
-}
-function fail(error, message) {
-    return {
-        content: [{ type: "text", text: JSON.stringify({ error, message }) }],
-        isError: true,
-    };
-}
-/** Resolve the feedback-gate policy from env at call time (so tests can vary it). */
-function resolveGate() {
-    const raw = String(process.env.EXPERIENCE_RECALL_FEEDBACK_GATE ?? "soft")
-        .trim()
-        .toLowerCase();
-    const mode = raw === "off" || raw === "hard" ? raw : "soft";
-    const parsed = Number.parseInt(process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD ?? "", 10);
-    const threshold = Number.isFinite(parsed) && parsed > 0 ? parsed : 3;
-    return { mode, threshold };
-}
-/** One readable block naming the still-unrated recalls + how to clear them. */
-function formatPendingBlock(pending, hard, max = 8) {
-    const shown = pending.slice(0, max);
-    const lines = shown.map((p) => `  - [${p.id} ${p.collection ?? "?"}]  (from recall: "${p.query}")`);
-    const more = pending.length > max ? `\n  …and ${pending.length - max} more` : "";
-    const head = hard
-        ? `⚠️ FEEDBACK GATE — ${pending.length} earlier recall(s) are still unrated. Rate them with ` +
-            `ee_feedback(id, collection, verdict) before pulling new recalls:`
-        : `⚠️ ${pending.length} earlier recall(s) still unrated — call ` +
-            `ee_feedback(id, collection, verdict=followed|ignored|noise) so the brain keeps what helped and prunes the rest:`;
-    return `${head}\n${lines.join("\n")}${more}`;
-}
-export function registerEETools(server, deps = {}) {
-    // Default to the shared EE recall/health/feedback helpers (src/ee/search.ts) so
-    // the MCP tools and the in-CLI builtin tools resolve auth/baseUrl the same way.
-    // Tests inject `deps` to avoid the network and a fresh `ledger` to stay isolated.
-    const recall = deps.recall ?? ((q, o) => recallEE(q, o));
-    const health = deps.health ?? (() => healthEE());
-    const ledger = deps.ledger ?? sessionRecallLedger;
-    server.registerTool("ee_query", {
-        description: "Active recall over the Experience Engine brain — prior decisions, gotchas, learned warnings/recipes, and " +
-            "task checkpoints for this codebase — via the recallMode pipeline (same path as exp-recall.js). " +
-            "CALL THIS PROACTIVELY, before acting: when starting work in an unfamiliar area, when unsure how something " +
-            "is done in this stack, before a risky or hard-to-reverse step, or to recall finished work after a " +
-            "compaction (e.g. query='recent compaction checkpoint Progress DONE for <subtask>'). A deliberate query " +
-            "here is cheaper than re-deriving or repeating a past mistake. Returns a formatted index whose entries " +
-            "carry `[id col]` handles — after you act on a recall, rate each entry you used or judged with the " +
-            "ee_feedback tool (followed/ignored/noise) so the brain keeps what helped and prunes the rest; unrated " +
-            "recalls are surfaced back to you on the next ee_query. Optional project scopes the recall. Returns a " +
-            "compact ranked index (cosine-ranked, strongest first), capped at maxChars (default 6000, range " +
-            "500-20000) and truncated from the tail; raise maxChars to see more. Returns ee_unavailable if EE is " +
-            "down (then proceed without it).",
-        inputSchema: {
-            query: z.string().min(1).max(1000),
-            project: z.string().max(200).optional(),
-            maxChars: z.number().int().min(500).max(20_000).optional(),
-        },
-    }, async ({ query, project, maxChars }) => {
-        const gate = resolveGate();
-        const pendingBefore = gate.mode === "off" ? [] : ledger.pending();
-        // Hard gate: refuse a NEW recall while unrated debt is at/over threshold —
-        // do not even spend the brain call. Below threshold, fall through to soft.
-        if (gate.mode === "hard" && pendingBefore.length >= gate.threshold) {
-            return fail("feedback_required", formatPendingBlock(pendingBefore, true));
-        }
-        try {
-            const resp = await recall(query, { project });
-            if (resp === null) {
-                return fail("ee_unavailable", "EE recall returned no response (server down, timeout, or circuit open)");
-            }
-            // Stamp the new entries as pending debt (unless the gate is off).
-            if (gate.mode !== "off")
-                ledger.record(resp.entries, query);
-            // Return the compact `[id col]` index (capped) rather than JSON.stringify
-            // of the whole response — the wide-net recall text (~30k) otherwise blows
-            // the MCP per-result token cap and spills to a file. See formatRecallForAgent.
-            const index = formatRecallForAgent(resp, { query, maxChars });
-            if (gate.mode !== "off" && pendingBefore.length > 0) {
-                return okText(`${formatPendingBlock(pendingBefore, false)}\n\n${index}`);
-            }
-            return okText(index);
-        }
-        catch (e) {
-            return fail("ee_unavailable", e instanceof Error ? e.message : String(e));
-        }
-    });
-    server.registerTool("ee_feedback", {
-        description: "Rate an Experience Engine recall entry so the brain keeps what helped and prunes the rest. Call after " +
-            "acting on an ee_query result — once per `[id col]` you used or judged. verdict: 'followed' (you changed " +
-            "your approach because of it), 'ignored' (topical but did not apply this time), 'noise' (wrong by category — " +
-            "REQUIRES reason: wrong_repo | wrong_language | wrong_task | stale_rule). id may be a short prefix; the " +
-            "server resolves it. Clears the entry from this session's pending-feedback gate.",
-        inputSchema: {
-            id: z.string().min(1).max(200),
-            collection: z.string().min(1).max(200),
-            verdict: z.enum(["followed", "ignored", "noise"]),
-            reason: z.enum(["wrong_repo", "wrong_language", "wrong_task", "stale_rule"]).optional(),
-        },
-    }, async ({ id, collection, verdict, reason }) => {
-        if (verdict === "noise" && !reason) {
-            return fail("reason_required", "verdict 'noise' requires reason: wrong_repo | wrong_language | wrong_task | stale_rule");
-        }
-        const feedback = deps.feedback ?? ((pid, col, v, r) => import("../ee/search.js").then((m) => m.feedbackEE(pid, col, v, r)));
-        try {
-            const result = await feedback(id, collection, verdict, reason);
-            if (!result.ok) {
-                return fail("feedback_failed", result.error ?? "feedback POST failed");
-            }
-            // Clear by the server-resolved full id AND the (possibly short) id the
-            // agent passed, so a prefix-based call still settles the ledger debt.
-            const clearedId = result.resolvedId ?? id;
-            ledger.clear(clearedId);
-            ledger.clear(id);
-            return ok({
-                ok: true,
-                id: clearedId,
-                verdict: result.verdict,
-                ...(result.reason ? { reason: result.reason } : {}),
-                ...(result.queued ? { queued: true } : {}),
-                pendingRemaining: ledger.pendingCount(),
-            });
-        }
-        catch (e) {
-            return fail("feedback_failed", e instanceof Error ? e.message : String(e));
-        }
-    });
-    server.registerTool("ee_health", { description: "Check Experience Engine server reachability.", inputSchema: {} }, async () => {
-        try {
-            return ok(await health());
-        }
-        catch (e) {
-            return fail("ee_unavailable", e instanceof Error ? e.message : String(e));
-        }
-    });
-    server.registerTool("ee_write", {
-        description: "Save a NEW lesson to the Experience Engine brain so you and future sessions recall it. Call the MOMENT you " +
-            "hit a mistake / error / dead-end and find the working fix: record the pitfall AND the fix in one concise, " +
-            "generalizable lesson (1-3 sentences — what to do or avoid next time, NOT a play-by-play of this turn). The " +
-            "lesson is embedded immediately (via /api/import-memory: dense + sparse) and becomes recallable via ee_query " +
-            "in this and future sessions. Use ee_query first if unsure a lesson already exists. collection defaults to " +
-            "experience-behavioral (use experience-principles only for a broad, project-independent principle); project " +
-            "scopes the lesson.",
-        inputSchema: {
-            lesson: z.string().min(12).max(4000),
-            title: z.string().max(200).optional(),
-            collection: z.enum(["experience-behavioral", "experience-principles"]).optional(),
-            project: z.string().max(200).optional(),
-        },
-    }, async ({ lesson, title, collection, project }) => {
-        const trimmed = lesson.trim();
-        const text = trimmed.length > 1500 ? `${trimmed.slice(0, 1497)}...` : trimmed;
-        const targetCollection = collection ?? "experience-behavioral";
-        const write = deps.write ?? ((l, o) => import("../ee/search.js").then((m) => m.writeExperienceEE(l, o)));
-        try {
-            const result = await write(text, {
-                collection: targetCollection,
-                title,
-                projectSlug: project,
-                confidence: 0.65,
-            });
-            if (!result.ok)
-                return fail("write_failed", result.error ?? "import-memory POST failed");
-            return ok({ ok: true, id: result.id, collection: targetCollection, recallable: "now via ee_query" });
-        }
-        catch (e) {
-            return fail("write_failed", e instanceof Error ? e.message : String(e));
-        }
-    });
-}
-//# sourceMappingURL=ee-tools.js.map