@hemansubedi/aether-ai 1.0.0

package/dist/settings.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const SETTINGS_DIR = path.join(os.homedir(), ".aether");
+const SETTINGS_FILE = path.join(SETTINGS_DIR, "settings.json");
+const SETTINGS_VERSION = 1;
+const DEFAULTS = {
+    theme: "dark",
+    streaming: true,
+    maxSteps: 15,
+    temperature: 0.7,
+    confirmTools: true,
+    autoSave: true,
+};
+function isBool(v) {
+    return typeof v === "boolean";
+}
+function isNum(v) {
+    return typeof v === "number" && Number.isFinite(v);
+}
+function isStr(v) {
+    return typeof v === "string";
+}
+function coerce(key, v) {
+    const def = DEFAULTS[key];
+    if (typeof def === "boolean")
+        return isBool(v) ? v : def;
+    if (typeof def === "number")
+        return isNum(v) ? v : def;
+    return isStr(v) ? v : def;
+}
+export class Settings {
+    settings = { ...DEFAULTS };
+    dirty = false;
+    constructor() { }
+    get(key) {
+        return this.settings[key];
+    }
+    set(key, value) {
+        this.settings[key] = coerce(key, value);
+        this.dirty = true;
+    }
+    getAll() {
+        return { ...this.settings };
+    }
+    reset() {
+        this.settings = { ...DEFAULTS };
+        this.dirty = true;
+    }
+    save() {
+        try {
+            if (!fs.existsSync(SETTINGS_DIR)) {
+                fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+            }
+            const snapshot = { version: SETTINGS_VERSION, settings: { ...this.settings } };
+            const tmp = SETTINGS_FILE + ".tmp";
+            fs.writeFileSync(tmp, JSON.stringify(snapshot, null, 2), "utf8");
+            fs.renameSync(tmp, SETTINGS_FILE);
+        }
+        catch {
+            // best-effort persistence
+        }
+        this.dirty = false;
+    }
+    restore(snapshot) {
+        if (!snapshot || typeof snapshot !== "object")
+            return;
+        const src = snapshot.settings ?? {};
+        for (const key of Object.keys(DEFAULTS)) {
+            if (key in src) {
+                this.settings[key] = coerce(key, src[key]);
+            }
+        }
+    }
+    static load() {
+        const s = new Settings();
+        try {
+            if (fs.existsSync(SETTINGS_FILE)) {
+                const raw = fs.readFileSync(SETTINGS_FILE, "utf8");
+                s.restore(JSON.parse(raw));
+            }
+        }
+        catch {
+            // ignore malformed settings file
+        }
+        return s;
+    }
+    static instanceCache = new Map();
+    static instance(name = "default") {
+        let s = Settings.instanceCache.get(name);
+        if (!s) {
+            s = name === "default" ? Settings.load() : new Settings();
+            Settings.instanceCache.set(name, s);
+        }
+        return s;
+    }
+}

