@aiaiaichain/agent 0.1.3 → 0.1.5

package/dist/tui/REPL.d.ts

@@ -1,5 +1,6 @@
 /**
- * REPL — scrolling message history + bottom input box.
+ * REPL — scrolling message history + feature-rich input box.
+ * Supports: multi-line (Shift+Enter), command history (↑/↓), tab completion.
  */
 import React from "react";
 export interface ChatMessage {

package/dist/tui/REPL.js

@@ -1,12 +1,33 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * REPL — scrolling message history + bottom input box.
+ * REPL — scrolling message history + feature-rich input box.
+ * Supports: multi-line (Shift+Enter), command history (↑/↓), tab completion.
  */
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef } from "react";
 import { Box, Text, useStdout, useInput } from "ink";
-import TextInput from "ink-text-input";
 import { AIAIAI_COLORS } from "./theme.js";
 const MAX_VISIBLE = 40;
+const MAX_HISTORY = 100;
+// ── Command completions ─────────────────────────────────────────────────────
+const COMMANDS = [
+    "token info", "token security", "token holders", "token traders",
+    "track kol", "track smartmoney", "track follow-wallet",
+    "market kline", "market trending", "market trenches", "market signal",
+    "watch", "unwatch", "watchlist", "alerts", "alert above", "alert below",
+    "compare",
+    "price", "news", "models", "cost", "model", "clear",
+    "wallet", "deposit", "burn", "actions", "activity", "fees",
+    "keys", "providers", "goals", "goal add", "goal done", "goal list",
+    "schedule", "sessions", "resume", "memory", "update", "gmgn", "help",
+    "exit", "quit",
+];
+function getCompletions(prefix) {
+    if (!prefix || prefix === "/")
+        return COMMANDS.map(c => `/${c}`);
+    const p = prefix.startsWith("/") ? prefix.slice(1) : prefix;
+    return COMMANDS.filter(c => c.startsWith(p)).map(c => `/${c}`);
+}
+// ── Message components ──────────────────────────────────────────────────────
 function MessageLine({ msg }) {
     const time = new Date(msg.ts).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
     if (msg.role === "user") {
@@ -24,25 +45,178 @@ function MessageLine({ msg }) {
     if (msg.role === "notify") {
         return (_jsx(Box, { borderStyle: "round", borderColor: AIAIAI_COLORS.accent, marginY: 1, paddingX: 1, children: _jsx(Text, { wrap: "wrap", children: msg.content }) }));
     }
-    // system messages — dimmed
+    // system — dimmed
     return (_jsx(Box, { flexDirection: "row", gap: 1, children: _jsx(Text, { color: AIAIAI_COLORS.dim, wrap: "wrap", children: msg.content }) }));
 }
+function InputBox({ value, onChange, onSubmit, disabled, onAbort }) {
+    const [cursor, setCursor] = useState(value.length);
+    const [history, setHistory] = useState([]);
+    const [historyIdx, setHistoryIdx] = useState(-1);
+    const [completions, setCompletions] = useState([]);
+    const [completionIdx, setCompletionIdx] = useState(-1);
+    const [showCompletions, setShowCompletions] = useState(false);
+    const valueRef = useRef(value);
+    const cursorRef = useRef(cursor);
+    valueRef.current = value;
+    cursorRef.current = cursor;
+    // Messages scroll handled by Ink container
+    const insertAtCursor = useCallback((text) => {
+        const before = valueRef.current.slice(0, cursorRef.current);
+        const after = valueRef.current.slice(cursorRef.current);
+        const newVal = before + text + after;
+        onChange(newVal);
+        setCursor(cursorRef.current + text.length);
+    }, [onChange]);
+    const doSubmit = useCallback(() => {
+        const val = valueRef.current;
+        if (!val.trim() || disabled)
+            return;
+        setHistory(prev => [val, ...prev].slice(0, MAX_HISTORY));
+        setHistoryIdx(-1);
+        setShowCompletions(false);
+        onChange("");
+        setCursor(0);
+        onSubmit(val);
+    }, [disabled, onChange, onSubmit]);
+    useInput((input, key) => {
+        // Always handle Escape for abort
+        if (key.escape) {
+            if (disabled) {
+                onAbort();
+                return;
+            }
+            setShowCompletions(false);
+            return;
+        }
+        if (disabled)
+            return;
+        // Tab completion
+        if (key.tab) {
+            const val = valueRef.current;
+            if (!showCompletions) {
+                // Check only when typing a command
+                if (val.startsWith("/") && val.length > 0) {
+                    const comps = getCompletions(val);
+                    if (comps.length === 1 && comps[0] !== val) {
+                        // Auto-complete if only one match
+                        onChange(comps[0] + " ");
+                        setCursor(comps[0].length + 1);
+                        return;
+                    }
+                    if (comps.length > 0) {
+                        setCompletions(comps);
+                        setCompletionIdx(0);
+                        setShowCompletions(true);
+                        return;
+                    }
+                }
+                return;
+            }
+            // Cycle through completions
+            if (completions.length > 0) {
+                const nextIdx = (completionIdx + 1) % completions.length;
+                setCompletionIdx(nextIdx);
+                // Show the completion
+                const comp = completions[nextIdx];
+                onChange(comp + " ");
+                setCursor(comp.length + 1);
+            }
+            return;
+        }
+        // Close completions on any other key
+        if (showCompletions)
+            setShowCompletions(false);
+        // Enter submits
+        if (key.return) {
+            // Shift+Enter = new line, Enter = submit
+            if (input === "\r" && !key.shift) {
+                doSubmit();
+                return;
+            }
+            // Shift+Enter inserts newline
+            if (key.shift || input === "\u0003") {
+                insertAtCursor("\n");
+                return;
+            }
+        }
+        // History navigation (↑/↓)
+        if (key.upArrow) {
+            if (history.length === 0)
+                return;
+            const newIdx = historyIdx < history.length - 1 ? historyIdx + 1 : historyIdx;
+            setHistoryIdx(newIdx);
+            onChange(history[newIdx]);
+            setCursor(history[newIdx].length);
+            return;
+        }
+        if (key.downArrow) {
+            if (historyIdx <= 0) {
+                setHistoryIdx(-1);
+                onChange("");
+                setCursor(0);
+                return;
+            }
+            const newIdx = historyIdx - 1;
+            setHistoryIdx(newIdx);
+            onChange(history[newIdx]);
+            setCursor(history[newIdx].length);
+            return;
+        }
+        // Left/right arrow — update cursor tracking
+        if (key.leftArrow) {
+            setCursor(Math.max(0, cursorRef.current - 1));
+            return;
+        }
+        if (key.rightArrow) {
+            setCursor(Math.min(valueRef.current.length, cursorRef.current + 1));
+            return;
+        }
+        // Backspace
+        if (key.backspace || key.delete) {
+            if (cursorRef.current <= 0)
+                return;
+            const before = valueRef.current.slice(0, cursorRef.current - 1);
+            const after = valueRef.current.slice(cursorRef.current);
+            onChange(before + after);
+            setCursor(cursorRef.current - 1);
+            return;
+        }
+        // Printable character
+        if (input && input.length === 1 && input.charCodeAt(0) >= 32) {
+            insertAtCursor(input);
+            return;
+        }
+    });
+    const placeholder = disabled ? "thinking…" : "message or /command";
+    const displayValue = value || placeholder;
+    const inputLines = displayValue.split("\n");
+    const inputHeight = Math.min(inputLines.length, 5); // max 5 visible lines
+    return (_jsxs(Box, { flexDirection: "column", children: [showCompletions && completions.length > 0 && (_jsxs(Box, { borderStyle: "single", borderColor: AIAIAI_COLORS.accent, paddingX: 1, flexDirection: "column", marginBottom: 0, children: [completions.slice(0, 8).map((c, i) => (_jsxs(Text, { color: i === completionIdx ? AIAIAI_COLORS.accent : AIAIAI_COLORS.muted, bold: i === completionIdx, children: [i === completionIdx ? "▸ " : "  ", c] }, c))), completions.length > 8 && (_jsxs(Text, { color: AIAIAI_COLORS.dim, children: ["  \u2026", completions.length - 8, " more"] }))] })), _jsx(Box, { borderStyle: "round", borderColor: disabled ? AIAIAI_COLORS.dim : AIAIAI_COLORS.accent, paddingX: 1, paddingY: inputHeight > 1 ? 0 : 0, flexDirection: "column", marginTop: 1, children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: AIAIAI_COLORS.accent, bold: true, children: "\u203A " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: value ? (
+                            // Show actual input with cursor
+                            inputLines.slice(0, 5).map((line, i) => {
+                                const isCursorLine = i === Math.min(cursorRef.current, inputLines.length - 1);
+                                const cursorCol = isCursorLine
+                                    ? cursorRef.current - inputLines.slice(0, i).join("\n").length - (i > 0 ? 1 : 0)
+                                    : line.length;
+                                const cursorColClamped = Math.min(cursorCol, line.length);
+                                const before = line.slice(0, cursorColClamped);
+                                const at = line[cursorColClamped] || " ";
+                                const after = line.slice(cursorColClamped + 1);
+                                return (_jsxs(Text, { wrap: "truncate-end", children: [before, _jsx(Text, { inverse: true, children: at }), after] }, i));
+                            })) : (_jsx(Text, { color: AIAIAI_COLORS.dim, children: placeholder })) })] }) })] }));
+}
 export function REPL({ messages, streamingText, toolRunning, onSubmit, onAbort, disabled }) {
     const [input, setInput] = useState("");
     const { stdout } = useStdout();
-    const termWidth = stdout?.columns ?? 80;
+    const termWidth = (stdout?.columns ?? 80) - 2;
     const handleSubmit = useCallback((val) => {
-        const trimmed = val.trim();
-        if (!trimmed || disabled)
-            return;
-        setInput("");
-        onSubmit(trimmed);
-    }, [onSubmit, disabled]);
-    useInput((_input, key) => {
-        if (key.escape && disabled && onAbort)
-            onAbort();
-    });
+        onSubmit(val);
+    }, [onSubmit]);
+    const handleAbort = useCallback(() => {
+        onAbort?.();
+    }, [onAbort]);
+    // Scrolling: show last N messages
     const visible = messages.slice(-MAX_VISIBLE);
