ideacode 1.0.0

package/dist/tools/bash.js

@@ -0,0 +1,27 @@
+import { spawn } from "node:child_process";
+export function runBash(args) {
+    return new Promise((resolve) => {
+        const cmd = args.cmd ?? "";
+        const proc = spawn("/bin/sh", ["-c", cmd], { stdio: ["ignore", "pipe", "pipe"] });
+        const outputChunks = [];
+        let resolved = false;
+        const done = (out) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve(out);
+        };
+        const onData = (s) => outputChunks.push(s);
+        proc.stdout?.on("data", (chunk) => onData(chunk.toString()));
+        proc.stderr?.on("data", (chunk) => onData(chunk.toString()));
+        const t = setTimeout(() => {
+            proc.kill("SIGKILL");
+            outputChunks.push("\n(timed out after 30s)");
+            done(outputChunks.join("").trim() || "(empty)");
+        }, 30_000);
+        proc.on("close", () => {
+            clearTimeout(t);
+            done(outputChunks.join("").trim() || "(empty)");
+        });
+    });
+}

package/dist/tools/file.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+const DEFAULT_READ_LIMIT = 500;
+export function readFile(args) {
+    const content = fs.readFileSync(args.path, "utf-8");
+    const parts = content.split("\n");
+    const lines = content.endsWith("\n") ? parts.slice(0, -1) : parts;
+    if (lines.length === 0 && content === "")
+        return "";
+    const offset = args.offset ?? 0;
+    const requestedLimit = args.limit ?? lines.length;
+    const limit = Math.min(requestedLimit, DEFAULT_READ_LIMIT);
+    const selected = lines.slice(offset, offset + limit);
+    const total = lines.length;
+    const truncated = total > offset + selected.length;
+    const suffix = truncated
+        ? `\n\n... (${total - offset - selected.length} more line(s). Use offset/limit to read in chunks.)`
+        : "";
+    return (selected.map((line, idx) => `${String(offset + idx + 1).padStart(4)}| ${line}`).join("\n") +
+        suffix);
+}
+export function writeFile(args) {
+    fs.writeFileSync(args.path, args.content, "utf-8");
+    return "ok";
+}
+export function editFile(args) {
+    const text = fs.readFileSync(args.path, "utf-8");
+    const oldStr = args.old;
+    const newStr = args.new;
+    if (!text.includes(oldStr))
+        return "error: old_string not found";
+    let count = 0;
+    let pos = 0;
+    while ((pos = text.indexOf(oldStr, pos)) !== -1) {
+        count++;
+        pos += oldStr.length;
+    }
+    if (!args.all && count > 1) {
+        return `error: old_string appears ${count} times, must be unique (use all=true)`;
+    }
+    const replacement = args.all ? text.split(oldStr).join(newStr) : text.replace(oldStr, newStr);
+    fs.writeFileSync(args.path, replacement, "utf-8");
+    return "ok";
+}

package/dist/tools/index.js

@@ -0,0 +1,80 @@
+import { getBraveSearchApiKey } from "../config.js";
+import { readFile, writeFile, editFile } from "./file.js";
+import { globFiles, grepFiles } from "./search.js";
+import { runBash } from "./bash.js";
+import { webFetch, webSearch } from "./web.js";
+export const TOOLS = {
+    read: [
+        "Read file with line numbers (file path, not directory). Use limit to read a portion; avoid reading huge files in one go.",
+        { path: "string", offset: "number?", limit: "number?" },
+        readFile,
+    ],
+    write: ["Write content to file", { path: "string", content: "string" }, writeFile],
+    edit: [
+        "Replace old with new in file (old must be unique unless all=true)",
+        { path: "string", old: "string", new: "string", all: "boolean?" },
+        editFile,
+    ],
+    glob: [
+        "Find files by pattern, sorted by mtime. With path '.' (default), .gitignore entries (e.g. node_modules, dist) are excluded; use path node_modules/<pkg> to search inside a single package.",
+        { pat: "string", path: "string?" },
+        globFiles,
+    ],
+    grep: [
+        "Search files for regex. With path '.' (default), .gitignore entries are excluded; use path node_modules/<pkg> to search one package. Prefer specific patterns and narrow path. Returns at most limit matches (default 50, max 100).",
+        { pat: "string", path: "string?", limit: "number?" },
+        grepFiles,
+    ],
+    bash: ["Run shell command", { cmd: "string" }, runBash],
+    web_fetch: [
+        "Fetch a URL and return the main text content (handles JS-rendered pages). Use for docs, raw GitHub, any web page.",
+        { url: "string" },
+        webFetch,
+    ],
+    web_search: [
+        "Search the web and return ranked results (title, url, snippet). Use for current info, docs, GitHub repos.",
+        { query: "string" },
+        webSearch,
+    ],
+};
+function getTools() {
+    const braveKey = getBraveSearchApiKey();
+    if (braveKey)
+        return TOOLS;
+    const { web_search: _, ...rest } = TOOLS;
+    return rest;
+}
+export async function runTool(name, args) {
+    if (name === "web_search" && !getBraveSearchApiKey()) {
+        return "error: Brave Search API key not set. Use /brave or set BRAVE_API_KEY to enable web search.";
+    }
+    const tools = getTools();
+    const def = tools[name];
+    if (!def)
+        return `error: Unknown tool: ${name}`;
+    try {
+        const result = await def[2](args);
+        return result;
+    }
+    catch (err) {
+        return `error: ${err instanceof Error ? err.message : err}`;
+    }
+}
+export function makeSchema() {
+    return Object.entries(getTools()).map(([name, [description, params]]) => {
+        const properties = {};
+        const required = [];
+        for (const [paramName, paramType] of Object.entries(params)) {
+            const isOptional = paramType.endsWith("?");
+            const baseType = paramType.replace(/\?$/, "");
+            properties[paramName] = { type: baseType === "number" ? "integer" : baseType };
+            if (!isOptional)
+                required.push(paramName);
+        }
+        return {
+            name,
+            description,
+            input_schema: { type: "object", properties, required },
+        };
+    });
+}