package/dist/skills.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+export class Skills {
+    dir;
+    skills;
+    constructor(dir) {
+        this.dir = dir ?? path.join(os.homedir(), ".aether", "skills");
+        this.skills = new Map();
+        this.load();
+    }
+    load() {
+        try {
+            if (!fs.existsSync(this.dir)) {
+                this.ensureDefault();
+                return;
+            }
+            const files = fs.readdirSync(this.dir).filter((f) => f.endsWith(".md"));
+            for (const f of files) {
+                const skill = this.parseFile(path.join(this.dir, f));
+                if (skill)
+                    this.skills.set(skill.name, skill);
+            }
+            if (this.skills.size === 0)
+                this.ensureDefault();
+        }
+        catch {
+            this.ensureDefault();
+        }
+    }
+    ensureDefault() {
+        const def = {
+            name: "explain",
+            description: "Explain a concept in simple terms",
+            arguments: ["topic"],
+            template: "Explain {{topic}} in simple terms with an analogy. Keep it under 200 words."
+        };
+        this.skills.set(def.name, def);
+        try {
+            fs.mkdirSync(this.dir, { recursive: true });
+            const file = path.join(this.dir, "explain.md");
+            if (!fs.existsSync(file)) {
+                fs.writeFileSync(file, `---\nname: explain\ndescription: Explain a concept in simple terms\narguments:\n  - topic\n---\n\nExplain {{topic}} in simple terms with an analogy. Keep it under 200 words.`, "utf8");
+            }
+        }
+        catch {
+            // best effort
+        }
+    }
+    parseFile(file) {
+        try {
+            const raw = fs.readFileSync(file, "utf8");
+            const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+            if (!fmMatch)
+                return null;
+            const fm = fmMatch[1];
+            const body = fmMatch[2].trim();
+            const name = fm.match(/^name:\s*(.+)$/m)?.[1].trim() ?? "";
+            const description = fm.match(/^description:\s*(.+)$/m)?.[1].trim() ?? "";
+            const argsSection = fm.match(/^arguments:\s*\n((?:\s+-\s*.+\n?)+)/m);
+            const args = [];
+            if (argsSection) {
+                const re = /^\s+-\s*(.+)$/gm;
+                let m;
+                while ((m = re.exec(argsSection[1])) !== null)
+                    args.push(m[1].trim());
+            }
+            if (!name)
+                return null;
+            return { name, description, arguments: args, template: body };
+        }
+        catch {
+            return null;
+        }
+    }
+    list() {
+        return Array.from(this.skills.values());
+    }
+    get(name) {
+        return this.skills.get(name);
+    }
+    render(name, args) {
+        const skill = this.skills.get(name);
+        if (!skill)
+            return `ERROR: unknown skill "${name}"`;
+        let out = skill.template;
+        for (const [k, v] of Object.entries(args)) {
+            out = out.replace(new RegExp(`{{${k}}}`, "g"), v);
+        }
+        // Replace any remaining {{arg}} with the joined args string.
+        out = out.replace(/{{(\w+)}}/g, (_, k) => args[k] ?? "");
+        return out;
+    }
+    static instance_ = null;
+    static instance() {
+        if (!Skills.instance_)
+            Skills.instance_ = new Skills();
+        return Skills.instance_;
+    }
+}

package/dist/tokensaver.js

