@hemansubedi/aether-ai 1.0.0

package/src/index.ts

@@ -0,0 +1,281 @@
+import * as path from "node:path";
+import * as os from "node:os";
+import { RouterEngine } from "./router-engine.js";
+import { HealthTracker } from "./health.js";
+import { getConfig } from "./config.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool } from "./tools/filesystem.js";
+import { makeGlobTool } from "./tools/glob.js";
+import { makeGrepTool } from "./tools/grep.js";
+import { makeWebSearchTool } from "./tools/websearch.js";
+import { makeVisionTool } from "./tools/vision.js";
+import { makeGitTool } from "./tools/git.js";
+import { Agent } from "./agent.js";
+import { Session } from "./session.js";
+import { Arena } from "./arena.js";
+import { Memory } from "./memory.js";
+import { ModeManager } from "./modes.js";
+import { CostTracker } from "./cost.js";
+import { Settings } from "./settings.js";
+import { createTUI } from "./tui.js";
+import type { ChatChunk, Message, ToolDef } from "./types.js";
+import { FreeRouterClient, type ChatResult } from "./client.js";
+import { KeyManager } from "./keys.js";
+
+export async function runChat(
+  messages: Message[],
+  tools: ToolDef[] = [],
+  opts?: { temperature?: number; maxTokens?: number; signal?: AbortSignal }
+): Promise<{ text: string; toolCalls: any[]; usage?: { input_tokens: number; output_tokens: number } }> {
+  const cfg = getConfig();
+  const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+  let text = "";
+  const toolCalls: any[] = [];
+  let usage: ChatChunk["usage"];
+  try {
+    const result = await engine.chat(messages, tools, opts);
+    text = result.text;
+    toolCalls.push(...result.toolCalls);
+    usage = result.usage;
+  } catch (err) {
+    throw new Error((err as Error).message);
+  }
+  return { text, toolCalls, usage };
+}
+
+function makeRouterAdapter(engine: RouterEngine) {
+  const adapter: any = {
+    configs: engine.configs_,
+    activeProvider: undefined as string | undefined,
+    activeModel: undefined as string | undefined,
+    chat: (messages: any, tools: any, opts?: any) => engine.chatStream(messages, tools, opts),
+    select: () => null,
+    setActiveProvider: (n?: string) => { adapter.activeProvider = n; },
+    setActiveModel: (m: string) => { adapter.activeModel = m; },
+    getActiveProvider: () => adapter.activeProvider,
+    getActiveModel: () => adapter.activeModel,
+    getProviderNames: () => engine.configs_.filter((c: any) => c.enabled).map((c: any) => c.name),
+    getModelsFor: (name?: string) => {
+      const c = engine.configs_.find((cfg: any) => cfg.name === (name ?? adapter.activeProvider));
+      return c?.models ?? [];
+    },
+    listAllModels: () => engine.listFreeModels(),
+    healthAll: () => engine.healthAll(),
+    resetHealth: () => engine.resetHealth(),
+    keys: engine.keys,
+    setKey: (name: string, key: string) => engine.setKey(name, key),
+  };
+  return adapter;
+}
+
+export function createAgent(rootDir: string = process.cwd()): Agent {
+  const cfg = getConfig();
+  const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+  const router = makeRouterAdapter(engine);
+  const registry = new ToolRegistry();
+  const factories = [
+    makeReadFileTool,
+    makeWriteFileTool,
+    makeEditFileTool,
+    makeListDirTool,
+    makeBashTool,
+    makeGlobTool,
+    makeGrepTool,
+    makeWebSearchTool,
+    makeVisionTool,
+    makeGitTool,
+  ];
+  for (const make of factories) {
+    const tool = make(rootDir);
+    registry.register(tool.def, tool.execute);
+  }
+  const memory = new Memory();
+  const modeManager = new ModeManager();
+  return new Agent(router, registry, { memory, modeManager });
+}
+
+export function createAgentFromServer(baseURL?: string): Agent {
+  const client = new FreeRouterClient(baseURL);
+  const adapter: any = {
+    configs: [],
+    activeProvider: undefined as string | undefined,
+    activeModel: undefined as string | undefined,
+    select: () => null,
+    setActiveProvider: (n?: string) => { adapter.activeProvider = n; },
+    setActiveModel: (m: string) => { adapter.activeModel = m; },
+    getActiveProvider: () => adapter.activeProvider,
+    getActiveModel: () => adapter.activeModel,
+    getProviderNames: async () => {
+      const statuses = await client.providers();
+      return statuses.map((s) => s.provider);
+    },
+    getModelsFor: async (_name?: string) => {
+      const list = await client.listModels();
+      return list.data.map((m) => m.id);
+    },
+    listAllModels: async () => {
+      const list = await client.listModels();
+      const out: Record<string, string[]> = {};
+      for (const m of list.data) {
+        const owner = m.owned_by || "server";
+        (out[owner] ??= []).push(m.id);
+      }
+      return out;
+    },
+    healthAll: async () => client.providers(),
+    resetHealth: async () => { await client.resetHealth(); },
+  };
+  adapter.chat = async function* (messages: any, tools: any, opts?: any): AsyncGenerator<ChatChunk> {
+    const result: ChatResult = await client.chat(messages, {
+      model: opts?.model,
+      tools,
+      temperature: opts?.temperature,
+      maxTokens: opts?.maxTokens,
+      stream: false,
+    });
+    adapter.activeProvider = result.provider;
+    adapter.activeModel = result.model;
+    if (result.text) yield { type: "text", text: result.text } as ChatChunk;
+    for (const tc of result.toolCalls ?? []) {
+      yield { type: "tool_call", tool_call: tc } as ChatChunk;
+    }
+    yield { type: "done", usage: result.usage } as ChatChunk;
+  };
+
+  const registry = new ToolRegistry();
+  const factories = [
+    makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool,
+    makeGlobTool, makeGrepTool, makeWebSearchTool, makeVisionTool, makeGitTool,
+  ];
+  for (const make of factories) {
+    const tool = make(process.cwd());
+    registry.register(tool.def, tool.execute);
+  }
+  return new Agent(adapter, registry, { memory: new Memory(), modeManager: new ModeManager() });
+}
+export function createTUIContext(rootDir: string = process.cwd()) {
+  const cfg = getConfig();
+  const engine = new RouterEngine(undefined, undefined, KeyManager.instance());
+  const router = makeRouterAdapter(engine);
+  const registry = new ToolRegistry();
+  for (const make of [makeReadFileTool, makeWriteFileTool, makeEditFileTool, makeListDirTool, makeBashTool, makeGlobTool, makeGrepTool, makeWebSearchTool, makeVisionTool, makeGitTool]) {
+    const tool = make(rootDir);
+    registry.register(tool.def, tool.execute);
+  }
+  const agent = new Agent(router, registry, { memory: new Memory(), modeManager: new ModeManager() });
+  const session = new Session();
+  const arena = new Arena(router);
+  const costTracker = CostTracker.load();
+  const settings = Settings.load();
+  const skills = Skills.instance();
+  const checkpoint = Checkpoint.instance();
+  const tui = createTUI({ agent, router, session, arena, costTracker, settings, skills, checkpoint });
+  return { agent, router, session, arena, costTracker, settings, tui };
+}
+
+export { RouterEngine, HealthTracker, KeyManager, getConfig, Agent, ToolRegistry, Session, Arena, createTUI, Memory, ModeManager, CostTracker, GitTool, Checkpoint, Skills, FreeRouterClient };
+import { GitTool } from "./git.js";
+import { Checkpoint } from "./checkpoint.js";
+import { Skills } from "./skills.js";
+
+// CLI entrypoint
+function isMainModule(): boolean {
+  // Robust across tsx/Node and Windows path formatting.
+  const self = import.meta.url.replace(/\/$/g, "");
+  const argv1 = "file://" + path.resolve(process.argv[1] ?? "");
+  if (self === argv1) return true;
+  // Also match when invoked via `tsx` where argv may be a .ts source file.
+  try {
+    const selfPath = new URL(self).pathname;
+    const argvPath = path.resolve(process.argv[1] ?? "");
+    const norm = (p: string) => p.toLowerCase().replace(/\\/g, "/").replace(/^\//, "");
+    if (norm(selfPath) === norm(argvPath)) return true;
+  } catch {
+    // ignore
+  }
+  return false;
+}
+
+if (isMainModule()) {
+  // Parse CLI flags: --plan and --yolo set the agent mode and are stripped
+  // from the prompt args.
+  let modeFlag: string | null = null;
+  const promptArgs: string[] = [];
+  for (const arg of process.argv.slice(2)) {
+    if (arg === "--plan") {
+      modeFlag = "plan";
+    } else if (arg === "--yolo") {
+      modeFlag = "yolo";
+    } else {
+      promptArgs.push(arg);
+    }
+  }
+  const prompt = promptArgs.join(" ").trim();
+
+  if (!prompt) {
+    // Interactive TUI mode.
+    const { tui } = createTUIContext();
+    tui.start();
+  } else if (prompt.startsWith("/")) {
+    // A single command in non-interactive mode.
+    const { tui } = createTUIContext();
+    tui.handleCommand(prompt).then(() => process.exit(0)).catch((err) => {
+      process.stderr.write(`error: ${(err as Error).message}\n`);
+      process.exit(1);
+    });
+  } else {
+    // One-shot prompt: run the agent, print the answer, save the session.
+    (async () => {
+      try {
+        const agent = createAgent();
+        // Honor AETHER_MODEL / AETHER_PROVIDER env vars in one-shot mode so
+        // local Ollama models can be selected without an interactive TUI.
+        if (process.env.AETHER_PROVIDER) {
+          agent.router.setActiveProvider(process.env.AETHER_PROVIDER);
+        }
+        if (process.env.AETHER_MODEL) {
+          agent.router.setActiveModel(process.env.AETHER_MODEL);
+        }
+        const session = new Session();
+        const costTracker = CostTracker.load();
+  const settings = Settings.load();
+        const provider = agent.router.getActiveProvider() ?? "unknown";
+        const model = agent.router.getActiveModel() ?? "default";
+        if (modeFlag) agent.setMode(modeFlag);
+
+        let assistantText = "";
+        for await (const chunk of agent.run(prompt, session.messages)) {
+          if (chunk.type === "text" && chunk.text) {
+            process.stdout.write(chunk.text);
+            assistantText += chunk.text;
+          }
+          if (chunk.type === "tool_call" && chunk.tool_call) {
+            process.stderr.write(`\n[Tool: ${chunk.tool_call.function.name}]\n`);
+          }
+          if (chunk.type === "error" && chunk.error) {
+            process.stderr.write(`\n[error] ${chunk.error}\n`);
+          }
+          if (chunk.type === "done" && chunk.usage) {
+            costTracker.record(provider, model, chunk.usage.input_tokens, chunk.usage.output_tokens);
+          }
+        }
+        CostTracker.save(costTracker);
+
+        if (agent.lastMessages.length > 0) {
+          session.messages = agent.lastMessages.filter((m) => m.role !== "system");
+        }
+        const sessions = Session.list();
+        const file = sessions[0]?.file ?? path.join(os.homedir(), ".aether", "sessions", "session.json");
+        Session.save(file, session);
+        process.stdout.write("\n");
+      } catch (err) {
+        process.stderr.write(`error: ${(err as Error).message}\n`);
+        process.exit(1);
+      }
+    })();
+  }
+}
+
+
+
+

package/src/keys.ts

@@ -0,0 +1,135 @@
+// 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: Record<string, string> = {
+  "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(): string {
+  return path.join(os.homedir(), ".aether", "keys.json");
+}
+
+export class KeyManager {
+  private keys: Map<string, string> = new Map();
+  private loaded = false;
+
+  private ensureLoaded(): void {
+    if (this.loaded) return;
+    this.loaded = true;
+    this.loadFromDisk();
+  }
+
+  private loadFromDisk(): void {
+    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: string, key: string): void {
+    this.ensureLoaded();
+    if (key && key.trim()) this.keys.set(providerName, key.trim());
+    else this.keys.delete(providerName);
+    this.save();
+  }
+
+  get(providerName: string): string | undefined {
+    this.ensureLoaded();
+    return this.keys.get(providerName);
+  }
+
+  has(providerName: string): boolean {
+    this.ensureLoaded();
+    return this.keys.has(providerName);
+  }
+
+  remove(providerName: string): void {
+    this.ensureLoaded();
+    this.keys.delete(providerName);
+    this.save();
+  }
+
+  /** Every known provider and whether a key is currently configured. */
+  list(): { provider: string; hasKey: boolean }[] {
+    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 {
+    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(): void {
+    this.ensureLoaded();
+    const file = keysPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const obj: Record<string, string> = {};
+    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(): KeyManager {
+    if (!KeyManager._instance) KeyManager._instance = new KeyManager();
+    const km = KeyManager._instance;
+    km.ensureLoaded();
+    km.detectFromEnv();
+    return km;
+  }
+
+  static instance(): KeyManager {
+    return KeyManager.load();
+  }
+
+  private static _instance: KeyManager | null = null;
+}

package/src/memory.ts

@@ -0,0 +1,101 @@
+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 {
+  private facts: string[] = [];
+  private dirty = false;
+
+  constructor() {
+    this.load();
+  }
+
+  static path(): string {
+    return path.join(MEMORY_DIR, "MEMORY.md");
+  }
+
+  load(): void {
+    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(): void {
+    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: string): void {
+    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: string): void {
+    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: string): string[] {
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    return this.facts.filter((f) => f.toLowerCase().includes(q));
+  }
+
+  getAll(): string[] {
+    return this.facts.slice();
+  }
+
+  toContext(): string {
+    if (this.facts.length === 0) return "";
+    const lines = this.facts.map((f) => `- ${f}`);
+    return "## Long-term Memory\n" + lines.join("\n");
+  }
+
+  ensureSaved(): void {
+    if (this.dirty) this.save();
+  }
+}

package/src/modes.ts

@@ -0,0 +1,84 @@
+export type ModeName = "plan" | "yolo" | "normal";
+
+export class ModeManager {
+  static readonly MODES: Record<ModeName, ModeName> = {
+    plan: "plan",
+    yolo: "yolo",
+    normal: "normal",
+  };
+
+  private mode: ModeName = "normal";
+
+  constructor(mode?: ModeName) {
+    if (mode) this.setMode(mode);
+  }
+
+  setMode(name: string): ModeName {
+    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 as ModeName;
+    return this.mode;
+  }
+
+  getMode(): ModeName {
+    return this.mode;
+  }
+
+  getSystemPromptModifier(): string {
+    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: string): boolean {
+    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?: ModeName): string[] {
+    const m = (mode ?? this.mode) as ModeName;
+    switch (m) {
+      case "plan":
+        return ["ReadFile", "Glob", "Grep", "ListDir"];
+      case "yolo":
+      case "normal":
+      default:
+        return [
+          "ReadFile",
+          "WriteFile",
+          "EditFile",
+          "ListDir",
+          "Bash",
+          "Glob",
+          "Grep",
+        ];
+    }
+  }
+}

package/src/providers/index.ts

@@ -0,0 +1,59 @@
+import type {
+  ChatChunk,
+  HealthStatus,
+  Message,
+  ProviderConfig,
+  ToolDef,
+} from "../types.js";
+
+export type { ProviderConfig };
+
+export interface Provider {
+  readonly name: string;
+  readonly config: ProviderConfig;
+  listModels(): Promise<string[]>;
+  chat(
+    messages: Message[],
+    tools: ToolDef[],
+    opts?: { signal?: AbortSignal; temperature?: number; maxTokens?: number }
+  ): AsyncIterable<ChatChunk>;
+  health(): Promise<Omit<HealthStatus, "provider">>;
+  countTokens?(text: string): Promise<number>;
+}
+
+export async function fetchWithTimeout(
+  url: string,
+  opts: RequestInit = {},
+  timeoutMs: number
+): Promise<Response> {
+  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: ProviderConfig): Promise<Provider> {
+  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}`);
+  }
+}