zizou-ai 0.1.1 → 0.1.2

package/dist/cli.js

@@ -642,6 +642,7 @@ import { streamText, stepCountIs } from "ai";
 
 // src/tools/read-file.ts
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { z } from "zod";
 import { tool } from "ai";
 var readFile = tool({
@@ -656,7 +657,8 @@ var readFile = tool({
    */
   execute: async ({ path }) => {
     try {
-      const contents = readFileSync(path, "utf-8");
+      const absPath = resolve(process.cwd(), path);
+      const contents = readFileSync(absPath, "utf-8");
       return { success: true, contents };
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error reading file";
@@ -667,7 +669,7 @@ var readFile = tool({
 
 // src/tools/write-file.ts
 import { writeFileSync, mkdirSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, resolve as resolve2 } from "node:path";
 import { z as z2 } from "zod";
 import { tool as tool2 } from "ai";
 var writeFile = tool2({
@@ -678,7 +680,7 @@ var writeFile = tool2({
   }),
   execute: async ({ path: inputPath, contents }) => {
     try {
-      const absPath = resolve(process.cwd(), inputPath);
+      const absPath = resolve2(process.cwd(), inputPath);
       const dir = dirname(absPath);
       mkdirSync(dir, { recursive: true });
       writeFileSync(absPath, contents, "utf-8");
@@ -695,6 +697,7 @@ var writeFile = tool2({
 
 // src/tools/edit-file.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 import { z as z3 } from "zod";
 import { tool as tool3 } from "ai";
 var editFile = tool3({
@@ -706,7 +709,10 @@ var editFile = tool3({
   }),
   execute: async ({ path, old_string, new_string }) => {
     try {
-      const contents = readFileSync2(path, "utf-8");
+      const absPath = resolve3(process.cwd(), path);
+      let contents = readFileSync2(absPath, "utf-8");
+      contents = contents.replace(/\r\n/g, "\n");
+      old_string = old_string.replace(/\r\n/g, "\n");
       let count = 0;
       let pos = contents.indexOf(old_string);
       while (pos !== -1) {
@@ -726,10 +732,10 @@ var editFile = tool3({
         };
       }
       const updatedContents = contents.replace(old_string, new_string);
-      writeFileSync2(path, updatedContents, "utf-8");
+      writeFileSync2(absPath, updatedContents, "utf-8");
       return {
         success: true,
-        message: `Successfully replaced 1 occurrence in ${path}`
+        message: `Successfully replaced 1 occurrence in ${absPath}`
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : "Unknown error editing file";
@@ -743,6 +749,45 @@ import { readdirSync, statSync } from "fs";
 import { join, relative } from "path";
 import { z as z4 } from "zod";
 import { tool as tool4 } from "ai";
+function globToRegex(pattern) {
+  let p = pattern.replace(/\\/g, "/");
+  const hasSlash = p.includes("/");
+  let regexStr = "";
+  let i = 0;
+  while (i < p.length) {
+    const char = p[i];
+    if (char === "*" && p[i + 1] === "*") {
+      if (p[i + 2] === "/") {
+        regexStr += "(.*/)?";
+        i += 3;
+      } else {
+        regexStr += ".*";
+        i += 2;
+      }
+    } else if (char === "*") {
+      regexStr += "[^/]*";
+      i++;
+    } else if (char === "?") {
+      regexStr += "[^/]";
+      i++;
+    } else if (char === ".") {
+      regexStr += "\\.";
+      i++;
+    } else if (char === "/" || char === "\\") {
+      regexStr += "/";
+      i++;
+    } else if (".+^${}()|[]\\".includes(char)) {
+      regexStr += "\\" + char;
+      i++;
+    } else {
+      regexStr += char;
+      i++;
+    }
+  }
+  const finalPattern = hasSlash ? `^${regexStr}$` : `^(.*/)?${regexStr}$`;
+  const flags = process.platform === "win32" ? "i" : "";
+  return new RegExp(finalPattern, flags);
+}
 function simpleGlob(dir, pattern, results = [], root = dir) {
   const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next"]);
   let entries;
@@ -762,28 +807,78 @@ function simpleGlob(dir, pattern, results = [], root = dir) {
     }
     if (stat.isDirectory()) {
       simpleGlob(fullPath, pattern, results, root);
-    } else if (pattern.test(entry)) {
-      results.push(relative(root, fullPath));
+    } else {
+      const relPath = relative(root, fullPath).replace(/\\/g, "/");
+      if (pattern.test(relPath) || pattern.test(entry)) {
+        results.push(relPath);
+      }
     }
   }
   return results;
 }
 var glob = tool4({
-  description: "Find files in the project by filename pattern (e.g. '*.ts', 'test*.js')",
+  description: "Find files in the project by filename pattern (e.g. '*.ts', '**/app.css')",
   inputSchema: z4.object({
-    pattern: z4.string().describe("A simple glob-style pattern, e.g. '*.ts'")
+    pattern: z4.string().describe("A simple glob-style pattern, e.g. '*.ts' or '**/app.css'")
   }),
   execute: async ({ pattern }) => {
-    const regexPattern = "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$";
-    const matches = simpleGlob(".", new RegExp(regexPattern));
-    return { success: true, files: matches.slice(0, 50) };
+    try {
+      const regex = globToRegex(pattern);
+      const matches = simpleGlob(".", regex);
+      return { success: true, files: matches.slice(0, 50) };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
   }
 });
 
 // src/tools/grep.ts
-import { execSync } from "child_process";
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2, relative as relative2 } from "path";
 import { z as z5 } from "zod";
 import { tool as tool5 } from "ai";
+function simpleGrep(dir, regex, filePattern, results = [], root = dir) {
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "coverage"]);
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (SKIP.has(entry)) continue;
+    const fullPath = join2(dir, entry);
+    let stat;
+    try {
+      stat = statSync2(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      simpleGrep(fullPath, regex, filePattern, results, root);
+    } else {
+      if (stat.size > 1024 * 1024) continue;
+      const relPath = relative2(root, fullPath).replace(/\\/g, "/");
+      if (filePattern && !filePattern.test(relPath) && !filePattern.test(entry)) {
+        continue;
+      }
+      try {
+        const content = readFileSync3(fullPath, "utf-8");
+        if (content.indexOf("\0") !== -1) continue;
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push(`${relPath}:${i + 1}:${lines[i].trim()}`);
+            if (results.length >= 50) return results;
+          }
+        }
+      } catch {
+      }
+    }
+    if (results.length >= 50) break;
+  }
+  return results;
+}
 var grep = tool5({
   description: "Search file contents for a text pattern across the project (like grep -r)",
   inputSchema: z5.object({
@@ -792,12 +887,14 @@ var grep = tool5({
   }),
   execute: async ({ pattern, fileGlob }) => {
     try {
-      const includeFlag = fileGlob ? `--include="${fileGlob}"` : "";
-      const safePattern = pattern.replace(/"/g, '\\"');
-      const cmd = `grep -rn ${includeFlag} --exclude-dir=node_modules --exclude-dir=.git "${safePattern}" . || true`;
-      const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 1024 * 1024 });
-      const lines = output.split("\n").filter(Boolean).slice(0, 30);
-      return { success: true, matches: lines };
+      const searchRegex = new RegExp(pattern);
+      let fileRegex = null;
+      if (fileGlob) {
+        const fp = "^" + fileGlob.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$";
+        fileRegex = new RegExp(fp);
+      }
+      const matches = simpleGrep(".", searchRegex, fileRegex);
+      return { success: true, matches };
     } catch (err) {
       return { success: false, error: String(err) };
     }
@@ -805,8 +902,8 @@ var grep = tool5({
 });
 
 // src/tools/list-dir.ts
-import { readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import { join as join2, resolve as resolve2 } from "node:path";
+import { readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { join as join3, resolve as resolve4 } from "node:path";
 import { z as z6 } from "zod";
 import { tool as tool6 } from "ai";
 var listDir = tool6({
@@ -819,13 +916,13 @@ var listDir = tool6({
   execute: async ({ path: inputPath }) => {
     const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".cache"]);
     try {
-      const dir = resolve2(process.cwd(), inputPath ?? ".");
-      const entries = readdirSync2(dir);
+      const dir = resolve4(process.cwd(), inputPath ?? ".");
+      const entries = readdirSync3(dir);
       const items = [];
       for (const entry of entries) {
         if (SKIP.has(entry)) continue;
         try {
-          const stat = statSync2(join2(dir, entry));
+          const stat = statSync3(join3(dir, entry));
           items.push({ name: entry, type: stat.isDirectory() ? "dir" : "file" });
         } catch {
         }
@@ -844,7 +941,7 @@ var listDir = tool6({
 
 // src/tools/open-file.ts
 import { spawn } from "node:child_process";
-import { resolve as resolve3, extname } from "node:path";
+import { resolve as resolve5, extname } from "node:path";
 import { existsSync } from "node:fs";
 import { z as z7 } from "zod";
 import { tool as tool7 } from "ai";
@@ -862,7 +959,7 @@ var openFile = tool7({
   }),
   execute: async ({ path: inputPath }) => {
     try {
-      const absPath = resolve3(process.cwd(), inputPath);
+      const absPath = resolve5(process.cwd(), inputPath);
       if (!existsSync(absPath)) {
         return {
           success: false,
@@ -895,10 +992,10 @@ import { tool as tool8 } from "ai";
 import { z as z8 } from "zod";
 
 // src/context/repo-map.ts
-import { readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { join as join3, relative as relative2 } from "path";
+import { readFileSync as readFileSync4, readdirSync as readdirSync4, statSync as statSync4 } from "fs";
+import { join as join4, relative as relative3 } from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "coverage"]);
-var CODE_FILE_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+var CODE_FILE_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|html|css)$/;
 var SYMBOL_PATTERNS = [
   /^\s*(export\s+)?(async\s+)?function\s+(\w+)\s*\(/,
   /^\s*(export\s+)?const\s+(\w+)\s*=\s*(async\s*)?\(/,
@@ -935,25 +1032,34 @@ function scanRepo(rootDir) {
   function walk(dir) {
     let entries;
     try {
-      entries = readdirSync3(dir);
+      entries = readdirSync4(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (SKIP_DIRS.has(entry)) continue;
-      const fullPath = join3(dir, entry);
+      const fullPath = join4(dir, entry);
       let stat;
       try {
-        stat = statSync3(fullPath);
+        stat = statSync4(fullPath);
       } catch {
         continue;
       }
       if (stat.isDirectory()) {
         walk(fullPath);
       } else if (CODE_FILE_PATTERN.test(entry)) {
-        const content = readFileSync3(fullPath, "utf-8");
-        const relPath = relative2(rootDir, fullPath);
-        allSymbols.push(...extractSymbols(relPath, content));
+        const content = readFileSync4(fullPath, "utf-8");
+        const relPath = relative3(rootDir, fullPath).replace(/\\/g, "/");
+        const fileSymbols = extractSymbols(relPath, content);
+        if (fileSymbols.length === 0) {
+          allSymbols.push({
+            file: relPath,
+            line: 1,
+            signature: "(no exported symbols extracted)"
+          });
+        } else {
+          allSymbols.push(...fileSymbols);
+        }
       }
     }
   }
@@ -983,11 +1089,11 @@ function buildRepoMap(rootDir) {
 }
 
 // src/context/build-system-prompt.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve6 } from "path";
 var pinnedContextFiles = /* @__PURE__ */ new Set();
 function addPinnedFile(projectRoot, filePath) {
-  const absolutePath = resolve4(projectRoot, filePath);
+  const absolutePath = resolve6(projectRoot, filePath);
   if (!existsSync2(absolutePath)) {
     throw new Error(`File not found: ${absolutePath}`);
   }
@@ -997,6 +1103,12 @@ function addPinnedFile(projectRoot, filePath) {
 function clearPinnedFiles() {
   pinnedContextFiles.clear();
 }
+function getOSInfo() {
+  const p = process.platform;
+  if (p === "win32") return { os: "Windows", shell: "PowerShell" };
+  if (p === "darwin") return { os: "macOS", shell: "bash/zsh" };
+  return { os: "Linux", shell: "bash" };
+}
 var BASE_INSTRUCTIONS = `You are Zizou, an AI coding agent operating inside a user's terminal,
 with direct access to their project's filesystem through tools.
 
@@ -1013,6 +1125,12 @@ You have two complementary ways to understand the codebase:
 
 When creating a new file or completely replacing a file's contents, use the writeFile tool. When modifying existing files in a targeted way, use editFile with an old_string that exactly matches existing content and is unique in the file \u2014 never rewrite whole files from scratch if you are only making minor edits. Before running any shell command, know that the user will be asked to approve it; explain briefly what a command will do if it's not obvious.
 
+IMPORTANT \u2014 "Read Before Edit" Rule:
+Before calling editFile, you MUST first readFile the file to see its current contents.
+The old_string parameter must EXACTLY match text currently in the file \u2014 including all
+whitespace, indentation, and line breaks. If you guess at the content without reading
+the file first, the edit will almost certainly fail.
+
 For general knowledge questions, conversational chat, or queries that do not require workspace files or terminal command execution, answer directly from your internal knowledge. Do NOT use tools (such as grep, glob, readFile, or runBash) unless the task specifically requires accessing the project codebase or executing commands.
 
 CRITICAL INSTRUCTION FOR TOOL CALLING: You are interacting with a system that supports native tool calling (function calling). You MUST use the native tool calling protocol. 
@@ -1025,9 +1143,12 @@ async function buildSystemPrompt(projectRoot) {
   if (mode !== "light") {
     repoMap = buildRepoMap(projectRoot);
   }
+  const { os, shell } = getOSInfo();
   const SESSION_CONTEXT = `
 --- SESSION CONTEXT ---
 Workspace root (cwd): ${projectRoot}
+Operating system: ${os}
+Shell: ${shell}
 All relative paths you provide to tools are resolved from this root.
 When creating or writing a file, you can use either:
   - An absolute path  (e.g. ${projectRoot}/index.html)
@@ -1038,24 +1159,65 @@ TOOL GUIDE:
   listDir(path?)     \u2192 list immediate children of a directory. Use this FIRST
                        whenever you need to understand the folder structure or
                        decide where a new file should go.
-  readFile(path)     \u2192 read the full contents of an existing file.
+  readFile(path)     \u2192 read the full contents of an existing file. ALWAYS call
+                       this before editFile so you have the exact current text.
   writeFile(path, contents) \u2192 create a NEW file or FULLY REPLACE an existing one.
                        Use this for brand-new files or when you want to overwrite everything.
   editFile(path, old_string, new_string) \u2192 make a TARGETED replacement inside an existing
                        file. old_string must match exactly and be unique in the file.
-  glob(pattern)      \u2192 find files recursively by name pattern (e.g. "*.ts").
-  grep(query)        \u2192 search file contents by text pattern.
+                       IMPORTANT: Always readFile first to get the exact text.
+  glob(pattern)      \u2192 find files recursively by name pattern (e.g. "*.ts",
+                       "**/app.css"). Supports ** for any depth matching.
+  grep(pattern)      \u2192 search file contents by text or regex pattern across the project.
   runBash(command)   \u2192 run a shell command (user must approve first).
+                       On ${os} this runs in ${shell}.
+                       Has a 120-second timeout \u2014 suitable for short/medium installation & builds.
+  runBackground(command) \u2192 Run a shell command in the background (non-blocking).
+                       Perfect for long-running servers (e.g. 'npm run dev' or 'bun run dev').
+                       Returns a 'taskId' and 'pid' immediately.
+  manageTasks(action, taskId?) \u2192 Manage background tasks.
+                       - action="list": Return details of all tasks spawned in this session.
+                       - action="logs": Return stdout/stderr buffer from a task (helps check server state/logs).
+                       - action="kill": Terminate a background task (and its children).
+  managePorts(action, port) \u2192 Find and terminate processes on ports.
+                       - action="find": Find PID and name of process listening on 'port'.
+                       - action="kill": Kill the process listening on 'port'.
+                       Helps solve 'Address already in use' errors.
+  fileOperations(action, source, destination?) \u2192 Native file management.
+                       - action="delete": Recursively delete a file/folder.
+                       - action="createDirectory": Recursively create folders.
+                       - action="copy": Recursively copy a file/folder to destination.
+                       - action="move": Move/rename a file/folder to destination.
   openFile(path)     \u2192 open a file in the OS default app (HTML \u2192 browser,
                        images \u2192 viewer, etc.). Use after creating a file so the
                        user can immediately preview it.
+
+WORKFLOW FOR FINDING AND EDITING FILES:
+When the user asks you to modify a file you haven't seen yet:
+  1. Use glob("**/filename") or listDir() to FIND the file path
+  2. Use readFile(path) to READ its current contents
+  3. Use editFile(path, old_string, new_string) to EDIT it
+  Never skip step 2 \u2014 editFile needs an exact string match.
+
+PROJECT SCAFFOLDING (React, Next.js, Vite, etc.):
+When the user asks you to create a new project with a framework:
+  1. Use runBash to scaffold: e.g.
+     - React/Vite: npx -y create-vite@latest my-app -- --template react
+     - Next.js:    npx -y create-next-app@latest my-app --yes --use-npm
+     - Plain React: npx -y create-react-app my-app
+  2. Use runBash("cd my-app && npm install") if dependencies weren't auto-installed
+  3. Spin up development server in the background:
+     - runBackground("cd my-app && npm run dev")
+  4. Verify server running using:
+     - manageTasks("list")
+     - Wait a few seconds, then query logs using manageTasks("logs", taskId) to see server startup details.
 --- END SESSION CONTEXT ---`;
   let pinnedText = "";
   if (pinnedContextFiles.size > 0) {
     pinnedText = "\n\n--- PINNED FILES ---\nThe user has pinned the following files to your permanent context:\n";
     for (const file of pinnedContextFiles) {
       try {
-        const contents = readFileSync4(file, "utf8");
+        const contents = readFileSync5(file, "utf8");
         pinnedText += `
 File: ${file}
 \`\`\`
@@ -1107,12 +1269,21 @@ var addFileToContext = tool8({
 // src/tools/run-bash.ts
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { join as join5 } from "node:path";
 import { z as z9 } from "zod";
 import { tool as tool9 } from "ai";
 var execAsync = promisify(exec);
+function getShellConfig() {
+  if (process.platform === "win32") {
+    const systemRoot = process.env.SystemRoot || "C:\\Windows";
+    const powershellPath = join5(systemRoot, "System32\\WindowsPowerShell\\v1.0\\powershell.exe");
+    return { shell: powershellPath };
+  }
+  return {};
+}
 var createRunBashTool = (confirm) => {
   return tool9({
-    description: "Execute a shell command. This requires user confirmation, so only use it when necessary. Commands run with a 15-second timeout. Output is truncated if too long.",
+    description: "Execute a shell command. This requires user confirmation, so only use it when necessary. Commands run with a 120-second timeout. Output is truncated if too long. On Windows this runs in PowerShell; on macOS/Linux it uses the default shell.",
     inputSchema: z9.object({
       command: z9.string().describe("The shell command to execute")
     }),
@@ -1130,10 +1301,13 @@ Allow?`
       }
       try {
         const { stdout, stderr } = await execAsync(command, {
-          timeout: 15e3,
-          // 15 seconds
-          maxBuffer: 1024 * 1024
+          timeout: 12e4,
+          // 120 seconds — enough for npm install, npx create-*, etc.
+          maxBuffer: 1024 * 1024,
           // 1 MB
+          cwd: process.cwd(),
+          // explicit: run from the project root
+          ...getShellConfig()
         });
         const rawOutput = `STDOUT:
 ${stdout}
@@ -1163,6 +1337,487 @@ ${stderr}`;
   });
 };
 
+// src/tools/run-background.ts
+import { spawn as spawn2 } from "node:child_process";
+import { join as join6 } from "node:path";
+import { z as z10 } from "zod";
+import { tool as tool10 } from "ai";
+
+// src/tools/task-registry.ts
+var tasks = /* @__PURE__ */ new Map();
+var taskIdCounter = 1;
+var MAX_BUFFER_LENGTH = 1e4;
+function registerTask(command, process2) {
+  const id = `task_${taskIdCounter++}`;
+  const task = {
+    id,
+    command,
+    pid: process2.pid,
+    status: "running",
+    exitCode: null,
+    outputBuffer: "",
+    startTime: /* @__PURE__ */ new Date(),
+    process: process2
+  };
+  const appendToBuffer = (data) => {
+    task.outputBuffer += data;
+    if (task.outputBuffer.length > MAX_BUFFER_LENGTH) {
+      task.outputBuffer = task.outputBuffer.slice(task.outputBuffer.length - MAX_BUFFER_LENGTH);
+    }
+  };
+  process2.stdout?.setEncoding("utf-8");
+  process2.stdout?.on("data", (chunk) => {
+    appendToBuffer(chunk);
+  });
+  process2.stderr?.setEncoding("utf-8");
+  process2.stderr?.on("data", (chunk) => {
+    appendToBuffer(chunk);
+  });
+  process2.on("close", (code) => {
+    task.exitCode = code;
+    task.status = code === 0 ? "exited" : "failed";
+  });
+  process2.on("error", (err) => {
+    task.status = "failed";
+    appendToBuffer(`
+[Task Registry Error]: ${err.message}
+`);
+  });
+  tasks.set(id, task);
+  return task;
+}
+function getTask(id) {
+  return tasks.get(id);
+}
+function listTasks() {
+  return Array.from(tasks.values()).map(({ id, command, pid, status, exitCode, outputBuffer, startTime }) => ({
+    id,
+    command,
+    pid,
+    status,
+    exitCode,
+    outputBuffer,
+    startTime
+  }));
+}
+function killTask(id) {
+  const task = tasks.get(id);
+  if (!task || task.status !== "running") return false;
+  try {
+    if (process.platform === "win32") {
+      const { execSync } = __require("node:child_process");
+      execSync(`taskkill /pid ${task.process.pid} /T /F`, { stdio: "ignore" });
+    } else {
+      task.process.kill("SIGTERM");
+      setTimeout(() => {
+        if (task.status === "running") {
+          task.process.kill("SIGKILL");
+        }
+      }, 2e3);
+    }
+    task.status = "exited";
+    return true;
+  } catch (err) {
+    try {
+      task.process.kill();
+      task.status = "exited";
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function cleanup() {
+  for (const [id, task] of tasks.entries()) {
+    if (task.status === "running") {
+      try {
+        if (process.platform === "win32") {
+          const { execSync } = __require("node:child_process");
+          execSync(`taskkill /pid ${task.process.pid} /T /F`, { stdio: "ignore" });
+        } else {
+          task.process.kill("SIGKILL");
+        }
+      } catch {
+      }
+    }
+  }
+}
+process.on("exit", cleanup);
+process.on("SIGINT", () => {
+  cleanup();
+  process.exit(130);
+});
+process.on("SIGTERM", () => {
+  cleanup();
+  process.exit(143);
+});
+
+// src/tools/run-background.ts
+function getShellConfig2() {
+  if (process.platform === "win32") {
+    const systemRoot = process.env.SystemRoot || "C:\\Windows";
+    const powershellPath = join6(systemRoot, "System32\\WindowsPowerShell\\v1.0\\powershell.exe");
+    return { shell: powershellPath };
+  }
+  return { shell: true };
+}
+var createRunBackgroundTool = (confirm) => {
+  return tool10({
+    description: "Execute a shell command in the background (non-blocking). This is perfect for starting development servers (e.g. npm run dev), or running long tasks like compilation. Returns a taskId immediately. Requires user confirmation. On Windows, runs in PowerShell; on macOS/Linux it uses the default shell.",
+    inputSchema: z10.object({
+      command: z10.string().describe("The shell command to execute in the background")
+    }),
+    execute: async ({ command }) => {
+      const isApproved = await confirm(
+        `The agent wants to run this command in the background:
+  ${command}
+Allow?`
+      );
+      if (!isApproved) {
+        return {
+          success: false,
+          error: "User denied permission to run this command."
+        };
+      }
+      try {
+        const shellOpts = getShellConfig2();
+        const child = spawn2(command, {
+          ...shellOpts,
+          cwd: process.cwd(),
+          detached: process.platform !== "win32",
+          // detached group on Unix so child isn't killed immediately if parent detaches
+          stdio: ["ignore", "pipe", "pipe"]
+          // pipe stdout and stderr
+        });
+        if (process.platform !== "win32") {
+          child.unref();
+        }
+        const task = registerTask(command, child);
+        return {
+          success: true,
+          message: `Successfully started background task.`,
+          taskId: task.id,
+          pid: task.pid
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error starting background command";
+        return { success: false, error: message };
+      }
+    }
+  });
+};
+
+// src/tools/manage-tasks.ts
+import { z as z11 } from "zod";
+import { tool as tool11 } from "ai";
+var manageTasks = tool11({
+  description: "Manage active background tasks spawned during this session. Can list running tasks, view their real-time output logs, or kill/terminate them.",
+  inputSchema: z11.object({
+    action: z11.enum(["list", "kill", "logs"]).describe("Action to perform: 'list' (all tasks), 'kill' (stop a task), 'logs' (get stdout/stderr output)"),
+    taskId: z11.string().optional().describe("The taskId returned by runBackground. Required for 'kill' and 'logs'.")
+  }),
+  execute: async ({ action, taskId }) => {
+    try {
+      if (action === "list") {
+        const activeTasks = listTasks();
+        return {
+          success: true,
+          tasks: activeTasks.map((t) => ({
+            id: t.id,
+            command: t.command,
+            pid: t.pid,
+            status: t.status,
+            exitCode: t.exitCode,
+            startTime: t.startTime.toISOString(),
+            logSize: t.outputBuffer.length
+          }))
+        };
+      }
+      if (!taskId) {
+        return {
+          success: false,
+          error: "A 'taskId' is required for actions 'kill' and 'logs'."
+        };
+      }
+      if (action === "logs") {
+        const task = getTask(taskId);
+        if (!task) {
+          return {
+            success: false,
+            error: `Task ${taskId} not found.`
+          };
+        }
+        return {
+          success: true,
+          taskId: task.id,
+          command: task.command,
+          status: task.status,
+          logs: task.outputBuffer || "(No output logs yet)"
+        };
+      }
+      if (action === "kill") {
+        const task = getTask(taskId);
+        if (!task) {
+          return {
+            success: false,
+            error: `Task ${taskId} not found.`
+          };
+        }
+        if (task.status !== "running") {
+          return {
+            success: false,
+            error: `Task ${taskId} is not running (status: ${task.status}).`
+          };
+        }
+        const killed = killTask(taskId);
+        if (killed) {
+          return {
+            success: true,
+            message: `Successfully terminated background task ${taskId}.`
+          };
+        } else {
+          return {
+            success: false,
+            error: `Failed to terminate task ${taskId}.`
+          };
+        }
+      }
+      return {
+        success: false,
+        error: `Unsupported action: ${action}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error managing tasks";
+      return { success: false, error: message };
+    }
+  }
+});
+
+// src/tools/manage-ports.ts
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { z as z12 } from "zod";
+import { tool as tool12 } from "ai";
+var execAsync2 = promisify2(exec2);
+async function findProcessOnPort(port) {
+  const results = [];
+  if (process.platform === "win32") {
+    try {
+      const { stdout } = await execAsync2(`netstat -ano | findstr :${port}`);
+      const lines = stdout.split("\n");
+      const pids = /* @__PURE__ */ new Set();
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 5) {
+          const localAddr = parts[1];
+          if (localAddr.endsWith(`:${port}`)) {
+            const pid = parseInt(parts[parts.length - 1], 10);
+            if (!isNaN(pid) && pid > 0) {
+              pids.add(pid);
+            }
+          }
+        }
+      }
+      for (const pid of pids) {
+        let name = "Unknown";
+        let details = "";
+        try {
+          const { stdout: taskStdout } = await execAsync2(`tasklist /FI "PID eq ${pid}" /NH`);
+          const taskParts = taskStdout.trim().split(/\s+/);
+          if (taskParts.length > 0 && taskParts[0] !== "INFO:") {
+            name = taskParts[0];
+          }
+          details = `PID: ${pid}, Name: ${name}`;
+        } catch {
+          details = `PID: ${pid}`;
+        }
+        results.push({ pid, name, details });
+      }
+    } catch {
+    }
+  } else {
+    try {
+      const { stdout } = await execAsync2(`lsof -i :${port} -F p c`);
+      const lines = stdout.trim().split("\n");
+      let currentPid = null;
+      for (const line of lines) {
+        if (line.startsWith("p")) {
+          currentPid = parseInt(line.substring(1), 10);
+        } else if (line.startsWith("c") && currentPid !== null) {
+          const name = line.substring(1);
+          results.push({
+            pid: currentPid,
+            name,
+            details: `PID: ${currentPid}, Command: ${name}`
+          });
+          currentPid = null;
+        }
+      }
+      if (results.length === 0 && lines.length > 0) {
+        const pids = lines.filter((l) => l.startsWith("p")).map((l) => parseInt(l.substring(1), 10)).filter((pid) => !isNaN(pid));
+        for (const pid of pids) {
+          results.push({ pid, details: `PID: ${pid}` });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+async function killProcess(pid) {
+  try {
+    if (process.platform === "win32") {
+      await execAsync2(`taskkill /F /PID ${pid}`);
+    } else {
+      await execAsync2(`kill -9 ${pid}`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+var managePorts = tool12({
+  description: "Find and terminate processes listening on a specific port. Useful for resolving 'Port already in use' errors during web server startup.",
+  inputSchema: z12.object({
+    action: z12.enum(["find", "kill"]).describe("Action to perform: 'find' (view what process is on the port), 'kill' (terminate the process on the port)"),
+    port: z12.number().describe("The local port number (e.g. 3000, 8080)")
+  }),
+  execute: async ({ action, port }) => {
+    try {
+      if (action === "find") {
+        const found = await findProcessOnPort(port);
+        if (found.length === 0) {
+          return {
+            success: true,
+            message: `No active processes found listening on port ${port}.`,
+            processes: []
+          };
+        }
+        return {
+          success: true,
+          message: `Found ${found.length} process(es) listening on port ${port}.`,
+          processes: found
+        };
+      }
+      if (action === "kill") {
+        const found = await findProcessOnPort(port);
+        if (found.length === 0) {
+          return {
+            success: false,
+            error: `No active processes found listening on port ${port} to terminate.`
+          };
+        }
+        const killedPids = [];
+        const failedPids = [];
+        for (const proc of found) {
+          const ok = await killProcess(proc.pid);
+          if (ok) {
+            killedPids.push(proc.pid);
+          } else {
+            failedPids.push(proc.pid);
+          }
+        }
+        if (failedPids.length > 0) {
+          return {
+            success: false,
+            error: `Successfully killed PID(s) ${killedPids.join(", ")}, but failed to kill PID(s) ${failedPids.join(", ")}.`
+          };
+        }
+        return {
+          success: true,
+          message: `Successfully terminated all process(es) on port ${port} (PID(s): ${killedPids.join(", ")}).`
+        };
+      }
+      return {
+        success: false,
+        error: `Unsupported action: ${action}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error managing ports";
+      return { success: false, error: message };
+    }
+  }
+});
+
+// src/tools/file-operations.ts
+import { rmSync, mkdirSync as mkdirSync2, cpSync, renameSync, existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+import { z as z13 } from "zod";
+import { tool as tool13 } from "ai";
+var fileOperations = tool13({
+  description: "Perform safe, native filesystem operations (delete, copy, move, create directories) without running shell commands. Always resolves relative paths from the project root.",
+  inputSchema: z13.object({
+    action: z13.enum(["delete", "createDirectory", "copy", "move"]).describe("The filesystem action to perform"),
+    source: z13.string().describe("The target path to delete/copy/move/create. Relative or absolute."),
+    destination: z13.string().optional().describe("The destination path. Required only for 'copy' and 'move' actions.")
+  }),
+  execute: async ({ action, source, destination }) => {
+    try {
+      const absSource = resolve7(process.cwd(), source);
+      if (action === "createDirectory") {
+        mkdirSync2(absSource, { recursive: true });
+        return {
+          success: true,
+          message: `Successfully created directory hierarchy at ${absSource}`
+        };
+      }
+      if (action === "delete") {
+        if (!existsSync3(absSource)) {
+          return {
+            success: false,
+            error: `Path does not exist: ${absSource}`
+          };
+        }
+        rmSync(absSource, { recursive: true, force: true });
+        return {
+          success: true,
+          message: `Successfully deleted ${absSource}`
+        };
+      }
+      if (!destination) {
+        return {
+          success: false,
+          error: `A 'destination' path is required for '${action}' operations.`
+        };
+      }
+      const absDest = resolve7(process.cwd(), destination);
+      if (action === "copy") {
+        if (!existsSync3(absSource)) {
+          return {
+            success: false,
+            error: `Source path does not exist: ${absSource}`
+          };
+        }
+        cpSync(absSource, absDest, { recursive: true });
+        return {
+          success: true,
+          message: `Successfully copied ${absSource} to ${absDest}`
+        };
+      }
+      if (action === "move") {
+        if (!existsSync3(absSource)) {
+          return {
+            success: false,
+            error: `Source path does not exist: ${absSource}`
+          };
+        }
+        renameSync(absSource, absDest);
+        return {
+          success: true,
+          message: `Successfully moved/renamed ${absSource} to ${absDest}`
+        };
+      }
+      return {
+        success: false,
+        error: `Unsupported action: ${action}`
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error in file operations";
+      return { success: false, error: message };
+    }
+  }
+});
+
 // src/agent/run-turn.ts
 function sanitizeJsonString(jsonStr) {
   let isInsideString = false;
@@ -1213,8 +1868,8 @@ async function* runTurn(options) {
   };
   try {
     const { writeFileSync: writeFileSync3 } = await import("node:fs");
-    const { resolve: resolve5 } = await import("node:path");
-    debugPath = resolve5(process.cwd(), "zizou-debug.log");
+    const { resolve: resolve8 } = await import("node:path");
+    debugPath = resolve8(process.cwd(), "zizou-debug.log");
     const toolSchemas = [
       {
         name: "readFile",
@@ -1271,6 +1926,34 @@ async function* runTurn(options) {
         parameters: { command: "string \u2014 the shell command" },
         returnShape: "{ success: true, output: string } | { success: false, error }",
         howPassed: "ConfirmFn suspends the agent loop (via Promise) until user presses y/n in the TUI. If approved, uses child_process.exec with 15s timeout + 1MB buffer."
+      },
+      {
+        name: "runBackground",
+        description: "Execute a shell command in the background (non-blocking).",
+        parameters: { command: "string \u2014 the shell command" },
+        returnShape: "{ success: true, taskId: string, pid?: number } | { success: false, error: string }",
+        howPassed: "Uses child_process.spawn to run command in the background, registers it in the task registry."
+      },
+      {
+        name: "manageTasks",
+        description: "Manage background tasks spawned in the session.",
+        parameters: { action: "'list' | 'kill' | 'logs'", taskId: "string" },
+        returnShape: "{ success: true, ... } | { success: false, error: string }",
+        howPassed: "Queries active background task list, logs buffer, or terminates a task."
+      },
+      {
+        name: "managePorts",
+        description: "Find or terminate processes listening on a port.",
+        parameters: { action: "'find' | 'kill'", port: "number" },
+        returnShape: "{ success: true, ... } | { success: false, error: string }",
+        howPassed: "Invokes platform commands (netstat, taskkill, lsof, kill) to find or stop processes on local ports."
+      },
+      {
+        name: "fileOperations",
+        description: "Perform filesystem operations natively (delete, copy, move, create directories).",
+        parameters: { action: "'delete' | 'createDirectory' | 'copy' | 'move'", source: "string", destination: "string" },
+        returnShape: "{ success: true, message: string } | { success: false, error: string }",
+        howPassed: "Uses Node fs methods directly to modify directories and files."
       }
     ];
     const hr = (label) => `
@@ -1390,7 +2073,11 @@ ${"\u2500".repeat(60)}`;
     listDir,
     openFile,
     addFileToContext,
-    runBash: createRunBashTool(onConfirm)
+    runBash: createRunBashTool(onConfirm),
+    runBackground: createRunBackgroundTool(onConfirm),
+    manageTasks,
+    managePorts,
+    fileOperations
   };
   const result = streamText({
     model,
@@ -1589,8 +2276,8 @@ ${"\u2500".repeat(60)}`;
 }
 
 // src/commands/index.ts
-import { existsSync as existsSync3, readdirSync as readdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync5 } from "fs";
+import { join as join7 } from "path";
 var SHORT_LABELS2 = {
   groq: "Groq",
   google: "Google Gemini",
@@ -1602,19 +2289,19 @@ var SHORT_LABELS2 = {
 function getSkills() {
   const skills = [];
   const globalPath = "C:\\Users\\Arnv\\.gemini\\config\\skills";
-  const localPath = join4(process.cwd(), ".agents", "skills");
-  if (existsSync3(globalPath)) {
+  const localPath = join7(process.cwd(), ".agents", "skills");
+  if (existsSync4(globalPath)) {
     try {
-      const entries = readdirSync4(globalPath, { withFileTypes: true });
+      const entries = readdirSync5(globalPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) skills.push(`global:${entry.name}`);
       }
     } catch {
     }
   }
-  if (existsSync3(localPath)) {
+  if (existsSync4(localPath)) {
     try {
-      const entries = readdirSync4(localPath, { withFileTypes: true });
+      const entries = readdirSync5(localPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) skills.push(`workspace:${entry.name}`);
       }
@@ -1994,8 +2681,8 @@ function Chat({ onChangeKeys }) {
     });
   }, []);
   const confirmFn = (description) => {
-    return new Promise((resolve5) => {
-      setPendingConfirm({ description, resolve: resolve5 });
+    return new Promise((resolve8) => {
+      setPendingConfirm({ description, resolve: resolve8 });
     });
   };
   useInput3((inputChar) => {