@hemansubedi/aether-ai 1.0.0

package/src/config.ts

@@ -0,0 +1,122 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import type { ProviderConfig } from "./types.js";
+
+const CONFIG_DIR = path.join(os.homedir(), ".aether");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+// Real, locally-installed Ollama models (verified 2026-09-02):
+//   - goekdenizguelmez/JOSIEFIED-Qwen3:8b        (tool-capable, default)
+//   - hf.co/OBLITERATUS/Qwen3.8-27B-OBLITERATED:Q4_K_M (vision, no tools)
+export const DEFAULT_OLLAMA_MODELS = [
+  "goekdenizguelmez/JOSIEFIED-Qwen3:8b",
+  "hf.co/OBLITERATUS/Qwen3.8-27B-OBLITERATED:Q4_K_M",
+];
+
+export const DEFAULT_PROVIDERS: ProviderConfig[] = [
+  {
+    name: "ollama-local",
+    type: "ollama",
+    baseURL: process.env.AETHER_BASE_URL || "http://localhost:11434",
+    apiKey: undefined,
+    models: [...DEFAULT_OLLAMA_MODELS],
+    priority: 1,
+    enabled: true,
+    maxRetries: 2,
+    timeoutMs: 120000,
+  },
+  {
+    name: "openrouter-free",
+    type: "openrouter",
+    baseURL: "https://openrouter.ai/api/v1",
+    apiKey: process.env.OPENROUTER_API_KEY || process.env.AETHER_API_KEY,
+    models: [],
+    priority: 2,
+    enabled: true,
+    maxRetries: 2,
+    timeoutMs: 120000,
+  },
+  {
+    name: "openai-compatible",
+    type: "openai-compatible",
+    baseURL: process.env.AETHER_BASE_URL || "https://api.openai.com/v1",
+    apiKey: process.env.OPENAI_API_KEY || process.env.AETHER_API_KEY,
+    models: [],
+    priority: 3,
+    enabled: true,
+    maxRetries: 1,
+    timeoutMs: 120000,
+  },
+];
+
+export interface Config {
+  providers: ProviderConfig[];
+  defaultModel: string;
+  activeProvider?: string;
+}
+
+export function loadConfig(): Config {
+  let fileConfig: Partial<Config> = {};
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = fs.readFileSync(CONFIG_FILE, "utf8");
+      fileConfig = JSON.parse(raw);
+    }
+  } catch {
+    // ignore malformed config; fall back to defaults
+  }
+
+  const envModel = process.env.AETHER_MODEL;
+  const envProvider = process.env.AETHER_PROVIDER;
+
+  let providers: ProviderConfig[];
+  if (Array.isArray(fileConfig.providers) && fileConfig.providers.length > 0) {
+    providers = fileConfig.providers as ProviderConfig[];
+  } else {
+    providers = DEFAULT_PROVIDERS.map((p) => ({ ...p }));
+  }
+
+  // Apply env overrides on top of file config.
+  if (envProvider) {
+    providers = providers.map((p) =>
+      p.name === envProvider ? { ...p, enabled: true } : p
+    );
+  }
+
+  const defaultModel = envModel || fileConfig.defaultModel || DEFAULT_OLLAMA_MODELS[0];
+  const activeProvider = envProvider || fileConfig.activeProvider;
+
+  return { providers, defaultModel, activeProvider };
+}
+
+export function saveConfig(cfg: Config): void {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf8");
+  } catch (err) {
+    throw new Error(`Failed to save config to ${CONFIG_FILE}: ${(err as Error).message}`);
+  }
+}
+
+export function getConfig(): Config {
+  return loadConfig();
+}
+
+export function getActiveProvider(): ProviderConfig | undefined {
+  const cfg = loadConfig();
+  if (cfg.activeProvider) {
+    const match = cfg.providers.find((p) => p.name === cfg.activeProvider);
+    if (match) return match;
+  }
+  const sorted = [...cfg.providers]
+    .filter((p) => p.enabled)
+    .sort((a, b) => a.priority - b.priority);
+  return sorted[0];
+}
+
+export function configPath(): string {
+  return CONFIG_FILE;
+}

