@zhongqian97-code/ecode 0.2.5 → 0.3.1

package/dist/index.js

@@ -3,10 +3,11 @@ const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a)
 
 // src/index.ts
 import { createRequire } from "module";
-import { resolve, dirname as dirname2 } from "path";
+import { resolve as resolve4, dirname as dirname6 } from "path";
 import { fileURLToPath } from "url";
 import React4 from "react";
 import { render } from "ink";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -74,7 +75,10 @@ function loadConfig() {
     try {
       const raw = readFileSync(configPath, "utf-8");
       fileConfig = JSON.parse(raw);
-    } catch {
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[ecode] warning: ${configPath} parse failed (${msg}), falling back to defaults/env
+`);
     }
   }
   return {
@@ -96,7 +100,7 @@ function loadConfig() {
 
 // src/ui/App.tsx
 import { useState as useState3, useCallback, useRef as useRef2, useEffect as useEffect3, useMemo } from "react";
-import { Box as Box5, useInput as useInput2, useStdout } from "ink";
+import { Box as Box6, useInput as useInput2, useStdout, useStdin } from "ink";
 
 // src/llm.ts
 import OpenAI from "openai";
@@ -120,7 +124,7 @@ function createLLMClient(config2) {
      * @param messages  完整的对话历史，包含 user/assistant/tool 所有轮次
      * @param tools     可选的工具列表，不传或传空数组时不附加 tools 字段
      */
-    stream(messages, tools) {
+    stream(messages, tools, signal) {
       return {
         [Symbol.asyncIterator]: async function* () {
           const requestParams = {
@@ -133,7 +137,8 @@ function createLLMClient(config2) {
             requestParams.tools = tools;
           }
           const response = await openai.chat.completions.create(
-            requestParams
+            requestParams,
+            signal ? { signal } : void 0
           );
           const tcAccumulator = /* @__PURE__ */ new Map();
           let reasoningAccumulator = "";
@@ -229,9 +234,90 @@ var DEFAULT_DANGER_LIST = [
 function matchesEntry(cmd, entry) {
   return cmd === entry || cmd.startsWith(entry + " ");
 }
-function classifyCommand(cmd, dangerPatterns) {
+function splitByControlOps(cmd) {
+  const segments = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let i = 0;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      i++;
+      continue;
+    }
+    if (inSingle || inDouble) {
+      if (inDouble && ch === "\\" && i + 1 < cmd.length) {
+        current += ch + cmd[i + 1];
+        i += 2;
+      } else {
+        current += ch;
+        i++;
+      }
+      continue;
+    }
+    if (ch === "&" && cmd[i + 1] === "&") {
+      segments.push(current.trim());
+      current = "";
+      i += 2;
+      continue;
+    }
+    if (ch === "|" && cmd[i + 1] === "|") {
+      segments.push(current.trim());
+      current = "";
+      i += 2;
+      continue;
+    }
+    if (ch === ";" || ch === "|") {
+      segments.push(current.trim());
+      current = "";
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  segments.push(current.trim());
+  return segments.filter((s) => s.length > 0);
+}
+function stripShellWrapper(cmd) {
+  const trimmed = cmd.trim();
+  const dq = trimmed.match(/^(?:bash|sh)\s+-c\s+"((?:[^"\\]|\\.)*)"/);
+  if (dq) return dq[1];
+  const sq = trimmed.match(/^(?:bash|sh)\s+-c\s+'([^']*)'/);
+  if (sq) return sq[1];
+  const nq = trimmed.match(/^(?:bash|sh)\s+-c\s+(\S+)/);
+  if (nq) return nq[1];
+  return trimmed;
+}
+function classifyCommand(cmd, dangerPatterns, _depth = 0) {
   const trimmed = cmd.trim();
   const patterns = dangerPatterns ?? DEFAULT_DANGER_LIST;
+  if (_depth < 5) {
+    const inner = stripShellWrapper(trimmed);
+    if (inner !== trimmed) {
+      const innerClass = classifyCommand(inner.trim(), dangerPatterns, _depth + 1);
+      if (innerClass === "danger") return "danger";
+      return "normal";
+    }
+  }
+  const segments = splitByControlOps(trimmed);
+  if (segments.length > 1) {
+    for (const seg of segments) {
+      if (classifyCommand(seg, dangerPatterns, _depth + 1) === "danger") {
+        return "danger";
+      }
+    }
+    return "normal";
+  }
   for (const entry of patterns) {
     if (matchesEntry(trimmed, entry)) return "danger";
   }
@@ -245,18 +331,671 @@ function classifyCommand(cmd, dangerPatterns) {
 import { exec } from "child_process";
 var DEFAULT_TIMEOUT_MS = 3e4;
 function executeBash(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve5) => {
     exec(cmd, { timeout: timeoutMs }, (err, stdout, stderr) => {
       if (err) {
         const exitCode = err.code ?? 1;
-        resolve2({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
+        resolve5({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
       } else {
-        resolve2({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode: 0 });
+        resolve5({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode: 0 });
       }
     });
   });
 }
 
+// src/tools/read.ts
+import * as fs from "fs/promises";
+var READ_TOOL = {
+  type: "function",
+  function: {
+    name: "read",
+    description: "\u8BFB\u53D6\u6587\u4EF6\u5185\u5BB9\u3002\u4F7F\u7528 offset\uFF080-based \u884C\u7D22\u5F15\uFF09\u548C limit \u53EF\u8BFB\u53D6\u6307\u5B9A\u884C\u8303\u56F4\uFF0C\u9002\u5408\u5927\u6587\u4EF6\u5C40\u90E8\u9605\u8BFB\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        offset: { type: "number", description: "\u8D77\u59CB\u884C\u7D22\u5F15\uFF080-based\uFF0C\u9ED8\u8BA4 0\uFF09\u3002" },
+        limit: { type: "number", description: "\u6700\u591A\u8FD4\u56DE\u7684\u884C\u6570\u3002" }
+      },
+      required: ["path"]
+    }
+  }
+};
+async function readFile2(params) {
+  const { path: path7, offset = 0, limit } = params;
+  let raw;
+  try {
+    raw = await fs.readFile(path7, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error reading ${path7}: ${msg}`;
+  }
+  const lines = raw.split("\n");
+  const sliced = limit !== void 0 ? lines.slice(offset, offset + limit) : lines.slice(offset);
+  return sliced.map((line, i) => `${String(offset + i + 1).padStart(4)} ${line}`).join("\n");
+}
+
+// src/tools/write.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+var WRITE_TOOL = {
+  type: "function",
+  function: {
+    name: "write",
+    description: "\u5C06\u5185\u5BB9\u5199\u5165\u6587\u4EF6\uFF08\u8986\u76D6\u6A21\u5F0F\uFF09\uFF0C\u81EA\u52A8\u521B\u5EFA\u7236\u76EE\u5F55\u3002\u5199\u5165\u524D\u8BF7\u5148\u7528 read \u786E\u8BA4\u73B0\u6709\u5185\u5BB9\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        content: { type: "string", description: "\u8981\u5199\u5165\u7684\u5B8C\u6574\u5185\u5BB9\u3002" }
+      },
+      required: ["path", "content"]
+    }
+  }
+};
+async function writeFile2(params) {
+  const { path: filePath, content } = params;
+  try {
+    await fs2.mkdir(path.dirname(filePath), { recursive: true });
+    await fs2.writeFile(filePath, content, "utf8");
+    return `Written ${filePath}`;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error writing ${filePath}: ${msg}`;
+  }
+}
+
+// src/tools/edit.ts
+import * as fs3 from "fs/promises";
+var EDIT_TOOL = {
+  type: "function",
+  function: {
+    name: "edit",
+    description: "\u5728\u6587\u4EF6\u4E2D\u7CBE\u786E\u66FF\u6362\u4E00\u6BB5\u5B57\u7B26\u4E32\u3002old_string \u5728\u6587\u4EF6\u4E2D\u5FC5\u987B\u552F\u4E00\u51FA\u73B0\u2014\u2014\u82E5\u6709\u6B67\u4E49\u8BF7\u63D0\u4F9B\u66F4\u591A\u4E0A\u4E0B\u6587\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002" },
+        old_string: { type: "string", description: "\u8981\u67E5\u627E\u7684\u7CBE\u786E\u5B57\u7B26\u4E32\uFF08\u5728\u6587\u4EF6\u4E2D\u5FC5\u987B\u552F\u4E00\uFF09\u3002" },
+        new_string: { type: "string", description: "\u66FF\u6362\u540E\u7684\u5B57\u7B26\u4E32\u3002" }
+      },
+      required: ["path", "old_string", "new_string"]
+    }
+  }
+};
+async function editFile(params) {
+  const { path: path7, old_string, new_string } = params;
+  let content;
+  try {
+    content = await fs3.readFile(path7, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error reading ${path7}: ${msg}`;
+  }
+  const count = countOccurrences(content, old_string);
+  if (count === 0) {
+    return `Error: old_string not found in ${path7}`;
+  }
+  if (count > 1) {
+    return `Error: old_string appears ${count} times in ${path7} (ambiguous \u2014 add more context)`;
+  }
+  const updated = content.replace(old_string, new_string);
+  try {
+    await fs3.writeFile(path7, updated, "utf8");
+    return `Edited ${path7}`;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error writing ${path7}: ${msg}`;
+  }
+}
+function countOccurrences(haystack, needle) {
+  if (needle === "") return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = haystack.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+
+// src/tools/glob.ts
+import * as fs4 from "fs/promises";
+import * as path2 from "path";
+var GLOB_TOOL = {
+  type: "function",
+  function: {
+    name: "glob",
+    description: "Find files matching a glob pattern. Returns relative paths (one per line). Default excludes node_modules, .git and hidden dirs; pass includeHidden=true to include them.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Glob pattern, e.g. '**/*.ts', 'src/**', '*.md'" },
+        cwd: { type: "string", description: "Base directory to search in (default: current working directory)" },
+        includeHidden: { type: "boolean", description: "If true, include hidden files/dirs (starting with '.')" },
+        limit: { type: "number", description: "Max number of results to return (default 100)" }
+      },
+      required: ["pattern"]
+    }
+  }
+};
+function globToRegex(pattern) {
+  const hasSlash = pattern.includes("/");
+  const DSS = "\0DSS\0";
+  const DS = "\0DS\0";
+  const SS = "\0SS\0";
+  const QQ = "\0QQ\0";
+  let p = pattern.replace(/\*\*\//g, DSS).replace(/\*\*/g, DS).replace(/\*/g, SS).replace(/\?/g, QQ);
+  p = p.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  p = p.replace(new RegExp(DSS, "g"), "(.*/)?").replace(new RegExp(DS, "g"), ".*").replace(new RegExp(SS, "g"), "[^/]*").replace(new RegExp(QQ, "g"), "[^/]");
+  if (!hasSlash) {
+  }
+  return new RegExp(`^${p}$`);
+}
+async function walk(dir, cwd, regex, includeHidden, results, total, limit) {
+  let entries;
+  try {
+    entries = await fs4.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const name = entry.name;
+    if (name === "node_modules") continue;
+    if (!includeHidden && name.startsWith(".")) continue;
+    const abs = path2.join(dir, name);
+    const rel = path2.relative(cwd, abs);
+    if (entry.isDirectory()) {
+      await walk(abs, cwd, regex, includeHidden, results, total, limit);
+    } else if (entry.isFile()) {
+      const relPosix = rel.split(path2.sep).join("/");
+      if (regex.test(relPosix)) {
+        total.count++;
+        if (results.length < limit) {
+          results.push(relPosix);
+        }
+      }
+    }
+  }
+}
+async function globFiles(params) {
+  const {
+    pattern,
+    cwd = process.cwd(),
+    includeHidden = false,
+    limit = 100
+  } = params;
+  try {
+    const stat5 = await fs4.stat(cwd);
+    if (!stat5.isDirectory()) {
+      return `Error: ${cwd} is not a directory`;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const regex = globToRegex(pattern);
+  const results = [];
+  const total = { count: 0 };
+  await walk(cwd, cwd, regex, includeHidden, results, total, limit);
+  if (results.length === 0) {
+    return `No files found matching pattern: ${pattern}`;
+  }
+  results.sort();
+  let output = results.join("\n");
+  if (total.count > limit) {
+    output += `
+... (truncated, ${total.count} total matches)`;
+  }
+  return output;
+}
+
+// src/tools/grep.ts
+import * as fs5 from "fs/promises";
+import * as path3 from "path";
+var GREP_TOOL = {
+  type: "function",
+  function: {
+    name: "grep",
+    description: "\u5728\u6587\u4EF6\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u6A21\u5F0F\u3002\u8FD4\u56DE file:linenum:content \u683C\u5F0F\uFF0Ccontext \u884C\u7528 -- \u5206\u9694\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "\u6B63\u5219\u8868\u8FBE\u5F0F\u6A21\u5F0F\u3002" },
+        path: { type: "string", description: "\u641C\u7D22\u7684\u6587\u4EF6\u6216\u76EE\u5F55\u8DEF\u5F84\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09\u3002" },
+        cwd: { type: "string", description: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4 process.cwd()\uFF09\u3002" },
+        context: { type: "number", description: "\u5339\u914D\u524D\u540E\u7684\u4E0A\u4E0B\u6587\u884C\u6570\uFF08\u9ED8\u8BA4 0\uFF09\u3002" },
+        includeHidden: { type: "boolean", description: "\u662F\u5426\u5305\u542B\u9690\u85CF\u76EE\u5F55\uFF08\u9ED8\u8BA4 false\uFF09\u3002" },
+        limit: { type: "number", description: "\u6700\u5927\u8FD4\u56DE\u5339\u914D\u6570\uFF08\u9ED8\u8BA4 50\uFF09\u3002" }
+      },
+      required: ["pattern"]
+    }
+  }
+};
+async function searchFile(absFile, displayFile, regex, matches, totalCount, limit) {
+  let text;
+  try {
+    text = await fs5.readFile(absFile, "utf8");
+  } catch {
+    return;
+  }
+  const lines = text.split("\n");
+  const lastIdx = lines.length - 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (i === lastIdx && lines[i] === "") continue;
+    if (regex.test(lines[i])) {
+      totalCount.count++;
+      if (matches.length < limit) {
+        matches.push({ file: displayFile, line: i + 1, content: lines[i] });
+      }
+    }
+  }
+}
+async function walkDir(dir, cwd, regex, includeHidden, matches, totalCount, limit) {
+  let entries;
+  try {
+    entries = await fs5.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const name = entry.name;
+    if (name === "node_modules") continue;
+    if (!includeHidden && name.startsWith(".")) continue;
+    const abs = path3.join(dir, name);
+    if (entry.isDirectory()) {
+      await walkDir(abs, cwd, regex, includeHidden, matches, totalCount, limit);
+    } else if (entry.isFile()) {
+      const rel = path3.relative(cwd, abs).split(path3.sep).join("/");
+      await searchFile(abs, rel, regex, matches, totalCount, limit);
+    }
+  }
+}
+async function renderWithContext(entries, contextLines) {
+  const outputLines = [];
+  for (const { absFile, displayFile, matches: fileMatches } of entries) {
+    let allLines = [];
+    try {
+      const text = await fs5.readFile(absFile, "utf8");
+      allLines = text.split("\n");
+    } catch {
+    }
+    if (allLines.length === 0) {
+      for (const m of fileMatches) {
+        outputLines.push(`${displayFile}:${m.line}:${m.content}`);
+      }
+      continue;
+    }
+    const ranges = [];
+    for (const m of fileMatches) {
+      const start = Math.max(0, m.line - 1 - contextLines);
+      const end = Math.min(allLines.length - 1, m.line - 1 + contextLines);
+      const last = ranges[ranges.length - 1];
+      if (last && start <= last.end + 1) {
+        last.end = Math.max(last.end, end);
+      } else {
+        ranges.push({ start, end });
+      }
+    }
+    for (let ri = 0; ri < ranges.length; ri++) {
+      if (ri > 0) outputLines.push("--");
+      const { start, end } = ranges[ri];
+      for (let i = start; i <= end; i++) {
+        if (i === allLines.length - 1 && allLines[i] === "") continue;
+        outputLines.push(`${displayFile}:${i + 1}:${allLines[i]}`);
+      }
+    }
+  }
+  return outputLines;
+}
+async function grepFiles(params) {
+  const {
+    pattern,
+    path: searchPath = ".",
+    cwd = process.cwd(),
+    context = 0,
+    includeHidden = false,
+    limit = 50
+  } = params;
+  let regex;
+  try {
+    regex = new RegExp(pattern);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: Invalid regex: ${msg}`;
+  }
+  const target = path3.isAbsolute(searchPath) ? searchPath : path3.resolve(cwd, searchPath);
+  let stat5;
+  try {
+    stat5 = await fs5.stat(target);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const matches = [];
+  const totalCount = { count: 0 };
+  if (stat5.isFile()) {
+    await searchFile(target, searchPath, regex, matches, totalCount, limit);
+  } else if (stat5.isDirectory()) {
+    await walkDir(target, target, regex, includeHidden, matches, totalCount, limit);
+  } else {
+    return `Error: ${target} is neither a file nor a directory`;
+  }
+  if (matches.length === 0 && totalCount.count === 0) {
+    return "No matches found";
+  }
+  const matchesByFile = /* @__PURE__ */ new Map();
+  for (const m of matches) {
+    let group = matchesByFile.get(m.file);
+    if (!group) {
+      group = [];
+      matchesByFile.set(m.file, group);
+    }
+    group.push(m);
+  }
+  let outputLines;
+  if (context > 0) {
+    const baseDir = stat5.isDirectory() ? target : path3.dirname(target);
+    const entries = Array.from(matchesByFile.entries()).map(([displayFile, fileMatches]) => {
+      const absFile = path3.isAbsolute(displayFile) ? displayFile : path3.resolve(baseDir, displayFile);
+      return { absFile, displayFile, matches: fileMatches };
+    });
+    outputLines = await renderWithContext(entries, context);
+  } else {
+    outputLines = [];
+    for (const m of matches) {
+      outputLines.push(`${m.file}:${m.line}:${m.content}`);
+    }
+  }
+  let output = outputLines.join("\n");
+  if (totalCount.count > limit) {
+    const extra = totalCount.count - limit;
+    output += `
+... (truncated, ${extra} more matches)`;
+  }
+  return output;
+}
+
+// src/tools/apply_patch.ts
+import * as fs6 from "fs/promises";
+import * as path4 from "path";
+var APPLY_PATCH_TOOL = {
+  type: "function",
+  function: {
+    name: "apply_patch",
+    description: "\u5C06 unified diff \u683C\u5F0F\u7684 patch \u5E94\u7528\u5230\u6587\u4EF6\u3002\u652F\u6301 context \u4E0A\u4E0B\u6587\u884C\u6A21\u7CCA\u5B9A\u4F4D\uFF08\u5141\u8BB8\u5C11\u91CF\u884C\u53F7\u504F\u79FB\uFF09\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        patch: {
+          type: "string",
+          description: "Unified diff \u683C\u5F0F\u7684 patch \u5185\u5BB9\u3002"
+        },
+        file: {
+          type: "string",
+          description: "\u76EE\u6807\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u9009\uFF0C\u82E5 patch \u4E2D\u5305\u542B --- / +++ \u5934\u5219\u4ECE\u4E2D\u89E3\u6790\uFF09\u3002"
+        },
+        cwd: {
+          type: "string",
+          description: "\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4 process.cwd()\uFF09\u3002"
+        },
+        dryRun: {
+          type: "boolean",
+          description: "\u82E5\u4E3A true\uFF0C\u4EC5\u6821\u9A8C patch \u662F\u5426\u80FD\u5E94\u7528\uFF0C\u4E0D\u4FEE\u6539\u6587\u4EF6\uFF08\u9ED8\u8BA4 false\uFF09\u3002"
+        }
+      },
+      required: ["patch"]
+    }
+  }
+};
+function parseFilePath(patch) {
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      let p = line.slice(4).trim();
+      if (p.startsWith("b/")) p = p.slice(2);
+      if (p === "/dev/null" || p === "") return null;
+      return p;
+    }
+  }
+  return null;
+}
+function parseHunkHeader(header) {
+  const m = header.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+\d+(?:,\d+)?\s+@@/);
+  if (!m) return null;
+  const oldStart = parseInt(m[1], 10) - 1;
+  const oldCount = m[2] !== void 0 ? parseInt(m[2], 10) : 1;
+  return { oldStart, oldCount };
+}
+function parseHunks(patch) {
+  const rawLines = patch.split("\n");
+  const hunks = [];
+  let current = null;
+  for (const raw of rawLines) {
+    if (raw.startsWith("diff --git ")) continue;
+    if (raw.startsWith("--- ") || raw.startsWith("+++ ")) continue;
+    if (raw.startsWith("\\ ")) continue;
+    if (raw.startsWith("@@ ")) {
+      const parsed = parseHunkHeader(raw);
+      if (!parsed) continue;
+      current = {
+        header: raw,
+        oldStart: parsed.oldStart,
+        oldCount: parsed.oldCount,
+        lines: []
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (current === null) continue;
+    if (raw.startsWith("+")) {
+      current.lines.push({ kind: "add", content: raw.slice(1) });
+    } else if (raw.startsWith("-")) {
+      current.lines.push({ kind: "remove", content: raw.slice(1) });
+    } else if (raw.startsWith(" ")) {
+      current.lines.push({ kind: "context", content: raw.slice(1) });
+    }
+  }
+  return hunks;
+}
+var FUZZY_RADIUS = 3;
+function fuzzyFind(fileLines, hunk, suggestedStart) {
+  const expected = hunk.lines.filter((l) => l.kind === "context" || l.kind === "remove").map((l) => l.content);
+  if (expected.length === 0) {
+    return Math.max(0, Math.min(suggestedStart, fileLines.length));
+  }
+  const lo = Math.max(0, suggestedStart - FUZZY_RADIUS);
+  const hi = Math.min(
+    fileLines.length - expected.length,
+    suggestedStart + FUZZY_RADIUS
+  );
+  for (let start = lo; start <= hi; start++) {
+    let match = true;
+    for (let i = 0; i < expected.length; i++) {
+      if (fileLines[start + i] !== expected[i]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return start;
+  }
+  return null;
+}
+function applyHunk(fileLines, hunk, actualStart) {
+  const oldLineCount = hunk.lines.filter(
+    (l) => l.kind === "context" || l.kind === "remove"
+  ).length;
+  const newBlock = [];
+  for (const hl of hunk.lines) {
+    if (hl.kind === "context" || hl.kind === "add") {
+      newBlock.push(hl.content);
+    }
+  }
+  return [
+    ...fileLines.slice(0, actualStart),
+    ...newBlock,
+    ...fileLines.slice(actualStart + oldLineCount)
+  ];
+}
+async function applyPatch(params) {
+  const { patch, file: fileParam, cwd = process.cwd(), dryRun = false } = params;
+  let filePath;
+  if (fileParam) {
+    filePath = path4.isAbsolute(fileParam) ? fileParam : path4.resolve(cwd, fileParam);
+  } else {
+    const parsed = parseFilePath(patch);
+    if (!parsed) {
+      return "Error: no target file path found in patch headers (--- / +++ missing) and no 'file' param provided";
+    }
+    filePath = path4.isAbsolute(parsed) ? parsed : path4.resolve(cwd, parsed);
+  }
+  let originalContent;
+  try {
+    originalContent = await fs6.readFile(filePath, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: ${msg}`;
+  }
+  const hasTrailingNewline = originalContent.endsWith("\n");
+  const rawLines = originalContent.split("\n");
+  let fileLines = hasTrailingNewline ? rawLines.slice(0, -1) : rawLines;
+  const hunks = parseHunks(patch);
+  if (hunks.length === 0) {
+    return `Error: no valid hunks found in patch`;
+  }
+  let lineOffset = 0;
+  for (const hunk of hunks) {
+    const suggestedStart = hunk.oldStart + lineOffset;
+    const actualStart = fuzzyFind(fileLines, hunk, suggestedStart);
+    if (actualStart === null) {
+      return `Error: hunk ${hunk.header} does not apply (context mismatch)`;
+    }
+    const addCount = hunk.lines.filter((l) => l.kind === "add").length;
+    const removeCount = hunk.lines.filter((l) => l.kind === "remove").length;
+    fileLines = applyHunk(fileLines, hunk, actualStart);
+    lineOffset += addCount - removeCount;
+  }
+  const displayPath = path4.relative(cwd, filePath) || filePath;
+  if (dryRun) {
+    return `Patch applies cleanly to ${displayPath} (dry run)`;
+  }
+  const newContent = fileLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+  try {
+    await fs6.writeFile(filePath, newContent, "utf8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error: failed to write file: ${msg}`;
+  }
+  return `Applied ${hunks.length} hunk(s) to ${displayPath}`;
+}
+
+// src/tools/todo.ts
+var TODO_TOOL = {
+  type: "function",
+  function: {
+    name: "todo",
+    description: "\u7BA1\u7406\u5F53\u524D\u4F1A\u8BDD\u7684\u4EFB\u52A1\u6E05\u5355\u3002op=read \u8BFB\u53D6\uFF0Cop=write \u5168\u91CF\u8986\u5199\uFF0Cop=update \u66F4\u65B0\u5355\u9879\u3002",
+    parameters: {
+      type: "object",
+      properties: {
+        op: {
+          type: "string",
+          enum: ["read", "write", "update"],
+          description: "\u64CD\u4F5C\u7C7B\u578B\u3002"
+        },
+        todos: {
+          type: "array",
+          description: "write \u64CD\u4F5C\uFF1A\u5168\u91CF\u66FF\u6362\u7684\u4EFB\u52A1\u5217\u8868\u3002",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string" },
+              content: { type: "string" },
+              status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed", "cancelled"]
+              }
+            },
+            required: ["id", "content", "status"]
+          }
+        },
+        id: {
+          type: "string",
+          description: "update \u64CD\u4F5C\uFF1A\u76EE\u6807\u4EFB\u52A1\u7684\u552F\u4E00 id\u3002"
+        },
+        status: {
+          type: "string",
+          enum: ["pending", "in_progress", "completed", "cancelled"],
+          description: "update \u64CD\u4F5C\uFF1A\u65B0\u72B6\u6001\uFF08\u53EF\u9009\uFF09\u3002"
+        },
+        content: {
+          type: "string",
+          description: "update \u64CD\u4F5C\uFF1A\u65B0\u5185\u5BB9\uFF08\u53EF\u9009\uFF09\u3002"
+        }
+      },
+      required: ["op"]
+    }
+  }
+};
+var _todos = [];
+var STATUS_SYMBOL = {
+  pending: "[ ]",
+  in_progress: "[~]",
+  completed: "[x]",
+  cancelled: "[-]"
+};
+function opRead() {
+  if (_todos.length === 0) {
+    return "(no todos)";
+  }
+  return _todos.map((item) => `- ${STATUS_SYMBOL[item.status]} ${item.id}: ${item.content}`).join("\n");
+}
+function opWrite(params) {
+  if (params.todos === void 0) {
+    return "Error: write operation requires 'todos' parameter";
+  }
+  _todos = params.todos.map((t) => ({ ...t }));
+  return `Wrote ${_todos.length} todos.`;
+}
+function opUpdate(params) {
+  if (params.id === void 0) {
+    return "Error: update operation requires 'id' parameter";
+  }
+  if (params.status === void 0 && params.content === void 0) {
+    return "Error: update operation requires at least 'status' or 'content' parameter";
+  }
+  const idx = _todos.findIndex((t) => t.id === params.id);
+  if (idx === -1) {
+    return `Error: todo '${params.id}' not found`;
+  }
+  const updated = {
+    ..._todos[idx],
+    ...params.status !== void 0 ? { status: params.status } : {},
+    ...params.content !== void 0 ? { content: params.content } : {}
+  };
+  _todos = [
+    ..._todos.slice(0, idx),
+    updated,
+    ..._todos.slice(idx + 1)
+  ];
+  return `Updated todo ${params.id}.`;
+}
+function todo(params) {
+  switch (params.op) {
+    case "read":
+      return opRead();
+    case "write":
+      return opWrite(params);
+    case "update":
+      return opUpdate(params);
+    default: {
+      const unknownOp = params.op;
+      return `Error: unknown op '${unknownOp}'`;
+    }
+  }
+}
+
 // src/repl.ts
 var SKIP_MESSAGE = "Command skipped by user.";
 var BASH_TOOL = {
@@ -301,12 +1040,12 @@ Proceed? (y/n) `);
 }
 
 // src/logger.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 function createLogger(logDir, sessionStart) {
-  fs.mkdirSync(logDir, { recursive: true });
+  fs7.mkdirSync(logDir, { recursive: true });
   const filename = sessionStart.toISOString().replace(/:/g, "-").replace(/\..+/, "") + ".jsonl";
-  const filePath = path.join(logDir, filename);
+  const filePath = path5.join(logDir, filename);
   return {
     filePath,
     /**
@@ -320,7 +1059,7 @@ function createLogger(logDir, sessionStart) {
      */
     append(entry) {
       try {
-        fs.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+        fs7.appendFileSync(filePath, JSON.stringify(entry) + "\n");
       } catch (err) {
         process.stderr.write(`[logger] Failed to write log entry: ${err}
 `);
@@ -359,7 +1098,168 @@ function handleSkillInput(input, registry2) {
   const content = args ? `${skill.body}
 
 ${args}` : skill.body;
-  return { type: "skill", message: { role: "user", content } };
+  return { type: "skill", message: { role: "user", content }, skill };
+}
+
+// src/skills/executor.ts
+import { exec as exec2 } from "child_process";
+import { dirname as dirname4 } from "path";
+import { promisify } from "util";
+
+// src/skills/loader.ts
+import { readFile as readFile6, readdir as readdir3, stat as stat3 } from "fs/promises";
+import { join as join5, dirname as dirname3, basename, resolve as resolve3, sep as sep3 } from "path";
+function parseFrontmatter(content) {
+  const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+  const match = FRONTMATTER_RE.exec(content);
+  if (!match) {
+    return { data: {}, body: content };
+  }
+  const rawFrontmatter = match[1];
+  const body = match[2] ?? "";
+  const data = {};
+  for (const line of rawFrontmatter.split(/\r?\n/)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key) {
+      data[key] = value;
+    }
+  }
+  return { data, body };
+}
+function isTrustedSkillPath(skillDir, trustedDirs) {
+  const normalized = resolve3(skillDir);
+  for (const trusted of trustedDirs) {
+    const normalizedTrusted = resolve3(trusted);
+    if (normalized === normalizedTrusted || normalized.startsWith(normalizedTrusted + sep3)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    await stat3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTools(skillDir) {
+  const toolsJsonPath = join5(skillDir, "tools.json");
+  if (!await fileExists(toolsJsonPath)) return [];
+  let raw;
+  try {
+    raw = await readFile6(toolsJsonPath, "utf-8");
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const tools = [];
+  for (const item of parsed) {
+    if (typeof item === "object" && item !== null && typeof item["name"] === "string" && typeof item["description"] === "string") {
+      const entry = item;
+      tools.push({
+        name: entry["name"],
+        description: entry["description"],
+        parameters: entry["parameters"] ?? {},
+        scriptPath: join5(skillDir, `${entry["name"]}.sh`)
+      });
+    }
+  }
+  return tools;
+}
+async function loadSkillFile(skillMdPath) {
+  const content = await readFile6(skillMdPath, "utf-8");
+  const { data, body } = parseFrontmatter(content);
+  const skillDir = dirname3(skillMdPath);
+  const dirName = basename(skillDir);
+  const [tools, hasPreScript, hasPostScript] = await Promise.all([
+    loadTools(skillDir),
+    fileExists(join5(skillDir, "pre.sh")),
+    fileExists(join5(skillDir, "post.sh"))
+  ]);
+  return {
+    name: data["name"] ?? dirName,
+    description: data["description"] ?? "",
+    body,
+    source: skillMdPath,
+    tools,
+    preScript: hasPreScript ? join5(skillDir, "pre.sh") : null,
+    postScript: hasPostScript ? join5(skillDir, "post.sh") : null
+  };
+}
+async function loadSkillsFromDir(dir) {
+  let entries;
+  try {
+    entries = await readdir3(dir);
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries) {
+    const entryPath = join5(dir, entry);
+    let entryStat;
+    try {
+      entryStat = await stat3(entryPath);
+    } catch {
+      continue;
+    }
+    if (!entryStat.isDirectory()) continue;
+    const skillMdPath = join5(entryPath, "SKILL.md");
+    try {
+      await stat3(skillMdPath);
+    } catch {
+      continue;
+    }
+    const skill = await loadSkillFile(skillMdPath);
+    skills.push(skill);
+  }
+  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// src/skills/executor.ts
+var execAsync = promisify(exec2);
+var SecurityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+  }
+};
+async function runScript(scriptPath, args) {
+  const quotedArgs = args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
+  const cmd = quotedArgs ? `${scriptPath} ${quotedArgs}` : scriptPath;
+  const { stdout } = await execAsync(cmd);
+  return stdout;
+}
+async function executePreScript(skill, trustedDirs) {
+  if (!skill.preScript) {
+    throw new Error("No pre script configured for this skill");
+  }
+  const skillDir = dirname4(skill.source);
+  if (!isTrustedSkillPath(skillDir, trustedDirs)) {
+    throw new SecurityError(
+      `Untrusted skill path: ${skillDir} is not in trusted dirs`
+    );
+  }
+  return runScript(skill.preScript, []);
+}
+async function executeSkillTool(tool, args, trustedDirs) {
+  const scriptDir = dirname4(tool.scriptPath);
+  if (!isTrustedSkillPath(scriptDir, trustedDirs)) {
+    throw new SecurityError(
+      `Untrusted tool script path: ${tool.scriptPath}`
+    );
+  }
+  return runScript(tool.scriptPath, [JSON.stringify(args)]);
 }
 
 // src/ui/StatusBar.tsx
@@ -822,9 +1722,9 @@ import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-run
 function SkillAutocomplete({
   suggestions,
   selectedIndex,
-  isOpen: isOpen2
+  isOpen: isOpen3
 }) {
-  if (!isOpen2 || suggestions.length === 0) {
+  if (!isOpen3 || suggestions.length === 0) {
     return /* @__PURE__ */ jsx4(Fragment2, {});
   }
   return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", children: suggestions.map((skill, idx) => {
@@ -843,6 +1743,27 @@ function SkillAutocomplete({
   }) });
 }
 
+// src/ui/FileAutocomplete.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function FileAutocomplete({
+  suggestions,
+  selectedIndex,
+  isOpen: isOpen3
+}) {
+  if (!isOpen3 || suggestions.length === 0) {
+    return /* @__PURE__ */ jsx5(Fragment3, {});
+  }
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", children: suggestions.map((entry, idx) => {
+    const selected = idx === selectedIndex;
+    const label = entry.isDir ? entry.path + "/" : entry.path;
+    return /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: selected ? "yellow" : void 0, bold: selected, children: selected ? "> " : "  " }),
+      /* @__PURE__ */ jsx5(Text5, { color: selected ? "yellow" : void 0, bold: selected, children: label })
+    ] }, entry.path);
+  }) });
+}
+
 // src/ui/autocompleteLogic.ts
 function getInitialState() {
   return { query: "", selectedIndex: 0, dismissed: false };
@@ -870,12 +1791,166 @@ function dismiss(state) {
   return { ...state, dismissed: true };
 }
 
+// src/ui/fileCompletion.ts
+import * as fs8 from "fs/promises";
+import * as path6 from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function isHidden(name) {
+  return name.startsWith(".");
+}
+async function walkDir2(dir, root, results, maxResults) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = await fs8.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) return;
+    if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
+    const relPath = path6.relative(root, path6.join(dir, entry.name));
+    if (entry.isDirectory()) {
+      results.push({ path: relPath, isDir: true });
+      await walkDir2(path6.join(dir, entry.name), root, results, maxResults);
+    } else {
+      results.push({ path: relPath, isDir: false });
+    }
+  }
+}
+async function listFilesForQuery(query, cwd, maxResults = 50) {
+  if (path6.isAbsolute(query)) {
+    return listAbsolute(query, maxResults);
+  }
+  const all = [];
+  await walkDir2(cwd, cwd, all, maxResults * 4);
+  const filtered = query ? all.filter((e) => e.path.includes(query)) : all;
+  return filtered.slice(0, maxResults);
+}
+async function listAbsolute(query, maxResults) {
+  let dir = query;
+  let filter = "";
+  try {
+    const stat5 = await fs8.stat(dir);
+    if (!stat5.isDirectory()) {
+      filter = path6.basename(dir);
+      dir = path6.dirname(dir);
+    }
+  } catch {
+    filter = path6.basename(dir);
+    dir = path6.dirname(dir);
+  }
+  let entries;
+  try {
+    entries = await fs8.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
+    if (filter && !entry.name.includes(filter)) continue;
+    results.push({
+      path: path6.join(dir, entry.name),
+      isDir: entry.isDirectory()
+    });
+    if (results.length >= maxResults) break;
+  }
+  return results;
+}
+function extractAtQuery(text) {
+  const lastAt = text.lastIndexOf("@");
+  if (lastAt === -1) return null;
+  const after = text.slice(lastAt + 1);
+  const spaceIdx = after.indexOf(" ");
+  if (spaceIdx !== -1) return null;
+  return after;
+}
+async function expandFileRefs(text, cwd) {
+  const atPattern = /@([\w./\-]+)/g;
+  const replacements = [];
+  let match;
+  atPattern.lastIndex = 0;
+  while ((match = atPattern.exec(text)) !== null) {
+    const filePath = match[1];
+    const fullPath = path6.isAbsolute(filePath) ? filePath : path6.join(cwd, filePath);
+    let replacement;
+    try {
+      const content = await fs8.readFile(fullPath, "utf8");
+      replacement = `\`\`\`
+// @${filePath}
+${content}
+\`\`\``;
+    } catch {
+      replacement = `@${filePath} (not found)`;
+    }
+    replacements.push({ start: match.index, end: match.index + match[0].length, replacement });
+  }
+  if (replacements.length === 0) return text;
+  let result = text;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const { start, end, replacement } = replacements[i];
+    result = result.slice(0, start) + replacement + result.slice(end);
+  }
+  return result;
+}
+
+// src/ui/fileAutocompleteLogic.ts
+function getInitialState2() {
+  return { query: "", selectedIndex: 0, dismissed: false };
+}
+function handleInputChange2(_state, newText) {
+  return { query: newText, selectedIndex: 0, dismissed: false };
+}
+function isOpen2(state, suggestions) {
+  if (state.dismissed) return false;
+  if (suggestions.length === 0) return false;
+  return extractAtQuery(state.query) !== null;
+}
+function moveUp2(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex - 1 + count) % count };
+}
+function moveDown2(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex + 1) % count };
+}
+function dismiss2(state) {
+  return { ...state, dismissed: true };
+}
+function confirmSelection(inputText, selectedPath) {
+  const lastAt = inputText.lastIndexOf("@");
+  if (lastAt === -1) return inputText;
+  const prefix = inputText.slice(0, lastAt);
+  return `${prefix}@${selectedPath} `;
+}
+
+// src/ui/mouseInput.ts
+var SGR_MOUSE_RE = /^\x1b\[<(\d+);\d+;\d+[Mm]/;
+function parseMouseScroll(data) {
+  const s = typeof data === "string" ? data : data.toString("binary");
+  if (!s) return null;
+  const sgrMatch = SGR_MOUSE_RE.exec(s);
+  if (sgrMatch) {
+    const cb = parseInt(sgrMatch[1], 10);
+    if (cb === 64) return { direction: "up" };
+    if (cb === 65) return { direction: "down" };
+    return null;
+  }
+  if (s.length >= 6 && s.charCodeAt(0) === 27 && s[1] === "[" && s[2] === "M") {
+    const buttonByte = s.charCodeAt(3);
+    if (buttonByte === 96) return { direction: "up" };
+    if (buttonByte === 97) return { direction: "down" };
+    return null;
+  }
+  return null;
+}
+
 // src/ui/App.tsx
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, llmClient }) {
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, trustedSkillDirs: trustedSkillDirs2 = [], initialMessages: initialMessages2 = [], llmClient }) {
   const { stdout } = useStdout();
+  const { stdin } = useStdin();
   const historyMaxHeight = Math.max(5, (stdout?.rows ?? 24) - 4);
-  const [messages, setMessages] = useState3([]);
+  const [messages, setMessages] = useState3(initialMessages2);
   const [status, setStatus] = useState3("idle");
   const contextLimit = getContextLimit(config2.model, config2.contextLimit);
   const [tokenUsage, setTokenUsage] = useState3({
@@ -899,10 +1974,18 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       0
     );
   }, [messages, expandTools, stdout?.columns]);