-    return (_jsxs(Box, { flexDirection: "column", width: termWidth, children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [visible.map(m => _jsx(MessageLine, { msg: m }, m.id)), streamingText && (_jsxs(Box, { flexDirection: "row", gap: 1, marginTop: 1, children: [_jsx(Text, { color: AIAIAI_COLORS.muted, children: "   " }), _jsx(Text, { color: AIAIAI_COLORS.header, bold: true, children: "\uD83E\uDD16  " }), _jsx(Text, { wrap: "wrap", children: streamingText })] })), toolRunning && (_jsx(Box, { flexDirection: "row", gap: 1, marginTop: 1, children: _jsxs(Text, { color: AIAIAI_COLORS.warn, children: ["\u2699  running ", toolRunning, "\u2026"] }) }))] }), _jsxs(Box, { borderStyle: "round", borderColor: disabled ? AIAIAI_COLORS.dim : AIAIAI_COLORS.accent, paddingX: 1, marginTop: 1, children: [_jsx(Text, { color: AIAIAI_COLORS.accent, children: "\u203A " }), _jsx(TextInput, { value: input, onChange: setInput, onSubmit: handleSubmit, placeholder: disabled ? "thinking…" : "message or /command" })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [visible.map(m => _jsx(MessageLine, { msg: m }, m.id)), streamingText && (_jsxs(Box, { flexDirection: "row", gap: 1, marginTop: 1, children: [_jsx(Text, { color: AIAIAI_COLORS.muted, children: "   " }), _jsx(Text, { color: AIAIAI_COLORS.header, bold: true, children: "\uD83E\uDD16  " }), _jsx(Text, { wrap: "wrap", children: streamingText })] })), toolRunning && (_jsx(Box, { flexDirection: "row", gap: 1, marginTop: 1, children: _jsxs(Text, { color: AIAIAI_COLORS.warn, children: ["\u2699  running ", toolRunning, "\u2026"] }) }))] }), _jsx(InputBox, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: !!disabled, onAbort: handleAbort })] }));
 }
 //# sourceMappingURL=REPL.js.map

