@albalink/agent 1.0.0

package/README.md

@@ -0,0 +1,91 @@
+# @albalink/agent
+
+**THE AGENT • THE WEB3 AGENT**
+
+A React dashboard and open SDK. Bring any provider — Anthropic, OpenAI, local models on your Mac — and let ALBA reason, act and transact across chains. Fully open-source.
+
+## Links
+
+- **GitHub:** [github.com/alba-agent](https://github.com/alba-agent)
+- **Website:** [alba.souldotmd.xyz](https://alba.souldotmd.xyz)
+
+---
+
+## What is ALBA?
+
+Open-source Web3 agent. React dashboard. Bring your own AI provider — cloud or local.
+
+```typescript
+TypeScript
+React
+Web3
+MIT
+```
+
+---
+
+## Install
+
+```bash
+npm i @albalink/agent
+```
+
+Install the agent SDK in any project. Plug providers from Anthropic API to local Mac models. More coming soon.
+
+---
+
+## Features
+
+- **Multi-Provider Support:** OpenRouter, Anthropic, OpenAI, local models (Ollama, etc.)
+- **Tool System:** File operations, shell commands, grep, price feeds, news sentiment
+- **Memory Layer:** Persistent context across sessions
+- **Swarm Mode:** Sub-agent orchestration for complex tasks
+- **Zero Cloud Dependency:** Runs entirely on your machine
+
+---
+
+## Quick Start
+
+```javascript
+import { ModelClient, resolveModelConfig, PriceFeed, NewsFeed, SwarmRouter } from "@albalink/agent";
+
+// Configure with your provider
+const cfg = resolveModelConfig();
+const client = new ModelClient(cfg);
+
+// Stream chat completions
+for await (const chunk of client.stream(messages, tools)) {
+  console.log(chunk.type, chunk.text || "");
+}
+```
+
+---
+
+## // WEB VERSION — COMING SOON
+
+NOTIFY ME
+
+Drop your Telegram username. We'll ping you the moment the web app opens.
+@
+
+---
+
+## // 04 — ROADMAP
+
+### THE DAWN
+
+**PHASE 01 · DONE**  
+GENESIS  
+$ALBA launch, liquidity burned, contract audited, community formed.
+
+**PHASE 02 · LIVE**  
+ALBA AGENT SDK  
+Open-source Web3 agent — React dashboard + @albalink/agent npm package. Any provider, any chain, run locally on your Mac.
+
+**PHASE 03 · Q3 2026**  
+OPEN MIND — WEB APP  
+Public web app, memory layer and community-driven training. Notify list first.
+
+**PHASE 04 · Q4 2026**  
+CROSS-CHAIN DAWN  
+Multi-chain presence, DAO governance and an open SDK to build on top of ALBA.

package/bin/albacli

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * albacli — ALBA CLI entry point.
+ * Uses tsx for transparent TypeScript support at runtime.
+ * No compilation step needed when running from source.
+ */
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join }  from "path";
+import { existsSync }     from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require   = createRequire(import.meta.url);
+
+// Prefer pre-built dist/ if available, otherwise run TypeScript source via tsx
+const distEntry = join(__dirname, "..", "dist", "cli.js");
+const srcEntry  = join(__dirname, "..", "src",  "cli.ts");
+
+if (existsSync(distEntry)) {
+  // Built package — just run the compiled JS
+  await import(distEntry);
+} else if (existsSync(srcEntry)) {
+  // Development / source install — run via tsx
+  const { register } = await import("tsx/esm");
+  // tsx registers TypeScript support on the module system
+  await import(srcEntry);
+} else {
+  console.error("ALBA: could not find dist/cli.js or src/cli.ts");
+  console.error("Run: npm run build  or  pnpm build");
+  process.exit(1);
+}

package/dist/api/ExtensionAPI.d.ts

@@ -0,0 +1,103 @@
+/**
+ * ExtensionAPI — the interface exposed to extension files (e.g. extensions/alba.ts).
+ *
+ * Drop-in replacement for Pi's ExtensionAPI. Extension files that ran under Pi
+ * work without changes — all Pi methods and calling conventions are preserved:
+ *   - ui.setStatus, ui.setTheme, ui.setHeader
+ *   - ctx.hasUI
+ *   - pi.on("session_start",       async (_event, ctx) => { ... })  ← Pi convention
+ *   - pi.on("session_shutdown",    async () => { ... })
+ *   - pi.on("before_agent_start",  async (_event, ctx) => { ... })
+ */
+import { type Static, type TObject, type TSchema } from "@sinclair/typebox";
+export type { Static, TObject, TSchema };
+export interface ToolContent {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: Record<string, unknown>;
+}
+export declare function text(t: string): ToolContent;
+export interface ToolDef<P extends TSchema = TSchema> {
+    name: string;
+    label: string;
+    description: string;
+    parameters: P;
+    /**
+     * #10: If true, the agent pauses before executing this tool and asks the
+     * user for confirmation. Use for any tool that moves money or signs txs.
+     * The REPL renders an [APPROVE] prompt — user types y/n within 60 seconds.
+     */
+    requiresApproval?: boolean;
+    execute(id: string, params: Static<P>): Promise<ToolContent>;
+}
+export interface TuiHeader {
+    render(width: number): string[];
+    invalidate(): void;
+}
+export type HeaderFactory = (tui: unknown, theme: ThemeContext) => TuiHeader;
+export interface ThemeContext {
+    /** Apply a named colour to text. Colours: accent, error, warn, muted, success, border, dim */
+    fg(color: string, text: string): string;
+}
+export interface UIContext {
+    /** Show a bordered notification in the REPL panel */
+    notify(message: string): void;
+    /**
+     * Set a named status badge in the status bar.
+     * Pi compat — multiple badges can be shown simultaneously.
+     * @param key   Badge slot name (e.g. "vault", "alba", "chain")
+     * @param value Themed text to display
+     */
+    setStatus(key: string, value: string): void;
+    /**
+     * Activate a named theme. Pi compat — engine uses alba theme by default.
+     */
+    setTheme(name: string): void;
+    /**
+     * Replace the TUI header with a custom rendering factory.
+     * Pi compat — accepted but engine renders its own Ink header.
+     */
+    setHeader(factory: HeaderFactory): void;
+    /**
+     * Open the interactive model selector overlay.
+     * @param query Optional initial search query to pre-filter the list.
+     */
+    showModelSelector(query?: string): void;
+    theme: ThemeContext;
+}
+export interface CommandContext {
+    ui: UIContext;
+}
+export interface CommandDef {
+    description: string;
+    handler(args: string, ctx: CommandContext): Promise<void>;
+}
+export interface SkillDef {
+    name: string;
+    content: string;
+}
+export type SessionEvent = "session_start" | "session_end" | "session_shutdown" | "before_agent_start";
+export interface SessionContext {
+    ui: UIContext;
+    /** True when running inside an interactive TUI (always true for @alba/agent) */
+    hasUI: boolean;
+    config: Record<string, string | undefined>;
+}
+export interface ExtensionAPI {
+    registerCommand(name: string, def: CommandDef): void;
+    registerTool<P extends TSchema>(def: ToolDef<P>): void;
+    registerSkill(def: SkillDef): void;
+    /**
+     * Subscribe to a lifecycle event.
+     * Pi calling convention: handler receives (event, ctx).
+     * Handlers may use any arity: (event, ctx) | (ctx) | () — all are safe.
+     */
+    on(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    setSystemPrompt(prompt: string): void;
+    /** Direct UI access available at any time */
+    ui: UIContext;
+}
+export type ExtensionModule = (api: ExtensionAPI) => void | Promise<void>;
+//# sourceMappingURL=ExtensionAPI.d.ts.map

package/dist/api/ExtensionAPI.js

@@ -0,0 +1,15 @@
+/**
+ * ExtensionAPI — the interface exposed to extension files (e.g. extensions/alba.ts).
+ *
+ * Drop-in replacement for Pi's ExtensionAPI. Extension files that ran under Pi
+ * work without changes — all Pi methods and calling conventions are preserved:
+ *   - ui.setStatus, ui.setTheme, ui.setHeader
+ *   - ctx.hasUI
+ *   - pi.on("session_start",       async (_event, ctx) => { ... })  ← Pi convention
+ *   - pi.on("session_shutdown",    async () => { ... })
+ *   - pi.on("before_agent_start",  async (_event, ctx) => { ... })
+ */
+export function text(t) {
+    return { content: [{ type: "text", text: t }], details: {} };
+}
+//# sourceMappingURL=ExtensionAPI.js.map

package/dist/api/Registry.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Registry — stores all commands, tools, and skills registered by extension files.
+ *
+ * Pi calling convention for lifecycle hooks:
+ *   session_start / session_end / session_shutdown: handler(event, ctx)
+ *   before_agent_start:                             handler(event, ctx)
+ *
+ * We always call hooks as handler(undefined, ctx) — handlers that expect only
+ * one argument (ctx) will receive it as the first positional parameter only if
+ * they follow Pi's two-arg (event, ctx) convention; handlers with no args are
+ * also safe. This matches Pi's actual calling convention exactly.
+ */
+import type { CommandDef, ToolDef, SkillDef, SessionEvent, SessionContext } from "./ExtensionAPI.js";
+import type { TSchema } from "@sinclair/typebox";
+export declare class Registry {
+    private commands;
+    private tools;
+    private skills;
+    private hooks;
+    private _systemPrompt;
+    addCommand(name: string, def: CommandDef): void;
+    addTool<P extends TSchema>(def: ToolDef<P>): void;
+    addSkill(def: SkillDef): void;
+    addHook(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    setSystemPrompt(prompt: string): void;
+    getCommand(name: string): CommandDef | undefined;
+    listCommands(): Array<[string, CommandDef]>;
+    listTools(): Array<ToolDef<TSchema>>;
+    getTool(name: string): ToolDef<TSchema> | undefined;
+    listSkills(): SkillDef[];
+    getSystemPrompt(): string;
+    /**
+     * Fire hooks for a lifecycle event.
+     *
+     * Supports all handler arities so Pi-compat and simplified extensions both work:
+     *   h.length === 0 : async () => { ... }          → called with no args
+     *   h.length === 1 : async (ctx) => { ... }        → called with ctx as first arg
+     *   h.length >= 2  : async (event, ctx) => { ... } → Pi convention: (undefined, ctx)
+     *
+     * Using Function.length (declared parameter count) lets us detect intent without
+     * runtime type checks, avoiding the bug where h(undefined, ctx) puts `undefined`
+     * into the `ctx` parameter of a single-argument handler.
+     */
+    fireHook(event: string, ctx: SessionContext): Promise<void>;
+    toOpenAITools(): Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: unknown;
+        };
+    }>;
+}
+//# sourceMappingURL=Registry.d.ts.map

package/dist/api/Registry.js

@@ -0,0 +1,103 @@
+/**
+ * Registry — stores all commands, tools, and skills registered by extension files.
+ *
+ * Pi calling convention for lifecycle hooks:
+ *   session_start / session_end / session_shutdown: handler(event, ctx)
+ *   before_agent_start:                             handler(event, ctx)
+ *
+ * We always call hooks as handler(undefined, ctx) — handlers that expect only
+ * one argument (ctx) will receive it as the first positional parameter only if
+ * they follow Pi's two-arg (event, ctx) convention; handlers with no args are
+ * also safe. This matches Pi's actual calling convention exactly.
+ */
+export class Registry {
+    commands = new Map();
+    tools = new Map();
+    skills = [];
+    hooks = new Map();
+    _systemPrompt = "";
+    // ── Registration ────────────────────────────────────────────────────────
+    addCommand(name, def) {
+        this.commands.set(name.toLowerCase(), def);
+    }
+    addTool(def) {
+        this.tools.set(def.name, def);
+    }
+    addSkill(def) {
+        this.skills.push(def);
+    }
+    addHook(event, handler) {
+        // Normalize aliases: session_shutdown → session_end
+        const key = event === "session_shutdown" ? "session_end" : event;
+        const list = this.hooks.get(key) ?? [];
+        list.push(handler);
+        this.hooks.set(key, list);
+    }
+    setSystemPrompt(prompt) {
+        this._systemPrompt = prompt;
+    }
+    // ── Reads ────────────────────────────────────────────────────────────────
+    getCommand(name) {
+        return this.commands.get(name.toLowerCase());
+    }
+    listCommands() {
+        return [...this.commands.entries()];
+    }
+    listTools() {
+        return [...this.tools.values()];
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    listSkills() {
+        return this.skills;
+    }
+    getSystemPrompt() {
+        return this._systemPrompt;
+    }
+    // ── Hook dispatch ────────────────────────────────────────────────────────
+    /**
+     * Fire hooks for a lifecycle event.
+     *
+     * Supports all handler arities so Pi-compat and simplified extensions both work:
+     *   h.length === 0 : async () => { ... }          → called with no args
+     *   h.length === 1 : async (ctx) => { ... }        → called with ctx as first arg
+     *   h.length >= 2  : async (event, ctx) => { ... } → Pi convention: (undefined, ctx)
+     *
+     * Using Function.length (declared parameter count) lets us detect intent without
+     * runtime type checks, avoiding the bug where h(undefined, ctx) puts `undefined`
+     * into the `ctx` parameter of a single-argument handler.
+     */
+    async fireHook(event, ctx) {
+        const key = event === "session_shutdown" ? "session_end" : event;
+        const handlers = this.hooks.get(key) ?? [];
+        for (const h of handlers) {
+            try {
+                if (h.length === 0) {
+                    await h(); // () => {...}
+                }
+                else if (h.length === 1) {
+                    await h(ctx); // (ctx) => {...}
+                }
+                else {
+                    await h(undefined, ctx); // (_event, ctx) => {...}  — Pi convention
+                }
+            }
+            catch (e) {
+                console.error(`[Registry] hook "${event}" threw:`, e);
+            }
+        }
+    }
+    // ── OpenAI tool schema ───────────────────────────────────────────────────
+    toOpenAITools() {
+        return [...this.tools.values()].map(t => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+}
+//# sourceMappingURL=Registry.js.map

package/dist/cli.d.ts

@@ -0,0 +1,6 @@
+/**
+ * cli.ts — ALBA entry point.
+ * Completely standalone — all outbound, no inbound ports exposed.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,230 @@
+/**
+ * cli.ts — ALBA entry point.
+ * Completely standalone — all outbound, no inbound ports exposed.
+ */
+import { readFileSync, existsSync, writeFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+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 } from "./util/safeLog.js";
+import { priceFeed } from "./tools/PriceFeed.js";
+import { newsFeed } from "./tools/NewsSentiment.js";
+// ── Load env vars from ~/.alba/.env ─────────────────────────────────────────
+const ALBA_HOME = process.env.ALBA_HOME ?? join(homedir(), ".alba");
+const envPath = join(ALBA_HOME, ".env");
+if (existsSync(envPath))
+    loadDotenv({ path: envPath, override: false });
+// ── Parse CLI args ────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const subcmd = args[0];
+// ── Setup Command ───────────────────────────────────────────────────────────
+function runSetup() {
+    (async () => {
+        console.log(T.accent("\n  ALBA Setup\n"));
+        const readline = await import("node:readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (prompt) => new Promise((res) => rl.question(prompt, res));
+        const fs = await import("node:fs");
+        fs.mkdirSync(ALBA_HOME, { recursive: true });
+        const existingLines = existsSync(envPath) ? readFileSync(envPath, "utf-8").split("\n") : [];
+        const existingValues = {};
+        for (const line of existingLines) {
+            const m = line.match(/^([A-Z_]+)=(.*)$/);
+            if (m)
+                existingValues[m[1]] = m[2];
+        }
+        const requiredFields = [
+            { key: "OPENROUTER_API_KEY", label: "OpenRouter API key", hint: "https://openrouter.ai/keys (or use local Ollama)", required: false },
+        ];
+        const optionalFields = [
+            { key: "ANTHROPIC_API_KEY", label: "Anthropic API key", hint: "https://console.anthropic.com", required: false },
+            { key: "OPENAI_API_KEY", label: "OpenAI API key", hint: "https://platform.openai.com", required: false },
+            { key: "OPENAI_BASE_URL", label: "Local API base URL", hint: "e.g. http://localhost:11434/v1 for Ollama", required: false },
+        ];
+        const updateEnv = (key, value) => {
+            const re = new RegExp(`^${key}=.*$`, "m");
+            const content = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+            const newContent = re.test(content) ? content.replace(re, `${key}=${value}`) : content + (content ? "\n" : "") + `${key}=${value}`;
+            writeFileSync(envPath, newContent, "utf-8");
+        };
+        console.log(T.bold("  Required Configuration\n"));
+        for (const f of requiredFields) {
+            const current = existingValues[f.key] || process.env[f.key] || "";
+            const hint = f.hint ? ` (${f.hint})` : "";
+            const prompt = `  ${f.label}${hint}${current ? " [set]" : ""}: `;
+            const val = (await ask(prompt)).trim();
+            if (val)
+                updateEnv(f.key, val);
+        }
+        console.log("\n" + T.bold("  Optional Configuration\n"));
+        for (const f of optionalFields) {
+            const current = existingValues[f.key] || "";
+            const hint = f.hint ? ` (${f.hint})` : "";
+            const prompt = `  ${f.label}${hint}${current ? " [set]" : ""}: `;
+            const val = (await ask(prompt)).trim();
+            if (val)
+                updateEnv(f.key, val);
+        }
+        rl.close();
+        console.log(T.success(`\n  ✓ Config saved → ${envPath}\n`));
+        console.log(T.muted("  Run: albacli  (terminal mode)\n"));
+    })();
+    process.exit(0);
+}
+// ── Config Command ───────────────────────────────────────────────────────────
+function runConfig() {
+    console.log(T.accent("ALBA 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) + "******" : "******";
+            console.log(`  ${m[1].padEnd(28)} ${masked}`);
+        }
+    }
+    else {
+        console.log(T.warn("No config found. Run: albacli setup"));
+    }
+    process.exit(0);
+}
+// ── 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];
+}
+if (!extensionPath) {
+    for (const c of ["extensions/alba.ts", "extensions/alba.js", "extension.ts", "extension.js"]) {
+        const abs = resolve(c);
+        if (existsSync(abs)) {
+            extensionPath = abs;
+            break;
+        }
+    }
+}
+let systemPrompt = "";
+if (promptPath && existsSync(promptPath)) {
+    systemPrompt = readFileSync(promptPath, "utf-8");
+}
+else {
+    const dp = resolve("prompts/alba.md");
+    if (existsSync(dp))
+        systemPrompt = readFileSync(dp, "utf-8");
+}
+function loadContext() {
+    const ctxPath = join(ALBA_HOME, "context.json");
+    if (!existsSync(ctxPath))
+        return { effectLevel: "normal", chain: "ethereum" };
+    try {
+        const ctx = JSON.parse(readFileSync(ctxPath, "utf-8"));
+        if (ctx.model && typeof ctx.model === "string") {
+            process.env.DEFAULT_MODEL = ctx.model;
+            try {
+                const envFile = join(ALBA_HOME, ".env");
+                const content = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "";
+                const re = /^DEFAULT_MODEL=.*$/m;
+                const line = `DEFAULT_MODEL=${ctx.model}`;
+                writeFileSync(envFile, re.test(content) ? content.replace(re, line) : content + "\n" + line + "\n", "utf-8");
+            }
+            catch { /* non-fatal */ }
+        }
+        return { effectLevel: ctx.effect_level ?? "normal", chain: ctx.active_chain ?? "ethereum" };
+    }
+    catch {
+        return { effectLevel: "normal", chain: "ethereum" };
+    }
+}
+// ── Subcommand Router ───────────────────────────────────────────────────────
+if (subcmd === "setup") {
+    runSetup();
+}
+if (subcmd === "config") {
+    runConfig();
+}
+// ── Boot ──────────────────────────────────────────────────────────────────────
+(async () => {
+    console.clear();
+    console.log(T.accent(`
+   █████╗ ██╗     ██████╗  █████╗
+   ██╔══██╗██║     ██╔══██╗██╔══██╗
+   ███████║██║     ██████╔╝███████║
+   ██╔══██║██║     ██╔══██╗██╔══██║
+   ██║  ██║███████╗██████╔╝██║  ██║
+   ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝
+  `));
+    console.log(T.muted("  Personal AI assistant — all local, zero exposure\n"));
+    const registry = new Registry();
+    const { effectLevel, chain } = loadContext();
+    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);
+        }
+    }
+    else {
+        console.log(T.warn("  No extension found — base agent only."));
+        console.log(T.muted("  Run from alba project root or pass --extension path\n"));
+    }
+    if (!process.env.OPENROUTER_API_KEY && !process.env.ANTHROPIC_API_KEY && !process.env.OPENAI_API_KEY) {
+        console.log(T.warn("  No API key found. Set OPENROUTER_API_KEY in ~/.alba/.env\n"));
+        console.log(T.muted("  Or use local Ollama: OPENAI_BASE_URL=http://localhost:11434/v1\n"));
+    }
+    await new Promise(r => setTimeout(r, 500));
+    console.clear();
+    // Start price + news feeds
+    priceFeed.start();
+    newsFeed.start();
+    // Graceful shutdown
+    let shutdownInProgress = false;
+    function handleShutdown() {
+        if (shutdownInProgress)
+            return;
+        shutdownInProgress = true;
+        console.log(T.muted("\n  Shutting down..."));
+        priceFeed.stop();
+        newsFeed.stop();
+        process.exit(0);
+    }
+    process.on("SIGINT", handleShutdown);
+    process.on("SIGTERM", handleShutdown);
+    render(React.createElement(App, {
+        registry,
+        systemPrompt,
+        effectLevel,
+        chain,
+        onNotifyReady: (fn) => { _notifyFn = fn; wireNotify(fn); },
+        onStatusReady: (fn) => { _setStatusFn = fn; },
+        onModelSelectorReady: (fn) => { _showModelSelectorFn = fn; },
+    }), { exitOnCtrlC: false });
+    const _safeLog = (...args) => {
+        const msg = args.map(a => (typeof a === "string" ? a : String(a))).join(" ");
+        _notifyFn?.(msg);
+    };
+    console.log = _safeLog;
+    console.error = _safeLog;
+    console.warn = _safeLog;
+})();
+//# sourceMappingURL=cli.js.map

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @alba/agent — public API
+ *
+ * Extension files import from here:
+ *   import { Type } from "@alba/agent"
+ *   import type { ExtensionAPI } from "@alba/agent"
+ */
+export { Type, type Static } from "@sinclair/typebox";
+export type { ExtensionAPI, ExtensionModule, CommandDef, CommandContext, UIContext, ThemeContext, ToolDef, ToolContent, 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 { loadExtension } from "./loader.js";
+export { makeTheme, T, ALBA_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 type { UsageEntry, SessionUsage, LifetimeUsage } from "./models/CostTracker.js";
+export { fullAnalysis, rsi, macd, ema, sma, bollingerBands, atr, getCandlesTool, getCandlesParams } from "./tools/TechnicalAnalysis.js";
+export { PriceFeed, priceFeed, getPricesTool, topMoversTool, marketOverviewTool } from "./tools/PriceFeed.js";
+export { NewsFeed, newsFeed, getNewsTool, scoreSentiment } from "./tools/NewsSentiment.js";
+export { getFearGreedTool, fundingRatesParams, getFundingRatesTool, getBtcMempoolTool, getDefiTvlTool, getSolanaStatsTool, } from "./tools/MarketSentiment.js";
+export type { OHLCV, AnalysisResult } from "./tools/TechnicalAnalysis.js";
+export type { PriceTick } 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 { MemoryEntry, RecentSession } from "./session/MemoryStore.js";
+export type { Goal } from "./session/GoalManager.js";
+export type { TaskContext } from "./session/ContextStore.js";
+export type { ContextPressure } from "./session/SessionManager.js";
+export { MCPServer } from "./mcp/server.js";
+export { AgentScheduler, agentScheduler } from "./scheduler/AgentScheduler.js";
+export type { ScheduledTask, PriceTrigger } from "./scheduler/AgentScheduler.js";
+export { Tracer } from "./telemetry/Tracer.js";
+export type { Span, Trace } from "./telemetry/Tracer.js";
+//# sourceMappingURL=index.d.ts.map