+  const totalLinesRef = useRef2(totalLines);
+  totalLinesRef.current = totalLines;
   const pendingConfirmRef = useRef2(null);
+  const abortControllerRef = useRef2(null);
   const llmRef = useRef2(llmClient ?? createLLMClient(config2));
   const inputRef = useRef2(null);
+  const [skillTools, setSkillTools] = useState3([]);
+  const skillToolsRef = useRef2([]);
+  skillToolsRef.current = skillTools;
   const [acState, setAcState] = useState3(getInitialState());
+  const [fileAcState, setFileAcState] = useState3(getInitialState2());
+  const [fileSuggestions, setFileSuggestions] = useState3([]);
   const loggerRef = useRef2(null);
   const loggedCountRef = useRef2(0);
   useEffect3(() => {
@@ -927,7 +2010,67 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
     loggedCountRef.current = messages.length;
   }, [messages]);
+  useEffect3(() => {
+    if (!stdin || !stdout) return;
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    const onMouseData = (data) => {
+      const event = parseMouseScroll(data);
+      if (!event) return;
+      if (event.direction === "up") {
+        setScrollOffset((prev) => Math.min(prev + 3, Math.max(0, totalLinesRef.current - 1)));
+      } else {
+        setScrollOffset((prev) => Math.max(0, prev - 3));
+      }
+    };
+    stdin.on("data", onMouseData);
+    return () => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+      stdin.off("data", onMouseData);
+    };
+  }, [stdin, stdout]);
+  useEffect3(() => {
+    const atFragment = extractAtQuery(fileAcState.query);
+    if (atFragment === null) {
+      setFileSuggestions([]);
+      return;
+    }
+    let cancelled = false;
+    listFilesForQuery(atFragment, process.cwd()).then((entries) => {
+      if (!cancelled) setFileSuggestions(entries);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [fileAcState.query]);
   useInput2((input, key) => {
+    if (key.escape && status === "thinking" && abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      return;
+    }
+    const fileOpen = isOpen2(fileAcState, fileSuggestions);
+    if (fileOpen) {
+      if (key.upArrow) {
+        setFileAcState((prev) => moveUp2(prev, fileSuggestions.length));
+        return;
+      }
+      if (key.downArrow) {
+        setFileAcState((prev) => moveDown2(prev, fileSuggestions.length));
+        return;
+      }
+      if (key.escape) {
+        setFileAcState((prev) => dismiss2(prev));
+        return;
+      }
+      if (key.tab) {
+        const selected = fileSuggestions[fileAcState.selectedIndex];
+        if (selected) {
+          const newText = confirmSelection(fileAcState.query, selected.path);
+          inputRef.current?.fill(newText);
+        }
+        return;
+      }
+    }
     const skillList = registry2?.list() ?? [];
     const suggestions = computeSuggestions(skillList, acState);
     const open = isOpen(acState, suggestions);
@@ -999,10 +2142,10 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
   });
   const confirm = useCallback((prompt) => {
-    return new Promise((resolve2) => {
+    return new Promise((resolve5) => {
       setStatus("awaiting_confirm");
       setConfirmPrompt(prompt);
-      pendingConfirmRef.current = { resolve: resolve2 };
+      pendingConfirmRef.current = { resolve: resolve5 };
     });
   }, []);
   const runLlmLoop = useCallback(
@@ -1017,44 +2160,69 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         // autoMode=true 时自动同意 normal 级工具调用，无需用户确认
         autoApproveNormal: autoMode2
       };
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
       let currentMessages = history;
       let continueLoop = true;
-      while (continueLoop) {
+      let wasAborted = false;
+      while (continueLoop && !wasAborted) {
         continueLoop = false;
         setStatus("thinking");
         let assistantText = "";
         let assistantReasoning;
         const toolCalls = [];
-        for await (const chunk of llmRef.current.stream(currentMessages, [BASH_TOOL])) {
-          if (chunk.text) {
-            assistantText += chunk.text;
-            setMessages((prev) => {
-              const last = prev[prev.length - 1];
-              if (last?.role === "assistant" && !last.tool_calls) {
-                return [...prev.slice(0, -1), { ...last, content: assistantText }];
+        const dynamicTools = skillToolsRef.current.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.parameters }
+        }));
+        try {
+          for await (const chunk of llmRef.current.stream(currentMessages, [BASH_TOOL, READ_TOOL, WRITE_TOOL, EDIT_TOOL, GLOB_TOOL, GREP_TOOL, APPLY_PATCH_TOOL, TODO_TOOL, ...dynamicTools], abortController.signal)) {
+            if (chunk.text) {
+              assistantText += chunk.text;
+              setMessages((prev) => {
+                const last = prev[prev.length - 1];
+                if (last?.role === "assistant" && !last.tool_calls) {
+                  return [...prev.slice(0, -1), { ...last, content: assistantText }];
+                }
+                return [...prev, { role: "assistant", content: assistantText }];
+              });
+            }
+            if (chunk.done) {
+              if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
+              if (chunk.reasoning) assistantReasoning = chunk.reasoning;
+              if (chunk.usage) {
+                setTokenUsage({
+                  used: chunk.usage.totalTokens,
+                  estimated: false,
+                  limit: getContextLimit(config2.model, config2.contextLimit)
+                });
               }
-              return [...prev, { role: "assistant", content: assistantText }];
-            });
+            } else {
+              const estimatedUsed = Math.floor(
+                currentMessages.reduce(
+                  (acc, m) => acc + (typeof m.content === "string" ? m.content.length : 0),
+                  0
+                ) * 0.25 + assistantText.length * 0.25
+              );
+              setTokenUsage((prev) => ({ ...prev, used: estimatedUsed, estimated: true }));
+            }
           }
-          if (chunk.done) {
-            if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
-            if (chunk.reasoning) assistantReasoning = chunk.reasoning;
-            if (chunk.usage) {
-              setTokenUsage({
-                used: chunk.usage.totalTokens,
-                estimated: false,
-                limit: getContextLimit(config2.model, config2.contextLimit)
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError") {
+            if (assistantText) {
+              setMessages((prev) => {
+                const last = prev[prev.length - 1];
+                const partial = { role: "assistant", content: assistantText };
+                return last?.role === "assistant" && !last.tool_calls ? [...prev.slice(0, -1), partial] : [...prev, partial];
               });
             }
-          } else {
-            const estimatedUsed = Math.floor(
-              currentMessages.reduce(
-                (acc, m) => acc + (typeof m.content === "string" ? m.content.length : 0),
-                0
-              ) * 0.25 + assistantText.length * 0.25
-            );
-            setTokenUsage((prev) => ({ ...prev, used: estimatedUsed, estimated: true }));
+            wasAborted = true;
+            setStatus("idle");
+            setToolName(void 0);
+            abortControllerRef.current = null;
+            return;
           }
+          throw err;
         }
         if (toolCalls.length > 0) {
           const assistantMsg = {
@@ -1077,6 +2245,8 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           currentMessages = [...currentMessages, assistantMsg];
           setStatus("tool_calling");
           for (const tc of toolCalls) {
+            setToolName(tc.name);
+            let toolResult;
             if (tc.name === "bash") {
               let args;
               try {
@@ -1084,16 +2254,48 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
               } catch {
                 args = { command: "" };
               }
-              setToolName(tc.name);
-              const toolResult = await handleBashTool(args.command, deps);
-              const toolMsg = {
-                role: "tool",
-                tool_call_id: tc.id,
-                content: toolResult
-              };
-              setMessages((prev) => [...prev, toolMsg]);
-              currentMessages = [...currentMessages, toolMsg];
+              toolResult = await handleBashTool(args.command, deps);
+            } else if (tc.name === "read") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await readFile2(args);
+            } else if (tc.name === "write") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await writeFile2(args);
+            } else if (tc.name === "edit") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await editFile(args);
+            } else if (tc.name === "glob") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await globFiles(args);
+            } else if (tc.name === "grep") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await grepFiles(args);
+            } else if (tc.name === "apply_patch") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await applyPatch(args);
+            } else if (tc.name === "todo") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = todo(args);
+            } else {
+              const skillTool = skillToolsRef.current.find((t) => t.name === tc.name);
+              if (skillTool) {
+                let toolArgs = {};
+                try {
+                  toolArgs = JSON.parse(tc.arguments);
+                } catch {
+                }
+                toolResult = await executeSkillTool(skillTool, toolArgs, trustedSkillDirs2);
+              } else {
+                toolResult = `Unknown tool: ${tc.name}`;
+              }
             }
+            const toolMsg = {
+              role: "tool",
+              tool_call_id: tc.id,
+              content: toolResult
+            };
+            setMessages((prev) => [...prev, toolMsg]);
+            currentMessages = [...currentMessages, toolMsg];
           }
           continueLoop = true;
         } else {
@@ -1123,11 +2325,12 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       }
       setStatus("idle");
       setToolName(void 0);
+      abortControllerRef.current = null;
     },
     [confirm, config2.dangerousPatterns, autoMode2]
   );
   const handleSubmit = useCallback(
-    (text) => {
+    async (text) => {
       const trimmed = text.trim();
       if (status === "awaiting_confirm") {
         const pending = pendingConfirmRef.current;
@@ -1153,6 +2356,18 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           return;
         }
         if (skillResult.type === "skill") {
+          const { skill } = skillResult;
+          setSkillTools(skill.tools);
+          if (skill.preScript) {
+            try {
+              await executePreScript(skill, trustedSkillDirs2);
+            } catch (preErr) {
+              setMessages((prev) => [
+                ...prev,
+                { role: "assistant", content: `[pre.sh error] ${String(preErr)}` }
+              ]);
+            }
+          }
           const nextMessages2 = [...messages, skillResult.message];
           setMessages(nextMessages2);
           runLlmLoop(nextMessages2).catch((err) => {
@@ -1166,7 +2381,12 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           return;
         }
       }
-      const userMsg = { role: "user", content: trimmed };
+      let content = trimmed;
+      try {
+        content = await expandFileRefs(trimmed, process.cwd());
+      } catch {
+      }
+      const userMsg = { role: "user", content };
       const nextMessages = [...messages, userMsg];
       setMessages(nextMessages);
       runLlmLoop(nextMessages).catch((err) => {
@@ -1174,7 +2394,6 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         setToolName(void 0);
         setMessages((prev) => [
           ...prev,
-          // 错误消息前缀 "[error]" 便于用户识别和日志筛选
           { role: "assistant", content: `[error] ${String(err)}` }
         ]);
       });
@@ -1190,12 +2409,13 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
     if (status !== "awaiting_confirm") {
       setAcState((prev) => handleInputChange(prev, text));
+      setFileAcState((prev) => handleInputChange2(prev, text));
     }
   }, [status]);
   const skillSuggestions = registry2 ? computeSuggestions(registry2.list(), acState) : [];
   const acOpen = isOpen(acState, skillSuggestions);
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", height: "100%", children: [
-    /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx6(Box6, { flexGrow: 1, flexDirection: "column", justifyContent: "flex-end", children: /* @__PURE__ */ jsx6(
       ConversationHistory,
       {
         messages,
@@ -1204,8 +2424,8 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         terminalWidth: stdout?.columns,
         scrollOffset
       }
-    ),
-    /* @__PURE__ */ jsx5(
+    ) }),
+    /* @__PURE__ */ jsx6(
       StatusBar,
       {
         status,
@@ -1215,7 +2435,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         tokenUsage
       }
     ),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
       SkillAutocomplete,
       {
         suggestions: skillSuggestions,
@@ -1223,7 +2443,15 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         isOpen: acOpen
       }
     ),
-    /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx6(
+      FileAutocomplete,
+      {
+        suggestions: fileSuggestions,
+        selectedIndex: fileAcState.selectedIndex,
+        isOpen: isOpen2(fileAcState, fileSuggestions)
+      }
+    ),
+    /* @__PURE__ */ jsx6(
       Input_default,
       {
         ref: inputRef,
@@ -1236,6 +2464,64 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   ] });
 }
 