package/dist/tui/Sparkline.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/tui/Sparkline.tsx — Mini ASCII sparkline chart for sidebar.
+ * Uses Unicode block characters: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █
+ */
+import React from "react";
+export interface SparklineProps {
+    data: number[];
+    width?: number;
+    label?: string;
+    color?: string;
+}
+export declare function Sparkline({ data, width, label, color }: SparklineProps): React.JSX.Element | null;
+/** Track a rolling price history for sparkline use */
+export declare class PriceHistory {
+    private prices;
+    private maxLength;
+    constructor(maxLength?: number);
+    push(price: number): void;
+    getData(): number[];
+}
+//# sourceMappingURL=Sparkline.d.ts.map

package/dist/tui/Sparkline.js

@@ -0,0 +1,44 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const CHARS = "▁▂▃▄▅▆▇█";
+export function Sparkline({ data, width = 30, label, color }) {
+    if (!data || data.length < 2)
+        return null;
+    const min = Math.min(...data);
+    const max = Math.max(...data);
+    const range = max - min || 1;
+    // Normalize and compress to width
+    const compressed = [];
+    const step = data.length / width;
+    for (let i = 0; i < width; i++) {
+        const idx = Math.floor(i * step);
+        compressed.push(data[idx]);
+    }
+    const bars = compressed.map(v => {
+        const normalized = (v - min) / range;
+        const idx = Math.min(7, Math.floor(normalized * 8));
+        return CHARS[Math.max(0, idx)];
+    }).join("");
+    const trend = data[data.length - 1] > (data[0] ?? data[data.length - 1]) ? "▲" : "▼";
+    const minStr = min < 1 ? min.toFixed(6) : min < 100 ? min.toFixed(2) : min.toLocaleString();
+    const maxStr = max < 1 ? max.toFixed(6) : max < 100 ? max.toFixed(2) : max.toLocaleString();
+    return (_jsxs(Box, { flexDirection: "column", children: [label && _jsxs(Text, { dimColor: true, children: [label, " ", trend] }), _jsx(Text, { color: color, children: bars }), _jsxs(Text, { dimColor: true, children: ["$", minStr, " \u2013 $", maxStr] })] }));
+}
+/** Track a rolling price history for sparkline use */
+export class PriceHistory {
+    prices = [];
+    maxLength;
+    constructor(maxLength = 50) {
+        this.maxLength = maxLength;
+    }
+    push(price) {
+        this.prices.push(price);
+        if (this.prices.length > this.maxLength) {
+            this.prices = this.prices.slice(-this.maxLength);
+        }
+    }
+    getData() {
+        return [...this.prices];
+    }
+}
+//# sourceMappingURL=Sparkline.js.map

