@aiaiaichain/agent 0.1.1

package/dist/core/AgentDir.js

@@ -0,0 +1,74 @@
+/**
+ * AgentDir — manages the AIAIAI home directory (~/.aiaiai/)
+ * Created on first run. Contains config, memory, sessions, skills.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+const HOME = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
+const DIRS = [
+    'config',
+    'memory',
+    'checkpoints',
+    'sessions',
+    'skills',
+];
+const AIAIAI_MD_CONTENT = `# AIAIAI Chain Agent
+
+Solana-native AI agent for decentralized AI governance.
+Ticker: $AIAIAI (AVPJS61gZmWKtaEpb7qYPKo8Fk2xQUsayYQxPiPMpump)
+
+## Directory layout
+
+| Path           | Contents                                    |
+|----------------|---------------------------------------------|
+| config/        | Settings and API keys                       |
+| memory/        | Long-term conversation memory               |
+| checkpoints/   | Agent state checkpoints                     |
+| sessions/      | REPL conversation sessions                  |
+| skills/        | Strategy skill definitions                  |
+| .env           | API keys and runtime config                 |
+| AIAIAI.md      | This file                                   |
+| settings.json  | User preferences                            |
+
+## Quick reference
+
+\`\`\`
+aiaiaichain         — start interactive REPL
+aiaiaichain setup   — re-run setup wizard
+aiaiaichain config  — show configuration
+aiaiaichain price   — show $AIAIAI token price
+\`\`\`
+`;
+export class AgentDir {
+    static init() {
+        if (!existsSync(HOME))
+            mkdirSync(HOME, { recursive: true });
+        for (const dir of DIRS) {
+            const full = resolve(HOME, dir);
+            if (!existsSync(full))
+                mkdirSync(full, { recursive: true });
+        }
+        const mdPath = resolve(HOME, 'AIAIAI.md');
+        if (!existsSync(mdPath))
+            writeFileSync(mdPath, AIAIAI_MD_CONTENT, 'utf-8');
+        const histPath = resolve(HOME, 'history.jsonl');
+        if (!existsSync(histPath))
+            writeFileSync(histPath, '', 'utf-8');
+        const settingsPath = resolve(HOME, 'settings.json');
+        if (!existsSync(settingsPath)) {
+            writeFileSync(settingsPath, JSON.stringify({
+                theme: 'dark',
+                autoSave: true,
+                activeChain: 'solana',
+            }, null, 2), 'utf-8');
+        }
+    }
+    static path(...parts) {
+        return resolve(HOME, ...parts);
+    }
+    static getHome() {
+        return HOME;
+    }
+}
+//# sourceMappingURL=AgentDir.js.map

package/dist/core/ChainConfig.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ChainConfig — single source of truth for supported chains.
+ * Solana is the default/primary chain. EVM chains are available but disabled by default.
+ */
+export interface ChainInfo {
+    name: string;
+    symbol: string;
+    chainId: number;
+    rpcUrl: string;
+    explorerUrl: string;
+    enabled: boolean;
+    primary: boolean;
+}
+export declare const CHAINS: Record<string, ChainInfo>;
+export declare function getPrimaryChain(): ChainInfo;
+export declare function getEnabledChains(): ChainInfo[];
+export declare function getChain(name: string): ChainInfo | undefined;
+export declare function getSupportedChains(): string[];
+//# sourceMappingURL=ChainConfig.d.ts.map

package/dist/core/ChainConfig.js

