plasalid 0.2.0

package/dist/db/queries/account_balance.d.ts

@@ -0,0 +1,61 @@
+import type Database from "libsql";
+export type AccountType = "asset" | "liability" | "income" | "expense" | "equity";
+export interface AccountRow {
+    id: string;
+    name: string;
+    type: AccountType;
+    subtype: string | null;
+    bank_name: string | null;
+    account_number_masked: string | null;
+    currency: string;
+    due_day: number | null;
+    statement_day: number | null;
+    points_balance: number | null;
+    metadata_json: string | null;
+    pii_flag: number;
+    created_at: string;
+}
+export interface AccountBalance extends AccountRow {
+    balance: number;
+}
+/**
+ * Balance per account using the natural debit/credit convention:
+ *   asset / expense  → debit-normal  → balance = debits − credits
+ *   liability / income / equity → credit-normal → balance = credits − debits
+ */
+export declare function getAccountBalances(db: Database.Database, opts?: {
+    type?: AccountType;
+}): AccountBalance[];
+export interface NetWorth {
+    assets: number;
+    liabilities: number;
+    net_worth: number;
+}
+export declare function getNetWorth(db: Database.Database): NetWorth;
+export interface PeriodTotals {
+    income: number;
+    expenses: number;
+}
+export declare function getPeriodTotals(db: Database.Database, from: string, to: string): PeriodTotals;
+export declare function findAccountById(db: Database.Database, id: string): AccountRow | null;
+export declare function renameAccount(db: Database.Database, id: string, name: string): number;
+/**
+ * Re-point every journal line on `fromId` to `toId`, then delete the source
+ * account. Wrapped in a transaction. Returns the number of journal lines moved.
+ * Throws if either account doesn't exist.
+ */
+export declare function mergeAccounts(db: Database.Database, fromId: string, toId: string): number;
+/** Delete an account only if no journal_lines reference it. */
+export declare function deleteAccount(db: Database.Database, id: string): void;
+export interface SimilarAccountPair {
+    a: AccountRow;
+    b: AccountRow;
+    similarity: number;
+}
+/**
+ * Pairwise Levenshtein similarity over `accounts.name`. Returns pairs above the
+ * threshold (0–1, where 1 = identical), sorted highest first. Quadratic in the
+ * number of accounts — fine for the small N a personal chart of accounts holds.
+ */
+export declare function findSimilarAccounts(db: Database.Database, threshold?: number): SimilarAccountPair[];
+export declare function findUnusedAccounts(db: Database.Database): AccountRow[];

package/dist/db/queries/account_balance.js

