@zqagent/core 0.1.30 → 0.2.5

package/dist/tools/git.js

@@ -1,88 +1,441 @@
 // src/tools/git.ts
-import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+
+// src/tools/execAsync.ts
+import { spawn } from "child_process";
+
+// src/tools/killTree.ts
+import { spawnSync } from "child_process";
+function killTree(pid) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+
+// src/tools/execAsync.ts
+var liveChildren = /* @__PURE__ */ new Set();
+var exitCleanupInstalled = false;
+function trackChild(pid) {
+  if (!pid) return;
+  liveChildren.add(pid);
+  if (exitCleanupInstalled) return;
+  exitCleanupInstalled = true;
+  process.once("exit", () => {
+    for (const p of liveChildren) killTree(p);
+  });
+}
+var DEFAULT_MAX_BUFFER = 1024 * 1024 * 5;
+var KILL_GRACE_MS = 1e3;
+function makeSink(maxBuffer) {
+  const chunks = [];
+  let len = 0;
+  let over = false;
+  return {
+    push(chunk) {
+      if (len >= maxBuffer) {
+        over = true;
+        return;
+      }
+      const room = maxBuffer - len;
+      if (chunk.length > room) {
+        chunks.push(chunk.subarray(0, room));
+        len = maxBuffer;
+        over = true;
+        return;
+      }
+      chunks.push(chunk);
+      len += chunk.length;
+    },
+    done: () => Buffer.concat(chunks),
+    over: () => over
+  };
+}
+function execAsync(file, argv, opts = {}) {
+  return new Promise((resolve2) => {
+    const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    const out = makeSink(maxBuffer);
+    const err = makeSink(maxBuffer);
+    if (opts.signal?.aborted) {
+      resolve2({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        timedOut: false,
+        truncated: false,
+        aborted: true
+      });
+      return;
+    }
+    let child;
+    try {
+      child = spawn(file, argv, {
+        ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+        ...opts.env !== void 0 ? { env: opts.env } : {},
+        // 自成进程组（POSIX）：超时/中断时用 killTree 一次收掉整棵进程树
+        detached: process.platform !== "win32",
+        stdio: [opts.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve2({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        error: e,
+        timedOut: false,
+        truncated: false
+      });
+      return;
+    }
+    trackChild(child.pid);
+    let settled = false;
+    let timedOut = false;
+    let aborted = false;
+    let spawnError;
+    let timer = null;
+    let graceTimer = null;
+    const onAbort = () => {
+      aborted = true;
+      killAndSettle();
+    };
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (graceTimer) clearTimeout(graceTimer);
+      if (child.pid !== void 0) liveChildren.delete(child.pid);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const result = {
+        status,
+        stdout: out.done(),
+        stderr: err.done(),
+        timedOut,
+        truncated: out.over() || err.over()
+      };
+      if (aborted) result.aborted = true;
+      if (spawnError) result.error = spawnError;
+      resolve2(result);
+    };
+    const killAndSettle = () => {
+      killTree(child.pid);
+      if (settled || graceTimer) return;
+      graceTimer = setTimeout(() => {
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        finish(null);
+      }, KILL_GRACE_MS);
+    };
+    if (opts.timeoutMs !== void 0 && opts.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        killAndSettle();
+      }, opts.timeoutMs);
+    }
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.on("data", (c) => out.push(c));
+    child.stderr?.on("data", (c) => err.push(c));
+    child.on("error", (e) => {
+      spawnError = e;
+      if (child.pid === void 0) finish(null);
+    });
+    if (opts.input !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(opts.input);
+    }
+    child.on("close", (code) => finish(code));
+  });
+}
+
+// src/tools/shellBackground.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_BUFFER_LIMIT = 64 * 1024;
+var RingBuffer = class {
+  constructor(limit = DEFAULT_BUFFER_LIMIT) {
+    this.limit = limit;
+  }
+  limit;
+  chunks = [];
+  size = 0;
+  add(chunk) {
+    if (!chunk) return;
+    this.chunks.push(chunk);
+    this.size += chunk.length;
+    while (this.size > this.limit && this.chunks.length > 1) {
+      this.size -= this.chunks.shift().length;
+    }
+    if (this.size > this.limit) {
+      const joined = this.chunks.join("");
+      this.chunks = [joined.slice(-this.limit)];
+      this.size = this.chunks[0].length;
+    }
+  }
+  get() {
+    const joined = this.chunks.join("");
+    return joined.length > this.limit ? joined.slice(-this.limit) : joined;
+  }
+};
+var ShellTaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  seq = 0;
+  cleanupInstalled = false;
+  /** 启动一个后台任务，立即返回快照（不等退出） */
+  start(opts) {
+    this.installCleanup();
+    const id = `shell-${++this.seq}-${Date.now().toString(36)}`;
+    const child = spawn2(opts.file, opts.argv, {
+      cwd: opts.cwd,
+      env: opts.env,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const task = {
+      id,
+      command: opts.command,
+      scope: opts.scope ?? null,
+      child,
+      stdout: new RingBuffer(),
+      stderr: new RingBuffer(),
+      status: "running",
+      exitCode: null,
+      signal: null,
+      startedAt: Date.now(),
+      endedAt: null
+    };
+    this.tasks.set(id, task);
+    child.stdout?.on("data", (d) => task.stdout.add(d.toString("utf-8")));
+    child.stderr?.on("data", (d) => task.stderr.add(d.toString("utf-8")));
+    child.on("error", (err) => task.stderr.add(`[spawn error] ${err.message}
+`));
+    child.on("exit", (code, signal) => {
+      task.exitCode = code;
+      task.signal = signal;
+      task.endedAt = Date.now();
+      if (task.status !== "killed") task.status = "exited";
+    });
+    child.unref();
+    return this.snapshot(task);
+  }
+  /** 读取任务输出与状态 */
+  output(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    return this.snapshot(task);
+  }
+  /** 终止任务（进程树）并返回快照；传 scope 时只允许终止该归属下的任务 */
+  kill(taskId, scope) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    if (scope !== void 0 && task.scope !== scope) {
+      return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    }
+    if (task.status === "running") {
+      task.status = "killed";
+      task.endedAt = Date.now();
+      killTree(task.child.pid);
+    }
+    return this.snapshot(task);
+  }
+  /** 列出任务快照（调试/展示用）；传 scope 时只返回该归属下的任务 */
+  list(scope) {
+    const all = [...this.tasks.values()];
+    return (scope === void 0 ? all : all.filter((t) => t.scope === scope)).map(
+      (t) => this.snapshot(t)
+    );
+  }
+  /** 终止全部任务（进程退出时调用） */
+  disposeAll() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "running") {
+        task.status = "killed";
+        killTree(task.child.pid);
+      }
+    }
+  }
+  snapshot(task) {
+    return {
+      task_id: task.id,
+      command: task.command,
+      status: task.status,
+      running: task.status === "running",
+      exit_code: task.exitCode,
+      signal: task.signal,
+      stdout: task.stdout.get(),
+      stderr: task.stderr.get(),
+      duration_ms: (task.endedAt ?? Date.now()) - task.startedAt
+    };
+  }
+  installCleanup() {
+    if (this.cleanupInstalled) return;
+    this.cleanupInstalled = true;
+    process.once("exit", () => this.disposeAll());
+  }
+};
+
+// src/tools/shell.ts
+var MAX_BUFFER = 1024 * 1024 * 5;
+function decodeOutput(buf) {
+  if (!buf || buf.length === 0) return "";
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(buf);
+  } catch {
+    for (const enc of ["gbk", "big5", "shift_jis", "latin1"]) {
+      try {
+        return new TextDecoder(enc).decode(buf);
+      } catch {
+      }
+    }
+    return buf.toString("latin1");
+  }
+}
+var shellTasks = new ShellTaskManager();
+
+// src/tools/git.ts
+async function runGit(repoDir, args, timeout = 15e3) {
+  const res = await execAsync("git", ["-c", "core.quotepath=false", ...args], {
+    cwd: repoDir,
+    timeoutMs: timeout,
+    maxBuffer: 1024 * 1024 * 5,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  return {
+    status: res.status ?? 1,
+    stdout: decodeOutput(res.stdout),
+    stderr: decodeOutput(res.stderr) || (res.error?.message ?? "")
+  };
+}
+async function resolveRepoRoot(workspace, pathArg) {
+  let dir = workspace;
+  if (pathArg) {
+    const abs = path.resolve(workspace, pathArg);
+    try {
+      dir = fs.statSync(abs).isDirectory() ? abs : path.dirname(abs);
+    } catch {
+      dir = abs;
+    }
+  }
+  const res = await runGit(dir, ["rev-parse", "--show-toplevel"], 1e4);
+  if (res.status === 0 && res.stdout.trim()) return res.stdout.trim();
+  return workspace;
+}
+function repoDirArg(workspace, raw) {
+  if (typeof raw !== "string") return void 0;
+  const v = raw.trim();
+  if (!v) return void 0;
+  const base = path.resolve(workspace);
+  const abs = path.resolve(base, v);
+  const rel = path.relative(base, abs);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return void 0;
+  return abs;
+}
+function toPathspec(repoRoot, workspace, pathArg) {
+  if (!pathArg) return null;
+  const abs = path.resolve(workspace, pathArg);
+  let rel = path.relative(repoRoot, abs);
+  if (rel === "") return ".";
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    try {
+      const realRepo = fs.realpathSync(repoRoot);
+      const realAbs = fs.realpathSync(abs);
+      const rel2 = path.relative(realRepo, realAbs);
+      if (rel2 === "") return ".";
+      if (!rel2.startsWith("..") && !path.isAbsolute(rel2)) return rel2;
+    } catch {
+    }
+    return null;
+  }
+  return rel;
+}
 function makeGitLog(workspace) {
-  return function git_log(args) {
+  return async function git_log(args) {
     const filePath = args.path ? String(args.path) : void 0;
     const maxCount = Math.min(Number(args.max_count ?? 20), 200);
     if (maxCount < 1) return { error: "max_count \u5FC5\u987B >= 1" };
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo) ?? filePath);
     const cmd = [
-      "-C",
-      workspace,
       "log",
       `-n${maxCount}`,
       "--pretty=format:%h%x1f%an%x1f%ad%x1f%s",
       "--date=short"
     ];
-    if (filePath) cmd.push("--", filePath);
-    try {
-      const out = execFileSync("git", cmd, { encoding: "utf-8", timeout: 15e3 });
-      const commits = out.trim().split("\n").filter(Boolean).map((line) => {
-        const parts = line.split("");
-        if (parts.length === 4) {
-          return { hash: parts[0], author: parts[1], date: parts[2], subject: parts[3] };
-        }
-        return { raw: line };
-      });
-      return { count: commits.length, commits };
-    } catch (exc) {
-      const err = exc;
-      return { error: (err.stderr ?? err.message ?? "git log failed").slice(0, 300) };
+    const pathspec = toPathspec(repo, workspace, filePath);
+    if (pathspec) cmd.push("--", pathspec);
+    const res = await runGit(repo, cmd);
+    if (res.status !== 0) {
+      return { error: (res.stderr || "git log failed").trim().slice(0, 300) };
     }
+    const commits = res.stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter((l) => l.length > 0).map((line) => {
+      const parts = line.split("");
+      if (parts.length === 4) {
+        return { hash: parts[0], author: parts[1], date: parts[2], subject: parts[3] };
+      }
+      return { raw: line };
+    });
+    return { repo, count: commits.length, commits };
   };
 }
 function makeGitStatus(workspace) {
-  return function git_status(_args) {
-    try {
-      const out = execFileSync(
-        "git",
-        ["-C", workspace, "status", "--porcelain"],
-        { encoding: "utf-8", timeout: 1e4 }
-      );
-      const lines = out.trim().split("\n").filter(Boolean);
-      const entries = lines.map((line) => {
-        const status = line.slice(0, 2).trim();
-        const file = line.slice(3);
-        return { status, file };
-      });
-      return {
-        clean: entries.length === 0,
-        entries,
-        count: entries.length
-      };
-    } catch (exc) {
-      const err = exc;
-      if ((err.stderr ?? "").toLowerCase().includes("not a git repository")) {
+  return async function git_status(args) {
+    const filePath = args.path ? String(args.path) : void 0;
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo) ?? filePath);
+    const res = await runGit(repo, ["status", "--porcelain"], 1e4);
+    if (res.status !== 0) {
+      const msg = res.stderr;
+      if (msg.toLowerCase().includes("not a git repository")) {
         return { error: "\u4E0D\u662F git \u4ED3\u5E93" };
       }
-      return { error: (err.stderr ?? err.message ?? "git status failed").slice(0, 300) };
+      return { error: (msg || "git status failed").trim().slice(0, 300) };
     }
+    const lines = res.stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter((l) => l.length > 0);
+    const entries = lines.map((line) => {
+      const status = line.slice(0, 2).trim();
+      const index = line.slice(0, 1).trim();
+      const worktree = line.slice(1, 2).trim();
+      let file = line.slice(3);
+      const renameArrow = file.indexOf(" -> ");
+      if (renameArrow >= 0) file = file.slice(renameArrow + 4);
+      return { status, file, index, worktree };
+    });
+    return { repo, clean: entries.length === 0, entries, count: entries.length };
   };
 }
 function makeGitDiff(workspace) {
-  return function git_diff(args) {
+  return async function git_diff(args) {
     const staged = args.staged === true;
     const filePath = args.path ? String(args.path) : void 0;
     const contextLines = Math.min(Number(args.context ?? 3), 10);
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo) ?? filePath);
     const cmd = ["diff"];
     if (staged) cmd.push("--staged");
     cmd.push(`-U${contextLines}`);
-    if (filePath) cmd.push("--", filePath);
-    try {
-      const out = execFileSync("git", ["-C", workspace, ...cmd], {
-        encoding: "utf-8",
-        timeout: 15e3,
-        maxBuffer: 1024 * 1024 * 2
-      });
-      return {
-        staged,
-        path: filePath ?? null,
-        diff: out.slice(0, 5e4),
-        truncated: out.length > 5e4
-      };
-    } catch (exc) {
-      const err = exc;
-      return { error: (err.stderr ?? err.message ?? "git diff failed").slice(0, 300) };
+    const pathspec = toPathspec(repo, workspace, filePath);
+    if (pathspec) cmd.push("--", pathspec);
+    const res = await runGit(repo, cmd);
+    if (res.status !== 0) {
+      return { error: (res.stderr || "git diff failed").trim().slice(0, 300) };
     }
+    return {
+      repo,
+      staged,
+      path: filePath ?? null,
+      diff: res.stdout.slice(0, 5e4),
+      truncated: res.stdout.length > 5e4
+    };
   };
 }
 function registerGitTools(registry, workspace) {
@@ -94,11 +447,11 @@ function registerGitTools(registry, workspace) {
       type: "function",
       function: {
         name: "git_log",
-        description: "\u67E5\u770B\u6700\u8FD1\u7684 git \u63D0\u4EA4\u5386\u53F2 (hash, \u4F5C\u8005, \u65E5\u671F, \u4E3B\u9898)\u3002\u53EF\u9009\u5730\u9650\u5B9A\u5230\u67D0\u4E2A\u8DEF\u5F84\u3002\u7528\u4E8E\u5728\u7F16\u8F91\u524D\u4E86\u89E3\u4EE3\u7801\u7684\u6F14\u8FDB\u8FC7\u7A0B\u3002\u53EA\u8BFB\u3002",
+        description: "\u67E5\u770B\u6700\u8FD1\u7684 git \u63D0\u4EA4\u5386\u53F2 (hash, \u4F5C\u8005, \u65E5\u671F, \u4E3B\u9898)\u3002\u53EF\u9009\u5730\u9650\u5B9A\u5230\u67D0\u4E2A\u8DEF\u5F84\uFF08\u8BE5\u8DEF\u5F84\u6240\u5728\u4ED3\u5E93\u4F1A\u88AB\u81EA\u52A8\u5B9A\u4F4D\uFF09\u3002\u7528\u4E8E\u5728\u7F16\u8F91\u524D\u4E86\u89E3\u4EE3\u7801\u7684\u6F14\u8FDB\u8FC7\u7A0B\u3002\u53EA\u8BFB\u3002",
         parameters: {
           type: "object",
           properties: {
-            path: { type: "string", description: "\u53EF\u9009\uFF1A\u9650\u5B9A\u5230\u67D0\u4E2A\u6587\u4EF6\u6216\u76EE\u5F55" },
+            path: { type: "string", description: "\u53EF\u9009\uFF1A\u9650\u5B9A\u5230\u67D0\u4E2A\u6587\u4EF6\u6216\u76EE\u5F55\uFF08\u5E76\u6309\u5176\u6240\u5728\u4ED3\u5E93\u67E5\u8BE2\uFF09" },
             max_count: { type: "integer", description: "\u8FD4\u56DE\u591A\u5C11\u6761\u63D0\u4EA4 (\u9ED8\u8BA4 20\uFF0C\u6700\u5927 200)" }
           }
         }
@@ -116,7 +469,9 @@ function registerGitTools(registry, workspace) {
         description: "\u67E5\u770B\u5DE5\u4F5C\u533A git \u72B6\u6001 (\u5DF2\u4FEE\u6539\u3001\u5DF2\u6682\u5B58\u3001\u672A\u8DDF\u8E2A\u7684\u6587\u4EF6)\u3002\u53EA\u8BFB\u3002",
         parameters: {
           type: "object",
-          properties: {}
+          properties: {
+            path: { type: "string", description: "\u53EF\u9009\uFF1A\u4F18\u5148\u67E5\u8BE2\u8BE5\u8DEF\u5F84\u6240\u5728\u7684\u4ED3\u5E93\uFF08\u9ED8\u8BA4\u5DE5\u4F5C\u533A\u6839\uFF09" }
+          }
         }
       }
     }
@@ -134,7 +489,7 @@ function registerGitTools(registry, workspace) {
           type: "object",
           properties: {
             staged: { type: "boolean", description: "\u662F\u5426\u67E5\u770B\u5DF2\u6682\u5B58\u7684\u66F4\u6539 (\u9ED8\u8BA4 false)" },
-            path: { type: "string", description: "\u53EF\u9009\uFF1A\u9650\u5B9A\u5230\u67D0\u4E2A\u6587\u4EF6" },
+            path: { type: "string", description: "\u53EF\u9009\uFF1A\u9650\u5B9A\u5230\u67D0\u4E2A\u6587\u4EF6\uFF08\u5E76\u6309\u5176\u5728\u4ED3\u5E93\u4E2D\u7684\u8DEF\u5F84\uFF09" },
             context: { type: "integer", description: "\u4E0A\u4E0B\u6587\u884C\u6570 (\u9ED8\u8BA4 3)" }
           }
         }
@@ -142,7 +497,378 @@ function registerGitTools(registry, workspace) {
     }
   );
 }
+var OP_OUTPUT_LIMIT = 8e3;
+function opResult(res) {
+  const stdout = res.stdout.trim().slice(-OP_OUTPUT_LIMIT);
+  const stderr = res.stderr.trim().slice(-OP_OUTPUT_LIMIT);
+  if (res.status !== 0) {
+    return {
+      ok: false,
+      stdout,
+      stderr,
+      error: (stderr || stdout || "git \u547D\u4EE4\u5931\u8D25").slice(0, 500)
+    };
+  }
+  return { ok: true, stdout, stderr };
+}
+function failed(error) {
+  return { ok: false, stdout: "", stderr: "", error };
+}
+function gitRefProblem(name) {
+  const v = name.trim();
+  if (!v) return "\u5206\u652F\u540D\u4E0D\u80FD\u4E3A\u7A7A";
+  if (v.startsWith("-")) return "\u5206\u652F\u540D\u4E0D\u80FD\u4EE5 - \u5F00\u5934";
+  if (/[\s~^:?*\[\\\x00-\x1f\x7f]/.test(v)) return "\u5206\u652F\u540D\u5305\u542B\u7A7A\u767D\u6216\u975E\u6CD5\u5B57\u7B26";
+  if (v.includes("..") || v.includes("//") || v.endsWith("/") || v.endsWith(".lock")) {
+    return "\u5206\u652F\u540D\u4E0D\u5408\u6CD5";
+  }
+  return null;
+}
+function normalizePaths(raw) {
+  const list = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  return list.map((p) => String(p).trim()).filter((p) => p.length > 0);
+}
+function toPathspecs(repoRoot, workspace, paths) {
+  const out = [];
+  for (const p of paths) {
+    const spec = toPathspec(repoRoot, workspace, p);
+    if (spec) out.push(spec);
+  }
+  return out;
+}
+function makeGitBranches(workspace) {
+  return async function git_branches(args) {
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const list = await runGit(
+      repo,
+      [
+        "for-each-ref",
+        "--sort=-committerdate",
+        // 制表符作字段分隔（git 的 --format 不支持 %x1f 之类的十六进制转义）
+        "--format=%(refname:short)	%(HEAD)	%(upstream:short)",
+        "refs/heads"
+      ],
+      1e4
+    );
+    if (list.status !== 0) {
+      const msg = list.stderr;
+      if (msg.toLowerCase().includes("not a git repository")) return { error: "\u4E0D\u662F git \u4ED3\u5E93" };
+      return { error: (msg || "git branch failed").trim().slice(0, 300) };
+    }
+    const head = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], 1e4);
+    const detached = head.status !== 0;
+    let current = detached ? "" : head.stdout.trim();
+    if (detached) {
+      const rev = await runGit(repo, ["rev-parse", "--short", "HEAD"], 1e4);
+      current = rev.status === 0 ? rev.stdout.trim() : "";
+    }
+    const branches = list.stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter((l) => l.length > 0).map((line) => {
+      const [name, headMark, upstream] = line.split("	");
+      return {
+        name,
+        current: headMark?.trim() === "*" || !!current && name === current,
+        ...upstream ? { upstream } : {}
+      };
+    });
+    return { repo, current, detached, branches };
+  };
+}
+function gitObjectProblem(name) {
+  const v = name.trim();
+  if (!v) return "\u63D0\u4EA4\u6807\u8BC6\u4E0D\u80FD\u4E3A\u7A7A";
+  if (v.startsWith("-")) return "\u63D0\u4EA4\u6807\u8BC6\u4E0D\u80FD\u4EE5 - \u5F00\u5934";
+  if (/[\s~^:?*\[\\\x00-\x1f\x7f]/.test(v)) return "\u63D0\u4EA4\u6807\u8BC6\u5305\u542B\u7A7A\u767D\u6216\u975E\u6CD5\u5B57\u7B26";
+  if (v.includes("..") || v.includes("//") || v.endsWith("/") || v.endsWith(".lock")) {
+    return "\u63D0\u4EA4\u6807\u8BC6\u4E0D\u5408\u6CD5";
+  }
+  return null;
+}
+function makeGitRefs(workspace) {
+  return async function git_refs(args) {
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const list = await runGit(
+      repo,
+      [
+        "for-each-ref",
+        "--sort=-committerdate",
+        "--format=%(refname)	%(refname:short)	%(HEAD)	%(upstream:short)	%(objectname:short)",
+        "refs/heads",
+        "refs/remotes",
+        "refs/tags"
+      ],
+      15e3
+    );
+    if (list.status !== 0) {
+      const msg = list.stderr;
+      if (msg.toLowerCase().includes("not a git repository")) return { error: "\u4E0D\u662F git \u4ED3\u5E93" };
+      return { error: (msg || "git for-each-ref failed").trim().slice(0, 300) };
+    }
+    const head = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], 1e4);
+    const detached = head.status !== 0;
+    let current = detached ? "" : head.stdout.trim();
+    if (detached) {
+      const rev = await runGit(repo, ["rev-parse", "--short", "HEAD"], 1e4);
+      current = rev.status === 0 ? rev.stdout.trim() : "";
+    }
+    const local = [];
+    const remote = [];
+    const tags = [];
+    for (const raw of list.stdout.split("\n")) {
+      const line = raw.replace(/\r$/, "");
+      if (!line) continue;
+      const [refname, short, headMark, upstream, target] = line.split("	");
+      if (!refname || !short) continue;
+      if (refname.startsWith("refs/heads/")) {
+        local.push({
+          name: short,
+          current: headMark?.trim() === "*" || !!current && short === current,
+          ...upstream ? { upstream } : {}
+        });
+        continue;
+      }
+      if (refname.startsWith("refs/remotes/")) {
+        if (refname.endsWith("/HEAD")) continue;
+        remote.push({ name: short });
+        continue;
+      }
+      if (refname.startsWith("refs/tags/")) {
+        tags.push({ name: short, ...target ? { target } : {} });
+      }
+    }
+    return { repo, current, detached, local, remote, tags };
+  };
+}
+function makeGitShow(workspace) {
+  return async function git_show(args) {
+    const hash = String(args.hash ?? "").trim();
+    const problem = gitObjectProblem(hash);
+    if (problem) return { error: problem };
+    const filePath = args.path ? String(args.path) : void 0;
+    const contextLines = Math.min(Number(args.context ?? 3), 10);
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo) ?? filePath);
+    const metaRes = await runGit(
+      repo,
+      [
+        "show",
+        "-s",
+        "--first-parent",
+        "--date=iso-strict",
+        "--format=%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s%x1f%b",
+        hash
+      ],
+      15e3
+    );
+    if (metaRes.status !== 0) {
+      return { error: (metaRes.stderr || "git show failed").trim().slice(0, 300) };
+    }
+    const parts = metaRes.stdout.split("");
+    const commit = {
+      hash: (parts[0] ?? "").trim(),
+      short: (parts[1] ?? "").trim(),
+      author: (parts[2] ?? "").trim(),
+      authorEmail: (parts[3] ?? "").trim(),
+      date: (parts[4] ?? "").trim(),
+      subject: (parts[5] ?? "").trim(),
+      body: (parts.slice(6).join("") ?? "").trim()
+    };
+    if (!commit.hash) return { error: "\u672A\u627E\u5230\u8BE5\u63D0\u4EA4" };
+    const filesRes = await runGit(
+      repo,
+      ["show", "--name-status", "--format=", "--first-parent", commit.hash],
+      15e3
+    );
+    const files = filesRes.stdout.split("\n").map((l) => l.replace(/\r$/, "")).filter((l) => l.trim().length > 0).map((line) => {
+      const cols = line.split("	");
+      const status = (cols[0] ?? "").trim();
+      const file = (cols[cols.length - 1] ?? "").trim();
+      return { status, file };
+    }).filter((f) => f.file.length > 0);
+    const cmd = ["show", "--format=", "--first-parent", `-U${contextLines}`, commit.hash];
+    const pathspec = toPathspec(repo, workspace, filePath);
+    if (pathspec) cmd.push("--", pathspec);
+    const diffRes = await runGit(repo, cmd, 2e4);
+    if (diffRes.status !== 0) {
+      return { error: (diffRes.stderr || "git show diff failed").trim().slice(0, 300) };
+    }
+    return {
+      repo,
+      commit,
+      files,
+      path: filePath ?? null,
+      diff: diffRes.stdout.slice(0, 5e4),
+      truncated: diffRes.stdout.length > 5e4
+    };
+  };
+}
+function makeGitStage(workspace) {
+  return async function git_stage(args) {
+    const paths = normalizePaths(args.paths);
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const specs = paths.length > 0 ? toPathspecs(repo, workspace, paths) : [];
+    if (paths.length > 0 && specs.length === 0) return failed("\u8DEF\u5F84\u4E0D\u5728\u4ED3\u5E93\u5185");
+    const cmd = specs.length > 0 ? ["add", "--", ...specs] : ["add", "-A"];
+    return opResult(await runGit(repo, cmd, 3e4));
+  };
+}
+function makeGitUnstage(workspace) {
+  return async function git_unstage(args) {
+    const paths = normalizePaths(args.paths);
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const specs = paths.length > 0 ? toPathspecs(repo, workspace, paths) : [];
+    if (paths.length > 0 && specs.length === 0) return failed("\u8DEF\u5F84\u4E0D\u5728\u4ED3\u5E93\u5185");
+    const cmd = specs.length > 0 ? ["restore", "--staged", "--", ...specs] : ["reset", "-q"];
+    return opResult(await runGit(repo, cmd, 3e4));
+  };
+}
+function makeGitCommit(workspace) {
+  return async function git_commit(args) {
+    const message = String(args.message ?? "").trim();
+    if (!message) return failed("\u63D0\u4EA4\u8BF4\u660E\u4E0D\u80FD\u4E3A\u7A7A");
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    return opResult(await runGit(repo, ["commit", "-m", message], 6e4));
+  };
+}
+function makeGitCheckout(workspace) {
+  return async function git_checkout(args) {
+    const branch = String(args.branch ?? "").trim();
+    const problem = gitRefProblem(branch);
+    if (problem) return failed(problem);
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const cmd = args.create === true ? ["checkout", "-b", branch] : ["checkout", branch];
+    return opResult(await runGit(repo, cmd, 3e4));
+  };
+}
+function makeGitPull(workspace) {
+  return async function git_pull(args) {
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    return opResult(await runGit(repo, ["pull"], 6e4));
+  };
+}
+function makeGitPush(workspace) {
+  return async function git_push(args) {
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const upstream = await runGit(
+      repo,
+      ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+      1e4
+    );
+    if (upstream.status !== 0) {
+      const head = await runGit(repo, ["symbolic-ref", "--short", "HEAD"], 1e4);
+      const remotes = await runGit(repo, ["remote"], 1e4);
+      const hasOrigin = remotes.status === 0 && remotes.stdout.split("\n").some((r) => r.trim() === "origin");
+      if (head.status === 0 && hasOrigin) {
+        return opResult(await runGit(repo, ["push", "-u", "origin", head.stdout.trim()], 6e4));
+      }
+    }
+    return opResult(await runGit(repo, ["push"], 6e4));
+  };
+}
+function makeGitFetch(workspace) {
+  return async function git_fetch(args) {
+    const repo = await resolveRepoRoot(workspace, repoDirArg(workspace, args.repo));
+    const remotes = await runGit(repo, ["remote"], 1e4);
+    if (remotes.status !== 0) {
+      const msg = remotes.stderr;
+      if (msg.toLowerCase().includes("not a git repository")) return failed("\u4E0D\u662F git \u4ED3\u5E93");
+      return failed((msg || "git remote failed").trim().slice(0, 300));
+    }
+    if (!remotes.stdout.trim()) return failed("\u672A\u914D\u7F6E\u8FDC\u7AEF\u4ED3\u5E93");
+    return opResult(await runGit(repo, ["fetch", "--all", "--prune", "--tags"], 6e4));
+  };
+}
+var SCAN_SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
+var SCAN_DEFAULT_DEPTH = 3;
+var SCAN_MAX_DIRS = 2e3;
+function readRepoHead(repoDir) {
+  const dotGit = path.join(repoDir, ".git");
+  try {
+    let headFile;
+    if (fs.statSync(dotGit).isDirectory()) {
+      headFile = path.join(dotGit, "HEAD");
+    } else {
+      const raw = fs.readFileSync(dotGit, "utf-8");
+      const m = /^gitdir:\s*(.+)$/m.exec(raw);
+      if (!m) return {};
+      headFile = path.join(path.resolve(repoDir, m[1].trim()), "HEAD");
+    }
+    const head = fs.readFileSync(headFile, "utf-8").trim();
+    const prefix = "ref: refs/heads/";
+    if (head.startsWith(prefix)) return { branch: head.slice(prefix.length), detached: false };
+    if (/^[0-9a-f]{7,40}$/i.test(head)) return { branch: head.slice(0, 7), detached: true };
+  } catch {
+  }
+  return {};
+}
+function scanGitRepos(workspace, depth = SCAN_DEFAULT_DEPTH) {
+  const root = path.resolve(workspace);
+  const maxDepth = Number.isFinite(depth) ? Math.min(Math.max(Math.floor(depth), 0), 6) : SCAN_DEFAULT_DEPTH;
+  const repos = [];
+  const stack = [{ dir: root, depth: 0 }];
+  let visited = 0;
+  let truncated = false;
+  while (stack.length > 0) {
+    const { dir, depth: d } = stack.pop();
+    visited += 1;
+    if (visited > SCAN_MAX_DIRS) {
+      truncated = true;
+      break;
+    }
+    const rel = path.relative(root, dir).split(path.sep).join("/");
+    if (fs.existsSync(path.join(dir, ".git"))) {
+      repos.push({
+        path: rel,
+        name: rel ? path.basename(dir) : path.basename(root),
+        ...readRepoHead(dir)
+      });
+    }
+    if (d >= maxDepth) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || SCAN_SKIP_DIRS.has(e.name)) continue;
+      stack.push({ dir: path.join(dir, e.name), depth: d + 1 });
+    }
+  }
+  repos.sort(
+    (a, b) => a.path === "" ? -1 : b.path === "" ? 1 : a.path.localeCompare(b.path)
+  );
+  return { repos, ...truncated ? { truncated: true } : {} };
+}
+function makeGitRepos(workspace) {
+  return async function git_repos(args) {
+    const root = path.resolve(workspace);
+    try {
+      if (!fs.statSync(root).isDirectory()) return { root, repos: [], error: "\u5DE5\u4F5C\u533A\u4E0D\u662F\u76EE\u5F55" };
+    } catch {
+      return { root, repos: [], error: "\u5DE5\u4F5C\u533A\u76EE\u5F55\u4E0D\u5B58\u5728" };
+    }
+    const rawDepth = Number(args.depth);
+    const depth = Number.isFinite(rawDepth) ? rawDepth : SCAN_DEFAULT_DEPTH;
+    return { root, ...scanGitRepos(root, depth) };
+  };
+}
 export {
-  registerGitTools
+  gitObjectProblem,
+  gitRefProblem,
+  makeGitBranches,
+  makeGitCheckout,
+  makeGitCommit,
+  makeGitDiff,
+  makeGitFetch,
+  makeGitLog,
+  makeGitPull,
+  makeGitPush,
+  makeGitRefs,
+  makeGitRepos,
+  makeGitShow,
+  makeGitStage,
+  makeGitStatus,
+  makeGitUnstage,
+  registerGitTools,
+  scanGitRepos
 };
 //# sourceMappingURL=git.js.map