@hemansubedi/aether-ai 1.0.0

package/dist/keys.js

@@ -0,0 +1,128 @@
+// API key manager for Aether.
+//
+// WARNING: Keys are stored PLAINTEXT in ~/.aether/keys.json on this machine.
+// This is intentional for a local CLI tool running on your own machine --
+// anyone with read access to that file can use your keys. Do not share the
+// file, do not commit it, and do not run Aether on machines you do not trust.
+// For temporary keys, prefer environment variables (they are never written
+// to disk by this module).
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+// Provider name -> environment variable that may hold its API key.
+export const ENV_MAP = {
+    "openrouter-free": "OPENROUTER_API_KEY",
+    groq: "GROQ_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    cohere: "COHERE_API_KEY",
+    huggingface: "HUGGINGFACE_API_KEY",
+    fireworks: "FIREWORKS_API_KEY",
+    together: "TOGETHER_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    gemini: "GEMINI_API_KEY",
+    xai: "XAI_API_KEY",
+    perplexity: "PERPLEXITY_API_KEY",
+    cerebras: "CEREBRAS_API_KEY",
+    nvidia: "NVIDIA_NIM_API_KEY",
+    jina: "JINA_API_KEY",
+    parasail: "PARASAIL_API_KEY",
+    featherless: "FEATHERLESS_API_KEY",
+    voyage: "VOYAGE_API_KEY",
+    cloudflare: "CLOUDFLARE_API_KEY",
+};
+function keysPath() {
+    return path.join(os.homedir(), ".aether", "keys.json");
+}
+export class KeyManager {
+    keys = new Map();
+    loaded = false;
+    ensureLoaded() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        this.loadFromDisk();
+    }
+    loadFromDisk() {
+        try {
+            const p = keysPath();
+            if (!fs.existsSync(p))
+                return;
+            const raw = fs.readFileSync(p, "utf8");
+            const obj = JSON.parse(raw);
+            if (obj && typeof obj === "object") {
+                for (const [k, v] of Object.entries(obj)) {
+                    if (typeof v === "string" && v)
+                        this.keys.set(k, v);
+                }
+            }
+        }
+        catch {
+            // Ignore a missing or corrupt keys file; we'll just have no keys.
+        }
+    }
+    /** Store a key (or remove it when given an empty/falsy value). */
+    set(providerName, key) {
+        this.ensureLoaded();
+        if (key && key.trim())
+            this.keys.set(providerName, key.trim());
+        else
+            this.keys.delete(providerName);
+        this.save();
+    }
+    get(providerName) {
+        this.ensureLoaded();
+        return this.keys.get(providerName);
+    }
+    has(providerName) {
+        this.ensureLoaded();
+        return this.keys.has(providerName);
+    }
+    remove(providerName) {
+        this.ensureLoaded();
+        this.keys.delete(providerName);
+        this.save();
+    }
+    /** Every known provider and whether a key is currently configured. */
+    list() {
+        this.ensureLoaded();
+        return Object.keys(ENV_MAP).map((provider) => ({
+            provider,
+            hasKey: this.keys.has(provider),
+        }));
+    }
+    /** Scan process.env for known key env vars and load any found into the map. */
+    detectFromEnv() {
+        this.ensureLoaded();
+        for (const [provider, envVar] of Object.entries(ENV_MAP)) {
+            const v = process.env[envVar];
+            if (v && v.trim())
+                this.keys.set(provider, v.trim());
+        }
+        return this;
+    }
+    /** Persist the current in-memory keys to disk atomically. */
+    save() {
+        this.ensureLoaded();
+        const file = keysPath();
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        const obj = {};
+        for (const [k, v] of this.keys)
+            obj[k] = v;
+        const tmp = file + ".tmp";
+        fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf8");
+        fs.renameSync(tmp, file);
+    }
+    /** Singleton: load from disk AND env. */
+    static load() {
+        if (!KeyManager._instance)
+            KeyManager._instance = new KeyManager();
+        const km = KeyManager._instance;
+        km.ensureLoaded();
+        km.detectFromEnv();
+        return km;
+    }
+    static instance() {
+        return KeyManager.load();
+    }
+    static _instance = null;
+}

