@aiaiaichain/agent 0.1.4 → 0.1.6

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

package/dist/util/logger.js

@@ -0,0 +1,43 @@
+/**
+ * src/util/logger.ts — Structured logging with levels for AIAIAI Agent
+ */
+const LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function getMinLevel() {
+    const env = process.env.AIAIAI_LOG_LEVEL?.toLowerCase();
+    if (env && env in LEVEL_PRIORITY)
+        return env;
+    return 'info';
+}
+function shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[getMinLevel()];
+}
+function formatMessage(level, context, message, meta) {
+    const ts = new Date().toISOString();
+    const prefix = `[${ts}] [${level.toUpperCase()}] [${context}]`;
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+    return `${prefix} ${message}${metaStr}`;
+}
+export const logger = {
+    debug(context, message, meta) {
+        if (shouldLog('debug'))
+            console.error(formatMessage('debug', context, message, meta));
+    },
+    info(context, message, meta) {
+        if (shouldLog('info'))
+            console.error(formatMessage('info', context, message, meta));
+    },
+    warn(context, message, meta) {
+        if (shouldLog('warn'))
+            console.error(formatMessage('warn', context, message, meta));
+    },
+    error(context, message, meta) {
+        if (shouldLog('error'))
+            console.error(formatMessage('error', context, message, meta));
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/util/processManager.d.ts

@@ -0,0 +1,5 @@
+export declare class ProcessManager {
+    static setupGlobalHandlers(): void;
+    static shutdown(exitCode: number): void;
+}
+//# sourceMappingURL=processManager.d.ts.map

package/dist/util/processManager.js

@@ -0,0 +1,39 @@
+/**
+ * Process management utilities for AIAIAI Agent
+ */
+import { safeLog } from "./safeLog.js";
+export class ProcessManager {
+    static setupGlobalHandlers() {
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            safeLog('[UNCAUGHT_EXCEPTION] ' + error.message);
+            if (error.stack) {
+                safeLog('[STACK_TRACE] ' + error.stack);
+            }
+            // Gracefully shutdown
+            this.shutdown(1);
+        });
+        // Handle unhandled promises
+        process.on('unhandledRejection', (reason, promise) => {
+            safeLog('[UNHANDLED_REJECTION] ' + reason?.message || String(reason));
+            // Attempt graceful shutdown
+            this.shutdown(1);
+        });
+        // Handle graceful shutdown signals
+        process.on('SIGTERM', () => {
+            safeLog('[SIGTERM] Received shutdown signal');
+            this.shutdown(0);
+        });
+        process.on('SIGINT', () => {
+            safeLog('[SIGINT] Received shutdown signal');
+            this.shutdown(0);
+        });
+    }
+    static shutdown(exitCode) {
+        // Allow cleanup time
+        setTimeout(() => {
+            process.exit(exitCode);
+        }, 100);
+    }
+}
+//# sourceMappingURL=processManager.js.map

