@aiaiaichain/agent 0.1.1

package/dist/runner/SwarmRouter.js

@@ -0,0 +1,24 @@
+/**
+ * SwarmRouter — parallel sub-agent orchestration.
+ * Routes tasks to appropriate model tiers for parallel execution.
+ */
+export class SwarmRouter {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async runConcurrent(tasks, _sessionCtx) {
+        return Promise.all(tasks.map(t => this.runSingle(t)));
+    }
+    async runSingle(task) {
+        try {
+            // For v1, just execute the task via the available tools
+            // This is simplified — real parallel model calls would go through ModelClient
+            return { taskId: task.id, output: `[${task.tier}] ${task.prompt}` };
+        }
+        catch (e) {
+            return { taskId: task.id, output: "", error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+}
+//# sourceMappingURL=SwarmRouter.js.map

package/dist/runner/ToolDispatcher.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ToolDispatcher — dispatches tool calls from the AI to registered tool handlers.
+ */
+import type { ToolDef, ToolResult } from "../api/ExtensionAPI.js";
+import type { Registry } from "../api/Registry.js";
+export declare class ToolDispatcher {
+    private registry;
+    constructor(registry: Registry);
+    dispatch(toolName: string, params: Record<string, unknown>): Promise<ToolResult>;
+    listTools(): ToolDef[];
+    getTool(name: string): ToolDef | undefined;
+}
+//# sourceMappingURL=ToolDispatcher.d.ts.map

package/dist/runner/ToolDispatcher.js

@@ -0,0 +1,34 @@
+/**
+ * ToolDispatcher — dispatches tool calls from the AI to registered tool handlers.
+ */
+export class ToolDispatcher {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async dispatch(toolName, params) {
+        const tool = this.registry.getTool(toolName);
+        if (!tool) {
+            return {
+                content: [{ type: "text", text: `Unknown tool: "${toolName}"` }],
+                isError: true,
+            };
+        }
+        try {
+            return await tool.execute(`invoke-${Date.now()}`, params);
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Tool "${toolName}" error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }
+    listTools() {
+        return this.registry.listTools();
+    }
+    getTool(name) {
+        return this.registry.getTool(name);
+    }
+}
+//# sourceMappingURL=ToolDispatcher.js.map

package/dist/scheduler/AgentScheduler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AgentScheduler — cron and price-triggered scheduled tasks.
+ * Persisted to ~/.aiaiai/memory/schedule.json
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    prompt: string;
+    cron?: string;
+    priceTrigger?: {
+        symbol: string;
+        above?: number;
+        below?: number;
+    };
+    enabled: boolean;
+    lastRun?: number;
+    createdAt: number;
+}
+export declare class AgentScheduler {
+    private tasks;
+    private interval;
+    private onTask?;
+    constructor();
+    private load;
+    private save;
+    addTask(name: string, prompt: string, intervalSeconds?: number): ScheduledTask;
+    removeTask(id: string): boolean;
+    listTasks(): ScheduledTask[];
+    start(onTask: (task: ScheduledTask) => void): void;
+    stop(): void;
+    addTaskParams: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        prompt: import("@sinclair/typebox").TString;
+        interval: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    listTasksParams: import("@sinclair/typebox").TObject<{
+        enabled_only: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    }>;
+    removeTaskParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+    }>;
+    addTaskTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    listTasksTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    removeTaskTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+}
+export declare const agentScheduler: AgentScheduler;
+//# sourceMappingURL=AgentScheduler.d.ts.map

package/dist/scheduler/AgentScheduler.js

@@ -0,0 +1,111 @@
+/**
+ * AgentScheduler — cron and price-triggered scheduled tasks.
+ * Persisted to ~/.aiaiai/memory/schedule.json
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { AgentDir } from "../core/AgentDir.js";
+const SCHEDULE_PATH = resolve(AgentDir.getHome(), "memory", "schedule.json");
+export class AgentScheduler {
+    tasks = [];
+    interval = null;
+    onTask;
+    constructor() {
+        this.load();
+    }
+    load() {
+        try {
+            if (existsSync(SCHEDULE_PATH)) {
+                this.tasks = JSON.parse(readFileSync(SCHEDULE_PATH, "utf-8"));
+            }
+        }
+        catch {
+            this.tasks = [];
+        }
+    }
+    save() {
+        try {
+            writeFileSync(SCHEDULE_PATH, JSON.stringify(this.tasks, null, 2), "utf-8");
+        }
+        catch { /* non-fatal */ }
+    }
+    addTask(name, prompt, intervalSeconds) {
+        const task = {
+            id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
+            name,
+            prompt,
+            cron: intervalSeconds ? String(intervalSeconds) : undefined,
+            enabled: true,
+            createdAt: Date.now(),
+        };
+        this.tasks.push(task);
+        this.save();
+        return task;
+    }
+    removeTask(id) {
+        const idx = this.tasks.findIndex(t => t.id === id);
+        if (idx === -1)
+            return false;
+        this.tasks.splice(idx, 1);
+        this.save();
+        return true;
+    }
+    listTasks() {
+        return [...this.tasks];
+    }
+    start(onTask) {
+        this.onTask = onTask;
+        if (this.interval)
+            clearInterval(this.interval);
+        this.interval = setInterval(() => {
+            const now = Date.now();
+            for (const task of this.tasks) {
+                if (!task.enabled || !task.cron)
+                    continue;
+                const interval = parseInt(task.cron) * 1000;
+                if (!task.lastRun || (now - task.lastRun) >= interval) {
+                    task.lastRun = now;
+                    this.save();
+                    this.onTask?.(task);
+                }
+            }
+        }, 10_000); // Check every 10 seconds
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    addTaskParams = Type.Object({
+        name: Type.String({ description: "Task name" }),
+        prompt: Type.String({ description: "Prompt to run when task fires" }),
+        interval: Type.Optional(Type.Number({ description: "Run every N seconds" })),
+    });
+    listTasksParams = Type.Object({
+        enabled_only: Type.Optional(Type.Boolean({ default: false })),
+    });
+    removeTaskParams = Type.Object({
+        id: Type.String({ description: "Task ID to remove" }),
+    });
+    async addTaskTool(_id, params) {
+        const task = this.addTask(params.name, params.prompt, params.interval);
+        return { content: [{ type: "text", text: `Task "${task.name}" created (${task.id})` }] };
+    }
+    async listTasksTool(_id, params) {
+        const enabledOnly = params.enabled_only || false;
+        const tasks = enabledOnly ? this.tasks.filter(t => t.enabled) : this.tasks;
+        if (tasks.length === 0)
+            return { content: [{ type: "text", text: "No scheduled tasks." }] };
+        const lines = tasks.map(t => `  ${t.enabled ? "🟢" : "⏸️"} ${t.id} — ${t.name}${t.cron ? ` (every ${t.cron}s)` : ""}`);
+        return { content: [{ type: "text", text: `Scheduled Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
+    }
+    async removeTaskTool(_id, params) {
+        const ok = this.removeTask(params.id);
+        return { content: [{ type: "text", text: ok ? `Task ${params.id} removed` : `Task ${params.id} not found` }] };
+    }
+}
+export const agentScheduler = new AgentScheduler();
+//# sourceMappingURL=AgentScheduler.js.map

package/dist/session/ContextStore.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ContextStore — persistent task context folders.
+ * Allows multi-step operations to store and retrieve intermediate state.
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface TaskContext {
+    taskId: string;
+    data: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+    keep?: boolean;
+}
+export declare class ContextStore {
+    private basePath;
+    constructor();
+    saveTask(taskId: string, data: Record<string, unknown>): void;
+    readTask(taskId: string): TaskContext | null;
+    listTasks(): TaskContext[];
+    keepTask(taskId: string): boolean;
+    readContextParams: import("@sinclair/typebox").TObject<{
+        taskId: import("@sinclair/typebox").TString;
+    }>;
+    listTasksParams: import("@sinclair/typebox").TObject<{}>;
+    readContextTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    listTasksTool(): Promise<ToolResult>;
+}
+export declare const contextStore: ContextStore;
+//# sourceMappingURL=ContextStore.d.ts.map

package/dist/session/ContextStore.js

@@ -0,0 +1,85 @@
+/**
+ * ContextStore — persistent task context folders.
+ * Allows multi-step operations to store and retrieve intermediate state.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { AgentDir } from "../core/AgentDir.js";
+export class ContextStore {
+    basePath;
+    constructor() {
+        this.basePath = resolve(AgentDir.getHome(), "sessions", "tasks");
+        if (!existsSync(this.basePath))
+            mkdirSync(this.basePath, { recursive: true });
+    }
+    saveTask(taskId, data) {
+        const ctx = {
+            taskId,
+            data,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
+    }
+    readTask(taskId) {
+        const p = resolve(this.basePath, `${taskId}.json`);
+        if (!existsSync(p))
+            return null;
+        try {
+            return JSON.parse(readFileSync(p, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    listTasks() {
+        if (!existsSync(this.basePath))
+            return [];
+        try {
+            return readdirSync(this.basePath)
+                .filter(f => f.endsWith(".json"))
+                .map(f => {
+                try {
+                    return JSON.parse(readFileSync(resolve(this.basePath, f), "utf-8"));
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    keepTask(taskId) {
+        const ctx = this.readTask(taskId);
+        if (!ctx)
+            return false;
+        ctx.keep = true;
+        ctx.updatedAt = Date.now();
+        writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
+        return true;
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    readContextParams = Type.Object({
+        taskId: Type.String({ description: "Task ID from a previous multi-step operation" }),
+    });
+    listTasksParams = Type.Object({});
+    async readContextTool(_id, params) {
+        const ctx = this.readTask(params.taskId);
+        if (!ctx)
+            return { content: [{ type: "text", text: `Task "${params.taskId}" not found.` }] };
+        return { content: [{ type: "text", text: JSON.stringify(ctx.data, null, 2) }] };
+    }
+    async listTasksTool() {
+        const tasks = this.listTasks();
+        if (tasks.length === 0)
+            return { content: [{ type: "text", text: "No saved tasks." }] };
+        const lines = tasks.map(t => `  ${t.taskId} — ${Object.keys(t.data).length} keys (${new Date(t.updatedAt).toLocaleString()})${t.keep ? " 🔒" : ""}`);
+        return { content: [{ type: "text", text: `Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
+    }
+}
+export const contextStore = new ContextStore();
+//# sourceMappingURL=ContextStore.js.map

package/dist/session/GoalManager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * GoalManager — persistent cross-session goals for the agent to monitor and complete.
+ * Goals are stored in ~/.aiaiai/memory/goals.json
+ */
+import type { ToolResult } from "../api/ExtensionAPI.js";
+export interface Goal {
+    id: string;
+    text: string;
+    status: "active" | "completed";
+    createdAt: number;
+    completedAt?: number;
+    notes: string[];
+}
+export declare class GoalManager {
+    private goals;
+    constructor();
+    private load;
+    private save;
+    addGoal(text: string): Goal;
+    completeGoal(id: string): boolean;
+    addNote(id: string, note: string): boolean;
+    listGoals(status?: "active" | "completed" | "all"): Goal[];
+    buildContextBlock(): string;
+    setGoalParams: import("@sinclair/typebox").TObject<{
+        text: import("@sinclair/typebox").TString;
+    }>;
+    completeGoalParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+    }>;
+    listGoalsParams: import("@sinclair/typebox").TObject<{
+        status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    addGoalNoteParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        note: import("@sinclair/typebox").TString;
+    }>;
+    setGoalTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    completeGoalTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    listGoalsTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+    addGoalNoteTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
+}
+export declare const goalManager: GoalManager;
+//# sourceMappingURL=GoalManager.d.ts.map

package/dist/session/GoalManager.js

@@ -0,0 +1,108 @@
+/**
+ * GoalManager — persistent cross-session goals for the agent to monitor and complete.
+ * Goals are stored in ~/.aiaiai/memory/goals.json
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { AgentDir } from "../core/AgentDir.js";
+const GOALS_PATH = resolve(AgentDir.getHome(), "memory", "goals.json");
+export class GoalManager {
+    goals = [];
+    constructor() {
+        this.load();
+    }
+    load() {
+        try {
+            if (existsSync(GOALS_PATH)) {
+                this.goals = JSON.parse(readFileSync(GOALS_PATH, "utf-8"));
+            }
+        }
+        catch {
+            this.goals = [];
+        }
+    }
+    save() {
+        try {
+            writeFileSync(GOALS_PATH, JSON.stringify(this.goals, null, 2), "utf-8");
+        }
+        catch { /* non-fatal */ }
+    }
+    addGoal(text) {
+        const goal = {
+            id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
+            text,
+            status: "active",
+            createdAt: Date.now(),
+            notes: [],
+        };
+        this.goals.push(goal);
+        this.save();
+        return goal;
+    }
+    completeGoal(id) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.status = "completed";
+        goal.completedAt = Date.now();
+        this.save();
+        return true;
+    }
+    addNote(id, note) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.notes.push(note);
+        this.save();
+        return true;
+    }
+    listGoals(status) {
+        if (!status || status === "all")
+            return [...this.goals];
+        return this.goals.filter(g => g.status === status);
+    }
+    buildContextBlock() {
+        const active = this.goals.filter(g => g.status === "active");
+        if (active.length === 0)
+            return "";
+        const lines = active.map(g => `  [${g.id}] ${g.text.slice(0, 200)}`);
+        return `\n\n[ACTIVE GOALS]\n${lines.join("\n")}\n`;
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    setGoalParams = Type.Object({
+        text: Type.String({ description: "Goal description" }),
+    });
+    completeGoalParams = Type.Object({
+        id: Type.String({ description: "Goal ID to complete" }),
+    });
+    listGoalsParams = Type.Object({
+        status: Type.Optional(Type.String({ description: "Filter: active, completed, or all" })),
+    });
+    addGoalNoteParams = Type.Object({
+        id: Type.String({ description: "Goal ID" }),
+        note: Type.String({ description: "Progress note" }),
+    });
+    async setGoalTool(_id, params) {
+        const goal = this.addGoal(params.text);
+        return { content: [{ type: "text", text: `Goal created: "${goal.text}" (${goal.id})` }] };
+    }
+    async completeGoalTool(_id, params) {
+        const ok = this.completeGoal(params.id);
+        return { content: [{ type: "text", text: ok ? `Goal ${params.id} completed ✅` : `Goal ${params.id} not found` }] };
+    }
+    async listGoalsTool(_id, params) {
+        const status = params.status || "active";
+        const goals = this.listGoals(status);
+        if (goals.length === 0)
+            return { content: [{ type: "text", text: "No goals found." }] };
+        const lines = goals.map(g => `  ${g.status === "completed" ? "✅" : "🎯"} ${g.id} — ${g.text.slice(0, 120)}${g.notes.length > 0 ? ` (${g.notes.length} notes)` : ""}`);
+        return { content: [{ type: "text", text: `Goals (${goals.length}):\n${lines.join("\n")}` }] };
+    }
+    async addGoalNoteTool(_id, params) {
+        const ok = this.addNote(params.id, params.note);
+        return { content: [{ type: "text", text: ok ? `Note added to ${params.id}` : `Goal ${params.id} not found` }] };
+    }
+}
+export const goalManager = new GoalManager();
+//# sourceMappingURL=GoalManager.js.map