+// src/replay.ts
+var KNOWN_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system"]);
+function entryToMessage(entry) {
+  const { role, content } = entry;
+  if (typeof role !== "string" || !KNOWN_ROLES.has(role)) return null;
+  if (role === "user" || role === "system") {
+    return { role, content: content ?? "" };
+  }
+  if (role === "assistant") {
+    const msg = {
+      role: "assistant",
+      content: content ?? null
+    };
+    if (Array.isArray(entry.tool_calls)) {
+      msg.tool_calls = entry.tool_calls;
+    }
+    return msg;
+  }
+  if (role === "tool") {
+    if (typeof entry.tool_call_id !== "string") return null;
+    return {
+      role: "tool",
+      tool_call_id: entry.tool_call_id,
+      content: content ?? ""
+    };
+  }
+  return null;
+}
+function parseReplayLog(content) {
+  const messages = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry;
+    try {
+      entry = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const msg = entryToMessage(entry);
+    if (msg) messages.push(msg);
+  }
+  return messages;
+}
+function truncateToTurn(messages, turn) {
+  if (turn <= 0) return [];
+  let userCount = 0;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "user") {
+      userCount++;
+      if (userCount > turn) {
+        return messages.slice(0, i);
+      }
+    }
+  }
+  return messages.slice();
+}
+
 // src/skills/registry.ts
 var SkillRegistry = class {
   skills = /* @__PURE__ */ new Map();
@@ -1259,67 +2545,32 @@ var SkillRegistry = class {
   }
 };
 