@@ -0,0 +1,50 @@
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.split(/\s+/).filter(Boolean).length * 1.3);
+}
+export function estimateMessageTokens(m) {
+    let n = estimateTokens(typeof m.content === "string" ? m.content : m.content.map((p) => p.type === "text" ? p.text : "").join(""));
+    if (m.tool_calls) {
+        for (const tc of m.tool_calls) {
+            n += estimateTokens(tc.function.name) + estimateTokens(tc.function.arguments);
+        }
+    }
+    return n + 4; // role/name overhead
+}
+export function compressText(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function compressHistory(messages, maxTokens) {
+    if (messages.length === 0)
+        return [];
+    const system = messages.find((m) => m.role === "system");
+    const rest = system ? messages.slice(1) : messages;
+    let budget = maxTokens;
+    if (system)
+        budget -= estimateMessageTokens(system);
+    const kept = [];
+    let used = 0;
+    // Walk from the newest backwards.
+    for (let i = rest.length - 1; i >= 0; i--) {
+        const cost = estimateMessageTokens(rest[i]);
+        if (used + cost > budget)
+            break;
+        kept.unshift(rest[i]);
+        used += cost;
+    }
+    const dropped = rest.length - kept.length;
+    const result = [];
+    if (system)
+        result.push(system);
+    if (dropped > 0) {
+        result.push({
+            role: "system",
+            content: `[${dropped} earlier message(s) omitted to fit context]`,
+        });
+    }
+    result.push(...kept);
+    return result;
+}

package/dist/tools/filesystem.js

@@ -0,0 +1,243 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execSync } from "node:child_process";
+import { Checkpoint } from "../checkpoint.js";
+const MAX_READ_CHARS = 50_000;
+const MAX_OUTPUT_CHARS = 30_000;
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return (s.slice(0, max) +
+        `\n\n[...truncated ${s.length - max} more characters...]\n`);
+}
+export function makeReadFileTool(rootDir) {
+    return {
+        def: {
+            name: "ReadFile",
+            description: "Read the contents of a file at a given relative path. Returns file contents.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "relative path from project root",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+        execute: async (args) => {
+            const rel = String(args.path ?? "");
+            const target = path.resolve(rootDir, rel);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${rel}" escapes the project root`;
+            }
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: file not found: ${rel}`;
+                }
+                if (fs.statSync(target).isDirectory()) {
+                    return `ERROR: path "${rel}" is a directory, not a file`;
+                }
+                const content = fs.readFileSync(target, "utf8");
+                return truncate(content, MAX_READ_CHARS);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR reading "${rel}": ${message}`;
+            }
+        },
+    };
+}
+export function makeWriteFileTool(rootDir) {
+    return {
+        def: {
+            name: "WriteFile",
+            description: "Write content to a file, creating parent directories if needed. Returns confirmation.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    content: { type: "string" },
+                },
+                required: ["path", "content"],
+            },
+        },
+        execute: async (args) => {
+            const rel = String(args.path ?? "");
+            const content = String(args.content ?? "");
+            const target = path.resolve(rootDir, rel);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${rel}" escapes the project root`;
+            }
+            try {
+                try {
+                    Checkpoint.instance().autoCheckpoint(rootDir, rel);
+                }
+                catch { }
+                const parent = path.dirname(target);
+                fs.mkdirSync(parent, { recursive: true });
+                fs.writeFileSync(target, content, "utf8");
+                return `Wrote ${Buffer.byteLength(content, "utf8")} bytes to ${rel}`;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR writing "${rel}": ${message}`;
+            }
+        },
+    };
+}
+export function makeEditFileTool(rootDir) {
+    return {
+        def: {
+            name: "EditFile",
+            description: "Replace exact text in a file. oldText must match exactly once. Returns confirmation.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string" },
+                    oldText: { type: "string" },
+                    newText: { type: "string" },
+                },
+                required: ["path", "oldText", "newText"],
+            },
+        },
+        execute: async (args) => {
+            const rel = String(args.path ?? "");
+            const oldText = String(args.oldText ?? "");
+            const newText = String(args.newText ?? "");
+            const target = path.resolve(rootDir, rel);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${rel}" escapes the project root`;
+            }
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: file not found: ${rel}`;
+                }
+                try {
+                    Checkpoint.instance().autoCheckpoint(rootDir, rel);
+                }
+                catch { }
+                const original = fs.readFileSync(target, "utf8");
+                const first = original.indexOf(oldText);
+                if (first === -1) {
+                    return `ERROR: oldText not found in "${rel}". The file may have changed; read it first.`;
+                }
+                const second = original.indexOf(oldText, first + 1);
+                if (second !== -1) {
+                    return `ERROR: oldText found multiple times in "${rel}". oldText must match exactly once.`;
+                }
+                const updated = original.slice(0, first) +
+                    newText +
+                    original.slice(first + oldText.length);
+                fs.writeFileSync(target, updated, "utf8");
+                return `Edited ${rel}: ${countLines(oldText)} old line(s) -> ${countLines(newText)} new line(s)`;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR editing "${rel}": ${message}`;
+            }
+        },
+    };
+}
+function countLines(s) {
+    if (s.length === 0)
+        return 0;
+    return s.split("\n").length;
+}
+export function makeListDirTool(rootDir) {
+    return {
+        def: {
+            name: "ListDir",
+            description: "List files and subdirectories at a path (recursive, like tree).",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", default: "." },
+                },
+            },
+        },
+        execute: async (args) => {
+            const rel = String(args.path ?? ".");
+            const target = path.resolve(rootDir, rel);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${rel}" escapes the project root`;
+            }
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: path not found: ${rel}`;
+                }
+                const lines = [];
+                const rootLabel = rel === "." ? "." : rel;
+                lines.push(rootLabel);
+                walk(target, "", lines);
+                return truncate(lines.join("\n"), MAX_OUTPUT_CHARS);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR listing "${rel}": ${message}`;
+            }
+        },
+    };
+}
+function walk(dir, prefix, lines) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    const filtered = entries.filter((e) => !e.name.startsWith("."));
+    filtered.forEach((entry, i) => {
+        const isLast = i === filtered.length - 1;
+        const connector = isLast ? "+-- " : "+-- ";
+        lines.push(`${prefix}${connector}${entry.name}`);
+        if (entry.isDirectory()) {
+            walk(path.join(dir, entry.name), prefix + (isLast ? "    " : "�   "), lines);
+        }
+    });
+}
+export function makeBashTool(rootDir) {
+    return {
+        def: {
+            name: "Bash",
+            description: "Execute a shell command in the project directory. Returns stdout+stderr. Use for running commands, tests, installs. Prefer non-interactive commands.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "the shell command",
+                    },
+                    timeoutMs: { type: "number", default: 30000 },
+                },
+                required: ["command"],
+            },
+        },
+        execute: async (args) => {
+            const command = String(args.command ?? "");
+            if (!command.trim()) {
+                return "ERROR: empty command";
+            }
+            const timeoutMs = Math.max(1000, Math.min(600_000, Number(args.timeoutMs) || 30_000));
+            try {
+                const stdout = execSync(command, {
+                    cwd: rootDir,
+                    maxBuffer: 10 * 1024 * 1024,
+                    timeout: timeoutMs,
+                    encoding: "utf8",
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+                return truncate(stdout, MAX_OUTPUT_CHARS);
+            }
+            catch (err) {
+                const stderr = err?.stderr ? String(err.stderr) : "";
+                const message = err?.message ? String(err.message) : String(err);
+                const stdout = err?.stdout ? String(err.stdout) : "";
+                return truncate(`ERROR: ${stderr || message}\nSTDOUT: ${stdout}`, MAX_OUTPUT_CHARS);
+            }
+        },
+    };
+}

