plasalid 0.2.0

package/dist/cli/ink/ChatApp.d.ts

@@ -0,0 +1,8 @@
+import type Database from "libsql";
+interface Props {
+    db: Database.Database;
+    /** Auto-kick-off message to send silently on mount (onboarding). */
+    onboardingPrompt?: string;
+}
+export declare function ChatApp({ db, onboardingPrompt }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/ink/ChatApp.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Box, Static, Text, useApp } from "ink";
+import chalk from "chalk";
+import { PromptFrame } from "./PromptFrame.js";
+import { ThinkingLine } from "./messages/ThinkingLine.js";
+import { UserMessage } from "./messages/UserMessage.js";
+import { AssistantMessage } from "./messages/AssistantMessage.js";
+import { ErrorMessage } from "./messages/ErrorMessage.js";
+import { InterruptedMessage } from "./messages/InterruptedMessage.js";
+import { useTextInput } from "./hooks/useTextInput.js";
+import { useAgent } from "./hooks/useAgent.js";
+import { useCtrlCExit } from "./hooks/useCtrlCExit.js";
+import { useFooterText } from "./hooks/useFooterText.js";
+let turnSeq = 0;
+const nextId = () => `t${++turnSeq}`;
+export function ChatApp({ db, onboardingPrompt }) {
+    const { exit } = useApp();
+    const [turns, setTurns] = useState([]);
+    const footerText = useFooterText(db);
+    const ctrlC = useCtrlCExit();
+    const pushTurn = useCallback((t) => {
+        setTurns(prev => [...prev, t]);
+    }, []);
+    const { thinking, submit: runAgent, cancel, isBusy } = useAgent({
+        db,
+        onEvent: (e) => {
+            if (e.type === "response") {
+                pushTurn({ id: nextId(), kind: "assistant", text: e.text });
+            }
+            else if (e.type === "error") {
+                pushTurn({ id: nextId(), kind: "error", error: e.error });
+            }
+            else if (e.type === "interrupted") {
+                pushTurn({ id: nextId(), kind: "interrupted" });
+            }
+        },
+    });
+    const handleSubmit = useCallback((raw) => {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return;
+        if (trimmed === "/quit" || trimmed === "/exit" || trimmed === "/q") {
+            exit();
+            return;
+        }
+        pushTurn({ id: nextId(), kind: "user", text: trimmed });
+        runAgent(trimmed);
+    }, [exit, pushTurn, runAgent]);
+    const onCtrlCFromInput = useCallback((bufferEmpty) => {
+        const action = ctrlC.trigger({ bufferEmpty, busy: isBusy });
+        if (action === "clear-input") {
+            textInput.reset();
+        }
+        else if (action === "abort") {
+            cancel();
+        }
+        else if (action === "exit") {
+            exit();
+        }
+        // "arm" → do nothing; hint renders via ctrlC.pending
+    }, [ctrlC, isBusy, cancel, exit]);
+    const textInput = useTextInput({
+        onSubmit: handleSubmit,
+        onCtrlC: onCtrlCFromInput,
+        onChange: () => {
+            if (ctrlC.pending)
+                ctrlC.clear();
+        },
+    });
+    // Auto-onboarding: fire exactly once on mount
+    const onboardedRef = useRef(false);
+    useEffect(() => {
+        if (onboardedRef.current)
+            return;
+        onboardedRef.current = true;
+        if (onboardingPrompt)
+            runAgent(onboardingPrompt);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const exitHint = ctrlC.pending
+        ? chalk.yellow("  press ctrl+c again to exit")
+        : undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: turns, children: (t) => _jsx(TurnView, { turn: t }, t.id) }), thinking ? _jsx(ThinkingLine, { state: thinking }) : null, !isBusy ? (_jsx(PromptFrame, { buffer: textInput.buffer, footerText: footerText, showCaret: !isBusy, banner: exitHint })) : null] }));
+}
+function TurnView({ turn }) {
+    switch (turn.kind) {
+        case "user": return _jsx(UserMessage, { text: turn.text });
+        case "assistant": return _jsx(AssistantMessage, { text: turn.text });
+        case "error": return _jsx(ErrorMessage, { error: turn.error, context: turn.context });
+        case "interrupted": return _jsx(InterruptedMessage, {});
+        default: return _jsx(Text, {});
+    }
+}

