plasalid 0.7.1 → 0.7.2

package/dist/scanner/workers/chunkWorker.js

@@ -0,0 +1,65 @@
+import { randomUUID } from "crypto";
+import { runScanAgent } from "../../ai/agent.js";
+import { buildDocumentBlock } from "../pdf.js";
+/**
+ * Process one chunk: run the LLM scan agent over a single-page PDF blob with
+ * the shared Buffer + chunkId injected. The agent's `record_transactions`
+ * calls land in the shared buffer; events fan out to the auditor and the
+ * dashboard.
+ */
+export async function runChunkWorker(deps, hooks) {
+    const workerId = `cw:${randomUUID()}`;
+    hooks.onWorkerStart?.(workerId, deps.chunk);
+    const outcome = await tryParseChunk(deps);
+    hooks.onWorkerEnd?.(workerId, deps.chunk, outcome.ok);
+    if (!outcome.ok)
+        await recordChunkFailure(deps.buffer, deps.chunk, outcome.error);
+    return { workerId, ...outcome };
+}
+async function tryParseChunk(deps) {
+    try {
+        await runScanAgent({
+            db: deps.db,
+            initialMessages: [
+                {
+                    role: "user",
+                    content: [
+                        buildDocumentBlock(deps.chunk.bytes, deps.chunk.fileName, deps.chunk.mime),
+                        { type: "text", text: buildChunkPrompt(deps.chunk) },
+                    ],
+                },
+            ],
+            prompt: { fileName: deps.chunk.fileName },
+            agentCtx: {
+                interactive: false,
+                buffer: deps.buffer,
+                chunkId: deps.chunk.chunkId,
+            },
+        });
+        return { ok: true };
+    }
+    catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+async function recordChunkFailure(buffer, chunk, error) {
+    await buffer.appendUnknown({
+        chunkId: chunk.chunkId,
+        transaction_id: null,
+        account_id: null,
+        kind: "chunk_failed",
+        prompt: `Chunk ${chunk.fileName} p${chunk.pageNumber} failed to parse: ${error}.`,
+    });
+}
+function buildChunkPrompt(chunk) {
+    return [
+        `You are parsing page ${chunk.pageNumber} of ${chunk.totalPages} of ${chunk.fileName}.`,
+        ``,
+        `Steps:`,
+        `1. Call list_accounts to see what already exists.`,
+        `2. If this page reveals an account that isn't in the chart yet, call create_account once.`,
+        `3. For every transaction on this page, call record_transactions (plural) with all rows in one batch.`,
+        `4. If the first or last row looks incomplete (no date, or no amount column visible — the row likely continues onto an adjacent page), call note_unknown with kind="boundary_continuation" and the raw row text. Do NOT invent missing fields.`,
+        `5. When done with this page, call mark_file_scanned with a short summary.`,
+    ].join("\n");
+}

package/dist/scanner/workers/fileWorker.d.ts

@@ -0,0 +1,32 @@
+import type Database from "libsql";
+import { type ChunkWorkerDeps, type ChunkWorkerResult } from "./chunkWorker.js";
+import type { ScanBuffer } from "../buffer/types.js";
+import type { Chunk, ScanHooks } from "../engine/types.js";
+/**
+ * Strategy hook — pluggable parser for one chunk. Default is the LLM-driven
+ * runChunkWorker; tests and alternate flows (OCR-only, mock, dry-run) inject
+ * their own without modifying the file worker. Open for extension; closed
+ * for modification.
+ */
+export type ChunkWorkerFn = (deps: ChunkWorkerDeps, hooks: ScanHooks) => Promise<ChunkWorkerResult>;
+export interface FileWorkerDeps {
+    readonly db: Database.Database;
+    readonly buffer: ScanBuffer;
+    readonly fileId: string;
+    readonly chunks: readonly Chunk[];
+    readonly maxChunkWorkers: number;
+    /** Optional override; defaults to the LLM-backed runChunkWorker. */
+    readonly chunkWorkerFn?: ChunkWorkerFn;
+}
+export interface FileWorkerResult {
+    readonly workerId: string;
+    readonly fileId: string;
+    readonly ok: number;
+    readonly failed: number;
+}
+/**
+ * Process every chunk of one file in parallel up to `maxChunkWorkers`. The
+ * shared buffer + bus are dependency-injected; this function has no global
+ * state and never reaches outside its args.
+ */
+export declare function runFileWorker(deps: FileWorkerDeps, hooks: ScanHooks): Promise<FileWorkerResult>;

package/dist/scanner/workers/fileWorker.js

@@ -0,0 +1,22 @@
+import { randomUUID } from "crypto";
+import { runWithConcurrency } from "../concurrency.js";
+import { runChunkWorker } from "./chunkWorker.js";
+/**
+ * Process every chunk of one file in parallel up to `maxChunkWorkers`. The
+ * shared buffer + bus are dependency-injected; this function has no global
+ * state and never reaches outside its args.
+ */
+export async function runFileWorker(deps, hooks) {
+    const workerId = `fw:${randomUUID()}`;
+    const chunkFn = deps.chunkWorkerFn ?? runChunkWorker;
+    const tasks = deps.chunks.map(chunk => () => chunkFn({ db: deps.db, buffer: deps.buffer, chunk }, hooks));
+    const settled = await runWithConcurrency(tasks, deps.maxChunkWorkers);
+    let ok = 0, failed = 0;
+    for (const r of settled) {
+        if (!r.ok || !r.value.ok)
+            failed++;
+        else
+            ok++;
+    }
+    return { workerId, fileId: deps.fileId, ok, failed };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plasalid",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Plasalid — The Harness Layer for Personal Finance",
   "keywords": [
     "finance",