package/dist/tools/git.js

@@ -0,0 +1,53 @@
+import { GitTool } from "../git.js";
+export function makeGitTool(rootDir) {
+    return {
+        def: {
+            name: "Git",
+            description: "Run git operations: status, diff, commit, log, branch. Use this to inspect version control state or make commits.",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["status", "diff", "commit", "log", "branch"], description: "The git operation to perform" },
+                    message: { type: "string", description: "Commit message (required for commit)" },
+                    file: { type: "string", description: "Optional file path to limit diff" },
+                    count: { type: "number", description: "Number of commits to show (for log)", default: 5 }
+                },
+                required: ["action"]
+            }
+        },
+        execute: async (args) => {
+            if (!GitTool.isRepo(rootDir)) {
+                return `ERROR: ${rootDir} is not a git repository.`;
+            }
+            try {
+                switch (args.action) {
+                    case "status": {
+                        const files = await GitTool.status(rootDir);
+                        if (files.length === 0)
+                            return "Working tree clean.";
+                        return files.map((f) => `${f.status}\t${f.file}`).join("\n");
+                    }
+                    case "diff": {
+                        const d = await GitTool.diff(rootDir, args.file);
+                        return d || "(no differences)";
+                    }
+                    case "commit": {
+                        return await GitTool.commit(rootDir, args.message || "");
+                    }
+                    case "log": {
+                        const commits = await GitTool.log(rootDir, args.count ?? 5);
+                        return commits.map((c) => `${c.hash} ${c.date} ${c.message}`).join("\n");
+                    }
+                    case "branch": {
+                        return `Current branch: ${await GitTool.branch(rootDir)}`;
+                    }
+                    default:
+                        return `ERROR: unknown git action "${args.action}"`;
+                }
+            }
+            catch (err) {
+                return `ERROR: ${err.message}`;
+            }
+        }
+    };
+}