@@ -0,0 +1,146 @@
+/**
+ * Balance per account using the natural debit/credit convention:
+ *   asset / expense  → debit-normal  → balance = debits − credits
+ *   liability / income / equity → credit-normal → balance = credits − debits
+ */
+export function getAccountBalances(db, opts = {}) {
+    const params = [];
+    const where = [];
+    if (opts.type) {
+        where.push("a.type = ?");
+        params.push(opts.type);
+    }
+    const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+    const rows = db.prepare(`SELECT a.*,
+            COALESCE(SUM(jl.debit), 0)  AS sum_debit,
+            COALESCE(SUM(jl.credit), 0) AS sum_credit
+     FROM accounts a
+     LEFT JOIN journal_lines jl ON jl.account_id = a.id
+     ${whereSql}
+     GROUP BY a.id
+     ORDER BY a.type, a.name`).all(...params);
+    return rows.map(r => {
+        const debitNormal = r.type === "asset" || r.type === "expense";
+        const balance = debitNormal ? r.sum_debit - r.sum_credit : r.sum_credit - r.sum_debit;
+        const { sum_debit: _d, sum_credit: _c, ...account } = r;
+        return { ...account, balance };
+    });
+}
+export function getNetWorth(db) {
+    const balances = getAccountBalances(db);
+    let assets = 0;
+    let liabilities = 0;
+    for (const b of balances) {
+        if (b.type === "asset")
+            assets += b.balance;
+        else if (b.type === "liability")
+            liabilities += b.balance;
+    }
+    return { assets, liabilities, net_worth: assets - liabilities };
+}
+export function getPeriodTotals(db, from, to) {
+    const row = db.prepare(`SELECT
+        COALESCE(SUM(CASE WHEN a.type = 'income'  THEN jl.credit - jl.debit ELSE 0 END), 0) AS income,
+        COALESCE(SUM(CASE WHEN a.type = 'expense' THEN jl.debit - jl.credit ELSE 0 END), 0) AS expenses
+     FROM journal_lines jl
+     JOIN journal_entries je ON je.id = jl.entry_id
+     JOIN accounts a ON a.id = jl.account_id
+     WHERE je.date BETWEEN ? AND ?`).get(from, to);
+    return { income: row.income, expenses: row.expenses };
+}
+export function findAccountById(db, id) {
+    return db.prepare(`SELECT * FROM accounts WHERE id = ?`).get(id) ?? null;
+}
+export function renameAccount(db, id, name) {
+    return db.prepare(`UPDATE accounts SET name = ? WHERE id = ?`).run(name, id).changes;
+}
+/**
+ * Re-point every journal line on `fromId` to `toId`, then delete the source
+ * account. Wrapped in a transaction. Returns the number of journal lines moved.
+ * Throws if either account doesn't exist.
+ */
+export function mergeAccounts(db, fromId, toId) {
+    if (fromId === toId)
+        throw new Error("Cannot merge an account into itself.");
+    const from = findAccountById(db, fromId);
+    if (!from)
+        throw new Error(`Source account ${fromId} not found.`);
+    const to = findAccountById(db, toId);
+    if (!to)
+        throw new Error(`Destination account ${toId} not found.`);
+    let moved = 0;
+    const tx = db.transaction(() => {
+        moved = db
+            .prepare(`UPDATE journal_lines SET account_id = ? WHERE account_id = ?`)
+            .run(toId, fromId).changes;
+        db.prepare(`DELETE FROM accounts WHERE id = ?`).run(fromId);
+    });
+    tx();
+    return moved;
+}
+/** Delete an account only if no journal_lines reference it. */
+export function deleteAccount(db, id) {
+    const inUse = db
+        .prepare(`SELECT 1 FROM journal_lines WHERE account_id = ? LIMIT 1`)
+        .get(id);
+    if (inUse) {
+        throw new Error(`Account ${id} still has journal lines; merge it first.`);
+    }
+    db.prepare(`DELETE FROM accounts WHERE id = ?`).run(id);
+}
+/**
+ * Pairwise Levenshtein similarity over `accounts.name`. Returns pairs above the
+ * threshold (0–1, where 1 = identical), sorted highest first. Quadratic in the
+ * number of accounts — fine for the small N a personal chart of accounts holds.
+ */
+export function findSimilarAccounts(db, threshold = 0.85) {
+    const rows = db.prepare(`SELECT * FROM accounts ORDER BY name`).all();
+    const pairs = [];
+    for (let i = 0; i < rows.length; i++) {
+        for (let j = i + 1; j < rows.length; j++) {
+            const sim = similarity(rows[i].name.toLowerCase(), rows[j].name.toLowerCase());
+            if (sim >= threshold)
+                pairs.push({ a: rows[i], b: rows[j], similarity: Math.round(sim * 1000) / 1000 });
+        }
+    }
+    pairs.sort((x, y) => y.similarity - x.similarity);
+    return pairs;
+}
+export function findUnusedAccounts(db) {
+    return db
+        .prepare(`SELECT a.* FROM accounts a
+       LEFT JOIN journal_lines jl ON jl.account_id = a.id
+       WHERE jl.id IS NULL
+       ORDER BY a.name`)
+        .all();
+}
+// ── helpers ────────────────────────────────────────────────────────────────
+function similarity(a, b) {
+    if (a === b)
+        return 1;
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    const dist = levenshtein(a, b);
+    return 1 - dist / Math.max(a.length, b.length);
+}
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const prev = new Array(n + 1);
+    const curr = new Array(n + 1);
+    for (let j = 0; j <= n; j++)
+        prev[j] = j;
+    for (let i = 1; i <= m; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+            curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+        }
+        for (let j = 0; j <= n; j++)
+            prev[j] = curr[j];
+    }
+    return prev[n];
+}