package/dist/cli/ink/PromptFrame.d.ts

@@ -0,0 +1,10 @@
+import type { TextBuffer } from "./hooks/useTextInput.js";
+interface Props {
+    buffer: TextBuffer;
+    footerText: string;
+    showCaret: boolean;
+    banner?: string;
+}
+/** Framed prompt: top rule, input area, bottom rule, footer, optional banner below. */
+export declare function PromptFrame({ buffer, footerText, showCaret, banner }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/ink/PromptFrame.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useStdout } from "ink";
+import chalk from "chalk";
+import { TextInput } from "./TextInput.js";
+/** Framed prompt: top rule, input area, bottom rule, footer, optional banner below. */
+export function PromptFrame({ buffer, footerText, showCaret, banner }) {
+    const { stdout } = useStdout();
+    const cols = stdout?.columns || 80;
+    const rule = chalk.dim("─".repeat(cols));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: rule }), _jsx(TextInput, { buffer: buffer, prompt: chalk.dim("❯ "), showCaret: showCaret }), _jsx(Text, { children: rule }), _jsx(Text, { children: chalk.dim(`  ${footerText}`) }), banner ? _jsx(Text, { children: banner }) : null] }));
+}

package/dist/cli/ink/TextInput.d.ts

@@ -0,0 +1,13 @@
+import type { TextBuffer } from "./hooks/useTextInput.js";
+interface Props {
+    buffer: TextBuffer;
+    prompt: string;
+    /** Render caret inverted on the current character. */
+    showCaret: boolean;
+}
+/**
+ * Renders a multiline text buffer with an inverted caret at the cursor position.
+ * Prefixes the first line with `prompt`; continuation lines are indented to match.
+ */
+export declare function TextInput({ buffer, prompt, showCaret }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/cli/ink/TextInput.js

@@ -0,0 +1,24 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from "ink";
+/**
+ * Renders a multiline text buffer with an inverted caret at the cursor position.
+ * Prefixes the first line with `prompt`; continuation lines are indented to match.
+ */
+export function TextInput({ buffer, prompt, showCaret }) {
+    const plainPromptLen = stripAnsi(prompt).length;
+    const indent = " ".repeat(plainPromptLen);
+    return (_jsx(_Fragment, { children: buffer.lines.map((line, row) => {
+            const isCursorRow = showCaret && row === buffer.row;
+            const prefix = row === 0 ? prompt : indent;
+            if (!isCursorRow) {
+                return (_jsxs(Text, { children: [prefix, line || " "] }, row));
+            }
+            const before = line.slice(0, buffer.col);
+            const caretChar = buffer.col < line.length ? line[buffer.col] : " ";
+            const after = buffer.col < line.length ? line.slice(buffer.col + 1) : "";
+            return (_jsxs(Text, { children: [prefix, before, _jsx(Text, { inverse: true, children: caretChar }), after] }, row));
+        }) }));
+}
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}

package/dist/cli/ink/hooks/useAgent.d.ts

@@ -0,0 +1,27 @@
+import type Database from "libsql";
+import type { ThinkingState } from "../messages/ThinkingLine.js";
+export type AgentEvent = {
+    type: "response";
+    text: string;
+} | {
+    type: "error";
+    error: unknown;
+} | {
+    type: "interrupted";
+};
+interface UseAgentOpts {
+    db: Database.Database;
+    onEvent: (event: AgentEvent) => void;
+}
+/**
+ * Bridges handleMessage with Ink state. submit() kicks off a run and owns the
+ * AbortController; cancel() aborts whatever's in flight. state.thinking is null
+ * when idle, a ThinkingState otherwise.
+ */
+export declare function useAgent({ db, onEvent }: UseAgentOpts): {
+    thinking: ThinkingState | null;
+    submit: (text: string) => void;
+    cancel: () => void;
+    isBusy: boolean;
+};
+export {};