-// src/skills/loader.ts
-import { readFile, readdir, stat } from "fs/promises";
-import { join as join3, dirname, basename } from "path";
-function parseFrontmatter(content) {
-  const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-  const match = FRONTMATTER_RE.exec(content);
-  if (!match) {
-    return { data: {}, body: content };
-  }
-  const rawFrontmatter = match[1];
-  const body = match[2] ?? "";
-  const data = {};
-  for (const line of rawFrontmatter.split(/\r?\n/)) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    const value = line.slice(colonIdx + 1).trim();
-    if (key) {
-      data[key] = value;
-    }
-  }
-  return { data, body };
+// src/pipe.ts
+function emit(out, event) {
+  out.write(JSON.stringify(event) + "\n");
 }
-async function loadSkillFile(skillMdPath) {
-  const content = await readFile(skillMdPath, "utf-8");
-  const { data, body } = parseFrontmatter(content);
-  const dirName = basename(dirname(skillMdPath));
-  return {
-    name: data["name"] ?? dirName,
-    description: data["description"] ?? "",
-    body,
-    source: skillMdPath
-  };
-}
-async function loadSkillsFromDir(dir) {
-  let entries;
-  try {
-    entries = await readdir(dir);
-  } catch {
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries) {
-    const entryPath = join3(dir, entry);
-    let entryStat;
-    try {
-      entryStat = await stat(entryPath);
-    } catch {
-      continue;
+async function runPipe(prompt, llm, out = process.stdout) {
+  const messages = [{ role: "user", content: prompt }];
+  for await (const chunk of llm.stream(messages)) {
+    if (chunk.text) {
+      emit(out, { type: "chunk", text: chunk.text });
     }
-    if (!entryStat.isDirectory()) continue;
-    const skillMdPath = join3(entryPath, "SKILL.md");
-    try {
-      await stat(skillMdPath);
-    } catch {
-      continue;
+    if (chunk.done) {
+      const doneEvent = chunk.usage ? { type: "done", usage: chunk.usage } : { type: "done" };
+      emit(out, doneEvent);
     }
-    const skill = await loadSkillFile(skillMdPath);
-    skills.push(skill);
   }
-  return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+function readStdin() {
+  return new Promise((resolve5, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve5(data.trim()));
+    process.stdin.on("error", reject);
+  });
 }
 
 // src/index.ts
@@ -1329,6 +2580,9 @@ var VERSION = version;
 var rawArgs = process.argv.slice(2);
 var autoMode = false;
 var cliLogDir;
+var replayFile;
+var forkSpec;
+var pipeMode = false;
 for (let i = 0; i < rawArgs.length; i++) {
   const arg = rawArgs[i];
   if (arg === "-v" || arg === "--version") {
@@ -1345,6 +2599,30 @@ for (let i = 0; i < rawArgs.length; i++) {
       i++;
     }
   }
+  if (arg === "--replay") {
+    const next = rawArgs[i + 1];
+    if (next && !next.startsWith("-")) {
+      replayFile = next;
+      i++;
+    }
+  }
+  if (arg === "--pipe") {
+    pipeMode = true;
+  }
+  if (arg === "--fork") {
+    const next = rawArgs[i + 1];
+    if (next && !next.startsWith("-")) {
+      const colonIdx = next.lastIndexOf(":");
+      if (colonIdx > 0) {
+        const file = next.slice(0, colonIdx);
+        const turn = parseInt(next.slice(colonIdx + 1), 10);
+        if (!isNaN(turn)) {
+          forkSpec = { file, turn };
+        }
+      }
+      i++;
+    }
+  }
 }
 var config = loadConfig();
 var finalConfig = cliLogDir ? { ...config, logDir: cliLogDir } : config;
@@ -1354,15 +2632,40 @@ if (!finalConfig.apiKey) {
   );
   process.exit(1);
 }
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var builtinSkillsDir = resolve(__dirname, "../skills");
-var userSkillsDir = resolve(process.env.HOME ?? "~", ".ecode/skills");
-var projectSkillsDir = resolve(process.cwd(), ".ecode/skills");
+var initialMessages = [];
+if (replayFile) {
+  try {
+    const raw = readFileSync2(replayFile, "utf-8");
+    initialMessages = parseReplayLog(raw);
+  } catch (err) {
+    console.error(`Error reading replay file: ${err}`);
+    process.exit(1);
+  }
+} else if (forkSpec) {
+  try {
+    const raw = readFileSync2(forkSpec.file, "utf-8");
+    initialMessages = truncateToTurn(parseReplayLog(raw), forkSpec.turn);
+  } catch (err) {
+    console.error(`Error reading fork file: ${err}`);
+    process.exit(1);
+  }
+}
+var __dirname = dirname6(fileURLToPath(import.meta.url));
+var builtinSkillsDir = resolve4(__dirname, "../skills");
+var userSkillsDir = resolve4(process.env.HOME ?? "~", ".ecode/skills");
+var projectSkillsDir = resolve4(process.cwd(), ".ecode/skills");
 var registry = new SkillRegistry();
 for (const dir of [builtinSkillsDir, userSkillsDir, projectSkillsDir]) {
   const skills = await loadSkillsFromDir(dir);
   for (const skill of skills) registry.register(skill);
 }
+var trustedSkillDirs = [builtinSkillsDir, userSkillsDir, projectSkillsDir];
+if (pipeMode) {
+  const prompt = await readStdin();
+  const llm = createLLMClient(finalConfig);
+  await runPipe(prompt, llm);
+  process.exit(0);
+}
 if (process.stdout.isTTY) {
   process.stdout.write("\x1B[?1049h");
   const exitAltScreen = () => process.stdout.write("\x1B[?1049l");
@@ -1380,4 +2683,4 @@ if (process.stdout.isTTY) {
     process.exit(0);
   });
 }
-render(React4.createElement(App, { config: finalConfig, version: VERSION, autoMode, registry }));
+render(React4.createElement(App, { config: finalConfig, version: VERSION, autoMode, registry, trustedSkillDirs, initialMessages }));