package/dist/db/queries/journal.d.ts

@@ -0,0 +1,95 @@
+import type Database from "libsql";
+export interface JournalLineInput {
+    account_id: string;
+    debit?: number;
+    credit?: number;
+    currency?: string;
+    memo?: string | null;
+    pii_flag?: boolean;
+}
+export interface JournalEntryInput {
+    date: string;
+    description: string;
+    source_file_id?: string | null;
+    source_page?: number | null;
+    lines: JournalLineInput[];
+}
+export interface JournalEntryRow {
+    id: string;
+    date: string;
+    description: string;
+    source_file_id: string | null;
+    source_page: number | null;
+    created_at: string;
+}
+export interface JournalLineRow {
+    id: string;
+    entry_id: string;
+    account_id: string;
+    debit: number;
+    credit: number;
+    currency: string;
+    memo: string | null;
+    account_name?: string;
+    account_type?: string;
+    entry_date?: string;
+    entry_description?: string;
+}
+/**
+ * Insert a balanced journal entry. Throws if SUM(debit) !== SUM(credit) or any
+ * line both debits and credits. Transaction-wrapped: lines never land without
+ * a header, header never lands without lines.
+ */
+export declare function recordJournalEntry(db: Database.Database, entry: JournalEntryInput): string;
+export interface ListJournalLinesOptions {
+    account_id?: string;
+    from?: string;
+    to?: string;
+    q?: string;
+    limit?: number;
+}
+export interface UpdateJournalEntryFields {
+    date?: string;
+    description?: string;
+    source_page?: number | null;
+}
+export declare function updateJournalEntry(db: Database.Database, entryId: string, fields: UpdateJournalEntryFields): number;
+export interface UpdateJournalLineFields {
+    account_id?: string;
+    memo?: string | null;
+}
+/**
+ * Safe single-line edits only. Refuses changes to `debit`, `credit`, or `currency`
+ * because those would silently break the entry's balance — to fix amounts the
+ * caller must delete the entry and record a fresh one.
+ */
+export declare function updateJournalLine(db: Database.Database, lineId: string, fields: UpdateJournalLineFields): number;
+/**
+ * Delete a journal entry. ON DELETE CASCADE on `journal_lines.entry_id` removes
+ * the lines automatically.
+ */
+export declare function deleteJournalEntry(db: Database.Database, entryId: string): number;
+export interface DuplicateGroupEntry {
+    id: string;
+    date: string;
+    description: string;
+    amount: number;
+    account_ids: string[];
+    account_names: string[];
+}
+export interface FindDuplicateEntriesOptions {
+    /** Days of slack when grouping by date. 0 means same-day only. Default 2. */
+    toleranceDays?: number;
+    /** Only consider entries that have at least one line on this account. */
+    accountId?: string;
+    /** Skip entries whose total debit is below this value. */
+    minAmount?: number;
+}
+/**
+ * Heuristic duplicate finder: group entries by (rounded total debit) and check
+ * pairs whose date difference is ≤ toleranceDays. Returns groups with ≥2 members.
+ * Each entry carries both account_ids (for follow-up tool calls) and
+ * account_names (for human-readable presentation to the user).
+ */
+export declare function findDuplicateEntries(db: Database.Database, opts?: FindDuplicateEntriesOptions): DuplicateGroupEntry[][];
+export declare function listJournalLines(db: Database.Database, opts?: ListJournalLinesOptions): JournalLineRow[];

package/dist/db/queries/journal.js

