plasalid 0.7.9 → 0.8.1

package/dist/scanner/hooks.d.ts

@@ -19,5 +19,11 @@ export interface ScanHooks {
     beforeClarify?(s: Readonly<ScanState>): MaybePromise<void>;
     afterClarify?(s: Readonly<ScanState>, summary: ClarifySummary): MaybePromise<void>;
     onError?(err: unknown, phase: PhaseName, s: Readonly<ScanState>): MaybePromise<void>;
+    /**
+     * Fired when an AbortSignal trip propagates out of any phase. The CLI uses
+     * this to unmount Ink and restore the cursor before runScan's promise
+     * settles. onFinish still fires after onAbort.
+     */
+    onAbort?(s: Readonly<ScanState>): MaybePromise<void>;
     onFinish?(s: Readonly<ScanState>): MaybePromise<void>;
 }

package/dist/scanner/parse.js

@@ -1,8 +1,8 @@
 import { runWithConcurrency } from "./concurrency.js";
 import { runScanWorker } from "./worker.js";
 import { errorMessage } from "./result.js";
-const DEFAULT_MAX_FILE_WORKERS = 5;
-const DEFAULT_MAX_SCAN_WORKERS_PER_FILE = 5;
+const MAX_FILE_WORKERS = 5;
+const MAX_SCAN_WORKERS_PER_FILE = 5;
 const HARD_CAP = 8;
 const clamp = (n, fallback) => Math.min(HARD_CAP, Math.max(1, n ?? fallback));
 /**
@@ -13,35 +13,47 @@ const clamp = (n, fallback) => Math.min(HARD_CAP, Math.max(1, n ?? fallback));
  */
 export async function parsePhase(db, state, hooks) {
     await hooks.beforeParse?.(state);
-    const maxFile = clamp(state.options.maxFileWorkers, DEFAULT_MAX_FILE_WORKERS);
-    const maxChunk = clamp(state.options.maxScanWorkersPerFile, DEFAULT_MAX_SCAN_WORKERS_PER_FILE);
+    const maxFile = clamp(state.options.maxFileWorkers, MAX_FILE_WORKERS);
+    const maxChunk = clamp(state.options.maxScanWorkersPerFile, MAX_SCAN_WORKERS_PER_FILE);
     const fileGroups = state.decrypted
-        .map(file => ({
+        .map((file) => ({
         fileId: file.path,
         scannedFileId: file.scannedFileId,
-        chunks: state.chunks.filter(c => c.fileId === file.path),
+        chunks: state.chunks.filter((c) => c.fileId === file.path),
     }))
-        .filter(g => g.chunks.length > 0);
-    const fileTasks = fileGroups.map(group => () => {
-        const chunkTasks = group.chunks.map(chunk => () => runScanWorker({
+        .filter((g) => g.chunks.length > 0);
+    const fileTasks = fileGroups.map((group) => () => {
+        const chunkTasks = group.chunks.map((chunk) => () => runScanWorker({
             db,
             scanId: state.scanId,
             scannedFileId: group.scannedFileId,
             progress: state.progress,
             chunk,
+            signal: state.signal,
         }, hooks));
-        return runWithConcurrency(chunkTasks, maxChunk);
+        return runWithConcurrency(chunkTasks, maxChunk, state.signal);
     });
-    const settled = await runWithConcurrency(fileTasks, maxFile);
+    const settled = await runWithConcurrency(fileTasks, maxFile, state.signal);
     for (let i = 0; i < settled.length; i++) {
         const r = settled[i];
-        if (!r.ok)
-            state.errors.push({ phase: "parse", target: fileGroups[i].fileId, error: errorMessage(r.error) });
+        if (r && !r.ok)
+            state.errors.push({
+                phase: "parse",
+                target: fileGroups[i].fileId,
+                error: errorMessage(r.error),
+            });
     }
-    for (const file of state.decrypted) {
-        if (!file.scannedFileId)
+    // Only flip files to "scanned" for groups that actually completed. On abort
+    // the pool leaves later groups unclaimed (their settled slot is undefined);
+    // those rows stay `pending` so a future re-scan can pick them up. Partial
+    // transactions already committed during the run stay (scanner is DB-direct).
+    for (let i = 0; i < fileGroups.length; i++) {
+        if (!settled[i])
             continue;
-        db.prepare(`UPDATE scanned_files SET status = 'scanned', scanned_at = datetime('now') WHERE id = ?`).run(file.scannedFileId);
+        const sfId = fileGroups[i].scannedFileId;
+        if (!sfId)
+            continue;
+        db.prepare(`UPDATE scanned_files SET status = 'scanned', scanned_at = datetime('now') WHERE id = ?`).run(sfId);
     }
     await hooks.afterParse?.(state);
 }

package/dist/scanner/pdf/pdf.d.ts

@@ -1,4 +1,5 @@
-import type { DocumentBlock } from "../../ai/provider.js";
+import type { DocumentBlock, ImageBlock, Provider } from "../../ai/provider.js";
+import type { Chunk } from "../engine.js";
 export interface LoadedFile {
     bytes: Buffer;
     hash: string;
@@ -13,5 +14,5 @@ export interface LoadedFile {
  * recognize the same file across re-scans regardless of unlock state.
  */
 export declare function readPdf(path: string): LoadedFile;
-/** Build an Anthropic-compatible document content block from PDF bytes. */
 export declare function buildDocumentBlock(bytes: Buffer, fileName: string, mime?: string): DocumentBlock;
+export declare function buildScanAttachment(chunk: Chunk, provider: Provider): Promise<DocumentBlock | ImageBlock>;

package/dist/scanner/pdf/pdf.js

@@ -1,6 +1,7 @@
 import { readFileSync, statSync } from "fs";
 import { createHash } from "crypto";
 import { basename, extname } from "path";
+import { rasterizePage } from "./rasterize.js";
 const MIME_BY_EXT = {
     ".pdf": "application/pdf",
 };
@@ -26,7 +27,6 @@ export function readPdf(path) {
     const hash = createHash("sha256").update(bytes).digest("hex");
     return { bytes, hash, mime, fileName: basename(path) };
 }
-/** Build an Anthropic-compatible document content block from PDF bytes. */
 export function buildDocumentBlock(bytes, fileName, mime = "application/pdf") {
     return {
         type: "document",
@@ -34,3 +34,13 @@ export function buildDocumentBlock(bytes, fileName, mime = "application/pdf") {
         title: fileName,
     };
 }
+export async function buildScanAttachment(chunk, provider) {
+    if (provider.acceptsDocuments) {
+        return buildDocumentBlock(chunk.bytes, chunk.fileName, chunk.mime);
+    }
+    const { bytes, mime } = await rasterizePage(chunk.bytes);
+    return {
+        type: "image",
+        source: { type: "base64", media_type: mime, data: bytes.toString("base64") },
+    };
+}

package/dist/scanner/pdf/rasterize.d.ts

@@ -0,0 +1,6 @@
+export declare function rasterizePage(pdfBytes: Buffer, opts?: {
+    dpi?: number;
+}): Promise<{
+    bytes: Buffer;
+    mime: "image/png";
+}>;

package/dist/scanner/pdf/rasterize.js

@@ -0,0 +1,36 @@
+let mupdfPromise = null;
+function getMupdf() {
+    if (!mupdfPromise)
+        mupdfPromise = import("mupdf");
+    return mupdfPromise;
+}
+/**
+ * 150 DPI keeps statement numerals readable to a VL model without blowing
+ * up the token bill on a dense page.
+ */
+const DEFAULT_DPI = 150;
+export async function rasterizePage(pdfBytes, opts = {}) {
+    const mupdf = await getMupdf();
+    const dpi = opts.dpi ?? DEFAULT_DPI;
+    const scale = dpi / 72;
+    const doc = mupdf.Document.openDocument(pdfBytes, "application/pdf");
+    try {
+        const page = doc.loadPage(0);
+        try {
+            const pixmap = page.toPixmap(mupdf.Matrix.scale(scale, scale), mupdf.ColorSpace.DeviceRGB, false);
+            try {
+                const png = pixmap.asPNG();
+                return { bytes: Buffer.from(png), mime: "image/png" };
+            }
+            finally {
+                pixmap.destroy();
+            }
+        }
+        finally {
+            page.destroy();
+        }
+    }
+    finally {
+        doc.destroy();
+    }
+}

package/dist/scanner/worker.d.ts

@@ -8,6 +8,7 @@ export interface ScanWorkerDeps {
     readonly scannedFileId: string | undefined;
     readonly progress: ScanProgress;
     readonly chunk: Chunk;
+    readonly signal: AbortSignal;
 }
 /**
  * Process one chunk: run the LLM scan agent over a single-page PDF blob with
@@ -15,5 +16,10 @@ export interface ScanWorkerDeps {
  * context. Agent's record_transactions / note_question calls write directly to
  * the DB; per-row ticks fan out via `progress.emit`. Failures land in the DB
  * as a `chunk_failed` question so the clarifier can pick them up.
+ *
+ * Cancellation entry point: the worker pool stops claiming new chunks when
+ * `signal` aborts; in-flight provider calls abort natively via the SDK and
+ * surface as a failed tryExecute outcome — we suppress the chunk_failed row
+ * in that case (see below) since cancellation isn't a real failure.
  */
 export declare function runScanWorker(deps: ScanWorkerDeps, hooks: ScanHooks): Promise<void>;

package/dist/scanner/worker.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "crypto";
 import { runScanAgent } from "../ai/agent.js";
+import { getProvider } from "../ai/providers/index.js";
 import { recordQuestion } from "../db/queries/questions.js";
-import { buildDocumentBlock } from "./pdf/pdf.js";
+import { buildScanAttachment } from "./pdf/pdf.js";
 import { tryExecute } from "./result.js";
 /**
  * Process one chunk: run the LLM scan agent over a single-page PDF blob with
@@ -9,17 +10,23 @@ import { tryExecute } from "./result.js";
  * context. Agent's record_transactions / note_question calls write directly to
  * the DB; per-row ticks fan out via `progress.emit`. Failures land in the DB
  * as a `chunk_failed` question so the clarifier can pick them up.
+ *
+ * Cancellation entry point: the worker pool stops claiming new chunks when
+ * `signal` aborts; in-flight provider calls abort natively via the SDK and
+ * surface as a failed tryExecute outcome — we suppress the chunk_failed row
+ * in that case (see below) since cancellation isn't a real failure.
  */
 export async function runScanWorker(deps, hooks) {
     const workerId = `cw:${randomUUID()}`;
     hooks.onWorkerStart?.(workerId, deps.chunk);
+    const attachment = await buildScanAttachment(deps.chunk, getProvider());
     const outcome = await tryExecute(() => runScanAgent({
         db: deps.db,
         initialMessages: [
             {
                 role: "user",
                 content: [
-                    buildDocumentBlock(deps.chunk.bytes, deps.chunk.fileName, deps.chunk.mime),
+                    attachment,
                     { type: "text", text: buildChunkPrompt(deps.chunk) },
                 ],
             },
@@ -32,10 +39,16 @@ export async function runScanWorker(deps, hooks) {
             chunkId: deps.chunk.chunkId,
             progress: deps.progress,
         },
+        signal: deps.signal,
     }));
     hooks.onWorkerEnd?.(workerId, deps.chunk, outcome.ok);
-    if (!outcome.ok)
+    if (!outcome.ok) {
+        // A worker whose in-flight call was cancelled by Ctrl+C is not a real
+        // failure — don't pollute the questions table with chunk_failed rows.
+        if (deps.signal.aborted)
+            return;
         recordChunkFailure(deps, outcome.error);
+    }
 }
 function recordChunkFailure(deps, error) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plasalid",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "description": "Plasalid — The Harness Layer for Personal Finance",
   "keywords": [
     "finance",
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
+    "@google/genai": "^2.6.0",
     "chalk": "^5.3.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.0",