@wrongstack/tools 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,10 +1,12 @@
 import * as fs4 from 'fs/promises';
 import * as path from 'path';
-import { atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, stripAnsi } from '@wrongstack/core';
+import { dirname } from 'path';
 import { spawn } from 'child_process';
+import { atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, stripAnsi } from '@wrongstack/core';
 import * as os from 'os';
 import * as dns from 'dns/promises';
 import * as fsSync from 'fs';
+import { statSync } from 'fs';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -41,6 +43,83 @@ function isBinaryBuffer(buf) {
   }
   return false;
 }
+async function* spawnStream(opts) {
+  const max = opts.maxBytes ?? 2e5;
+  const flushAt = opts.flushBytes ?? 4 * 1024;
+  let stdout = "";
+  let stderr = "";
+  let pending = "";
+  let error;
+  const child = spawn(opts.cmd, opts.args, {
+    cwd: opts.cwd,
+    signal: opts.signal,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const queue = [];
+  let waiter;
+  const wake = () => {
+    if (waiter) {
+      const w = waiter;
+      waiter = void 0;
+      w();
+    }
+  };
+  child.stdout?.on("data", (c) => {
+    const s = c.toString();
+    if (stdout.length < max) stdout += s;
+    queue.push({ kind: "out", data: s });
+    wake();
+  });
+  child.stderr?.on("data", (c) => {
+    const s = c.toString();
+    if (stderr.length < max) stderr += s;
+    queue.push({ kind: "err", data: s });
+    wake();
+  });
+  child.on("error", (e) => {
+    error = e.message;
+    queue.push({ kind: "error", data: e.message });
+    wake();
+  });
+  child.on("close", (code) => {
+    queue.push({ kind: "close", data: "", code: code ?? 0 });
+    wake();
+  });
+  let exitCode = 0;
+  let spawnFailed = false;
+  for (; ; ) {
+    while (queue.length === 0) {
+      await new Promise((resolve2) => {
+        waiter = resolve2;
+      });
+    }
+    const chunk = queue.shift();
+    if (chunk.kind === "close") {
+      if (!spawnFailed) exitCode = chunk.code ?? 0;
+      break;
+    }
+    if (chunk.kind === "error") {
+      spawnFailed = true;
+      exitCode = 1;
+      continue;
+    }
+    pending += chunk.data;
+    if (pending.length >= flushAt) {
+      yield { type: "partial_output", text: pending };
+      pending = "";
+    }
+  }
+  if (pending.length > 0) {
+    yield { type: "partial_output", text: pending };
+  }
+  return {
+    stdout,
+    stderr,
+    exitCode,
+    truncated: stdout.length >= max || stderr.length >= max,
+    error
+  };
+}
 
 // src/read.ts
 var MAX_BYTES = 5 * 1024 * 1024;
@@ -347,7 +426,7 @@ async function resolveFiles(filesInput, ctx, extraGlob) {
   return resolved;
 }
 async function globFiles(pattern, base, extraGlob) {
-  const { spawn: spawn16 } = await import('child_process');
+  const { spawn: spawn11 } = await import('child_process');
   const rgAvailable = await checkRg();
   if (rgAvailable) {
     try {
@@ -511,6 +590,14 @@ var grepTool = {
     required: ["pattern"]
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of grepTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("grep: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     if (!input?.pattern) throw new Error("grep: pattern is required");
     const base = input.path ? safeResolve(input.path, ctx) : ctx.cwd;
     const mode = input.output_mode ?? "content";
@@ -518,11 +605,14 @@ var grepTool = {
     const rgAvailable = await detectRg(opts.signal);
     if (rgAvailable) {
       try {
-        return await runRg(input, base, mode, limit, opts.signal);
+        yield* runRgStream(input, base, mode, limit, opts.signal);
+        return;
       } catch {
       }
     }
-    return await runNative(input, base, mode, limit, opts.signal);
+    yield { type: "log", text: "Falling back to native grep\u2026" };
+    const out = await runNative(input, base, mode, limit, opts.signal);
+    yield { type: "final", output: out };
   }
 };
 async function detectRg(signal) {
@@ -536,35 +626,109 @@ async function detectRg(signal) {
     }
   });
 }
-function runRg(input, base, mode, limit, signal) {
-  return new Promise((resolve2, reject) => {
-    const args = ["--no-heading"];
-    if (input.case_insensitive) args.push("-i");
-    if (mode === "files_with_matches") args.push("-l");
-    if (mode === "count") args.push("-c");
-    if (mode === "content") {
-      args.push("-n");
-      if (input.context_lines) args.push("-C", String(input.context_lines));
-    }
-    if (input.glob) args.push("--glob", input.glob);
-    args.push("--", input.pattern, base);
-    const child = spawn("rg", args, { signal, stdio: ["ignore", "pipe", "pipe"] });
-    let buf = "";
-    child.stdout?.on("data", (chunk) => {
-      buf += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", () => {
-      const lines = buf.split("\n").filter(Boolean);
-      const sliced = lines.slice(0, limit);
-      resolve2({
-        matches: sliced,
-        count: lines.length,
-        truncated: lines.length > limit,
-        used: "rg"
-      });
-    });
+async function* runRgStream(input, base, mode, limit, signal) {
+  const args = ["--no-heading"];
+  if (input.case_insensitive) args.push("-i");
+  if (mode === "files_with_matches") args.push("-l");
+  if (mode === "count") args.push("-c");
+  if (mode === "content") {
+    args.push("-n");
+    if (input.context_lines) args.push("-C", String(input.context_lines));
+  }
+  if (input.glob) args.push("--glob", input.glob);
+  args.push("--", input.pattern, base);
+  const matches = [];
+  let buf = "";
+  let totalLines = 0;
+  let batchSinceFlush = 0;
+  const FLUSH_AT = 16;
+  const child = spawn("rg", args, { signal, stdio: ["ignore", "pipe", "pipe"] });
+  const queue = [];
+  let waiter;
+  const wake = () => {
+    if (waiter) {
+      const w = waiter;
+      waiter = void 0;
+      w();
+    }
+  };
+  child.stdout?.on("data", (c) => {
+    queue.push({ kind: "out", data: c.toString() });
+    wake();
   });
+  child.on("error", (e) => {
+    queue.push({ kind: "error", data: e.message });
+    wake();
+  });
+  child.on("close", () => {
+    queue.push({ kind: "close", data: "" });
+    wake();
+  });
+  let pendingBatch = [];
+  let errored = false;
+  for (; ; ) {
+    while (queue.length === 0) {
+      await new Promise((r) => {
+        waiter = r;
+      });
+    }
+    const c = queue.shift();
+    if (c.kind === "error") {
+      errored = true;
+      continue;
+    }
+    if (c.kind === "close") break;
+    buf += c.data;
+    const idx = buf.lastIndexOf("\n");
+    if (idx === -1) continue;
+    const ready = buf.slice(0, idx);
+    buf = buf.slice(idx + 1);
+    for (const line of ready.split("\n")) {
+      if (!line) continue;
+      totalLines++;
+      if (matches.length < limit) {
+        matches.push(line);
+        pendingBatch.push(line);
+        batchSinceFlush++;
+      }
+    }
+    if (batchSinceFlush >= FLUSH_AT) {
+      yield {
+        type: "partial_output",
+        text: pendingBatch.join("\n"),
+        data: { matches_so_far: matches.length }
+      };
+      pendingBatch = [];
+      batchSinceFlush = 0;
+    }
+  }
+  if (buf.trim()) {
+    for (const line of buf.split("\n")) {
+      if (!line) continue;
+      totalLines++;
+      if (matches.length < limit) {
+        matches.push(line);
+        pendingBatch.push(line);
+      }
+    }
+  }
+  if (pendingBatch.length > 0) {
+    yield {
+      type: "partial_output",
+      text: pendingBatch.join("\n"),
+      data: { matches_so_far: matches.length }
+    };
+  }
+  if (errored) throw new Error("rg: spawn error");
+  yield {
+    type: "final",
+    output: {
+      matches,
+      count: totalLines,
+      truncated: totalLines > limit,
+      used: "rg"
+    }
+  };
 }
 async function runNative(input, base, mode, limit, signal) {
   const flags = input.case_insensitive ? "i" : "";
@@ -635,6 +799,8 @@ async function runNative(input, base, mode, limit, signal) {
 }
 var MAX_OUTPUT = 32768;
 var DEFAULT_TIMEOUT = 3e4;
+var STREAM_FLUSH_INTERVAL_MS = 200;
+var STREAM_FLUSH_BYTES = 4 * 1024;
 var bashTool = {
   name: "bash",
   description: "Run a shell command. stdout and stderr are merged.",
@@ -643,6 +809,7 @@ var bashTool = {
   mutating: true,
   timeoutMs: 3e4,
   maxOutputBytes: MAX_OUTPUT,
+  estimatedDurationMs: 3e3,
   inputSchema: {
     type: "object",
     properties: {
@@ -653,6 +820,14 @@ var bashTool = {
     required: ["command"]
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of bashTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("bash: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     if (!input?.command) throw new Error("bash: command is required");
     const timeoutMs = Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT, 6e5);
     const isWin = os.platform() === "win32";
@@ -660,75 +835,127 @@ var bashTool = {
     const args = isWin ? ["/c", input.command] : ["-c", input.command];
     const env = { ...process.env };
     env["WRONGSTACK_SESSION_ID"] = ctx.session.id;
-    return new Promise((resolve2, reject) => {
-      let child;
-      try {
-        child = spawn(shell, args, {
-          cwd: ctx.projectRoot,
-          env,
-          stdio: input.background ? "ignore" : ["ignore", "pipe", "pipe"],
-          detached: input.background,
-          signal: opts.signal
-        });
-      } catch (err) {
-        return reject(err);
-      }
-      if (input.background) {
-        const pid = child.pid;
-        if (typeof pid === "number") child.unref();
-        return resolve2({
+    const child = spawn(shell, args, {
+      cwd: ctx.projectRoot,
+      env,
+      stdio: input.background ? "ignore" : ["ignore", "pipe", "pipe"],
+      detached: input.background,
+      signal: opts.signal
+    });
+    if (input.background) {
+      const pid = child.pid;
+      if (typeof pid === "number") child.unref();
+      yield {
+        type: "final",
+        output: {
           output: `[background] pid=${pid ?? "unknown"}`,
           exit_code: null,
           timed_out: false,
           pid
-        });
+        }
+      };
+      return;
+    }
+    let buf = "";
+    let pending = "";
+    let timedOut = false;
+    const timers = [];
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (isWin) {
+        try {
+          child.kill();
+        } catch {
+        }
+      } else {
+        try {
+          child.kill("SIGTERM");
+          const killTimer = setTimeout(() => {
+            try {
+              child.kill("SIGKILL");
+            } catch {
+            }
+          }, 2e3);
+          timers.push(killTimer);
+        } catch {
+        }
       }
-      let buf = "";
-      let timedOut = false;
-      const timers = [];
-      const timer = setTimeout(() => {
-        timedOut = true;
-        if (isWin) {
-          try {
-            child.kill();
-          } catch {
-          }
-        } else {
-          try {
-            child.kill("SIGTERM");
-            const killTimer = setTimeout(() => {
-              try {
-                child.kill("SIGKILL");
-              } catch {
-              }
-            }, 2e3);
-            timers.push(killTimer);
-          } catch {
+    }, timeoutMs);
+    timers.push(timer);
+    timer.unref?.();
+    const queue = [];
+    let resolveNext = null;
+    const push = (c) => {
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(c);
+      } else {
+        queue.push(c);
+      }
+    };
+    const next = () => new Promise((resolve2) => {
+      const c = queue.shift();
+      if (c) resolve2(c);
+      else resolveNext = resolve2;
+    });
+    let lastFlush = Date.now();
+    const flush = () => {
+      if (pending.length === 0) return null;
+      const text = pending;
+      pending = "";
+      lastFlush = Date.now();
+      return text;
+    };
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      buf += text;
+      pending += text;
+      push({ kind: "data", text });
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      buf += text;
+      pending += text;
+      push({ kind: "data", text });
+    });
+    child.on("error", (err) => {
+      for (const t of timers) clearTimeout(t);
+      push({ kind: "error", err });
+    });
+    child.on("close", (code) => {
+      for (const t of timers) clearTimeout(t);
+      push({ kind: "end", code });
+    });
+    try {
+      while (true) {
+        const c = await next();
+        if (c.kind === "error") throw c.err;
+        if (c.kind === "end") {
+          const remainder = flush();
+          if (remainder !== null) {
+            yield { type: "partial_output", text: remainder };
           }
+          const cleaned = stripAnsi(buf).replace(/\r\n?/g, "\n");
+          yield {
+            type: "final",
+            output: {
+              output: truncateMiddle(cleaned, MAX_OUTPUT),
+              exit_code: c.code,
+              timed_out: timedOut
+            }
+          };
+          return;
         }
-      }, timeoutMs);
-      timers.push(timer);
-      timer.unref?.();
-      child.stdout?.on("data", (chunk) => {
-        buf += chunk.toString();
-      });
-      child.stderr?.on("data", (chunk) => {
-        buf += chunk.toString();
-      });
-      child.on("error", (err) => {
-        for (const t of timers) clearTimeout(t);
-        reject(err);
-      });
-      child.on("close", (code) => {
-        for (const t of timers) clearTimeout(t);
-        const cleaned = stripAnsi(buf).replace(/\r\n?/g, "\n");
-        resolve2({
-          output: truncateMiddle(cleaned, MAX_OUTPUT),
-          exit_code: code,
-          timed_out: timedOut
-        });
-      });
-    });
+        const now = Date.now();
+        if (pending.length >= STREAM_FLUSH_BYTES || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
+          const text = flush();
+          if (text) yield { type: "partial_output", text };
+        }
+      }
+    } finally {
+      for (const t of timers) clearTimeout(t);
+    }
   }
 };
 var ALLOWED_COMMANDS = {
@@ -940,7 +1167,15 @@ var fetchTool = {
     },
     required: ["url"]
   },
-  async execute(input, _ctx, opts) {
+  async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of fetchTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("fetch: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, _ctx, opts) {
     if (!input?.url) throw new Error("fetch: url is required");
     const u = new URL(input.url);
     if (u.protocol !== "https:" && u.protocol !== "http:") {
@@ -950,6 +1185,7 @@ var fetchTool = {
       throw new Error("fetch: http:// blocked (HTTPS required by default)");
     }
     await assertNotPrivate(u.hostname);
+    yield { type: "log", text: `GET ${input.url}` };
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("fetch timeout")), TIMEOUT_MS2);
     const combined = combineSignals(opts.signal, ctrl.signal);
@@ -959,16 +1195,29 @@ var fetchTool = {
       if (/^image\/|^audio\/|^video\/|application\/octet-stream/.test(ct)) {
         throw new Error(`fetch: refusing to read binary content-type "${ct}"`);
       }
+      yield { type: "log", text: `HTTP ${res.status} ${ct}`, data: { status: res.status, contentType: ct } };
       const reader = res.body?.getReader();
       let received = 0;
       const chunks = [];
+      let pendingBytes = 0;
+      const FLUSH_AT = 4 * 1024;
       if (reader) {
         for (; ; ) {
           const { value, done } = await reader.read();
           if (done) break;
           if (!value) continue;
           received += value.byteLength;
+          pendingBytes += value.byteLength;
           chunks.push(value);
+          if (pendingBytes >= FLUSH_AT) {
+            const recent = Buffer.from(value).toString("utf8");
+            yield {
+              type: "partial_output",
+              text: recent,
+              data: { received }
+            };
+            pendingBytes = 0;
+          }
           if (received > MAX_BYTES2) break;
         }
       }
@@ -979,11 +1228,14 @@ var fetchTool = {
       else if (format === "markdown" && ct.includes("text/html")) content = htmlToMarkdown(text);
       else if (ct.includes("application/json")) content = prettyJson(text);
       else content = text;
-      return {
-        content: truncateMiddle(content, MAX_BYTES2),
-        status: res.status,
-        content_type: ct,
-        url: res.url
+      yield {
+        type: "final",
+        output: {
+          content: truncateMiddle(content, MAX_BYTES2),
+          status: res.status,
+          content_type: ct,
+          url: res.url
+        }
       };
     } finally {
       clearTimeout(timer);
@@ -1083,20 +1335,39 @@ var searchTool = {
     },
     required: ["query"]
   },
-  async execute(input, _ctx, opts) {
+  async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of searchTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("search: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, _ctx, opts) {
     if (!input?.query) throw new Error("search: query is required");
     const num = Math.max(1, Math.min(input.num_results ?? DEFAULT_NUM, MAX_RESULTS));
     const source = input.source ?? "duckduckgo";
+    yield { type: "log", text: `Querying ${source} for "${input.query}"\u2026`, data: { source, query: input.query } };
+    let output;
     switch (source) {
       case "duckduckgo":
-        return await duckduckgoSearch(input.query, num, opts.signal);
+        output = await duckduckgoSearch(input.query, num, opts.signal);
+        break;
       case "google":
-        return await googleSearch(input.query, num, opts.signal);
+        output = await googleSearch(input.query, num, opts.signal);
+        break;
       case "bing":
-        return await bingSearch(input.query, num, opts.signal);
+        output = await bingSearch(input.query, num, opts.signal);
+        break;
       default:
         throw new Error(`search: unknown source "${source}"`);
     }
+    yield {
+      type: "partial_output",
+      text: `${output.results.length} results from ${output.source}`,
+      data: { count: output.results.length }
+    };
+    yield { type: "final", output };
   }
 };
 async function duckduckgoSearch(query2, num, signal) {
@@ -1110,21 +1381,26 @@ async function duckduckgoSearch(query2, num, signal) {
     truncated: results.length >= num
   };
 }
+function takeFrom(iter, max) {
+  const out = [];
+  for (const item of iter) {
+    if (out.length >= max) break;
+    out.push(item);
+  }
+  return out;
+}
 function parseDuckDuckGo(html, num) {
   const results = [];
   const snippetRegex = /<a class="result-link"[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/gi;
   const snippet2Regex = /<a class="result-snippet"[^>]*>([^<]+)<\/a>/gi;
-  let match;
-  const linkMatches = [];
-  while ((match = snippetRegex.exec(html)) !== null && linkMatches.length < num) {
-    if (!match[1] || !match[2]) continue;
-    linkMatches.push({ url: match[1], title: stripTags2(match[2]) });
-  }
-  const snippetMatches = [];
-  while ((match = snippet2Regex.exec(html)) !== null && snippetMatches.length < num) {
-    if (!match[1]) continue;
-    snippetMatches.push(stripTags2(match[1]));
-  }
+  const linkMatches = takeFrom(
+    [...html.matchAll(snippetRegex)].filter((m) => m[1] && m[2]).map((m) => ({ url: m[1], title: stripTags2(m[2]) })),
+    num
+  );
+  const snippetMatches = takeFrom(
+    [...html.matchAll(snippet2Regex)].filter((m) => m[1]).map((m) => stripTags2(m[1])),
+    num
+  );
   for (let i = 0; i < linkMatches.length && i < num; i++) {
     const entry = linkMatches[i];
     results.push({
@@ -1152,23 +1428,18 @@ function parseGoogleResults(html, num) {
   const titleRegex = /<h3[^>]*class="[^"]*DKV84"[^>]*>([^<]+)<\/h3>/gi;
   const urlRegex = /<cite[^>]*>([^<]+)<\/cite>/gi;
   const snippetRegex = /<span[^>]*class="[^"]*aXCZ0b[^>]*>([^<]+)<\/span>/gi;
-  const titles = [];
-  let m;
-  while ((m = titleRegex.exec(html)) !== null && titles.length < num) {
-    if (!m[1]) continue;
-    titles.push(stripTags2(m[1]));
-  }
-  const urls = [];
-  while ((m = urlRegex.exec(html)) !== null && urls.length < num) {
-    if (!m[1]) continue;
-    const url = stripTags2(m[1]).replace(/^\*(https?:\/\/[^\s]+).*$/, "$1");
-    if (url.startsWith("http")) urls.push(url);
-  }
-  const snippets = [];
-  while ((m = snippetRegex.exec(html)) !== null && snippets.length < num) {
-    if (!m[1]) continue;
-    snippets.push(stripTags2(m[1]));
-  }
+  const titles = takeFrom(
+    [...html.matchAll(titleRegex)].filter((m) => m[1]).map((m) => stripTags2(m[1])),
+    num
+  );
+  const urls = takeFrom(
+    [...html.matchAll(urlRegex)].filter((m) => m[1]).map((m) => stripTags2(m[1]).replace(/^\*(https?:\/\/[^\s]+).*$/, "$1")).filter((u) => u.startsWith("http")),
+    num
+  );
+  const snippets = takeFrom(
+    [...html.matchAll(snippetRegex)].filter((m) => m[1]).map((m) => stripTags2(m[1])),
+    num
+  );
   for (let i = 0; i < Math.min(titles.length, num); i++) {
     results.push({
       title: titles[i] ?? "",
@@ -1194,17 +1465,14 @@ function parseBingResults(html, num) {
   const results = [];
   const titleRegex = /<h2[^>]*>\s*<a[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>\s*<\/h2>/gi;
   const snippetRegex = /<p[^>]*class="[^"]*b_paractl[^"]*"[^>]*>([^<]+)<\/p>/gi;
-  const entries = [];
-  let m;
-  while ((m = titleRegex.exec(html)) !== null && entries.length < num) {
-    if (!m[1] || !m[2]) continue;
-    entries.push({ url: m[1], title: stripTags2(m[2]) });
-  }
-  const snippets = [];
-  while ((m = snippetRegex.exec(html)) !== null && snippets.length < num) {
-    if (!m[1]) continue;
-    snippets.push(stripTags2(m[1]));
-  }
+  const entries = takeFrom(
+    [...html.matchAll(titleRegex)].filter((m) => m[1] && m[2]).map((m) => ({ url: m[1], title: stripTags2(m[2]) })),
+    num
+  );
+  const snippets = takeFrom(
+    [...html.matchAll(snippetRegex)].filter((m) => m[1]).map((m) => stripTags2(m[1])),
+    num
+  );
   for (let i = 0; i < entries.length; i++) {
     results.push({
       title: entries[i]?.title ?? "",
@@ -1365,11 +1633,11 @@ function findGitDir(cwd) {
   let dir = cwd;
   for (let i = 0; i < 20; i++) {
     try {
-      const stat9 = __require("fs").statSync(`${dir}/.git`);
+      const stat9 = statSync(`${dir}/.git`);
       if (stat9.isDirectory()) return dir;
     } catch {
     }
-    const parent = __require("path").dirname(dir);
+    const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1531,8 +1799,7 @@ function runPatch(args, cwd, signal) {
 function extractPatchedFiles(output) {
   const files = [];
   const re = /patching file (.+)/gi;
-  let m;
-  while ((m = re.exec(output)) !== null) {
+  for (const m of output.matchAll(re)) {
     if (m[1]) files.push(m[1]);
   }
   return files;
@@ -1803,7 +2070,15 @@ var treeTool = {
       }
     }
   },
-  async execute(input, ctx) {
+  async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of treeTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("tree: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx) {
     const basePath = input.path ? safeResolve(input.path, ctx) : ctx.cwd;
     const maxDepth = input.depth ?? 3;
     const showFiles = input.show_files ?? true;
@@ -1812,9 +2087,22 @@ var treeTool = {
     const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE4, ...input.exclude ?? []]);
     const filterGlob = input.glob;
     const lines = [basePath];
-    let totalFiles = 0;
-    let totalDirs = 0;
-    await walkDir(basePath, "", 0, {
+    const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
+    const queue = [];
+    const FLUSH_EVERY = 200;
+    let lastEmittedTotal = 0;
+    const tickProgress = () => {
+      const seen = totals.totalFiles.value + totals.totalDirs.value;
+      if (seen - lastEmittedTotal >= FLUSH_EVERY) {
+        queue.push({
+          type: "metric",
+          text: `${seen} entries`,
+          data: { files: totals.totalFiles.value, dirs: totals.totalDirs.value }
+        });
+        lastEmittedTotal = seen;
+      }
+    };
+    const walkPromise = walkDir(basePath, 0, {
       maxDepth,
       exclude,
       showFiles,
@@ -1824,19 +2112,38 @@ var treeTool = {
       lines,
       prefix: "",
       isLast: true,
-      totalFiles: { value: 0 },
-      totalDirs: { value: 0 }
+      totalFiles: totals.totalFiles,
+      totalDirs: totals.totalDirs,
+      onProgress: tickProgress
     });
-    return {
-      tree: lines.join("\n"),
-      total_files: totalFiles,
-      total_dirs: totalDirs,
-      truncated: false,
-      path: basePath
+    let walkDone = false;
+    walkPromise.finally(() => {
+      walkDone = true;
+    });
+    while (!walkDone || queue.length > 0) {
+      if (queue.length > 0) {
+        yield queue.shift();
+      } else {
+        await Promise.race([
+          walkPromise,
+          new Promise((r) => setTimeout(r, 50))
+        ]).catch(() => void 0);
+      }
+    }
+    await walkPromise;
+    yield {
+      type: "final",
+      output: {
+        tree: lines.join("\n"),
+        total_files: totals.totalFiles.value,
+        total_dirs: totals.totalDirs.value,
+        truncated: false,
+        path: basePath
+      }
     };
   }
 };
-async function walkDir(dir, name, depth, opts) {
+async function walkDir(dir, depth, opts) {
   const entries = await fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
@@ -1848,6 +2155,7 @@ async function walkDir(dir, name, depth, opts) {
     const fileCount = filtered.filter((e) => e.isFile()).length;
     opts.totalDirs.value += dirCount;
     opts.totalFiles.value += fileCount;
+    opts.onProgress?.();
   }
   const items = filtered.sort((a, b) => {
     if (a.isDirectory() && !b.isDirectory()) return -1;
@@ -1866,7 +2174,7 @@ async function walkDir(dir, name, depth, opts) {
     opts.lines.push(opts.prefix + branch + displayName);
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
-      await walkDir(path.join(dir, entry.name), entry.name, depth + 1, {
+      await walkDir(path.join(dir, entry.name), depth + 1, {
         ...opts,
         prefix: childPrefix,
         isLast
@@ -1874,6 +2182,8 @@ async function walkDir(dir, name, depth, opts) {
     }
   }
 }
+
+// src/lint.ts
 var lintTool = {
   name: "lint",
   description: "Run a linter on files. Auto-detects biome, eslint, or tslint. Use `fix` to auto-fix issues.",
@@ -1898,25 +2208,59 @@ var lintTool = {
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of lintTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("lint: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
     const linter = input.linter ?? "auto";
     const detected = linter === "auto" ? await detectLinter(cwd) : linter;
     if (!detected) {
-      return {
-        linter: "none",
-        files_checked: 0,
-        errors: 0,
-        warnings: 0,
-        output: "No linter found (biome.json, .eslintrc, tslint.json)",
-        fix_applied: false,
-        truncated: false
+      yield {
+        type: "final",
+        output: {
+          linter: "none",
+          files_checked: 0,
+          errors: 0,
+          warnings: 0,
+          output: "No linter found (biome.json, .eslintrc, tslint.json)",
+          fix_applied: false,
+          truncated: false
+        }
       };
+      return;
     }
-    return await runLinter(detected, input, cwd, opts.signal);
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { linter: detected } };
+    const args = ["lint"];
+    if (input.fix) args.push("--write");
+    if (input.files) {
+      const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+      args.push("--", ...files.map((f) => f.trim()));
+    }
+    const cmd = detected === "biome" ? "biome" : detected;
+    const result = yield* spawnStream({ cmd, args, cwd, signal: opts.signal, maxBytes: 1e5 });
+    const errors = (result.stdout.match(/error/g) || []).length;
+    const warnings = (result.stdout.match(/warning/g) || []).length;
+    yield {
+      type: "final",
+      output: {
+        linter: detected,
+        files_checked: input.files ? Array.isArray(input.files) ? input.files.length : input.files.split(",").length : 0,
+        errors,
+        warnings,
+        output: result.stdout,
+        fix_applied: input.fix ?? false,
+        truncated: result.truncated
+      }
+    };
   }
 };
 async function detectLinter(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   const checks = ["biome.json", ".eslintrc.json", "tslint.json", ".eslintrc.js", "tsconfig.json"];
   for (const f of checks) {
     try {
@@ -1929,42 +2273,8 @@ async function detectLinter(cwd) {
   }
   return "biome";
 }
-async function runLinter(linter, input, cwd, signal) {
-  const args = ["lint"];
-  if (input.fix) args.push("--write");
-  if (input.files) {
-    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
-    args.push("--", ...files.map((f) => f.trim()));
-  }
-  const result = await runCommand2(linter === "biome" ? "biome" : linter, args, cwd, signal);
-  const errors = (result.stdout.match(/error/g) || []).length;
-  const warnings = (result.stdout.match(/warning/g) || []).length;
-  return {
-    linter,
-    files_checked: input.files ? Array.isArray(input.files) ? input.files.length : input.files.split(",").length : 0,
-    errors,
-    warnings,
-    output: result.stdout,
-    fix_applied: input.fix ?? false,
-    truncated: result.truncated
-  };
-}
-function runCommand2(cmd, args, cwd, signal) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 1e5;
-    const child = spawn(cmd, args, { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? 0, truncated: stdout.length >= MAX }));
-    child.on("error", (e) => resolve2({ stdout: "", stderr: e.message, exitCode: 1, truncated: false }));
-  });
-}
+
+// src/format.ts
 var formatTool = {
   name: "format",
   description: "Format files with biome or prettier. Use `check` to verify without modifying.",
@@ -1992,23 +2302,59 @@ var formatTool = {
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of formatTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("format: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
     const fixer = input.fixer ?? "auto";
     const detected = fixer === "auto" ? await detectFixer(cwd) : fixer;
     if (!detected) {
-      return {
-        fixer: "none",
-        files_checked: 0,
-        files_changed: 0,
-        output: "No formatter found (biome.json, .prettierrc)",
-        truncated: false
+      yield {
+        type: "final",
+        output: {
+          fixer: "none",
+          files_checked: 0,
+          files_changed: 0,
+          output: "No formatter found (biome.json, .prettierrc)",
+          truncated: false
+        }
       };
+      return;
+    }
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { fixer: detected, check: !!input.check } };
+    const args = ["format", "--write"];
+    if (input.check) args[args.length - 1] = "--check";
+    if (input.files) {
+      const files = Array.isArray(input.files) ? input.files : input.files.split(",");
+      args.push("--", ...files.map((f) => f.trim()));
     }
-    return await runFormatter(detected, input, cwd, opts.signal);
+    const result = yield* spawnStream({
+      cmd: detected,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 1e5
+    });
+    const changed = (result.stdout.match(/changed/g) || []).length;
+    yield {
+      type: "final",
+      output: {
+        fixer: detected,
+        files_checked: 0,
+        files_changed: changed,
+        output: result.stdout || result.stderr || result.error || "",
+        truncated: result.truncated
+      }
+    };
   }
 };
 async function detectFixer(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   try {
     await stat9(`${cwd}/biome.json`);
     return "biome";
@@ -2021,46 +2367,6 @@ async function detectFixer(cwd) {
     }
   }
 }
-async function runFormatter(fixer, input, cwd, signal) {
-  const args = ["format", "--write"];
-  if (input.check) args[args.length - 1] = "--check";
-  if (input.files) {
-    const files = Array.isArray(input.files) ? input.files : input.files.split(",");
-    args.push("--", ...files.map((f) => f.trim()));
-  }
-  return runCommand3(fixer, args, cwd, signal);
-}
-function runCommand3(cmd, args, cwd, signal) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 1e5;
-    const child = spawn(cmd, args, { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => {
-      const changed = (stdout.match(/changed/g) || []).length;
-      resolve2({
-        fixer: cmd,
-        files_checked: 0,
-        files_changed: changed,
-        output: stdout || stderr,
-        truncated: stdout.length >= MAX
-      });
-    });
-    child.on("error", (e) => resolve2({
-      fixer: cmd,
-      files_checked: 0,
-      files_changed: 0,
-      output: e.message,
-      truncated: false
-    }));
-  });
-}
 var typecheckTool = {
   name: "typecheck",
   description: "Run TypeScript type checking with `tsc --noEmit`. Checks for type errors without compiling.",
@@ -2084,19 +2390,52 @@ var typecheckTool = {
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of typecheckTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("typecheck: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
+    let args;
+    let project;
     if (input.all) {
-      return runTsc(["--noEmit"], cwd, opts.signal, "workspace");
-    }
-    const tsconfig = input.project ? safeResolve(input.project, ctx) : await findTsConfig(cwd);
-    const args = ["--noEmit"];
-    if (input.strict) args.push("--strict");
-    if (tsconfig) args.push("--project", tsconfig);
-    return runTsc(args, cwd, opts.signal, tsconfig ?? "default");
+      args = ["--noEmit"];
+      project = "workspace";
+    } else {
+      const tsconfig = input.project ? safeResolve(input.project, ctx) : await findTsConfig(cwd);
+      args = ["--noEmit"];
+      if (input.strict) args.push("--strict");
+      if (tsconfig) args.push("--project", tsconfig);
+      project = tsconfig ?? "default";
+    }
+    yield { type: "log", text: `tsc ${args.join(" ")}`, data: { project } };
+    const result = yield* spawnStream({
+      cmd: "npx",
+      args: ["tsc", ...args],
+      cwd,
+      signal: opts.signal,
+      maxBytes: 2e5
+    });
+    const errors = (result.stdout.match(/error TS/g) || []).length;
+    const warnings = (result.stdout.match(/warning/g) || []).length;
+    yield {
+      type: "final",
+      output: {
+        project,
+        exit_code: result.exitCode,
+        errors,
+        warnings,
+        output: result.stdout || result.stderr || result.error || "",
+        truncated: result.truncated
+      }
+    };
   }
 };
 async function findTsConfig(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
@@ -2107,39 +2446,6 @@ async function findTsConfig(cwd) {
   }
   return null;
 }
-function runTsc(args, cwd, signal, project) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 2e5;
-    const child = spawn("npx", ["tsc", ...args], { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => {
-      const errors = (stdout.match(/error TS/g) || []).length;
-      resolve2({
-        project,
-        exit_code: code ?? 0,
-        errors,
-        warnings: (stdout.match(/warning/g) || []).length,
-        output: stdout || stderr,
-        truncated: stdout.length >= MAX
-      });
-    });
-    child.on("error", (e) => resolve2({
-      project,
-      exit_code: 1,
-      errors: 0,
-      warnings: 0,
-      output: e.message,
-      truncated: false
-    }));
-  });
-}
 var testTool = {
   name: "test",
   description: "Run tests with vitest, jest, or mocha. Returns pass/fail counts and output.",
@@ -2159,46 +2465,57 @@ var testTool = {
         enum: ["vitest", "jest", "mocha", "auto"],
         description: "Test runner (default: auto-detect)"
       },
-      watch: {
-        type: "boolean",
-        description: "Run in watch mode (default: false)"
-      },
-      coverage: {
-        type: "boolean",
-        description: "Generate coverage report (default: false)"
-      },
+      watch: { type: "boolean", description: "Run in watch mode (default: false)" },
+      coverage: { type: "boolean", description: "Generate coverage report (default: false)" },
       cwd: { type: "string", description: "Working directory (default: cwd)" },
-      grep: {
-        type: "string",
-        description: "Filter tests by name pattern (default: none)"
-      },
-      timeout: {
-        type: "integer",
-        description: "Test timeout in ms (default: 30000)"
-      }
+      grep: { type: "string", description: "Filter tests by name pattern (default: none)" },
+      timeout: { type: "integer", description: "Test timeout in ms (default: 30000)" }
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of testTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("test: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
     const runner = input.runner ?? "auto";
     const detected = runner === "auto" ? await detectRunner(cwd) : runner;
     if (!detected) {
-      return {
-        runner: "none",
-        exit_code: 1,
-        tests_run: 0,
-        passed: 0,
-        failed: 0,
-        duration_ms: 0,
-        output: "No test runner found (vitest.config.ts, jest.config.js, .mocharc.json)",
-        truncated: false
+      yield {
+        type: "final",
+        output: {
+          runner: "none",
+          exit_code: 1,
+          tests_run: 0,
+          passed: 0,
+          failed: 0,
+          duration_ms: 0,
+          output: "No test runner found (vitest.config.ts, jest.config.js, .mocharc.json)",
+          truncated: false
+        }
       };
+      return;
     }
-    return await runTests(detected, input, cwd, opts.signal);
+    yield { type: "log", text: `Running ${detected}\u2026`, data: { runner: detected } };
+    const start = Date.now();
+    const args = buildArgs2(detected, input);
+    const result = yield* spawnStream({
+      cmd: detected,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 2e5
+    });
+    const duration = Date.now() - start;
+    yield { type: "final", output: parseResult(detected, result, duration) };
   }
 };
 async function detectRunner(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
@@ -2211,13 +2528,6 @@ async function detectRunner(cwd) {
   }
   return "vitest";
 }
-async function runTests(runner, input, cwd, signal) {
-  const start = Date.now();
-  const args = buildArgs2(runner, input);
-  const result = await runCommand4(runner, args, cwd, signal);
-  const duration = Date.now() - start;
-  return parseResult(runner, result, duration);
-}
 function buildArgs2(runner, input) {
   const args = [];
   const timeout = input.timeout ?? 3e4;
@@ -2251,22 +2561,6 @@ function buildArgs2(runner, input) {
   }
   return args;
 }
-function runCommand4(cmd, args, cwd, signal) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 2e5;
-    const child = spawn(cmd, args, { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => resolve2({ stdout, stderr, exitCode: code ?? 0, truncated: stdout.length >= MAX }));
-    child.on("error", (e) => resolve2({ stdout: "", stderr: e.message, exitCode: 1, truncated: false }));
-  });
-}
 function parseResult(runner, result, duration) {
   const out = result.stdout + result.stderr;
   let tests_run = 0;
@@ -2275,16 +2569,16 @@ function parseResult(runner, result, duration) {
   if (runner === "vitest") {
     const passedMatch = out.match(/(\d+) passed/);
     const failedMatch = out.match(/(\d+) failed/);
-    if (passedMatch?.[1]) passed = parseInt(passedMatch[1], 10);
-    if (failedMatch?.[1]) failed = parseInt(failedMatch[1], 10);
+    if (passedMatch?.[1]) passed = Number.parseInt(passedMatch[1], 10);
+    if (failedMatch?.[1]) failed = Number.parseInt(failedMatch[1], 10);
     tests_run = passed + failed;
   } else if (runner === "jest") {
     const suitesMatch = out.match(/Test Suites:\s+(\d+)\s+total/);
     const passedMatch = out.match(/Tests:\s+(\d+)\s+passed/);
     const failedMatch = out.match(/Tests:\s+(\d+)\s+failed/);
-    tests_run = parseInt(suitesMatch?.[1] ?? "0", 10);
-    passed = parseInt(passedMatch?.[1] ?? "0", 10);
-    failed = parseInt(failedMatch?.[1] ?? "0", 10);
+    tests_run = Number.parseInt(suitesMatch?.[1] ?? "0", 10);
+    passed = Number.parseInt(passedMatch?.[1] ?? "0", 10);
+    failed = Number.parseInt(failedMatch?.[1] ?? "0", 10);
   }
   return {
     runner,
@@ -2293,10 +2587,12 @@ function parseResult(runner, result, duration) {
     passed,
     failed,
     duration_ms: duration,
-    output: result.stdout,
+    output: result.stdout || result.error || "",
     truncated: result.truncated
   };
 }
+
+// src/install.ts
 var installTool = {
   name: "install",
   description: "Install npm packages. Detects pnpm/npm/yarn and uses the right package manager.",
@@ -2322,8 +2618,17 @@ var installTool = {
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of installTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("install: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
     const pkgManager = await detectPackageManager(cwd);
+    yield { type: "log", text: `Resolving with ${pkgManager}\u2026`, data: { phase: "resolve" } };
     const save = input.save === "dev" ? "-D" : input.save === "optional" ? "-O" : "";
     const globalFlag = input.global ? ["-g"] : [];
     const args = [];
@@ -2336,15 +2641,30 @@ var installTool = {
     } else {
       args.push("install", ...globalFlag);
     }
-    if (input.packages) {
-      const pkgs = Array.isArray(input.packages) ? input.packages : input.packages.split(",");
-      args.push(...pkgs.map((p) => p.trim()));
-    }
-    return runInstall(pkgManager, args, cwd, opts.signal, input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).map((p) => p.trim()) : []);
+    const pkgList = input.packages ? (Array.isArray(input.packages) ? input.packages : input.packages.split(",")).map((p) => p.trim()) : [];
+    if (pkgList.length > 0) args.push(...pkgList);
+    yield { type: "log", text: `Fetching ${pkgList.length || "all"} packages\u2026`, data: { phase: "fetch" } };
+    const result = yield* spawnStream({
+      cmd: pkgManager,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 1e5
+    });
+    yield {
+      type: "final",
+      output: {
+        packages: pkgList,
+        exit_code: result.exitCode,
+        output: result.stdout || result.stderr || result.error || "",
+        dry_run: args.includes("--dry-run"),
+        truncated: result.truncated
+      }
+    };
   }
 };
 async function detectPackageManager(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   try {
     await stat9(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
@@ -2357,34 +2677,8 @@ async function detectPackageManager(cwd) {
     }
   }
 }
-function runInstall(manager, args, cwd, signal, packages) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 1e5;
-    const child = spawn(manager, args, { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => resolve2({
-      packages,
-      exit_code: code ?? 0,
-      output: stdout || stderr,
-      dry_run: args.includes("--dry-run"),
-      truncated: stdout.length >= MAX
-    }));
-    child.on("error", (e) => resolve2({
-      packages,
-      exit_code: 1,
-      output: e.message,
-      dry_run: false,
-      truncated: false
-    }));
-  });
-}
+
+// src/audit.ts
 var auditTool = {
   name: "audit",
   description: "Run npm/pnpm security audit. Returns vulnerabilities sorted by severity.",
@@ -2401,30 +2695,40 @@ var auditTool = {
         enum: ["low", "moderate", "high", "critical"],
         description: "Minimum severity level to report"
       },
-      fix: {
-        type: "boolean",
-        description: "Attempt to fix vulnerabilities (default: false)"
-      },
-      packages: {
-        type: "string",
-        description: "Specific package(s) to audit (comma-separated)"
-      }
+      fix: { type: "boolean", description: "Attempt to fix vulnerabilities (default: false)" },
+      packages: { type: "string", description: "Specific package(s) to audit (comma-separated)" }
     }
   },
   async execute(input, ctx, opts) {
+    let final;
+    for await (const ev of auditTool.executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("audit: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
     const cwd = input.cwd ? safeResolve(input.cwd, ctx) : ctx.cwd;
     const manager = await detectManager(cwd);
+    yield { type: "log", text: `Auditing with ${manager}\u2026`, data: { manager } };
     const args = ["audit", "--json"];
     if (input.fix) args.push("--fix");
     if (input.packages) {
       const pkgs = Array.isArray(input.packages) ? input.packages : input.packages.split(",");
       args.push(...pkgs.map((p) => p.trim()));
     }
-    return runAudit(manager, args, cwd, opts.signal);
+    const result = yield* spawnStream({
+      cmd: manager,
+      args,
+      cwd,
+      signal: opts.signal,
+      maxBytes: 1e5
+    });
+    yield { type: "final", output: parseAuditOutput(result.stdout, result.exitCode) };
   }
 };
 async function detectManager(cwd) {
-  const { stat: stat9 } = __require("fs/promises");
+  const { stat: stat9 } = await import('fs/promises');
   try {
     await stat9(`${cwd}/pnpm-lock.yaml`);
     return "pnpm";
@@ -2437,32 +2741,6 @@ async function detectManager(cwd) {
   }
   return "npm";
 }
-function runAudit(manager, args, cwd, signal) {
-  return new Promise((resolve2) => {
-    let stdout = "";
-    let stderr = "";
-    const MAX = 1e5;
-    const child = spawn(manager, args, { cwd, signal, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout?.on("data", (c) => {
-      if (stdout.length < MAX) stdout += c.toString();
-    });
-    child.stderr?.on("data", (c) => {
-      if (stderr.length < MAX) stderr += c.toString();
-    });
-    child.on("close", (code) => {
-      const result = parseAuditOutput(stdout, code ?? 0);
-      resolve2(result);
-    });
-    child.on("error", (e) => resolve2({
-      exit_code: 1,
-      vulnerabilities: [],
-      total: 0,
-      summary: e.message,
-      output: e.message,
-      truncated: false
-    }));
-  });
-}
 function parseAuditOutput(json, exitCode) {
   if (!json) {
     return {
@@ -2717,7 +2995,7 @@ async function fileLogs(path10, lines, filterRe, stream) {
   const allLines = [];
   const rl = createInterface({
     input: createReadStream(path10),
-    crlfDelay: Infinity
+    crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
     if (filterRe && !filterRe.test(line)) continue;
@@ -2859,30 +3137,27 @@ function processFile(content, absPath, style, overwrite, target) {
   const arrowRegex = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/g;
   const classRegex = /class\s+(\w+)/g;
   const typeRegex = /(?:type|interface)\s+(\w+)\s*[=<]/g;
-  let match;
   const allMatches = [];
   if (target === "all" || target === "function") {
-    while ((match = functionRegex.exec(content)) !== null) {
-      if (!match[1]) continue;
-      allMatches.push({ name: match[1], sig: match[2] ?? "", type: "function", line: content.slice(0, match.index).split("\n").length });
+    for (const m of content.matchAll(functionRegex)) {
+      if (!m[1]) continue;
+      allMatches.push({ name: m[1], sig: m[2] ?? "", type: "function", line: content.slice(0, m.index).split("\n").length });
     }
-    while ((match = arrowRegex.exec(content)) !== null) {
-      if (!match[1]) continue;
-      allMatches.push({ name: match[1], sig: match[2] ?? "", type: "arrow", line: content.slice(0, match.index).split("\n").length });
+    for (const m of content.matchAll(arrowRegex)) {
+      if (!m[1]) continue;
+      allMatches.push({ name: m[1], sig: m[2] ?? "", type: "arrow", line: content.slice(0, m.index).split("\n").length });
     }
   }
   if (target === "all" || target === "class") {
-    functionRegex.lastIndex = 0;
-    while ((match = classRegex.exec(content)) !== null) {
-      if (!match[1]) continue;
-      allMatches.push({ name: match[1], sig: "", type: "class", line: content.slice(0, match.index).split("\n").length });
+    for (const m of content.matchAll(classRegex)) {
+      if (!m[1]) continue;
+      allMatches.push({ name: m[1], sig: "", type: "class", line: content.slice(0, m.index).split("\n").length });
     }
   }
   if (target === "all" || target === "type") {
-    functionRegex.lastIndex = 0;
-    while ((match = typeRegex.exec(content)) !== null) {
-      if (!match[1]) continue;
-      allMatches.push({ name: match[1], sig: match[0] ?? "", type: "type", line: content.slice(0, match.index).split("\n").length });
+    for (const m of content.matchAll(typeRegex)) {
+      if (!m[1]) continue;
+      allMatches.push({ name: m[1], sig: m[0] ?? "", type: "type", line: content.slice(0, m.index).split("\n").length });
     }
   }
   for (const m of allMatches) {
@@ -2902,7 +3177,7 @@ var BUILT_IN_TEMPLATES = {
     files: {
       "package.json": JSON.stringify({
         name: "{{name}}",
-        version: "0.0.1",
+        version: "0.1.1",
         type: "module",
         main: "./dist/index.js",
         scripts: { build: "tsc", test: "vitest run" },
@@ -2932,7 +3207,7 @@ describe('hello', () => {
     files: {
       "package.json": JSON.stringify({
         name: "{{name}}",
-        version: "0.0.1",
+        version: "0.1.1",
         type: "module",
         bin: { "{{name}}": "./src/index.js" },
         scripts: { build: "tsc", start: "node dist/index.js" }
@@ -3097,7 +3372,7 @@ var toolSearchTool = {
     const limit = Math.min(input.limit ?? 20, 100);
     const tools = ctx.tools;
     const query2 = input.query?.toLowerCase() ?? "";
-    let filtered = tools.filter((t) => {
+    const filtered = tools.filter((t) => {
       if (query2 && !t.name.toLowerCase().includes(query2) && !t.description.toLowerCase().includes(query2)) {
         return false;
       }
@@ -3549,7 +3824,7 @@ ${mode.description}`
   };
 }
 
-// src/index.ts
+// src/builtin.ts
 var builtinTools = [
   readTool,
   writeTool,