@@ -0,0 +1,204 @@
+import { randomUUID } from "crypto";
+const TOLERANCE = 0.005;
+/**
+ * Insert a balanced journal entry. Throws if SUM(debit) !== SUM(credit) or any
+ * line both debits and credits. Transaction-wrapped: lines never land without
+ * a header, header never lands without lines.
+ */
+export function recordJournalEntry(db, entry) {
+    if (!entry.lines || entry.lines.length < 2) {
+        throw new Error("Journal entry must contain at least two lines.");
+    }
+    let debitTotal = 0;
+    let creditTotal = 0;
+    for (const line of entry.lines) {
+        const debit = line.debit ?? 0;
+        const credit = line.credit ?? 0;
+        if (debit < 0 || credit < 0) {
+            throw new Error("debit and credit values must be non-negative.");
+        }
+        if (debit > 0 && credit > 0) {
+            throw new Error("A single journal line cannot debit and credit at the same time.");
+        }
+        if (debit === 0 && credit === 0) {
+            throw new Error("Each journal line must have either a debit or a credit.");
+        }
+        debitTotal += debit;
+        creditTotal += credit;
+    }
+    if (Math.abs(debitTotal - creditTotal) > TOLERANCE) {
+        throw new Error(`Journal entry does not balance: debits ${debitTotal.toFixed(2)} vs credits ${creditTotal.toFixed(2)}.`);
+    }
+    const entryId = `je:${randomUUID()}`;
+    const insertHeader = db.prepare(`INSERT INTO journal_entries (id, date, description, source_file_id, source_page)
+     VALUES (?, ?, ?, ?, ?)`);
+    const insertLine = db.prepare(`INSERT INTO journal_lines (id, entry_id, account_id, debit, credit, currency, memo, pii_flag)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+    const tx = db.transaction(() => {
+        insertHeader.run(entryId, entry.date, entry.description, entry.source_file_id ?? null, entry.source_page ?? null);
+        for (const line of entry.lines) {
+            insertLine.run(`jl:${randomUUID()}`, entryId, line.account_id, line.debit ?? 0, line.credit ?? 0, line.currency || "THB", line.memo ?? null, line.pii_flag ? 1 : 0);
+        }
+    });
+    tx();
+    return entryId;
+}
+export function updateJournalEntry(db, entryId, fields) {
+    const sets = [];
+    const params = [];
+    if (fields.date !== undefined) {
+        sets.push("date = ?");
+        params.push(fields.date);
+    }
+    if (fields.description !== undefined) {
+        sets.push("description = ?");
+        params.push(fields.description);
+    }
+    if (fields.source_page !== undefined) {
+        sets.push("source_page = ?");
+        params.push(fields.source_page);
+    }
+    if (sets.length === 0)
+        return 0;
+    params.push(entryId);
+    return db.prepare(`UPDATE journal_entries SET ${sets.join(", ")} WHERE id = ?`).run(...params).changes;
+}
+/**
+ * Safe single-line edits only. Refuses changes to `debit`, `credit`, or `currency`
+ * because those would silently break the entry's balance — to fix amounts the
+ * caller must delete the entry and record a fresh one.
+ */
+export function updateJournalLine(db, lineId, fields) {
+    const sets = [];
+    const params = [];
+    if (fields.account_id !== undefined) {
+        sets.push("account_id = ?");
+        params.push(fields.account_id);
+    }
+    if (fields.memo !== undefined) {
+        sets.push("memo = ?");
+        params.push(fields.memo);
+    }
+    if (sets.length === 0)
+        return 0;
+    params.push(lineId);
+    return db.prepare(`UPDATE journal_lines SET ${sets.join(", ")} WHERE id = ?`).run(...params).changes;
+}
+/**
+ * Delete a journal entry. ON DELETE CASCADE on `journal_lines.entry_id` removes
+ * the lines automatically.
+ */
+export function deleteJournalEntry(db, entryId) {
+    return db.prepare(`DELETE FROM journal_entries WHERE id = ?`).run(entryId).changes;
+}
+/**
+ * Heuristic duplicate finder: group entries by (rounded total debit) and check
+ * pairs whose date difference is ≤ toleranceDays. Returns groups with ≥2 members.
+ * Each entry carries both account_ids (for follow-up tool calls) and
+ * account_names (for human-readable presentation to the user).
+ */
+export function findDuplicateEntries(db, opts = {}) {
+    const toleranceDays = Math.max(0, Math.floor(opts.toleranceDays ?? 2));
+    const minAmount = opts.minAmount ?? 0;
+    const accountFilter = opts.accountId
+        ? `WHERE je.id IN (SELECT entry_id FROM journal_lines WHERE account_id = ?)`
+        : ``;
+    const params = opts.accountId ? [opts.accountId] : [];
+    // Small chart of accounts → a single name lookup beats GROUP_CONCAT join
+    // hacks (account names can contain commas which break a comma-separated
+    // concat, and SQLite's GROUP_CONCAT has no robust escape mechanism).
+    const nameById = new Map();
+    for (const row of db.prepare(`SELECT id, name FROM accounts`).all()) {
+        nameById.set(row.id, row.name);
+    }
+    const rows = db.prepare(`SELECT je.id, je.date, je.description,
+            COALESCE(SUM(jl.debit), 0) AS amount,
+            GROUP_CONCAT(jl.account_id) AS account_ids
+     FROM journal_entries je
+     LEFT JOIN journal_lines jl ON jl.entry_id = je.id
+     ${accountFilter}
+     GROUP BY je.id`).all(...params);
+    const entries = rows
+        .filter(r => r.amount >= minAmount)
+        .map(r => {
+        const ids = (r.account_ids ?? "").split(",").filter(Boolean);
+        return {
+            id: r.id,
+            date: r.date,
+            description: r.description,
+            amount: Math.round(r.amount * 100) / 100,
+            account_ids: ids,
+            account_names: ids.map(id => nameById.get(id) ?? id),
+        };
+    });
+    const byAmount = new Map();
+    for (const e of entries) {
+        const key = Math.round(e.amount * 100); // cents
+        const arr = byAmount.get(key) ?? [];
+        arr.push(e);
+        byAmount.set(key, arr);
+    }
+    const groups = [];
+    for (const candidates of byAmount.values()) {
+        if (candidates.length < 2)
+            continue;
+        candidates.sort((a, b) => a.date.localeCompare(b.date));
+        let current = [];
+        for (const e of candidates) {
+            if (current.length === 0) {
+                current.push(e);
+                continue;
+            }
+            const last = current[current.length - 1];
+            if (dayDiff(last.date, e.date) <= toleranceDays) {
+                current.push(e);
+            }
+            else {
+                if (current.length >= 2)
+                    groups.push(current);
+                current = [e];
+            }
+        }
+        if (current.length >= 2)
+            groups.push(current);
+    }
+    return groups;
+}
+function dayDiff(a, b) {
+    const aDate = Date.parse(a);
+    const bDate = Date.parse(b);
+    if (Number.isNaN(aDate) || Number.isNaN(bDate))
+        return Number.POSITIVE_INFINITY;
+    return Math.abs(Math.round((bDate - aDate) / 86_400_000));
+}
+export function listJournalLines(db, opts = {}) {
+    const conditions = [];
+    const params = [];
+    if (opts.account_id) {
+        conditions.push("jl.account_id = ?");
+        params.push(opts.account_id);
+    }
+    if (opts.from) {
+        conditions.push("je.date >= ?");
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        conditions.push("je.date <= ?");
+        params.push(opts.to);
+    }
+    if (opts.q) {
+        conditions.push("(je.description LIKE ? OR jl.memo LIKE ?)");
+        params.push(`%${opts.q}%`, `%${opts.q}%`);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = Math.min(Math.max(opts.limit ?? 50, 1), 500);
+    return db.prepare(`SELECT jl.id, jl.entry_id, jl.account_id, jl.debit, jl.credit, jl.currency, jl.memo,
+            a.name AS account_name, a.type AS account_type,
+            je.date AS entry_date, je.description AS entry_description
+     FROM journal_lines jl
+     JOIN journal_entries je ON je.id = jl.entry_id
+     JOIN accounts a ON a.id = jl.account_id
+     ${where}
+     ORDER BY je.date DESC, je.id DESC
+     LIMIT ?`).all(...params, limit);
+}

package/dist/db/queries/search.d.ts

@@ -0,0 +1,7 @@
+import type Database from "libsql";
+import type { JournalLineRow } from "./journal.js";
+/**
+ * Free-text search across journal entry descriptions, line memos, and account
+ * names. Returns matching journal lines joined with account + entry metadata.
+ */
+export declare function searchJournalLines(db: Database.Database, query: string, limit?: number): JournalLineRow[];

package/dist/db/queries/search.js

@@ -0,0 +1,19 @@
+/**
+ * Free-text search across journal entry descriptions, line memos, and account
+ * names. Returns matching journal lines joined with account + entry metadata.
+ */
+export function searchJournalLines(db, query, limit = 30) {
+    const needle = `%${query}%`;
+    const capped = Math.min(Math.max(limit, 1), 200);
+    return db.prepare(`SELECT jl.id, jl.entry_id, jl.account_id, jl.debit, jl.credit, jl.currency, jl.memo,
+            a.name AS account_name, a.type AS account_type,
+            je.date AS entry_date, je.description AS entry_description
+     FROM journal_lines jl
+     JOIN journal_entries je ON je.id = jl.entry_id
+     JOIN accounts a ON a.id = jl.account_id
+     WHERE je.description LIKE ?
+        OR jl.memo LIKE ?
+        OR a.name LIKE ?
+     ORDER BY je.date DESC, je.id DESC
+     LIMIT ?`).all(needle, needle, needle, capped);
+}

package/dist/db/schema.d.ts

@@ -0,0 +1,2 @@
+import type Database from "libsql";
+export declare function migrate(db: Database.Database): void;

package/dist/db/schema.js

@@ -0,0 +1,95 @@
+export function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS accounts (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL CHECK(type IN ('asset','liability','income','expense','equity')),
+      subtype TEXT,
+      bank_name TEXT,
+      account_number_masked TEXT,
+      currency TEXT NOT NULL DEFAULT 'THB',
+      due_day INTEGER,
+      statement_day INTEGER,
+      points_balance REAL,
+      metadata_json TEXT,
+      pii_flag INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS scanned_files (
+      id TEXT PRIMARY KEY,
+      path TEXT NOT NULL,
+      file_hash TEXT NOT NULL UNIQUE,
+      mime TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('pending','scanned','needs_input','failed')),
+      raw_text TEXT,
+      scanned_at TEXT,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS journal_entries (
+      id TEXT PRIMARY KEY,
+      date TEXT NOT NULL,
+      description TEXT NOT NULL,
+      source_file_id TEXT REFERENCES scanned_files(id) ON DELETE CASCADE,
+      source_page INTEGER,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS journal_lines (
+      id TEXT PRIMARY KEY,
+      entry_id TEXT NOT NULL REFERENCES journal_entries(id) ON DELETE CASCADE,
+      account_id TEXT NOT NULL REFERENCES accounts(id),
+      debit REAL NOT NULL DEFAULT 0,
+      credit REAL NOT NULL DEFAULT 0,
+      currency TEXT NOT NULL DEFAULT 'THB',
+      memo TEXT,
+      pii_flag INTEGER NOT NULL DEFAULT 0,
+      CHECK (debit >= 0 AND credit >= 0 AND (debit = 0 OR credit = 0))
+    );
+
+    CREATE INDEX IF NOT EXISTS journal_lines_entry_idx ON journal_lines(entry_id);
+    CREATE INDEX IF NOT EXISTS journal_lines_account_idx ON journal_lines(account_id);
+    CREATE INDEX IF NOT EXISTS journal_entries_source_file_idx ON journal_entries(source_file_id);
+    CREATE INDEX IF NOT EXISTS journal_entries_date_idx ON journal_entries(date);
+
+    CREATE TABLE IF NOT EXISTS pending_questions (
+      id TEXT PRIMARY KEY,
+      file_id TEXT REFERENCES scanned_files(id) ON DELETE CASCADE,
+      prompt TEXT NOT NULL,
+      options_json TEXT,
+      answer TEXT,
+      resolved_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS conversation_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      category TEXT NOT NULL DEFAULT 'general',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS file_passwords (
+      id TEXT PRIMARY KEY,
+      pattern TEXT NOT NULL UNIQUE,
+      password_encrypted TEXT NOT NULL,
+      last_used_at TEXT,
+      use_count INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/parser/pdf.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentBlock } from "../ai/provider.js";
+export interface LoadedDocument {
+    block: DocumentBlock;
+    hash: string;
+    mime: string;
+    byteLength: number;
+    fileName: string;
+}
+/**
+ * Read a local file, hash it, and produce a base64 document block ready to
+ * attach to an Anthropic user message. Hash is sha256 of the raw bytes; used as
+ * the idempotency key in `parsed_files`.
+ */
+export declare function loadDocument(path: string): LoadedDocument;