@djolex999/vir-cli 0.12.0 → 0.14.0

package/dist/cli.js

@@ -10,12 +10,15 @@ import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CONFIG_PATH, ConfigSchema, configExists, ensureVirDir, expandHome, loadConfig, saveConfig, } from "./config.js";
+import { CONFIG_PATH, maskSecret, ConfigSchema, configExists, ensureVirDir, expandHome, loadConfig, saveConfig, } from "./config.js";
 import { applyPlan, planUpdates } from "./claude/updater.js";
 import { detectDuplicates } from "./dedupe/detector.js";
 import { mergeNotes } from "./dedupe/merger.js";
 import { contradictionCheck, orphanCheck, stalenessCheck, } from "./lint/linter.js";
 import { runPipeline } from "./pipeline/run.js";
+import { categorizeTranscriptHead, classifyTranscript, estimateSessionCost, groupByProject, readTranscriptHead, } from "./pipeline/projects.js";
+import { persistProjectDecisions, promptProjectDecisions, } from "./cli/projectSelect.js";
+import { gatherProjectsReport } from "./cli/projects.js";
 import { scanSessions } from "./pipeline/scanner.js";
 import { parseSession } from "./pipeline/parser.js";
 import { scoreSession } from "./pipeline/filter.js";
@@ -27,7 +30,8 @@ import { computeCost } from "./cost/pricing.js";
 import { countByCategory, summarizeAll, summarizeProject, } from "./pipeline/summarizer.js";
 import { buildPeriodPrompt, estimatePeriodCostTokens, periodLabel, periodRange, selectNotesInPeriod, summarizePeriod, } from "./pipeline/periodSummary.js";
 import { embeddingForNote, isOllamaAvailable, } from "./search/embedder.js";
-import { search, vaultRoot } from "./search/retriever.js";
+import { acquireLock, LockHeldError, releaseLock } from "./pipeline/lock.js";
+import { search, searchWithOutcome, vaultRoot } from "./search/retriever.js";
 import { buildQueryResults, errorPayload } from "./output/json.js";
 import { synthesize } from "./search/synthesizer.js";
 import { runMcpServer } from "./mcp/server.js";
@@ -69,6 +73,8 @@ program
     .option("--yes", "Skip the cost confirmation prompt")
     .option("--force-model <model>", "Override the distill model for this run only: haiku | sonnet")
     .option("--dry-run", "Estimate per-session cost after filtering, then exit before any LLM call")
