ideacode 1.2.5 → 1.3.0

package/dist/repl.js

@@ -39,7 +39,15 @@ const MAX_TOOL_RESULT_CHARS = 3500;
 const MAX_AT_SUGGESTIONS = 12;
 const INITIAL_BANNER_LINES = 12;
 const ENABLE_PARALLEL_TOOL_CALLS = process.env.IDEACODE_PARALLEL_TOOL_CALLS !== "0";
-const PARALLEL_SAFE_TOOLS = new Set(["read", "glob", "grep", "web_fetch", "web_search"]);
+const PARALLEL_SAFE_TOOLS = new Set([
+    "read",
+    "glob",
+    "grep",
+    "web_fetch",
+    "web_search",
+    "bash_status",
+    "bash_logs",
+]);
 const LOADING_TICK_MS = 80;
 const MAX_EMPTY_ASSISTANT_RETRIES = 3;
 const TRUNCATE_NOTE = "\n\n(Output truncated to save context. Use read with offset/limit, grep with a specific pattern, or tail with fewer lines to get more.)";
@@ -150,7 +158,7 @@ function summarizeBashCommand(cmdRaw) {
     return (shown.join(", ") + suffix).slice(0, 140);
 }
 function toolArgPreview(toolName, toolArgs) {
-    if (toolName === "bash") {
+    if (toolName === "bash" || toolName === "bash_detach") {
         const cmd = String(toolArgs.cmd ?? "").trim();
         return cmd ? summarizeBashCommand(cmd) : "—";
     }
@@ -643,7 +651,7 @@ export function Repl({ apiKey, cwd, onQuit }) {
         appendLog(userPromptBox(userInput));
         appendLog("");
         let state = [...messages, { role: "user", content: userInput }];
-        const systemPrompt = `Concise coding assistant. cwd: ${cwd}. PRIORITIZE grep to locate; then read with offset and limit to fetch only relevant sections. Do not read whole files unless the user explicitly asks. Use focused greps (specific patterns, narrow paths) and read in chunks when files are large; avoid one huge grep or read that floods context. When exploring a dependency, set path to that package (e.g. node_modules/<pkg>) and list/read only what you need. Prefer grep or keyword search for the most recent or specific occurrence; avoid tail/read of thousands of lines. If a tool result says it was truncated, call the tool again with offset, limit, or a narrower pattern to get what you need. Use as many parallel read/search/web tool calls as needed in one turn when they are independent (often more than 3 is appropriate for broad research), but keep each call high-signal, non-redundant, and minimal in output size. For bash tool calls, avoid decorative echo headers; run direct commands and keep commands concise.`;
+        const systemPrompt = `Concise coding assistant. cwd: ${cwd}. PRIORITIZE grep to locate; then read with offset and limit to fetch only relevant sections. Do not read whole files unless the user explicitly asks. Use focused greps (specific patterns, narrow paths) and read in chunks when files are large; avoid one huge grep or read that floods context. When exploring a dependency, set path to that package (e.g. node_modules/<pkg>) and list/read only what you need. Prefer grep or keyword search for the most recent or specific occurrence; avoid tail/read of thousands of lines. If a tool result says it was truncated, call the tool again with offset, limit, or a narrower pattern to get what you need. Use as many parallel read/search/web tool calls as needed in one turn when they are independent (often more than 3 is appropriate for broad research), but keep each call high-signal, non-redundant, and minimal in output size. For bash tool calls, avoid decorative echo headers; run direct commands and keep commands concise. For long-running commands, prefer bash_detach then poll with bash_status and bash_logs instead of blocking bash.`;
         const modelContext = modelList.find((m) => m.id === currentModel)?.context_length;
         const maxContextTokens = Math.floor((modelContext ?? CONTEXT_WINDOW_K * 1024) * 0.85);
         const stateBeforeCompress = state;

package/dist/tools/bash.js

@@ -1,4 +1,73 @@
 import { spawn } from "node:child_process";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { closeSync, openSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MIN_TIMEOUT_MS = 1_000;
+const MAX_TIMEOUT_MS = 60 * 60 * 1000;
+const TERM_GRACE_MS = 2_000;
+const JOBS_DIR = path.join(tmpdir(), "ideacode-jobs");
+const JOBS_DB_PATH = path.join(JOBS_DIR, "jobs.json");
+function clampTimeoutMs(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_TIMEOUT_MS;
+    return Math.max(MIN_TIMEOUT_MS, Math.min(MAX_TIMEOUT_MS, Math.round(value)));
+}
+function resolveTimeoutMs(args) {
+    const fromArgs = Number(args.timeout_ms);
+    if (Number.isFinite(fromArgs) && fromArgs > 0)
+        return clampTimeoutMs(fromArgs);
+    const fromEnv = Number.parseInt(process.env.IDEACODE_BASH_TIMEOUT_MS ?? "", 10);
+    if (Number.isFinite(fromEnv) && fromEnv > 0)
+        return clampTimeoutMs(fromEnv);
+    return DEFAULT_TIMEOUT_MS;
+}
+function shSingleQuote(v) {
+    return `'${v.replace(/'/g, `'\\''`)}'`;
+}
+function makeJobId() {
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `job_${Date.now().toString(36)}_${rand}`;
+}
+async function ensureJobsDir() {
+    await mkdir(JOBS_DIR, { recursive: true });
+}
+async function loadJobs() {
+    try {
+        const raw = await readFile(JOBS_DB_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function saveJobs(db) {
+    await ensureJobsDir();
+    await writeFile(JOBS_DB_PATH, JSON.stringify(db, null, 2), "utf8");
+}
+function isPidRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readExitCode(statusPath) {
+    try {
+        const raw = await readFile(statusPath, "utf8");
+        const m = raw.match(/EXIT_CODE:(-?\d+)/);
+        if (!m)
+            return null;
+        return Number.parseInt(m[1] ?? "", 10);
+    }
+    catch {
+        return null;
+    }
+}
 export function runBash(args) {
     return new Promise((resolve) => {
         const cmd = args.cmd ?? "";
@@ -14,14 +83,97 @@ export function runBash(args) {
         const onData = (s) => outputChunks.push(s);
         proc.stdout?.on("data", (chunk) => onData(chunk.toString()));
         proc.stderr?.on("data", (chunk) => onData(chunk.toString()));
+        const timeoutMs = resolveTimeoutMs(args);
         const t = setTimeout(() => {
-            proc.kill("SIGKILL");
-            outputChunks.push("\n(timed out after 30s)");
-            done(outputChunks.join("").trim() || "(empty)");
-        }, 30_000);
+            proc.kill("SIGTERM");
+            outputChunks.push(`\n(timeout ${Math.round(timeoutMs / 1000)}s reached, sending SIGTERM…)`);
+            const killTimer = setTimeout(() => {
+                proc.kill("SIGKILL");
+                outputChunks.push("\n(process did not exit after SIGTERM; sent SIGKILL)");
+            }, TERM_GRACE_MS);
+            proc.on("close", () => clearTimeout(killTimer));
+        }, timeoutMs);
         proc.on("close", () => {
             clearTimeout(t);
             done(outputChunks.join("").trim() || "(empty)");
         });
     });
 }
+export async function runBashDetach(args) {
+    const cmd = String(args.cmd ?? "").trim();
+    if (!cmd)
+        return "error: missing cmd";
+    await ensureJobsDir();
+    const id = makeJobId();
+    const cwd = process.cwd();
+    const logPath = path.join(JOBS_DIR, `${id}.log`);
+    const statusPath = path.join(JOBS_DIR, `${id}.status`);
+    await appendFile(logPath, `# ideacode detached job ${id}\n# cwd: ${cwd}\n# cmd: ${cmd}\n\n`);
+    const wrapped = [
+        cmd,
+        "__ec=$?",
+        `printf "EXIT_CODE:%s\\n" "$__ec" > ${shSingleQuote(statusPath)}`,
+        "exit $__ec",
+    ].join("\n");
+    const logFd = openSync(logPath, "a");
+    const proc = spawn("/bin/sh", ["-lc", wrapped], {
+        cwd,
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+    });
+    closeSync(logFd);
+    proc.unref();
+    const db = await loadJobs();
+    db[id] = {
+        id,
+        cmd,
+        pid: proc.pid ?? -1,
+        cwd,
+        startedAt: new Date().toISOString(),
+        logPath,
+        statusPath,
+    };
+    await saveJobs(db);
+    return `ok: ${id} pid=${proc.pid ?? -1}\nlog=${logPath}\nuse bash_status(job_id=${id}) or bash_logs(job_id=${id})`;
+}
+export async function runBashStatus(args) {
+    const jobId = String(args.job_id ?? "").trim();
+    if (!jobId)
+        return "error: missing job_id";
+    const db = await loadJobs();
+    const job = db[jobId];
+    if (!job)
+        return `error: unknown job_id ${jobId}`;
+    const running = job.pid > 0 ? isPidRunning(job.pid) : false;
+    const exitCode = await readExitCode(job.statusPath);
+    const status = running ? "running" : exitCode == null ? "unknown (not running, no exit code)" : `finished (exit=${exitCode})`;
+    return [
+        `job_id: ${job.id}`,
+        `status: ${status}`,
+        `pid: ${job.pid}`,
+        `started_at: ${job.startedAt}`,
+        `cwd: ${job.cwd}`,
+        `log: ${job.logPath}`,
+    ].join("\n");
+}
+export async function runBashLogs(args) {
+    const jobId = String(args.job_id ?? "").trim();
+    if (!jobId)
+        return "error: missing job_id";
+    const tailLinesRaw = Number(args.tail_lines);
+    const tailLines = Number.isFinite(tailLinesRaw)
+        ? Math.max(1, Math.min(500, Math.round(tailLinesRaw)))
+        : 80;
+    const db = await loadJobs();
+    const job = db[jobId];
+    if (!job)
+        return `error: unknown job_id ${jobId}`;
+    try {
+        const content = await readFile(job.logPath, "utf8");
+        const lines = content.split(/\r?\n/);
+        return lines.slice(Math.max(0, lines.length - tailLines)).join("\n").trim() || "(empty)";
+    }
+    catch (err) {
+        return `error: failed to read logs for ${jobId}: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

package/dist/tools/index.js

@@ -1,7 +1,7 @@
 import { getBraveSearchApiKey } from "../config.js";
 import { readFile, writeFile, editFile } from "./file.js";
 import { globFiles, grepFiles } from "./search.js";
-import { runBash } from "./bash.js";
+import { runBash, runBashDetach, runBashLogs, runBashStatus } from "./bash.js";
 import { webFetch, webSearch } from "./web.js";
 export const TOOLS = {
     read: [
@@ -26,10 +26,25 @@ export const TOOLS = {
         grepFiles,
     ],
     bash: [
-        "Run shell command. Use for things the other tools don't cover (e.g. running tests, installs, one-off commands, ephemeral << PY scripts, etc.). Always avoid dump outputs. Prefer read/grep/glob for file content and search; use targeted commands and avoid dumping huge output.",
-        { cmd: "string" },
+        "Run shell command. Supports optional timeout_ms (default 30000). Use for things other tools don't cover. Prefer targeted commands and avoid huge outputs.",
+        { cmd: "string", timeout_ms: "number?" },
         runBash,
     ],
+    bash_detach: [
+        "Start a long-running shell command in the background and return a job_id for later polling.",
+        { cmd: "string" },
+        runBashDetach,
+    ],
+    bash_status: [
+        "Check status of a detached bash job.",
+        { job_id: "string" },
+        runBashStatus,
+    ],
+    bash_logs: [
+        "Read recent log lines from a detached bash job.",
+        { job_id: "string", tail_lines: "number?" },
+        runBashLogs,
+    ],
     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" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ideacode",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "CLI TUI for AI agents via OpenRouter — agentic loop, tools, markdown",
   "type": "module",
   "repository": {