package/dist/memory.js

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const MEMORY_DIR = path.join(os.homedir(), ".aether", "memory");
+export class Memory {
+    facts = [];
+    dirty = false;
+    constructor() {
+        this.load();
+    }
+    static path() {
+        return path.join(MEMORY_DIR, "MEMORY.md");
+    }
+    load() {
+        this.facts = [];
+        const file = Memory.path();
+        try {
+            if (fs.existsSync(file)) {
+                const raw = fs.readFileSync(file, "utf8");
+                for (const line of raw.split("\n")) {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith("- ")) {
+                        const fact = trimmed.slice(2).trim();
+                        if (fact)
+                            this.facts.push(fact);
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore read errors; start with empty memory
+        }
+        this.dirty = false;
+    }
+    save() {
+        try {
+            if (!fs.existsSync(MEMORY_DIR)) {
+                fs.mkdirSync(MEMORY_DIR, { recursive: true });
+            }
+            const lines = this.facts.map((f) => `- ${f}`);
+            const content = lines.length ? lines.join("\n") + "\n" : "";
+            const tmp = Memory.path() + ".tmp";
+            fs.writeFileSync(tmp, content, "utf8");
+            fs.renameSync(tmp, Memory.path());
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to save memory: ${message}`);
+        }
+        this.dirty = false;
+    }
+    add(fact) {
+        const trimmed = fact.trim();
+        if (!trimmed)
+            return;
+        const lower = trimmed.toLowerCase();
+        for (let i = 0; i < this.facts.length; i++) {
+            if (this.facts[i].toLowerCase() === lower) {
+                // Move to end (refresh).
+                this.facts.splice(i, 1);
+                this.facts.push(trimmed);
+                this.dirty = true;
+                return;
+            }
+        }
+        this.facts.push(trimmed);
+        this.dirty = true;
+    }
+    remove(fact) {
+        const trimmed = fact.trim();
+        if (!trimmed)
+            return;
+        const lower = trimmed.toLowerCase();
+        const before = this.facts.length;
+        this.facts = this.facts.filter((f) => f.toLowerCase() !== lower);
+        if (this.facts.length !== before)
+            this.dirty = true;
+    }
+    search(query) {
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return [];
+        return this.facts.filter((f) => f.toLowerCase().includes(q));
+    }
+    getAll() {
+        return this.facts.slice();
+    }
+    toContext() {
+        if (this.facts.length === 0)
+            return "";
+        const lines = this.facts.map((f) => `- ${f}`);
+        return "## Long-term Memory\n" + lines.join("\n");
+    }
+    ensureSaved() {
+        if (this.dirty)
+            this.save();
+    }
+}

package/dist/modes.js

@@ -0,0 +1,68 @@
+export class ModeManager {
+    static MODES = {
+        plan: "plan",
+        yolo: "yolo",
+        normal: "normal",
+    };
+    mode = "normal";
+    constructor(mode) {
+        if (mode)
+            this.setMode(mode);
+    }
+    setMode(name) {
+        const key = name.trim().toLowerCase();
+        if (!(key in ModeManager.MODES)) {
+            throw new Error(`Unknown mode "${name}". Available: ${Object.keys(ModeManager.MODES).join(", ")}`);
+        }
+        this.mode = key;
+        return this.mode;
+    }
+    getMode() {
+        return this.mode;
+    }
+    getSystemPromptModifier() {
+        switch (this.mode) {
+            case "plan":
+                return ("You are in PLAN mode. Do NOT modify files or run commands. " +
+                    "Explore only with ReadFile, Glob, Grep, ListDir. Produce a detailed plan.");
+            case "yolo":
+                return ("You are in YOLO mode. Proceed with all actions without asking for " +
+                    "confirmation. Be efficient and direct.");
+            default:
+                return "";
+        }
+    }
+    requiresConfirmation(toolName) {
+        switch (this.mode) {
+            case "plan":
+                // Plan mode should not even expose these tools; if called, block.
+                return true;
+            case "yolo":
+                return false;
+            default:
+                // Normal mode: confirm destructive actions.
+                return (toolName === "Bash" ||
+                    toolName === "WriteFile" ||
+                    toolName === "EditFile");
+        }
+    }
+    allowedTools(mode) {
+        const m = (mode ?? this.mode);
+        switch (m) {
+            case "plan":
+                return ["ReadFile", "Glob", "Grep", "ListDir"];
+            case "yolo":
+            case "normal":
+            default:
+                return [
+                    "ReadFile",
+                    "WriteFile",
+                    "EditFile",
+                    "ListDir",
+                    "Bash",
+                    "Glob",
+                    "Grep",
+                ];
+        }
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,32 @@
+export async function fetchWithTimeout(url, opts = {}, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signal = opts.signal
+        ? AbortSignal.any([controller.signal, opts.signal])
+        : controller.signal;
+    try {
+        const res = await fetch(url, { ...opts, signal });
+        return res;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function createProvider(config) {
+    switch (config.type) {
+        case "ollama": {
+            const { OllamaProvider } = await import("./ollama.js");
+            return new OllamaProvider(config);
+        }
+        case "openrouter": {
+            const { OpenRouterProvider } = await import("./openrouter.js");
+            return new OpenRouterProvider(config);
+        }
+        case "openai-compatible": {
+            const { OpenAICompatProvider } = await import("./openai-compat.js");
+            return new OpenAICompatProvider(config);
+        }
+        default:
+            throw new Error(`Unknown provider type: ${config.type}`);
+    }
+}

package/dist/providers/ollama.js

@@ -0,0 +1,206 @@
+import { fetchWithTimeout } from "./index.js";
+function estimateTokens(text) {
+    return Math.ceil(text.split(/\s+/).filter(Boolean).length * 1.3);
+}
+export class OllamaProvider {
+    name;
+    config;
+    resolvedModel;
+    constructor(config) {
+        this.name = config.name;
+        this.config = config;
+    }
+    get base() {
+        return this.config.baseURL.replace(/\/$/, "");
+    }
+    async listModels() {
+        try {
+            const res = await fetchWithTimeout(`${this.base}/api/tags`, {}, this.config.timeoutMs);
+            if (!res.ok)
+                return [];
+            const data = (await res.json());
+            return (data?.models ?? []).map((m) => m.name).filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Query /api/tags and return the installed models together with their
+     * Ollama-reported capabilities (e.g. ["completion","tools","vision"]).
+     */
+    async listModelsWithCapabilities() {
+        const out = new Map();
+        try {
+            const res = await fetchWithTimeout(`${this.base}/api/tags`, {}, this.config.timeoutMs);
+            if (!res.ok)
+                return out;
+            const data = (await res.json());
+            for (const m of data?.models ?? []) {
+                const name = m?.name;
+                if (!name)
+                    continue;
+                const caps = Array.isArray(m?.capabilities) ? m.capabilities.map(String) : [];
+                out.set(name, caps);
+            }
+        }
+        catch {
+            // ignore
+        }
+        return out;
+    }
+    /**
+     * Resolve the actual model to use for a request.
+     *
+     * 1. If the configured model (config.models[0]) is installed locally, use it.
+     * 2. Otherwise fall back to the first installed model that supports tools
+     *    (its capabilities include "tools") � this is what lets the agent call
+     *    tools without failing over to cloud providers.
+     * 3. If no installed model supports tools, fall back to the first installed
+     *    model, else a sane default.
+     *
+     * The result is cached so /api/tags is only hit once per provider instance.
+     */
+    async resolveModel() {
+        if (this.resolvedModel)
+            return this.resolvedModel;
+        const configured = this.config.models[0];
+        const withCaps = await this.listModelsWithCapabilities();
+        const installed = Array.from(withCaps.keys());
+        let chosen;
+        if (configured && installed.includes(configured)) {
+            chosen = configured;
+        }
+        else {
+            // Prefer a tool-capable installed model so the agent can call tools.
+            const toolCapable = installed.find((n) => (withCaps.get(n) ?? []).includes("tools"));
+            chosen = toolCapable ?? installed[0] ?? configured ?? "aether";
+        }
+        this.resolvedModel = chosen;
+        return chosen;
+    }
+    async health() {
+        const start = Date.now();
+        try {
+            const res = await fetchWithTimeout(`${this.base}/api/version`, {}, 5000);
+            if (!res.ok) {
+                return { healthy: false, failures: 0, lastCheck: start, lastError: `HTTP ${res.status}`, circuitOpen: false, cooldownUntil: 0 };
+            }
+            return { healthy: true, failures: 0, lastCheck: start, circuitOpen: false, cooldownUntil: 0 };
+        }
+        catch (err) {
+            return { healthy: false, failures: 0, lastCheck: start, lastError: err.message, circuitOpen: false, cooldownUntil: 0 };
+        }
+    }
+    async countTokens(text) {
+        try {
+            const res = await fetchWithTimeout(`${this.base}/api/count`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ text }),
+            }, 5000);
+            if (res.ok) {
+                const data = (await res.json());
+                if (typeof data?.count === "number")
+                    return data.count;
+            }
+        }
+        catch {
+            // fall back to estimation
+        }
+        return estimateTokens(text);
+    }
+    async *chat(messages, tools, opts) {
+        // Auto-detect the real installed model at runtime; fall back gracefully.
+        const model = await this.resolveModel();
+        const body = {
+            model,
+            messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+                ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+                ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+                ...(m.name ? { name: m.name } : {}),
+                // Ollama vision: top-level `images` array of base64 strings on a message.
+                ...(Array.isArray(m.images) && m.images.length > 0
+                    ? { images: m.images }
+                    : {}),
+            })),
+            stream: true,
+            options: {
+                temperature: opts?.temperature ?? 0.7,
+                num_ctx: 4096,
+            },
+        };
+        if (tools && tools.length > 0) {
+            body.tools = tools.map((t) => ({
+                type: "function",
+                function: { name: t.name, description: t.description, parameters: t.parameters },
+            }));
+        }
+        if (opts?.maxTokens) {
+            body.options.num_predict = opts.maxTokens;
+        }
+        const res = await fetchWithTimeout(`${this.base}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            signal: opts?.signal,
+        }, this.config.timeoutMs);
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Ollama chat failed: HTTP ${res.status} ${text}`);
+        }
+        const reader = res.body?.getReader();
+        if (!reader) {
+            throw new Error("Ollama chat: no response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let idx = buffer.indexOf("\n");
+            while (idx !== -1) {
+                const line = buffer.slice(0, idx).trim();
+                buffer = buffer.slice(idx + 1);
+                if (line) {
+                    const obj = JSON.parse(line);
+                    if (obj?.message?.content) {
+                        yield { type: "text", text: obj.message.content };
+                    }
+                    if (Array.isArray(obj?.message?.tool_calls)) {
+                        for (const tc of obj.message.tool_calls) {
+                            yield {
+                                type: "tool_call",
+                                tool_call: {
+                                    id: tc.id || `call_${Date.now()}`,
+                                    type: "function",
+                                    function: {
+                                        name: tc.function.name,
+                                        arguments: tc.function.arguments ?? "",
+                                    },
+                                },
+                            };
+                        }
+                    }
+                    if (typeof obj?.prompt_eval_count === "number")
+                        inputTokens = obj.prompt_eval_count;
+                    if (typeof obj?.eval_count === "number")
+                        outputTokens = obj.eval_count;
+                    if (obj?.done) {
+                        yield {
+                            type: "done",
+                            usage: { input_tokens: inputTokens, output_tokens: outputTokens },
+                        };
+                    }
+                }
+                idx = buffer.indexOf("\n");
+            }
+        }
+    }
+}