package/src/cost.ts

@@ -0,0 +1,206 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+export interface CostRecord {
+  provider: string;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  requests: number;
+  cost: number;
+}
+
+interface CostSnapshot {
+  version: number;
+  records: Record<string, Omit<CostRecord, "provider" | "model">>;
+}
+
+// Per-token pricing in USD. Defaults are conservative estimates for free/cheap
+// endpoints; callers may override via CostTracker.setPrice().
+const DEFAULT_INPUT_PRICE: Record<string, number> = {
+  "openrouter-free": 0,
+  "openai-compatible": 0.000002,
+  ollama: 0,
+};
+
+const DEFAULT_OUTPUT_PRICE: Record<string, number> = {
+  "openrouter-free": 0,
+  "openai-compatible": 0.000006,
+  ollama: 0,
+};
+
+const COST_DIR = path.join(os.homedir(), ".aether");
+const COST_FILE = path.join(COST_DIR, "cost.json");
+const COST_VERSION = 1;
+
+function key(provider: string, model: string): string {
+  return `${provider}::${model}`;
+}
+
+function pad(s: string, width: number): string {
+  if (s.length >= width) return s;
+  return s + " ".repeat(width - s.length);
+}
+
+function formatUSD(value: number): string {
+  if (!isFinite(value)) return "0.000000";
+  if (Math.abs(value) < 1e-6 && value !== 0) return value.toExponential(3);
+  return value.toFixed(6);
+}
+
+export class CostTracker {
+  private records = new Map<string, CostRecord>();
+  private inputPrice: Record<string, number> = { ...DEFAULT_INPUT_PRICE };
+  private outputPrice: Record<string, number> = { ...DEFAULT_OUTPUT_PRICE };
+
+  constructor() {}
+
+  setPrice(provider: string, inputPerToken: number, outputPerToken: number): void {
+    this.inputPrice[provider] = inputPerToken;
+    this.outputPrice[provider] = outputPerToken;
+  }
+
+  record(provider: string, model: string, inputTokens: number, outputTokens: number): void {
+    const k = key(provider, model);
+    let r = this.records.get(k);
+    if (!r) {
+      r = { provider, model, inputTokens: 0, outputTokens: 0, requests: 0, cost: 0 };
+      this.records.set(k, r);
+    }
+    const safeIn = Number.isFinite(inputTokens) ? Math.max(0, inputTokens) : 0;
+    const safeOut = Number.isFinite(outputTokens) ? Math.max(0, outputTokens) : 0;
+    r.inputTokens += safeIn;
+    r.outputTokens += safeOut;
+    r.requests += 1;
+    const inPrice = this.inputPrice[provider] ?? DEFAULT_INPUT_PRICE[provider] ?? 0;
+    const outPrice = this.outputPrice[provider] ?? DEFAULT_OUTPUT_PRICE[provider] ?? 0;
+    r.cost += safeIn * inPrice + safeOut * outPrice;
+  }
+
+  private list(): CostRecord[] {
+    return Array.from(this.records.values()).sort((a, b) => b.cost - a.cost);
+  }
+
+  getSummary(): CostRecord[] {
+    return this.list();
+  }
+
+  getTotal(): number {
+    let total = 0;
+    for (const r of this.records.values()) total += r.cost;
+    return total;
+  }
+
+  formatSummary(): string {
+    const rows = this.list();
+    const total = this.getTotal();
+
+    const headers = ["Provider", "Model", "Requests", "Input Tok", "Output Tok", "Cost (USD)"];
+    const data: string[][] = [];
+    for (const r of rows) {
+      data.push([
+        r.provider,
+        r.model,
+        String(r.requests),
+        String(r.inputTokens),
+        String(r.outputTokens),
+        formatUSD(r.cost),
+      ]);
+    }
+    if (rows.length === 0) {
+      data.push(["-", "-", "-", "-", "-", "-"]);
+    }
+    data.push(["", "", "", "", "Total", formatUSD(total)]);
+
+    const widths: number[] = headers.map((h, i) => {
+      let w = h.length;
+      for (const row of data) {
+        if (row[i] && row[i].length > w) w = row[i].length;
+      }
+      return w;
+    });
+
+    const lines: string[] = [];
+    lines.push(headers.map((h, i) => pad(h, widths[i])).join("  "));
+    lines.push(widths.map((w) => "-".repeat(w)).join("  "));
+    for (const row of data) {
+      lines.push(row.map((c, i) => pad(c, widths[i])).join("  "));
+    }
+    return lines.join("\n");
+  }
+
+  reset(): void {
+    this.records.clear();
+  }
+
+  private snapshot(): CostSnapshot {
+    const out: CostSnapshot["records"] = {};
+    for (const [k, r] of this.records) {
+      out[k] = {
+        inputTokens: r.inputTokens,
+        outputTokens: r.outputTokens,
+        requests: r.requests,
+        cost: r.cost,
+      };
+    }
+    return { version: COST_VERSION, records: out };
+  }
+
+  private restore(snapshot: CostSnapshot): void {
+    this.records.clear();
+    if (!snapshot || typeof snapshot !== "object") return;
+    for (const [k, v] of Object.entries(snapshot.records ?? {})) {
+      const parts = k.split("::");
+      const provider = parts[0] ?? "";
+      const model = parts.slice(1).join("::");
+      const r: CostRecord = {
+        provider,
+        model,
+        inputTokens: v?.inputTokens ?? 0,
+        outputTokens: v?.outputTokens ?? 0,
+        requests: v?.requests ?? 0,
+        cost: v?.cost ?? 0,
+      };
+      this.records.set(k, r);
+    }
+  }
+
+  static load(): CostTracker {
+    const tracker = new CostTracker();
+    try {
+      if (fs.existsSync(COST_FILE)) {
+        const raw = fs.readFileSync(COST_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        tracker.restore(parsed);
+      }
+    } catch {
+      // ignore malformed cost file
+    }
+    return tracker;
+  }
+
+  static save(tracker: CostTracker): void {
+    try {
+      if (!fs.existsSync(COST_DIR)) {
+        fs.mkdirSync(COST_DIR, { recursive: true });
+      }
+      const tmp = COST_FILE + ".tmp";
+      fs.writeFileSync(tmp, JSON.stringify(tracker.snapshot(), null, 2), "utf8");
+      fs.renameSync(tmp, COST_FILE);
+    } catch {
+      // best-effort persistence
+    }
+  }
+
+  private static instanceCache = new Map<string, CostTracker>();
+
+  static instance(name: string = "default"): CostTracker {
+    let t = CostTracker.instanceCache.get(name);
+    if (!t) {
+      t = name === "default" ? CostTracker.load() : new CostTracker();
+      CostTracker.instanceCache.set(name, t);
+    }
+    return t;
+  }
+}

package/src/git.ts

@@ -0,0 +1,68 @@
+import * as cp from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface GitFileStatus {
+  file: string;
+  status: string;
+}
+
+export interface GitCommit {
+  hash: string;
+  message: string;
+  date: string;
+}
+
+export class GitTool {
+  static isRepo(rootDir: string): boolean {
+    try {
+      cp.execSync("git rev-parse --is-inside-work-tree", { cwd: rootDir, stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static async status(rootDir: string): Promise<GitFileStatus[]> {
+    const out = cp.execSync("git status --short", { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+    const results: GitFileStatus[] = [];
+    for (const line of out.split("\n")) {
+      if (!line.trim()) continue;
+      const status = line.slice(0, 2).trim();
+      const file = line.slice(3).trim();
+      results.push({ file, status });
+    }
+    return results;
+  }
+
+  static async diff(rootDir: string, file?: string): Promise<string> {
+    const args = file ? `-- "${file}"` : "";
+    return cp.execSync(`git diff ${args}`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+  }
+
+  static async commit(rootDir: string, message: string): Promise<string> {
+    if (!message || message.trim().length === 0) {
+      throw new Error("Commit message is required");
+    }
+    if (message.includes("\n") || message.includes("'") || message.includes('"')) {
+      throw new Error("Commit message must be a single line without quotes");
+    }
+    return cp.execSync(`git commit -am "${message.replace(/"/g, "")}"`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+  }
+
+  static async branch(rootDir: string): Promise<string> {
+    return cp.execSync("git rev-parse --abbrev-ref HEAD", { cwd: rootDir, encoding: "utf8", maxBuffer: 1024 * 1024 }).trim();
+  }
+
+  static async log(rootDir: string, count = 5): Promise<GitCommit[]> {
+    const fmt = "%H%x1f%s%x1f%ci";
+    const out = cp.execSync(`git log -n ${count} --format="${fmt}"`, { cwd: rootDir, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 });
+    const commits: GitCommit[] = [];
+    for (const line of out.split("\n")) {
+      if (!line.trim()) continue;
+      const [hash, message, date] = line.split("\x1f");
+      commits.push({ hash: hash.slice(0, 7), message, date });
+    }
+    return commits;
+  }
+}

package/src/health.ts

@@ -0,0 +1,90 @@
+import type { HealthStatus } from "./types.js";
+
+const FAILURE_THRESHOLD = 3;
+const COOLDOWN_MS = 60000;
+
+export class HealthTracker {
+  private map = new Map<string, HealthStatus>();
+
+  private ensure(provider: string): HealthStatus {
+    let s = this.map.get(provider);
+    if (!s) {
+      s = {
+        provider,
+        healthy: true,
+        failures: 0,
+        lastCheck: 0,
+        circuitOpen: false,
+        cooldownUntil: 0,
+      };
+      this.map.set(provider, s);
+    }
+    return s;
+  }
+
+  recordSuccess(provider: string): void {
+    const s = this.ensure(provider);
+    s.healthy = true;
+    s.failures = 0;
+    s.circuitOpen = false;
+    s.cooldownUntil = 0;
+    s.lastError = undefined;
+    s.lastCheck = Date.now();
+  }
+
+  recordFailure(provider: string, error?: string): void {
+    const s = this.ensure(provider);
+    s.failures += 1;
+    s.healthy = false;
+    s.lastError = error;
+    s.lastCheck = Date.now();
+    if (s.failures >= FAILURE_THRESHOLD) {
+      s.circuitOpen = true;
+      s.cooldownUntil = Date.now() + COOLDOWN_MS;
+    }
+  }
+
+  getStatus(provider: string): HealthStatus {
+    const s = this.ensure(provider);
+    const now = Date.now();
+    if (s.circuitOpen) {
+      if (now >= s.cooldownUntil) {
+        // half-open: allow one probe
+        s.circuitOpen = false;
+        s.cooldownUntil = 0;
+      } else {
+        return { ...s };
+      }
+    }
+    s.lastCheck = now;
+    return { ...s };
+  }
+
+  isAvailable(provider: string): boolean {
+    const s = this.ensure(provider);
+    if (!s.circuitOpen) return true;
+    if (Date.now() >= s.cooldownUntil) {
+      s.circuitOpen = false;
+      s.cooldownUntil = 0;
+      return true;
+    }
+    return false;
+  }
+
+  getAll(): HealthStatus[] {
+    return Array.from(this.map.values()).map((s) => ({ ...s }));
+  }
+
+  reset(provider: string): void {
+    const s = this.ensure(provider);
+    s.healthy = true;
+    s.failures = 0;
+    s.circuitOpen = false;
+    s.cooldownUntil = 0;
+    s.lastError = undefined;
+  }
+
+  resetAll(): void {
+    this.map.clear();
+  }
+}