@@ -0,0 +1,65 @@
+/**
+ * ChainConfig — single source of truth for supported chains.
+ * Solana is the default/primary chain. EVM chains are available but disabled by default.
+ */
+export const CHAINS = {
+    solana: {
+        name: 'solana',
+        symbol: 'SOL',
+        chainId: 101,
+        rpcUrl: 'https://api.mainnet-beta.solana.com',
+        explorerUrl: 'https://solscan.io',
+        enabled: true,
+        primary: true,
+    },
+    ethereum: {
+        name: 'ethereum',
+        symbol: 'ETH',
+        chainId: 1,
+        rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/',
+        explorerUrl: 'https://etherscan.io',
+        enabled: false,
+        primary: false,
+    },
+    bsc: {
+        name: 'bsc',
+        symbol: 'BNB',
+        chainId: 56,
+        rpcUrl: 'https://bsc-dataseed.binance.org',
+        explorerUrl: 'https://bscscan.com',
+        enabled: false,
+        primary: false,
+    },
+    base: {
+        name: 'base',
+        symbol: 'ETH',
+        chainId: 8453,
+        rpcUrl: 'https://mainnet.base.org',
+        explorerUrl: 'https://basescan.org',
+        enabled: false,
+        primary: false,
+    },
+    arbitrum: {
+        name: 'arbitrum',
+        symbol: 'ETH',
+        chainId: 42161,
+        rpcUrl: 'https://arb1.arbitrum.io/rpc',
+        explorerUrl: 'https://arbiscan.io',
+        enabled: false,
+        primary: false,
+    },
+};
+export function getPrimaryChain() {
+    const primary = Object.values(CHAINS).find(c => c.primary);
+    return primary ?? CHAINS.solana;
+}
+export function getEnabledChains() {
+    return Object.values(CHAINS).filter(c => c.enabled);
+}
+export function getChain(name) {
+    return CHAINS[name];
+}
+export function getSupportedChains() {
+    return Object.keys(CHAINS);
+}
+//# sourceMappingURL=ChainConfig.js.map

package/dist/core/EnvLoader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * EnvLoader — loads environment variables from ~/.aiaiai/.env and process.env
+ */
+export declare class EnvLoader {
+    private cache;
+    private envPath;
+    constructor();
+    private load;
+    get(key: string, defaultValue?: string): string | undefined;
+    getRequired(key: string): string;
+    has(key: string): boolean;
+    reload(): void;
+}
+export declare const env: EnvLoader;
+//# sourceMappingURL=EnvLoader.d.ts.map

package/dist/core/EnvLoader.js

