@aiaiaichain/agent 0.1.1

package/README.md

@@ -0,0 +1,157 @@
+# aiaiaichain
+
+<div align="center">
+
+<pre>
+   █████╗ ██╗ █████╗ ██╗ █████╗ ██╗
+  ██╔══██╗██║██╔══██╗██║██╔══██╗██║
+  ███████║██║███████║██║███████║██║
+  ██╔══██║██║██╔══██║██║██╔══██║██║
+  ██║  ██║██║██║  ██║██║██║  ██║██║
+  ╚═╝  ╚═╝╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝╚═╝
+</pre>
+
+**$AIAIAI — Solana-native AI agent for decentralized AI governance.**
+
+[![npm](https://img.shields.io/npm/v/@aiaiaichain/agent?color=ff3366&style=flat-square)](https://www.npmjs.com/package/@aiaiaichain/agent)
+[![Node](https://img.shields.io/badge/node-%3E%3D20-brightgreen?style=flat-square)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=flat-square)](LICENSE)
+
+[X / Twitter](https://x.com/aiaiaisol)
+
+</div>
+
+---
+
+## What is AIAIAI Chain?
+
+AIAIAI Chain Agent is a Solana-native AI agent that runs entirely in your terminal. It connects to AI model providers and the DexScreener price API through outbound HTTP calls only — nothing is hosted, nothing listens for inbound connections, and your keys never leave your machine.
+
+**Ticker:** $AIAIAI
+**Contract:** `AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump`
+**Chain:** Solana (primary)
+
+Inspired by the call for an "AI Associated Institute of America" (AIAIAI) — a vision for decentralized AI governance.
+
+```
+Your machine
+├── @aiaiaichain/agent (CLI)
+│   ├── Ink TUI             ← streaming terminal UI with sidebar
+│   ├── AgentRunner         ← model loop + tool dispatcher
+│   ├── SwarmRouter         ← parallel sub-agent orchestration
+│   ├── PriceFeed           ← DexScreener price data (primary source)
+│   ├── NewsFeed            ← crypto news + sentiment analysis
+│   ├── TechnicalAnalysis   ← RSI, MACD, Bollinger, EMA, ATR
+│   ├── MarketSentiment     ← Fear & Greed, funding rates, DeFi TVL
+│   ├── GoalManager         ← persistent cross-session goals
+│   ├── AgentScheduler      ← cron/price-triggered scheduled tasks
+│   ├── MemoryStore         ← long-term conversation memory
+│   └── MCPServer           ← Model Context Protocol server
+│
+├── ~/.aiaiai/
+│   ├── .env                ← your API keys
+│   ├── config/             ← settings
+│   ├── memory/             ← long-term memory
+│   ├── checkpoints/        ← agent state checkpoints
+│   └── sessions/           ← task contexts
+│
+└── Outbound only:
+    ├── openrouter.ai           ← AI model gateway (your key)
+    ├── api.dexscreener.com     ← token prices, liquidity, volume
+    ├── api.binance.com         ← OHLCV candle data
+    ├── api.alternative.me      ← Fear & Greed Index
+    ├── api.llama.fi            ← DeFi TVL
+    ├── mempool.space           ← BTC mempool
+    └── cryptopanic.com         ← crypto news
+```
+
+## Installation
+
+```bash
+npm install -g @aiaiaichain/agent
+```
+
+## Quick Start
+
+```bash
+# 1. Configure (requires OpenRouter API key)
+aiaiaichain setup
+
+# 2. Start the agent
+aiaiaichain
+
+# 3. Or check $AIAIAI price directly
+aiaiaichain price
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `aiaiaichain` | Start interactive TUI agent |
+| `aiaiaichain setup` | First-time setup wizard |
+| `aiaiaichain config` | Show/edit configuration |
+| `aiaiaichain price` | Show $AIAIAI token price |
+| `aiaiaichain status` | Quick status + price |
+| `aiaiaichain --headless "prompt"` | Single-turn mode |
+| `aiaiaichain --help` | Show help |
+| `aiaiaichain --version` | Show version |
+
+## TUI Commands
+
+Inside the interactive agent:
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show all commands |
+| `/price` | Show $AIAIAI price |
+| `/news` | Latest crypto news |
+| `/models` | List available models |
+| `/model` | Switch AI model |
+| `/cost` | Show token usage cost |
+| `/goal add <text>` | Set a persistent goal |
+| `/goal done <id>` | Complete a goal |
+| `/goals` | List all goals |
+| `/schedule` | List scheduled tasks |
+| `/memory <query>` | Search conversation memory |
+| `/clear` | Clear chat history |
+| `/exit` | Exit the agent |
+
+## MCP Server
+
+The included MCP server exposes AIAIAI tools via the Model Context Protocol (stdio):
+
+```bash
+aiaiai-mcp
+```
+
+Tools: `get_aiaiai_price`, `get_token_price`, `get_news`, `get_candles`, `get_fear_greed`, `get_funding_rates`, `get_btc_mempool`, `get_defi_tvl`, `get_solana_stats`
+
+## Architecture
+
+- **Solana-first** — primary chain is Solana. EVM chains (Ethereum, Base, Arbitrum, BSC) are available but disabled by default.
+- **DexScreener** — all token price data comes from the DexScreener public API.
+- **OpenRouter** — AI model access via OpenRouter (supports 200+ models).
+- **Ink TUI** — React-based terminal UI with live price sidebar, news panel, and context window tracking.
+- **Zero inbound** — all outbound connections. No server, no listening ports.
+
+## Configuration
+
+Configuration lives in `~/.aiaiai/.env`:
+
+```env
+OPENROUTER_API_KEY=sk-or-...
+SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+DEFAULT_MODEL=openai/gpt-4o
+```
+
+Get an OpenRouter key at https://openrouter.ai/keys
+
+## Links
+
+- [X / Twitter](https://x.com/aiaiaisol)
+- [npm](https://www.npmjs.com/package/@aiaiaichain/agent)
+
+## License
+
+MIT

package/bin/aiai-mcp

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * AIAIAI MCP server launcher — exposes AIAIAI tools over stdio (Model Context Protocol).
+ */
+
+import { resolve, join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const AIAIAI_HOME = process.env.AIAIAI_HOME || join(homedir(), '.aiaiai');
+
+const envPath = join(AIAIAI_HOME, '.env');
+if (existsSync(envPath)) {
+  for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
+    const m = line.trim().match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (m && !process.env[m[1]]) process.env[m[1]] = m[2].replace(/^["']|["']$/g, '');
+  }
+}
+
+const entry = join(PKG_ROOT, 'dist', 'mcp', 'entry.js');
+if (!existsSync(entry)) {
+  process.stderr.write('AIAIAI MCP server not built. Run: npm run build\n');
+  process.exit(1);
+}
+
+await import(entry);

package/bin/aiaiaicli

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * AIAIAI Chain Agent launcher.
+ */
+
+import { spawn, execFileSync } from 'node:child_process';
+import { resolve, join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const AIAIAI_HOME = process.env.AIAIAI_HOME || join(homedir(), '.aiaiai');
+
+const envPath = join(AIAIAI_HOME, '.env');
+if (existsSync(envPath)) {
+  for (const line of readFileSync(envPath, 'utf-8').split('\n')) {
+    const m = line.trim().match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+    if (m && !process.env[m[1]]) process.env[m[1]] = m[2].replace(/^["']|["']$/g, '');
+  }
+}
+
+if (!existsSync(AIAIAI_HOME)) {
+  mkdirSync(AIAIAI_HOME, { recursive: true });
+}
+
+const cliPath = join(PKG_ROOT, 'dist', 'cli.js');
+if (!existsSync(cliPath)) {
+  console.error('\n  AIAIAI Chain Agent is not built. Run: npm run build\n');
+  process.exit(1);
+}
+
+const WIDE_CHAR_OFFSET = 6;
+const rawCols = process.stdout.columns || 120;
+const rawRows = process.stdout.rows || 40;
+const cols = Math.max(40, rawCols - WIDE_CHAR_OFFSET);
+
+try { execFileSync('stty', ['cols', String(cols)], { stdio: 'inherit' }); } catch { /* non-TTY */ }
+
+const child = spawn(process.execPath, [cliPath, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    AIAIAI_HOME,
+    COLUMNS: String(cols),
+    LINES: String(rawRows),
+    TERM: process.env.TERM || 'xterm-256color',
+    FORCE_COLOR: '3',
+  },
+});
+
+child.on('error', err => { console.error(`\nFailed to start AIAIAI: ${err.message}\n`); process.exit(1); });
+child.on('exit', (code, signal) => {
+  try { execFileSync('stty', ['cols', String(rawCols)], { stdio: 'inherit' }); } catch {}
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});

package/dist/api/ExtensionAPI.d.ts

@@ -0,0 +1,68 @@
+/**
+ * ExtensionAPI — types for the extension system.
+ * Extensions export a function that receives an ExtensionAPI object.
+ */
+import type { TSchema } from "@sinclair/typebox";
+export interface ThemeContext {
+    fg(color: string, text: string): string;
+}
+export interface UIContext {
+    notify(message: string): void;
+    setStatus(key: string, value: string): void;
+    setTheme(name: string): void;
+    setHeader(factory: ((theme: ThemeContext) => string) | null): void;
+    showModelSelector(query?: string): void;
+    theme: ThemeContext;
+}
+export interface ToolContent {
+    type: "text";
+    text: string;
+}
+export interface ToolResult {
+    content: ToolContent[];
+    details?: Record<string, unknown>;
+    isError?: boolean;
+}
+export interface ToolDef<P extends TSchema = any> {
+    name: string;
+    label?: string;
+    description: string;
+    parameters: P;
+    execute: (invocationId: string, params: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+}
+export interface CommandContext {
+    ui: UIContext;
+}
+export interface CommandDef {
+    description: string;
+    handler: (args: string, ctx: CommandContext) => Promise<void> | void;
+}
+export interface SkillDef {
+    name: string;
+    description: string;
+    tools?: ToolDef[];
+    commands?: [string, CommandDef][];
+    hooks?: Partial<Record<SessionEvent, (...args: any[]) => Promise<void>>>;
+}
+export type SessionEvent = "session_start" | "session_end" | "before_agent_start" | "session_shutdown";
+export interface SessionContext {
+    ui: UIContext;
+    hasUI: boolean;
+    config: Record<string, string | undefined>;
+}
+export interface SessionEventMap {
+    session_start: [ctx: SessionContext];
+    session_end: [ctx: SessionContext];
+    before_agent_start: [prompt: string];
+    session_shutdown: [];
+}
+export interface ExtensionAPI {
+    registerCommand(name: string, def: CommandDef): void;
+    registerTool<P extends TSchema>(def: ToolDef<P>): void;
+    registerSkill(def: SkillDef): void;
+    on(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    setSystemPrompt(prompt: string): void;
+    ui: UIContext;
+}
+export declare function text(content: string): ToolContent;
+//# sourceMappingURL=ExtensionAPI.d.ts.map

package/dist/api/ExtensionAPI.js

@@ -0,0 +1,9 @@
+/**
+ * ExtensionAPI — types for the extension system.
+ * Extensions export a function that receives an ExtensionAPI object.
+ */
+// ── text() helper ────────────────────────────────────────────────────────────
+export function text(content) {
+    return { type: "text", text: content };
+}
+//# sourceMappingURL=ExtensionAPI.js.map

package/dist/api/Registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Registry — central registry for tools, commands, skills, hooks, and system prompt.
+ */
+import type { TSchema } from "@sinclair/typebox";
+import type { ToolDef, CommandDef, SkillDef, SessionEvent } from "./ExtensionAPI.js";
+export declare class Registry {
+    private tools;
+    private commands;
+    private skills;
+    private hooks;
+    private systemPrompt;
+    addTool<P extends TSchema>(def: ToolDef<P>): void;
+    addCommand(name: string, def: CommandDef): void;
+    addSkill(def: SkillDef): void;
+    addHook(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    fireHook(event: SessionEvent, ...args: any[]): Promise<void>;
+    getTool(name: string): ToolDef | undefined;
+    getCommand(name: string): CommandDef | undefined;
+    listTools(): ToolDef[];
+    listCommands(): [string, CommandDef][];
+    setSystemPrompt(prompt: string): void;
+    getSystemPrompt(): string;
+}
+//# sourceMappingURL=Registry.d.ts.map

package/dist/api/Registry.js

@@ -0,0 +1,58 @@
+/**
+ * Registry — central registry for tools, commands, skills, hooks, and system prompt.
+ */
+export class Registry {
+    tools = new Map();
+    commands = new Map();
+    skills = new Map();
+    hooks = new Map();
+    systemPrompt = "";
+    addTool(def) {
+        this.tools.set(def.name, def);
+    }
+    addCommand(name, def) {
+        this.commands.set(name, def);
+    }
+    addSkill(def) {
+        this.skills.set(def.name, def);
+        if (def.tools)
+            for (const t of def.tools)
+                this.addTool(t);
+        if (def.commands)
+            for (const [n, c] of def.commands)
+                this.addCommand(n, c);
+        if (def.hooks)
+            for (const [event, handler] of Object.entries(def.hooks))
+                this.addHook(event, handler);
+    }
+    addHook(event, handler) {
+        if (!this.hooks.has(event))
+            this.hooks.set(event, new Set());
+        this.hooks.get(event).add(handler);
+    }
+    async fireHook(event, ...args) {
+        const handlers = this.hooks.get(event);
+        if (handlers)
+            for (const h of handlers)
+                await h(...args);
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    getCommand(name) {
+        return this.commands.get(name);
+    }
+    listTools() {
+        return [...this.tools.values()];
+    }
+    listCommands() {
+        return [...this.commands.entries()];
+    }
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+}
+//# sourceMappingURL=Registry.js.map

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+/**
+ * cli.ts — AIAIAI Chain Agent entry point.
+ * Fully local, all outbound — no inbound ports.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,252 @@
+/**
+ * cli.ts — AIAIAI Chain Agent entry point.
+ * Fully local, all outbound — no inbound ports.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { render } from "ink";
+import React from "react";
+import { config as loadDotenv } from "dotenv";
+import { Registry } from "./api/Registry.js";
+import { loadExtension } from "./loader.js";
+import { App } from "./tui/App.js";
+import { T } from "./tui/theme.js";
+import { wireNotify, safeLog } from "./util/safeLog.js";
+import { modelRegistry } from "./models/ModelRegistry.js";
+import { CostTracker } from "./models/CostTracker.js";
+import { AgentRunner } from "./runner/AgentRunner.js";
+import { SessionManager } from "./session/SessionManager.js";
+import { makeTheme } from "./tui/theme.js";
+import { AgentDir } from "./core/AgentDir.js";
+import { priceFeed } from "./tools/PriceFeed.js";
+const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
+const envPath = join(AIAIAI_HOME, ".env");
+if (existsSync(envPath))
+    loadDotenv({ path: envPath, override: false });
+const SYSTEM_PROMPT = `You are AIAIAI Chain Agent — a Solana-native autonomous AI agent.
+
+Ticker: $AIAIAI
+Contract: AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump
+Chain: Solana (primary)
+
+Your purpose: advance the vision of decentralized AI governance — inspired by the call
+for an "AI Associated Institute of America" (AIAIAI). You monitor on-chain activity,
+crypto markets, and AI-related market narratives.
+
+You have tools for:
+- $AIAIAI token price and any Solana token price (DexScreener)
+- Crypto news with sentiment analysis
+- Technical analysis (RSI, MACD, Bollinger, ATR)
+- Market sentiment (Fear & Greed, funding rates, DeFi TVL, Solana stats, BTC mempool)
+- Persistent goals and scheduled tasks
+
+Be concise, sharp, and useful. When asked about $AIAIAI, use the get_aiaiai_price tool.`;
+const args = process.argv.slice(2);
+const subcmd = args[0];
+// ── --help / --version ────────────────────────────────────────────────────
+if (subcmd === "--help" || subcmd === "-h" || subcmd === "help") {
+    console.log(T.accent("\n  AIAIAI Chain Agent — $AIAIAI\n"));
+    console.log(T.muted("  Usage:\n"));
+    console.log("    aiaiaichain                      Start interactive agent");
+    console.log("    aiaiaichain setup                First-time setup wizard");
+    console.log("    aiaiaichain config               Show configuration");
+    console.log("    aiaiaichain price                Show $AIAIAI token price");
+    console.log("    aiaiaichain status               Quick status + price");
+    console.log("    aiaiaichain --headless \"prompt\"  Run single turn, print to stdout");
+    console.log("    aiaiaichain --extension ./ext.ts Load extension");
+    console.log("    aiaiaichain --help               This help");
+    console.log("    aiaiaichain --version            Show version");
+    console.log("");
+    console.log(T.muted("  https://x.com/aiaiaisol\n"));
+    process.exit(0);
+}
+if (subcmd === "--version" || subcmd === "-v") {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (subcmd === "setup") {
+    (async () => {
+        const { SetupWizard } = await import("./setup/SetupWizard.js");
+        AgentDir.init();
+        const wizard = new SetupWizard();
+        const ok = await wizard.run();
+        if (!ok) {
+            console.log(T.error("Setup cancelled."));
+            process.exit(1);
+        }
+        console.log(T.success("\n  ✓ AIAIAI setup complete!\n"));
+        console.log(T.muted(`  Home: ${AIAIAI_HOME}`));
+        console.log(T.accent("\n  Run `aiaiaichain` to start the agent.\n"));
+        process.exit(0);
+    })().catch(e => { console.error(T.error(`Setup error: ${e.message}`)); process.exit(1); });
+    await new Promise(() => { });
+}
+if (subcmd === "config") {
+    console.log(T.accent("AIAIAI Config"));
+    console.log(T.muted(`Config file: ${envPath}`));
+    if (existsSync(envPath)) {
+        for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+            const m = line.match(/^([A-Z_]+)=(.*)$/);
+            if (!m)
+                continue;
+            const masked = m[2].length > 12 ? m[2].slice(0, 6) + "********" : (m[2] ? "********" : "(empty)");
+            console.log(`  ${m[1].padEnd(28)} ${masked}`);
+        }
+    }
+    else {
+        console.log(T.warn("No config found. Run: aiaiaichain setup"));
+    }
+    process.exit(0);
+}
+if (subcmd === "price") {
+    (async () => {
+        const result = await priceFeed.getAiaiaiPriceTool();
+        console.log(result.content[0].text);
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
+if (subcmd === "status") {
+    (async () => {
+        console.log(T.accent("\n  🤖 AIAIAI Chain Agent\n"));
+        console.log(T.muted(`  Home:   ${AIAIAI_HOME}`));
+        console.log(T.muted(`  Config: ${existsSync(envPath) ? "✓ found" : "✗ run setup"}`));
+        console.log(T.muted(`  Key:    ${process.env.OPENROUTER_API_KEY ? "✓ set" : "✗ missing"}`));
+        console.log("");
+        const result = await priceFeed.getAiaiaiPriceTool();
+        console.log(result.content[0].text);
+        console.log("");
+        process.exit(0);
+    })();
+    await new Promise(() => { });
+}
+// ── Resolve extension + prompt ────────────────────────────────────────────────
+let extensionPath = null;
+let promptPath = null;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--extension" && args[i + 1])
+        extensionPath = args[i + 1];
+    if (args[i] === "--prompt" && args[i + 1])
+        promptPath = args[i + 1];
+}
+let systemPrompt = SYSTEM_PROMPT;
+if (promptPath && existsSync(promptPath)) {
+    systemPrompt = readFileSync(promptPath, "utf-8");
+}
+// ── Headless mode ─────────────────────────────────────────────────────────
+const headlessIdx = args.indexOf("--headless");
+const headlessMsg = headlessIdx >= 0 ? args[headlessIdx + 1] : null;
+if (headlessMsg) {
+    (async () => {
+        AgentDir.init();
+        const registry = new Registry();
+        registry.setSystemPrompt(systemPrompt);
+        if (extensionPath) {
+            try {
+                await loadExtension(extensionPath, registry);
+            }
+            catch (e) {
+                process.stderr.write(`Extension load failed: ${e instanceof Error ? e.message : String(e)}\n`);
+                process.exit(1);
+            }
+        }
+        await modelRegistry.initialise();
+        const session = new SessionManager();
+        session.setSystemPrompt(registry.getSystemPrompt() || systemPrompt);
+        const theme = makeTheme();
+        const nullUi = {
+            notify: () => { }, setStatus: () => { }, setTheme: () => { },
+            setHeader: () => { }, showModelSelector: () => { }, theme,
+        };
+        const sessionCtx = {
+            ui: nullUi, hasUI: false,
+            config: { OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY },
+        };
+        await registry.fireHook("session_start", sessionCtx);
+        let exitCode = 0;
+        const runner = new AgentRunner(registry, session, (event) => {
+            if (event.type === "text_delta")
+                process.stdout.write(event.text);
+            if (event.type === "turn_done")
+                process.stdout.write("\n");
+            if (event.type === "error") {
+                process.stderr.write(`\nError: ${event.message}\n`);
+                exitCode = 1;
+            }
+        }, sessionCtx, "normal", modelRegistry);
+        try {
+            await runner.run(headlessMsg);
+        }
+        catch (e) {
+            process.stderr.write(`Runner error: ${e instanceof Error ? e.message : String(e)}\n`);
+            exitCode = 1;
+        }
+        await registry.fireHook("session_end", sessionCtx);
+        process.exit(exitCode);
+    })();
+}
+else {
+    // ── Boot (interactive TUI) ──────────────────────────────────────────────
+    (async () => {
+        AgentDir.init();
+        console.clear();
+        console.log(T.accent(`
+   █████╗ ██╗ █████╗ ██╗ █████╗ ██╗
+  ██╔══██╗██║██╔══██╗██║██╔══██╗██║
+  ███████║██║███████║██║███████║██║
+  ██╔══██║██║██╔══██║██║██╔══██║██║
+  ██║  ██║██║██║  ██║██║██║  ██║██║
+  ╚═╝  ╚═╝╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═╝╚═╝
+  `));
+        console.log(T.muted("  Solana-native AI agent — $AIAIAI · all local, zero exposure\n"));
+        const registry = new Registry();
+        registry.setSystemPrompt(systemPrompt);
+        let _notifyFn = null;
+        let _setStatusFn = null;
+        let _showModelSelectorFn = null;
+        if (extensionPath) {
+            try {
+                console.log(T.muted(`  Loading: ${extensionPath}`));
+                await loadExtension(extensionPath, registry, {
+                    onNotify: (msg) => { _notifyFn?.(msg); },
+                    onStatusUpdate: (k, v) => { _setStatusFn?.(k, v); },
+                    onShowModelSelector: (q) => { _showModelSelectorFn?.(q); },
+                });
+                console.log(T.success(`  ✓ ${registry.listTools().length} tools · ${registry.listCommands().length} commands`));
+            }
+            catch (e) {
+                console.error(T.error(`  ✗ Extension load failed: ${e.message}`));
+                process.exit(1);
+            }
+        }
+        if (!process.env.OPENROUTER_API_KEY) {
+            console.log(T.warn("  No API key found. Run: aiaiaichain setup\n"));
+        }
+        const costTracker = new CostTracker(modelRegistry);
+        console.log(T.muted("  Discovering available models via OpenRouter…"));
+        await modelRegistry.initialise();
+        console.log(T.success(`  ✓ ${modelRegistry.modelCount} models available\n`));
+        await new Promise(r => setTimeout(r, 500));
+        console.clear();
+        render(React.createElement(App, {
+            registry,
+            systemPrompt,
+            chain: "solana",
+            modelReg: modelRegistry,
+            costTracker,
+            onNotifyReady: (fn) => { _notifyFn = fn; wireNotify(fn); },
+            onStatusReady: (fn) => { _setStatusFn = fn; },
+            onModelSelectorReady: (fn) => { _showModelSelectorFn = fn; },
+        }), { exitOnCtrlC: false });
+        process.prependListener("SIGWINCH", () => { process.stdout.write("\x1B[2J\x1B[H"); });
+        console.log = safeLog;
+        console.error = safeLog;
+        console.warn = safeLog;
+    })();
+}
+//# sourceMappingURL=cli.js.map

package/dist/core/AgentDir.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AgentDir — manages the AIAIAI home directory (~/.aiaiai/)
+ * Created on first run. Contains config, memory, sessions, skills.
+ */
+export declare class AgentDir {
+    static init(): void;
+    static path(...parts: string[]): string;
+    static getHome(): string;
+}
+//# sourceMappingURL=AgentDir.d.ts.map