package/dist/tui/StatusBar.d.ts

@@ -9,6 +9,10 @@ export interface StatusBarProps {
     toolRunning: string | null;
     connected: boolean;
     statusLine?: string | null;
+    cpu?: number;
+    ram?: number;
+    uptime?: string;
+    apiCalls?: number;
 }
-export declare function StatusBar({ model, chain, price, toolRunning, connected, statusLine }: StatusBarProps): React.JSX.Element;
+export declare function StatusBar({ model, chain, price, toolRunning, connected, statusLine, cpu, ram, uptime, apiCalls }: StatusBarProps): React.JSX.Element;
 //# sourceMappingURL=StatusBar.d.ts.map

package/dist/tui/StatusBar.js

@@ -1,13 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { AIAIAI_COLORS } from "./theme.js";
-export function StatusBar({ model, chain, price, toolRunning, connected, statusLine }) {
+export function StatusBar({ model, chain, price, toolRunning, connected, statusLine, cpu, ram, uptime, apiCalls }) {
     const chainShort = chain.slice(0, 8);
-    const modelShort = model.split("/").pop()?.slice(0, 18) ?? model.slice(0, 18);
+    const modelShort = model.split("/").pop()?.slice(0, 16) ?? model.slice(0, 16);
+    const cpuColor = (cpu ?? 0) > 80 ? AIAIAI_COLORS.error : (cpu ?? 0) > 50 ? AIAIAI_COLORS.warn : AIAIAI_COLORS.success;
+    const ramColor = (ram ?? 0) > 85 ? AIAIAI_COLORS.error : (ram ?? 0) > 60 ? AIAIAI_COLORS.warn : AIAIAI_COLORS.success;
     return (_jsxs(Box, { borderStyle: "single", borderColor: AIAIAI_COLORS.dim, paddingX: 1, flexDirection: "row", justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: AIAIAI_COLORS.accent, bold: true, children: "\uD83E\uDD16 AIAIAI" }), price ? _jsx(Text, { color: AIAIAI_COLORS.success, children: price }) : null, _jsx(Text, { color: AIAIAI_COLORS.muted, children: modelShort })] }), _jsx(Box, { children: toolRunning
                     ? _jsxs(Text, { color: AIAIAI_COLORS.warn, children: ["\u2699 ", toolRunning] })
                     : statusLine
-                        ? _jsx(Text, { color: AIAIAI_COLORS.muted, children: statusLine.slice(0, 80) })
-                        : _jsx(Text, { color: AIAIAI_COLORS.muted, children: connected ? "ready" : "connecting…" }) }), _jsx(Box, { gap: 2, children: _jsxs(Text, { color: AIAIAI_COLORS.header, children: ["\u26D3 ", chainShort] }) })] }));
+                        ? _jsx(Text, { color: AIAIAI_COLORS.muted, children: statusLine.slice(0, 60) })
+                        : _jsx(Text, { color: AIAIAI_COLORS.muted, children: connected ? "ready" : "connecting…" }) }), _jsxs(Box, { gap: 2, children: [cpu !== undefined && _jsxs(Text, { color: cpuColor, children: ["CPU:", cpu, "%"] }), ram !== undefined && _jsxs(Text, { color: ramColor, children: ["RAM:", ram, "%"] }), uptime && _jsx(Text, { color: AIAIAI_COLORS.muted, children: uptime }), apiCalls !== undefined && _jsxs(Text, { color: AIAIAI_COLORS.muted, children: ["API:", apiCalls, "/m"] }), _jsxs(Text, { color: AIAIAI_COLORS.header, children: ["\u26D3 ", chainShort] })] })] }));
 }
 //# sourceMappingURL=StatusBar.js.map