package/dist/cli/ink/hooks/useAgent.js

@@ -0,0 +1,65 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { handleChatMessage, AbortedError } from "../../../ai/agent.js";
+import { pickThinking } from "../../../ai/thinking.js";
+/**
+ * Bridges handleMessage with Ink state. submit() kicks off a run and owns the
+ * AbortController; cancel() aborts whatever's in flight. state.thinking is null
+ * when idle, a ThinkingState otherwise.
+ */
+export function useAgent({ db, onEvent }) {
+    const [thinking, setThinking] = useState(null);
+    const controllerRef = useRef(null);
+    const onEventRef = useRef(onEvent);
+    onEventRef.current = onEvent;
+    const inflightRef = useRef(false);
+    const cancel = useCallback(() => {
+        const c = controllerRef.current;
+        if (c && !c.signal.aborted)
+            c.abort();
+    }, []);
+    const submit = useCallback((text) => {
+        if (inflightRef.current)
+            return; // ignore overlapping submits
+        inflightRef.current = true;
+        const controller = new AbortController();
+        controllerRef.current = controller;
+        setThinking({ phrase: pickThinking() });
+        const onProgress = ({ phase, toolName, toolCount, elapsedMs }) => {
+            setThinking(prev => prev
+                ? { ...prev, progress: { phase, toolName, toolCount, elapsedMs } }
+                : prev);
+        };
+        (async () => {
+            try {
+                const response = await handleChatMessage(db, text, onProgress, controller.signal);
+                if (controller.signal.aborted) {
+                    onEventRef.current({ type: "interrupted" });
+                }
+                else {
+                    onEventRef.current({ type: "response", text: response });
+                }
+            }
+            catch (err) {
+                if (err instanceof AbortedError || controller.signal.aborted) {
+                    onEventRef.current({ type: "interrupted" });
+                }
+                else {
+                    onEventRef.current({ type: "error", error: err });
+                }
+            }
+            finally {
+                inflightRef.current = false;
+                setThinking(null);
+                if (controllerRef.current === controller) {
+                    controllerRef.current = null;
+                }
+            }
+        })();
+    }, [db]);
+    useEffect(() => {
+        return () => {
+            controllerRef.current?.abort();
+        };
+    }, []);
+    return { thinking, submit, cancel, isBusy: thinking !== null };
+}

package/dist/cli/ink/hooks/useCtrlCExit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Two-step exit state machine, Claude-style.
+ *
+ * - trigger({ bufferEmpty: false }) → caller should clear the input; returns "cleared"
+ * - trigger({ bufferEmpty: true, busy: true }) → caller should abort; returns "abort"
+ * - trigger({ bufferEmpty: true, busy: false }): first call sets `pending=true`
+ *   and returns "arm"; second call within 2s returns "exit".
+ */
+export declare function useCtrlCExit(): {
+    pending: boolean;
+    trigger: (opts: {
+        bufferEmpty: boolean;
+        busy: boolean;
+    }) => "clear-input" | "abort" | "arm" | "exit";
+    clear: () => void;
+};

package/dist/cli/ink/hooks/useCtrlCExit.js

@@ -0,0 +1,43 @@
+import { useCallback, useRef, useState } from "react";
+const EXIT_WINDOW_MS = 2000;
+/**
+ * Two-step exit state machine, Claude-style.
+ *
+ * - trigger({ bufferEmpty: false }) → caller should clear the input; returns "cleared"
+ * - trigger({ bufferEmpty: true, busy: true }) → caller should abort; returns "abort"
+ * - trigger({ bufferEmpty: true, busy: false }): first call sets `pending=true`
+ *   and returns "arm"; second call within 2s returns "exit".
+ */
+export function useCtrlCExit() {
+    const [pending, setPending] = useState(false);
+    const timerRef = useRef(null);
+    const clear = useCallback(() => {
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        timerRef.current = null;
+        setPending(false);
+    }, []);
+    const trigger = useCallback((opts) => {
+        if (opts.busy) {
+            clear();
+            return "abort";
+        }
+        if (!opts.bufferEmpty) {
+            clear();
+            return "clear-input";
+        }
+        if (pending) {
+            clear();
+            return "exit";
+        }
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        setPending(true);
+        timerRef.current = setTimeout(() => {
+            setPending(false);
+            timerRef.current = null;
+        }, EXIT_WINDOW_MS);
+        return "arm";
+    }, [pending, clear]);
+    return { pending, trigger, clear };
+}