+    .option("--only <project>", "Restrict this run to a project (repeatable, never persisted)", (v, acc) => acc.concat(v), [])
+    .option("--exclude-project <project>", "Skip a project for this run only (repeatable, never persisted)", (v, acc) => acc.concat(v), [])
     .action(runAction(async (opts) => {
     const cfg = loadConfig();
     const daemon = opts.daemon === true;
@@ -87,19 +93,59 @@ program
         articlesOnly ||
         pdfsOnly ||
         dryRun;
-    const summary = await runPipeline(cfg, {
-        full: opts.full,
-        quiet: daemon,
-        logToFile: daemon,
-        rewriteOnly,
-        articlesOnly,
-        pdfsOnly,
-        forceDistillModel: opts.forceModel,
-        dryRun,
-        onConfirm: skipPrompt
-            ? undefined
-            : async (newCount) => confirmCostIfNeeded(cfg, newCount),
-    });
+    // Dry-run and rewrite-only never call the distiller — no lock needed,
+    // and they must not be blocked by (or block) a running pipeline.
+    const needsLock = !dryRun && !rewriteOnly;
+    if (needsLock) {
+        try {
+            acquireLock();
+        }
+        catch (err) {
+            if (err instanceof LockHeldError) {
+                console.error(chalk.yellow(err.message));
+                process.exitCode = 1;
+                return;
+            }
+            throw err;
+        }
+    }
+    // Interactivity for the undecided-projects triage is a TTY question,
+    // not a --yes question: --yes skips the COST prompt but a human at a
+    // terminal can still answer include/exclude. launchd/cron have no
+    // TTY, so the daemon path can never reach the prompt.
+    const canPromptProjects = process.stdin.isTTY === true && !daemon && !dryRun;
+    let summary;
+    try {
+        summary = await runPipeline(cfg, {
+            full: opts.full,
+            quiet: daemon,
+            logToFile: daemon,
+            rewriteOnly,
+            articlesOnly,
+            pdfsOnly,
+            forceDistillModel: opts.forceModel,
+            dryRun,
+            onlyProjects: opts.only?.length ? opts.only : undefined,
+            excludeProjects: opts.excludeProject?.length
+                ? opts.excludeProject
+                : undefined,
+            onUndecidedProjects: canPromptProjects
+                ? async (pending) => {
+                    const answers = await promptProjectDecisions(pending, cfg.projects, `${pending.length} project(s) have sessions awaiting a decision — select the ones vir should track`);
+                    persistProjectDecisions(answers);
+                    ui.row(ui.success(ui.CHECK), ui.text(`saved ${Object.keys(answers).length} project decision(s)`));
+                    return answers;
+                }
+                : undefined,
+            onConfirm: skipPrompt
+                ? undefined
+                : async (newCount) => confirmCostIfNeeded(cfg, newCount),
+        });
+    }
+    finally {
+        if (needsLock)
+            releaseLock();
+    }
     // Surface per-item distill failures via a non-zero exit so external
     // callers (and the user) don't get false "success" — the silent-success
     // bug that hid Kie's 200-with-error responses pre-0.7.2.
@@ -222,10 +268,11 @@ const schedule = program
     .description("Manage the background daemon (launchd / systemd / cron)");
 schedule
     .command("install")
-    .description("Install + start the scheduled daemon")
-    .action(runAction(async () => {
+    .description("Install the scheduled daemon (first run at the next interval)")
+    .option("--run-now", "Also kick off one run immediately after installing")
+    .action(runAction(async (opts) => {
     const cfg = loadConfig();
-    await installDaemon(cfg);
+    await installDaemon(cfg, { runNow: opts.runNow });
     const ds = await daemonStatus();
     console.log(chalk.green(`installed via ${ds.method}: ${ds.configPath ?? "(no path)"} (active=${ds.active})`));
 }));
@@ -777,19 +824,24 @@ program
         console.log(ui.text(question));
         ui.divider();
         ui.blank();
-        const ollamaUp = await isOllamaAvailable();
-        const sp = ui
-            .spinner(`searching vault (${ollamaUp ? "embeddings" : "tfidf"})`)
-            .start();
-        let hits;
+        // The label must reflect what actually served the results, so it can
+        // only be printed AFTER the search — the old up-front isOllamaAvailable
+        // label claimed "embeddings" even when the embed call failed and TF-IDF
+        // served the hits.
+        const sp = ui.spinner("searching vault").start();
+        let outcome;
         try {
-            hits = await search(cfg, db, question, 8);
+            outcome = await searchWithOutcome(cfg, db, question, 8);
             sp.stop();
         }
         catch (err) {
             sp.fail(ui.errorColor(err.message));
             return;
         }
+        const hits = outcome.hits;
+        if (outcome.degraded) {
+            ui.row(ui.warn(ui.WARN_GLYPH), ui.text(`embedding search failed — results are TF-IDF fallback (${outcome.embedError})`));
+        }
         if (hits.length === 0) {
             ui.row(ui.warn(ui.WARN_GLYPH), ui.text("no documents matched"));
             return;
@@ -798,7 +850,7 @@ program
         ui.blank();
         console.log(ui.text(ui.wrap(answer.trim(), 60)));
         ui.blank();
-        const method = hits[0]?.method ?? "tfidf";
+        const method = outcome.method;
         const relevant = hits.filter((h) => h.score > 0).slice(0, 3);
         ui.divider();
         for (const h of relevant)
@@ -809,7 +861,10 @@ program
             : new VaultWriter(cfg).noteCount();
         ui.summary({
             sources: { value: relevant.length, color: ui.info },
-            via: { value: method, color: ui.accent },
+            via: {
+                value: outcome.degraded ? "tfidf (embeddings failed)" : method,
+                color: outcome.degraded ? ui.warn : ui.accent,
+            },
             searched: { value: totalNotes, color: ui.muted },
         });
     }
@@ -906,6 +961,70 @@ program
         db.close();
     }
 }));
+const projectsCmd = program
+    .command("projects")
+    .description("Per-project distillation decisions: table + include/exclude");
+projectsCmd
+    .option("--json", "Machine-readable output")
+    .action(runAction(async (opts) => {
+    const cfg = loadConfig();
+    const rows = gatherProjectsReport(cfg);
+    if (opts.json === true) {
+        process.stdout.write(JSON.stringify(rows.map(({ pendingPaths: _pendingPaths, ...r }) => r), null, 2) + "\n");
+        return;
+    }
+    ui.header("projects");
+    ui.blank();
+    if (rows.length === 0) {
+        ui.line(ui.dim("  no projects found under the Claude projects dir"));
+        return;
+    }
+    const nameW = Math.min(Math.max(...rows.map((r) => r.name.length), 7), 44);
+    ui.line(ui.dim(`  ${"project".padEnd(nameW)}  decision   sessions  distilled  pending  excluded  est. pending`));
+    for (const r of rows) {
+        const decision = r.decision === "include"
+            ? ui.success("include  ")
+            : r.decision === "exclude"
+                ? ui.dim("exclude  ")
+                : ui.warn("undecided");
+        const nestedParts = [
+            ...(r.workflowSessions > 0 ? [`+${r.workflowSessions} workflow`] : []),
+            ...(r.sidechainSessions > 0
+                ? [`+${r.sidechainSessions} sidechain`]
+                : []),
+            ...(r.agentSessions > 0 ? [`+${r.agentSessions} agent`] : []),
+        ];
+        const nestedNote = nestedParts.length > 0 ? ui.dim(`  (${nestedParts.join(", ")})`) : "";
+        ui.line(`  ${ui.text(r.name.padEnd(nameW))}  ${decision}  ${String(r.sessions).padStart(8)}  ${String(r.distilled).padStart(9)}  ${String(r.pending).padStart(7)}  ${String(r.excluded).padStart(8)}  ${r.pending > 0 ? ui.warn(ui.formatUsd(r.estPendingCost).padStart(12)) : ui.dim("—".padStart(12))}${nestedNote}`);
+    }
+    const pending = rows.filter((r) => r.decision === "undecided" && r.pending > 0);
+    if (pending.length > 0) {
+        ui.blank();
+        ui.line(ui.dim(`  ${pending.length} project(s) undecided — vir projects include|exclude <name>, or answer the prompt on the next interactive vir run`));
+    }
+}));
+async function cmdProjectDecision(name, decision) {
+    const cfg = loadConfig();
+    const rows = gatherProjectsReport(cfg);
+    const known = rows.find((r) => r.name === name);
+    if (!known) {
+        console.error(chalk.red(`unknown project '${name}' — seen projects: ${rows.map((r) => r.name).join(", ") || "(none)"}`));
+        process.exitCode = 1;
+        return;
+    }
+    persistProjectDecisions({ [name]: decision });
+    ui.row(ui.success(ui.CHECK), ui.text(decision === "include"
+        ? `${name} will be distilled from the next run (${known.pending} session(s) pending)`
+        : `${name} excluded — forward-looking only; already-distilled notes stay in the vault`));
+}
+projectsCmd
+    .command("include <name>")
+    .description("Track a project's sessions from now on")
+    .action(runAction(async (name) => cmdProjectDecision(name, "include")));
+projectsCmd
+    .command("exclude <name>")
+    .description("Stop tracking a project (existing notes are untouched)")
+    .action(runAction(async (name) => cmdProjectDecision(name, "exclude")));
 program
     .command("status")
     .description("Show processing status + knowledge base breakdown")
@@ -937,9 +1056,14 @@ program
     .description("Retry sessions that silently failed pre-0.7.2 (null/empty content despite skipped=0)")
     .option("--dry-run", "Report recoverable count + estimated cost + false-cost collateral; exit before any LLM call")
     .option("--yes", "Skip the cost confirmation prompt")
+    .option("--force", "Also retry retry-exhausted sessions (3+ consecutive failed distills)")
     .action(runAction(async (opts) => {
     const cfg = loadConfig();
-    await runReconcile(cfg, { dryRun: opts.dryRun, yes: opts.yes });
+    await runReconcile(cfg, {
+        dryRun: opts.dryRun,
+        yes: opts.yes,
+        force: opts.force,
+    });
 }));
 program
     .command("review")
@@ -1227,30 +1351,36 @@ async function cmdInit() {
         default: existing?.provider ?? "anthropic",
         choices: [
             {
-                name: "Anthropic  (direct, official pricing)",
+                name: "Anthropic  (direct + reliable, official pricing — recommended)",
                 value: "anthropic",
             },
             {
-                name: "Kie.ai     (same Claude models, ~72% cheaper)",
+                name: "Kie.ai     (~72% cheaper, third-party proxy — you trade reliability for cost)",
                 value: "kie",
             },
         ],
     }));