package/dist/session/MemoryStore.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MemoryStore — persistent long-term memory for agents.
+ * Stored in ~/.aiaiai/memory/ as JSONL files per session.
+ */
+export interface MemoryEntry {
+    id: string;
+    sessionId: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    ts: number;
+}
+export interface RecentSession {
+    sessionId: string;
+    lastActive: number;
+    summary: string;
+}
+export declare class MemoryStore {
+    private basePath;
+    private available;
+    constructor();
+    get isAvailable(): boolean;
+    save(sessionId: string, role: "user" | "assistant" | "system", content: string): void;
+    search(query: string, limit?: number): MemoryEntry[];
+    buildContextBlock(sessionId: string): string;
+}
+export declare const memoryStore: MemoryStore;
+//# sourceMappingURL=MemoryStore.d.ts.map

package/dist/session/MemoryStore.js

@@ -0,0 +1,92 @@
+/**
+ * MemoryStore — persistent long-term memory for agents.
+ * Stored in ~/.aiaiai/memory/ as JSONL files per session.
+ */
+import { existsSync, readFileSync, appendFileSync, mkdirSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { AgentDir } from "../core/AgentDir.js";
+export class MemoryStore {
+    basePath;
+    available = false;
+    constructor() {
+        this.basePath = resolve(AgentDir.getHome(), "memory");
+        try {
+            if (!existsSync(this.basePath))
+                mkdirSync(this.basePath, { recursive: true });
+            this.available = true;
+        }
+        catch {
+            this.available = false;
+        }
+    }
+    get isAvailable() { return this.available; }
+    save(sessionId, role, content) {
+        if (!this.available)
+            return;
+        const entry = {
+            id: `mem-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            sessionId,
+            role,
+            content: content.slice(0, 500), // Cap individual entries
+            ts: Date.now(),
+        };
+        try {
+            appendFileSync(resolve(this.basePath, `${sessionId}.jsonl`), JSON.stringify(entry) + "\n", "utf-8");
+        }
+        catch { /* non-fatal */ }
+    }
+    search(query, limit = 8) {
+        if (!this.available)
+            return [];
+        try {
+            const all = [];
+            const files = readdirSync(this.basePath).filter((f) => f.endsWith(".jsonl"));
+            for (const file of files) {
+                const content = readFileSync(resolve(this.basePath, file), "utf-8");
+                for (const line of content.split("\n").filter(Boolean)) {
+                    try {
+                        all.push(JSON.parse(line));
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+            const q = query.toLowerCase().trim();
+            const results = all.filter(e => e.content && e.content.toLowerCase().includes(q));
+            return results.sort((a, b) => b.ts - a.ts).slice(0, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    buildContextBlock(sessionId) {
+        if (!this.available)
+            return "";
+        try {
+            const path = resolve(this.basePath, `${sessionId}.jsonl`);
+            if (!existsSync(path))
+                return "";
+            const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
+            if (lines.length < 3)
+                return "";
+            // Build a compact memory summary from previous turns
+            const entries = lines.slice(-20).map(l => { try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            } }).filter(Boolean);
+            if (entries.length < 2)
+                return "";
+            const recent = entries.slice(-6);
+            const summaries = recent.map(e => `[${e.role}]: ${e.content.slice(0, 150)}`);
+            return `\n\n[RECENT MEMORY]\n${summaries.join("\n")}\n`;
+        }
+        catch {
+            return "";
+        }
+    }
+}
+export const memoryStore = new MemoryStore();
+//# sourceMappingURL=MemoryStore.js.map

package/dist/session/SessionManager.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SessionManager — manages conversation session state, context pressure tracking.
+ */
+export interface ContextPressure {
+    pct: number;
+    level: "green" | "yellow" | "red" | "critical";
+    turboReady: boolean;
+}
+export declare class SessionManager {
+    private messages;
+    private systemPrompt;
+    private maxContextTokens;
+    setSystemPrompt(prompt: string): void;
+    getSystemPrompt(): string;
+    addMessage(role: string, content: string): void;
+    getMessages(): Array<{
+        role: string;
+        content: string;
+    }>;
+    getContextPressure(): ContextPressure;
+    clearMessages(): void;
+    getMessageCount(): number;
+}
+//# sourceMappingURL=SessionManager.d.ts.map