package/dist/cli/ink/hooks/useFooterText.d.ts

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

package/dist/cli/ink/hooks/useFooterText.js

@@ -0,0 +1,43 @@
+import { useEffect, useMemo, useState } from "react";
+const HINTS = [
+    "try: what is my net worth?",
+    "try: how much did I spend on food this month?",
+    "try: when is my credit card due?",
+    "try: show me transactions over 5000 baht",
+    "try: which credit card has the highest balance?",
+    "try: how much income did I receive last month?",
+    "try: list all accounts",
+];
+export function useFooterText(db) {
+    const [tick, setTick] = useState(0);
+    const [hintIdx] = useState(() => Math.floor(Math.random() * HINTS.length));
+    useEffect(() => {
+        const id = setInterval(() => setTick((t) => t + 1), 60_000);
+        return () => clearInterval(id);
+    }, []);
+    return useMemo(() => {
+        const lastScan = db
+            .prepare(`SELECT MAX(scanned_at) AS ts FROM scanned_files WHERE status = 'scanned'`)
+            .get();
+        let scanStr = "";
+        if (lastScan?.ts) {
+            const diffMs = Date.now() - new Date(lastScan.ts + "Z").getTime();
+            const mins = Math.floor(diffMs / 60000);
+            if (mins < 1)
+                scanStr = "scanned just now";
+            else if (mins < 60)
+                scanStr = `scanned ${mins}m ago`;
+            else if (mins < 1440)
+                scanStr = `scanned ${Math.floor(mins / 60)}h ago`;
+            else
+                scanStr = `scanned ${Math.floor(mins / 1440)}d ago`;
+        }
+        const idx = (hintIdx + tick) % HINTS.length;
+        const parts = ["Plasalid"];
+        if (scanStr)
+            parts.push(scanStr);
+        parts.push(HINTS[idx]);
+        parts.push("ctrl+c to exit");
+        return parts.join("  |  ");
+    }, [db, tick, hintIdx]);
+}

package/dist/cli/ink/hooks/useTextInput.d.ts

@@ -0,0 +1,32 @@
+/** A multiline text buffer with a 2D cursor. */
+export interface TextBuffer {
+    lines: string[];
+    row: number;
+    col: number;
+}
+export interface UseTextInputOpts {
+    onSubmit: (text: string) => void;
+    onCtrlC: (bufferEmpty: boolean) => void;
+    /** Called every time the buffer changes — can be used for hints. */
+    onChange?: (buf: TextBuffer) => void;
+    /** Return true to signal the key was handled and default behavior should be skipped. */
+    onKey?: (key: {
+        code: number;
+        raw: string;
+    }) => boolean | void;
+}
+/**
+ * Raw-stdin driven keystroke state machine that owns a multiline buffer and
+ * exposes its current state plus reset/insert helpers. Purely stateful — Ink
+ * re-renders whenever the buffer changes via setBuffer.
+ *
+ * Handles: Enter/submit, Backspace, Ctrl+A/E/K/U/W, arrow keys, Option+←/→,
+ * Option+B/F, Option+Backspace, Kitty Cmd+Backspace, Shift+Enter (newline),
+ * bracketed paste.
+ */
+export declare function useTextInput(opts: UseTextInputOpts): {
+    buffer: TextBuffer;
+    reset: () => void;
+    insert: (text: string) => void;
+    isEmpty: boolean;
+};