plasalid 0.7.1 → 0.7.3

package/dist/cli/commands/scan.js

@@ -1,165 +1,236 @@
 import chalk from "chalk";
-import { runScan } from "../../scanner/pipeline.js";
+import { getDb } from "../../db/connection.js";
+import { runScan } from "../../scanner/engine.js";
 export async function runScanCommand(opts) {
-    if (opts.regex !== undefined) {
+    if (opts.regex) {
         try {
             new RegExp(opts.regex, "i");
         }
         catch (err) {
-            console.error(chalk.red(`Invalid regex: ${err.message}`));
+            console.error(chalk.red(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`));
             process.exitCode = 1;
             return;
         }
     }
-    const events = process.stdout.isTTY
-        ? await inkScanEvents(opts.parallel ?? 3)
-        : plainScanEvents();
-    const summary = await runScan({
+    const parallel = opts.parallel ?? 5;
+    const isTTY = !!process.stdout.isTTY;
+    const hooks = isTTY ? await buildTtyHooks() : buildPlainHooks();
+    const result = await runScan(getDb(), {
         regex: opts.regex,
         force: opts.force,
         interactive: true,
-        concurrency: opts.parallel,
-        events,
-    });
-    renderScanSummary(summary);
+        maxFileWorkers: parallel,
+    }, hooks);
+    renderSummary(result.state);
 }
-function logDecryptProgress(e) {
-    const marker = e.outcome === "decrypted" ? chalk.dim("·")
-        : e.outcome === "skipped" ? chalk.dim("•")
-            : chalk.red("✗");
-    console.log(`  ${marker} [${e.index + 1}/${e.total}] ${e.fileName} (${e.outcome})`);
-}
-/**
- * Hooks every mode shares: the decrypt phase, commit notice, and inspector
- * summary all render the same way in TTY and non-TTY runs. Each mode-specific
- * factory below spreads this base and overrides the scan-phase hooks
- * (`scanStart` / `scanProgress` / `scanEnd`) to render differently.
- *
- * Returns `Partial<ScanRunEvents>` because the scan-phase hooks are filled in
- * by the caller — composition, not inheritance.
- */
-function baseScanEvents() {
-    let decryptTotal = 0;
+/* TTY mode — Ink dashboard with one in-place row per file. */
+async function buildTtyHooks() {
+    const { render } = await import("ink");
+    const { createElement } = await import("react");
+    const { ScanDashboard, createScanDashboardController } = await import("../ink/ScanDashboard.js");
+    const controller = createScanDashboardController();
+    let inkInstance = null;
+    let unsubscribeProgress = null;
+    const chunkLookup = new Map();
     return {
-        decryptStart: (count) => {
-            decryptTotal = count;
-            if (count > 0)
-                console.log(chalk.dim(`Decrypting ${count} file(s)...`));
+        afterDecrypt: (s) => {
+            const total = s.decrypted.length + s.skipped.length + s.failed.length;
+            if (total === 0) {
+                console.log(chalk.dim("No files to scan."));
+                return;
+            }
+            console.log(chalk.dim(`Decrypted ${s.decrypted.length}, skipped ${s.skipped.length}, failed ${s.failed.length}.`));
+        },
+        afterChunk: (s) => {
+            if (s.chunks.length === 0)
+                return;
+            console.log(chalk.dim(`Chunked into ${s.chunks.length} page(s). Mounting dashboard…`));
         },
-        decryptProgress: logDecryptProgress,
-        decryptDone: (e) => {
-            if (decryptTotal === 0)
+        beforeParse: (s) => {
+            for (const c of s.chunks)
+                chunkLookup.set(c.chunkId, {
+                    fileId: c.fileId,
+                    pageNumber: c.pageNumber,
+                });
+            if (s.decrypted.length === 0)
                 return;
-            console.log(chalk.dim(`Decrypted ${e.decrypted}, skipped ${e.skipped}, failed ${e.failed}.`));
+            process.stdout.write("\x1b[2J\x1b[H\x1b[?25l");
+            const files = s.decrypted.map((d) => ({
+                fileId: d.path,
+                fileName: d.fileName,
+                totalPages: s.chunks.filter((c) => c.fileId === d.path).length,
+            }));
+            inkInstance = render(createElement(ScanDashboard, {
+                controller,
+                files,
+            }), {
+                exitOnCtrlC: false,
+                patchConsole: false,
+            });
+            unsubscribeProgress = s.progress.subscribe((event) => {
+                const map = chunkLookup.get(event.chunkId);
+                if (!map)
+                    return;
+                controller.publish({
+                    type: event.kind === "tx" ? "chunk-tx" : "chunk-question",
+                    fileId: map.fileId,
+                    pageNumber: map.pageNumber,
+                });
+            });
         },
-        committing: () => { console.log(chalk.dim("Committing...")); },
-        inspecting: (r) => {
-            if (r.total > 0)
-                console.log(chalk.dim(`Inspectors flagged ${r.total} unknown(s).`));
+        onWorkerStart: (_id, chunk) => {
+            controller.publish({
+                type: "chunk-start",
+                fileId: chunk.fileId,
+                fileName: chunk.fileName,
+                pageNumber: chunk.pageNumber,
+                totalPages: chunk.totalPages,
+            });
+        },
+        onWorkerEnd: (_id, chunk, ok) => {
+            controller.publish({
+                type: "chunk-end",
+                fileId: chunk.fileId,
+                pageNumber: chunk.pageNumber,
+                ok,
+            });
+        },
+        afterParse: () => {
+            unsubscribeProgress?.();
+            unsubscribeProgress = null;
+        },
+        beforeClarify: () => {
+            controller.publish({ type: "phase-set", phase: "clarify" });
+        },
+        afterClarify: () => {
+            controller.publish({ type: "phase-set", phase: "done" });
+            inkInstance?.unmount();
+            inkInstance = null;
+            process.stdout.write("\x1b[?25h");
         },
     };
 }
-/** TTY mode: mount the Ink dashboard during the scan phase. */
-async function inkScanEvents(parallel) {
-    // Lazy-load ink + react so this module stays importable in non-TTY contexts.
-    const { render } = await import("ink");
-    const { createElement } = await import("react");
-    const { ScanDashboard, ScanDashboardController } = await import("../ink/scan_dashboard.js");
-    const controller = new ScanDashboardController();
-    let inkInstance = null;
-    let mountedFiles = 0;
-    const base = baseScanEvents();
+const FINALIZE_RULES = [
+    { when: (t) => t.failedChunks === 0, kind: "success" },
+    { when: (t) => t.failedChunks === t.totalChunks, kind: "all-failed" },
+    { when: () => true, kind: "partial" },
+];
+const FINALIZE_RENDER = {
+    success: (t) => `  ${chalk.green("ok")} ${t.fileName} ${chalk.dim(`${t.completedChunks} of ${t.totalChunks} pages · ${t.txAdded} transactions${t.questionsAdded > 0 ? `, ${t.questionsAdded} questions` : ""}`)}`,
+    "all-failed": (t) => `  ${chalk.red("fail")} ${t.fileName} ${chalk.dim("every chunk failed")}`,
+    partial: (t) => `  ${chalk.yellow("partial")} ${t.fileName} ${chalk.dim(`${t.completedChunks} of ${t.totalChunks} pages · ${t.failedChunks} chunks failed · ${t.txAdded} transactions`)}`,
+};
+function classifyFinalize(t) {
+    for (const r of FINALIZE_RULES)
+        if (r.when(t))
+            return r.kind;
+    return "partial";
+}
+function buildPlainHooks() {
+    const tallies = new Map();
+    const fileIdByChunkId = new Map();
+    let unsubscribeProgress = null;
+    const finalize = (fileId) => {
+        const t = tallies.get(fileId);
+        if (!t || t.completedChunks + t.failedChunks < t.totalChunks)
+            return;
+        console.log(FINALIZE_RENDER[classifyFinalize(t)](t));
+    };
     return {
-        ...base,
-        decryptDone: (e) => {
-            base.decryptDone?.(e);
-            console.log("");
-            mountedFiles = e.decrypted;
-            if (e.decrypted > 0) {
-                inkInstance = render(createElement(ScanDashboard, { controller, totalFiles: e.decrypted, parallel }));
+        afterDecrypt: (s) => {
+            const total = s.decrypted.length + s.skipped.length + s.failed.length;
+            if (total === 0) {
+                console.log("No files to scan.");
+                return;
             }
+            console.log(`Decrypted ${s.decrypted.length}, skipped ${s.skipped.length}, failed ${s.failed.length}.`);
         },
-        scanStart: (e) => controller.publish({ type: "scan-start", fileName: e.fileName }),
-        scanProgress: (e) => controller.publish({ type: "scan-progress", fileName: e.fileName, step: e.step }),
-        scanEnd: (e) => controller.publish({
-            type: "scan-end",
-            fileName: e.fileName,
-            status: e.status,
-            transactions: e.transactions,
-            unknowns: e.unknowns,
-            error: e.error,
-        }),
-        committing: () => {
-            if (inkInstance) {
-                inkInstance.unmount();
-                inkInstance = null;
-            }
-            if (mountedFiles > 0)
-                base.committing?.();
+        afterChunk: (s) => {
+            if (s.chunks.length > 0)
+                console.log(`Chunked into ${s.chunks.length} page(s).`);
         },
-    };
-}
-/** Non-TTY mode: print one line per file as it progresses. */
-function plainScanEvents() {
-    // De-dupe scan-progress chatter: only print when the step text changes per file.
-    const lastStepByFile = new Map();
-    return {
-        ...baseScanEvents(),
-        scanStart: (e) => {
-            console.log(`${chalk.cyan("→")} ${e.fileName} ${chalk.dim("starting...")}`);
+        beforeParse: (s) => {
+            for (const c of s.chunks)
+                fileIdByChunkId.set(c.chunkId, c.fileId);
+            unsubscribeProgress = s.progress.subscribe((event) => {
+                const fileId = fileIdByChunkId.get(event.chunkId);
+                if (!fileId)
+                    return;
+                const t = tallies.get(fileId);
+                if (!t)
+                    return;
+                if (event.kind === "tx")
+                    t.txAdded++;
+                else
+                    t.questionsAdded++;
+            });
+        },
+        onWorkerStart: (_id, chunk) => {
+            if (!tallies.has(chunk.fileId)) {
+                tallies.set(chunk.fileId, {
+                    fileName: chunk.fileName,
+                    totalChunks: chunk.totalPages,
+                    completedChunks: 0,
+                    failedChunks: 0,
+                    txAdded: 0,
+                    questionsAdded: 0,
+                });
+            }
         },
-        scanProgress: (e) => {
-            if (lastStepByFile.get(e.fileName) === e.step)
+        onWorkerEnd: (_id, chunk, ok) => {
+            const t = tallies.get(chunk.fileId);
+            if (!t)
                 return;
-            lastStepByFile.set(e.fileName, e.step);
-            console.log(chalk.dim(`    ${e.fileName} · ${e.step}`));
+            if (ok)
+                t.completedChunks++;
+            else
+                t.failedChunks++;
+            finalize(chunk.fileId);
         },
-        scanEnd: (e) => {
-            lastStepByFile.delete(e.fileName);
-            const line = e.status === "scanned"
-                ? `${chalk.green("✓")} ${e.fileName} ${chalk.dim(`(${e.transactions} transactions, ${e.unknowns} unknowns)`)}`
-                : `${chalk.red("✗")} ${e.fileName} ${chalk.dim(`— ${e.error ?? "failed"}`)}`;
-            console.log(line);
+        afterParse: () => {
+            unsubscribeProgress?.();
+            unsubscribeProgress = null;
+        },
+        beforeClarify: () => {
+            console.log("Clarifying...");
         },
     };
 }
-/** Terse summary */
-function renderScanSummary(summary) {
-    console.log("");
-    const headline = `Scanned ${summary.total} file(s) — ` +
-        `${summary.scanned + summary.replaced} ok, ` +
-        `${summary.failed} failed, ` +
-        `${summary.unknowns} unknown${summary.unknowns === 1 ? "" : "s"} flagged`;
-    console.log(chalk.bold(headline));
+function renderSummary(state) {
     console.log("");
-    for (const d of summary.details) {
-        const label = d.relPath;
-        switch (d.status) {
-            case "scanned": {
-                const tag = chalk.dim(`${d.transactions} transactions${d.unknowns > 0 ? ` · ${d.unknowns} unknowns` : ""}`);
-                console.log(`  ${chalk.green("✓")} ${label}  ${tag}`);
-                break;
-            }
-            case "replaced": {
-                const tag = chalk.dim(`${d.transactions} transactions${d.unknowns > 0 ? ` · ${d.unknowns} unknowns` : ""} (replaces prior)`);
-                console.log(`  ${chalk.cyan("↻")} ${label}  ${tag}`);
-                break;
-            }
-            case "skipped": {
-                console.log(`  ${chalk.dim("•")} ${label}  ${chalk.dim("(already scanned)")}`);
-                break;
-            }
-            case "failed": {
-                console.log(`  ${chalk.red("✗")} ${label}  ${chalk.dim(`— ${d.error ?? "failed"}`)}`);
-                break;
-            }
+    const txCount = countTransactions(state);
+    console.log(chalk.bold(`Scanned ${state.decrypted.length} file(s) → ${txCount} transactions.`));
+    const r = state.clarifySummary;
+    if (r && r.total > 0) {
+        console.log(`Clarified ${r.clarified}/${r.total} questions.`);
+        if (r.remaining > 0) {
+            console.log(chalk.yellow(`${r.remaining} question(s) remain — run ${chalk.cyan("plasalid clarify")} to finish them.`));
         }
     }
-    const newlyProcessed = summary.scanned + summary.replaced;
-    if (newlyProcessed > 0) {
+    if (state.errors.length > 0) {
+        console.log(chalk.yellow(`${state.errors.length} phase error(s):`));
+        for (const e of state.errors) {
+            console.log(chalk.dim(`  - [${e.phase}] ${e.target ?? ""} ${e.error?.message ?? ""}`));
+        }
+    }
+    if (txCount > 0) {
         console.log("");
-        console.log(`${chalk.dim("Next:")} ${chalk.cyan("plasalid resolve")}${chalk.dim(summary.unknowns > 0
-            ? " — to walk every open unknown and apply your decision."
-            : " — no unknowns surfaced this run; nothing to do.")}`);
+        console.log(`Next: run ${chalk.cyan("plasalid")} to chat with your ledger about what just landed.`);
     }
 }
+/**
+ * Snapshot transaction count attributable to this scan. Reads from
+ * scanned_files via the file ids assigned in decryptPhase.
+ */
+function countTransactions(state) {
+    const ids = state.decrypted
+        .map((d) => d.scannedFileId)
+        .filter((s) => !!s);
+    if (ids.length === 0)
+        return 0;
+    const placeholders = ids.map(() => "?").join(",");
+    const row = getDb()
+        .prepare(`SELECT COUNT(*) AS n FROM transactions WHERE source_file_id IN (${placeholders})`)
+        .get(...ids);
+    return row.n;
+}

package/dist/cli/commands/status.js

@@ -4,7 +4,7 @@ import { getNetWorth } from "../../db/queries/account-balance.js";
 import { countTransactions } from "../../db/queries/transactions.js";
 import { getRecurringSummary } from "../../db/queries/recurrences.js";
 import { countScannedFiles } from "../../db/queries/files.js";
-import { countOpenUnknowns } from "../../db/queries/unknowns.js";
+import { countQuestions } from "../../db/queries/questions.js";
 import { countMemories } from "../../ai/memory.js";
 import { formatAmount } from "../../currency.js";
 import { visibleLength } from "../format.js";
@@ -38,7 +38,7 @@ function systemRows(db) {
     const tx = countTransactions(db);
     const files = countScannedFiles(db);
     const memories = countMemories(db);
-    const unknowns = countOpenUnknowns(db);
+    const questions = countQuestions(db);
     const rows = [
         {
             label: "Transactions",
@@ -63,11 +63,11 @@ function systemRows(db) {
     if (memories > 0) {
         rows.push({ label: "Memories", value: formatInteger(memories) });
     }
-    if (unknowns > 0) {
+    if (questions > 0) {
         rows.push({
-            label: "Unknowns",
-            value: chalk.yellow(formatInteger(unknowns)),
-            suffix: chalk.dim("run `plasalid resolve`"),
+            label: "Questions",
+            value: chalk.yellow(formatInteger(questions)),
+            suffix: chalk.dim("run `plasalid clarify`"),
         });
     }
     return rows;

package/dist/cli/index.js

@@ -118,23 +118,6 @@ program
     const { runScanCommand } = await import("./commands/scan.js");
     await runScanCommand({ regex: regexes[0], force: !!opts.force, parallel });
 });
-program
-    .command("resolve")
-    .description("Walk every open unknown from the last scan one at a time and apply your decision (categorize, merge duplicates, link recurrences, skip).")
-    .option("-a, --account <id>", "Limit to unknowns attached to a single account")
-    .option("--from <date>", "Only consider entries on or after this date (YYYY-MM-DD)")
-    .option("--to <date>", "Only consider entries on or before this date (YYYY-MM-DD)")
-    .option("-k, --kind <kind>", "Filter by unknown kind (uncategorized_expense, duplicate, correlation, recurrence_candidate, similar_accounts)")
-    .action(async (opts) => {
-    ensureConfigured();
-    const { runResolveCommand } = await import("./commands/resolve.js");
-    await runResolveCommand({
-        accountId: opts.account,
-        from: opts.from,
-        to: opts.to,
-        kind: opts.kind,
-    });
-});
 program
     .command("rules")
     .description("List rules the system has learned")
@@ -152,12 +135,12 @@ program
     forgetRule(regex);
 });
 program
-    .command("revert <regex>")
-    .description("Delete scanned files matching <regex> and all their transactions")
-    .action(async (regex) => {
+    .command("clarify")
+    .description("Clarify every question across the ledger")
+    .action(async () => {
     ensureConfigured();
-    const { runRevertCommand } = await import("./commands/revert.js");
-    await runRevertCommand(regex);
+    const { runClarifyCommand } = await import("./commands/clarify.js");
+    await runClarifyCommand();
 });
 program.configureHelp({
     formatHelp: () => helpScreen([
@@ -170,7 +153,7 @@ program.configureHelp({
             desc: "Open the data folder in your OS file explorer (alias: open)",
         },
         { name: "accounts", desc: "Browse the chart of accounts (interactive TTY) or list them (piped)" },
-        { name: "status", desc: "Show financial and system status (net worth, recurring, unknowns)" },
+        { name: "status", desc: "Show financial and system status (net worth, recurring, questions)" },
         {
             name: "transactions",
             desc: "Browse transactions (interactive TTY) or list them (piped/--no-interactive)",
@@ -183,10 +166,6 @@ program.configureHelp({
             name: "scan",
             desc: "Scan new PDFs (optionally by regex; --force to re-scan)",
         },
-        {
-            name: "resolve",
-            desc: "Walk open unknowns one at a time and apply your decision",
-        },
         {
             name: "rules",
             desc: "List rules the system has learned",
@@ -196,8 +175,8 @@ program.configureHelp({
             desc: "Delete learned rules whose ids match <regex> (anchored)",
         },
         {
-            name: "revert",
-            desc: "Delete scanned files matching <regex> and their transactions",
+            name: "clarify",
+            desc: "Clarify every question across the ledger",
         },
     ]),
 });

package/dist/cli/ink/ScanDashboard.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Events the CLI publishes into the dashboard. The CLI subscribes to the
+ * scanner's ScanProgress sink and routes per-chunk ticks here via chunkLookup.
+ */
+export type CurrentPhase = "parse" | "clarify" | "done";
+export type DashboardEvent = {
+    type: "chunk-start";
+    fileId: string;
+    fileName: string;
+    pageNumber: number;
+    totalPages: number;
+} | {
+    type: "chunk-tx";
+    fileId: string;
+    pageNumber: number;
+} | {
+    type: "chunk-question";
+    fileId: string;
+    pageNumber: number;
+} | {
+    type: "chunk-end";
+    fileId: string;
+    pageNumber: number;
+    ok: boolean;
+} | {
+    type: "phase-set";
+    phase: CurrentPhase;
+};
+export interface ScanDashboardController {
+    publish(event: DashboardEvent): void;
+    subscribe(handler: (e: DashboardEvent) => void): () => void;
+}
+export declare function createScanDashboardController(): ScanDashboardController;
+export interface FileSeed {
+    readonly fileId: string;
+    readonly fileName: string;
+    readonly totalPages: number;
+}
+interface Props {
+    controller: ScanDashboardController;
+    files: ReadonlyArray<FileSeed>;
+}
+/**
+ * Tree-layout scan dashboard. Header carries the only animated element (one
+ * `<Spinner>`). All other status indicators are static glyphs that only
+ * redraw when their data changes.
+ */
+export declare function ScanDashboard(props: Props): import("react/jsx-runtime").JSX.Element;
+export {};