+    // Secret prompt discipline: mask while typing, echo only a masked
+    // confirmation (maskSecret), and NEVER render the existing key as the
+    // visible inquirer default — that prints the full secret to the terminal
+    // before a single keystroke. Empty input keeps the existing/env key.
+    const promptSecret = async (message, keep, validate) => {
+        const value = await input({
+            message: keep
+                ? `${message} (Enter keeps ${maskSecret(keep)})`
+                : message,
+            transformer: (v, { isFinal }) => isFinal ? maskSecret(v || keep || "") : "•".repeat(v.length),
+            validate: (v) => (v === "" && keep ? true : validate(v)),
+        });
+        return value === "" && keep ? keep : value;
+    };
     let anthropicApiKey;
     let kieApiKey;
     if (provider === "anthropic") {
-        anthropicApiKey = await input({
-            message: "Anthropic API key",
-            default: existing?.anthropicApiKey ?? process.env.ANTHROPIC_API_KEY ?? "",
-            validate: (v) => v.startsWith("sk-ant-") ? true : "key should start with sk-ant-",
-        });
+        anthropicApiKey = await promptSecret("Anthropic API key", existing?.anthropicApiKey ?? process.env.ANTHROPIC_API_KEY ?? undefined, (v) => (v.startsWith("sk-ant-") ? true : "key should start with sk-ant-"));
     }
     else {
-        kieApiKey = await input({
-            message: "Kie.ai API key",
-            default: existing?.kieApiKey ?? process.env.KIE_API_KEY ?? "",
-            validate: (v) => v.length > 10 ? true : "enter a valid Kie.ai API key",
-        });
+        kieApiKey = await promptSecret("Kie.ai API key", existing?.kieApiKey ?? process.env.KIE_API_KEY ?? undefined, (v) => (v.length > 10 ? true : "enter a valid Kie.ai API key"));
     }
     // ── model pickers (provider-aware) ──────────────────────────────────────
     const classifyChoices = provider === "anthropic"