package/dist/tui/ThemePresets.d.ts

@@ -0,0 +1,25 @@
+/**
+ * src/tui/ThemePresets.ts — Theme presets system for AIAIAI TUI.
+ * 5 built-in presets + custom via ~/.aiaiai/config/theme.json
+ */
+export interface ThemeColors {
+    accent: string;
+    header: string;
+    muted: string;
+    dim: string;
+    success: string;
+    warn: string;
+    error: string;
+    background: string;
+}
+export interface ThemePreset {
+    name: string;
+    description: string;
+    colors: ThemeColors;
+}
+export declare const PRESETS: Record<string, ThemePreset>;
+export declare function getCurrentTheme(): string;
+export declare function setTheme(name: string): boolean;
+export declare function getPresetColors(): ThemeColors;
+export declare function listThemes(): string;
+//# sourceMappingURL=ThemePresets.d.ts.map

package/dist/tui/ThemePresets.js

@@ -0,0 +1,117 @@
+/**
+ * src/tui/ThemePresets.ts — Theme presets system for AIAIAI TUI.
+ * 5 built-in presets + custom via ~/.aiaiai/config/theme.json
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
+export const PRESETS = {
+    "solana": {
+        name: "Solana Sunset",
+        description: "Warm gradients inspired by the Solana blockchain colors",
+        colors: {
+            accent: "#9945FF",
+            header: "#14F195",
+            muted: "#888888",
+            dim: "#444444",
+            success: "#14F195",
+            warn: "#FFD600",
+            error: "#FF4444",
+            background: "#111111",
+        },
+    },
+    "cyberpunk": {
+        name: "Cyberpunk",
+        description: "Neon pink and cyan — late night trading terminal",
+        colors: {
+            accent: "#FF00FF",
+            header: "#00FFFF",
+            muted: "#666666",
+            dim: "#333333",
+            success: "#00FF44",
+            warn: "#FFFF00",
+            error: "#FF0044",
+            background: "#0A0A0A",
+        },
+    },
+    "monochrome": {
+        name: "Monochrome",
+        description: "Clean grayscale — professional trading desk",
+        colors: {
+            accent: "#FFFFFF",
+            header: "#DDDDDD",
+            muted: "#888888",
+            dim: "#444444",
+            success: "#CCCCCC",
+            warn: "#999999",
+            error: "#FF4444",
+            background: "#111111",
+        },
+    },
+    "forest": {
+        name: "Forest",
+        description: "Calm greens — for zen trading sessions",
+        colors: {
+            accent: "#50FA7B",
+            header: "#7BFA50",
+            muted: "#6272A4",
+            dim: "#44475A",
+            success: "#50FA7B",
+            warn: "#F1FA8C",
+            error: "#FF5555",
+            background: "#1A2D1A",
+        },
+    },
+    "ocean": {
+        name: "Ocean",
+        description: "Deep blues — data-rich dashboard feel",
+        colors: {
+            accent: "#8BE9FD",
+            header: "#6272A4",
+            muted: "#6272A4",
+            dim: "#44475A",
+            success: "#50FA7B",
+            warn: "#F1FA8C",
+            error: "#FF5555",
+            background: "#0D1B2A",
+        },
+    },
+};
+export function getCurrentTheme() {
+    const configPath = join(AIAIAI_HOME, "config", "theme.json");
+    try {
+        if (existsSync(configPath)) {
+            const raw = readFileSync(configPath, "utf-8");
+            const config = JSON.parse(raw);
+            return config.theme || "solana";
+        }
+    }
+    catch { /* use default */ }
+    return "solana";
+}
+export function setTheme(name) {
+    const preset = PRESETS[name];
+    if (!preset)
+        return false;
+    const configDir = join(AIAIAI_HOME, "config");
+    const configPath = join(configDir, "theme.json");
+    try {
+        const { mkdirSync, writeFileSync } = require("node:fs");
+        if (!existsSync(configDir))
+            mkdirSync(configDir, { recursive: true });
+        writeFileSync(configPath, JSON.stringify({ theme: name, colors: preset.colors }, null, 2), "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function getPresetColors() {
+    const themeName = getCurrentTheme();
+    return PRESETS[themeName]?.colors ?? PRESETS["solana"].colors;
+}
+export function listThemes() {
+    return Object.entries(PRESETS).map(([key, preset]) => `  ${key === getCurrentTheme() ? "★" : " "} ${key.padEnd(14)} ${preset.description}`).join("\n");
+}
+//# sourceMappingURL=ThemePresets.js.map

package/dist/util/clipboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * src/util/clipboard.ts — Copy text to system clipboard via OSC 52 escape sequences.
+ * Works in most modern terminals: iTerm2, Terminal.app, kitty, WezTerm, Alacritty.
+ */
+export declare function encodeOSC52(text: string): string;
+export declare function copyToClipboard(text: string): boolean;
+/** Get a friendly message indicating clipboard support */
+export declare function clipboardSupported(): string;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/util/clipboard.js

@@ -0,0 +1,26 @@
+/**
+ * src/util/clipboard.ts — Copy text to system clipboard via OSC 52 escape sequences.
+ * Works in most modern terminals: iTerm2, Terminal.app, kitty, WezTerm, Alacritty.
+ */
+export function encodeOSC52(text) {
+    const encoded = Buffer.from(text).toString("base64");
+    return `\x1b]52;c;${encoded}\x07`;
+}
+export function copyToClipboard(text) {
+    try {
+        process.stdout.write(encodeOSC52(text));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Get a friendly message indicating clipboard support */
+export function clipboardSupported() {
+    const term = process.env.TERM_PROGRAM ?? "";
+    const isTerminalApp = process.env.TERM?.includes("xterm") || term.includes("iTerm") || term.includes("kitty") || term.includes("Wez") || term.includes("Alacritty") || term.includes("Terminal");
+    if (isTerminalApp)
+        return "✅ Clipboard ready (OSC 52)";
+    return "⚠️ Clipboard may not be supported in this terminal";
+}
+//# sourceMappingURL=clipboard.js.map

package/dist/util/commandSuggest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * src/util/commandSuggest.ts — Levenshtein-based command suggestions.
+ * When a user types an unknown command, suggest the closest match.
+ */
+export declare function levenshtein(a: string, b: string): number;
+export declare function suggestCommands(input: string, maxResults?: number): string[];
+//# sourceMappingURL=commandSuggest.d.ts.map

package/dist/util/commandSuggest.js

@@ -0,0 +1,44 @@
+/**
+ * src/util/commandSuggest.ts — Levenshtein-based command suggestions.
+ * When a user types an unknown command, suggest the closest match.
+ */
+const COMMANDS = [
+    "help", "exit", "quit", "clear",
+    "price", "news", "models", "cost", "model",
+    "wallet", "deposit", "burn", "actions", "activity", "fees",
+    "keys", "providers", "goals", "goal add", "goal done",
+    "schedule", "sessions", "resume", "memory", "update", "gmgn",
+    "token info", "token security", "token holders", "token traders",
+    "track kol", "track smartmoney", "track follow-wallet",
+    "market kline", "market trending", "market trenches", "market signal",
+    "watch", "unwatch", "watchlist", "alerts", "alert", "compare", "portfolio",
+    "diff", "explain", "copy", "theme", "status",
+];
+export function levenshtein(a, b) {
+    const alen = a.length, blen = b.length;
+    const matrix = [];
+    for (let i = 0; i <= alen; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= blen; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= alen; i++) {
+        for (let j = 1; j <= blen; j++) {
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+    }
+    return matrix[alen][blen];
+}
+export function suggestCommands(input, maxResults = 3) {
+    const normalized = input.toLowerCase().replace(/^\/+/, "");
+    if (!normalized || normalized.length < 1)
+        return [];
+    const scored = COMMANDS.map(cmd => ({
+        cmd,
+        dist: levenshtein(normalized, cmd),
+    }));
+    scored.sort((a, b) => a.dist - b.dist);
+    return scored.slice(0, maxResults).filter(s => s.dist <= 4).map(s => s.cmd);
+}
+//# sourceMappingURL=commandSuggest.js.map

package/dist/util/confirmation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * src/util/confirmation.ts — Confirmation prompt for destructive operations
+ */
+export declare function requireConfirmation(message: string): Promise<boolean>;
+export declare function isNonInteractive(): boolean;
+//# sourceMappingURL=confirmation.d.ts.map

package/dist/util/confirmation.js

@@ -0,0 +1,16 @@
+/**
+ * src/util/confirmation.ts — Confirmation prompt for destructive operations
+ */
+import { createInterface } from "node:readline";
+export async function requireConfirmation(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((res) => {
+        rl.question(`${message} (yes/no): `, res);
+    });
+    rl.close();
+    return answer.trim().toLowerCase() === "yes" || answer.trim().toLowerCase() === "y";
+}
+export function isNonInteractive() {
+    return !process.stdin.isTTY || process.env.AIAIAI_YES === "1" || process.env.CI === "true";
+}
+//# sourceMappingURL=confirmation.js.map

package/dist/util/errorHandler.d.ts

@@ -0,0 +1,3 @@
+export declare function withErrorHandling<T>(operation: () => Promise<T>, context: string): Promise<T>;
+export declare function setupGlobalErrorHandlers(): void;
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/util/errorHandler.js

@@ -0,0 +1,28 @@
+/**
+ * Global error handling utilities for AIAIAI agent
+ */
+import { safeLog } from "./safeLog.js";
+// Generic error handler to wrap async operations
+export function withErrorHandling(operation, context) {
+    return operation().catch((error) => {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        safeLog(`[${context}] ERROR: ${errorMessage}`);
+        if (error instanceof Error) {
+            safeLog(`Stack trace: ${error.stack}`);
+        }
+        throw error; // Re-throw to maintain expected behavior
+    });
+}
+// Enhanced logging for unhandled promise rejections
+export function setupGlobalErrorHandlers() {
+    process.on('unhandledRejection', (reason, promise) => {
+        console.error('[UNHANDLED_REJECTION] Reason:', reason);
+        console.error('[PROMISE]', promise);
+        process.exit(1);
+    });
+    process.on('uncaughtException', (error) => {
+        console.error('[UNCAUGHT_EXCEPTION]', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=errorHandler.js.map

package/dist/util/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * src/util/logger.ts — Structured logging with levels for AIAIAI Agent
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare const logger: {
+    debug(context: string, message: string, meta?: unknown): void;
+    info(context: string, message: string, meta?: unknown): void;
+    warn(context: string, message: string, meta?: unknown): void;
+    error(context: string, message: string, meta?: unknown): void;
+};
+//# sourceMappingURL=logger.d.ts.map