@hemansubedi/aether-ai 1.0.0

package/dist/tools/glob.js

@@ -0,0 +1,175 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const MAX_RESULTS = 5000;
+/**
+ * Match a single path segment against a glob segment.
+ *  - `*`  matches any characters except `/`
+ *  - `**` matches any number of path segments (including zero)
+ *  - `?`  matches exactly one character except `/`
+ *  - `[...]` character class
+ */
+function matchSegment(segment, value) {
+    if (segment === "**")
+        return true;
+    if (segment === value)
+        return true;
+    // Build a regex from the segment.
+    let re = "";
+    let i = 0;
+    while (i < segment.length) {
+        const ch = segment[i];
+        if (ch === "*") {
+            if (segment[i + 1] === "*") {
+                // `**` within a segment means match anything including /
+                re += ".*";
+                i += 2;
+                continue;
+            }
+            re += "[^/]*";
+            i += 1;
+            continue;
+        }
+        if (ch === "?") {
+            re += "[^/]";
+            i += 1;
+            continue;
+        }
+        if (ch === "[") {
+            let j = i + 1;
+            if (j < segment.length && segment[j] === "!")
+                j++;
+            if (j < segment.length && segment[j] === "]")
+                j++;
+            while (j < segment.length && segment[j] !== "]")
+                j++;
+            if (j >= segment.length) {
+                // No closing bracket - treat literally.
+                re += "\\[";
+                i += 1;
+                continue;
+            }
+            let cls = segment.slice(i + 1, j);
+            if (cls.startsWith("!"))
+                cls = "^" + cls.slice(1);
+            re += "[" + cls + "]";
+            i = j + 1;
+            continue;
+        }
+        re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        i += 1;
+    }
+    return new RegExp("^" + re + "$").test(value);
+}
+function splitPattern(pattern) {
+    return pattern.replace(/\\/g, "/").replace(/^\.\//, "").split("/").filter((s) => s !== "");
+}
+function* walkMatches(segments, prefix, cwd, depth) {
+    const seg = segments[depth];
+    const isLast = depth === segments.length - 1;
+    if (seg === "**") {
+        // `**` matches the current directory and any depth below it.
+        if (isLast) {
+            yield prefix;
+        }
+        // Recurse into the current directory.
+        yield* walkMatches(segments, prefix, cwd, depth + 1);
+        let entries;
+        try {
+            entries = fs.readdirSync(cwd, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith("."))
+                continue;
+            const sub = path.join(cwd, e.name);
+            const rel = prefix ? prefix + "/" + e.name : e.name;
+            if (e.isDirectory()) {
+                yield* walkMatches(segments, rel, sub, depth);
+            }
+            else if (isLast) {
+                yield rel;
+            }
+        }
+        return;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(cwd, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith("."))
+            continue;
+        if (!matchSegment(seg, e.name))
+            continue;
+        const sub = path.join(cwd, e.name);
+        const rel = prefix ? prefix + "/" + e.name : e.name;
+        if (isLast) {
+            yield rel;
+        }
+        else if (e.isDirectory()) {
+            yield* walkMatches(segments, rel, sub, depth + 1);
+        }
+    }
+}
+export function makeGlobTool(rootDir) {
+    return {
+        def: {
+            name: "Glob",
+            description: "Find files matching a glob pattern (e.g. **/*.ts, src/*.js). Returns matching paths relative to project root, sorted.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "glob pattern like **/*.ts",
+                    },
+                    path: {
+                        type: "string",
+                        default: ".",
+                        description: "root dir to search",
+                    },
+                },
+                required: ["pattern"],
+            },
+        },
+        execute: async (args) => {
+            const pattern = String(args.pattern ?? "").trim();
+            if (!pattern) {
+                return "ERROR: pattern is required";
+            }
+            const relRoot = String(args.path ?? ".").trim() || ".";
+            const target = path.resolve(rootDir, relRoot);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${relRoot}" escapes the project root`;
+            }
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: path not found: ${relRoot}`;
+                }
+                const segments = splitPattern(pattern);
+                if (segments.length === 0) {
+                    return "ERROR: empty pattern";
+                }
+                const results = [];
+                for (const match of walkMatches(segments, "", target, 0)) {
+                    results.push(match);
+                    if (results.length >= MAX_RESULTS)
+                        break;
+                }
+                results.sort();
+                if (results.length === 0)
+                    return "No matches";
+                return results.join("\n");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR globbing "${pattern}": ${message}`;
+            }
+        },
+    };
+}

package/dist/tools/grep.js

@@ -0,0 +1,193 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const MAX_RESULTS = 5000;
+const MAX_LINE_CHARS = 5000;
+function matchesInclude(name, include) {
+    if (!include)
+        return true;
+    const patterns = include.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const pat of patterns) {
+        if (matchGlob(pat, name))
+            return true;
+    }
+    return false;
+}
+function matchGlob(pattern, value) {
+    const re = globToRegex(pattern);
+    return re.test(value);
+}
+function globToRegex(pattern) {
+    let re = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === "*") {
+            if (pattern[i + 1] === "*") {
+                re += ".*";
+                i += 2;
+                continue;
+            }
+            re += "[^/]*";
+            i += 1;
+            continue;
+        }
+        if (ch === "?") {
+            re += "[^/]";
+            i += 1;
+            continue;
+        }
+        if (ch === "[") {
+            let j = i + 1;
+            if (j < pattern.length && pattern[j] === "!")
+                j++;
+            if (j < pattern.length && pattern[j] === "]")
+                j++;
+            while (j < pattern.length && pattern[j] !== "]")
+                j++;
+            if (j >= pattern.length) {
+                re += "\\[";
+                i += 1;
+                continue;
+            }
+            let cls = pattern.slice(i + 1, j);
+            if (cls.startsWith("!"))
+                cls = "^" + cls.slice(1);
+            re += "[" + cls + "]";
+            i = j + 1;
+            continue;
+        }
+        re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        i += 1;
+    }
+    return new RegExp("^" + re + "$");
+}
+function isBinary(buf) {
+    // Detect null bytes (common in binary files).
+    for (let i = 0; i < Math.min(buf.length, 4096); i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+function* walkFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith("."))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            yield* walkFiles(full);
+        }
+        else if (e.isFile()) {
+            yield full;
+        }
+    }
+}
+export function makeGrepTool(rootDir) {
+    return {
+        def: {
+            name: "Grep",
+            description: "Search file contents for a regex pattern. Returns matching lines with file path and line number. Use include filter like *.ts.",
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "regex pattern",
+                    },
+                    path: {
+                        type: "string",
+                        default: ".",
+                        description: "dir or file to search",
+                    },
+                    include: {
+                        type: "string",
+                        default: "",
+                        description: "file filter e.g. *.ts",
+                    },
+                    maxResults: {
+                        type: "number",
+                        default: 50,
+                    },
+                },
+                required: ["pattern"],
+            },
+        },
+        execute: async (args) => {
+            const pattern = String(args.pattern ?? "");
+            if (!pattern) {
+                return "ERROR: pattern is required";
+            }
+            let regex;
+            try {
+                regex = new RegExp(pattern);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR: invalid regex: ${message}`;
+            }
+            const relPath = String(args.path ?? ".").trim() || ".";
+            const target = path.resolve(rootDir, relPath);
+            if (!target.startsWith(path.resolve(rootDir))) {
+                return `ERROR: path "${relPath}" escapes the project root`;
+            }
+            const include = String(args.include ?? "");
+            const maxResults = Math.max(1, Math.min(MAX_RESULTS, Number(args.maxResults) || 50));
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: path not found: ${relPath}`;
+                }
+                const files = [];
+                if (fs.statSync(target).isFile()) {
+                    files.push(target);
+                }
+                else {
+                    for (const f of walkFiles(target)) {
+                        files.push(f);
+                    }
+                }
+                const matches = [];
+                for (const full of files) {
+                    const rel = path.relative(rootDir, full).replace(/\\/g, "/");
+                    if (!matchesInclude(rel, include))
+                        continue;
+                    try {
+                        const buf = fs.readFileSync(full);
+                        if (isBinary(buf))
+                            continue;
+                        const text = buf.toString("utf8");
+                        const lines = text.split("\n");
+                        for (let ln = 1; ln <= lines.length; ln++) {
+                            if (matches.length >= maxResults)
+                                break;
+                            const line = lines[ln - 1];
+                            if (line.length > MAX_LINE_CHARS)
+                                continue;
+                            if (regex.test(line)) {
+                                matches.push(`${rel}:${ln}: ${line}`);
+                            }
+                        }
+                    }
+                    catch {
+                        // skip unreadable files
+                    }
+                    if (matches.length >= maxResults)
+                        break;
+                }
+                if (matches.length === 0)
+                    return "No matches";
+                return matches.join("\n");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR grepping "${pattern}": ${message}`;
+            }
+        },
+    };
+}

package/dist/tools/registry.js

@@ -0,0 +1,39 @@
+export class ToolRegistry {
+    tools = new Map();
+    register(def, execute) {
+        this.tools.set(def.name, { ...def, execute });
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    list() {
+        return Array.from(this.tools.values()).map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        }));
+    }
+    toJSON() {
+        return this.list().map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+    async executeTool(name, args) {
+        const registered = this.tools.get(name);
+        if (!registered) {
+            return `ERROR: Unknown tool "${name}". Available tools: ${Array.from(this.tools.keys()).join(", ")}`;
+        }
+        try {
+            return await registered.execute(args ?? {});
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return `ERROR executing tool "${name}": ${message}`;
+        }
+    }
+}

package/dist/tools/vision.js

@@ -0,0 +1,140 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfig } from "../config.js";
+import { createProvider } from "../providers/index.js";
+// Locally-installed vision-capable model (verified 2026-09-02).
+const VISION_MODEL = "hf.co/OBLITERATUS/Qwen3.8-27B-OBLITERATED:Q4_K_M";
+/**
+ * Find a vision-capable provider by inspecting the configured models for the
+ * known vision model. Falls back to any provider that lists the vision model.
+ */
+export async function findVisionProvider() {
+    const cfg = getConfig();
+    // 1. Any provider that has the vision model configured. Force the provider
+    //    to use ONLY the vision model so resolveModel()/models[0] picks it.
+    for (const p of cfg.providers) {
+        if (!p.enabled)
+            continue;
+        if (p.models.includes(VISION_MODEL)) {
+            try {
+                const visionConfig = { ...p, models: [VISION_MODEL] };
+                return wrapProvider(await createProvider(visionConfig), p.name);
+            }
+            catch {
+                // try next
+            }
+        }
+    }
+    // 2. Any provider whose listModels() includes the vision model.
+    for (const p of cfg.providers) {
+        if (!p.enabled)
+            continue;
+        try {
+            const probe = await createProvider(p);
+            const models = await probe.listModels();
+            if (models.includes(VISION_MODEL)) {
+                const visionConfig = { ...p, models: [VISION_MODEL] };
+                return wrapProvider(await createProvider(visionConfig), p.name);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
+function wrapProvider(provider, name) {
+    return {
+        name,
+        async *chatVision(messages, opts) {
+            try {
+                // Ollama's OpenAI-compatible endpoint expects `content` as a string
+                // plus a top-level `images` array of base64 strings on the message.
+                // Other OpenAI-compatible providers accept content arrays; send the
+                // Ollama form since that is the primary vision path here.
+                const serialised = messages.map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                    ...(m.images ? { images: m.images } : {}),
+                }));
+                for await (const chunk of provider.chat(serialised, [], {
+                    signal: opts?.signal,
+                    maxTokens: opts?.maxTokens,
+                })) {
+                    if (chunk.type === "text" && chunk.text)
+                        yield { text: chunk.text };
+                    if (chunk.type === "error" && chunk.error)
+                        yield { error: chunk.error };
+                }
+            }
+            catch (err) {
+                yield { error: err.message };
+            }
+        },
+    };
+}
+export function makeVisionTool(rootDir) {
+    return {
+        def: {
+            name: "DescribeImage",
+            description: "Describe an image file at a given path using a vision-capable model. Returns a textual description.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "path to the image file" },
+                    question: { type: "string", default: "Describe this image in detail.", description: "question about the image" },
+                },
+                required: ["path"],
+            },
+        },
+        execute: async (args) => {
+            const rel = String(args.path ?? "");
+            // Resolve relative to the project root, but allow absolute paths to
+            // image files anywhere on the filesystem (that is the tool's purpose).
+            const target = path.isAbsolute(rel)
+                ? rel
+                : path.resolve(rootDir, rel);
+            const question = String(args.question ?? "Describe this image in detail.");
+            let buf;
+            try {
+                if (!fs.existsSync(target)) {
+                    return `ERROR: image not found: ${rel}`;
+                }
+                if (!fs.statSync(target).isFile()) {
+                    return `ERROR: path "${rel}" is not a file`;
+                }
+                buf = fs.readFileSync(target);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR reading image "${rel}": ${message}`;
+            }
+            const b64 = buf.toString("base64");
+            const provider = await findVisionProvider();
+            if (!provider) {
+                return "No vision-capable provider available.";
+            }
+            const messages = [
+                {
+                    role: "user",
+                    content: question,
+                    images: [b64],
+                },
+            ];
+            let text = "";
+            try {
+                for await (const chunk of provider.chatVision(messages, { maxTokens: 1024 })) {
+                    if (chunk.text)
+                        text += chunk.text;
+                    if (chunk.error)
+                        return `ERROR: vision provider failed: ${chunk.error}`;
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR: vision provider failed: ${message}`;
+            }
+            return text.trim() || "(no description returned)";
+        },
+    };
+}

package/dist/tools/websearch.js

@@ -0,0 +1,118 @@
+const DDG_URL = "https://html.duckduckgo.com/html/";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36";
+/**
+ * Parse DuckDuckGo HTML results into a list of {title, url, snippet}.
+ * DDG wraps real URLs in a redirect (`uddg` query param); we unwrap them.
+ */
+export function parseDdgResults(html) {
+    const results = [];
+    // Each result is an <a class="result__a"> whose href points at the redirect.
+    const linkRe = /<a\b[^>]*class="[^"]*\bresult__a\b[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi;
+    // Snippets live in <a class="result__snippet"> ... </a>.
+    const snippetRe = /<a\b[^>]*class="[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/a>/gi;
+    const rawSnippets = [];
+    let sm;
+    while ((sm = snippetRe.exec(html)) !== null) {
+        rawSnippets.push(stripTags(sm[1] ?? ""));
+    }
+    let idx = 0;
+    let lm;
+    while ((lm = linkRe.exec(html)) !== null) {
+        const href = lm[1] ?? "";
+        const title = stripTags(lm[2] ?? "").trim();
+        if (!title)
+            continue;
+        const url = unwrapRedirect(href);
+        if (!url)
+            continue;
+        const snippet = rawSnippets[idx] ?? "";
+        results.push({ title, url, snippet });
+        idx++;
+    }
+    return results;
+}
+function stripTags(s) {
+    return s
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;|&apos;/g, "'")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function unwrapRedirect(href) {
+    // DDG wraps real URLs in a redirect like:
+    //   //duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com%2Fpage&amp;rut=...
+    // The real destination is the `uddg` query param. The hostname can vary
+    // (html.duckduckgo.com or duckduckgo.com) and the link may be protocol-
+    // relative, so we key off the /l/ path and the uddg param instead.
+    try {
+        const u = new URL(href, "https://html.duckduckgo.com/");
+        if (u.pathname === "/l/") {
+            const target = u.searchParams.get("uddg");
+            if (target)
+                return decodeURIComponent(target);
+        }
+    }
+    catch {
+        // fall through
+    }
+    // Some results are absolute URLs directly.
+    if (/^https?:\/\//i.test(href))
+        return href;
+    return "";
+}
+export function makeWebSearchTool() {
+    return {
+        def: {
+            name: "WebSearch",
+            description: "Search the web for current information. Returns titles, URLs, and snippets. Use for recent events or facts not in the project.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "the search query" },
+                    maxResults: { type: "number", default: 5, description: "max number of results to return" },
+                },
+                required: ["query"],
+            },
+        },
+        execute: async (args) => {
+            const query = String(args.query ?? "").trim();
+            if (!query)
+                return "ERROR: query is required";
+            const maxResults = Math.max(1, Math.min(20, Number(args.maxResults) || 5));
+            let res;
+            try {
+                const url = `${DDG_URL}?${new URLSearchParams({ q: query }).toString()}`;
+                res = await fetch(url, {
+                    method: "GET",
+                    headers: { "User-Agent": USER_AGENT, "Accept": "text/html" },
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR: WebSearch network failure: ${message}`;
+            }
+            if (!res.ok) {
+                return `ERROR: WebSearch failed: HTTP ${res.status}`;
+            }
+            let html = "";
+            try {
+                html = await res.text();
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return `ERROR: WebSearch failed to read response: ${message}`;
+            }
+            const parsed = parseDdgResults(html).slice(0, maxResults);
+            if (parsed.length === 0) {
+                return "No matches found";
+            }
+            return parsed
+                .map((r, i) => `${i + 1}. ${r.title} - ${r.url}\n   ${r.snippet}`)
+                .join("\n\n");
+        },
+    };
+}