@@ -1275,9 +1405,10 @@ async function cmdInit() {
     const distillChoices = provider === "anthropic"
         ? [
             {
-                name: "claude-sonnet-4-6  (recommended)",
-                value: "claude-sonnet-4-6",
+                name: "claude-sonnet-5  (recommended)",
+                value: "claude-sonnet-5",
             },
+            { name: "claude-sonnet-4-6", value: "claude-sonnet-4-6" },
             {
                 name: "claude-haiku-4-5-20251001  (faster, cheaper)",
                 value: "claude-haiku-4-5-20251001",
@@ -1307,6 +1438,67 @@ async function cmdInit() {
                 : "must be between 0 and 1";
         },
     }));
+    // ── project triage (the primary decision point) ─────────────────────────
+    // Every project found under the Claude projects dir is shown once with its
+    // session count and rough cost; selected = include, unselected = exclude.
+    // Projects that appear later start undecided and trigger the run prompt.
+    let projectDecisions = {};
+    let agentTranscriptsAnswer;
+    try {
+        const projectsDirX = expandHome(claudeProjectsDir);
+        const allFound = scanSessions(projectsDirX);
+        // Triage counts + the agent-transcript question. Only top-level
+        // transcripts count (nested workflow/sidechain have their own filter),
+        // and agent transcripts are excluded from the per-project multi-select
+        // numbers so the costs shown reflect what would actually distill.
+        const topLevel = allFound.filter((s) => classifyTranscript(s.path, projectsDirX) === "session");
+        const counts = { interactive: 0, agent: 0, stub: 0 };
+        const agentPaths = new Set();
+        for (const s of topLevel) {
+            const cat = categorizeTranscriptHead(readTranscriptHead(s.path), s.size);
+            counts[cat] += 1;
+            if (cat === "agent")
+                agentPaths.add(s.path);
+        }
+        if (counts.agent > 0) {
+            ui.blank();
+            ui.line(ui.dim(`  ${counts.interactive} interactive · ${counts.agent} SDK-launched · ${counts.stub} stubs`));
+            agentTranscriptsAnswer = (await select({
+                message: "SDK-launched agent transcripts (review/verify harness output) — distill them?",
+                default: existing?.agentTranscripts ?? "exclude",
+                choices: [
+                    {
+                        name: "Exclude  (recommended — agent-internal execution, not your decisions)",
+                        value: "exclude",
+                    },
+                    { name: "Include  (distill them like any session)", value: "include" },
+                ],
+            }));
+        }
+        const found = agentTranscriptsAnswer !== "include"
+            ? topLevel.filter((s) => !agentPaths.has(s.path))
+            : topLevel;
+        const groups = [...groupByProject(found, projectsDirX).values()];
+        if (groups.length > 0) {
+            const classifyId = normalizeModelName(classifyModel, provider);
+            const distillId = normalizeModelName(distillModel, provider);
+            const infos = groups
+                .map((g) => ({
+                name: g.name,
+                sessionCount: g.sessions.length,
+                totalBytes: g.totalBytes,
+                estCost: g.sessions.reduce((sum, s) => sum +
+                    estimateSessionCost(provider, classifyId, distillId, s.size), 0),
+            }))
+                .sort((a, b) => b.estCost - a.estCost);
+            ui.blank();
+            ui.line(ui.dim("  Which projects should vir distill? Costs are rough upper bounds."));
+            projectDecisions = await promptProjectDecisions(infos, existing?.projects ?? {}, "Projects to track");
+        }
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`project scan failed (${err.message}) — you can decide later with vir projects`));
+    }
     const parsed = ConfigSchema.safeParse(buildInitConfig(existing, {
         vaultPath,
         outputDir,
@@ -1320,6 +1512,8 @@ async function cmdInit() {
         pdfsDir,
         classifyModel,
         distillModel,
+        projects: projectDecisions,
+        agentTranscripts: agentTranscriptsAnswer,
     }));
     if (!parsed.success) {
         console.error(chalk.red("invalid config:"));