@@ -0,0 +1,58 @@
+/**
+ * EnvLoader — loads environment variables from ~/.aiaiai/.env and process.env
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+export class EnvLoader {
+    cache = {};
+    envPath;
+    constructor() {
+        const home = process.env.AIAIAI_HOME ?? resolve(homedir(), '.aiaiai');
+        this.envPath = resolve(home, '.env');
+        this.load();
+    }
+    load() {
+        // Load from .env file
+        if (existsSync(this.envPath)) {
+            const content = readFileSync(this.envPath, 'utf-8');
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const eqIdx = trimmed.indexOf('=');
+                if (eqIdx === -1)
+                    continue;
+                const key = trimmed.slice(0, eqIdx).trim();
+                const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+                if (key)
+                    this.cache[key] = value;
+            }
+        }
+        // Process.env overrides file
+        for (const key of Object.keys(process.env)) {
+            const value = process.env[key];
+            if (value !== undefined) {
+                this.cache[key] = value;
+            }
+        }
+    }
+    get(key, defaultValue) {
+        return this.cache[key] ?? defaultValue;
+    }
+    getRequired(key) {
+        const value = this.get(key);
+        if (!value)
+            throw new Error(`Required env var ${key} is not set`);
+        return value;
+    }
+    has(key) {
+        return this.cache[key] !== undefined;
+    }
+    reload() {
+        this.cache = {};
+        this.load();
+    }
+}
+export const env = new EnvLoader();
+//# sourceMappingURL=EnvLoader.js.map

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * aiaiaichain — public API
+ *
+ * Extension files import from here:
+ *   import { Type } from "aiaiaichain"
+ *   import type { ExtensionAPI } from "aiaiaichain"
+ */
+export { Type, type Static } from "@sinclair/typebox";
+export type { ExtensionAPI, CommandDef, CommandContext, UIContext, ThemeContext, ToolDef, ToolContent, ToolResult, SkillDef, SessionEvent, SessionContext, } from "./api/ExtensionAPI.js";
+export { text } from "./api/ExtensionAPI.js";
+export { Registry } from "./api/Registry.js";
+export { AgentRunner } from "./runner/AgentRunner.js";
+export { ModelClient, resolveModelConfig } from "./runner/ModelClient.js";
+export { ToolDispatcher } from "./runner/ToolDispatcher.js";
+export { SwarmRouter } from "./runner/SwarmRouter.js";
+export { loadExtension } from "./loader.js";
+export { makeTheme, T, AIAIAI_COLORS } from "./tui/theme.js";
+export { ModelRegistry, modelRegistry, classifyModel } from "./models/ModelRegistry.js";
+export { CostTracker } from "./models/CostTracker.js";
+export type { OpenRouterModel, TieredModel, TieredPool, ModelTier } from "./models/ModelRegistry.js";
+export { fullAnalysis, rsi, macd, ema, sma, bollingerBands, atr, getCandlesTool, getCandlesParams } from "./tools/TechnicalAnalysis.js";
+export { PriceFeed, priceFeed } from "./tools/PriceFeed.js";
+export { NewsFeed, newsFeed, getNewsTool, scoreSentiment } from "./tools/NewsSentiment.js";
+export { getFearGreedTool, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "./tools/MarketSentiment.js";
+export type { OHLCV, AnalysisResult } from "./tools/TechnicalAnalysis.js";
+export type { PriceResult, DexScreenerPair } from "./tools/PriceFeed.js";
+export type { NewsItem, SentimentReport } from "./tools/NewsSentiment.js";
+export { SessionManager } from "./session/SessionManager.js";
+export { MemoryStore, memoryStore } from "./session/MemoryStore.js";
+export { GoalManager, goalManager } from "./session/GoalManager.js";
+export { ContextStore, contextStore } from "./session/ContextStore.js";
+export type { Goal } from "./session/GoalManager.js";
+export type { ContextPressure } from "./session/SessionManager.js";
+export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
+export type { ScheduledTask } from "./scheduler/AgentScheduler.js";
+export { MCPServer } from "./mcp/server.js";
+export { AgentDir } from "./core/AgentDir.js";
+export { EnvLoader, env } from "./core/EnvLoader.js";
+export { CHAINS, getPrimaryChain, getEnabledChains, getChain, getSupportedChains } from "./core/ChainConfig.js";
+export type { ChainInfo } from "./core/ChainConfig.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,42 @@
+/**
+ * aiaiaichain — public API
+ *
+ * Extension files import from here:
+ *   import { Type } from "aiaiaichain"
+ *   import type { ExtensionAPI } from "aiaiaichain"
+ */
+// Re-export TypeBox Type builder
+export { Type } from "@sinclair/typebox";
+export { text } from "./api/ExtensionAPI.js";
+export { Registry } from "./api/Registry.js";
+// Runner
+export { AgentRunner } from "./runner/AgentRunner.js";
+export { ModelClient, resolveModelConfig } from "./runner/ModelClient.js";
+export { ToolDispatcher } from "./runner/ToolDispatcher.js";
+export { SwarmRouter } from "./runner/SwarmRouter.js";
+// Loader
+export { loadExtension } from "./loader.js";
+// Theme
+export { makeTheme, T, AIAIAI_COLORS } from "./tui/theme.js";
+// Models
+export { ModelRegistry, modelRegistry, classifyModel } from "./models/ModelRegistry.js";
+export { CostTracker } from "./models/CostTracker.js";
+// Tools
+export { fullAnalysis, rsi, macd, ema, sma, bollingerBands, atr, getCandlesTool, getCandlesParams } from "./tools/TechnicalAnalysis.js";
+export { PriceFeed, priceFeed } from "./tools/PriceFeed.js";
+export { NewsFeed, newsFeed, getNewsTool, scoreSentiment } from "./tools/NewsSentiment.js";
+export { getFearGreedTool, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "./tools/MarketSentiment.js";
+// Session
+export { SessionManager } from "./session/SessionManager.js";
+export { MemoryStore, memoryStore } from "./session/MemoryStore.js";
+export { GoalManager, goalManager } from "./session/GoalManager.js";
+export { ContextStore, contextStore } from "./session/ContextStore.js";
+// Scheduler
+export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
+// MCP
+export { MCPServer } from "./mcp/server.js";
+// Core
+export { AgentDir } from "./core/AgentDir.js";
+export { EnvLoader, env } from "./core/EnvLoader.js";
+export { CHAINS, getPrimaryChain, getEnabledChains, getChain, getSupportedChains } from "./core/ChainConfig.js";
+//# sourceMappingURL=index.js.map

package/dist/loader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * loader.ts — loads an extension file and wires it to a Registry.
+ */
+import { Registry } from "./api/Registry.js";
+export interface LoaderOptions {
+    onStatusUpdate?: (key: string, value: string) => void;
+    onNotify?: (message: string) => void;
+    onShowModelSelector?: (query?: string) => void;
+}
+export declare function loadExtension(extensionPath: string, registry: Registry, opts?: LoaderOptions): Promise<void>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.js

@@ -0,0 +1,73 @@
+/**
+ * loader.ts — loads an extension file and wires it to a Registry.
+ */
+import { pathToFileURL } from "node:url";
+import { resolve, extname } from "node:path";
+import { existsSync } from "node:fs";
+import { makeTheme } from "./tui/theme.js";
+export async function loadExtension(extensionPath, registry, opts = {}) {
+    const abs = resolve(extensionPath);
+    if (!existsSync(abs))
+        throw new Error(`Extension file not found: ${abs}`);
+    const theme = makeTheme();
+    let _notify = opts.onNotify ?? (() => { });
+    let _setStatus = opts.onStatusUpdate ?? (() => { });
+    let _showModelSelector = opts.onShowModelSelector ?? (() => { });
+    const ui = {
+        notify(msg) { _notify(msg); },
+        setStatus(key, value) { _setStatus(key, value); },
+        setTheme(_name) { },
+        setHeader(_factory) { },
+        showModelSelector(query) { _showModelSelector(query); },
+        theme,
+    };
+    const api = {
+        registerCommand(name, def) { registry.addCommand(name, def); },
+        registerTool(def) { registry.addTool(def); },
+        registerSkill(def) { registry.addSkill(def); },
+        on(event, handler) { registry.addHook(event, handler); },
+        setSystemPrompt(prompt) { registry.setSystemPrompt(prompt); },
+        ui,
+    };
+    const ext = extname(abs).toLowerCase();
+    let mod;
+    if (ext === ".ts") {
+        const jsPath = abs.replace(/\.ts$/, ".js");
+        if (existsSync(jsPath)) {
+            mod = await import(pathToFileURL(jsPath).href);
+        }
+        else {
+            try {
+                const tsxMod = await import("tsx/esm/api");
+                mod = await tsxMod.tsImport(pathToFileURL(abs).href, import.meta.url);
+            }
+            catch {
+                throw new Error(`Cannot import TypeScript extension "${abs}" in packaged mode.\n` +
+                    `Fix: compile to .js first or install tsx: npm install -g tsx`);
+            }
+        }
+    }
+    else {
+        mod = await import(pathToFileURL(abs).href);
+    }
+    const fn = mod.default ?? mod;
+    if (typeof fn !== "function") {
+        throw new Error(`Extension must export a default function. Got: ${typeof fn}`);
+    }
+    const _origLog = console.log;
+    const _origError = console.error;
+    const _origWarn = console.warn;
+    const _extLog = (...args) => { ui.notify(args.map(a => String(a)).join(" ")); };
+    console.log = _extLog;
+    console.error = _extLog;
+    console.warn = _extLog;
+    try {
+        await fn(api);
+    }
+    finally {
+        console.log = _origLog;
+        console.error = _origError;
+        console.warn = _origWarn;
+    }
+}
+//# sourceMappingURL=loader.js.map

package/dist/mcp/entry.d.ts

@@ -0,0 +1,5 @@
+/**
+ * MCP entry point — starts the AIAIAI MCP server over stdio.
+ */
+export {};
+//# sourceMappingURL=entry.d.ts.map

package/dist/mcp/entry.js

@@ -0,0 +1,10 @@
+/**
+ * MCP entry point — starts the AIAIAI MCP server over stdio.
+ */
+import { MCPServer } from "./server.js";
+const server = new MCPServer();
+server.start().catch((e) => {
+    process.stderr.write(`MCP server error: ${e instanceof Error ? e.message : String(e)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=entry.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MCP server — exposes AIAIAI tools via the Model Context Protocol (stdio).
+ * Minimal JSON-RPC implementation over stdin/stdout.
+ */
+export declare class MCPServer {
+    private tools;
+    constructor();
+    private registerTools;
+    start(): Promise<void>;
+    private handleMessage;
+    private respond;
+    private respondError;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,137 @@
+/**
+ * MCP server — exposes AIAIAI tools via the Model Context Protocol (stdio).
+ * Minimal JSON-RPC implementation over stdin/stdout.
+ */
+import { priceFeed } from "../tools/PriceFeed.js";
+import { getNewsTool } from "../tools/NewsSentiment.js";
+import { getCandlesTool } from "../tools/TechnicalAnalysis.js";
+import { getFearGreedTool, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "../tools/MarketSentiment.js";
+export class MCPServer {
+    tools = [];
+    constructor() {
+        this.registerTools();
+    }
+    registerTools() {
+        this.tools = [
+            {
+                name: "get_aiaiai_price",
+                description: "Get the current $AIAIAI token price, liquidity, market cap, and volume from DexScreener.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => priceFeed.getAiaiaiPriceTool(),
+            },
+            {
+                name: "get_token_price",
+                description: "Get price data for any Solana token by address via DexScreener.",
+                inputSchema: { type: "object", properties: { address: { type: "string", description: "Solana token address" } }, required: ["address"] },
+                handler: async (args) => priceFeed.getTokenPriceTool("", args),
+            },
+            {
+                name: "get_news",
+                description: "Crypto news headlines with sentiment scoring.",
+                inputSchema: { type: "object", properties: { limit: { type: "number", description: "Number of items" } } },
+                handler: async (args) => getNewsTool("", args),
+            },
+            {
+                name: "get_candles",
+                description: "Fetch OHLCV candles from Binance and run technical analysis.",
+                inputSchema: { type: "object", properties: { symbol: { type: "string" }, interval: { type: "string" }, limit: { type: "number" } }, required: ["symbol"] },
+                handler: async (args) => getCandlesTool("", args),
+            },
+            {
+                name: "get_fear_greed",
+                description: "Crypto Fear & Greed Index.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => getFearGreedTool(),
+            },
+            {
+                name: "get_funding_rates",
+                description: "Binance perpetual funding rates.",
+                inputSchema: { type: "object", properties: { limit: { type: "number" } } },
+                handler: async (args) => getFundingRatesTool("", args),
+            },
+            {
+                name: "get_btc_mempool",
+                description: "Bitcoin mempool stats and fee rates.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => getBtcMempoolTool(),
+            },
+            {
+                name: "get_defi_tvl",
+                description: "DeFiLlama TVL by chain or all chains.",
+                inputSchema: { type: "object", properties: { chain: { type: "string" } } },
+                handler: async (args) => getDefiTvlTool("", args),
+            },
+            {
+                name: "get_solana_stats",
+                description: "Solana network epoch, slot, and SOL price.",
+                inputSchema: { type: "object", properties: {} },
+                handler: async () => getSolanaStatsTool(),
+            },
+        ];
+    }
+    async start() {
+        let buffer = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", async (chunk) => {
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                await this.handleMessage(line.trim());
+            }
+        });
+        process.stderr.write("AIAIAI MCP server started (stdio)\n");
+    }
+    async handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const { id, method, params } = msg;
+        if (method === "initialize") {
+            this.respond(id, {
+                protocolVersion: "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "aiaiai-chain", version: "0.1.0" },
+            });
+            return;
+        }
+        if (method === "tools/list") {
+            this.respond(id, {
+                tools: this.tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+            });
+            return;
+        }
+        if (method === "tools/call") {
+            const tool = this.tools.find(t => t.name === params?.name);
+            if (!tool) {
+                this.respondError(id, -32602, `Unknown tool: ${params?.name}`);
+                return;
+            }
+            try {
+                const result = await tool.handler(params.arguments ?? {});
+                this.respond(id, { content: result.content });
+            }
+            catch (e) {
+                this.respondError(id, -32603, e instanceof Error ? e.message : String(e));
+            }
+            return;
+        }
+        if (method === "ping") {
+            this.respond(id, {});
+            return;
+        }
+    }
+    respond(id, result) {
+        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+    }
+    respondError(id, code, message) {
+        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/models/CostTracker.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CostTracker — tracks token usage and cost across sessions.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+import type { ModelRegistry } from "./ModelRegistry.js";
+export interface UsageEntry {
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    cost: number;
+    timestamp: number;
+}
+export interface SessionUsage {
+    entries: UsageEntry[];
+    totalCost: number;
+    totalTokens: number;
+}
+export interface LifetimeUsage {
+    sessions: number;
+    totalCost: number;
+    totalTokens: number;
+}
+export declare class CostTracker {
+    private registry;
+    private sessionEntry;
+    private lifetime;
+    private loaded;
+    constructor(registry: ModelRegistry);
+    track(model: string, promptTokens: number, completionTokens: number): void;
+    private estimateCost;
+    statusLine(): string;
+    saveLifetime(): void;
+    private loadLifetime;
+    private writeLifetime;
+    costReportParams: import("@sinclair/typebox").TObject<{}>;
+    costReportTool(): Promise<ToolResult>;
+}
+//# sourceMappingURL=CostTracker.d.ts.map