plasalid 0.2.0

package/dist/ai/agent.js

@@ -0,0 +1,155 @@
+import { config } from "../config.js";
+import { buildChatSystemPrompt, buildScanSystemPrompt, buildReconcileSystemPrompt, } from "./system-prompt.js";
+import { getToolDefinitions, executeTool } from "./tools/index.js";
+import { getConversationHistory, saveMessage } from "./memory.js";
+import { redact, unredact } from "./redactor.js";
+import { createProvider } from "./providers/index.js";
+const provider = createProvider();
+const MAX_TOOL_STEPS = 20;
+export class AbortedError extends Error {
+    constructor() {
+        super("aborted");
+        this.name = "AbortedError";
+    }
+}
+async function runAgent({ db, systemPrompt, tools, initialMessages, agentCtx, onProgress, signal, maxToolSteps, }) {
+    const messages = [...initialMessages];
+    const useThinking = config.thinkingBudget > 0 && provider.supportsThinking;
+    const throwIfAborted = () => {
+        if (signal?.aborted)
+            throw new AbortedError();
+    };
+    const stepLimit = maxToolSteps ?? MAX_TOOL_STEPS;
+    throwIfAborted();
+    let response = await provider.sendMessage({
+        model: config.model,
+        maxTokens: useThinking ? 16000 : 4096,
+        system: systemPrompt,
+        tools,
+        messages,
+        thinking: useThinking ? { type: "enabled", budget_tokens: config.thinkingBudget } : undefined,
+        signal,
+    });
+    const startTime = Date.now();
+    let toolCount = 0;
+    while (response.stopReason === "tool_use" && toolCount < stepLimit) {
+        throwIfAborted();
+        messages.push({ role: "assistant", content: response.content });
+        const toolResults = [];
+        for (const block of response.content) {
+            if (block.type === "tool_use") {
+                toolCount++;
+                onProgress?.({ phase: "tool", toolName: block.name, toolCount, elapsedMs: Date.now() - startTime });
+                const result = await executeTool(db, block.name, block.input, agentCtx);
+                toolResults.push({
+                    type: "tool_result",
+                    tool_use_id: block.id,
+                    content: redact(result),
+                });
+            }
+        }
+        messages.push({ role: "user", content: toolResults });
+        onProgress?.({ phase: "responding", toolCount, elapsedMs: Date.now() - startTime });
+        throwIfAborted();
+        response = await provider.sendMessage({
+            model: config.model,
+            maxTokens: useThinking ? 16000 : 4096,
+            system: systemPrompt,
+            tools,
+            messages,
+            thinking: useThinking ? { type: "enabled", budget_tokens: config.thinkingBudget } : undefined,
+            signal,
+        });
+    }
+    const textBlocks = response.content.filter((b) => b.type === "text");
+    const text = unredact(textBlocks.map(b => b.text).join("\n"));
+    return { text, messages };
+}
+/**
+ * Conversational chat used by the Ink TUI. Reuses conversation_history for context
+ * continuity, redacts PII on the way out, restores it on the way in for display.
+ */
+export async function handleChatMessage(db, userMessage, onProgress, signal) {
+    saveMessage(db, "user", userMessage);
+    const rawHistory = getConversationHistory(db, 30);
+    const MAX_HISTORY_CHARS = 24_000;
+    let historyChars = 0;
+    const history = [];
+    for (let i = rawHistory.length - 1; i >= 0; i--) {
+        historyChars += rawHistory[i].content.length;
+        if (historyChars > MAX_HISTORY_CHARS)
+            break;
+        history.unshift(rawHistory[i]);
+    }
+    const systemPrompt = redact(buildChatSystemPrompt(db));
+    const messages = history.map(h => ({
+        role: h.role,
+        content: redact(h.content),
+    }));
+    if (messages.length === 0 || messages[messages.length - 1].content !== redact(userMessage)) {
+        messages.push({ role: "user", content: redact(userMessage) });
+    }
+    try {
+        const { text } = await runAgent({
+            db,
+            systemPrompt,
+            tools: getToolDefinitions("chat"),
+            initialMessages: messages,
+            onProgress,
+            signal,
+        });
+        saveMessage(db, "assistant", text);
+        return text || "I couldn't formulate a response. Could you rephrase?";
+    }
+    catch (error) {
+        if (error instanceof AbortedError || error?.name === "AbortError" || signal?.aborted) {
+            throw new AbortedError();
+        }
+        if (error.status === 401 || error.status === 403) {
+            return "API key was rejected. Run `plasalid setup` to reconfigure your credentials.";
+        }
+        if (error.status === 429) {
+            return "Rate limited. Wait a moment and try again.";
+        }
+        const safeMessage = error.status ? `API error (${error.status}): ${error.message || ""}` : error.message || "internal error";
+        console.error("AI error:", safeMessage);
+        return "Sorry, I had trouble processing that. Could you try again?";
+    }
+}
+/**
+ * Scan-time agent loop. Caller supplies the initial user message (which carries
+ * the PDF as a content block) and a AgentExecutionContext that scopes the file
+ * id, scanner version, and interactivity for ask_user.
+ */
+export async function runScanAgent(opts) {
+    const systemPrompt = redact(buildScanSystemPrompt(opts.db, opts.prompt));
+    const { text } = await runAgent({
+        db: opts.db,
+        systemPrompt,
+        tools: getToolDefinitions("scan"),
+        initialMessages: opts.initialMessages,
+        agentCtx: opts.agentCtx,
+        onProgress: opts.onProgress,
+        signal: opts.signal,
+        maxToolSteps: 40,
+    });
+    return text;
+}
+/**
+ * Reconcile-time agent loop. Walks the existing journal with the reconcile
+ * tool profile (read tools + write/merge/delete primitives).
+ */
+export async function runReconcileAgent(opts) {
+    const systemPrompt = redact(buildReconcileSystemPrompt(opts.db, opts.prompt));
+    const { text } = await runAgent({
+        db: opts.db,
+        systemPrompt,
+        tools: getToolDefinitions("reconcile"),
+        initialMessages: opts.initialMessages,
+        agentCtx: opts.agentCtx,
+        onProgress: opts.onProgress,
+        signal: opts.signal,
+        maxToolSteps: 60,
+    });
+    return text;
+}