package/dist/tools/search.js

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { globSync } from "glob";
+function toGlobIgnore(line) {
+    const s = line.replace(/^\//, "").replace(/\/$/, "");
+    if (!s)
+        return "";
+    if (s.includes("*") || s.startsWith("!"))
+        return s;
+    if (s.includes("/") || s.endsWith(".env") || /\.\w+$/.test(s))
+        return `**/${s}`;
+    return `**/${s}/**`;
+}
+function getIgnorePatterns() {
+    const gitignorePath = path.join(process.cwd(), ".gitignore");
+    try {
+        const content = fs.readFileSync(gitignorePath, "utf-8");
+        const patterns = content
+            .split(/\n/)
+            .map((line) => line.trim())
+            .filter((line) => line !== "" && !line.startsWith("#"))
+            .map(toGlobIgnore)
+            .filter(Boolean);
+        return patterns.length > 0 ? patterns : ["**/node_modules/**", "**/dist/**"];
+    }
+    catch {
+        return ["**/node_modules/**", "**/dist/**"];
+    }
+}
+export function globFiles(args) {
+    const base = args.path ?? ".";
+    const pat = args.pat;
+    const pattern = path.join(base, pat).replace(/\/\/+/g, "/");
+    const isProjectRoot = base === "." || base === "";
+    const opts = { nodir: true };
+    if (isProjectRoot)
+        opts.ignore = getIgnorePatterns();
+    const files = globSync(pattern, opts);
+    const withMtime = files.map((f) => ({ f, m: fs.statSync(f).mtimeMs })).sort((a, b) => b.m - a.m);
+    return withMtime.map(({ f }) => f).join("\n") || "none";
+}
+const DEFAULT_GREP_LIMIT = 50;
+const MAX_GREP_LIMIT = 100;
+const MAX_GREP_CHARS = 16_000;
+export function grepFiles(args) {
+    const base = args.path ?? ".";
+    const pat = new RegExp(args.pat);
+    const limit = Math.min(MAX_GREP_LIMIT, Math.max(1, args.limit ?? DEFAULT_GREP_LIMIT));
+    const isProjectRoot = base === "." || base === "";
+    const grepOpts = { nodir: true };
+    if (isProjectRoot)
+        grepOpts.ignore = getIgnorePatterns();
+    const allFiles = globSync(path.join(base, "**/*").replace(/\/\/+/g, "/"), grepOpts);
+    const hits = [];
+    for (const filepath of allFiles) {
+        try {
+            const content = fs.readFileSync(filepath, "utf-8");
+            const lines = content.split(/\n/);
+            for (let i = 0; i < lines.length; i++) {
+                if (pat.test(lines[i]))
+                    hits.push(`${filepath}:${i + 1}:${lines[i].replace(/\r$/, "")}`);
+            }
+        }
+        catch {
+            /* skip */
+        }
+        if (hits.length >= limit)
+            break;
+    }
+    const sliced = hits.slice(0, limit);
+    let out = sliced.join("\n") || "none";
+    if (out.length > MAX_GREP_CHARS) {
+        let acc = 0;
+        let i = 0;
+        for (; i < sliced.length; i++) {
+            const line = sliced[i];
+            if (acc + line.length + 1 > MAX_GREP_CHARS)
+                break;
+            acc += line.length + 1;
+        }
+        out = sliced.slice(0, i).join("\n");
+        const dropped = sliced.length - i;
+        out += `\n\n... (truncated: ${dropped} more matches, total ${hits.length} hit(s). Use a more specific pattern or path to reduce output.)`;
+    }
+    return out;
+}

package/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/web-search.test.js

@@ -0,0 +1,114 @@
+/**
+ * Test module for web_search (Brave Search API only).
+ * Requires BRAVE_API_KEY or BRAVE_SEARCH_API_KEY in env or .env (free tier: https://brave.com/search/api).
+ * Run: npm run test:web-search
+ */
+import "dotenv/config";
+import { getBraveSearchApiKey } from "../config.js";
+import { webSearch } from "./web.js";
+const TESTS = [
+    {
+        name: "single search returns results",
+        query: "nodejs typescript",
+        expectError: false,
+        expectNonEmpty: true,
+    },
+    {
+        name: "empty query returns error",
+        query: "",
+        expectError: true,
+        expectNonEmpty: false,
+    },
+    {
+        name: "whitespace-only query returns error",
+        query: "   ",
+        expectError: true,
+        expectNonEmpty: false,
+    },
+    {
+        name: "specific query returns results",
+        query: "ideacode cli openrouter",
+        expectError: false,
+        expectNonEmpty: true,
+    },
+];
+async function runOne(name, query, expectError, expectNonEmpty) {
+    const out = await webSearch({ query });
+    const isError = out.startsWith("error:");
+    const isEmpty = !out.trim() || out === "No results found.";
+    if (expectError && !isError) {
+        return { ok: false, message: `expected error, got: ${out.slice(0, 80)}...` };
+    }
+    if (!expectError && isError) {
+        return { ok: false, message: `expected success, got: ${out.slice(0, 120)}` };
+    }
+    if (!expectError && expectNonEmpty && isEmpty) {
+        return { ok: false, message: `expected non-empty results, got: ${out.slice(0, 80)}` };
+    }
+    return { ok: true, message: isError ? out.slice(0, 60) : `got ${out.split("\n").length} lines` };
+}
+async function runRapidTwo() {
+    const q1 = await webSearch({ query: "ink react cli" });
+    const q2 = await webSearch({ query: "typescript strict" });
+    const e1 = q1.startsWith("error:");
+    const e2 = q2.startsWith("error:");
+    if (e1 && e2) {
+        return { ok: false, message: `both rapid searches failed: ${q1.slice(0, 50)}... / ${q2.slice(0, 50)}...` };
+    }
+    if (e1)
+        return { ok: false, message: `first search failed: ${q1.slice(0, 80)}` };
+    if (e2)
+        return { ok: false, message: `second search failed: ${q2.slice(0, 80)}` };
+    return { ok: true, message: "both rapid searches succeeded" };
+}
+async function main() {
+    if (!getBraveSearchApiKey()) {
+        console.log("web_search tests require BRAVE_API_KEY or BRAVE_SEARCH_API_KEY (free tier: https://brave.com/search/api).");
+        process.exit(1);
+    }
+    console.log("web_search tests (Brave Search API)\n");
+    let failed = 0;
+    for (const t of TESTS) {
+        process.stdout.write(`  ${t.name} ... `);
+        try {
+            const result = await runOne(t.name, t.query, t.expectError, t.expectNonEmpty);
+            if (result.ok) {
+                console.log("ok");
+            }
+            else {
+                console.log("FAIL");
+                console.log(`    ${result.message}`);
+                failed++;
+            }
+        }
+        catch (err) {
+            console.log("FAIL");
+            console.log(`    ${err instanceof Error ? err.message : String(err)}`);
+            failed++;
+        }
+    }
+    process.stdout.write("  two rapid searches ... ");
+    try {
+        const result = await runRapidTwo();
+        if (result.ok) {
+            console.log("ok");
+        }
+        else {
+            console.log("FAIL");
+            console.log(`    ${result.message}`);
+            failed++;
+        }
+    }
+    catch (err) {
+        console.log("FAIL");
+        console.log(`    ${err instanceof Error ? err.message : String(err)}`);
+        failed++;
+    }
+    console.log("");
+    if (failed > 0) {
+        console.log(`${failed} test(s) failed.`);
+        process.exit(1);
+    }
+    console.log("All web_search tests passed.");
+}
+main();

package/dist/tools/web.js

@@ -0,0 +1,147 @@
+import { getBraveSearchApiKey } from "../config.js";
+const MAX_FETCH_CHARS = 40_000;
+const FETCH_TIMEOUT_MS = 20_000;
+const MAX_SEARCH_RESULTS = 8;
+function formatSearchResults(hits) {
+    const slice = hits.slice(0, MAX_SEARCH_RESULTS);
+    return slice
+        .map((r, i) => `${i + 1}. ${(r.title ?? "Untitled").replace(/<[^>]+>/g, "")}\n   ${r.url ?? ""}${r.snippet ? "\n   " + String(r.snippet).replace(/<[^>]+>/g, "").slice(0, 300) : ""}`)
+        .join("\n\n");
+}
+const PLAYWRIGHT_INSTALL_MSG = "Playwright Chromium not installed. Run: npx playwright install chromium (in the project directory). web_fetch uses it only when plain fetch fails (e.g. JS-rendered pages).";
+function stripHtmlToText(html) {
+    let s = html
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "")
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, " ");
+    return s.replace(/\s+/g, " ").trim();
+}
+async function fetchWithTimeout(url) {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            signal: ac.signal,
+            headers: { "User-Agent": "ideacode-web-fetch/1" },
+        });
+        return res;
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+export async function webFetch(args) {
+    const url = args.url?.trim();
+    if (!url)
+        return "error: url is required";
+    if (!url.startsWith("http://") && !url.startsWith("https://"))
+        return "error: url must be http or https";
+    try {
+        const res = await fetchWithTimeout(url);
+        if (res.ok) {
+            const ct = (res.headers.get("content-type") ?? "").toLowerCase();
+            if (ct.includes("text/plain") ||
+                ct.includes("text/html") ||
+                ct.includes("application/json") ||
+                ct.includes("text/")) {
+                const raw = await res.text();
+                const text = ct.includes("text/html") && raw.includes("<")
+                    ? stripHtmlToText(raw)
+                    : raw.replace(/\s+/g, " ").trim();
+                if (text.length > MAX_FETCH_CHARS) {
+                    return (text.slice(0, MAX_FETCH_CHARS) +
+                        "\n\n... (truncated, total " +
+                        text.length +
+                        " chars)");
+                }
+                return text || "(no text content)";
+            }
+        }
+    }
+    catch {
+        // Fall through to Playwright for JS-rendered or when fetch fails
+    }
+    try {
+        const { chromium } = await import("playwright");
+        const browser = await chromium.launch({ headless: true });
+        try {
+            const page = await browser.newPage();
+            await page.goto(url, { waitUntil: "domcontentloaded", timeout: FETCH_TIMEOUT_MS });
+            const text = await page.evaluate(() => {
+                const body = document.body;
+                if (!body)
+                    return "";
+                const clone = body.cloneNode(true);
+                for (const el of clone.querySelectorAll("script, style, nav, header, footer, [role='navigation']")) {
+                    el.remove();
+                }
+                return (clone.innerText ?? clone.textContent ?? "").replace(/\s+/g, " ").trim();
+            });
+            if (text.length > MAX_FETCH_CHARS) {
+                return (text.slice(0, MAX_FETCH_CHARS) +
+                    "\n\n... (truncated, total " +
+                    text.length +
+                    " chars)");
+            }
+            return text || "(no text content)";
+        }
+        finally {
+            await browser.close().catch(() => { });
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const causeMsg = err instanceof Error && err.cause instanceof Error ? String(err.cause.message) : "";
+        const combined = (msg + " " + causeMsg).toLowerCase();
+        const needsPlaywright = combined.includes("executable doesn't exist") ||
+            combined.includes("browser was not found") ||
+            combined.includes("chromium revision is not downloaded") ||
+            (combined.includes("playwright") && (combined.includes("install") || combined.includes("not found")));
+        if (needsPlaywright) {
+            return `error: ${PLAYWRIGHT_INSTALL_MSG}`;
+        }
+        return `error: ${msg}`;
+    }
+}
+async function braveSearchApi(query, apiKey) {
+    const url = `https://api.search.brave.com/res/v1/web/search?${new URLSearchParams({
+        q: query,
+        count: String(MAX_SEARCH_RESULTS),
+        country: "us",
+        search_lang: "en",
+    })}`;
+    const res = await fetch(url, {
+        headers: { "X-Subscription-Token": apiKey, Accept: "application/json" },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        return `error: Brave Search API ${res.status}: ${text.slice(0, 200)}`;
+    }
+    const json = (await res.json());
+    if (json.message)
+        return `error: ${json.message}`;
+    const results = json.web?.results ?? [];
+    if (results.length === 0)
+        return "No results found.";
+    const hits = results.map((r) => ({
+        title: r.title ?? "Untitled",
+        url: r.url ?? "",
+        snippet: r.description,
+    }));
+    return formatSearchResults(hits);
+}
+export async function webSearch(args) {
+    const query = args.query?.trim();
+    if (!query)
+        return "error: query is required";
+    const apiKey = getBraveSearchApiKey();
+    if (!apiKey)
+        return "error: Brave Search API key not set. Use /brave or set BRAVE_API_KEY (https://brave.com/search/api).";
+    try {
+        return await braveSearchApi(query, apiKey);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `error: Brave Search API failed. ${msg}`;
+    }
+}

package/dist/ui/format.js

@@ -0,0 +1,65 @@
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import chalk from "chalk";
+import boxen from "boxen";
+import { colors, icons, theme, inkColors } from "./theme.js";
+const hrLine = () => {
+    const cols = process.stdout.columns ?? 80;
+    return colors.muted("─".repeat(Math.min(cols, 100)));
+};
+marked.use(markedTerminal({
+    code: chalk.hex(theme.syntax.code),
+    codespan: chalk.hex(theme.syntax.code),
+    blockquote: chalk.hex(theme.colors.muted.main).italic,
+    strong: chalk.bold,
+    em: chalk.italic,
+    heading: chalk.hex(theme.syntax.heading).bold,
+    firstHeading: chalk.hex(theme.colors.primary.dim).underline.bold,
+    link: chalk.hex(theme.syntax.link),
+    href: chalk.hex(theme.syntax.href).underline,
+    hr: () => hrLine(),
+}, { theme: { keyword: chalk.hex(theme.syntax.keyword), string: chalk.hex(theme.syntax.string) } }));
+const codeStyle = (s) => chalk.hex(theme.syntax.code)(s);
+export function renderMarkdown(text) {
+    let out = marked.parse(text, { async: false });
+    out = out.replace(/\`([^`]+)\`/g, (_, code) => codeStyle(code));
+    out = out.replace(/\*\*([^*]+)\*\*/g, (_, boldText) => chalk.bold(boldText));
+    out = out.replace(/(^|\n)\* /g, "$1• ");
+    out = out.replace(/(^|\n)([ \t]*[-*_]{3,}[ \t]*)(\n|$)/gm, (_, before, _rule, after) => before + hrLine() + after);
+    return out;
+}
+export function separator() {
+    const cols = process.stdout.columns ?? 80;
+    return colors.muted("─".repeat(Math.min(cols, 100)));
+}
+export function header(title, subtitle) {
+    return boxen(`${chalk.bold(title)}\n${colors.muted(subtitle)}`, {
+        padding: { top: 0, bottom: 0, left: 1, right: 1 },
+        margin: { bottom: 1 },
+        borderColor: inkColors.primary,
+        borderStyle: "round",
+    });
+}
+const TOOL_INDENT = "  ";
+const toolSubdued = chalk.hex("#3d3d3d");
+export function toolCallBox(toolName, argPreview, success = true) {
+    const diamondColor = success ? colors.toolSuccess : colors.toolFail;
+    const nameColor = success ? colors.toolSuccess : colors.toolFail;
+    const argColor = success ? toolSubdued : colors.toolFail;
+    const parenColor = chalk.white;
+    const name = " " + toolName.charAt(0).toUpperCase() + toolName.slice(1);
+    return `${TOOL_INDENT}${diamondColor(icons.tool)}${nameColor(name)}${parenColor("(")}${argColor(argPreview)}${parenColor(")")}`;
+}
+export function toolResultLine(preview, success = true) {
+    const pipeColor = success ? toolSubdued : colors.toolFail;
+    const textColor = success ? toolSubdued : colors.toolFail;
+    return `${TOOL_INDENT}${TOOL_INDENT}${pipeColor(icons.pipe + " ")}${textColor(preview)}`;
+}
+export function agentMessage(text) {
+    const rendered = renderMarkdown(text.trim());
+    return `${colors.accentPale(icons.agent)} ${rendered}`;
+}
+export function bashOutputLine(line) {
+    return `  ${colors.tool(icons.pipe + " ")}${colors.toolDim(line)}`;
+}
+export { colors, icons, theme, inkColors };

package/dist/ui/index.js

@@ -0,0 +1 @@
+export { colors, icons, theme, inkColors, separator, agentMessage, toolCallBox, toolResultLine, bashOutputLine, renderMarkdown, header, } from "./format.js";