@hemansubedi/aether-ai 1.0.0

package/dist/combos.js

@@ -0,0 +1,176 @@
+// Combo manager for Aether.
+//
+// A "combo" is a named group of providers/models that can be created, saved,
+// and later selected in a single step (replacing /provider + /model).
+// Combos persist to ~/.aether/combos.json and are loaded lazily on first use.
+//
+// Two built-in combos are always available, even before the user creates any:
+//   local  - ollama-local only
+//   cloud  - every enabled cloud provider
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { PROVIDER_REGISTRY } from "./providers/registry.js";
+function combosPath() {
+    return path.join(os.homedir(), ".aether", "combos.json");
+}
+function cloudProviderNames() {
+    return PROVIDER_REGISTRY.filter((p) => p.enabled && p.name !== "ollama-local").map((p) => p.name);
+}
+function firstModels(names) {
+    const out = [];
+    for (const n of names) {
+        const p = PROVIDER_REGISTRY.find((x) => x.name === n);
+        if (p && p.models[0])
+            out.push(p.models[0]);
+    }
+    return out;
+}
+const DEFAULT_COMBOS = [
+    {
+        name: "local",
+        description: "Local Ollama only",
+        providers: ["ollama-local"],
+        models: firstModels(["ollama-local"]),
+        default: true,
+    },
+    {
+        name: "cloud",
+        description: "All cloud providers",
+        providers: cloudProviderNames(),
+        models: firstModels(cloudProviderNames()),
+        default: true,
+    },
+];
+export class ComboManager {
+    combos = new Map();
+    active;
+    loaded = false;
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        this.loadFromDisk();
+    }
+    loadFromDisk() {
+        try {
+            const p = combosPath();
+            const raw = fs.readFileSync(p, "utf8");
+            const obj = JSON.parse(raw);
+            if (obj && typeof obj === "object") {
+                const arr = Array.isArray(obj) ? obj : obj.combos ?? [];
+                if (Array.isArray(arr)) {
+                    for (const c of arr) {
+                        if (c && typeof c.name === "string")
+                            this.combos.set(c.name, c);
+                    }
+                }
+            }
+        }
+        catch {
+            // Missing or corrupt combos file: start with an empty set.
+        }
+        this.ensureDefaults();
+    }
+    /** Re-add built-in combos if the user removed them from disk. */
+    ensureDefaults() {
+        for (const d of DEFAULT_COMBOS) {
+            if (!this.combos.has(d.name)) {
+                this.combos.set(d.name, { ...d, createdAt: Date.now() });
+            }
+        }
+    }
+    /** Create a new combo. Returns undefined if the name is empty or already used. */
+    create(name, opts = {}) {
+        const n = (name ?? "").trim();
+        if (!n)
+            return undefined;
+        this.ensureLoaded();
+        if (this.combos.has(n))
+            return undefined;
+        const providers = (opts.providers ?? [])
+            .map((p) => p.trim())
+            .filter(Boolean);
+        const combo = {
+            name: n,
+            description: opts.description,
+            providers,
+            models: opts.models ?? [],
+            createdAt: Date.now(),
+        };
+        this.combos.set(n, combo);
+        this.save();
+        return combo;
+    }
+    get(name) {
+        this.ensureLoaded();
+        return this.combos.get(name);
+    }
+    /** All combos sorted alphabetically (built-ins included). */
+    list() {
+        this.ensureLoaded();
+        return [...this.combos.values()].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Remove a combo. Built-in combos cannot be deleted. */
+    delete(name) {
+        this.ensureLoaded();
+        const c = this.combos.get(name);
+        if (!c)
+            return false;
+        if (c.default)
+            return false;
+        this.combos.delete(name);
+        if (this.active === name)
+            this.active = undefined;
+        this.save();
+        return true;
+    }
+    /** Select a combo as the active one. Returns the combo or undefined. */
+    select(name) {
+        this.ensureLoaded();
+        const c = this.combos.get(name);
+        if (!c)
+            return undefined;
+        this.active = name;
+        return c;
+    }
+    /** The currently selected combo, or undefined. */
+    getActive() {
+        this.ensureLoaded();
+        return this.active ? this.combos.get(this.active) : undefined;
+    }
+    /** Human-readable description of which providers/models a combo uses. */
+    render(name) {
+        this.ensureLoaded();
+        const c = this.combos.get(name);
+        if (!c)
+            return `Combo "${name}" not found.`;
+        const lines = [`Combo: ${c.name}`];
+        if (c.description)
+            lines.push(`  ${c.description}`);
+        lines.push(`  providers: ${c.providers.length ? c.providers.join(", ") : "(none)"}`);
+        lines.push(`  models: ${c.models.length ? c.models.join(", ") : "(none)"}`);
+        return lines.join("\n");
+    }
+    /** Persist combos to disk atomically. */
+    save() {
+        this.ensureLoaded();
+        const file = combosPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const arr = [...this.combos.values()];
+        const tmp = file + ".tmp";
+        fs.writeFileSync(tmp, JSON.stringify(arr, null, 2), "utf8");
+        fs.renameSync(tmp, file);
+    }
+    /** Singleton: load combos from disk (and re-add built-ins). */
+    static load() {
+        if (!ComboManager._instance)
+            ComboManager._instance = new ComboManager();
+        ComboManager._instance.ensureLoaded();
+        return ComboManager._instance;
+    }
+    static instance() {
+        return ComboManager.load();
+    }
+    static _instance = null;
+}

