ideacode 1.0.0

package/README.md

@@ -0,0 +1,63 @@
+# ideacode
+
+CLI TUI for interfacing with AI agents via OpenRouter. Agentic loop with tool use, conversation history, and markdown output.
+
+## Setup
+
+```bash
+npm install
+```
+
+`npm install` runs `playwright install chromium` automatically (for **web_fetch** on JS-rendered pages). If you skipped install scripts or see "Executable doesn't exist", run `npx playwright install chromium` once.
+
+## Usage
+
+```bash
+npm run run
+# or after build: npm run build && npm start
+```
+
+On first run, you'll be prompted for your OpenRouter API key. Get one at [openrouter.ai/keys](https://openrouter.ai/keys). You can optionally add a Brave Search API key for web search (get one at [brave.com/search/api](https://brave.com/search/api), free tier: 2,000 queries/month). Both are saved to:
+
+- **macOS/Linux:** `~/.config/ideacode/config.json`
+- **Windows:** `%LOCALAPPDATA%\ideacode\config.json`
+
+### Environment (optional)
+
+- `OPENROUTER_API_KEY` — API key (skips onboarding if set)
+- `MODEL` — Model ID (e.g. `anthropic/claude-sonnet-4`, `openai/gpt-4o`)
+- `BRAVE_API_KEY` or `BRAVE_SEARCH_API_KEY` — Brave Search API key (enables web_search tool)
+
+## Commands
+
+- **Ctrl+P** — Open command palette (switch model, set Brave key, etc.)
+- **Type `/`** — Inline command suggestions with descriptions (arrow keys to select, Enter to run)
+- `/` or `/palette` — Same as Ctrl+P (open command palette)
+- `/models` — Switch model (opens model selector)
+- `/brave` — Set Brave Search API key (enables web_search)
+- `/c` or `/clear` — Clear conversation
+- `/q` or `exit` — Quit
+
+## Tools
+
+`read`, `write`, `edit`, `glob`, `grep`, `bash`. Plus:
+
+- **web_fetch** — Fetch a URL and return main text. Tries plain `fetch()` first (works for raw GitHub, static HTML, APIs); falls back to Playwright for JS-rendered pages.
+- **web_search** — Search the web via [Brave Search API](https://brave.com/search/api). Only available when a Brave API key is set (onboarding or `/brave`). Without a key, the agent is not offered this tool.
+
+**web_fetch** uses Chromium for JS-rendered pages; it is installed automatically via postinstall. If you see "Executable doesn't exist", run `npx playwright install chromium` in the project directory.
+
+## Terminal UI
+
+The REPL uses **Ink** (React for the terminal) with a custom input: full-screen takeover, message log in a fixed viewport, hint row above input, slash/at suggestions above input. Run in an **interactive terminal** (real TTY); piping stdin or non-TTY may show "Raw mode is not supported".
+
+## Project structure
+
+- `src/index.tsx` — Entry: config/onboarding, then renders REPL
+- `src/Repl.tsx` — Main UI: input, log, suggestions, modals, API loop
+- `src/api.ts` — OpenRouter API (models, chat with tools)
+- `src/config.ts` — API key and model (env + `~/.config/ideacode/config.json`)
+- `src/commands.ts` — Slash commands and palette
+- `src/onboarding.ts` — First-run API key prompt
+- `src/tools/` — Agent tools (read, write, grep, bash, web_fetch, web_search, …)
+- `src/ui/` — Formatting and theme (markdown, colors, boxes)

package/dist/api.js

@@ -0,0 +1,54 @@
+import { config } from "./config.js";
+import { makeSchema } from "./tools/index.js";
+export async function fetchModels(apiKey) {
+    const res = await fetch(config.modelsUrl, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok)
+        throw new Error(`Failed to fetch models: ${res.status} ${await res.text()}`);
+    const json = (await res.json());
+    return json.data ?? [];
+}
+export async function callApi(apiKey, messages, systemPrompt, model) {
+    const body = {
+        model,
+        max_tokens: 8192,
+        system: systemPrompt,
+        messages,
+        tools: makeSchema(),
+    };
+    const res = await fetch(config.apiUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`API ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+const SUMMARIZE_SYSTEM = "You are a summarizer. Summarize the following conversation between user and assistant, including any tool use and results. Preserve the user's goal, key decisions, and important facts. Output only the summary, no preamble.";
+export async function callSummarize(apiKey, messages, model) {
+    const body = {
+        model,
+        max_tokens: 4096,
+        system: SUMMARIZE_SYSTEM,
+        messages,
+    };
+    const res = await fetch(config.apiUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`Summarize API ${res.status}: ${await res.text()}`);
+    const data = (await res.json());
+    const blocks = data.content ?? [];
+    const textBlock = blocks.find((b) => b.type === "text" && b.text);
+    return (textBlock?.text ?? "").trim();
+}

package/dist/commands.js

@@ -0,0 +1,43 @@
+/**
+ * Single source of truth for slash commands.
+ * Used by the REPL for slash suggestions, command palette, and processInput dispatch.
+ */
+export const COMMANDS = [
+    { cmd: "/models", desc: "Switch model", aliases: ["/model"] },
+    { cmd: "/brave", desc: "Set Brave Search API key", aliases: ["/brave-key"] },
+    { cmd: "/help", desc: "Show help", aliases: ["/?"] },
+    { cmd: "/palette", desc: "Command palette", aliases: ["/p"] },
+    { cmd: "/clear", desc: "Clear conversation", aliases: ["/c"] },
+    { cmd: "/status", desc: "Show session info" },
+    { cmd: "/q", desc: "Quit", aliases: ["/exit", "/quit", "exit"] },
+];
+const aliasToCanonical = new Map();
+for (const c of COMMANDS) {
+    aliasToCanonical.set(c.cmd.toLowerCase(), c.cmd);
+    for (const a of c.aliases ?? []) {
+        aliasToCanonical.set(a.toLowerCase().trim(), c.cmd);
+    }
+}
+export function resolveCommand(input) {
+    const key = input.trim().toLowerCase();
+    if (!key)
+        return null;
+    return aliasToCanonical.get(key) ?? null;
+}
+export function matchCommand(filter, c) {
+    const f = filter.toLowerCase().trim();
+    if (!f)
+        return true;
+    const search = [c.cmd, c.desc, ...(c.aliases ?? [])].join(" ").toLowerCase();
+    if (search.includes(f))
+        return true;
+    const compact = f.replace(/\s+/g, "");
+    if (!compact)
+        return true;
+    const cmdCompact = c.cmd.replace(/\s+/g, "");
+    const descCompact = c.desc.replace(/\s+/g, "");
+    const aliasCompact = (c.aliases ?? []).map((a) => a.replace(/\s+/g, ""));
+    return (cmdCompact.includes(compact) ||
+        descCompact.includes(compact) ||
+        aliasCompact.some((a) => a.includes(compact)));
+}

package/dist/config.js

@@ -0,0 +1,68 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME
+    ? path.join(process.env.XDG_CONFIG_HOME, "ideacode")
+    : process.platform === "win32"
+        ? path.join(process.env.LOCALAPPDATA ?? os.homedir(), "ideacode")
+        : path.join(os.homedir(), ".config", "ideacode");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function loadConfigFile() {
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfigFile(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+export function getApiKey() {
+    const fromEnv = process.env.OPENROUTER_API_KEY;
+    if (fromEnv?.trim())
+        return fromEnv.trim();
+    return loadConfigFile().apiKey;
+}
+export function getModel() {
+    const fromEnv = process.env.MODEL;
+    if (fromEnv?.trim())
+        return fromEnv.trim();
+    const fromFile = loadConfigFile().model;
+    if (fromFile?.trim())
+        return fromFile.trim();
+    return "anthropic/claude-sonnet-4";
+}
+export function getBraveSearchApiKey() {
+    const fromEnv = process.env.BRAVE_API_KEY?.trim() ?? process.env.BRAVE_SEARCH_API_KEY?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return loadConfigFile().braveSearchApiKey?.trim();
+}
+export function saveBraveSearchApiKey(key) {
+    const config = loadConfigFile();
+    config.braveSearchApiKey = key || undefined;
+    saveConfigFile(config);
+}
+export function saveApiKey(apiKey) {
+    const config = loadConfigFile();
+    config.apiKey = apiKey;
+    saveConfigFile(config);
+}
+export function saveModel(model) {
+    const config = loadConfigFile();
+    config.model = model;
+    saveConfigFile(config);
+}
+export const config = {
+    apiUrl: "https://openrouter.ai/api/v1/messages",
+    modelsUrl: "https://openrouter.ai/api/v1/models",
+    get apiKey() {
+        return getApiKey();
+    },
+    get model() {
+        return getModel();
+    },
+};

package/dist/context.js

@@ -0,0 +1,39 @@
+import { callSummarize } from "./api.js";
+export function estimateTokens(messages, systemPrompt) {
+    let chars = 0;
+    for (const m of messages) {
+        if (typeof m.content === "string")
+            chars += m.content.length;
+        else
+            chars += JSON.stringify(m.content).length;
+    }
+    if (systemPrompt)
+        chars += systemPrompt.length;
+    return Math.round(chars / 4);
+}
+export async function compressState(apiKey, state, systemPrompt, model, options) {
+    const { keepLast } = options;
+    if (state.length <= keepLast)
+        return state;
+    const toSummarize = state.slice(0, state.length - keepLast);
+    const recent = state.slice(-keepLast);
+    const summary = await callSummarize(apiKey, toSummarize, model);
+    const summaryMessage = {
+        role: "user",
+        content: `Previous context:\n${summary}`,
+    };
+    return [summaryMessage, ...recent];
+}
+export async function ensureUnderBudget(apiKey, state, systemPrompt, model, options) {
+    const { maxTokens, keepLast } = options;
+    if (estimateTokens(state, systemPrompt) <= maxTokens)
+        return state;
+    if (state.length <= keepLast) {
+        let trimmed = state;
+        while (trimmed.length > 1 && estimateTokens(trimmed, systemPrompt) > maxTokens) {
+            trimmed = trimmed.slice(1);
+        }
+        return trimmed;
+    }
+    return compressState(apiKey, state, systemPrompt, model, { keepLast });
+}

package/dist/index.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import "dotenv/config";
+import { render } from "ink";
+import { getApiKey } from "./config.js";
+import { runOnboarding } from "./onboarding.js";
+import { Repl } from "./Repl.js";
+async function main() {
+    let apiKey = getApiKey();
+    if (!apiKey) {
+        await runOnboarding();
+        apiKey = getApiKey();
+    }
+    if (!apiKey) {
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(Repl, { apiKey: apiKey, cwd: process.cwd(), onQuit: () => process.exit(0) }));
+    await waitUntilExit();
+}
+main();

package/dist/onboarding.js

@@ -0,0 +1,57 @@
+import * as readline from "node:readline";
+import ora from "ora";
+import { fetchModels } from "./api.js";
+import { saveApiKey, saveModel, saveBraveSearchApiKey } from "./config.js";
+import { colors } from "./ui/index.js";
+function question(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function runOnboarding() {
+    console.log(colors.accent("\n  OpenRouter API key required\n") +
+        colors.muted("  Get one at https://openrouter.ai/keys\n"));
+    for (;;) {
+        const apiKey = await question(colors.accent("  API key: "));
+        if (!apiKey) {
+            console.log(colors.error("  Key cannot be empty. Try again.\n"));
+            continue;
+        }
+        const spinner = ora({
+            text: colors.muted("  Validating..."),
+            color: "green",
+        }).start();
+        try {
+            const models = await fetchModels(apiKey);
+            spinner.stop();
+            saveApiKey(apiKey);
+            const defaultId = models.find((m) => m.id === "anthropic/claude-sonnet-4")?.id ??
+                models.find((m) => m.id.includes("claude-sonnet"))?.id ??
+                models.find((m) => m.id.includes("gpt-4o"))?.id ??
+                models[0]?.id ??
+                "anthropic/claude-sonnet-4";
+            console.log(colors.success("\n  ✓ API key saved") +
+                colors.muted(` (${models.length} models available)\n`));
+            console.log(colors.muted("  Default model: ") + colors.accent(defaultId) + "\n");
+            console.log(colors.muted("  In session: type / for commands, Ctrl+C or /q to quit.\n"));
+            const choice = await question(colors.muted("  Use this model? [Y/n] or enter model id: "));
+            const model = choice === "" || choice.toLowerCase() === "y" || choice.toLowerCase() === "yes"
+                ? defaultId
+                : choice || defaultId;
+            saveModel(model);
+            console.log(colors.muted("  Brave Search API key (optional, for web search). Get one at https://brave.com/search/api"));
+            const braveKey = await question(colors.muted("  Brave key (Enter to skip): "));
+            if (braveKey.trim())
+                saveBraveSearchApiKey(braveKey.trim());
+            return { apiKey, model };
+        }
+        catch (err) {
+            spinner.stop();
+            console.log(colors.error(`  Invalid key: ${err instanceof Error ? err.message : err}\n`));
+        }
+    }
+}