@aiaiaichain/agent 0.1.3 → 0.1.4

package/README.md

@@ -17,7 +17,7 @@
 [![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)
+[X / Twitter](https://x.com/aiaiaisol) · [aiaiaichain.xyz](https://aiaiaichain.xyz)
 
 </div>
 
@@ -149,7 +149,7 @@ Get an OpenRouter key at https://openrouter.ai/keys
 
 ## Links
 
-- [X / Twitter](https://x.com/aiaiaisol)
+- [X / Twitter](https://x.com/aiaiaisol) · [aiaiaichain.xyz](https://aiaiaichain.xyz)
 - [npm](https://www.npmjs.com/package/@aiaiaichain/agent)
 
 ## License

package/dist/cli.js

@@ -6,6 +6,7 @@ import { readFileSync, existsSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
 import { render } from "ink";
 import React from "react";
 import { config as loadDotenv } from "dotenv";
@@ -25,6 +26,7 @@ import { agentWallet, DEPOSIT_WALLET, ACTION_WALLET, SIGNER } from "./wallet/Age
 import { PROVIDERS, getConfigured, getUnconfigured } from "./providers/ProviderRegistry.js";
 import { env } from "./core/EnvLoader.js";
 import { gmgnHelp, gmgnStatus, saveGmgnApiKey } from "./tools/GmgnIntegration.js";
+import { sessionStore } from "./session/SessionStore.js";
 const AIAIAI_HOME = process.env.AIAIAI_HOME ?? join(homedir(), ".aiaiai");
 const envPath = join(AIAIAI_HOME, ".env");
 if (existsSync(envPath))
@@ -310,37 +312,34 @@ if (subcmd === "gmgn" || subcmd === "gmgnhelp") {
         process.exit(0);
     }
     // Forward to gmgn-cli
-    (async () => {
-        const { execSync } = await import("node:child_process");
+    try {
         const fullArgs = ["gmgn-cli", ...gmgnArgs];
+        const gmgnEnv = {};
         try {
-            const output = execSync(fullArgs.join(" "), {
-                env: { ...process.env, ...(() => { const e = {}; try {
-                        const f = require("fs").readFileSync(process.env.HOME + "/.config/gmgn/.env", "utf-8");
-                        for (const l of f.split("\n")) {
-                            const m = l.trim().match(/^([A-Z_]+)=(.*)$/);
-                            if (m)
-                                e[m[1]] = m[2];
-                        }
-                    }
-                    catch { } return e; })() },
-                encoding: "utf-8",
-                timeout: 30_000,
-            });
-            process.stdout.write(output);
-        }
-        catch (e) {
-            const msg = e.stderr?.toString() || e.message || "";
-            process.stderr.write(`gmgn-cli: ${msg.slice(0, 500)}\n`);
-            process.exit(e.status ?? 1);
+            const f = readFileSync(join(homedir(), ".config", "gmgn", ".env"), "utf-8");
+            for (const l of f.split("\n")) {
+                const m = l.trim().match(/^([A-Z_]+)=(.*)$/);
+                if (m)
+                    gmgnEnv[m[1]] = m[2];
+            }
         }
-        process.exit(0);
-    })();
-    await new Promise(() => { });
+        catch { /* no gmgn env */ }
+        const output = execSync(fullArgs.join(" "), {
+            env: { ...process.env, ...gmgnEnv },
+            encoding: "utf-8",
+            timeout: 30_000,
+        });
+        process.stdout.write(output);
+    }
+    catch (e) {
+        const msg = e.stderr?.toString() || e.message || "";
+        process.stderr.write(`gmgn-cli: ${msg.slice(0, 500)}\n`);
+        process.exit(e.status ?? 1);
+    }
+    process.exit(0);
 }
 if (subcmd === "update" || subcmd === "upgrade") {
     (async () => {
-        const { execSync } = await import("node:child_process");
         const pkgName = "@aiaiaichain/agent";
         console.log(T.accent("\n  🤖 AIAIAI Update Check\n"));
         // Get current version
@@ -415,6 +414,42 @@ if (subcmd === "update" || subcmd === "upgrade") {
     })().catch(e => { console.error(T.error(`Error: ${e.message}`)); process.exit(1); });
     await new Promise(() => { });
 }
+if (subcmd === "sessions") {
+    const sessions = sessionStore.list();
+    if (sessions.length === 0) {
+        console.log(T.muted("  No saved sessions."));
+        process.exit(0);
+    }
+    console.log(T.accent("\n  📂 Saved Sessions\n"));
+    sessions.slice(0, 15).forEach((s, i) => {
+        const date = new Date(s.updatedAt).toLocaleDateString();
+        console.log(T.muted(`  ${String(i + 1).padStart(2)}. ${s.title} (${s.messageCount} msgs, ${s.model}, ${date})`));
+    });
+    console.log("");
+    process.exit(0);
+}
+if (subcmd === "resume") {
+    const sessions = sessionStore.list();
+    if (sessions.length === 0) {
+        console.log(T.muted("  No saved sessions."));
+        process.exit(0);
+    }
+    const idx = parseInt(process.argv[3]) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= sessions.length) {
+        console.log(T.error("  Invalid session number."));
+        process.exit(1);
+    }
+    const session = sessionStore.load(sessions[idx].id);
+    if (!session) {
+        console.log(T.error("  Session not found."));
+        process.exit(1);
+    }
+    console.log(T.accent(`\n  📂 Resumed: ${session.title}\n`));
+    console.log(T.muted(`  Messages: ${session.messages.length}`));
+    console.log(T.muted(`  Model: ${session.model}`));
+    console.log("");
+    process.exit(0);
+}
 // ── Resolve extension + prompt ────────────────────────────────────────────────
 let extensionPath = null;
 let promptPath = null;

package/dist/core/SystemMonitor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SystemMonitor — tracks CPU, RAM, network, and agent stats.
+ * Uses Node.js built-in modules only (no external deps).
+ */
+export interface SystemStats {
+    cpuPercent: number;
+    ramPercent: number;
+    ramUsed: string;
+    ramTotal: string;
+    uptime: string;
+    netUp: string;
+    netDown: string;
+    apiCallsPerMin: number;
+    tokensUsed: number;
+}
+export declare class SystemMonitor {
+    private apiCallCount;
+    private lastNetStats;
+    constructor();
+    private initNetStats;
+    /** Track an API call */
+    trackApiCall(): void;
+    /** Get current system stats */
+    getStats(tokenCount?: number): SystemStats;
+    private getCpuPercent;
+    private getRamPercent;
+    private getNetStats;
+    private getRawNetStats;
+    private formatBytes;
+    private formatUptime;
+    /** Reset API call counter (call every minute) */
+    resetApiCounter(): number;
+}
+export declare const systemMonitor: SystemMonitor;
+//# sourceMappingURL=SystemMonitor.d.ts.map

package/dist/core/SystemMonitor.js

@@ -0,0 +1,115 @@
+/**
+ * SystemMonitor — tracks CPU, RAM, network, and agent stats.
+ * Uses Node.js built-in modules only (no external deps).
+ */
+import { cpus, totalmem, freemem, uptime, networkInterfaces } from 'node:os';
+export class SystemMonitor {
+    apiCallCount = 0;
+    lastNetStats = { rx: 0, tx: 0, time: Date.now() };
+    constructor() {
+        this.initNetStats();
+    }
+    initNetStats() {
+        try {
+            const stats = this.getRawNetStats();
+            this.lastNetStats = { rx: stats.rx, tx: stats.tx, time: Date.now() };
+        }
+        catch { /* non-fatal */ }
+    }
+    /** Track an API call */
+    trackApiCall() {
+        this.apiCallCount++;
+    }
+    /** Get current system stats */
+    getStats(tokenCount = 0) {
+        return {
+            cpuPercent: this.getCpuPercent(),
+            ramPercent: this.getRamPercent(),
+            ramUsed: this.formatBytes(totalmem() - freemem()),
+            ramTotal: this.formatBytes(totalmem()),
+            uptime: this.formatUptime(uptime()),
+            ...this.getNetStats(),
+            apiCallsPerMin: this.apiCallCount,
+            tokensUsed: tokenCount,
+        };
+    }
+    getCpuPercent() {
+        try {
+            const cpuInfo = cpus();
+            let totalIdle = 0, totalTick = 0;
+            for (const cpu of cpuInfo) {
+                for (const type in cpu.times) {
+                    totalTick += cpu.times[type];
+                }
+                totalIdle += cpu.times.idle;
+            }
+            const idle = totalIdle / cpuInfo.length;
+            const total = totalTick / cpuInfo.length;
+            return Math.round((1 - idle / total) * 100);
+        }
+        catch {
+            return 0;
+        }
+    }
+    getRamPercent() {
+        const used = totalmem() - freemem();
+        return Math.round((used / totalmem()) * 100);
+    }
+    getNetStats() {
+        try {
+            const current = this.getRawNetStats();
+            const elapsed = (Date.now() - this.lastNetStats.time) / 1000;
+            if (elapsed < 1)
+                return { netUp: '0 B/s', netDown: '0 B/s' };
+            const rxPerSec = Math.max(0, (current.rx - this.lastNetStats.rx) / elapsed);
+            const txPerSec = Math.max(0, (current.tx - this.lastNetStats.tx) / elapsed);
+            this.lastNetStats = { rx: current.rx, tx: current.tx, time: Date.now() };
+            return {
+                netUp: this.formatBytes(txPerSec) + '/s',
+                netDown: this.formatBytes(rxPerSec) + '/s',
+            };
+        }
+        catch {
+            return { netUp: 'N/A', netDown: 'N/A' };
+        }
+    }
+    getRawNetStats() {
+        let rx = 0, tx = 0;
+        const interfaces = networkInterfaces();
+        for (const name of Object.keys(interfaces)) {
+            const iface = interfaces[name];
+            if (!iface)
+                continue;
+            for (const info of iface) {
+                if (info.internal)
+                    continue;
+                // Node.js doesn't expose per-interface bytes by default
+                // This is a best-effort approximation
+            }
+        }
+        return { rx, tx };
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+    }
+    formatUptime(seconds) {
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        if (h > 0)
+            return `${h}h ${m}m`;
+        return `${m}m`;
+    }
+    /** Reset API call counter (call every minute) */
+    resetApiCounter() {
+        const count = this.apiCallCount;
+        this.apiCallCount = 0;
+        return count;
+    }
+}
+export const systemMonitor = new SystemMonitor();
+//# sourceMappingURL=SystemMonitor.js.map

package/dist/index.d.ts

@@ -23,7 +23,7 @@ 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 { PriceResult, DexScreenerPair as DexScreenerData } 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";
@@ -37,7 +37,12 @@ export { agentWallet, COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET, SIGNER, AIAIAI
 export { actionFeed } from "./wallet/ActionFeed.js";
 export type { WalletBalance, AgentWallets } from "./wallet/AgentWallet.js";
 export type { AgentAction, ActionType, FeeTracker } from "./wallet/ActionFeed.js";
-export { gmgnTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+export { gmgnTool, gmgnMarketTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+export { watchTokenTool, removeWatchTool, listWatchTool, addAlertTool, checkAlertsTool, compareTokensTool, portfolioTool, portfolioParams, getWatchList, checkAlerts, addAlert, getActiveAlerts, } from "./tools/CrossTools.js";
+export { sessionStore } from "./session/SessionStore.js";
+export type { Session, SessionMeta } from "./session/SessionStore.js";
+export { systemMonitor } from "./core/SystemMonitor.js";
+export type { SystemStats } from "./core/SystemMonitor.js";
 export { MCPServer } from "./mcp/server.js";
 export { AgentDir } from "./core/AgentDir.js";
 export { EnvLoader, env } from "./core/EnvLoader.js";

package/dist/index.js

@@ -37,7 +37,13 @@ export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
 export { agentWallet, COLD_WALLET, ACTION_WALLET, DEPOSIT_WALLET, SIGNER, AIAIAI_MINT } from "./wallet/AgentWallet.js";
 export { actionFeed } from "./wallet/ActionFeed.js";
 // GMGN
-export { gmgnTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+export { gmgnTool, gmgnMarketTool, gmgnHelp, gmgnStatus, hasGmgnApiKey, saveGmgnApiKey, GMGN_SUBCOMMANDS } from "./tools/GmgnIntegration.js";
+// Cross tools
+export { watchTokenTool, removeWatchTool, listWatchTool, addAlertTool, checkAlertsTool, compareTokensTool, portfolioTool, portfolioParams, getWatchList, checkAlerts, addAlert, getActiveAlerts, } from "./tools/CrossTools.js";
+// Session
+export { sessionStore } from "./session/SessionStore.js";
+// System
+export { systemMonitor } from "./core/SystemMonitor.js";
 // MCP
 export { MCPServer } from "./mcp/server.js";
 // Core

package/dist/session/SessionStore.d.ts

@@ -0,0 +1,45 @@
+/**
+ * SessionStore — saves/loads conversation sessions.
+ * Sessions stored as JSON in ~/.aiaiai/sessions/
+ */
+import type { ChatMessage } from '../tui/REPL.js';
+export interface SessionMeta {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messageCount: number;
+    model: string;
+}
+export interface Session {
+    id: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    messages: ChatMessage[];
+    model: string;
+    chain: string;
+}
+export declare class SessionStore {
+    private currentId;
+    private autoSaveInterval;
+    constructor();
+    /** Start auto-saving every 30s */
+    startAutoSave(getMessages: () => ChatMessage[]): void;
+    stopAutoSave(): void;
+    /** Save current session */
+    save(messages: ChatMessage[], title?: string): string;
+    /** Load a session by ID */
+    load(id: string): Session | null;
+    /** List all sessions (most recent first) */
+    list(): SessionMeta[];
+    /** Delete a session */
+    delete(id: string): boolean;
+    /** Set current session ID (for resuming) */
+    setCurrentId(id: string): void;
+    getCurrentId(): string;
+    /** Generate a title from first user message */
+    private generateTitle;
+}
+export declare const sessionStore: SessionStore;
+//# sourceMappingURL=SessionStore.d.ts.map

package/dist/session/SessionStore.js

@@ -0,0 +1,123 @@
+/**
+ * SessionStore — saves/loads conversation sessions.
+ * Sessions stored as JSON in ~/.aiaiai/sessions/
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+const SESSIONS_DIR = resolve(homedir(), '.aiaiai', 'sessions');
+function ensureDir() {
+    if (!existsSync(SESSIONS_DIR))
+        mkdirSync(SESSIONS_DIR, { recursive: true });
+}
+function sessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+export class SessionStore {
+    currentId;
+    autoSaveInterval = null;
+    constructor() {
+        ensureDir();
+        this.currentId = sessionId();
+    }
+    /** Start auto-saving every 30s */
+    startAutoSave(getMessages) {
+        this.stopAutoSave();
+        this.autoSaveInterval = setInterval(() => {
+            const msgs = getMessages();
+            if (msgs.length > 0)
+                this.save(msgs, 'current');
+        }, 30_000);
+    }
+    stopAutoSave() {
+        if (this.autoSaveInterval) {
+            clearInterval(this.autoSaveInterval);
+            this.autoSaveInterval = null;
+        }
+    }
+    /** Save current session */
+    save(messages, title) {
+        ensureDir();
+        const id = this.currentId;
+        const existing = this.load(id);
+        const session = {
+            id,
+            title: title || existing?.title || this.generateTitle(messages),
+            createdAt: existing?.createdAt || Date.now(),
+            updatedAt: Date.now(),
+            messages,
+            model: process.env.DEFAULT_MODEL || 'unknown',
+            chain: 'solana',
+        };
+        try {
+            writeFileSync(resolve(SESSIONS_DIR, `${id}.json`), JSON.stringify(session, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal */ }
+        return id;
+    }
+    /** Load a session by ID */
+    load(id) {
+        try {
+            const path = resolve(SESSIONS_DIR, `${id}.json`);
+            if (!existsSync(path))
+                return null;
+            return JSON.parse(readFileSync(path, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /** List all sessions (most recent first) */
+    list() {
+        ensureDir();
+        try {
+            const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+            const sessions = [];
+            for (const file of files) {
+                try {
+                    const data = JSON.parse(readFileSync(resolve(SESSIONS_DIR, file), 'utf-8'));
+                    sessions.push({
+                        id: data.id,
+                        title: data.title,
+                        createdAt: data.createdAt,
+                        updatedAt: data.updatedAt,
+                        messageCount: data.messages.length,
+                        model: data.model,
+                    });
+                }
+                catch { /* skip bad files */ }
+            }
+            return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Delete a session */
+    delete(id) {
+        try {
+            unlinkSync(resolve(SESSIONS_DIR, `${id}.json`));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Set current session ID (for resuming) */
+    setCurrentId(id) {
+        this.currentId = id;
+    }
+    getCurrentId() {
+        return this.currentId;
+    }
+    /** Generate a title from first user message */
+    generateTitle(messages) {
+        const firstUser = messages.find(m => m.role === 'user');
+        if (!firstUser)
+            return 'New Session';
+        const text = firstUser.content.trim();
+        return text.length > 40 ? text.slice(0, 37) + '…' : text;
+    }
+}
+export const sessionStore = new SessionStore();
+//# sourceMappingURL=SessionStore.js.map

package/dist/tools/CrossTools.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CrossTools — automation tools that combine multiple data sources.
+ * Watch tokens, compare, portfolio tracking, price alerts.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+interface PriceAlert {
+    id: string;
+    token: string;
+    type: 'above' | 'below';
+    price: number;
+    active: boolean;
+    createdAt: number;
+    triggeredAt?: number;
+}
+export declare function addAlert(token: string, type: 'above' | 'below', price: number): PriceAlert;
+export declare function checkAlerts(currentPrice: number, token: string): PriceAlert[];
+export declare function getActiveAlerts(): PriceAlert[];
+export declare function addToWatchList(tokenAddress: string): void;
+export declare function removeFromWatchList(tokenAddress: string): void;
+export declare function getWatchList(): string[];
+export declare const watchTokenParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const removeWatchParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const listWatchParams: import("@sinclair/typebox").TObject<{}>;
+export declare const addAlertParams: import("@sinclair/typebox").TObject<{
+    token: import("@sinclair/typebox").TString;
+    type: import("@sinclair/typebox").TString;
+    price: import("@sinclair/typebox").TNumber;
+}>;
+export declare const checkAlertsParams: import("@sinclair/typebox").TObject<{}>;
+export declare const compareTokensParams: import("@sinclair/typebox").TObject<{
+    address1: import("@sinclair/typebox").TString;
+    address2: import("@sinclair/typebox").TString;
+}>;
+export declare function watchTokenTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function removeWatchTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function listWatchTool(): Promise<ToolResult>;
+export declare function addAlertTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare function checkAlertsTool(): Promise<ToolResult>;
+export declare function compareTokensTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const portfolioParams: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare function portfolioTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+export declare const COLD_WALLET = "A11iZoqEt6hU7HyggqC67ee4AtYmaJjwKCvJLerJRV2J";
+export declare const ACTION_WALLET = "BygDYM1ZXLQNC1HXLhnd1rHZ7E5XjioqT3vPjJFfjnU2";
+export declare const DEPOSIT_WALLET = "FBMDYpG9WXKy4SgxuATQdB2sCyzHsJWPrEr45z3TgL2e";
+export {};
+//# sourceMappingURL=CrossTools.d.ts.map