plasalid 0.2.0

package/dist/ai/tools.js

@@ -0,0 +1,402 @@
+import { randomUUID } from "crypto";
+import { saveMemory, getMemories } from "./memory.js";
+import { getAccountBalances, findAccountById, getNetWorth, getPeriodTotals, } from "../db/queries/account_balance.js";
+import { listJournalLines, recordJournalEntry } from "../db/queries/journal.js";
+import { searchJournalLines } from "../db/queries/search.js";
+import { formatCurrencyAmount } from "../currency.js";
+import { sanitizeForPrompt, sanitizeForPromptCell } from "./sanitize.js";
+import { ALL_THAI_INSTITUTIONS, ACCOUNT_TYPE_DESCRIPTIONS, SUGGESTED_EXPENSE_SUBTYPES, SUGGESTED_INCOME_SUBTYPES, } from "../accounts/taxonomy.js";
+const ACCOUNT_TYPES = Object.keys(ACCOUNT_TYPE_DESCRIPTIONS);
+const COMMON_TOOLS = [
+    {
+        name: "list_accounts",
+        description: "List accounts in the chart of accounts, optionally filtered by type.",
+        input_schema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ACCOUNT_TYPES, description: "Filter by account type." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "save_memory",
+        description: "Persist a fact or bank-specific scanning hint to long-term memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                content: { type: "string", description: "What to remember." },
+                category: { type: "string", description: "Category: general, scanning_hint, preference, life_event.", default: "general" },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "get_memories",
+        description: "Retrieve all saved long-term memories.",
+        input_schema: { type: "object", properties: {}, required: [] },
+    },
+];
+const SCAN_TOOLS = [
+    ...COMMON_TOOLS,
+    {
+        name: "create_account",
+        description: "Create a new account in the chart of accounts when a statement reveals one that doesn't exist yet. Use a stable id like 'asset:kbank-savings-1234'.",
+        input_schema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Stable identifier, lowercase, colon-separated. e.g. 'asset:kbank-savings-1234'." },
+                name: { type: "string", description: "Human-readable name. e.g. 'KBank Savings ••1234'." },
+                type: { type: "string", enum: ACCOUNT_TYPES, description: "Account type." },
+                subtype: { type: "string", description: "e.g. 'bank', 'credit_card', 'salary', 'food'." },
+                bank_name: { type: "string", description: "Thai institution code from the taxonomy (e.g. KBANK, SCB, KTC)." },
+                account_number_masked: { type: "string", description: "Last 4 digits only, e.g. '••1234'." },
+                currency: { type: "string", description: "ISO 4217 code. Defaults to 'THB'.", default: "THB" },
+                due_day: { type: "number", description: "Credit-card due day of month (liabilities only)." },
+                statement_day: { type: "number", description: "Statement-cut day of month." },
+                metadata: { type: "object", description: "Free-form extra fields (e.g. {points_program: 'KTC Forever'})." },
+            },
+            required: ["id", "name", "type"],
+        },
+    },
+    {
+        name: "update_account_metadata",
+        description: "Update account metadata (due day, statement day, points balance, masked number, bank).",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string" },
+                due_day: { type: "number" },
+                statement_day: { type: "number" },
+                points_balance: { type: "number" },
+                account_number_masked: { type: "string" },
+                bank_name: { type: "string" },
+                metadata: { type: "object", description: "Merged into existing metadata_json." },
+            },
+            required: ["account_id"],
+        },
+    },
+    {
+        name: "record_journal_entry",
+        description: "Post a balanced double-entry journal entry. The sum of debits MUST equal the sum of credits (within one currency). Convert Buddhist-Era dates by subtracting 543. Every line carries an ISO 4217 currency code (THB, USD, EUR, …); default to THB. Use the account's currency where set; only deviate when the source row is explicitly in another currency.",
+        input_schema: {
+            type: "object",
+            properties: {
+                date: { type: "string", description: "ISO Gregorian date (YYYY-MM-DD)." },
+                description: { type: "string", description: "Short human-readable description of the entry." },
+                source_page: { type: "number", description: "Page number in the source PDF, if known." },
+                lines: {
+                    type: "array",
+                    description: "Two or more journal lines that balance.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            account_id: { type: "string", description: "Existing account id from list_accounts or create_account." },
+                            debit: { type: "number", description: "Debit amount in this line's currency. Use 0 if this line is a credit." },
+                            credit: { type: "number", description: "Credit amount in this line's currency. Use 0 if this line is a debit." },
+                            currency: { type: "string", description: "ISO 4217 currency code for this line (e.g. THB, USD, EUR). Defaults to THB.", default: "THB" },
+                            memo: { type: "string", description: "Optional per-line memo." },
+                        },
+                        required: ["account_id"],
+                    },
+                },
+            },
+            required: ["date", "description", "lines"],
+        },
+    },
+    {
+        name: "ask_user",
+        description: "Ask the user a clarifying question when you cannot confidently scan the document. The pipeline pauses the file and prompts the user interactively when running `plasalid scan`.",
+        input_schema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The question to ask in plain language." },
+                options: {
+                    type: "array",
+                    description: "Optional list of candidate answers.",
+                    items: { type: "string" },
+                },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "mark_file_scanned",
+        description: "Call this once the file is fully processed and all journal entries are posted. Summary text is shown to the user.",
+        input_schema: {
+            type: "object",
+            properties: {
+                summary: { type: "string", description: "Short summary of what was recorded." },
+            },
+            required: ["summary"],
+        },
+    },
+];
+const CHAT_TOOLS = [
+    ...COMMON_TOOLS,
+    {
+        name: "get_account_balance",
+        description: "Get balance for a single account by id.",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string" },
+            },
+            required: ["account_id"],
+        },
+    },
+    {
+        name: "get_net_worth",
+        description: "Compute current net worth: total assets minus total liabilities.",
+        input_schema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "list_journal_entries",
+        description: "List journal lines filtered by account and/or date range.",
+        input_schema: {
+            type: "object",
+            properties: {
+                account_id: { type: "string" },
+                from: { type: "string", description: "Start date YYYY-MM-DD" },
+                to: { type: "string", description: "End date YYYY-MM-DD" },
+                q: { type: "string", description: "Free-text contains-match on description or memo" },
+                limit: { type: "number", description: "Max results (default 50)" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "search_transactions",
+        description: "Free-text search across journal entry descriptions, line memos, and account names.",
+        input_schema: {
+            type: "object",
+            properties: {
+                query: { type: "string" },
+                limit: { type: "number", default: 30 },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_period_totals",
+        description: "Get total income and total expense in a date range. Useful for monthly summaries.",
+        input_schema: {
+            type: "object",
+            properties: {
+                from: { type: "string", description: "Start date YYYY-MM-DD" },
+                to: { type: "string", description: "End date YYYY-MM-DD" },
+            },
+            required: ["from", "to"],
+        },
+    },
+];
+export function getToolDefinitions(profile) {
+    return profile === "scan" ? SCAN_TOOLS : CHAT_TOOLS;
+}
+/** Human-readable labels shown in the spinner. */
+export const TOOL_LABELS = {
+    list_accounts: "Listing accounts",
+    create_account: "Creating account",
+    update_account_metadata: "Updating account metadata",
+    record_journal_entry: "Posting journal entry",
+    ask_user: "Asking for clarification",
+    save_memory: "Saving memory",
+    get_memories: "Recalling memories",
+    mark_file_scanned: "Finalizing file",
+    get_account_balance: "Looking up balance",
+    get_net_worth: "Computing net worth",
+    list_journal_entries: "Listing journal entries",
+    search_transactions: "Searching transactions",
+    get_period_totals: "Summing period totals",
+};
+function formatTHB(amount) {
+    return formatCurrencyAmount(amount, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+export async function executeTool(db, toolName, toolInput, ctx) {
+    switch (toolName) {
+        case "list_accounts": {
+            const accounts = getAccountBalances(db, toolInput?.type ? { type: toolInput.type } : {});
+            if (accounts.length === 0)
+                return "No accounts in the chart of accounts yet.";
+            return accounts
+                .map(a => {
+                const meta = [];
+                if (a.bank_name)
+                    meta.push(sanitizeForPrompt(a.bank_name));
+                if (a.account_number_masked)
+                    meta.push(sanitizeForPrompt(a.account_number_masked));
+                if (a.due_day)
+                    meta.push(`due day ${a.due_day}`);
+                if (a.points_balance)
+                    meta.push(`${a.points_balance} pts`);
+                const metaStr = meta.length ? ` [${meta.join(" · ")}]` : "";
+                return `${a.id} | ${sanitizeForPromptCell(a.name)} | ${a.type}${a.subtype ? `/${a.subtype}` : ""} | balance ${formatTHB(a.balance)}${metaStr}`;
+            })
+                .join("\n");
+        }
+        case "get_account_balance": {
+            const acct = findAccountById(db, toolInput.account_id);
+            if (!acct)
+                return `Account "${toolInput.account_id}" not found.`;
+            const balances = getAccountBalances(db);
+            const match = balances.find(b => b.id === acct.id);
+            const bal = match?.balance ?? 0;
+            return `${sanitizeForPrompt(acct.name)} (${acct.type}): ${formatTHB(bal)}`;
+        }
+        case "get_net_worth": {
+            const nw = getNetWorth(db);
+            return `Net worth: ${formatTHB(nw.net_worth)} (assets ${formatTHB(nw.assets)} − liabilities ${formatTHB(nw.liabilities)})`;
+        }
+        case "list_journal_entries": {
+            const rows = listJournalLines(db, {
+                account_id: toolInput.account_id,
+                from: toolInput.from,
+                to: toolInput.to,
+                q: toolInput.q,
+                limit: toolInput.limit,
+            });
+            if (rows.length === 0)
+                return "No matching journal lines.";
+            return rows
+                .map(r => {
+                const dr = r.debit > 0 ? `DR ${formatTHB(r.debit)}` : "";
+                const cr = r.credit > 0 ? `CR ${formatTHB(r.credit)}` : "";
+                return `${r.entry_date} | ${sanitizeForPromptCell(r.entry_description)} | ${sanitizeForPromptCell(r.account_name || "")} | ${dr}${cr} | ${sanitizeForPromptCell(r.memo || "")}`;
+            })
+                .join("\n");
+        }
+        case "search_transactions": {
+            const rows = searchJournalLines(db, toolInput.query, toolInput.limit);
+            if (rows.length === 0)
+                return `No matches for "${sanitizeForPrompt(toolInput.query)}".`;
+            return rows
+                .map(r => {
+                const dr = r.debit > 0 ? `DR ${formatTHB(r.debit)}` : "";
+                const cr = r.credit > 0 ? `CR ${formatTHB(r.credit)}` : "";
+                return `${r.entry_date} | ${sanitizeForPromptCell(r.entry_description)} | ${sanitizeForPromptCell(r.account_name || "")} | ${dr}${cr}`;
+            })
+                .join("\n");
+        }
+        case "get_period_totals": {
+            const totals = getPeriodTotals(db, toolInput.from, toolInput.to);
+            return `Income ${formatTHB(totals.income)} · Expenses ${formatTHB(totals.expenses)} · Net ${formatTHB(totals.income - totals.expenses)}`;
+        }
+        case "save_memory": {
+            saveMemory(db, toolInput.content, toolInput.category || "general");
+            return `Saved memory: "${sanitizeForPrompt(toolInput.content)}"`;
+        }
+        case "get_memories": {
+            const memories = getMemories(db);
+            if (memories.length === 0)
+                return "No memories saved yet.";
+            return memories.map(m => `[${m.category}] ${sanitizeForPrompt(m.content)} (saved ${m.created_at})`).join("\n");
+        }
+        case "create_account": {
+            if (!ACCOUNT_TYPES.includes(toolInput.type)) {
+                return `Invalid type "${toolInput.type}". Allowed: ${ACCOUNT_TYPES.join(", ")}.`;
+            }
+            const knownCodes = new Set(ALL_THAI_INSTITUTIONS.map(i => i.code));
+            const bank = toolInput.bank_name ? String(toolInput.bank_name).toUpperCase() : null;
+            if (bank && !knownCodes.has(bank)) {
+                // Allow unknown institutions but flag them. The taxonomy is a hint, not a hard list.
+            }
+            try {
+                db.prepare(`INSERT INTO accounts (id, name, type, subtype, bank_name, account_number_masked, currency, due_day, statement_day, metadata_json)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(toolInput.id, toolInput.name, toolInput.type, toolInput.subtype || null, bank, toolInput.account_number_masked || null, toolInput.currency || "THB", toolInput.due_day ?? null, toolInput.statement_day ?? null, toolInput.metadata ? JSON.stringify(toolInput.metadata) : null);
+                return `Account created: ${toolInput.id} (${toolInput.name}, ${toolInput.type}).`;
+            }
+            catch (err) {
+                if (String(err.message).includes("UNIQUE")) {
+                    return `Account "${toolInput.id}" already exists. Use update_account_metadata to modify it.`;
+                }
+                throw err;
+            }
+        }
+        case "update_account_metadata": {
+            const acct = findAccountById(db, toolInput.account_id);
+            if (!acct)
+                return `Account "${toolInput.account_id}" not found.`;
+            const updates = [];
+            const params = [];
+            if (toolInput.due_day !== undefined) {
+                updates.push("due_day = ?");
+                params.push(toolInput.due_day);
+            }
+            if (toolInput.statement_day !== undefined) {
+                updates.push("statement_day = ?");
+                params.push(toolInput.statement_day);
+            }
+            if (toolInput.points_balance !== undefined) {
+                updates.push("points_balance = ?");
+                params.push(toolInput.points_balance);
+            }
+            if (toolInput.account_number_masked !== undefined) {
+                updates.push("account_number_masked = ?");
+                params.push(toolInput.account_number_masked);
+            }
+            if (toolInput.bank_name !== undefined) {
+                updates.push("bank_name = ?");
+                params.push(String(toolInput.bank_name).toUpperCase());
+            }
+            if (toolInput.metadata) {
+                const existing = acct.metadata_json ? JSON.parse(acct.metadata_json) : {};
+                const merged = { ...existing, ...toolInput.metadata };
+                updates.push("metadata_json = ?");
+                params.push(JSON.stringify(merged));
+            }
+            if (updates.length === 0)
+                return "Nothing to update.";
+            params.push(toolInput.account_id);
+            db.prepare(`UPDATE accounts SET ${updates.join(", ")} WHERE id = ?`).run(...params);
+            return `Updated ${toolInput.account_id}.`;
+        }
+        case "record_journal_entry": {
+            if (!ctx)
+                return "record_journal_entry is only available during scan runs.";
+            try {
+                const entryId = recordJournalEntry(db, {
+                    date: toolInput.date,
+                    description: toolInput.description,
+                    source_file_id: ctx.fileId,
+                    source_page: toolInput.source_page ?? null,
+                    scanner_version: ctx.scannerVersion,
+                    lines: (toolInput.lines || []).map((l) => ({
+                        account_id: l.account_id,
+                        debit: l.debit ?? 0,
+                        credit: l.credit ?? 0,
+                        currency: l.currency || "THB",
+                        memo: l.memo ?? null,
+                    })),
+                });
+                return `Posted journal entry ${entryId} (${toolInput.date}).`;
+            }
+            catch (err) {
+                return `Could not post journal entry: ${err.message}`;
+            }
+        }
+        case "ask_user": {
+            if (!ctx)
+                return "ask_user is only available during scan runs.";
+            const id = `pq:${randomUUID()}`;
+            db.prepare(`INSERT INTO pending_questions (id, file_id, prompt, options_json) VALUES (?, ?, ?, ?)`).run(id, ctx.fileId, toolInput.prompt, toolInput.options ? JSON.stringify(toolInput.options) : null);
+            if (ctx.interactive && ctx.promptUser) {
+                const answer = await ctx.promptUser(toolInput.prompt, toolInput.options);
+                db.prepare(`UPDATE pending_questions SET answer = ?, resolved_at = datetime('now') WHERE id = ?`).run(answer, id);
+                return `User answered: ${sanitizeForPrompt(answer)}`;
+            }
+            return `Question recorded for later (${id}). Treat the file as awaiting input — do not post journal entries that depend on this answer.`;
+        }
+        case "mark_file_scanned": {
+            ctx?.onMarkScanned?.(toolInput.summary || "");
+            return `Marked file as scanned. Summary: ${sanitizeForPrompt(toolInput.summary || "")}`;
+        }
+        default:
+            return `Unknown tool: ${toolName}`;
+    }
+}
+export function getTaxonomyHint() {
+    const banks = ALL_THAI_INSTITUTIONS.map(i => `${i.code} (${i.label}, ${i.kind})`).join("\n");
+    const expenses = SUGGESTED_EXPENSE_SUBTYPES.join(", ");
+    const incomes = SUGGESTED_INCOME_SUBTYPES.join(", ");
+    return `Known Thai institutions:\n${banks}\n\nSuggested expense subtypes: ${expenses}\nSuggested income subtypes: ${incomes}`;
+}

package/dist/cli/chat.d.ts

@@ -0,0 +1 @@
+export declare function startChat(): Promise<void>;

package/dist/cli/chat.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import { config } from "../config.js";
+import { banner } from "./format.js";
+import { printLogo } from "./logo.js";
+export async function startChat() {
+    const { getDb } = await import("../db/connection.js");
+    const db = getDb();
+    console.log("");
+    printLogo();
+    console.log("");
+    console.log(banner());
+    console.log("");
+    const accountCount = db
+        .prepare(`SELECT COUNT(*) AS n FROM accounts`)
+        .get();
+    if (accountCount.n === 0) {
+        console.log(chalk.yellow("No accounts scanned yet. Run `plasalid data` to drop your bank/credit card statements in, then run `plasalid scan`."));
+        console.log("");
+        console.log(chalk.dim("You can still chat, but I won't have any data to answer questions about."));
+        console.log("");
+    }
+    else {
+        console.log(chalk.dim(`Hi ${config.userName}. Ask me anything about your financial data.`));
+        console.log("");
+    }
+    const { runChatApp } = await import("./ink/mount.js");
+    await runChatApp({ db });
+}

package/dist/cli/commands/accounts.d.ts

@@ -0,0 +1 @@
+export declare function showAccounts(): void;

package/dist/cli/commands/accounts.js

@@ -0,0 +1,86 @@
+import chalk from "chalk";
+import { getDb } from "../../db/connection.js";
+import { getAccountBalances } from "../../db/queries/account_balance.js";
+import { formatCurrencyAmount } from "../../currency.js";
+function fmtSigned(n) {
+    const body = formatCurrencyAmount(n, {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    });
+    return n < 0 ? `-${body}` : body;
+}
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function visibleLength(s) {
+    return s.replace(ANSI_RE, "").length;
+}
+const TYPE_TAG = {
+    asset: "asset",
+    liability: "liab",
+    income: "income",
+    expense: "expense",
+    equity: "equity",
+};
+const TYPE_TAG_WIDTH = 8;
+const TYPE_RANK = {
+    asset: 0,
+    liability: 1,
+    income: 2,
+    expense: 3,
+    equity: 4,
+};
+function compactMeta(a) {
+    const meta = [];
+    if (a.bank_name)
+        meta.push(a.bank_name);
+    if (a.due_day)
+        meta.push(`due ${a.due_day}`);
+    if (a.statement_day)
+        meta.push(`stmt ${a.statement_day}`);
+    if (a.points_balance)
+        meta.push(`${a.points_balance.toLocaleString()} pts`);
+    if (a.currency && a.currency !== "THB")
+        meta.push(a.currency);
+    // Subtype only when there's no other signal yet (e.g. "cash", "salary").
+    if (meta.length === 0 && a.subtype)
+        meta.push(a.subtype);
+    return meta;
+}
+export function showAccounts() {
+    const db = getDb();
+    const accounts = [...getAccountBalances(db)].sort((a, b) => {
+        const t = TYPE_RANK[a.type] - TYPE_RANK[b.type];
+        return t !== 0 ? t : a.name.localeCompare(b.name);
+    });
+    if (accounts.length === 0) {
+        console.log(chalk.yellow("No accounts yet. Drop your bank/credit card statements into ~/.plasalid/data/ and run `plasalid scan`."));
+        return;
+    }
+    const balanceWidth = Math.max(...accounts.map((a) => fmtSigned(a.balance).length));
+    const nameWidth = Math.max(...accounts.map((a) => a.name.length));
+    for (const a of accounts) {
+        const tag = chalk.dim(TYPE_TAG[a.type].padEnd(TYPE_TAG_WIDTH));
+        const name = chalk.bold(a.name) + " ".repeat(nameWidth - a.name.length);
+        const rawBalance = fmtSigned(a.balance);
+        const coloredBalance = a.balance < 0 ? chalk.red(rawBalance) : rawBalance;
+        const paddedBalance = " ".repeat(balanceWidth - visibleLength(coloredBalance)) + coloredBalance;
+        const meta = compactMeta(a);
+        const metaStr = meta.length ? `   ${chalk.dim(meta.join(" · "))}` : "";
+        console.log(`  ${tag}  ${name}   ${paddedBalance}${metaStr}`);
+    }
+    let assets = 0, liabilities = 0;
+    for (const a of accounts) {
+        if (a.type === "asset")
+            assets += a.balance;
+        else if (a.type === "liability")
+            liabilities += a.balance;
+    }
+    const netWorth = assets - liabilities;
+    console.log("");
+    console.log("  " +
+        chalk.dim(`Assets ${fmtSigned(assets)}`) +
+        chalk.dim("   ·   ") +
+        chalk.dim(`Liabilities ${fmtSigned(liabilities)}`) +
+        chalk.dim("   ·   ") +
+        chalk.bold(`Net worth ${fmtSigned(netWorth)}`));
+}

package/dist/cli/commands/data.d.ts

@@ -0,0 +1 @@
+export declare function runDataCommand(): void;

package/dist/cli/commands/data.js

@@ -0,0 +1,28 @@
+import { spawn } from "child_process";
+import { existsSync, mkdirSync } from "fs";
+import chalk from "chalk";
+import { getDataDir } from "../../config.js";
+function openerCommand() {
+    switch (process.platform) {
+        case "darwin": return "open";
+        case "win32": return "explorer";
+        case "linux": return "xdg-open";
+        default: return null;
+    }
+}
+export function runDataCommand() {
+    const dataDir = getDataDir();
+    if (!existsSync(dataDir))
+        mkdirSync(dataDir, { recursive: true });
+    console.log(chalk.dim(`Data folder: ${dataDir}`));
+    const cmd = openerCommand();
+    if (!cmd) {
+        console.log(chalk.yellow(`Don't know how to open the file manager on ${process.platform}. Open it manually with the path above.`));
+        return;
+    }
+    const child = spawn(cmd, [dataDir], { stdio: "ignore", detached: true });
+    child.on("error", (err) => {
+        console.error(chalk.red(`Couldn't open the folder: ${err.message}`));
+    });
+    child.unref();
+}

package/dist/cli/commands/reconcile.d.ts

@@ -0,0 +1,2 @@
+import { type ReconcileOptions } from "../../reconciler/pipeline.js";
+export declare function runReconcileCommand(opts: ReconcileOptions): Promise<void>;

package/dist/cli/commands/reconcile.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { runReconcile } from "../../reconciler/pipeline.js";
+export async function runReconcileCommand(opts) {
+    try {
+        const result = await runReconcile(opts);
+        if (result.summary) {
+            console.log("");
+            console.log(chalk.bold(result.summary));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Reconcile failed: ${err.message}`));
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/revert.d.ts

@@ -0,0 +1 @@
+export declare function runRevertCommand(regex: string): Promise<void>;

package/dist/cli/commands/revert.js

@@ -0,0 +1,68 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { relative, sep } from "path";
+import { getDb } from "../../db/connection.js";
+import { getDataDir } from "../../config.js";
+import { compileMatcher } from "../../scanner/pipeline.js";
+function pathToRelPath(absolutePath) {
+    return relative(getDataDir(), absolutePath).split(sep).join("/");
+}
+function findRevertMatches(db, regex) {
+    const matcher = compileMatcher(regex);
+    const rows = db
+        .prepare(`SELECT id, path, scanned_at FROM scanned_files ORDER BY scanned_at DESC, created_at DESC`)
+        .all();
+    return rows
+        .map((r) => ({
+        id: r.id,
+        path: r.path,
+        relPath: pathToRelPath(r.path),
+        scannedAt: r.scanned_at,
+    }))
+        .filter((r) => matcher.test(r.relPath));
+}
+function deleteMatches(db, ids) {
+    if (ids.length === 0)
+        return 0;
+    const stmt = db.prepare(`DELETE FROM scanned_files WHERE id = ?`);
+    const tx = db.transaction(() => {
+        for (const id of ids)
+            stmt.run(id);
+    });
+    tx();
+    return ids.length;
+}
+export async function runRevertCommand(regex) {
+    if (!regex) {
+        console.error(chalk.red("revert requires a regex argument."));
+        process.exitCode = 1;
+        return;
+    }
+    let matches;
+    try {
+        matches = findRevertMatches(getDb(), regex);
+    }
+    catch (err) {
+        console.error(chalk.red(`Invalid regex: ${err.message}`));
+        process.exitCode = 1;
+        return;
+    }
+    if (matches.length === 0) {
+        console.log(chalk.dim("No scanned files match that regex."));
+        return;
+    }
+    console.log(chalk.bold(`revert will delete ${matches.length} file(s) and their journal entries:`));
+    for (const m of matches) {
+        const when = m.scannedAt ? chalk.dim(` (scanned ${m.scannedAt})`) : "";
+        console.log(`  • ${m.relPath}${when}`);
+    }
+    const { proceed } = await inquirer.prompt([
+        { type: "confirm", name: "proceed", message: "Proceed?", default: false },
+    ]);
+    if (!proceed) {
+        console.log(chalk.dim("Cancelled."));
+        return;
+    }
+    const deleted = deleteMatches(getDb(), matches.map((m) => m.id));
+    console.log(chalk.green(`✓ Reverted ${deleted} file(s) and all linked records.`));
+}

package/dist/cli/commands/scan.d.ts

@@ -0,0 +1,4 @@
+export declare function runScanCommand(opts: {
+    regex?: string;
+    force?: boolean;
+}): Promise<void>;