package/dist/commands.js

@@ -0,0 +1,483 @@
+import * as path from "node:path";
+import * as os from "node:os";
+import * as fs from "node:fs";
+import { Session } from "./session.js";
+import { CostTracker } from "./cost.js";
+import { Settings } from "./settings.js";
+import { Skills } from "./skills.js";
+import { ComboManager } from "./combos.js";
+function coerceSetting(key, raw) {
+    const s = Settings.instance().getAll();
+    const cur = s[key];
+    if (typeof cur === "boolean") {
+        const v = raw.trim().toLowerCase();
+        if (["true", "1", "yes", "on"].includes(v))
+            return true;
+        if (["false", "0", "no", "off"].includes(v))
+            return false;
+        return cur;
+    }
+    if (typeof cur === "number") {
+        const n = Number(raw);
+        return (Number.isFinite(n) ? n : cur);
+    }
+    return raw;
+}
+export function parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) {
+        return { command: "", args: [] };
+    }
+    const parts = trimmed.slice(1).split(/\s+/);
+    const command = parts.shift() ?? "";
+    return { command, args: parts };
+}
+export const CommandHandler = {
+    help: {
+        help: "/help - Show all available commands",
+        run: (_args, ctx) => {
+            const lines = [];
+            lines.push("Commands:");
+            for (const [name, h] of Object.entries(CommandHandler)) {
+                lines.push(`  ${h.help}`);
+            }
+            ctx.tui.showSystem(lines.join("\n"));
+        },
+    },
+    model: {
+        help: "/model <name> - Switch the active model",
+        run: (args, ctx) => {
+            const name = args.join(" ").trim();
+            if (!name) {
+                ctx.tui.showSystem(`Current model: ${ctx.router.getActiveModel() ?? "(default)"}. Usage: /model <name>`);
+                return;
+            }
+            ctx.router.setActiveModel(name);
+            ctx.tui.showSystem(`Active model set to: ${name}`);
+        },
+    },
+    provider: {
+        help: "/provider <name> - Switch the active provider",
+        run: (args, ctx) => {
+            const name = args.join(" ").trim();
+            if (!name) {
+                ctx.tui.showSystem(`Current provider: ${ctx.router.getActiveProvider() ?? "(auto)"}. Usage: /provider <name>`);
+                return;
+            }
+            const names = ctx.router.getProviderNames();
+            if (!names.includes(name)) {
+                ctx.tui.showSystem(`Unknown provider "${name}". Available: ${names.join(", ") || "(none)"}`);
+                return;
+            }
+            ctx.router.setActiveProvider(name);
+            ctx.tui.showSystem(`Active provider set to: ${name}`);
+        },
+    },
+    models: {
+        help: "/models - List all available models across providers",
+        run: async (_args, ctx) => {
+            const all = await ctx.router.listAllModels();
+            const lines = [];
+            for (const [provider, models] of Object.entries(all)) {
+                const list = models.length ? models.join(",  ") : "(none returned)";
+                lines.push(`${provider}: ${list}`);
+            }
+            ctx.tui.showSystem(lines.join("\n") || "No models available.");
+        },
+    },
+    providers: {
+        help: "/providers - Show provider health status",
+        run: async (_args, ctx) => {
+            const statuses = await ctx.router.healthAll();
+            const lines = statuses.map((s) => {
+                const state = s.healthy ? "healthy" : s.circuitOpen ? "OPEN" : "unhealthy";
+                const err = s.lastError ? ` (${s.lastError})` : "";
+                return `${s.provider}: ${state}${err}`;
+            });
+            ctx.tui.showSystem(lines.join("\n") || "No providers.");
+        },
+    },
+    session: {
+        help: "/session save [name] | load <name> | list | clear - Manage sessions",
+        run: (args, ctx) => {
+            const sub = args[0]?.toLowerCase() ?? "";
+            const name = args.slice(1).join(" ").trim();
+            const dir = path.join(os.homedir(), ".aether", "sessions");
+            switch (sub) {
+                case "save": {
+                    const file = name
+                        ? path.join(dir, `${name}.json`)
+                        : path.join(dir, "session.json");
+                    fs.mkdirSync(path.dirname(file), { recursive: true });
+                    Session.save(file, ctx.session);
+                    ctx.tui.showSystem(`Session saved to: ${file}`);
+                    break;
+                }
+                case "load": {
+                    if (!name) {
+                        ctx.tui.showSystem("Usage: /session load <name>");
+                        break;
+                    }
+                    const candidates = [
+                        path.join(dir, `${name}.json`),
+                        path.join(dir, name),
+                    ];
+                    const target = candidates.find((f) => fs.existsSync(f));
+                    if (!target) {
+                        ctx.tui.showSystem(`Session "${name}" not found.`);
+                        break;
+                    }
+                    const loaded = Session.load(target);
+                    ctx.session.messages = loaded.messages;
+                    ctx.session.createdAt = loaded.createdAt;
+                    ctx.session.updatedAt = loaded.updatedAt;
+                    ctx.tui.showSystem(`Loaded session "${name}" (${loaded.messages.length} messages) from ${target}`);
+                    break;
+                }
+                case "list": {
+                    const list = Session.list();
+                    if (list.length === 0) {
+                        ctx.tui.showSystem("No saved sessions.");
+                        break;
+                    }
+                    const lines = list.map((s) => `${path.basename(s.file)}  (${s.size} bytes, ${new Date(s.mtime).toLocaleString()})`);
+                    ctx.tui.showSystem(lines.join("\n"));
+                    break;
+                }
+                case "clear": {
+                    ctx.session.clear();
+                    ctx.tui.showSystem("Session cleared.");
+                    break;
+                }
+                default:
+                    ctx.tui.showSystem("Usage: /session save [name] | load <name> | list | clear");
+            }
+        },
+    },
+    arena: {
+        help: "/arena - Enter arena mode (compare models)",
+        run: (_args, ctx) => {
+            ctx.tui.enterArena();
+        },
+    },
+    exit: {
+        help: "/exit - Exit the TUI",
+        run: (_args, ctx) => {
+            ctx.tui.exit();
+        },
+    },
+    cost: {
+        help: "/cost - Show token usage and estimated cost summary",
+        run: (_args, ctx) => {
+            const tracker = ctx.tui.costTracker;
+            if (!tracker) {
+                ctx.tui.showSystem("Cost tracking not available.");
+                return;
+            }
+            ctx.tui.showSystem(tracker.formatSummary());
+        },
+    },
+    "reset-cost": {
+        help: "/reset-cost - Reset cost and token counters",
+        run: (_args, ctx) => {
+            const tracker = ctx.tui.costTracker;
+            if (!tracker) {
+                ctx.tui.showSystem("Cost tracking not available.");
+                return;
+            }
+            tracker.reset();
+            try {
+                CostTracker.save(tracker);
+            }
+            catch {
+                // best-effort persistence
+            }
+            ctx.tui.showSystem("Cost counters reset.");
+        },
+    },
+    settings: {
+        help: "/settings [set <key> <value> | reset] - View or modify settings",
+        run: (args, ctx) => {
+            const settings = ctx.settings ?? Settings.instance();
+            const sub = args[0]?.toLowerCase() ?? "";
+            if (sub === "set") {
+                const key = args[1];
+                const value = args.slice(2).join(" ").trim();
+                if (!key) {
+                    return "Usage: /settings set <key> <value>";
+                }
+                if (!(key in settings.getAll())) {
+                    return `Unknown setting "${key}". Available: ${Object.keys(settings.getAll()).join(", ")}`;
+                }
+                const coerced = coerceSetting(key, value);
+                settings.set(key, coerced);
+                settings.save();
+                return `Set ${key} = ${coerced}`;
+            }
+            if (sub === "reset") {
+                settings.reset();
+                settings.save();
+                return "Settings reset to defaults.";
+            }
+            const s = settings.getAll();
+            const lines = [
+                "Settings:",
+                ...Object.entries(s).map(([k, v]) => `  ${k}: ${v}`),
+                "",
+                "Usage: /settings set <key> <value> | reset",
+            ];
+            return lines.join("\n");
+        },
+    },
+    stats: {
+        help: "/stats - Show session stats, cost summary, and provider health",
+        run: async (_args, ctx) => {
+            const lines = [];
+            const session = ctx.session;
+            const messages = session?.messages ?? [];
+            const userCount = messages.filter((m) => m.role === "user").length;
+            const assistantCount = messages.filter((m) => m.role === "assistant").length;
+            const toolCount = messages.filter((m) => m.role === "tool").length;
+            lines.push("Session:");
+            lines.push(`  messages: ${messages.length} (user: ${userCount}, assistant: ${assistantCount}, tool: ${toolCount})`);
+            const tracker = ctx.costTracker ?? ctx.tui.costTracker;
+            if (tracker) {
+                lines.push("");
+                lines.push("Cost:");
+                lines.push(tracker.formatSummary());
+            }
+            else {
+                lines.push("");
+                lines.push("Cost: (not available)");
+            }
+            lines.push("");
+            lines.push("Provider health:");
+            try {
+                const statuses = await ctx.router.healthAll();
+                if (statuses.length === 0) {
+                    lines.push("  (no providers)");
+                }
+                else {
+                    for (const s of statuses) {
+                        const state = s.healthy ? "healthy" : s.circuitOpen ? "OPEN" : "unhealthy";
+                        const err = s.lastError ? ` (${s.lastError})` : "";
+                        lines.push(`  ${s.provider}: ${state}${err}`);
+                    }
+                }
+            }
+            catch (err) {
+                lines.push(`  (health check failed: ${err.message})`);
+            }
+            return lines.join("\n");
+        },
+    },
+    combo: {
+        help: "/combo list | create <name> [provider...] | select <name> | delete <name> - Manage provider/model combos",
+        run: (args, ctx) => {
+            const mgr = ComboManager.instance();
+            const sub = args[0] ? args[0].toLowerCase() : "";
+            const renderList = () => {
+                const list = mgr.list();
+                if (list.length === 0)
+                    return "No combos yet. Create one with: /combo create <name> [provider...]";
+                return ["Combos:", ...list.map((c) => {
+                        const provs = c.providers.length ? c.providers.join(", ") : "(none)";
+                        const models = c.models.length ? c.models.join(", ") : "(none)";
+                        return "  " + c.name + (c.default ? " (built-in)" : "") + " - providers: " + provs + ", models: " + models;
+                    })].join("\n");
+            };
+            switch (sub) {
+                case "list": {
+                    ctx.tui.showSystem(renderList());
+                    return;
+                }
+                case "create": {
+                    const name = args[1];
+                    if (!name)
+                        return "Usage: /combo create <name> [provider...]";
+                    const providers = args.slice(2).map((p) => p.trim()).filter(Boolean);
+                    if (mgr.get(name))
+                        return 'Combo "' + name + '" already exists.';
+                    const created = mgr.create(name, { providers });
+                    if (!created)
+                        return 'Could not create combo "' + name + '".';
+                    ctx.tui.showSystem('Created combo "' + name + '"' + (providers.length ? " with providers: " + providers.join(", ") : "") + ".");
+                    ctx.tui.showSystem(mgr.render(name));
+                    return;
+                }
+                case "select": {
+                    const name = args[1];
+                    if (!name)
+                        return "Usage: /combo select <name>";
+                    const c = mgr.select(name);
+                    if (!c) {
+                        const names = mgr.list().map((x) => x.name).join(", ") || "(none)";
+                        return 'Unknown combo "' + name + '". Available: ' + names;
+                    }
+                    for (const p of c.providers) {
+                        if (ctx.router.getProviderNames().includes(p))
+                            ctx.router.setActiveProvider(p);
+                    }
+                    if (c.models[0])
+                        ctx.router.setActiveModel(c.models[0]);
+                    ctx.tui.showSystem('Selected combo "' + name + '". Active provider: ' + (ctx.router.getActiveProvider() ?? "(none)") + ', model: ' + (ctx.router.getActiveModel() ?? "(default)"));
+                    return;
+                }
+                case "delete": {
+                    const name = args[1];
+                    if (!name)
+                        return "Usage: /combo delete <name>";
+                    const ok = mgr.delete(name);
+                    if (!ok)
+                        return 'Cannot delete combo "' + name + '" (not found or built-in).';
+                    ctx.tui.showSystem('Deleted combo "' + name + '".');
+                    return;
+                }
+                default: {
+                    ctx.tui.showSystem("Usage: /combo list | create <name> [provider...] | select <name> | delete <name>");
+                    ctx.tui.showSystem("\n" + renderList());
+                    return;
+                }
+            }
+        },
+    },
+    quit: {
+        help: "/quit - Exit the TUI",
+        run: (_args, ctx) => {
+            ctx.tui.exit();
+        },
+    },
+    "reset-health": {
+        help: "/reset-health - Reset health state for all providers",
+        run: (_args, ctx) => {
+            ctx.router.resetHealth();
+            ctx.tui.showSystem("Health state reset for all providers.");
+        },
+    },
+    skills: {
+        help: "/skills - List available custom skills",
+        run: (_args, ctx) => {
+            const skills = (ctx.skills ?? Skills.instance());
+            const list = skills.list();
+            if (list.length === 0) {
+                ctx.tui.showSystem("No skills found. Add .md files to ~/.aether/skills/.");
+                return;
+            }
+            const lines = list.map((s) => `  ${s.name} - ${s.description}`);
+            ctx.tui.showSystem("Skills:\n" + lines.join("\n"));
+        },
+    },
+    skill: {
+        help: "/skill <name> [args] - Run a custom skill",
+        run: async (args, ctx) => {
+            const skills = (ctx.skills ?? Skills.instance());
+            const name = args[0];
+            if (!name) {
+                return "Usage: /skill <name> [args]";
+            }
+            const skill = skills.get(name);
+            if (!skill) {
+                return `Unknown skill "${name}". Available: ${skills.list().map((s) => s.name).join(", ") || "(none)"}`;
+            }
+            const rest = args.slice(1);
+            const argsObj = {};
+            for (let i = 0; i < rest.length; i++) {
+                const part = rest[i];
+                const eq = part.indexOf("=");
+                if (eq !== -1) {
+                    argsObj[part.slice(0, eq).trim()] = part.slice(eq + 1);
+                }
+                else if (skill.arguments[i]) {
+                    argsObj[skill.arguments[i]] = part;
+                }
+                else {
+                    argsObj["arg" + i] = part;
+                }
+            }
+            const prompt = skills.render(name, argsObj);
+            let result = "";
+            try {
+                for await (const chunk of ctx.agent.run(prompt, ctx.session.messages)) {
+                    if (chunk.type === "text" && chunk.text)
+                        result += chunk.text;
+                    if (chunk.type === "error" && chunk.error) {
+                        result += "\n[error] " + chunk.error;
+                    }
+                }
+            }
+            catch (err) {
+                return `Skill error: ${err.message}`;
+            }
+            if (!result.trim())
+                return "(no output)";
+            ctx.tui.showSystem(result);
+        },
+    },
+    connect: {
+        help: "/connect <provider> <api_key> - Connect an API key for a provider",
+        run: async (args, ctx) => {
+            const provider = args[0] ?? "";
+            const key = args.slice(1).join("").trim();
+            if (!provider) {
+                ctx.tui.showSystem("Usage: /connect <provider> <api_key>");
+                return;
+            }
+            if (!key) {
+                ctx.tui.showSystem("Usage: /connect <provider> <api_key>");
+                return;
+            }
+            const names = ctx.router.getProviderNames();
+            if (!names.includes(provider)) {
+                ctx.tui.showSystem(`Unknown provider "${provider}". Available: ${names.join(", ") || "(none)"}`);
+                return;
+            }
+            ctx.router.setKey(provider, key);
+            ctx.tui.showSystem(`Connected ${provider}.`);
+            ctx.tui.showSystem("Testing...");
+            try {
+                const statuses = await ctx.router.healthAll();
+                const s = statuses.find((x) => x.provider === provider);
+                if (s) {
+                    const state = s.healthy ? "healthy" : s.circuitOpen ? "OPEN" : "unhealthy";
+                    ctx.tui.showSystem(`${provider}: ${state}${s.lastError ? " (" + s.lastError + ")" : ""}`);
+                }
+                else {
+                    ctx.tui.showSystem(`${provider}: no status returned`);
+                }
+            }
+            catch (err) {
+                ctx.tui.showSystem(`Health check failed: ${err.message}`);
+            }
+        },
+    },
+    keys: {
+        help: "/keys - List which providers have API keys configured",
+        run: (_args, ctx) => {
+            const list = ctx.router.keys ? ctx.router.keys.list() : [];
+            if (list.length === 0) {
+                ctx.tui.showSystem("No known providers.");
+                return;
+            }
+            const lines = list.map((e) => `  ${e.provider}: ${e.hasKey ? "yes" : "no"}`);
+            ctx.tui.showSystem("API keys:\n" + lines.join("\n"));
+        },
+    },
+    disconnect: {
+        help: "/disconnect <provider> - Remove an API key",
+        run: (args, ctx) => {
+            const provider = args.join(" ").trim();
+            if (!provider) {
+                ctx.tui.showSystem("Usage: /disconnect <provider>");
+                return;
+            }
+            if (ctx.router.keys && ctx.router.keys.has(provider)) {
+                ctx.router.keys.remove(provider);
+                ctx.router.setKey(provider, "");
+                ctx.tui.showSystem(`Disconnected ${provider}.`);
+            }
+            else {
+                ctx.tui.showSystem(`No key configured for ${provider}.`);
+            }
+        },
+    },
+};