package/dist/util/resilientFetch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * src/util/resilientFetch.ts - Resilient HTTP client with timeout, retry, circuit breaker
+ */
+export interface FetchOptions {
+    timeout?: number;
+    retries?: number;
+    backoffMs?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+export interface CircuitState {
+    failures: number;
+    lastFailureTime: number;
+    state: "closed" | "open" | "half-open";
+}
+export declare function resilientFetch(url: string, options?: FetchOptions): Promise<Response>;
+export declare function isReachable(url: string, timeout?: number): Promise<boolean>;
+//# sourceMappingURL=resilientFetch.d.ts.map

package/dist/util/resilientFetch.js

@@ -0,0 +1,94 @@
+/**
+ * src/util/resilientFetch.ts - Resilient HTTP client with timeout, retry, circuit breaker
+ */
+const circuits = new Map();
+const CIRCUIT_THRESHOLD = 3;
+const CIRCUIT_RESET_MS = 60_000;
+function getCircuit(key) {
+    let c = circuits.get(key);
+    if (!c) {
+        c = { failures: 0, lastFailureTime: 0, state: "closed" };
+        circuits.set(key, c);
+    }
+    return c;
+}
+function canExecute(key) {
+    const c = getCircuit(key);
+    if (c.state === "closed")
+        return true;
+    if (c.state === "open" && Date.now() - c.lastFailureTime > CIRCUIT_RESET_MS) {
+        c.state = "half-open";
+        return true;
+    }
+    return c.state === "half-open";
+}
+function recordSuccess(key) {
+    const c = getCircuit(key);
+    c.failures = 0;
+    c.state = "closed";
+}
+function recordFailure(key) {
+    const c = getCircuit(key);
+    c.failures++;
+    c.lastFailureTime = Date.now();
+    if (c.failures >= CIRCUIT_THRESHOLD) {
+        c.state = "open";
+    }
+}
+export async function resilientFetch(url, options = {}) {
+    const { timeout = 8_000, retries = 2, backoffMs = 1_000, onRetry, method = "GET", headers, body, signal: externalSignal, } = options;
+    const circuitKey = new URL(url).hostname;
+    if (!canExecute(circuitKey)) {
+        throw new Error("Circuit open for " + circuitKey + " - service unavailable, retry later");
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        // Combine external abort signal with timeout
+        if (externalSignal) {
+            if (externalSignal.aborted)
+                controller.abort();
+            else
+                externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
+        try {
+            const response = await fetch(url, {
+                signal: controller.signal,
+                method,
+                headers,
+                body,
+            });
+            clearTimeout(timer);
+            if (!response.ok) {
+                throw new Error("HTTP " + response.status + ": " + response.statusText);
+            }
+            recordSuccess(circuitKey);
+            return response;
+        }
+        catch (error) {
+            clearTimeout(timer);
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < retries) {
+                onRetry?.(attempt + 1, lastError);
+                const delay = backoffMs * Math.pow(2, attempt);
+                await new Promise((r) => setTimeout(r, delay));
+            }
+        }
+    }
+    recordFailure(circuitKey);
+    throw lastError;
+}
+export async function isReachable(url, timeout = 5_000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=resilientFetch.js.map

package/dist/util/responseCache.d.ts

@@ -0,0 +1,27 @@
+/**
+ * src/util/responseCache.ts — TTL-based response cache for external APIs
+ */
+/**
+ * Get cached value or undefined if expired/missing.
+ */
+export declare function getCached<T>(key: string): T | undefined;
+/**
+ * Set value in cache with TTL (default 60s).
+ */
+export declare function setCache<T>(key: string, data: T, ttlMs?: number): void;
+/**
+ * Get or compute: return cached value, or compute, cache, and return.
+ */
+export declare function getOrCompute<T>(key: string, compute: () => Promise<T>, ttlMs?: number): Promise<T>;
+/**
+ * Clear all cached values.
+ */
+export declare function clearCache(): void;
+/**
+ * Get cache stats for diagnostics.
+ */
+export declare function cacheStats(): {
+    size: number;
+    entries: string[];
+};
+//# sourceMappingURL=responseCache.d.ts.map

package/dist/util/responseCache.js

@@ -0,0 +1,54 @@
+/**
+ * src/util/responseCache.ts — TTL-based response cache for external APIs
+ */
+const cache = new Map();
+const DEFAULT_TTL_MS = 60_000;
+/**
+ * Get cached value or undefined if expired/missing.
+ */
+export function getCached(key) {
+    const entry = cache.get(key);
+    if (!entry)
+        return undefined;
+    if (Date.now() > entry.expiresAt) {
+        cache.delete(key);
+        return undefined;
+    }
+    return entry.data;
+}
+/**
+ * Set value in cache with TTL (default 60s).
+ */
+export function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
+    cache.set(key, { data, expiresAt: Date.now() + ttlMs });
+    // Evict oldest if cache grows too large
+    if (cache.size > 200) {
+        const firstKey = cache.keys().next().value;
+        if (firstKey)
+            cache.delete(firstKey);
+    }
+}
+/**
+ * Get or compute: return cached value, or compute, cache, and return.
+ */
+export async function getOrCompute(key, compute, ttlMs = DEFAULT_TTL_MS) {
+    const cached = getCached(key);
+    if (cached !== undefined)
+        return cached;
+    const result = await compute();
+    setCache(key, result, ttlMs);
+    return result;
+}
+/**
+ * Clear all cached values.
+ */
+export function clearCache() {
+    cache.clear();
+}
+/**
+ * Get cache stats for diagnostics.
+ */
+export function cacheStats() {
+    return { size: cache.size, entries: [...cache.keys()] };
+}
+//# sourceMappingURL=responseCache.js.map

package/dist/util/safeLog.d.ts

@@ -1,8 +1,7 @@
 /**
- * safeLog — wraps console.log/error/warn to avoid corrupting Ink TUI output.
+ * src/util/safeLog.ts — Intercepts console output, masks secrets, routes to file
  */
-export declare function wireNotify(fn: (msg: string) => void): void;
-declare function safeLogFn(...args: unknown[]): void;
-export declare const safeLog: typeof safeLogFn;
-export {};
+export declare function wireNotify(fn?: (msg: string) => void): void;
+export declare function safeLog(...args: unknown[]): void;
+export declare function installSafeLogging(): void;
 //# sourceMappingURL=safeLog.d.ts.map