package/dist/ai/context.d.ts

@@ -0,0 +1,4 @@
+export declare function getContextPath(): string;
+export declare function readContext(): string;
+export declare function writeContext(content: string): void;
+export declare function createContextTemplate(userName: string): void;

package/dist/ai/context.js

@@ -0,0 +1,33 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { dirname, resolve } from "path";
+import { getPlasalidDir } from "../config.js";
+export function getContextPath() {
+    return resolve(getPlasalidDir(), "context.md");
+}
+export function readContext() {
+    const p = getContextPath();
+    if (!existsSync(p))
+        return "";
+    try {
+        return readFileSync(p, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export function writeContext(content) {
+    const p = getContextPath();
+    const dir = dirname(p);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(p, content, { encoding: "utf-8", mode: 0o600 });
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch { }
+}
+export function createContextTemplate(userName) {
+    if (existsSync(getContextPath()))
+        return;
+    writeContext(`# Plasalid context for ${userName}\n\n## Family\n- ${userName}\n\n## Income\n- (Optional: add your primary income source so Plasalid can mark it as PII when sending data to the model.)\n\n## Notes\n- (Free-form notes about your accounts, bank preferences, or anything Plasalid should keep in mind when scanning.)\n`);
+}

package/dist/ai/memory.d.ts

@@ -0,0 +1,14 @@
+import type Database from "libsql";
+export declare function getConversationHistory(db: Database.Database, limit?: number): {
+    role: string;
+    content: string;
+    created_at: string;
+}[];
+export declare function saveMessage(db: Database.Database, role: "user" | "assistant", content: string): void;
+export declare function getMemories(db: Database.Database): {
+    id: number;
+    content: string;
+    category: string;
+    created_at: string;
+}[];
+export declare function saveMemory(db: Database.Database, content: string, category?: string): void;

package/dist/ai/memory.js

@@ -0,0 +1,12 @@
+export function getConversationHistory(db, limit = 20) {
+    return db.prepare(`SELECT role, content, created_at FROM conversation_history ORDER BY id DESC LIMIT ?`).all(limit).reverse();
+}
+export function saveMessage(db, role, content) {
+    db.prepare(`INSERT INTO conversation_history (role, content) VALUES (?, ?)`).run(role, content);
+}
+export function getMemories(db) {
+    return db.prepare(`SELECT id, content, category, created_at FROM memories ORDER BY created_at DESC`).all();
+}
+export function saveMemory(db, content, category = "general") {
+    db.prepare(`INSERT INTO memories (content, category) VALUES (?, ?)`).run(content, category);
+}

package/dist/ai/provider.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Normalized types for provider abstraction.
+ * Mirrors Anthropic's content-block shape but decoupled from the SDK types.
+ */
+export interface TextBlock {
+    type: "text";
+    text: string;
+}
+export interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: any;
+}
+export interface DocumentBlock {
+    type: "document";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    };
+    title?: string;
+}
+export type NormalizedContentBlock = TextBlock | ToolUseBlock | DocumentBlock;
+export interface NormalizedResponse {
+    content: NormalizedContentBlock[];
+    stopReason: string;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export interface NormalizedMessage {
+    role: "user" | "assistant";
+    content: string | NormalizedContentBlock[] | NormalizedToolResult[];
+}
+export interface NormalizedToolResult {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export interface SendMessageParams {
+    model: string;
+    system: string;
+    messages: NormalizedMessage[];
+    tools: ToolDefinition[];
+    maxTokens: number;
+    thinking?: {
+        type: "enabled";
+        budget_tokens: number;
+    };
+    signal?: AbortSignal;
+}
+export interface Provider {
+    name: string;
+    supportsThinking: boolean;
+    sendMessage(params: SendMessageParams): Promise<NormalizedResponse>;
+}

package/dist/ai/provider.js

@@ -0,0 +1,5 @@
+/**
+ * Normalized types for provider abstraction.
+ * Mirrors Anthropic's content-block shape but decoupled from the SDK types.
+ */
+export {};

package/dist/ai/providers/anthropic.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../provider.js";
+export declare function createAnthropicProvider(opts: {
+    apiKey: string;
+    baseURL?: string;
+}): Provider;

package/dist/ai/providers/anthropic.js

@@ -0,0 +1,49 @@
+import Anthropic from "@anthropic-ai/sdk";
+export function createAnthropicProvider(opts) {
+    const client = new Anthropic(opts.baseURL
+        ? { apiKey: opts.apiKey, baseURL: opts.baseURL }
+        : { apiKey: opts.apiKey });
+    return {
+        name: "anthropic",
+        supportsThinking: true,
+        async sendMessage(params) {
+            const apiParams = {
+                model: params.model,
+                max_tokens: params.maxTokens,
+                system: params.system,
+                tools: params.tools,
+                messages: params.messages,
+            };
+            if (params.thinking) {
+                apiParams.thinking = params.thinking;
+            }
+            const response = await client.messages.create(apiParams, {
+                signal: params.signal,
+            });
+            // Filter thinking blocks and normalize content
+            const content = [];
+            for (const block of response.content) {
+                if (block.type === "thinking")
+                    continue;
+                if (block.type === "text") {
+                    content.push({ type: "text", text: block.text });
+                }
+                else if (block.type === "tool_use") {
+                    content.push({
+                        type: "tool_use",
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+            }
+            return {
+                content,
+                stopReason: response.stop_reason || "end_turn",
+                usage: response.usage
+                    ? { input_tokens: response.usage.input_tokens, output_tokens: response.usage.output_tokens }
+                    : undefined,
+            };
+        },
+    };
+}

package/dist/ai/providers/index.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from "../provider.js";
+export declare function createProvider(): Provider;

package/dist/ai/providers/index.js

@@ -0,0 +1,12 @@
+import { config } from "../../config.js";
+import { createAnthropicProvider } from "./anthropic.js";
+import { createOpenAICompatibleProvider } from "./openai.js";
+export function createProvider() {
+    if (config.providerType === "openai-compatible") {
+        return createOpenAICompatibleProvider({
+            apiKey: config.openaiCompatibleKey || "openai-compatible",
+            baseURL: config.openaiCompatibleBaseURL,
+        });
+    }
+    return createAnthropicProvider({ apiKey: config.anthropicKey });
+}

package/dist/ai/providers/openai-compat.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../provider.js";
+export declare function createOpenAICompatibleProvider(opts: {
+    apiKey: string;
+    baseURL: string;
+}): Provider;

package/dist/ai/providers/openai-compat.js

@@ -0,0 +1,147 @@
+import OpenAI from "openai";
+export function createOpenAICompatibleProvider(opts) {
+    const client = new OpenAI({
+        apiKey: opts.apiKey,
+        baseURL: opts.baseURL,
+    });
+    return {
+        name: "openai-compatible",
+        supportsThinking: false,
+        async sendMessage(params) {
+            const messages = convertMessages(params.system, params.messages);
+            const tools = convertTools(params.tools);
+            // Try max_tokens first (broadest compat: Ollama, vLLM, older OpenAI models),
+            // fall back to max_completion_tokens if rejected (newer OpenAI models require it)
+            let response;
+            try {
+                response = await client.chat.completions.create({
+                    model: params.model,
+                    max_tokens: params.maxTokens,
+                    messages,
+                    tools: tools.length > 0 ? tools : undefined,
+                }, { signal: params.signal });
+            }
+            catch (e) {
+                if (e.status === 400 && e.message?.includes("max_tokens")) {
+                    response = await client.chat.completions.create({
+                        model: params.model,
+                        max_completion_tokens: params.maxTokens,
+                        messages,
+                        tools: tools.length > 0 ? tools : undefined,
+                    }, { signal: params.signal });
+                }
+                else {
+                    throw e;
+                }
+            }
+            const choice = response.choices[0];
+            if (!choice) {
+                return { content: [], stopReason: "end_turn" };
+            }
+            const content = [];
+            if (choice.message.content) {
+                content.push({ type: "text", text: choice.message.content });
+            }
+            if (choice.message.tool_calls) {
+                for (const tc of choice.message.tool_calls) {
+                    if (tc.type !== "function")
+                        continue;
+                    content.push({
+                        type: "tool_use",
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: parseArguments(tc.function.arguments),
+                    });
+                }
+            }
+            const hasToolCalls = content.some((b) => b.type === "tool_use");
+            return {
+                content,
+                stopReason: hasToolCalls ? "tool_use" : "end_turn",
+                usage: response.usage
+                    ? { input_tokens: response.usage.prompt_tokens, output_tokens: response.usage.completion_tokens }
+                    : undefined,
+            };
+        },
+    };
+}
+function convertMessages(system, messages) {
+    const result = [
+        { role: "system", content: system },
+    ];
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            if (Array.isArray(msg.content) &&
+                msg.content.length > 0 &&
+                msg.content[0].type === "tool_result") {
+                const toolResults = msg.content;
+                for (const tr of toolResults) {
+                    result.push({
+                        role: "tool",
+                        tool_call_id: tr.tool_use_id,
+                        content: tr.content,
+                    });
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                // Strip document blocks (OpenAI-compat doesn't accept them); keep text.
+                const text = msg.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                result.push({ role: "user", content: text });
+            }
+            else {
+                result.push({ role: "user", content: msg.content });
+            }
+        }
+        else {
+            if (Array.isArray(msg.content)) {
+                const blocks = msg.content;
+                const textParts = blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                const toolCalls = blocks
+                    .filter((b) => b.type === "tool_use")
+                    .map((b) => {
+                    const tu = b;
+                    return {
+                        id: tu.id,
+                        type: "function",
+                        function: { name: tu.name, arguments: JSON.stringify(tu.input) },
+                    };
+                });
+                result.push({
+                    role: "assistant",
+                    content: textParts || null,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                });
+            }
+            else {
+                result.push({ role: "assistant", content: msg.content });
+            }
+        }
+    }
+    return result;
+}
+function convertTools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+        },
+    }));
+}
+function parseArguments(args) {
+    if (typeof args !== "string")
+        return args;
+    try {
+        return JSON.parse(args);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/ai/providers/openai.d.ts

@@ -0,0 +1,5 @@
+import type { Provider } from "../provider.js";
+export declare function createOpenAICompatibleProvider(opts: {
+    apiKey: string;
+    baseURL: string;
+}): Provider;

package/dist/ai/providers/openai.js

@@ -0,0 +1,147 @@
+import OpenAI from "openai";
+export function createOpenAICompatibleProvider(opts) {
+    const client = new OpenAI({
+        apiKey: opts.apiKey,
+        baseURL: opts.baseURL,
+    });
+    return {
+        name: "openai-compatible",
+        supportsThinking: false,
+        async sendMessage(params) {
+            const messages = convertMessages(params.system, params.messages);
+            const tools = convertTools(params.tools);
+            // Try max_tokens first (broadest compat: Ollama, vLLM, older OpenAI models),
+            // fall back to max_completion_tokens if rejected (newer OpenAI models require it)
+            let response;
+            try {
+                response = await client.chat.completions.create({
+                    model: params.model,
+                    max_tokens: params.maxTokens,
+                    messages,
+                    tools: tools.length > 0 ? tools : undefined,
+                }, { signal: params.signal });
+            }
+            catch (e) {
+                if (e.status === 400 && e.message?.includes("max_tokens")) {
+                    response = await client.chat.completions.create({
+                        model: params.model,
+                        max_completion_tokens: params.maxTokens,
+                        messages,
+                        tools: tools.length > 0 ? tools : undefined,
+                    }, { signal: params.signal });
+                }
+                else {
+                    throw e;
+                }
+            }
+            const choice = response.choices[0];
+            if (!choice) {
+                return { content: [], stopReason: "end_turn" };
+            }
+            const content = [];
+            if (choice.message.content) {
+                content.push({ type: "text", text: choice.message.content });
+            }
+            if (choice.message.tool_calls) {
+                for (const tc of choice.message.tool_calls) {
+                    if (tc.type !== "function")
+                        continue;
+                    content.push({
+                        type: "tool_use",
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: parseArguments(tc.function.arguments),
+                    });
+                }
+            }
+            const hasToolCalls = content.some((b) => b.type === "tool_use");
+            return {
+                content,
+                stopReason: hasToolCalls ? "tool_use" : "end_turn",
+                usage: response.usage
+                    ? { input_tokens: response.usage.prompt_tokens, output_tokens: response.usage.completion_tokens }
+                    : undefined,
+            };
+        },
+    };
+}
+function convertMessages(system, messages) {
+    const result = [
+        { role: "system", content: system },
+    ];
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            if (Array.isArray(msg.content) &&
+                msg.content.length > 0 &&
+                msg.content[0].type === "tool_result") {
+                const toolResults = msg.content;
+                for (const tr of toolResults) {
+                    result.push({
+                        role: "tool",
+                        tool_call_id: tr.tool_use_id,
+                        content: tr.content,
+                    });
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                // Strip document blocks (OpenAI-compat doesn't accept them); keep text.
+                const text = msg.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                result.push({ role: "user", content: text });
+            }
+            else {
+                result.push({ role: "user", content: msg.content });
+            }
+        }
+        else {
+            if (Array.isArray(msg.content)) {
+                const blocks = msg.content;
+                const textParts = blocks
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                const toolCalls = blocks
+                    .filter((b) => b.type === "tool_use")
+                    .map((b) => {
+                    const tu = b;
+                    return {
+                        id: tu.id,
+                        type: "function",
+                        function: { name: tu.name, arguments: JSON.stringify(tu.input) },
+                    };
+                });
+                result.push({
+                    role: "assistant",
+                    content: textParts || null,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                });
+            }
+            else {
+                result.push({ role: "assistant", content: msg.content });
+            }
+        }
+    }
+    return result;
+}
+function convertTools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+        },
+    }));
+}
+function parseArguments(args) {
+    if (typeof args !== "string")
+        return args;
+    try {
+        return JSON.parse(args);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/ai/redactor.d.ts

@@ -0,0 +1,2 @@
+export declare function redact(text: string): string;
+export declare function unredact(text: string): string;