autohand-cli 0.7.14 → 0.8.2

package/dist/chunk-WM5PAOTQ.cjs

@@ -0,0 +1,4498 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkJ6QET7EFcjs = require('./chunk-J6QET7EF.cjs');
+
+
+var _chunk4JNNTOGFcjs = require('./chunk-4JNNTOGF.cjs');
+
+
+
+
+
+
+var _chunkRKJTGGMUcjs = require('./chunk-RKJTGGMU.cjs');
+
+
+
+var _chunkZYQMLKOKcjs = require('./chunk-ZYQMLKOK.cjs');
+
+
+
+
+var _chunkPGRH5Q77cjs = require('./chunk-PGRH5Q77.cjs');
+
+
+var _chunkSEKD5FH3cjs = require('./chunk-SEKD5FH3.cjs');
+
+
+var _chunkULQ6MDSJcjs = require('./chunk-ULQ6MDSJ.cjs');
+
+
+var _chunkLJFUXC56cjs = require('./chunk-LJFUXC56.cjs');
+
+// src/core/actionExecutor.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _diff = require('diff');
+
+// src/ui/syntaxHighlight.ts
+
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var EXTENSION_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".rb": "ruby",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".php": "php",
+  ".sh": "bash",
+  ".bash": "bash",
+  ".zsh": "bash",
+  ".fish": "fish",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "css",
+  ".less": "css",
+  ".sql": "sql",
+  ".md": "markdown",
+  ".dockerfile": "dockerfile",
+  ".prisma": "prisma",
+  ".graphql": "graphql",
+  ".gql": "graphql"
+};
+var KEYWORDS = {
+  typescript: [
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "import",
+    "export",
+    "from",
+    "default",
+    "async",
+    "await",
+    "return",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "new",
+    "this",
+    "super",
+    "extends",
+    "implements",
+    "static",
+    "public",
+    "private",
+    "protected",
+    "readonly",
+    "abstract",
+    "as",
+    "is",
+    "in",
+    "of",
+    "typeof",
+    "instanceof",
+    "keyof",
+    "never",
+    "unknown",
+    "any",
+    "void",
+    "null",
+    "undefined",
+    "true",
+    "false"
+  ],
+  javascript: [
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "import",
+    "export",
+    "from",
+    "default",
+    "async",
+    "await",
+    "return",
+    "if",
+    "else",
+    "for",
+    "while",
+    "do",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "new",
+    "this",
+    "super",
+    "extends",
+    "static",
+    "get",
+    "set",
+    "typeof",
+    "instanceof",
+    "in",
+    "of",
+    "true",
+    "false",
+    "null",
+    "undefined"
+  ],
+  python: [
+    "def",
+    "class",
+    "import",
+    "from",
+    "as",
+    "return",
+    "if",
+    "elif",
+    "else",
+    "for",
+    "while",
+    "break",
+    "continue",
+    "try",
+    "except",
+    "finally",
+    "raise",
+    "with",
+    "as",
+    "pass",
+    "lambda",
+    "yield",
+    "global",
+    "nonlocal",
+    "assert",
+    "async",
+    "await",
+    "True",
+    "False",
+    "None",
+    "and",
+    "or",
+    "not",
+    "in",
+    "is"
+  ],
+  rust: [
+    "fn",
+    "let",
+    "mut",
+    "const",
+    "static",
+    "struct",
+    "enum",
+    "impl",
+    "trait",
+    "type",
+    "where",
+    "for",
+    "loop",
+    "while",
+    "if",
+    "else",
+    "match",
+    "return",
+    "break",
+    "continue",
+    "pub",
+    "mod",
+    "use",
+    "crate",
+    "super",
+    "self",
+    "Self",
+    "async",
+    "await",
+    "move",
+    "ref",
+    "dyn",
+    "true",
+    "false",
+    "as",
+    "in",
+    "unsafe"
+  ],
+  go: [
+    "func",
+    "var",
+    "const",
+    "type",
+    "struct",
+    "interface",
+    "map",
+    "chan",
+    "package",
+    "import",
+    "return",
+    "if",
+    "else",
+    "for",
+    "range",
+    "switch",
+    "case",
+    "default",
+    "break",
+    "continue",
+    "go",
+    "defer",
+    "select",
+    "fallthrough",
+    "true",
+    "false",
+    "nil",
+    "make",
+    "new",
+    "append",
+    "len",
+    "cap"
+  ],
+  bash: [
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "function",
+    "return",
+    "exit",
+    "break",
+    "continue",
+    "export",
+    "local",
+    "readonly",
+    "declare",
+    "unset",
+    "source",
+    "alias",
+    "echo",
+    "printf"
+  ],
+  sql: [
+    "SELECT",
+    "FROM",
+    "WHERE",
+    "AND",
+    "OR",
+    "NOT",
+    "IN",
+    "LIKE",
+    "ORDER",
+    "BY",
+    "GROUP",
+    "HAVING",
+    "JOIN",
+    "LEFT",
+    "RIGHT",
+    "INNER",
+    "OUTER",
+    "ON",
+    "AS",
+    "INSERT",
+    "INTO",
+    "VALUES",
+    "UPDATE",
+    "SET",
+    "DELETE",
+    "CREATE",
+    "TABLE",
+    "DROP",
+    "ALTER",
+    "INDEX",
+    "PRIMARY",
+    "KEY",
+    "FOREIGN",
+    "REFERENCES",
+    "NULL",
+    "DEFAULT",
+    "DISTINCT",
+    "LIMIT",
+    "OFFSET",
+    "UNION",
+    "ALL"
+  ]
+};
+var BUILTIN_TYPES = {
+  typescript: [
+    "string",
+    "number",
+    "boolean",
+    "object",
+    "symbol",
+    "bigint",
+    "Array",
+    "Map",
+    "Set",
+    "Promise",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "ReturnType"
+  ],
+  rust: [
+    "i8",
+    "i16",
+    "i32",
+    "i64",
+    "i128",
+    "isize",
+    "u8",
+    "u16",
+    "u32",
+    "u64",
+    "u128",
+    "usize",
+    "f32",
+    "f64",
+    "bool",
+    "char",
+    "str",
+    "String",
+    "Vec",
+    "Option",
+    "Result",
+    "Box",
+    "Rc",
+    "Arc",
+    "Cell",
+    "RefCell",
+    "HashMap"
+  ],
+  go: [
+    "int",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "uint",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uintptr",
+    "float32",
+    "float64",
+    "complex64",
+    "complex128",
+    "bool",
+    "byte",
+    "rune",
+    "string",
+    "error"
+  ]
+};
+function detectLanguage(filePath, content) {
+  if (filePath) {
+    const ext = _path2.default.extname(filePath).toLowerCase();
+    if (EXTENSION_MAP[ext]) {
+      return EXTENSION_MAP[ext];
+    }
+    const basename = _path2.default.basename(filePath).toLowerCase();
+    if (basename === "dockerfile") return "dockerfile";
+    if (basename === "makefile") return "makefile";
+    if (basename.endsWith(".d.ts")) return "typescript";
+  }
+  if (content) {
+    if (content.includes("#!/bin/bash") || content.includes("#!/usr/bin/env bash")) {
+      return "bash";
+    }
+    if (content.includes("#!/usr/bin/env python") || content.includes("#!/usr/bin/python")) {
+      return "python";
+    }
+    if (content.includes("#!/usr/bin/env node")) {
+      return "javascript";
+    }
+  }
+  return "text";
+}
+function tokenize(code, language) {
+  const tokens = [];
+  const keywords = KEYWORDS[language] || KEYWORDS.javascript || [];
+  const types = BUILTIN_TYPES[language] || [];
+  const patterns = [
+    // Comments (single line)
+    { type: "comment", regex: /^(\/\/.*|#.*|--.*)/m },
+    // Comments (multi-line for JS/TS/C-style)
+    { type: "comment", regex: /^\/\*[\s\S]*?\*\// },
+    // Strings (double quotes)
+    { type: "string", regex: /^"(?:[^"\\]|\\.)*"/ },
+    // Strings (single quotes)
+    { type: "string", regex: /^'(?:[^'\\]|\\.)*'/ },
+    // Template literals
+    { type: "string", regex: /^`(?:[^`\\]|\\.)*`/ },
+    // Numbers
+    { type: "number", regex: /^0x[0-9a-fA-F]+|^0b[01]+|^0o[0-7]+|^\d+\.?\d*(?:[eE][+-]?\d+)?/ },
+    // Operators
+    { type: "operator", regex: /^(?:=>|===|!==|==|!=|<=|>=|&&|\|\||[+\-*/%<>=!&|^~?:])+/ },
+    // Punctuation
+    { type: "punctuation", regex: /^[{}[\]();,.]/ },
+    // Words (identifiers, keywords, types)
+    { type: "text", regex: /^[a-zA-Z_$][a-zA-Z0-9_$]*/ },
+    // Whitespace and other
+    { type: "text", regex: /^\s+/ },
+    { type: "text", regex: /^./ }
+  ];
+  let remaining = code;
+  while (remaining.length > 0) {
+    let matched = false;
+    for (const { type, regex } of patterns) {
+      const match = remaining.match(regex);
+      if (match) {
+        let tokenType = type;
+        const value = match[0];
+        if (type === "text" && /^[a-zA-Z_$]/.test(value)) {
+          if (keywords.includes(value)) {
+            tokenType = "keyword";
+          } else if (types.includes(value)) {
+            tokenType = "type";
+          } else if (/^[A-Z]/.test(value)) {
+            tokenType = "type";
+          }
+        }
+        tokens.push({ type: tokenType, value });
+        remaining = remaining.slice(value.length);
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      tokens.push({ type: "text", value: remaining[0] });
+      remaining = remaining.slice(1);
+    }
+  }
+  return tokens;
+}
+function colorToken(token) {
+  if (_chunkPGRH5Q77cjs.isThemeInitialized.call(void 0, )) {
+    const theme = _chunkPGRH5Q77cjs.getTheme.call(void 0, );
+    switch (token.type) {
+      case "keyword":
+        return theme.fg("syntaxKeyword", token.value);
+      case "string":
+        return theme.fg("syntaxString", token.value);
+      case "number":
+        return theme.fg("syntaxNumber", token.value);
+      case "comment":
+        return theme.fg("syntaxComment", token.value);
+      case "type":
+        return theme.fg("syntaxType", token.value);
+      case "function":
+        return theme.fg("syntaxFunction", token.value);
+      case "operator":
+        return theme.fg("syntaxOperator", token.value);
+      case "punctuation":
+        return theme.fg("syntaxPunctuation", token.value);
+      default:
+        return token.value;
+    }
+  }
+  switch (token.type) {
+    case "keyword":
+      return _chalk2.default.magenta(token.value);
+    case "string":
+      return _chalk2.default.green(token.value);
+    case "number":
+      return _chalk2.default.yellow(token.value);
+    case "comment":
+      return _chalk2.default.gray(token.value);
+    case "type":
+      return _chalk2.default.cyan(token.value);
+    case "function":
+      return _chalk2.default.blue(token.value);
+    case "operator":
+      return _chalk2.default.white(token.value);
+    case "punctuation":
+      return _chalk2.default.white(token.value);
+    default:
+      return token.value;
+  }
+}
+function highlightLine(line, language) {
+  const tokens = tokenize(line, language);
+  return tokens.map(colorToken).join("");
+}
+
+// src/actions/dependencies.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+
+async function readPackageManifest(cwd) {
+  const manifestPath = _path2.default.join(cwd, "package.json");
+  if (!await _fsextra2.default.pathExists(manifestPath)) {
+    return null;
+  }
+  return _fsextra2.default.readJson(manifestPath);
+}
+async function addDependency(cwd, name, version, options = {}) {
+  const manifest = await _asyncNullishCoalesce(await readPackageManifest(cwd), async () => ( {}));
+  if (options.dev) {
+    manifest.devDependencies = _nullishCoalesce(manifest.devDependencies, () => ( {}));
+    manifest.devDependencies[name] = version;
+  } else {
+    manifest.dependencies = _nullishCoalesce(manifest.dependencies, () => ( {}));
+    manifest.dependencies[name] = version;
+  }
+  const manifestPath = _path2.default.join(cwd, "package.json");
+  await _fsextra2.default.writeJson(manifestPath, manifest, { spaces: 2 });
+}
+async function removeDependency(cwd, name, options = {}) {
+  const manifest = await _asyncNullishCoalesce(await readPackageManifest(cwd), async () => ( {}));
+  const targetKey = options.dev ? "devDependencies" : "dependencies";
+  if (manifest[targetKey] && manifest[targetKey][name]) {
+    delete manifest[targetKey][name];
+    const manifestPath = _path2.default.join(cwd, "package.json");
+    await _fsextra2.default.writeJson(manifestPath, manifest, { spaces: 2 });
+  }
+}
+
+// src/actions/command.ts
+var _child_process = require('child_process');
+
+function runCommand(cmd, args, cwd, options = {}) {
+  if (!cmd || typeof cmd !== "string") {
+    return Promise.reject(new Error("Command is required and must be a string"));
+  }
+  return new Promise((resolve, reject) => {
+    const workDir = options.directory ? _path.join.call(void 0, cwd, options.directory) : cwd;
+    const spawnOptions = {
+      cwd: workDir,
+      shell: _nullishCoalesce(options.shell, () => ( false)),
+      env: {
+        ...process.env,
+        AUTOHAND_CLI: "1",
+        ...options.env
+      }
+    };
+    if (options.background) {
+      spawnOptions.detached = true;
+      spawnOptions.stdio = ["ignore", "pipe", "pipe"];
+    }
+    let child;
+    try {
+      child = _child_process.spawn.call(void 0, cmd, args, spawnOptions);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        reject(new Error(`Command not found: ${cmd}`));
+      } else {
+        reject(error);
+      }
+      return;
+    }
+    if (options.background) {
+      child.unref();
+      resolve({
+        stdout: "",
+        stderr: "",
+        code: null,
+        backgroundPid: child.pid,
+        signal: null
+      });
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timeoutId;
+    if (options.timeout && options.timeout > 0) {
+      timeoutId = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, options.timeout);
+    }
+    _optionalChain([child, 'access', _ => _.stdout, 'optionalAccess', _2 => _2.on, 'call', _3 => _3("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stdout += text;
+      _optionalChain([options, 'access', _4 => _4.onStdout, 'optionalCall', _5 => _5(text)]);
+    })]);
+    _optionalChain([child, 'access', _6 => _6.stderr, 'optionalAccess', _7 => _7.on, 'call', _8 => _8("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stderr += text;
+      _optionalChain([options, 'access', _9 => _9.onStderr, 'optionalCall', _10 => _10(text)]);
+    })]);
+    child.once("error", (error) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (error.code === "ENOENT") {
+        reject(new Error(`Command not found: ${cmd}`));
+      } else {
+        reject(error);
+      }
+    });
+    child.once("close", (code, signal) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      resolve({ stdout, stderr, code, signal });
+    });
+  });
+}
+
+// src/actions/metadata.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+
+
+var ALWAYS_SKIP = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "__pycache__", ".cache"]);
+async function listDirectoryTree(root, options = {}) {
+  const depth = _nullishCoalesce(options.depth, () => ( 2));
+  const maxEntries = _nullishCoalesce(options.maxEntries, () => ( 200));
+  const workspaceRoot = _nullishCoalesce(options.workspaceRoot, () => ( root));
+  const result = [];
+  const resolvedRoot = _path2.default.resolve(root);
+  const resolvedWorkspace = _path2.default.resolve(workspaceRoot);
+  if (!resolvedRoot.startsWith(resolvedWorkspace)) {
+    throw new Error(`Path ${root} is outside the workspace root.`);
+  }
+  const ignoreFilter = new (0, _chunkLJFUXC56cjs.GitIgnoreParser)(workspaceRoot);
+  async function walk(current, prefix, currentDepth) {
+    if (result.length >= maxEntries) {
+      return;
+    }
+    let entries;
+    try {
+      entries = await _fsextra2.default.readdir(current);
+    } catch (e2) {
+      return;
+    }
+    const slice = entries.slice(0, maxEntries - result.length);
+    for (const entry of slice) {
+      if (entry.startsWith(".")) {
+        continue;
+      }
+      const full = _path2.default.join(current, entry);
+      const rel = _path2.default.relative(workspaceRoot, full);
+      if (ALWAYS_SKIP.has(entry) || ignoreFilter.isIgnored(rel)) {
+        continue;
+      }
+      try {
+        const stats = await _fsextra2.default.stat(full);
+        result.push(`${prefix}${entry}${stats.isDirectory() ? "/" : ""}`);
+        if (stats.isDirectory() && currentDepth < depth) {
+          await walk(full, `${prefix}  `, currentDepth + 1);
+        }
+      } catch (e3) {
+        continue;
+      }
+      if (result.length >= maxEntries) {
+        break;
+      }
+    }
+  }
+  await walk(root, "", 0);
+  return result;
+}
+async function fileStats(root, relativePath) {
+  const fullPath = _path2.default.join(root, relativePath);
+  if (!await _fsextra2.default.pathExists(fullPath)) {
+    return null;
+  }
+  const stats = await _fsextra2.default.stat(fullPath);
+  return {
+    size: stats.size,
+    mtime: stats.mtime.toISOString(),
+    isDirectory: stats.isDirectory()
+  };
+}
+async function checksumFile(root, relativePath, algorithm = "sha256") {
+  const fullPath = _path2.default.join(root, relativePath);
+  const exists = await _fsextra2.default.pathExists(fullPath);
+  if (!exists) {
+    throw new Error(`${relativePath} does not exist.`);
+  }
+  const hash = _crypto2.default.createHash(algorithm);
+  const stream = _fsextra2.default.createReadStream(fullPath);
+  return await new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+// src/actions/git.ts
+
+var GIT_SAFETY = {
+  /** Branches where force push is blocked */
+  PROTECTED_BRANCHES: ["main", "master", "develop", "production", "staging"],
+  /** Maximum commits to push at once (to prevent accidental mass pushes) */
+  MAX_COMMITS_PER_PUSH: 50
+};
+function getCurrentBranch(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8" });
+  return _optionalChain([result, 'access', _11 => _11.stdout, 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]) || "";
+}
+function getCommitsAhead(cwd, remote = "origin", branch) {
+  const currentBranch = branch || getCurrentBranch(cwd);
+  if (!currentBranch) return 0;
+  const result = _child_process.spawnSync.call(void 0, "git", ["rev-list", "--count", `${remote}/${currentBranch}..HEAD`], {
+    cwd,
+    encoding: "utf8"
+  });
+  return parseInt(_optionalChain([result, 'access', _14 => _14.stdout, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16()]) || "0", 10) || 0;
+}
+function applyGitPatch(cwd, patch) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["apply", "-"], {
+    cwd,
+    input: patch,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git apply failed");
+  }
+  return _nullishCoalesce(result.stdout, () => ( ""));
+}
+function diffFile(cwd, file) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["diff", "--", file], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || `git diff failed for ${file}`);
+  }
+  return result.stdout || "No diff";
+}
+function checkoutFile(cwd, file) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["checkout", "--", file], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || `git checkout failed for ${file}`);
+  }
+}
+function gitStatus(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["status", "-sb"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git status failed");
+  }
+  return result.stdout || "clean";
+}
+function gitListUntracked(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["ls-files", "--others", "--exclude-standard"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git ls-files failed");
+  }
+  return result.stdout || "";
+}
+function gitDiffRange(cwd, options = {}) {
+  const args = ["diff"];
+  if (options.staged) {
+    args.push("--staged");
+  }
+  if (options.range) {
+    args.push(options.range);
+  }
+  if (_optionalChain([options, 'access', _17 => _17.paths, 'optionalAccess', _18 => _18.length])) {
+    args.push("--", ...options.paths);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git diff failed");
+  }
+  return result.stdout || "No diff output.";
+}
+function gitListWorktrees(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["worktree", "list", "--porcelain"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git worktree list failed");
+  }
+  return result.stdout || "No worktrees.";
+}
+function gitAddWorktree(cwd, pathArg, ref) {
+  const args = ["worktree", "add", pathArg];
+  if (ref) {
+    args.push(ref);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git worktree add failed");
+  }
+  return result.stdout || `Added worktree at ${pathArg}`;
+}
+function gitRemoveWorktree(cwd, pathArg, force = false) {
+  const args = ["worktree", "remove"];
+  if (force) {
+    args.push("--force");
+  }
+  args.push(pathArg);
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git worktree remove failed");
+  }
+  return result.stdout || `Removed worktree ${pathArg}`;
+}
+function gitStash(cwd, options = {}) {
+  const args = ["stash", "push"];
+  if (options.includeUntracked) {
+    args.push("--include-untracked");
+  }
+  if (options.keepIndex) {
+    args.push("--keep-index");
+  }
+  if (options.message) {
+    args.push("-m", options.message);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git stash failed");
+  }
+  return result.stdout || result.stderr || "Stashed changes";
+}
+function gitStashList(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["stash", "list"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git stash list failed");
+  }
+  return result.stdout || "No stashes";
+}
+function gitStashPop(cwd, stashRef) {
+  const args = ["stash", "pop"];
+  if (stashRef) {
+    args.push(stashRef);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git stash pop failed");
+  }
+  return result.stdout || "Applied and dropped stash";
+}
+function gitStashApply(cwd, stashRef) {
+  const args = ["stash", "apply"];
+  if (stashRef) {
+    args.push(stashRef);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git stash apply failed");
+  }
+  return result.stdout || "Applied stash";
+}
+function gitStashDrop(cwd, stashRef) {
+  const args = ["stash", "drop"];
+  if (stashRef) {
+    args.push(stashRef);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git stash drop failed");
+  }
+  return result.stdout || "Dropped stash";
+}
+function gitBranch(cwd, branchName, options = {}) {
+  const args = ["branch"];
+  if (options.delete) {
+    args.push(options.force ? "-D" : "-d");
+  }
+  if (branchName) {
+    args.push(branchName);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git branch failed");
+  }
+  return result.stdout || "Branch operation completed";
+}
+function gitSwitch(cwd, branchName, options = {}) {
+  const args = ["switch"];
+  if (options.create) {
+    args.push("-c");
+  }
+  args.push(branchName);
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git switch failed");
+  }
+  return result.stdout || `Switched to ${branchName}`;
+}
+function gitCherryPick(cwd, commits, options = {}) {
+  const args = ["cherry-pick"];
+  if (options.noCommit) {
+    args.push("--no-commit");
+  }
+  if (options.mainline !== void 0) {
+    args.push("-m", String(options.mainline));
+  }
+  args.push(...commits);
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git cherry-pick failed");
+  }
+  return result.stdout || `Cherry-picked ${commits.join(", ")}`;
+}
+function gitCherryPickAbort(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["cherry-pick", "--abort"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git cherry-pick --abort failed");
+  }
+  return "Cherry-pick aborted";
+}
+function gitCherryPickContinue(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["cherry-pick", "--continue"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git cherry-pick --continue failed");
+  }
+  return "Cherry-pick continued";
+}
+function gitRebase(cwd, upstream, options = {}) {
+  const currentBranch = getCurrentBranch(cwd);
+  if (GIT_SAFETY.PROTECTED_BRANCHES.includes(currentBranch)) {
+    throw new Error(
+      `Rebasing protected branch "${currentBranch}" is blocked. Protected branches should not be rebased as it rewrites history. Use merge instead, or switch to a feature branch first.`
+    );
+  }
+  const args = ["rebase"];
+  if (options.onto) {
+    args.push("--onto", options.onto);
+  }
+  if (options.autosquash) {
+    args.push("--autosquash");
+  }
+  args.push(upstream);
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git rebase failed");
+  }
+  return result.stdout || `Rebased onto ${upstream}`;
+}
+function gitRebaseAbort(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["rebase", "--abort"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git rebase --abort failed");
+  }
+  return "Rebase aborted";
+}
+function gitRebaseContinue(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["rebase", "--continue"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git rebase --continue failed");
+  }
+  return "Rebase continued";
+}
+function gitRebaseSkip(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["rebase", "--skip"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git rebase --skip failed");
+  }
+  return "Skipped commit and continued rebase";
+}
+function gitMerge(cwd, branch, options = {}) {
+  const localBranches = _child_process.spawnSync.call(void 0, "git", ["branch", "--list"], { cwd, encoding: "utf8" });
+  const remoteBranches = _child_process.spawnSync.call(void 0, "git", ["branch", "-r", "--list"], { cwd, encoding: "utf8" });
+  const allBranches = (localBranches.stdout || "") + (remoteBranches.stdout || "");
+  const branchExists = allBranches.split("\n").some(
+    (b) => b.trim().replace("* ", "") === branch || b.trim() === `origin/${branch}` || b.trim() === branch
+  );
+  if (!branchExists) {
+    throw new Error(
+      `Branch "${branch}" not found locally or in remotes. For security, only existing branches can be merged. Run 'git fetch' first if the branch exists remotely.`
+    );
+  }
+  const args = ["merge"];
+  if (options.noCommit) {
+    args.push("--no-commit");
+  }
+  if (options.noFastForward) {
+    args.push("--no-ff");
+  }
+  if (options.squash) {
+    args.push("--squash");
+  }
+  if (options.message) {
+    args.push("-m", options.message);
+  }
+  args.push(branch);
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git merge failed");
+  }
+  return result.stdout || `Merged ${branch}`;
+}
+function gitMergeAbort(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["merge", "--abort"], { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git merge --abort failed");
+  }
+  return "Merge aborted";
+}
+function gitCommit(cwd, options) {
+  const args = ["commit", "-m", options.message];
+  if (options.amend) {
+    args.push("--amend");
+  }
+  if (options.allowEmpty) {
+    args.push("--allow-empty");
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git commit failed");
+  }
+  return result.stdout || "Committed";
+}
+function gitAdd(cwd, paths) {
+  const args = ["add", ...paths];
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git add failed");
+  }
+  return result.stdout || `Staged ${paths.join(", ")}`;
+}
+function gitReset(cwd, mode = "mixed", ref) {
+  if (mode === "hard") {
+    const currentBranch = getCurrentBranch(cwd);
+    if (GIT_SAFETY.PROTECTED_BRANCHES.includes(currentBranch)) {
+      throw new Error(
+        `Hard reset on protected branch "${currentBranch}" is blocked for safety.
+Protected branches: ${GIT_SAFETY.PROTECTED_BRANCHES.join(", ")}
+Use soft or mixed reset instead, or switch to a feature branch.`
+      );
+    }
+  }
+  const args = ["reset", `--${mode}`];
+  if (ref) {
+    args.push(ref);
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git reset failed");
+  }
+  return result.stdout || `Reset ${mode}${ref ? ` to ${ref}` : ""}`;
+}
+function isGitRepository(cwd) {
+  const result = _child_process.spawnSync.call(void 0, "git", ["rev-parse", "--is-inside-work-tree"], { cwd, encoding: "utf8" });
+  return result.status === 0;
+}
+function getAutoCommitInfo(cwd) {
+  if (!isGitRepository(cwd)) {
+    return {
+      canCommit: false,
+      error: "Not a git repository",
+      filesChanged: [],
+      suggestedMessage: "",
+      diffSummary: ""
+    };
+  }
+  const statusResult = _child_process.spawnSync.call(void 0, "git", ["status", "--porcelain"], { cwd, encoding: "utf8" });
+  if (statusResult.status !== 0) {
+    return {
+      canCommit: false,
+      error: "Failed to get git status",
+      filesChanged: [],
+      suggestedMessage: "",
+      diffSummary: ""
+    };
+  }
+  const changes = _optionalChain([statusResult, 'access', _19 => _19.stdout, 'optionalAccess', _20 => _20.trim, 'call', _21 => _21(), 'access', _22 => _22.split, 'call', _23 => _23("\n"), 'access', _24 => _24.filter, 'call', _25 => _25(Boolean)]) || [];
+  if (changes.length === 0) {
+    return {
+      canCommit: false,
+      error: "No changes to commit",
+      filesChanged: [],
+      suggestedMessage: "",
+      diffSummary: ""
+    };
+  }
+  const added = [];
+  const modified = [];
+  const deleted = [];
+  const renamed = [];
+  for (const change of changes) {
+    const status = change.substring(0, 2);
+    const file = change.substring(3).trim();
+    if (status.includes("A") || status === "??") {
+      added.push(file);
+    } else if (status.includes("M")) {
+      modified.push(file);
+    } else if (status.includes("D")) {
+      deleted.push(file);
+    } else if (status.includes("R")) {
+      renamed.push(file);
+    }
+  }
+  const diffStatResult = _child_process.spawnSync.call(void 0, "git", ["diff", "--stat", "HEAD"], { cwd, encoding: "utf8" });
+  const diffSummary = _optionalChain([diffStatResult, 'access', _26 => _26.stdout, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()]) || "";
+  const suggestedMessage = generateCommitMessage(added, modified, deleted, renamed);
+  return {
+    canCommit: true,
+    filesChanged: changes.map((c) => c.substring(3).trim()),
+    suggestedMessage,
+    diffSummary
+  };
+}
+function generateCommitMessage(added, modified, deleted, renamed) {
+  const parts = [];
+  const totalChanges = added.length + modified.length + deleted.length + renamed.length;
+  if (totalChanges === 1) {
+    if (added.length === 1) {
+      return `feat: Add ${added[0]}`;
+    } else if (modified.length === 1) {
+      return `update: Modify ${modified[0]}`;
+    } else if (deleted.length === 1) {
+      return `chore: Remove ${deleted[0]}`;
+    } else if (renamed.length === 1) {
+      return `refactor: Rename ${renamed[0]}`;
+    }
+  }
+  if (added.length > 0) {
+    parts.push(`add ${added.length} file${added.length > 1 ? "s" : ""}`);
+  }
+  if (modified.length > 0) {
+    parts.push(`update ${modified.length} file${modified.length > 1 ? "s" : ""}`);
+  }
+  if (deleted.length > 0) {
+    parts.push(`remove ${deleted.length} file${deleted.length > 1 ? "s" : ""}`);
+  }
+  if (renamed.length > 0) {
+    parts.push(`rename ${renamed.length} file${renamed.length > 1 ? "s" : ""}`);
+  }
+  const allFiles = [...added, ...modified];
+  const hasTests = allFiles.some((f) => f.includes("test") || f.includes("spec"));
+  const hasDocs = allFiles.some((f) => f.includes(".md") || f.includes("doc"));
+  const hasConfig = allFiles.some((f) => f.includes("config") || f.includes(".json") || f.includes(".yaml"));
+  let prefix = "chore";
+  if (added.length > modified.length && added.length > deleted.length) {
+    prefix = "feat";
+  } else if (hasTests) {
+    prefix = "test";
+  } else if (hasDocs) {
+    prefix = "docs";
+  } else if (hasConfig) {
+    prefix = "chore";
+  } else if (modified.length > 0) {
+    prefix = "update";
+  }
+  return `${prefix}: ${parts.join(", ")}`;
+}
+function executeAutoCommit(cwd, message, stageAll = true) {
+  const statusResult = _child_process.spawnSync.call(void 0, "git", ["status", "--porcelain"], { cwd, encoding: "utf8" });
+  const changes = _optionalChain([statusResult, 'access', _29 => _29.stdout, 'optionalAccess', _30 => _30.trim, 'call', _31 => _31(), 'access', _32 => _32.split, 'call', _33 => _33("\n"), 'access', _34 => _34.filter, 'call', _35 => _35(Boolean)]) || [];
+  if (stageAll) {
+    const addResult = _child_process.spawnSync.call(void 0, "git", ["add", "-A"], { cwd, encoding: "utf8" });
+    if (addResult.status !== 0) {
+      return {
+        success: false,
+        message: `Failed to stage changes: ${addResult.stderr}`,
+        filesChanged: 0
+      };
+    }
+  }
+  const commitResult = _child_process.spawnSync.call(void 0, "git", ["commit", "-m", message], { cwd, encoding: "utf8" });
+  if (commitResult.status !== 0) {
+    return {
+      success: false,
+      message: `Failed to commit: ${commitResult.stderr}`,
+      filesChanged: changes.length
+    };
+  }
+  const hashResult = _child_process.spawnSync.call(void 0, "git", ["rev-parse", "--short", "HEAD"], { cwd, encoding: "utf8" });
+  const commitHash = _optionalChain([hashResult, 'access', _36 => _36.stdout, 'optionalAccess', _37 => _37.trim, 'call', _38 => _38()]);
+  return {
+    success: true,
+    message: `Committed ${changes.length} file(s): ${commitHash}`,
+    filesChanged: changes.length,
+    commitHash
+  };
+}
+function gitLog(cwd, options = {}) {
+  const args = ["log"];
+  if (options.maxCount) {
+    args.push(`-n${options.maxCount}`);
+  }
+  if (options.oneline) {
+    args.push("--oneline");
+  }
+  if (options.graph) {
+    args.push("--graph");
+  }
+  if (options.all) {
+    args.push("--all");
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git log failed");
+  }
+  return result.stdout || "No commits";
+}
+function gitFetch(cwd, remote, branch) {
+  const args = ["fetch"];
+  if (remote) {
+    args.push(remote);
+    if (branch) {
+      args.push(branch);
+    }
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git fetch failed");
+  }
+  return result.stdout || result.stderr || "Fetched";
+}
+function gitPull(cwd, remote, branch) {
+  const args = ["pull"];
+  if (remote) {
+    args.push(remote);
+    if (branch) {
+      args.push(branch);
+    }
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git pull failed");
+  }
+  return result.stdout || "Pulled";
+}
+function gitPush(cwd, remote, branch, options = {}) {
+  const targetRemote = remote || "origin";
+  const targetBranch = branch || getCurrentBranch(cwd);
+  if (options.force && GIT_SAFETY.PROTECTED_BRANCHES.includes(targetBranch)) {
+    throw new Error(
+      `Force push to protected branch "${targetBranch}" is blocked. Protected branches: ${GIT_SAFETY.PROTECTED_BRANCHES.join(", ")}`
+    );
+  }
+  const commitsAhead = getCommitsAhead(cwd, targetRemote, targetBranch);
+  if (commitsAhead > GIT_SAFETY.MAX_COMMITS_PER_PUSH) {
+    throw new Error(
+      `Too many commits to push (${commitsAhead}). Maximum allowed: ${GIT_SAFETY.MAX_COMMITS_PER_PUSH}. This limit exists to prevent accidental large pushes. Push manually if intentional.`
+    );
+  }
+  const args = ["push"];
+  if (options.force) {
+    args.push("--force-with-lease");
+  }
+  if (options.setUpstream) {
+    args.push("--set-upstream");
+  }
+  if (remote) {
+    args.push(remote);
+    if (branch) {
+      args.push(branch);
+    }
+  }
+  const result = _child_process.spawnSync.call(void 0, "git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) {
+    throw new Error(result.stderr || "git push failed");
+  }
+  return result.stdout || result.stderr || "Pushed";
+}
+
+// src/actions/worktree.ts
+
+
+
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var DEFAULT_TEMPLATES = [
+  {
+    name: "feature",
+    description: "Feature branch worktree",
+    pathPattern: "../{repo}-feature-{branch}",
+    setupCommands: ["npm install || yarn install || pnpm install || true"]
+  },
+  {
+    name: "hotfix",
+    description: "Hotfix branch from main/master",
+    pathPattern: "../{repo}-hotfix-{branch}",
+    setupCommands: ["npm install || yarn install || pnpm install || true"]
+  },
+  {
+    name: "release",
+    description: "Release branch worktree",
+    pathPattern: "../{repo}-release-{branch}",
+    setupCommands: ["npm install || yarn install || pnpm install || true"]
+  },
+  {
+    name: "review",
+    description: "PR review worktree",
+    pathPattern: "../{repo}-review-{branch}",
+    setupCommands: []
+  },
+  {
+    name: "experiment",
+    description: "Experimental detached worktree",
+    pathPattern: "../{repo}-experiment-{timestamp}",
+    setupCommands: []
+  }
+];
+var WorktreeManager = class {
+  constructor(cwd) {
+    this.repoRoot = this.findGitRoot(cwd);
+    this.repoName = _path2.default.basename(this.repoRoot);
+    this.templates = [...DEFAULT_TEMPLATES];
+  }
+  // ============ Core Operations ============
+  /**
+   * List all worktrees with detailed information
+   */
+  list() {
+    const result = _child_process.spawnSync.call(void 0, "git", ["worktree", "list", "--porcelain"], {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr || "Failed to list worktrees");
+    }
+    return this.parseWorktreeList(result.stdout);
+  }
+  /**
+   * Get comprehensive status of all worktrees
+   */
+  async statusAll() {
+    const worktrees = this.list();
+    const statuses = [];
+    for (const wt of worktrees) {
+      if (wt.bare) continue;
+      try {
+        const status = await this.getWorktreeStatus(wt);
+        statuses.push(status);
+      } catch (e4) {
+        statuses.push({
+          worktree: wt,
+          gitStatus: { staged: 0, modified: 0, untracked: 0, conflicts: 0, ahead: 0, behind: 0 },
+          isClean: false,
+          lastCommit: null
+        });
+      }
+    }
+    return statuses;
+  }
+  /**
+   * Smart worktree creation with templates
+   */
+  async create(options) {
+    const branch = options.branch || `worktree-${Date.now()}`;
+    const template = options.template ? this.getTemplate(options.template) : null;
+    let worktreePath;
+    if (template) {
+      worktreePath = this.resolvePath(template.pathPattern, branch);
+    } else {
+      worktreePath = _path2.default.join(_path2.default.dirname(this.repoRoot), `${this.repoName}-${branch}`);
+    }
+    await _fsextra2.default.ensureDir(_path2.default.dirname(worktreePath));
+    const args = ["worktree", "add"];
+    if (options.newBranch) {
+      args.push("-b", branch);
+      if (options.baseBranch) {
+        args.push(worktreePath, options.baseBranch);
+      } else {
+        args.push(worktreePath);
+      }
+    } else if (options.detach) {
+      args.push("--detach", worktreePath);
+      if (options.branch) {
+        args.push(options.branch);
+      }
+    } else {
+      args.push(worktreePath);
+      if (options.branch) {
+        args.push(options.branch);
+      }
+    }
+    if (options.force) {
+      args.splice(2, 0, "--force");
+    }
+    const result = _child_process.spawnSync.call(void 0, "git", args, {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr || "Failed to create worktree");
+    }
+    if (_optionalChain([template, 'optionalAccess', _39 => _39.setupCommands]) && options.runSetup !== false) {
+      for (const cmd of template.setupCommands) {
+        await this.runInWorktree(worktreePath, cmd);
+      }
+    }
+    return { path: worktreePath, branch };
+  }
+  /**
+   * Remove a worktree with cleanup
+   */
+  async remove(worktreePath, options = {}) {
+    const absolutePath = _path2.default.isAbsolute(worktreePath) ? worktreePath : _path2.default.resolve(this.repoRoot, worktreePath);
+    const worktrees = this.list();
+    const wt = worktrees.find((w) => w.path === absolutePath);
+    const branchToDelete = _optionalChain([wt, 'optionalAccess', _40 => _40.branch]);
+    const args = ["worktree", "remove"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(absolutePath);
+    const result = _child_process.spawnSync.call(void 0, "git", args, {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr || "Failed to remove worktree");
+    }
+    if (options.deleteBranch && branchToDelete) {
+      const deleteResult = _child_process.spawnSync.call(void 0, "git", ["branch", "-d", branchToDelete], {
+        cwd: this.repoRoot,
+        encoding: "utf8"
+      });
+      if (deleteResult.status === 0) {
+        return `Removed worktree and deleted branch ${branchToDelete}`;
+      }
+    }
+    return `Removed worktree at ${absolutePath}`;
+  }
+  // ============ Advanced Operations ============
+  /**
+   * Find and clean up stale/merged worktrees
+   */
+  async cleanup(options = {}) {
+    const worktrees = this.list();
+    const mainBranch = this.getMainBranch();
+    const toRemove = [];
+    for (const wt of worktrees) {
+      if (wt.bare || wt.path === this.repoRoot) continue;
+      if (options.removeStale !== false && wt.prunable) {
+        toRemove.push(wt);
+        continue;
+      }
+      if (options.removeMerged && wt.branch) {
+        const isMerged = this.isBranchMerged(wt.branch, mainBranch);
+        if (isMerged) {
+          toRemove.push(wt);
+        }
+      }
+    }
+    if (options.dryRun) {
+      return { removed: [], wouldRemove: toRemove.map((w) => w.path) };
+    }
+    const removed = [];
+    for (const wt of toRemove) {
+      try {
+        await this.remove(wt.path, { force: true, deleteBranch: options.removeMerged });
+        removed.push(wt.path);
+      } catch (e5) {
+      }
+    }
+    _child_process.spawnSync.call(void 0, "git", ["worktree", "prune"], { cwd: this.repoRoot });
+    return { removed, wouldRemove: [] };
+  }
+  /**
+   * Run a command in parallel across all worktrees
+   */
+  async runParallel(command, options = {}) {
+    const worktrees = this.list().filter((wt) => !wt.bare);
+    const filtered = options.filter ? worktrees.filter(options.filter) : worktrees;
+    const maxConcurrent = options.maxConcurrent || _os2.default.cpus().length;
+    const timeout = options.timeout || 3e5;
+    const results = [];
+    const running = [];
+    for (const wt of filtered) {
+      const task = (async () => {
+        const start = Date.now();
+        try {
+          const output = await this.runInWorktreeWithTimeout(wt.path, command, timeout);
+          results.push({
+            worktree: wt.path,
+            branch: wt.branch,
+            success: true,
+            output,
+            exitCode: 0,
+            duration: Date.now() - start
+          });
+        } catch (error) {
+          results.push({
+            worktree: wt.path,
+            branch: wt.branch,
+            success: false,
+            output: "",
+            error: error.message,
+            exitCode: error.exitCode || 1,
+            duration: Date.now() - start
+          });
+        }
+      })();
+      running.push(task);
+      if (running.length >= maxConcurrent) {
+        await Promise.race(running);
+      }
+    }
+    await Promise.all(running);
+    return results;
+  }
+  /**
+   * Sync changes from main branch to all worktrees
+   */
+  async syncAll(options = {}) {
+    const mainBranch = options.mainBranch || this.getMainBranch();
+    const strategy = options.strategy || "rebase";
+    const worktrees = this.list().filter((wt) => !wt.bare && wt.branch && wt.branch !== mainBranch);
+    _child_process.spawnSync.call(void 0, "git", ["fetch", "--all"], { cwd: this.repoRoot });
+    const synced = [];
+    const failed = [];
+    const skipped = [];
+    for (const wt of worktrees) {
+      const status = await this.getWorktreeStatus(wt);
+      if (!status.isClean) {
+        skipped.push(`${wt.path} (has uncommitted changes)`);
+        continue;
+      }
+      if (options.dryRun) {
+        synced.push(wt.path);
+        continue;
+      }
+      try {
+        const cmd = strategy === "rebase" ? `git rebase origin/${mainBranch}` : `git merge origin/${mainBranch}`;
+        await this.runInWorktree(wt.path, cmd);
+        synced.push(wt.path);
+      } catch (error) {
+        try {
+          await this.runInWorktree(wt.path, `git ${strategy} --abort`);
+        } catch (e6) {
+        }
+        failed.push(`${wt.path}: ${error.message}`);
+      }
+    }
+    return { synced, failed, skipped };
+  }
+  /**
+   * Create a worktree for a PR review
+   */
+  async createForPR(prNumber, remote = "origin") {
+    const branch = `pr-${prNumber}`;
+    const fetchResult = _child_process.spawnSync.call(void 0, "git", ["fetch", remote, `pull/${prNumber}/head:${branch}`], {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (fetchResult.status !== 0) {
+      throw new Error(`Failed to fetch PR #${prNumber}: ${fetchResult.stderr}`);
+    }
+    return this.create({
+      branch,
+      template: "review",
+      runSetup: true
+    });
+  }
+  /**
+   * Switch to a worktree (opens in current terminal context)
+   */
+  getWorktreePath(branchOrPath) {
+    const worktrees = this.list();
+    const byPath = worktrees.find((wt) => wt.path === branchOrPath || wt.path.endsWith(branchOrPath));
+    if (byPath) return byPath.path;
+    const byBranch = worktrees.find((wt) => wt.branch === branchOrPath);
+    if (byBranch) return byBranch.path;
+    return null;
+  }
+  // ============ Template Management ============
+  getTemplates() {
+    return [...this.templates];
+  }
+  getTemplate(name) {
+    return this.templates.find((t) => t.name === name) || null;
+  }
+  addTemplate(template) {
+    const existing = this.templates.findIndex((t) => t.name === template.name);
+    if (existing >= 0) {
+      this.templates[existing] = template;
+    } else {
+      this.templates.push(template);
+    }
+  }
+  // ============ Helper Methods ============
+  findGitRoot(cwd) {
+    const result = _child_process.spawnSync.call(void 0, "git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) {
+      throw new Error("Not a git repository");
+    }
+    return result.stdout.trim();
+  }
+  parseWorktreeList(output) {
+    const worktrees = [];
+    const entries = output.trim().split("\n\n");
+    for (const entry of entries) {
+      if (!entry.trim()) continue;
+      const lines = entry.split("\n");
+      const info = {
+        bare: false,
+        detached: false,
+        locked: false,
+        prunable: false
+      };
+      for (const line of lines) {
+        if (line.startsWith("worktree ")) {
+          info.path = line.slice(9);
+        } else if (line.startsWith("HEAD ")) {
+          info.head = line.slice(5);
+        } else if (line.startsWith("branch ")) {
+          info.branch = line.slice(7).replace("refs/heads/", "");
+        } else if (line === "bare") {
+          info.bare = true;
+        } else if (line === "detached") {
+          info.detached = true;
+        } else if (line.startsWith("locked")) {
+          info.locked = true;
+        } else if (line.startsWith("prunable")) {
+          info.prunable = true;
+        }
+      }
+      if (info.path && info.head) {
+        worktrees.push(info);
+      }
+    }
+    return worktrees;
+  }
+  async getWorktreeStatus(wt) {
+    const statusResult = _child_process.spawnSync.call(void 0, "git", ["status", "--porcelain=v1", "-b"], {
+      cwd: wt.path,
+      encoding: "utf8"
+    });
+    const lines = statusResult.stdout.trim().split("\n");
+    const branchLine = lines[0] || "";
+    const fileLines = lines.slice(1);
+    let ahead = 0;
+    let behind = 0;
+    const aheadBehindMatch = branchLine.match(/\[ahead (\d+)(?:, behind (\d+))?\]|\[behind (\d+)\]/);
+    if (aheadBehindMatch) {
+      ahead = parseInt(aheadBehindMatch[1] || "0", 10);
+      behind = parseInt(aheadBehindMatch[2] || aheadBehindMatch[3] || "0", 10);
+    }
+    let staged = 0, modified = 0, untracked = 0, conflicts = 0;
+    for (const line of fileLines) {
+      if (!line) continue;
+      const x = line[0];
+      const y = line[1];
+      if (x === "U" || y === "U" || x === "D" && y === "D" || x === "A" && y === "A") {
+        conflicts++;
+      } else {
+        if (x !== " " && x !== "?") staged++;
+        if (y === "M" || y === "D") modified++;
+        if (x === "?") untracked++;
+      }
+    }
+    const logResult = _child_process.spawnSync.call(void 0, "git", ["log", "-1", "--format=%H|%s|%an|%ai"], {
+      cwd: wt.path,
+      encoding: "utf8"
+    });
+    let lastCommit = null;
+    if (logResult.status === 0 && logResult.stdout.trim()) {
+      const [hash, message, author, date] = logResult.stdout.trim().split("|");
+      lastCommit = { hash, message, author, date };
+    }
+    return {
+      worktree: wt,
+      gitStatus: { staged, modified, untracked, conflicts, ahead, behind },
+      isClean: staged === 0 && modified === 0 && untracked === 0 && conflicts === 0,
+      lastCommit
+    };
+  }
+  getMainBranch() {
+    const result = _child_process.spawnSync.call(void 0, "git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (result.status === 0) {
+      return result.stdout.trim().replace("refs/remotes/origin/", "");
+    }
+    const branches = _child_process.spawnSync.call(void 0, "git", ["branch", "-l", "main", "master"], {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (branches.stdout.includes("main")) return "main";
+    if (branches.stdout.includes("master")) return "master";
+    return "main";
+  }
+  isBranchMerged(branch, into) {
+    const result = _child_process.spawnSync.call(void 0, "git", ["branch", "--merged", into], {
+      cwd: this.repoRoot,
+      encoding: "utf8"
+    });
+    if (result.status !== 0) return false;
+    return result.stdout.split("\n").some(
+      (line) => line.trim() === branch || line.trim() === `* ${branch}`
+    );
+  }
+  resolvePath(pattern, branch) {
+    const timestamp = Date.now().toString();
+    const sanitizedBranch = branch.replace(/[^a-zA-Z0-9-_]/g, "-");
+    return _path2.default.resolve(
+      this.repoRoot,
+      pattern.replace("{repo}", this.repoName).replace("{branch}", sanitizedBranch).replace("{timestamp}", timestamp)
+    );
+  }
+  async runInWorktree(worktreePath, command) {
+    return new Promise((resolve, reject) => {
+      const child = _child_process.spawn.call(void 0, "sh", ["-c", command], {
+        cwd: worktreePath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data;
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data;
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          const error = new Error(stderr || `Command failed with code ${code}`);
+          error.exitCode = code;
+          reject(error);
+        }
+      });
+    });
+  }
+  async runInWorktreeWithTimeout(worktreePath, command, timeout) {
+    return new Promise((resolve, reject) => {
+      const child = _child_process.spawn.call(void 0, "sh", ["-c", command], {
+        cwd: worktreePath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      let killed = false;
+      const timer = setTimeout(() => {
+        killed = true;
+        child.kill("SIGTERM");
+        reject(new Error(`Command timed out after ${timeout}ms`));
+      }, timeout);
+      child.stdout.on("data", (data) => {
+        stdout += data;
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data;
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (killed) return;
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          const error = new Error(stderr || `Command failed with code ${code}`);
+          error.exitCode = code;
+          reject(error);
+        }
+      });
+    });
+  }
+};
+
+// src/core/customCommands.ts
+
+
+var COMMANDS_DIR = _chunkSEKD5FH3cjs.AUTOHAND_PATHS.commands;
+async function loadCustomCommand(name) {
+  const filePath = _path2.default.join(COMMANDS_DIR, `${sanitizeName(name)}.json`);
+  if (!await _fsextra2.default.pathExists(filePath)) {
+    return null;
+  }
+  return _fsextra2.default.readJson(filePath);
+}
+async function saveCustomCommand(definition) {
+  await _fsextra2.default.ensureDir(COMMANDS_DIR);
+  const filePath = _path2.default.join(COMMANDS_DIR, `${sanitizeName(definition.name)}.json`);
+  await _fsextra2.default.writeJson(filePath, definition, { spaces: 2 });
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-z0-9-_]/gi, "_");
+}
+
+// src/actions/webRepo.ts
+var _https = require('https'); var https = _interopRequireWildcard(_https);
+function parseRepoUrl(input) {
+  const shorthandMatch = input.match(/^(github|gitlab):(.+)$/);
+  if (shorthandMatch) {
+    const platform = shorthandMatch[1];
+    const path8 = shorthandMatch[2];
+    const lastSlash = path8.lastIndexOf("/");
+    if (lastSlash === -1) {
+      throw new Error("Could not parse repo URL. Use format: owner/repo (GitHub), github:owner/repo, gitlab:group/project, or full URL.");
+    }
+    return {
+      platform,
+      owner: path8.slice(0, lastSlash),
+      repo: path8.slice(lastSlash + 1)
+    };
+  }
+  if (!input.includes(":") && input.includes("/")) {
+    const slashIndex = input.indexOf("/");
+    const lastSlashIndex = input.lastIndexOf("/");
+    if (slashIndex === lastSlashIndex && slashIndex > 0) {
+      const owner = input.slice(0, slashIndex);
+      const repo = input.slice(slashIndex + 1);
+      if (owner && repo) {
+        return {
+          platform: "github",
+          owner,
+          repo
+        };
+      }
+    }
+  }
+  try {
+    const url = new URL(input);
+    const hostname = url.hostname.toLowerCase();
+    const pathParts = url.pathname.replace(/\/$/, "").split("/").filter(Boolean);
+    if (pathParts.length < 2) {
+      throw new Error("Could not parse repo URL. Use format: owner/repo (GitHub), github:owner/repo, gitlab:group/project, or full URL.");
+    }
+    if (hostname === "github.com") {
+      return {
+        platform: "github",
+        owner: pathParts[0],
+        repo: pathParts[1]
+      };
+    }
+    if (hostname === "gitlab.com") {
+      const repo = pathParts[pathParts.length - 1];
+      const owner = pathParts.slice(0, -1).join("/");
+      return {
+        platform: "gitlab",
+        owner,
+        repo
+      };
+    }
+    throw new Error("Could not parse repo URL. Use format: github:owner/repo, gitlab:group/project, or full URL.");
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Could not parse")) {
+      throw e;
+    }
+    throw new Error("Could not parse repo URL. Use format: github:owner/repo, gitlab:group/project, or full URL.");
+  }
+}
+async function fetchJson(url, headers = {}) {
+  const TIMEOUT_MS = 15e3;
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      timeout: TIMEOUT_MS,
+      headers: {
+        "User-Agent": "Autohand-CLI/1.0",
+        "Accept": "application/json",
+        ...headers
+      }
+    }, (res) => {
+      if (res.statusCode === 403) {
+        reject(new Error("Rate limited. Hint: Set GITHUB_TOKEN or GITLAB_TOKEN in env or ~/.autohand/config.json to increase limits."));
+        return;
+      }
+      if (res.statusCode === 404) {
+        reject(new Error("Repository not found. Check the URL/shorthand is correct."));
+        return;
+      }
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json);
+        } catch (parseError) {
+          reject(new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+        }
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+async function fetchGitHubInfo(parsed) {
+  const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}`;
+  const token = process.env.GITHUB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const data = await fetchJson(url, headers);
+  return {
+    platform: "github",
+    name: data.name,
+    fullName: data.full_name,
+    description: data.description || "",
+    stars: data.stargazers_count,
+    language: data.language,
+    defaultBranch: data.default_branch,
+    license: _optionalChain([data, 'access', _41 => _41.license, 'optionalAccess', _42 => _42.spdx_id]) || null
+  };
+}
+async function fetchGitLabInfo(parsed) {
+  const projectPath = encodeURIComponent(`${parsed.owner}/${parsed.repo}`);
+  const url = `https://gitlab.com/api/v4/projects/${projectPath}`;
+  const token = process.env.GITLAB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["PRIVATE-TOKEN"] = token;
+  }
+  const data = await fetchJson(url, headers);
+  return {
+    platform: "gitlab",
+    name: data.name,
+    fullName: data.path_with_namespace,
+    description: data.description || "",
+    stars: data.star_count,
+    language: null,
+    // Would require additional API call to /languages
+    defaultBranch: data.default_branch,
+    license: null
+    // Would require additional API call
+  };
+}
+async function fetchRepoInfo(parsed) {
+  switch (parsed.platform) {
+    case "github":
+      return fetchGitHubInfo(parsed);
+    case "gitlab":
+      return fetchGitLabInfo(parsed);
+    default:
+      throw new Error(`Unsupported platform: ${parsed.platform}`);
+  }
+}
+async function listGitHubDir(parsed, path8, branch) {
+  const encodedPath = path8 ? encodeURIComponent(path8).replace(/%2F/g, "/") : "";
+  let url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/contents/${encodedPath}`;
+  if (branch) {
+    url += `?ref=${encodeURIComponent(branch)}`;
+  }
+  const token = process.env.GITHUB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const data = await fetchJson(url, headers);
+  return data.map((item) => ({
+    name: item.name,
+    type: item.type === "dir" ? "dir" : "file",
+    path: item.path,
+    size: item.type === "file" ? item.size : void 0
+  }));
+}
+async function listGitLabDir(parsed, path8, branch) {
+  const projectPath = encodeURIComponent(`${parsed.owner}/${parsed.repo}`);
+  let url = `https://gitlab.com/api/v4/projects/${projectPath}/repository/tree?per_page=100`;
+  if (path8) {
+    url += `&path=${encodeURIComponent(path8)}`;
+  }
+  if (branch) {
+    url += `&ref=${encodeURIComponent(branch)}`;
+  }
+  const token = process.env.GITLAB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["PRIVATE-TOKEN"] = token;
+  }
+  const data = await fetchJson(url, headers);
+  return data.map((item) => ({
+    name: item.name,
+    type: item.type === "tree" ? "dir" : "file",
+    path: item.path
+    // GitLab tree API does not return file sizes
+  }));
+}
+async function listRepoDir(parsed, path8, branch) {
+  switch (parsed.platform) {
+    case "github":
+      return listGitHubDir(parsed, path8, branch);
+    case "gitlab":
+      return listGitLabDir(parsed, path8, branch);
+    default:
+      throw new Error(`Unsupported platform: ${parsed.platform}`);
+  }
+}
+async function fetchText(url, headers = {}, maxRedirects = 5) {
+  const TIMEOUT_MS = 15e3;
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, {
+      timeout: TIMEOUT_MS,
+      headers: {
+        "User-Agent": "Autohand-CLI/1.0",
+        ...headers
+      }
+    }, (res) => {
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        if (maxRedirects <= 0) {
+          reject(new Error("Too many redirects"));
+          return;
+        }
+        const redirectUrl = new URL(res.headers.location, url).toString();
+        fetchText(redirectUrl, headers, maxRedirects - 1).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode === 403) {
+        reject(new Error("Rate limited. Hint: Set GITHUB_TOKEN or GITLAB_TOKEN in env or ~/.autohand/config.json to increase limits."));
+        return;
+      }
+      if (res.statusCode === 404) {
+        reject(new Error("File not found. Use operation 'list' to see available files."));
+        return;
+      }
+      if (res.statusCode && res.statusCode >= 400) {
+        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+        return;
+      }
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        resolve(data);
+      });
+      res.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+  });
+}
+async function fetchGitHubFile(parsed, path8, branch = "HEAD") {
+  const url = `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/${branch}/${path8}`;
+  const token = process.env.GITHUB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return fetchText(url, headers);
+}
+async function fetchGitLabFile(parsed, path8, branch = "HEAD") {
+  const projectPath = encodeURIComponent(`${parsed.owner}/${parsed.repo}`);
+  const encodedFilePath = encodeURIComponent(path8);
+  const url = `https://gitlab.com/api/v4/projects/${projectPath}/repository/files/${encodedFilePath}/raw?ref=${encodeURIComponent(branch)}`;
+  const token = process.env.GITLAB_TOKEN;
+  const headers = {};
+  if (token) {
+    headers["PRIVATE-TOKEN"] = token;
+  }
+  return fetchText(url, headers);
+}
+async function fetchRepoFile(parsed, path8, branch) {
+  switch (parsed.platform) {
+    case "github":
+      return fetchGitHubFile(parsed, path8, branch);
+    case "gitlab":
+      return fetchGitLabFile(parsed, path8, branch);
+    default:
+      throw new Error(`Unsupported platform: ${parsed.platform}`);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatRepoInfo(info) {
+  const lines = [];
+  lines.push(`**${info.fullName}** (${info.platform})`);
+  lines.push("");
+  if (info.description) {
+    lines.push(info.description);
+    lines.push("");
+  }
+  lines.push(`Stars: ${info.stars}`);
+  lines.push(`Default branch: ${info.defaultBranch}`);
+  if (info.language) {
+    lines.push(`Language: ${info.language}`);
+  }
+  if (info.license) {
+    lines.push(`License: ${info.license}`);
+  }
+  return lines.join("\n");
+}
+function formatRepoDir(files, path8) {
+  const lines = [];
+  if (path8 === "") {
+    lines.push("Repository root:");
+  } else {
+    lines.push(`Contents of ${path8}/`);
+  }
+  lines.push("");
+  const dirs = files.filter((f) => f.type === "dir").sort((a, b) => a.name.localeCompare(b.name));
+  const fileItems = files.filter((f) => f.type === "file").sort((a, b) => a.name.localeCompare(b.name));
+  for (const dir of dirs) {
+    lines.push(`\u{1F4C1} ${dir.name}/`);
+  }
+  for (const file of fileItems) {
+    if (file.size !== void 0) {
+      lines.push(`\u{1F4C4} ${file.name} (${formatBytes(file.size)})`);
+    } else {
+      lines.push(`\u{1F4C4} ${file.name}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function webRepo(options) {
+  const parsed = parseRepoUrl(options.repo);
+  switch (options.operation) {
+    case "info": {
+      const data = await fetchRepoInfo(parsed);
+      return { type: "info", data };
+    }
+    case "list": {
+      const path8 = _nullishCoalesce(options.path, () => ( ""));
+      const data = await listRepoDir(parsed, path8, options.branch);
+      return { type: "list", data, path: path8 };
+    }
+    case "fetch": {
+      const path8 = _nullishCoalesce(options.path, () => ( "README.md"));
+      const data = await fetchRepoFile(parsed, path8, options.branch);
+      return { type: "fetch", data, path: path8 };
+    }
+    default:
+      throw new Error(`Invalid operation: ${options.operation}. Valid operations are: info, list, fetch`);
+  }
+}
+
+// src/core/toolsRegistry.ts
+
+
+var ToolsRegistry = class {
+  constructor(toolsDir = _chunkSEKD5FH3cjs.AUTOHAND_PATHS.tools) {
+    this.toolsDir = toolsDir;
+    this.metaToolCache = /* @__PURE__ */ new Map();
+  }
+  async initialize() {
+    await _fsextra2.default.ensureDir(this.toolsDir);
+    await this.loadMetaToolDefinitions();
+  }
+  async listTools(builtIns) {
+    const seen = /* @__PURE__ */ new Set();
+    const entries = [];
+    for (const def of builtIns) {
+      if (seen.has(def.name)) {
+        continue;
+      }
+      entries.push({
+        name: def.name,
+        description: def.description,
+        requiresApproval: def.requiresApproval,
+        approvalMessage: def.approvalMessage,
+        source: "builtin"
+      });
+      seen.add(def.name);
+    }
+    for (const [name, tool] of this.metaToolCache) {
+      if (seen.has(name)) {
+        continue;
+      }
+      entries.push({
+        name: tool.name,
+        description: tool.description,
+        source: "meta"
+      });
+      seen.add(name);
+    }
+    return entries;
+  }
+  async saveMetaTool(definition) {
+    const fullDef = {
+      ...definition,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const filePath = _path2.default.join(this.toolsDir, `${definition.name}.json`);
+    await _fsextra2.default.writeJson(filePath, fullDef, { spaces: 2 });
+    this.metaToolCache.set(definition.name, fullDef);
+    return fullDef;
+  }
+  getMetaTool(name) {
+    return this.metaToolCache.get(name);
+  }
+  hasMetaTool(name) {
+    return this.metaToolCache.has(name);
+  }
+  getAllMetaTools() {
+    return Array.from(this.metaToolCache.values());
+  }
+  toToolDefinitions() {
+    return this.getAllMetaTools().map((tool) => {
+      const params = tool.parameters;
+      return {
+        name: tool.name,
+        description: tool.description,
+        parameters: params.properties ? {
+          type: "object",
+          properties: params.properties,
+          required: _nullishCoalesce(params.required, () => ( []))
+        } : void 0
+      };
+    });
+  }
+  async loadMetaToolDefinitions() {
+    try {
+      const exists = await _fsextra2.default.pathExists(this.toolsDir);
+      if (!exists) {
+        return;
+      }
+      const files = await _fsextra2.default.readdir(this.toolsDir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) {
+          continue;
+        }
+        const fullPath = _path2.default.join(this.toolsDir, file);
+        try {
+          const data = await _fsextra2.default.readJson(fullPath);
+          if (this.isValidMetaTool(data)) {
+            this.metaToolCache.set(data.name, data);
+          }
+        } catch (e7) {
+        }
+      }
+    } catch (e8) {
+    }
+  }
+  isValidMetaTool(candidate) {
+    if (!candidate || typeof candidate !== "object") {
+      return false;
+    }
+    const value = candidate;
+    return typeof value.name === "string" && typeof value.description === "string" && typeof value.handler === "string" && typeof value.parameters === "object";
+  }
+};
+
+// src/core/SecurityScanner.ts
+var SecurityScanner = class {
+  constructor() {
+    /**
+     * Built-in secret detection patterns
+     */
+    this.patterns = [
+      // AWS
+      {
+        name: "AWS Access Key",
+        regex: /AKIA[0-9A-Z]{16}/,
+        severity: "high",
+        description: "AWS Access Key ID"
+      },
+      // GitHub
+      {
+        name: "GitHub Token",
+        regex: /ghp_[a-zA-Z0-9]{36}/,
+        severity: "high",
+        description: "GitHub Personal Access Token"
+      },
+      {
+        name: "GitHub OAuth",
+        regex: /gho_[a-zA-Z0-9]{36}/,
+        severity: "high",
+        description: "GitHub OAuth Token"
+      },
+      {
+        name: "GitHub App Token",
+        regex: /ghu_[a-zA-Z0-9]{36}/,
+        severity: "high",
+        description: "GitHub App User Token"
+      },
+      // OpenAI / Anthropic
+      {
+        name: "OpenAI Key",
+        regex: /sk-proj-[a-zA-Z0-9]{32,}/,
+        severity: "high",
+        description: "OpenAI Project API Key"
+      },
+      {
+        name: "Anthropic Key",
+        regex: /sk-ant-api[a-zA-Z0-9-]{32,}/,
+        severity: "high",
+        description: "Anthropic API Key"
+      },
+      // Google
+      {
+        name: "Google API Key",
+        regex: /AIzaSy[0-9A-Za-z-_]{33}/,
+        severity: "high",
+        description: "Google API Key"
+      },
+      // Stripe
+      {
+        name: "Stripe Live Key",
+        regex: /sk_live_[0-9a-zA-Z]{24,}/,
+        severity: "high",
+        description: "Stripe Live Secret Key"
+      },
+      {
+        name: "Stripe Test Key",
+        regex: /sk_test_[0-9a-zA-Z]{24,}/,
+        severity: "low",
+        description: "Stripe Test Secret Key"
+      },
+      // Private Keys
+      {
+        name: "Private Key",
+        regex: /-----BEGIN (RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+        severity: "high",
+        description: "Private Key File"
+      },
+      // Database URLs with credentials
+      {
+        name: "Database URL",
+        regex: /(postgres|postgresql|mysql|mongodb|redis):\/\/[^:]+:[^@]+@/,
+        severity: "high",
+        description: "Database URL with credentials"
+      },
+      // JWT Tokens
+      {
+        name: "JWT Token",
+        regex: /eyJ[a-zA-Z0-9]{10,}\.eyJ[a-zA-Z0-9]{10,}\.[a-zA-Z0-9_-]{10,}/,
+        severity: "medium",
+        description: "JSON Web Token"
+      },
+      // Generic patterns (lower priority)
+      {
+        name: "Generic API Key",
+        regex: /[aA][pP][iI][-_]?[kK][eE][yY]\s*[:=]\s*['"][a-zA-Z0-9]{16,}['"]/,
+        severity: "medium",
+        description: "Generic API Key Assignment"
+      },
+      {
+        name: "Generic Secret",
+        regex: /[sS][eE][cC][rR][eE][tT]\s*[:=]\s*['"][^'"]{8,}['"]/,
+        severity: "medium",
+        description: "Generic Secret Assignment"
+      },
+      {
+        name: "Password Assignment",
+        regex: /[pP][aA][sS][sS][wW][oO][rR][dD]\s*[:=]\s*['"][^'"]{4,}['"]/,
+        severity: "medium",
+        description: "Password Assignment"
+      }
+    ];
+    /**
+     * Placeholder patterns to ignore (false positives)
+     * These must be exact matches or specific patterns, not substrings
+     */
+    this.placeholderPatterns = [
+      /your[-_]?api[-_]?key/i,
+      /your[-_]?secret/i,
+      /\*\*\*/,
+      /\.\.\.$/,
+      /-example/i,
+      /placeholder/i,
+      /sk-xxx$/i,
+      /sk-your/i,
+      /<your[-_]?key[-_]?here>/i,
+      /\$\{[A-Z_]+\}/,
+      // Environment variable placeholders
+      /process\.env\./
+    ];
+  }
+  /**
+   * Scan git diff for secrets
+   * @param diff - Git diff output
+   * @returns Security scan result
+   */
+  scanDiff(diff) {
+    const findings = [];
+    const lines = diff.split("\n");
+    let currentFile;
+    let lineNumber = 0;
+    for (const line of lines) {
+      if (line.startsWith("+++ b/")) {
+        currentFile = line.slice(6);
+        continue;
+      }
+      if (line.startsWith("diff --git")) {
+        const match = line.match(/diff --git a\/.+ b\/(.+)/);
+        if (match) {
+          currentFile = match[1];
+        }
+        continue;
+      }
+      if (line.startsWith("@@")) {
+        const match = line.match(/@@ -\d+(?:,\d+)? \+(\d+)/);
+        if (match) {
+          lineNumber = parseInt(match[1], 10) - 1;
+        }
+        continue;
+      }
+      if (line.startsWith("-") && !line.startsWith("---")) {
+        continue;
+      }
+      if (line.startsWith(" ")) {
+        lineNumber++;
+        continue;
+      }
+      if (!line.startsWith("+") || line.startsWith("+++")) {
+        continue;
+      }
+      lineNumber++;
+      const content = line.slice(1);
+      if (this.isLikelyFalsePositive(content)) {
+        continue;
+      }
+      this.scanLine(content, currentFile, lineNumber, findings);
+    }
+    return this.buildResult(findings);
+  }
+  /**
+   * Scan file content directly
+   * @param content - File content
+   * @param filename - Optional filename for reporting
+   * @returns Security scan result
+   */
+  scanFile(content, filename) {
+    const findings = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (this.isLikelyFalsePositive(line)) {
+        continue;
+      }
+      this.scanLine(line, filename, i + 1, findings);
+    }
+    return this.buildResult(findings);
+  }
+  /**
+   * Scan a single line for secrets
+   */
+  scanLine(line, file, lineNumber, findings) {
+    for (const pattern of this.patterns) {
+      const match = line.match(pattern.regex);
+      if (match) {
+        findings.push({
+          type: pattern.name,
+          severity: pattern.severity,
+          line,
+          lineNumber,
+          file,
+          match: match[0]
+        });
+      }
+    }
+  }
+  /**
+   * Build scan result from findings
+   */
+  buildResult(findings) {
+    const blockedCount = findings.filter((f) => f.severity === "high").length;
+    const warningCount = findings.filter((f) => f.severity !== "high").length;
+    return {
+      clean: blockedCount === 0,
+      findings,
+      blockedCount,
+      warningCount
+    };
+  }
+  /**
+   * Check if commit should be blocked based on scan result
+   * @param result - Security scan result
+   * @returns true if commit should be blocked
+   */
+  shouldBlockCommit(result) {
+    return result.blockedCount > 0;
+  }
+  /**
+   * Check if a line is likely a false positive
+   */
+  isLikelyFalsePositive(line) {
+    if (/^\s*(\/\/|#|\/\*|\*|<!--)/.test(line)) {
+      return true;
+    }
+    for (const pattern of this.placeholderPatterns) {
+      if (pattern.test(line)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Add a custom secret pattern
+   * @param pattern - Pattern to add
+   */
+  addPattern(pattern) {
+    this.patterns.push(pattern);
+  }
+  /**
+   * Get all configured patterns (returns a copy)
+   * @returns Array of secret patterns
+   */
+  getPatterns() {
+    return [...this.patterns];
+  }
+  /**
+   * Format scan result for display
+   * @param result - Security scan result
+   * @returns Formatted string for terminal display
+   */
+  formatDisplay(result) {
+    const lines = ["[SECURITY] Scanning staged changes..."];
+    if (result.findings.length === 0) {
+      lines.push("");
+      lines.push("[OK] No secrets detected");
+      return lines.join("\n");
+    }
+    lines.push("");
+    for (const finding of result.findings) {
+      const severity = finding.severity === "high" ? "[HIGH]" : finding.severity === "medium" ? "[WARN]" : "[LOW]";
+      lines.push(`  ${severity} ${finding.type} detected`);
+      if (finding.file && finding.lineNumber) {
+        lines.push(`         File: ${finding.file}:${finding.lineNumber}`);
+      } else if (finding.file) {
+        lines.push(`         File: ${finding.file}`);
+      }
+      const redactedLine = this.redactSecret(finding.line, finding.match);
+      lines.push(`         Line: ${redactedLine}`);
+      lines.push("");
+    }
+    if (result.blockedCount > 0) {
+      lines.push(`[BLOCKED] ${result.blockedCount} high-severity secrets found`);
+      lines.push("          Remove secrets before committing.");
+      lines.push("          Consider using environment variables instead.");
+    } else if (result.warningCount > 0) {
+      lines.push(`[WARN] ${result.warningCount} potential secrets found`);
+      lines.push("       Review before committing.");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Redact a secret in a line for display
+   */
+  redactSecret(line, secret) {
+    if (secret.length <= 8) {
+      return line.replace(secret, "*".repeat(secret.length));
+    }
+    const redacted = secret.slice(0, 4) + "*".repeat(secret.length - 8) + secret.slice(-4);
+    return line.replace(secret, redacted);
+  }
+};
+
+// src/core/actionExecutor.ts
+
+
+// src/modes/planMode/PlanFileStorage.ts
+
+
+var PlanFileStorage = class {
+  constructor() {
+    this.plansDir = _chunkSEKD5FH3cjs.AUTOHAND_PATHS.plans;
+  }
+  /**
+   * Get the plans directory path
+   */
+  getPlansDirectory() {
+    return this.plansDir;
+  }
+  /**
+   * Save a plan to a markdown file
+   * Returns the file path
+   */
+  async savePlan(plan) {
+    await _fsextra2.default.ensureDir(this.plansDir);
+    const filePath = _path2.default.join(this.plansDir, `${plan.id}.md`);
+    const content = this.formatPlanAsMarkdown(plan);
+    await _fsextra2.default.writeFile(filePath, content, "utf8");
+    return filePath;
+  }
+  /**
+   * Load a plan from file by ID
+   * Returns null if not found
+   */
+  async loadPlan(planId) {
+    const filePath = _path2.default.join(this.plansDir, `${planId}.md`);
+    if (!await _fsextra2.default.pathExists(filePath)) {
+      return null;
+    }
+    const content = await _fsextra2.default.readFile(filePath, "utf8");
+    return this.parsePlanFromMarkdown(content, planId);
+  }
+  /**
+   * List all plan IDs in the plans directory
+   */
+  async listPlans() {
+    if (!await _fsextra2.default.pathExists(this.plansDir)) {
+      return [];
+    }
+    const files = await _fsextra2.default.readdir(this.plansDir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+  }
+  /**
+   * Delete a plan file by ID
+   * Returns true if deleted, false if not found
+   */
+  async deletePlan(planId) {
+    const filePath = _path2.default.join(this.plansDir, `${planId}.md`);
+    if (!await _fsextra2.default.pathExists(filePath)) {
+      return false;
+    }
+    await _fsextra2.default.remove(filePath);
+    return true;
+  }
+  /**
+   * Format a plan as markdown content
+   */
+  formatPlanAsMarkdown(plan) {
+    const createdDate = new Date(plan.createdAt).toISOString();
+    const lines = [
+      `# Plan: ${plan.id}`,
+      "",
+      `Created: ${createdDate}`,
+      "",
+      "## Steps",
+      ""
+    ];
+    for (const step of plan.steps) {
+      const checkbox = this.getCheckboxForStatus(step.status);
+      lines.push(`- ${checkbox} ${step.number}. ${step.description}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Get markdown checkbox for step status
+   */
+  getCheckboxForStatus(status) {
+    switch (status) {
+      case "completed":
+        return "[x]";
+      case "in_progress":
+        return "[>]";
+      case "skipped":
+        return "[-]";
+      default:
+        return "[ ]";
+    }
+  }
+  /**
+   * Parse markdown content back to a Plan object
+   */
+  parsePlanFromMarkdown(content, planId) {
+    const steps = [];
+    const stepPattern = /^-\s+\[([ x>\-])\]\s+(\d+)\.\s+(.+)$/gm;
+    let match;
+    while ((match = stepPattern.exec(content)) !== null) {
+      const checkboxChar = match[1];
+      const number = parseInt(match[2], 10);
+      const description = match[3].trim();
+      steps.push({
+        number,
+        description,
+        status: this.parseStatusFromCheckbox(checkboxChar)
+      });
+    }
+    const dateMatch = content.match(/Created:\s*(.+)/);
+    const createdAt = dateMatch ? new Date(dateMatch[1]).getTime() : Date.now();
+    return {
+      id: planId,
+      steps,
+      rawText: steps.map((s) => `${s.number}. ${s.description}`).join("\n"),
+      createdAt
+    };
+  }
+  /**
+   * Parse step status from checkbox character
+   */
+  parseStatusFromCheckbox(char) {
+    switch (char) {
+      case "x":
+        return "completed";
+      case ">":
+        return "in_progress";
+      case "-":
+        return "skipped";
+      default:
+        return "pending";
+    }
+  }
+};
+
+// src/core/actionExecutor.ts
+
+var ActionExecutor = class _ActionExecutor {
+  constructor(deps) {
+    this.deps = deps;
+    this.searchCache = /* @__PURE__ */ new Map();
+    this.runtime = deps.runtime;
+    this.files = deps.files;
+    this.resolveWorkspacePath = deps.resolveWorkspacePath;
+    this.confirmDangerousAction = deps.confirmDangerousAction;
+    this.projectManager = deps.projectManager;
+    this.sessionId = deps.sessionId;
+    this.logExploration = deps.onExploration;
+    this.toolsRegistry = _nullishCoalesce(deps.toolsRegistry, () => ( new ToolsRegistry()));
+    this.getRegisteredTools = _nullishCoalesce(deps.getRegisteredTools, () => ( (() => [])));
+    this.permissionManager = _nullishCoalesce(deps.permissionManager, () => ( new (0, _chunkJ6QET7EFcjs.PermissionManager)(deps.runtime.config.permissions)));
+    this.memoryManager = deps.memoryManager;
+    this.onToolOutput = deps.onToolOutput;
+    this.onFileModified = deps.onFileModified;
+    this.onAskFollowup = deps.onAskFollowup;
+    this.onPlanCreated = deps.onPlanCreated;
+    this.onPermissionRequest = deps.onPermissionRequest;
+    this.securityScanner = new SecurityScanner();
+  }
+  /**
+   * Check permission hooks before prompting user.
+   * Returns true if allowed, false if denied/blocked, undefined if should ask user.
+   */
+  async checkPermissionHook(context) {
+    if (!this.onPermissionRequest) {
+      return {};
+    }
+    const hookResponse = await this.onPermissionRequest(context);
+    if (!_optionalChain([hookResponse, 'optionalAccess', _43 => _43.decision])) {
+      return {};
+    }
+    switch (hookResponse.decision) {
+      case "allow":
+        return { allowed: true, updatedInput: hookResponse.updatedInput };
+      case "deny":
+        return { allowed: false, reason: _nullishCoalesce(hookResponse.reason, () => ( "Denied by hook")) };
+      case "block":
+        return { blocked: true, reason: _nullishCoalesce(hookResponse.reason, () => ( "Blocked by hook")) };
+      case "ask":
+      default:
+        return {};
+    }
+  }
+  async execute(action, context) {
+    if (this.runtime.options.dryRun && action.type !== "search" && action.type !== "plan") {
+      return "Dry-run mode: skipped mutation";
+    }
+    switch (action.type) {
+      case "plan": {
+        const notes = _nullishCoalesce(action.notes, () => ( ""));
+        if (!notes) {
+          return "No plan notes provided";
+        }
+        const storage = new PlanFileStorage();
+        const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+        const now = Date.now();
+        const existingPlanIds = await storage.listPlans();
+        let cleanedCount = 0;
+        for (const planId of existingPlanIds) {
+          const existingPlan = await storage.loadPlan(planId);
+          if (existingPlan && now - existingPlan.createdAt > THIRTY_DAYS_MS) {
+            await storage.deletePlan(planId);
+            cleanedCount++;
+          }
+        }
+        if (cleanedCount > 0) {
+          console.log(_chalk2.default.gray(`
+\u{1F9F9} Cleaned up ${cleanedCount} plan(s) older than 30 days`));
+        }
+        const planModeManager = _chunkULQ6MDSJcjs.getPlanModeManager.call(void 0, );
+        if (planModeManager.isEnabled() && this.onAskFollowup) {
+          const refreshedPlanIds = await storage.listPlans();
+          const incompletePlans = [];
+          for (const planId of refreshedPlanIds) {
+            const existingPlan = await storage.loadPlan(planId);
+            if (existingPlan) {
+              const pendingCount = existingPlan.steps.filter((s) => s.status === "pending").length;
+              const inProgressCount = existingPlan.steps.filter((s) => s.status === "in_progress").length;
+              if (pendingCount > 0 || inProgressCount > 0) {
+                incompletePlans.push({ plan: existingPlan, pendingCount, inProgressCount });
+              }
+            }
+          }
+          if (incompletePlans.length > 0) {
+            console.log(_chalk2.default.yellow(`
+\u{1F4CB} Found ${incompletePlans.length} incomplete plan(s):`));
+            for (const { plan: plan2, pendingCount, inProgressCount } of incompletePlans) {
+              const age = Math.floor((now - plan2.createdAt) / (1e3 * 60 * 60 * 24));
+              const ageStr = age === 0 ? "today" : age === 1 ? "1 day ago" : `${age} days ago`;
+              const statusStr = inProgressCount > 0 ? `${inProgressCount} in progress, ${pendingCount} pending` : `${pendingCount} pending`;
+              console.log(_chalk2.default.gray(`   \u2022 ${plan2.id} (${ageStr}) - ${plan2.steps.length} steps, ${statusStr}`));
+            }
+            console.log();
+            const suggestedAnswers = [
+              "Create new plan",
+              ...incompletePlans.slice(0, 3).map(({ plan: plan2 }) => `Resume: ${plan2.id}`)
+            ];
+            const answer = await this.onAskFollowup(
+              "Would you like to resume an incomplete plan or create a new one?",
+              suggestedAnswers
+            );
+            const answerText = answer.replace(/<\/?answer>/g, "").trim();
+            if (answerText.toLowerCase().includes("resume:") || answerText.toLowerCase().startsWith("resume")) {
+              const resumeMatch = answerText.match(/resume[:\s]+(\S+)/i);
+              if (resumeMatch) {
+                const planIdToResume = resumeMatch[1];
+                const planToResume = incompletePlans.find((p) => p.plan.id === planIdToResume);
+                if (planToResume) {
+                  const filePath2 = `${storage.getPlansDirectory()}/${planToResume.plan.id}.md`;
+                  console.log(_chalk2.default.cyan(`
+\u{1F4CB} Resuming plan: ${planToResume.plan.id}`));
+                  console.log(_chalk2.default.gray(`   File: ${filePath2}
+`));
+                  if (this.onPlanCreated) {
+                    return this.onPlanCreated(planToResume.plan, filePath2);
+                  }
+                  return `Resumed plan ${planToResume.plan.id}
+
+Steps:
+${planToResume.plan.steps.map((s) => {
+                    const status = s.status === "completed" ? "\u2713" : s.status === "in_progress" ? ">" : "\u25CB";
+                    return `${status} ${s.number}. ${s.description}`;
+                  }).join("\n")}`;
+                }
+              }
+            }
+            console.log(_chalk2.default.cyan("\n\u{1F4CB} Creating new plan..."));
+          }
+        }
+        const lines = notes.split("\n");
+        const steps = [];
+        let stepNumber = 0;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          const numberedMatch = trimmed.match(/^(\d+)[.)]\s*(.+)$/);
+          const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+          if (numberedMatch) {
+            stepNumber = parseInt(numberedMatch[1], 10);
+            steps.push({
+              number: stepNumber,
+              description: numberedMatch[2].trim(),
+              status: "pending"
+            });
+          } else if (bulletMatch) {
+            stepNumber++;
+            steps.push({
+              number: stepNumber,
+              description: bulletMatch[1].trim(),
+              status: "pending"
+            });
+          }
+        }
+        if (steps.length === 0) {
+          steps.push({
+            number: 1,
+            description: notes.substring(0, 200),
+            status: "pending"
+          });
+        }
+        const plan = {
+          id: `plan-${_crypto.randomUUID.call(void 0, ).split("-")[0]}`,
+          steps,
+          rawText: notes,
+          createdAt: Date.now()
+        };
+        const filePath = await storage.savePlan(plan);
+        console.log(_chalk2.default.cyan(`
+\u{1F4CB} Plan created with ${steps.length} step(s)`));
+        console.log(_chalk2.default.gray(`   Saved to: ${filePath}
+`));
+        if (this.onPlanCreated) {
+          return this.onPlanCreated(plan, filePath);
+        }
+        return `Plan saved to ${filePath}
+
+Steps:
+${steps.map((s) => `${s.number}. ${s.description}`).join("\n")}`;
+      }
+      case "read_file": {
+        if (!action.path) {
+          throw new Error('read_file requires a "path" argument.');
+        }
+        const offset = typeof action.offset === "number" ? action.offset : 0;
+        const limit = typeof action.limit === "number" ? action.limit : 0;
+        const fullContents = await this.files.readFile(action.path);
+        this.recordExploration("read", action.path);
+        const allLines = fullContents.split("\n");
+        const totalLines = allLines.length;
+        const fileSize = Buffer.byteLength(fullContents, "utf8");
+        const fileSizeKB = (fileSize / 1024).toFixed(2);
+        const MAX_LINES = 2e3;
+        const MAX_SIZE_BYTES = 80 * 1024;
+        const CHUNK_SIZE = 500;
+        if (offset > 0 || limit > 0) {
+          const effectiveLimit = limit > 0 ? limit : CHUNK_SIZE;
+          const startLine = Math.min(offset, totalLines);
+          const endLine = Math.min(startLine + effectiveLimit, totalLines);
+          const chunk = allLines.slice(startLine, endLine).join("\n");
+          console.log(_chalk2.default.cyan(`
+\u{1F4C4} ${action.path}`));
+          console.log(_chalk2.default.gray(`   Lines ${startLine + 1}-${endLine} of ${totalLines} (${fileSizeKB} KB total)`));
+          if (endLine < totalLines) {
+            console.log(_chalk2.default.yellow(`   ${totalLines - endLine} more lines remaining`));
+          }
+          return chunk;
+        }
+        if (totalLines > MAX_LINES || fileSize > MAX_SIZE_BYTES) {
+          console.log(_chalk2.default.cyan(`
+\u{1F4C4} ${action.path}`));
+          console.log(_chalk2.default.yellow(`   \u26A0 Large file: ${totalLines} lines \u2022 ${fileSizeKB} KB`));
+          console.log(_chalk2.default.gray(`   Smart chunking: outline + first ${CHUNK_SIZE} lines`));
+          const outline = this.extractFileOutline(allLines, action.path);
+          const firstChunk = allLines.slice(0, CHUNK_SIZE).join("\n");
+          const response = [
+            `=== FILE OUTLINE (${action.path}) ===`,
+            `Total: ${totalLines} lines \u2022 ${fileSizeKB} KB`,
+            "",
+            outline,
+            "",
+            `=== CONTENT (lines 1-${CHUNK_SIZE}) ===`,
+            firstChunk,
+            "",
+            `=== NAVIGATION ===`,
+            `Showing lines 1-${CHUNK_SIZE} of ${totalLines}`,
+            `To read more sections, use: read_file with offset=<line> limit=${CHUNK_SIZE}`,
+            `Example: read_file path="${action.path}" offset=${CHUNK_SIZE} limit=${CHUNK_SIZE}`
+          ].join("\n");
+          return response;
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F4C4} ${action.path}`));
+        console.log(_chalk2.default.gray(`   ${totalLines} lines \u2022 ${fileSizeKB} KB`));
+        return fullContents;
+      }
+      case "write_file": {
+        if (!action.path) {
+          const receivedKeys = Object.keys(action).filter((k) => k !== "type").join(", ") || "none";
+          throw new Error(`write_file requires a "path" argument. Received arguments: [${receivedKeys}]`);
+        }
+        const filePath = this.resolveWorkspacePath(action.path);
+        const fs7 = await Promise.resolve().then(() => _interopRequireWildcard(require("fs-extra")));
+        const exists = this.files.root && await fs7.pathExists(filePath);
+        const oldContent = exists ? await this.files.readFile(action.path) : "";
+        const newContent = _nullishCoalesce(this.pickText(action.contents, action.content), () => ( ""));
+        if (!exists) {
+          const permContext = {
+            tool: "write_file",
+            path: action.path
+          };
+          const decision = this.permissionManager.checkPermission(permContext);
+          if (decision.reason === "blacklisted" || decision.reason === "mode_restricted") {
+            return `Blocked: Cannot create ${action.path} (${decision.reason})`;
+          }
+          if (decision.allowed) {
+            console.log(_chalk2.default.cyan(`
+\u2728 Creating: ${action.path}`));
+          } else {
+            const hookResult = await this.checkPermissionHook({
+              tool: "write_file",
+              path: action.path,
+              args: { content: newContent }
+            });
+            if (hookResult.blocked) {
+              return `Blocked: ${hookResult.reason}`;
+            }
+            if (hookResult.allowed !== void 0) {
+              if (hookResult.allowed) {
+                console.log(_chalk2.default.cyan(`
+\u2728 Creating: ${action.path}`));
+                await this.permissionManager.recordDecision(permContext, true);
+              } else {
+                await this.permissionManager.recordDecision(permContext, false);
+                return `Denied: ${hookResult.reason}`;
+              }
+            } else {
+              console.log(_chalk2.default.cyan(`
+\u2728 Creating new file: ${action.path}`));
+              const preview = newContent.length > 500 ? newContent.substring(0, 500) + "\n... (truncated)" : newContent;
+              console.log(_chalk2.default.gray(preview));
+              const confirmed = await this.confirmDangerousAction(
+                `Create new file ${action.path}?`,
+                { tool: "write_file", path: action.path }
+              );
+              await this.permissionManager.recordDecision(permContext, confirmed);
+              if (!confirmed) {
+                return `Skipped creating ${action.path}`;
+              }
+            }
+          }
+        } else if (oldContent === newContent) {
+          return `No changes needed for ${action.path} (content identical)`;
+        } else {
+          console.log(_chalk2.default.cyan(`
+\u{1F4DD} ${action.path}:`));
+          this.showDiff(oldContent, newContent, action.path);
+        }
+        await this.files.writeFile(action.path, newContent);
+        _optionalChain([this, 'access', _44 => _44.onFileModified, 'optionalCall', _45 => _45(action.path)]);
+        return exists ? `Updated ${action.path}` : `Created ${action.path}`;
+      }
+      case "append_file": {
+        if (!action.path) {
+          throw new Error('append_file requires a "path" argument.');
+        }
+        const addition = _nullishCoalesce(this.pickText(action.contents, action.content), () => ( ""));
+        const oldContent = await this.files.readFile(action.path).catch(() => "");
+        const newContent = oldContent + addition;
+        console.log(_chalk2.default.cyan(`
+\u{1F4DD} ${action.path}:`));
+        this.showDiff(oldContent, newContent, action.path);
+        await this.files.appendFile(action.path, addition);
+        _optionalChain([this, 'access', _46 => _46.onFileModified, 'optionalCall', _47 => _47(action.path)]);
+        return `Appended to ${action.path}`;
+      }
+      case "apply_patch": {
+        if (!action.path) {
+          throw new Error('apply_patch requires a "path" argument.');
+        }
+        const oldContent = await this.files.readFile(action.path).catch(() => "");
+        const patch = this.pickText(action.patch, action.diff);
+        if (!patch) {
+          throw new Error("apply_patch requires patch or diff content.");
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F527} ${action.path}:`));
+        console.log(_chalk2.default.gray("Applying patch..."));
+        await this.files.applyPatch(action.path, patch);
+        const newContent = await this.files.readFile(action.path);
+        this.showDiff(oldContent, newContent, action.path);
+        _optionalChain([this, 'access', _48 => _48.onFileModified, 'optionalCall', _49 => _49(action.path)]);
+        return `Patched ${action.path}`;
+      }
+      case "tools_registry": {
+        const tools = await this.toolsRegistry.listTools(this.getRegisteredTools());
+        return JSON.stringify(tools, null, 2);
+      }
+      case "search": {
+        const cacheKey = `search:${action.query}:${action.path || ""}`;
+        if (this.searchCache.has(cacheKey)) {
+          return `[Cached] ${this.searchCache.get(cacheKey)}`;
+        }
+        const hits = this.files.search(action.query, action.path);
+        this.recordExploration("search", action.query);
+        const result = hits.slice(0, 10).map((hit) => `${hit.file}:${hit.line}: ${hit.text}`).join("\n");
+        this.searchCache.set(cacheKey, result);
+        return result;
+      }
+      case "search_with_context": {
+        const cacheKey = `search_ctx:${action.query}:${action.path || ""}:${action.limit || ""}:${action.context || ""}`;
+        if (this.searchCache.has(cacheKey)) {
+          return `[Cached] ${this.searchCache.get(cacheKey)}`;
+        }
+        this.recordExploration("search", action.query);
+        const result = this.files.searchWithContext(action.query, {
+          limit: action.limit,
+          context: action.context,
+          relativePath: action.path
+        });
+        this.searchCache.set(cacheKey, result);
+        return result;
+      }
+      case "semantic_search": {
+        const cacheKey = `semantic:${action.query}:${action.path || ""}:${action.limit || ""}:${action.window || ""}`;
+        if (this.searchCache.has(cacheKey)) {
+          return `[Cached] ${this.searchCache.get(cacheKey)}`;
+        }
+        const results = this.files.semanticSearch(action.query, {
+          limit: action.limit,
+          window: action.window,
+          relativePath: action.path
+        });
+        if (!results.length) {
+          this.searchCache.set(cacheKey, "No matches found.");
+          return "No matches found.";
+        }
+        const result = results.map((hit) => `${_chalk2.default.cyan(hit.file)}
+${hit.snippet}`).join("\n\n");
+        this.searchCache.set(cacheKey, result);
+        return result;
+      }
+      case "create_directory": {
+        await this.files.createDirectory(action.path);
+        return `Created directory ${action.path}`;
+      }
+      case "delete_path": {
+        if (!action.path) {
+          throw new Error('delete_path requires a "path" argument.');
+        }
+        const confirmed = await this.confirmDangerousAction(
+          `Delete ${action.path}?`,
+          { tool: "delete_path", path: action.path }
+        );
+        if (!confirmed) {
+          return `Skipped deleting ${action.path}`;
+        }
+        await this.files.deletePath(action.path);
+        return `Deleted ${action.path}`;
+      }
+      case "rename_path": {
+        if (!action.from || !action.to) {
+          throw new Error('rename_path requires "from" and "to" arguments.');
+        }
+        await this.files.renamePath(action.from, action.to);
+        return `Renamed ${action.from} -> ${action.to}`;
+      }
+      case "copy_path": {
+        if (!action.from || !action.to) {
+          throw new Error('copy_path requires "from" and "to" arguments.');
+        }
+        await this.files.copyPath(action.from, action.to);
+        return `Copied ${action.from} -> ${action.to}`;
+      }
+      case "search_replace": {
+        const content = await this.files.readFile(action.path);
+        const result = this.applySearchReplaceBlocks(content, action.blocks);
+        if (content !== result) {
+          console.log(_chalk2.default.cyan(`
+\u{1F504} ${action.path}:`));
+          this.showDiff(content, result, action.path);
+          await this.files.writeFile(action.path, result);
+          _optionalChain([this, 'access', _50 => _50.onFileModified, 'optionalCall', _51 => _51(action.path)]);
+        }
+        return `Updated ${action.path}`;
+      }
+      case "format_file": {
+        if (!action.path) {
+          throw new Error('format_file requires a "path" argument.');
+        }
+        await this.files.formatFile(action.path, (contents, file) => _chunk4JNNTOGFcjs.applyFormatter.call(void 0, action.formatter, contents, file));
+        return `Formatted ${action.path} (${action.formatter})`;
+      }
+      case "run_command": {
+        if (!action.command || typeof action.command !== "string") {
+          return 'Error: run_command requires a "command" argument (string)';
+        }
+        const shouldStreamOutput = Boolean(
+          this.onToolOutput && _optionalChain([context, 'optionalAccess', _52 => _52.toolCallId]) && !action.background && process.env.AUTOHAND_STREAM_TOOL_OUTPUT === "1"
+        );
+        const emitOutput = (stream, data) => {
+          if (!shouldStreamOutput) {
+            return;
+          }
+          _optionalChain([this, 'access', _53 => _53.onToolOutput, 'optionalCall', _54 => _54({
+            tool: action.type,
+            toolCallId: _optionalChain([context, 'optionalAccess', _55 => _55.toolCallId]),
+            stream,
+            data
+          })]);
+        };
+        const result = await runCommand(
+          action.command,
+          _nullishCoalesce(action.args, () => ( [])),
+          this.runtime.workspaceRoot,
+          {
+            directory: action.directory,
+            background: action.background,
+            onStdout: (chunk) => emitOutput("stdout", chunk),
+            onStderr: (chunk) => emitOutput("stderr", chunk)
+          }
+        );
+        const cmdStr = `${action.command} ${(_nullishCoalesce(action.args, () => ( []))).join(" ")}`.trim();
+        const header = action.description ? `$ ${action.description}
+> ${cmdStr}` : `$ ${cmdStr}`;
+        const dirInfo = action.directory ? `[dir: ${action.directory}]` : "";
+        const parts = [
+          dirInfo ? `${header} ${dirInfo}` : header,
+          result.stdout,
+          result.stderr
+        ].filter(Boolean);
+        if (result.backgroundPid) {
+          parts.push(`[Background PID: ${result.backgroundPid}]`);
+        }
+        return parts.join("\n");
+      }
+      case "add_dependency": {
+        await addDependency(this.runtime.workspaceRoot, action.name, action.version, { dev: action.dev });
+        return `Added dependency ${action.name}@${action.version}${action.dev ? " (dev)" : ""}`;
+      }
+      case "remove_dependency": {
+        await removeDependency(this.runtime.workspaceRoot, action.name, { dev: action.dev });
+        return `Removed dependency ${action.name}${action.dev ? " (dev)" : ""}`;
+      }
+      case "list_tree": {
+        const treeRoot = this.resolveWorkspacePath(_nullishCoalesce(action.path, () => ( ".")));
+        const lines = await listDirectoryTree(treeRoot, {
+          depth: action.depth,
+          workspaceRoot: this.runtime.workspaceRoot
+        });
+        this.recordExploration("list", _nullishCoalesce(action.path, () => ( ".")));
+        return lines.join("\n");
+      }
+      case "file_stats": {
+        if (!action.path) {
+          throw new Error('file_stats requires a "path" argument.');
+        }
+        this.resolveWorkspacePath(action.path);
+        const stats = await fileStats(this.runtime.workspaceRoot, action.path);
+        return stats ? JSON.stringify(stats, null, 2) : `No stats for ${action.path}`;
+      }
+      case "checksum": {
+        if (!action.path) {
+          throw new Error('checksum requires a "path" argument.');
+        }
+        this.resolveWorkspacePath(action.path);
+        const sum = await checksumFile(this.runtime.workspaceRoot, action.path, action.algorithm);
+        return `${_nullishCoalesce(action.algorithm, () => ( "sha256"))} ${action.path}: ${sum}`;
+      }
+      case "git_diff": {
+        if (!action.path) {
+          throw new Error('git_diff requires a "path" argument.');
+        }
+        this.resolveWorkspacePath(action.path);
+        const rawDiff = diffFile(this.runtime.workspaceRoot, action.path);
+        return this.colorizeGitDiff(rawDiff);
+      }
+      case "git_checkout": {
+        if (!action.path) {
+          throw new Error('git_checkout requires a "path" argument.');
+        }
+        this.resolveWorkspacePath(action.path);
+        checkoutFile(this.runtime.workspaceRoot, action.path);
+        return `Restored ${action.path} from git.`;
+      }
+      case "git_status":
+        return gitStatus(this.runtime.workspaceRoot);
+      case "git_list_untracked":
+        return gitListUntracked(this.runtime.workspaceRoot) || "No untracked files.";
+      case "git_diff_range": {
+        const rawDiff = gitDiffRange(this.runtime.workspaceRoot, {
+          range: action.range,
+          staged: action.staged,
+          paths: action.paths
+        });
+        return this.colorizeGitDiff(rawDiff);
+      }
+      case "git_apply_patch": {
+        const patch = this.pickText(action.patch, action.diff);
+        if (!patch) {
+          throw new Error("git_apply_patch requires patch or diff content.");
+        }
+        applyGitPatch(this.runtime.workspaceRoot, patch);
+        return "Applied git patch.";
+      }
+      case "git_worktree_list":
+        return gitListWorktrees(this.runtime.workspaceRoot);
+      case "git_worktree_add": {
+        const worktreePath = this.resolveWorkspacePath(action.path);
+        return gitAddWorktree(this.runtime.workspaceRoot, worktreePath, action.ref);
+      }
+      case "git_worktree_remove": {
+        const worktreePath = this.resolveWorkspacePath(action.path);
+        return gitRemoveWorktree(this.runtime.workspaceRoot, worktreePath, action.force);
+      }
+      // Advanced Worktree Operations
+      case "git_worktree_status_all": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        const statuses = await manager.statusAll();
+        if (statuses.length === 0) {
+          return "No worktrees found.";
+        }
+        const lines = [_chalk2.default.cyan("\u{1F4CA} Worktree Status Summary:"), ""];
+        for (const status of statuses) {
+          const branchName = status.worktree.branch || "(detached)";
+          const cleanIcon = status.isClean ? _chalk2.default.green("\u2713") : _chalk2.default.yellow("!");
+          const syncInfo = status.gitStatus.ahead > 0 || status.gitStatus.behind > 0 ? _chalk2.default.gray(` [\u2191${status.gitStatus.ahead} \u2193${status.gitStatus.behind}]`) : "";
+          lines.push(`${cleanIcon} ${_chalk2.default.bold(branchName)}${syncInfo}`);
+          lines.push(_chalk2.default.gray(`   ${status.worktree.path}`));
+          if (!status.isClean) {
+            const changes = [];
+            if (status.gitStatus.staged > 0) changes.push(`${status.gitStatus.staged} staged`);
+            if (status.gitStatus.modified > 0) changes.push(`${status.gitStatus.modified} modified`);
+            if (status.gitStatus.untracked > 0) changes.push(`${status.gitStatus.untracked} untracked`);
+            if (status.gitStatus.conflicts > 0) changes.push(_chalk2.default.red(`${status.gitStatus.conflicts} conflicts`));
+            lines.push(_chalk2.default.yellow(`   ${changes.join(", ")}`));
+          }
+          if (status.lastCommit) {
+            lines.push(_chalk2.default.gray(`   Last commit: ${status.lastCommit.message.substring(0, 50)}`));
+          }
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      case "git_worktree_cleanup": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        const result = await manager.cleanup({
+          dryRun: action.dry_run,
+          removeMerged: action.remove_merged,
+          removeStale: action.remove_stale
+        });
+        if (action.dry_run) {
+          if (result.wouldRemove.length === 0) {
+            return "No worktrees to clean up.";
+          }
+          return `Would remove ${result.wouldRemove.length} worktree(s):
+${result.wouldRemove.map((p) => `  - ${p}`).join("\n")}`;
+        }
+        if (result.removed.length === 0) {
+          return "No worktrees were cleaned up.";
+        }
+        return `Cleaned up ${result.removed.length} worktree(s):
+${result.removed.map((p) => `  - ${p}`).join("\n")}`;
+      }
+      case "git_worktree_run_parallel": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        console.log(_chalk2.default.cyan(`
+\u{1F504} Running "${action.command}" across all worktrees...
+`));
+        const results = await manager.runParallel(action.command, {
+          timeout: action.timeout,
+          maxConcurrent: action.max_concurrent
+        });
+        const lines = [];
+        let successCount = 0;
+        let failCount = 0;
+        for (const result of results) {
+          const branchName = result.branch || "(detached)";
+          const statusIcon = result.success ? _chalk2.default.green("\u2713") : _chalk2.default.red("\u2717");
+          const duration = `${(result.duration / 1e3).toFixed(1)}s`;
+          lines.push(`${statusIcon} ${_chalk2.default.bold(branchName)} (${duration})`);
+          if (result.success) {
+            successCount++;
+            if (result.output.trim()) {
+              lines.push(_chalk2.default.gray(result.output.trim().split("\n").map((l) => `   ${l}`).join("\n")));
+            }
+          } else {
+            failCount++;
+            lines.push(_chalk2.default.red(`   Error: ${result.error}`));
+          }
+          lines.push("");
+        }
+        lines.unshift(
+          _chalk2.default.cyan(`\u{1F4CA} Results: ${successCount} succeeded, ${failCount} failed`),
+          ""
+        );
+        return lines.join("\n");
+      }
+      case "git_worktree_sync": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        const result = await manager.syncAll({
+          strategy: action.strategy,
+          mainBranch: action.main_branch,
+          dryRun: action.dry_run
+        });
+        const lines = [_chalk2.default.cyan("\u{1F504} Worktree Sync Results:"), ""];
+        if (result.synced.length > 0) {
+          lines.push(_chalk2.default.green(`Synced (${result.synced.length}):`));
+          for (const path8 of result.synced) {
+            lines.push(`  \u2713 ${path8}`);
+          }
+          lines.push("");
+        }
+        if (result.skipped.length > 0) {
+          lines.push(_chalk2.default.yellow(`Skipped (${result.skipped.length}):`));
+          for (const info of result.skipped) {
+            lines.push(`  \u2298 ${info}`);
+          }
+          lines.push("");
+        }
+        if (result.failed.length > 0) {
+          lines.push(_chalk2.default.red(`Failed (${result.failed.length}):`));
+          for (const info of result.failed) {
+            lines.push(`  \u2717 ${info}`);
+          }
+        }
+        return lines.join("\n");
+      }
+      case "git_worktree_create_for_pr": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        const result = await manager.createForPR(action.pr_number, action.remote);
+        return `Created worktree for PR #${action.pr_number}:
+  Path: ${result.path}
+  Branch: ${result.branch}`;
+      }
+      case "git_worktree_create_from_template": {
+        const manager = new WorktreeManager(this.runtime.workspaceRoot);
+        const templates = manager.getTemplates();
+        const template = templates.find((t) => t.name === action.template);
+        if (!template) {
+          const available = templates.map((t) => t.name).join(", ");
+          throw new Error(`Unknown template "${action.template}". Available: ${available}`);
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F4C1} Creating worktree from template "${action.template}"...`));
+        console.log(_chalk2.default.gray(`   Template: ${template.description}`));
+        const result = await manager.create({
+          branch: action.branch,
+          newBranch: true,
+          baseBranch: action.base_branch,
+          template: action.template,
+          runSetup: action.run_setup
+        });
+        return `Created worktree from template "${action.template}":
+  Path: ${result.path}
+  Branch: ${result.branch}`;
+      }
+      // Git Stash Operations
+      case "git_stash":
+        return gitStash(this.runtime.workspaceRoot, {
+          message: action.message,
+          includeUntracked: action.include_untracked,
+          keepIndex: action.keep_index
+        });
+      case "git_stash_list":
+        return gitStashList(this.runtime.workspaceRoot);
+      case "git_stash_pop":
+        return gitStashPop(this.runtime.workspaceRoot, action.stash_ref);
+      case "git_stash_apply":
+        return gitStashApply(this.runtime.workspaceRoot, action.stash_ref);
+      case "git_stash_drop":
+        return gitStashDrop(this.runtime.workspaceRoot, action.stash_ref);
+      // Git Branch Operations
+      case "git_branch":
+        return gitBranch(this.runtime.workspaceRoot, action.branch_name, {
+          delete: action.delete,
+          force: action.force
+        });
+      case "git_switch":
+        return gitSwitch(this.runtime.workspaceRoot, action.branch_name, {
+          create: action.create
+        });
+      // Git Cherry-pick Operations
+      case "git_cherry_pick":
+        return gitCherryPick(this.runtime.workspaceRoot, action.commits, {
+          noCommit: action.no_commit,
+          mainline: action.mainline
+        });
+      case "git_cherry_pick_abort":
+        return gitCherryPickAbort(this.runtime.workspaceRoot);
+      case "git_cherry_pick_continue":
+        return gitCherryPickContinue(this.runtime.workspaceRoot);
+      // Git Rebase Operations
+      case "git_rebase":
+        return gitRebase(this.runtime.workspaceRoot, action.upstream, {
+          onto: action.onto,
+          autosquash: action.autosquash
+        });
+      case "git_rebase_abort":
+        return gitRebaseAbort(this.runtime.workspaceRoot);
+      case "git_rebase_continue":
+        return gitRebaseContinue(this.runtime.workspaceRoot);
+      case "git_rebase_skip":
+        return gitRebaseSkip(this.runtime.workspaceRoot);
+      // Git Merge Operations
+      case "git_merge":
+        return gitMerge(this.runtime.workspaceRoot, action.branch, {
+          noCommit: action.no_commit,
+          noFastForward: action.no_ff,
+          squash: action.squash,
+          message: action.message
+        });
+      case "git_merge_abort":
+        return gitMergeAbort(this.runtime.workspaceRoot);
+      // Git Commit Operations
+      case "git_commit": {
+        const scanResult = await this.scanBeforeCommit();
+        if (scanResult) {
+          return scanResult;
+        }
+        return gitCommit(this.runtime.workspaceRoot, {
+          message: action.message,
+          amend: action.amend,
+          allowEmpty: action.allow_empty
+        });
+      }
+      case "git_add":
+        return gitAdd(this.runtime.workspaceRoot, action.paths);
+      case "git_reset":
+        return gitReset(this.runtime.workspaceRoot, action.mode, action.ref);
+      case "auto_commit": {
+        const autoCommitScanResult = await this.scanBeforeCommit();
+        if (autoCommitScanResult) {
+          return autoCommitScanResult;
+        }
+        const info = getAutoCommitInfo(this.runtime.workspaceRoot);
+        if (!info.canCommit) {
+          console.log(_chalk2.default.yellow(`
+\u26A0 ${info.error}`));
+          return info.error || "Cannot commit";
+        }
+        let commitMessage = action.message || info.suggestedMessage;
+        console.log(_chalk2.default.cyan("\n\u{1F4DD} Changes to commit:"));
+        info.filesChanged.slice(0, 10).forEach((file) => {
+          console.log(_chalk2.default.gray(`   ${file}`));
+        });
+        if (info.filesChanged.length > 10) {
+          console.log(_chalk2.default.gray(`   ... and ${info.filesChanged.length - 10} more files`));
+        }
+        console.log();
+        console.log(_chalk2.default.cyan("Suggested commit message:"));
+        console.log(_chalk2.default.white(`   ${commitMessage}`));
+        console.log();
+        const autoApproveCommit = Boolean(
+          this.runtime.options.yes || process.env.CI === "1" || process.env.AUTOHAND_NON_INTERACTIVE === "1"
+        );
+        if (autoApproveCommit) {
+          console.log(_chalk2.default.gray("Auto-commit approval enabled; committing without prompt."));
+          const result2 = executeAutoCommit(this.runtime.workspaceRoot, commitMessage, action.stage_all !== false);
+          if (result2.success) {
+            console.log(_chalk2.default.green(`
+\u2713 ${result2.message}`));
+            return result2.message;
+          }
+          console.log(_chalk2.default.red(`
+\u2717 ${result2.message}`));
+          return result2.message;
+        }
+        const options = [
+          { label: "Yes - commit with this message", value: "y" },
+          { label: "Edit - modify the message", value: "e" },
+          { label: "No - cancel commit", value: "n" }
+        ];
+        const modalResult = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
+          title: "Commit with this message?",
+          options
+        });
+        if (!modalResult || modalResult.value === "n") {
+          console.log(_chalk2.default.yellow("Commit cancelled."));
+          return "Commit cancelled by user";
+        }
+        if (modalResult.value === "e") {
+          const editedMessage = await _chunkZYQMLKOKcjs.showInput.call(void 0, {
+            title: "Enter commit message:",
+            defaultValue: commitMessage
+          });
+          if (editedMessage) {
+            commitMessage = editedMessage;
+          }
+        }
+        const result = executeAutoCommit(this.runtime.workspaceRoot, commitMessage, action.stage_all !== false);
+        if (result.success) {
+          console.log(_chalk2.default.green(`
+\u2713 ${result.message}`));
+          return result.message;
+        } else {
+          console.log(_chalk2.default.red(`
+\u2717 ${result.message}`));
+          return result.message;
+        }
+      }
+      // Git Log Operations
+      case "git_log":
+        return gitLog(this.runtime.workspaceRoot, {
+          maxCount: action.max_count,
+          oneline: action.oneline,
+          graph: action.graph,
+          all: action.all
+        });
+      // Git Remote Operations
+      case "git_fetch":
+        return gitFetch(this.runtime.workspaceRoot, action.remote, action.branch);
+      case "git_pull":
+        return gitPull(this.runtime.workspaceRoot, action.remote, action.branch);
+      case "git_push":
+        return gitPush(this.runtime.workspaceRoot, action.remote, action.branch, {
+          force: action.force,
+          setUpstream: action.set_upstream
+        });
+      case "custom_command":
+        return this.executeCustomCommand(action);
+      case "multi_file_edit": {
+        const oldContent = await this.files.readFile(action.file_path);
+        let newContent = oldContent;
+        console.log(_chalk2.default.cyan(`
+\u270F\uFE0F  ${action.file_path}:`));
+        console.log(_chalk2.default.gray(`Applying ${action.edits.length} edit(s)...`));
+        for (let i = 0; i < action.edits.length; i++) {
+          const edit = action.edits[i];
+          if (edit.replace_all) {
+            const count = (newContent.match(new RegExp(this.escapeRegex(edit.old_string), "g")) || []).length;
+            if (count === 0) {
+              console.log(_chalk2.default.yellow(`  \u26A0 Edit ${i + 1}: No occurrences found to replace`));
+              console.log(_chalk2.default.gray(`    Looking for: "${edit.old_string.substring(0, 60)}${edit.old_string.length > 60 ? "..." : ""}"`));
+              const similar = this.findSimilarText(newContent, edit.old_string);
+              if (similar) {
+                console.log(_chalk2.default.gray(`    Similar text found: "${similar.substring(0, 60)}${similar.length > 60 ? "..." : ""}"`));
+              }
+              continue;
+            }
+            newContent = newContent.replaceAll(edit.old_string, edit.new_string);
+            console.log(_chalk2.default.green(`  \u2713 Edit ${i + 1}: Replaced ${count} occurrence(s)`));
+          } else {
+            let firstIndex = newContent.indexOf(edit.old_string);
+            if (firstIndex === -1) {
+              const normalizedOld = this.normalizeText(edit.old_string);
+              const normalizedContent = this.normalizeText(newContent);
+              const normalizedIndex = normalizedContent.indexOf(normalizedOld);
+              if (normalizedIndex !== -1) {
+                console.log(_chalk2.default.yellow(`  \u26A0 Edit ${i + 1}: Found match with normalized text (unicode chars differ)`));
+                const actualOldString = this.extractMatchingText(newContent, normalizedContent, normalizedOld, normalizedIndex);
+                if (actualOldString) {
+                  firstIndex = newContent.indexOf(actualOldString);
+                  if (firstIndex !== -1) {
+                    newContent = newContent.substring(0, firstIndex) + edit.new_string + newContent.substring(firstIndex + actualOldString.length);
+                    console.log(_chalk2.default.green(`  \u2713 Edit ${i + 1}: Applied with normalized match`));
+                    continue;
+                  }
+                }
+              }
+            }
+            if (firstIndex === -1) {
+              console.log(_chalk2.default.red(`  \u2717 Edit ${i + 1}: Could not find text to replace`));
+              console.log(_chalk2.default.gray(`    Looking for (${edit.old_string.length} chars):`));
+              console.log(_chalk2.default.gray(`    "${edit.old_string.substring(0, 80)}${edit.old_string.length > 80 ? "..." : ""}"`));
+              const similar = this.findSimilarText(newContent, edit.old_string);
+              if (similar) {
+                console.log(_chalk2.default.yellow(`    Did you mean:`));
+                console.log(_chalk2.default.yellow(`    "${similar.substring(0, 80)}${similar.length > 80 ? "..." : ""}"`));
+              }
+              if (edit.old_string.length < 100) {
+                const nonAscii = edit.old_string.match(/[^\x20-\x7E\n\r\t]/g);
+                if (nonAscii && nonAscii.length > 0) {
+                  console.log(_chalk2.default.gray(`    Non-ASCII chars: ${nonAscii.map((c) => `'${c}' (U+${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")})`).join(", ")}`));
+                }
+              }
+              throw new Error(`Could not find text to replace in edit ${i + 1}. See details above.`);
+            }
+            newContent = newContent.substring(0, firstIndex) + edit.new_string + newContent.substring(firstIndex + edit.old_string.length);
+            console.log(_chalk2.default.green(`  \u2713 Edit ${i + 1}: Applied successfully`));
+          }
+        }
+        if (oldContent !== newContent) {
+          this.showDiff(oldContent, newContent, action.file_path);
+          await this.files.writeFile(action.file_path, newContent);
+          _optionalChain([this, 'access', _56 => _56.onFileModified, 'optionalCall', _57 => _57(action.file_path)]);
+        }
+        return `Applied ${action.edits.length} edit(s) to ${action.file_path}`;
+      }
+      case "todo_write": {
+        const todoPath = ".autohand/agents/tasks/todos.json";
+        if (!Array.isArray(action.tasks)) {
+          console.log(_chalk2.default.yellow("\u26A0\uFE0F todo_write received invalid tasks (not an array), skipping"));
+          return "todo_write skipped: tasks must be an array";
+        }
+        const validTasks = action.tasks.filter((task) => {
+          if (!task) return false;
+          const hasId = !!task.id;
+          const hasContent = !!(task.content || task.title);
+          return hasId && hasContent;
+        });
+        const normalizedTasks = validTasks.map((task) => {
+          const content = task.content || task.title || "";
+          const title = content;
+          return {
+            ...task,
+            // Preserve extra properties like priority, tags, etc.
+            id: task.id,
+            title,
+            content,
+            // Keep original content field
+            status: task.status || "pending",
+            activeForm: task.activeForm || title,
+            description: task.description
+          };
+        });
+        const allTodos = normalizedTasks;
+        await this.files.writeFile(todoPath, JSON.stringify(allTodos, null, 2));
+        console.log(_chalk2.default.cyan("\n\u{1F4CB} Task Progress:"));
+        const total = allTodos.length;
+        const completed = allTodos.filter((t) => t.status === "completed").length;
+        const inProgress = allTodos.filter((t) => t.status === "in_progress");
+        const pending = allTodos.filter((t) => t.status === "pending").length;
+        const percent = total > 0 ? Math.round(completed / total * 100) : 0;
+        const barWidth = 20;
+        const filled = Math.round(barWidth * percent / 100);
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+        console.log(`  ${_chalk2.default.green(bar)} ${percent}%`);
+        console.log(_chalk2.default.gray(`  ${completed} done \xB7 ${inProgress.length} in progress \xB7 ${pending} pending`));
+        if (inProgress.length > 0) {
+          console.log(_chalk2.default.yellow("\n  \u{1F504} Active Tasks:"));
+          for (const task of inProgress) {
+            console.log(`    \u2022 ${task.title || task.content}`);
+          }
+        }
+        console.log();
+        return `Updated task list: ${percent}% complete (${completed}/${total})`;
+      }
+      case "save_memory": {
+        if (!this.memoryManager) {
+          return "Memory manager not available";
+        }
+        const level = _nullishCoalesce(action.level, () => ( "user"));
+        await this.memoryManager.store(action.fact, level);
+        console.log(_chalk2.default.green(`
+\u{1F4BE} Memory saved (${level} level): "${action.fact.slice(0, 60)}${action.fact.length > 60 ? "..." : ""}"`));
+        return `Saved to ${level} memory: ${action.fact}`;
+      }
+      case "recall_memory": {
+        if (!this.memoryManager) {
+          return "Memory manager not available";
+        }
+        const memories = await this.memoryManager.recall(action.query, action.level);
+        if (memories.length === 0) {
+          return action.query ? `No memories found matching "${action.query}"` : "No memories stored yet";
+        }
+        const formatted = memories.map((m) => `- [${m.level}] ${m.content}`).join("\n");
+        console.log(_chalk2.default.cyan(`
+\u{1F9E0} Recalled ${memories.length} memor${memories.length === 1 ? "y" : "ies"}:`));
+        console.log(_chalk2.default.gray(formatted));
+        return formatted;
+      }
+      case "create_meta_tool": {
+        if (!action.name || !action.description || !action.handler) {
+          throw new Error("create_meta_tool requires name, description, and handler");
+        }
+        const builtInNames = this.getRegisteredTools().map((t) => t.name);
+        if (builtInNames.includes(action.name)) {
+          throw new Error(`Cannot create meta-tool "${action.name}": conflicts with built-in tool`);
+        }
+        const dangerousPatterns = [
+          // Destructive file operations
+          { pattern: /rm\s+(-[rf]+\s+)*\/(?!\w)/i, description: "rm with root path" },
+          { pattern: /rm\s+.*--no-preserve-root/i, description: "rm --no-preserve-root" },
+          { pattern: /dd\s+.*(?:of|if)=\/dev\/[sh]d/i, description: "dd to disk device" },
+          { pattern: /mkfs\./i, description: "filesystem format" },
+          { pattern: /wipefs/i, description: "disk wipe" },
+          // Privilege escalation
+          { pattern: /\bsudo\s/i, description: "sudo command" },
+          { pattern: /\bsu\s+-?\s*\w/i, description: "su command" },
+          { pattern: /chmod\s+[0-7]*7[0-7]*/i, description: "world-writable chmod" },
+          { pattern: /chown\s+root/i, description: "chown to root" },
+          // Remote code execution
+          { pattern: /curl\s+.*\|\s*(ba)?sh/i, description: "curl | bash" },
+          { pattern: /wget\s+.*\|\s*(ba)?sh/i, description: "wget | sh" },
+          { pattern: /\beval\s+[`$]/i, description: "eval with expansion" },
+          // Fork bomb and resource exhaustion
+          { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/i, description: "fork bomb" },
+          { pattern: /while\s+true.*do.*done/i, description: "infinite loop" },
+          // Reverse shell indicators
+          { pattern: /nc\s+.*-e\s*\/bin/i, description: "netcat reverse shell" },
+          { pattern: /ncat\s+.*-e\s*\/bin/i, description: "ncat reverse shell" },
+          { pattern: /bash\s+-i\s+>&?\s*\/dev\/tcp/i, description: "bash reverse shell" },
+          // Dangerous network operations
+          { pattern: /iptables\s+-F/i, description: "flush firewall rules" },
+          // Crypto operations that could lock out user
+          { pattern: /gpg\s+.*--encrypt.*-r\s+\S+\s+\//i, description: "gpg encrypt root" }
+        ];
+        for (const { pattern, description } of dangerousPatterns) {
+          if (pattern.test(action.handler)) {
+            throw new Error(`Handler contains dangerous pattern: ${description}`);
+          }
+        }
+        await this.toolsRegistry.saveMetaTool({
+          name: action.name,
+          description: action.description,
+          parameters: _nullishCoalesce(action.parameters, () => ( { type: "object", properties: {} })),
+          handler: action.handler,
+          source: "agent"
+        });
+        console.log(_chalk2.default.green(`
+\u{1F527} Created meta-tool: ${action.name}`));
+        console.log(_chalk2.default.gray(`   ${action.description}`));
+        console.log(_chalk2.default.gray(`   Handler: ${action.handler}`));
+        return `Created meta-tool "${action.name}" - available in this and future sessions`;
+      }
+      // Web Search Operations
+      case "web_search": {
+        if (!action.query) {
+          throw new Error('web_search requires a "query" argument.');
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F50D} Searching web: "${action.query}"...`));
+        const results = await _chunkRKJTGGMUcjs.webSearch.call(void 0, action.query, {
+          maxResults: action.max_results,
+          searchType: action.search_type
+        });
+        const formatted = _chunkRKJTGGMUcjs.formatSearchResults.call(void 0, results);
+        console.log(_chalk2.default.gray(formatted.split("\n").slice(0, 10).join("\n")));
+        if (results.length > 3) {
+          console.log(_chalk2.default.gray("   ..."));
+        }
+        return formatted;
+      }
+      case "fetch_url": {
+        if (!action.url) {
+          throw new Error('fetch_url requires a "url" argument.');
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F310} Fetching: ${action.url}...`));
+        const content = await _chunkRKJTGGMUcjs.fetchUrl.call(void 0, action.url, {
+          maxLength: action.max_length
+        });
+        const preview = content.slice(0, 500);
+        console.log(_chalk2.default.gray(preview + (content.length > 500 ? "\n   ... (truncated)" : "")));
+        return content;
+      }
+      case "package_info": {
+        if (!action.package_name) {
+          throw new Error('package_info requires a "package_name" argument.');
+        }
+        const registryLabel = action.registry ? ` (${action.registry})` : "";
+        console.log(_chalk2.default.cyan(`
+\u{1F4E6} Getting package info: ${action.package_name}${action.version ? `@${action.version}` : ""}${registryLabel}...`));
+        const info = await _chunkRKJTGGMUcjs.getPackageInfo.call(void 0, action.package_name, {
+          registry: action.registry,
+          version: action.version
+        });
+        const formatted = _chunkRKJTGGMUcjs.formatPackageInfo.call(void 0, info);
+        console.log(_chalk2.default.gray(formatted));
+        return formatted;
+      }
+      case "web_repo": {
+        if (!action.repo) {
+          throw new Error('web_repo requires a "repo" argument.');
+        }
+        if (!action.operation) {
+          throw new Error('web_repo requires an "operation" argument (info, list, or fetch).');
+        }
+        console.log(_chalk2.default.cyan(`
+\u{1F517} ${action.operation}: ${action.repo}${action.path ? ` \u2192 ${action.path}` : ""}...`));
+        const result = await webRepo({
+          repo: action.repo,
+          operation: action.operation,
+          path: action.path,
+          branch: action.branch
+        });
+        let formattedResult;
+        switch (result.type) {
+          case "info":
+            formattedResult = formatRepoInfo(result.data);
+            break;
+          case "list":
+            formattedResult = formatRepoDir(result.data, result.path);
+            break;
+          case "fetch":
+            formattedResult = result.data;
+            break;
+        }
+        const previewResult = formattedResult.slice(0, 500);
+        console.log(_chalk2.default.gray(previewResult + (formattedResult.length > 500 ? "\n   ... (truncated)" : "")));
+        return formattedResult;
+      }
+      // Skills Discovery
+      case "find_agent_skills": {
+        const query = _nullishCoalesce(action.query, () => ( ""));
+        console.log(_chalk2.default.cyan(`
+Searching skills: "${query}"${action.category ? ` [${action.category}]` : ""}...`));
+        const { searchCommunitySkills } = await Promise.resolve().then(() => _interopRequireWildcard(require("./skills-FYY6F2WV.cjs")));
+        const result = await searchCommunitySkills(query, {
+          category: action.category,
+          limit: action.limit
+        });
+        console.log(_chalk2.default.gray(result.split("\n").slice(0, 15).join("\n")));
+        return result;
+      }
+      // User interaction
+      case "ask_followup_question": {
+        if (!action.question) {
+          throw new Error('ask_followup_question requires a "question" parameter.');
+        }
+        if (this.onAskFollowup) {
+          return this.onAskFollowup(action.question, action.suggested_answers);
+        }
+        console.log(_chalk2.default.cyan("\n\u2753 " + action.question + "\n"));
+        if (Array.isArray(action.suggested_answers) && action.suggested_answers.length > 0) {
+          const options = action.suggested_answers.map((answer, i) => ({
+            label: `${i + 1}. ${answer}`,
+            value: answer
+          }));
+          options.push({
+            label: `${options.length + 1}. Other (type your own answer)`,
+            value: "__other__"
+          });
+          const result = await _chunkZYQMLKOKcjs.showModal.call(void 0, {
+            title: "Select an answer:",
+            options
+          });
+          const selected = _optionalChain([result, 'optionalAccess', _58 => _58.value]);
+          if (!selected) {
+            console.log(_chalk2.default.yellow("\nAnswer cancelled.\n"));
+            return "<answer>No answer provided</answer>";
+          }
+          if (selected === "__other__") {
+            const answer = await _chunkZYQMLKOKcjs.showInput.call(void 0, {
+              title: "Your answer:"
+            });
+            if (!answer) {
+              console.log(_chalk2.default.yellow("\nAnswer cancelled.\n"));
+              return "<answer>No answer provided</answer>";
+            }
+            console.log(_chalk2.default.green(`
+\u2713 Answer: ${answer}
+`));
+            return `<answer>${answer}</answer>`;
+          }
+          console.log(_chalk2.default.green(`
+\u2713 Answer: ${selected}
+`));
+          return `<answer>${selected}</answer>`;
+        } else {
+          const answer = await _chunkZYQMLKOKcjs.showInput.call(void 0, {
+            title: "Your answer:"
+          });
+          const finalAnswer = answer || "No answer provided";
+          console.log(_chalk2.default.green(`
+\u2713 Answer: ${finalAnswer}
+`));
+          return `<answer>${finalAnswer}</answer>`;
+        }
+      }
+      default: {
+        const actionType = action.type;
+        const metaTool = this.toolsRegistry.getMetaTool(actionType);
+        if (metaTool) {
+          return this.executeMetaTool(metaTool, action);
+        }
+        throw new Error(`Unsupported action type ${actionType}`);
+      }
+    }
+  }
+  pickText(...values) {
+    for (const value of values) {
+      if (typeof value === "string") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract file outline/structure for smart chunking of large files.
+   * Identifies imports, classes, functions, and key sections with line numbers.
+   */
+  extractFileOutline(lines, filePath) {
+    const ext = _optionalChain([filePath, 'access', _59 => _59.split, 'call', _60 => _60("."), 'access', _61 => _61.pop, 'call', _62 => _62(), 'optionalAccess', _63 => _63.toLowerCase, 'call', _64 => _64()]) || "";
+    const outline = [];
+    const patterns = {
+      ts: [
+        /^(import|export)\s+/,
+        /^(export\s+)?(async\s+)?function\s+(\w+)/,
+        /^(export\s+)?(abstract\s+)?class\s+(\w+)/,
+        /^(export\s+)?interface\s+(\w+)/,
+        /^(export\s+)?type\s+(\w+)/,
+        /^(export\s+)?enum\s+(\w+)/,
+        /^(export\s+)?const\s+(\w+)\s*[=:]/
+      ],
+      js: [
+        /^(import|export)\s+/,
+        /^(export\s+)?(async\s+)?function\s+(\w+)/,
+        /^(export\s+)?class\s+(\w+)/,
+        /^(export\s+)?const\s+(\w+)\s*=/,
+        /^module\.exports/
+      ],
+      py: [
+        /^(from|import)\s+/,
+        /^(async\s+)?def\s+(\w+)/,
+        /^class\s+(\w+)/,
+        /^(\w+)\s*=\s*(lambda|def)/
+      ],
+      rs: [
+        /^(use|mod)\s+/,
+        /^(pub\s+)?(async\s+)?fn\s+(\w+)/,
+        /^(pub\s+)?struct\s+(\w+)/,
+        /^(pub\s+)?enum\s+(\w+)/,
+        /^(pub\s+)?trait\s+(\w+)/,
+        /^impl\s+/
+      ],
+      go: [
+        /^import\s+/,
+        /^func\s+(\w+|\(\w+\s+\*?\w+\)\s+\w+)/,
+        /^type\s+(\w+)\s+(struct|interface)/,
+        /^var\s+(\w+)/,
+        /^const\s+/
+      ]
+    };
+    const langPatterns = patterns[ext] || patterns["ts"] || [];
+    if (["tsx", "jsx", "mts", "cts"].includes(ext)) {
+      langPatterns.push(...patterns["ts"] || []);
+    }
+    let importStart = -1;
+    let importEnd = -1;
+    lines.forEach((line, idx) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) {
+        return;
+      }
+      const lineNum = idx + 1;
+      if (/^(import|from|use|require)\s+/.test(trimmed)) {
+        if (importStart === -1) {
+          importStart = lineNum;
+        }
+        importEnd = lineNum;
+        return;
+      }
+      for (const pattern of langPatterns) {
+        if (pattern.test(trimmed) && !/^(import|from|use)\s+/.test(trimmed)) {
+          let identifier = trimmed.slice(0, 60);
+          if (identifier.length < trimmed.length) identifier += "...";
+          outline.push(`  ${String(lineNum).padStart(4)}: ${identifier}`);
+          break;
+        }
+      }
+    });
+    const result = [];
+    if (importStart !== -1) {
+      result.push(`Imports: lines ${importStart}-${importEnd}`);
+    }
+    if (outline.length > 0) {
+      result.push("");
+      result.push("Definitions:");
+      result.push(...outline.slice(0, 50));
+      if (outline.length > 50) {
+        result.push(`  ... and ${outline.length - 50} more`);
+      }
+    }
+    return result.length > 0 ? result.join("\n") : "No structure detected";
+  }
+  recordExploration(kind, target) {
+    if (!target) {
+      return;
+    }
+    _optionalChain([this, 'access', _65 => _65.logExploration, 'optionalCall', _66 => _66({ kind, target })]);
+  }
+  async executeCustomCommand(action) {
+    const existing = await loadCustomCommand(action.name);
+    const definition = _nullishCoalesce(existing, () => ( {
+      name: action.name,
+      command: action.command,
+      args: action.args,
+      description: action.description,
+      dangerous: action.dangerous
+    }));
+    if (!definition.command || typeof definition.command !== "string") {
+      return `Error: custom_command "${action.name}" requires a "command" argument (string)`;
+    }
+    if (!existing) {
+      console.log(_chalk2.default.cyan(`Custom command: ${definition.name}`));
+      console.log(_chalk2.default.gray(_nullishCoalesce(definition.description, () => ( "No description provided."))));
+      console.log(_chalk2.default.gray(`Command: ${definition.command} ${(_nullishCoalesce(definition.args, () => ( []))).join(" ")}`));
+      if (this.isDestructiveCommand(definition.command)) {
+        console.log(_chalk2.default.red("Warning: command may be destructive."));
+      }
+      const answer = await this.confirmDangerousAction(
+        "Add and run this custom command?",
+        { tool: "run_command", command: definition.command }
+      );
+      if (!answer) {
+        return "Custom command rejected by user.";
+      }
+      await saveCustomCommand(definition);
+    }
+    const result = await runCommand(definition.command, _nullishCoalesce(definition.args, () => ( [])), this.runtime.workspaceRoot);
+    return [`$ ${definition.command} ${(_nullishCoalesce(definition.args, () => ( []))).join(" ")}`, result.stdout, result.stderr].filter(Boolean).join("\n");
+  }
+  isDestructiveCommand(command) {
+    const lowered = command.toLowerCase();
+    return lowered.includes("rm ") || lowered.includes("sudo ") || lowered.includes("dd ");
+  }
+  static {
+    /**
+     * Shell metacharacters that could enable command injection
+     */
+    this.SHELL_METACHARACTERS = /[|;&$`><(){}[\]!#*?~'"\\]/;
+  }
+  /**
+   * Safely escape a value for shell interpolation
+   * Uses single quotes which prevent all shell expansion except for single quotes themselves
+   */
+  shellEscape(value) {
+    return "'" + value.replace(/'/g, `'"'"'`) + "'";
+  }
+  /**
+   * Execute a dynamic meta-tool by substituting {{param}} placeholders
+   */
+  async executeMetaTool(metaTool, args) {
+    let command = metaTool.handler;
+    const placeholderRegex = /\{\{(\w+)\}\}/g;
+    let match;
+    while ((match = placeholderRegex.exec(metaTool.handler)) !== null) {
+      const paramName = match[1];
+      const value = args[paramName];
+      if (value === void 0 || value === null) {
+        throw new Error(`Missing required parameter "${paramName}" for meta-tool "${metaTool.name}"`);
+      }
+      const stringValue = String(value);
+      let safeValue;
+      if (_ActionExecutor.SHELL_METACHARACTERS.test(stringValue)) {
+        safeValue = this.shellEscape(stringValue);
+        console.log(_chalk2.default.yellow(`   \u26A0 Parameter "${paramName}" contains shell metacharacters, escaped for safety`));
+      } else {
+        safeValue = stringValue;
+      }
+      command = command.replace(new RegExp(`\\{\\{${paramName}\\}\\}`, "g"), safeValue);
+    }
+    console.log(_chalk2.default.cyan(`
+\u{1F527} Running meta-tool: ${metaTool.name}`));
+    console.log(_chalk2.default.gray(`   $ ${command}`));
+    const result = await runCommand(command, [], this.runtime.workspaceRoot, { shell: true });
+    return [`$ ${command}`, result.stdout, result.stderr].filter(Boolean).join("\n");
+  }
+  applySearchReplaceBlocks(content, blocks) {
+    let result = content;
+    if (blocks.includes("SEARCH:") && blocks.includes("REPLACE:") && !blocks.includes("<<<<<<< SEARCH")) {
+      const searchIdx = blocks.indexOf("SEARCH:");
+      const replaceIdx = blocks.indexOf("REPLACE:");
+      if (searchIdx !== -1 && replaceIdx !== -1 && replaceIdx > searchIdx) {
+        const searchText = blocks.slice(searchIdx + 7, replaceIdx).trim();
+        const replaceText = blocks.slice(replaceIdx + 8).trim();
+        const idx = result.indexOf(searchText);
+        if (idx === -1) {
+          throw new Error(`SEARCH text not found: "${searchText.slice(0, 50)}..."`);
+        }
+        result = result.slice(0, idx) + replaceText + result.slice(idx + searchText.length);
+        return result;
+      }
+    }
+    const MARKERS = { search: "<<<<<<< SEARCH", div: "=======", replace: ">>>>>>> REPLACE" };
+    let remaining = blocks;
+    while (remaining.includes(MARKERS.search)) {
+      const searchStart = remaining.indexOf(MARKERS.search);
+      const divPos = remaining.indexOf(MARKERS.div, searchStart);
+      const replaceEnd = remaining.indexOf(MARKERS.replace, divPos);
+      if (divPos === -1 || replaceEnd === -1) {
+        throw new Error("Malformed SEARCH/REPLACE block");
+      }
+      const searchText = remaining.slice(searchStart + MARKERS.search.length, divPos).replace(/^\n/, "").replace(/\n$/, "");
+      const replaceText = remaining.slice(divPos + MARKERS.div.length, replaceEnd).replace(/^\n/, "").replace(/\n$/, "");
+      const idx = result.indexOf(searchText);
+      if (idx === -1) {
+        throw new Error(`SEARCH text not found: "${searchText.slice(0, 50)}..."`);
+      }
+      result = result.slice(0, idx) + replaceText + result.slice(idx + searchText.length);
+      remaining = remaining.slice(replaceEnd + MARKERS.replace.length);
+    }
+    return result;
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Normalize text by converting common unicode variants to ASCII equivalents
+   */
+  normalizeText(text) {
+    return text.replace(/[\u2014\u2013]/g, "-").replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"').replace(/\u2026/g, "...").replace(/\u00A0/g, " ").replace(/[\u200B\u200C\u200D\uFEFF]/g, "");
+  }
+  /**
+   * Extract the actual text from original content that matches a normalized position
+   */
+  extractMatchingText(originalContent, normalizedContent, normalizedSearch, normalizedIndex) {
+    let origIdx = 0;
+    let normIdx = 0;
+    while (normIdx < normalizedIndex && origIdx < originalContent.length) {
+      const origChar = originalContent[origIdx];
+      const normChar = this.normalizeText(origChar);
+      origIdx++;
+      normIdx += normChar.length;
+    }
+    const startIdx = origIdx;
+    const targetNormEnd = normalizedIndex + normalizedSearch.length;
+    while (normIdx < targetNormEnd && origIdx < originalContent.length) {
+      const origChar = originalContent[origIdx];
+      const normChar = this.normalizeText(origChar);
+      origIdx++;
+      normIdx += normChar.length;
+    }
+    return originalContent.substring(startIdx, origIdx);
+  }
+  /**
+   * Find text similar to the search string in the content
+   * Uses a simple approach: look for lines that share significant words
+   */
+  findSimilarText(content, search) {
+    const commonWords = /* @__PURE__ */ new Set(["the", "and", "for", "are", "but", "not", "you", "all", "can", "had", "her", "was", "one", "our", "out"]);
+    const searchWords = search.toLowerCase().split(/\s+/).filter((w) => w.length >= 3 && !commonWords.has(w)).slice(0, 5);
+    if (searchWords.length === 0) return null;
+    const lines = content.split("\n");
+    let bestMatch = null;
+    for (const line of lines) {
+      const lineLower = line.toLowerCase();
+      let score = 0;
+      for (const word of searchWords) {
+        if (lineLower.includes(word)) {
+          score++;
+        }
+      }
+      const searchStart = search.substring(0, Math.min(20, search.length)).toLowerCase();
+      if (lineLower.includes(searchStart)) {
+        score += 2;
+      }
+      if (score > 0 && (!bestMatch || score > bestMatch.score)) {
+        bestMatch = { line: line.trim(), score };
+      }
+    }
+    return bestMatch && bestMatch.score >= 2 ? bestMatch.line : null;
+  }
+  /**
+   * Colorize raw git diff output with green for additions and red for removals
+   */
+  colorizeGitDiff(diffOutput) {
+    const useTheme = _chunkPGRH5Q77cjs.isThemeInitialized.call(void 0, );
+    const theme = useTheme ? _chunkPGRH5Q77cjs.getTheme.call(void 0, ) : null;
+    if (!diffOutput || diffOutput === "No diff") {
+      return theme ? theme.fg("muted", "No changes") : _chalk2.default.gray("No changes");
+    }
+    const termWidth = process.stdout.columns || 100;
+    const lines = diffOutput.split("\n");
+    const colorizedLines = [];
+    let additions = 0;
+    let deletions = 0;
+    const addedColor = _optionalChain([theme, 'optionalAccess', _67 => _67.getColor, 'call', _68 => _68("diffAdded")]) || "#4caf50";
+    const removedColor = _optionalChain([theme, 'optionalAccess', _69 => _69.getColor, 'call', _70 => _70("diffRemoved")]) || "#f44336";
+    const contextColor = _optionalChain([theme, 'optionalAccess', _71 => _71.getColor, 'call', _72 => _72("diffContext")]) || "#9e9e9e";
+    const accentColor = _optionalChain([theme, 'optionalAccess', _73 => _73.getColor, 'call', _74 => _74("accent")]) || "#00bcd4";
+    const addedRgb = _chunkPGRH5Q77cjs.hexToRgb.call(void 0, addedColor);
+    const removedRgb = _chunkPGRH5Q77cjs.hexToRgb.call(void 0, removedColor);
+    const addBgR = addedRgb ? Math.floor(addedRgb.r * 0.15) : 30;
+    const addBgG = addedRgb ? Math.floor(addedRgb.g * 0.2) : 50;
+    const addBgB = addedRgb ? Math.floor(addedRgb.b * 0.15) : 30;
+    const remBgR = removedRgb ? Math.floor(removedRgb.r * 0.25) : 60;
+    const remBgG = removedRgb ? Math.floor(removedRgb.g * 0.15) : 30;
+    const remBgB = removedRgb ? Math.floor(removedRgb.b * 0.15) : 30;
+    for (const line of lines) {
+      if (line.startsWith("+++") || line.startsWith("---")) {
+        colorizedLines.push(_chalk2.default.bold(line));
+      } else if (line.startsWith("@@")) {
+        colorizedLines.push(_chalk2.default.hex(accentColor)(line));
+      } else if (line.startsWith("+")) {
+        additions++;
+        const content = line.slice(1);
+        const prefix = _chalk2.default.bgHex(addedColor).black(" + ");
+        const lineContent = _chalk2.default.bgRgb(addBgR, addBgG, addBgB)(` ${content} `.padEnd(Math.max(termWidth - 5, content.length + 2)));
+        colorizedLines.push(prefix + lineContent);
+      } else if (line.startsWith("-")) {
+        deletions++;
+        const content = line.slice(1);
+        const prefix = _chalk2.default.bgHex(removedColor).white(" - ");
+        const lineContent = _chalk2.default.bgRgb(remBgR, remBgG, remBgB)(` ${content} `.padEnd(Math.max(termWidth - 5, content.length + 2)));
+        colorizedLines.push(prefix + lineContent);
+      } else if (line.startsWith("diff --git")) {
+        colorizedLines.push(_chalk2.default.bold.hex(accentColor)(line));
+      } else if (line.startsWith("index ") || line.startsWith("new file") || line.startsWith("deleted file")) {
+        colorizedLines.push(_chalk2.default.hex(contextColor)(line));
+      } else {
+        colorizedLines.push(_chalk2.default.hex(contextColor)("   ") + line);
+      }
+    }
+    const addText = additions === 1 ? "1 line" : `${additions} lines`;
+    const delText = deletions === 1 ? "1 line" : `${deletions} lines`;
+    const statsLine = _chalk2.default.hex(contextColor)(`  Added ${_chalk2.default.hex(addedColor)(addText)}, removed ${_chalk2.default.hex(removedColor)(delText)}
+`);
+    return statsLine + colorizedLines.join("\n");
+  }
+  /**
+   * Scan staged changes for secrets before commit
+   * @returns Error message if blocked, undefined if safe to proceed
+   */
+  async scanBeforeCommit() {
+    try {
+      const diff = _child_process.execSync.call(void 0, "git diff --cached", {
+        cwd: this.runtime.workspaceRoot,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      });
+      if (!diff.trim()) {
+        return void 0;
+      }
+      const result = this.securityScanner.scanDiff(diff);
+      console.log(this.securityScanner.formatDisplay(result));
+      if (this.securityScanner.shouldBlockCommit(result)) {
+        return `[BLOCKED] Commit blocked: ${result.blockedCount} high-severity secret(s) detected. Remove secrets before committing.`;
+      }
+      return void 0;
+    } catch (e9) {
+      console.log(_chalk2.default.yellow("\n[WARN] Could not scan for secrets (git diff failed)"));
+      return void 0;
+    }
+  }
+  showDiff(oldContent, newContent, filePath) {
+    const diff = _diff.diffLines.call(void 0, oldContent, newContent);
+    const contextLines = 3;
+    const lang = filePath ? detectLanguage(filePath) : "text";
+    const shouldHighlight = lang !== "text";
+    const useTheme = _chunkPGRH5Q77cjs.isThemeInitialized.call(void 0, );
+    const theme = useTheme ? _chunkPGRH5Q77cjs.getTheme.call(void 0, ) : null;
+    let additions = 0;
+    let deletions = 0;
+    for (const part of diff) {
+      const lineCount = part.value.split("\n").filter((l, i, a) => i < a.length - 1 || l !== "").length;
+      if (part.added) additions += lineCount;
+      else if (part.removed) deletions += lineCount;
+    }
+    const termWidth = process.stdout.columns || 100;
+    const addText = additions === 1 ? "1 line" : `${additions} lines`;
+    const delText = deletions === 1 ? "1 line" : `${deletions} lines`;
+    if (theme) {
+      console.log(theme.fg("muted", `  Added ${theme.fg("diffAdded", addText)}, removed ${theme.fg("diffRemoved", delText)}`));
+    } else {
+      console.log(_chalk2.default.gray(`  Added ${_chalk2.default.green(addText)}, removed ${_chalk2.default.red(delText)}`));
+    }
+    const hunks = [];
+    let currentHunk = null;
+    let oldLineNum = 1;
+    let newLineNum = 1;
+    let contextBuffer = [];
+    for (const part of diff) {
+      const lines = part.value.split("\n").filter((line, idx, arr) => {
+        return idx < arr.length - 1 || line !== "";
+      });
+      if (!part.added && !part.removed) {
+        if (currentHunk) {
+          const trailing = lines.slice(0, contextLines);
+          for (const line of trailing) {
+            currentHunk.changes.push({ line, type: "context", oldNum: oldLineNum, newNum: newLineNum });
+            oldLineNum++;
+            newLineNum++;
+          }
+          if (lines.length > contextLines * 2) {
+            hunks.push(currentHunk);
+            currentHunk = null;
+            const skipped = lines.length - trailing.length;
+            oldLineNum += skipped - contextLines;
+            newLineNum += skipped - contextLines;
+            contextBuffer = lines.slice(-contextLines).map((line, i) => ({
+              line,
+              oldNum: oldLineNum + i,
+              newNum: newLineNum + i
+            }));
+            oldLineNum += contextLines;
+            newLineNum += contextLines;
+          } else {
+            for (let i = contextLines; i < lines.length; i++) {
+              currentHunk.changes.push({ line: lines[i], type: "context", oldNum: oldLineNum, newNum: newLineNum });
+              oldLineNum++;
+              newLineNum++;
+            }
+          }
+        } else {
+          contextBuffer = lines.slice(-contextLines).map((line, i) => ({
+            line,
+            oldNum: oldLineNum + lines.length - contextLines + i,
+            newNum: newLineNum + lines.length - contextLines + i
+          }));
+          oldLineNum += lines.length;
+          newLineNum += lines.length;
+        }
+      } else {
+        if (!currentHunk) {
+          currentHunk = {
+            oldStart: contextBuffer.length > 0 ? contextBuffer[0].oldNum : oldLineNum,
+            newStart: contextBuffer.length > 0 ? contextBuffer[0].newNum : newLineNum,
+            changes: contextBuffer.map((c) => ({ line: c.line, type: "context", oldNum: c.oldNum, newNum: c.newNum }))
+          };
+          contextBuffer = [];
+        }
+        if (part.added) {
+          for (const line of lines) {
+            currentHunk.changes.push({ line, type: "add", newNum: newLineNum });
+            newLineNum++;
+          }
+        } else {
+          for (const line of lines) {
+            currentHunk.changes.push({ line, type: "remove", oldNum: oldLineNum });
+            oldLineNum++;
+          }
+        }
+      }
+    }
+    if (currentHunk) {
+      hunks.push(currentHunk);
+    }
+    for (const hunk of hunks) {
+      for (const change of hunk.changes) {
+        const lineNum = change.type === "add" ? change.newNum : change.oldNum;
+        const lineNumStr = String(lineNum || 0).padStart(3);
+        const highlighted = shouldHighlight ? highlightLine(change.line, lang) : change.line;
+        if (theme) {
+          const addedColor = theme.getColor("diffAdded");
+          const removedColor = theme.getColor("diffRemoved");
+          const contextColor = theme.getColor("diffContext");
+          if (change.type === "add") {
+            const addedRgb = _chunkPGRH5Q77cjs.hexToRgb.call(void 0, addedColor);
+            const bgR = addedRgb ? Math.floor(addedRgb.r * 0.15) : 30;
+            const bgG = addedRgb ? Math.floor(addedRgb.g * 0.2) : 50;
+            const bgB = addedRgb ? Math.floor(addedRgb.b * 0.15) : 30;
+            const prefix = _chalk2.default.bgHex(addedColor).black(` ${lineNumStr} + `);
+            const content = _chalk2.default.bgRgb(bgR, bgG, bgB)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
+            console.log(prefix + content);
+          } else if (change.type === "remove") {
+            const removedRgb = _chunkPGRH5Q77cjs.hexToRgb.call(void 0, removedColor);
+            const bgR = removedRgb ? Math.floor(removedRgb.r * 0.25) : 60;
+            const bgG = removedRgb ? Math.floor(removedRgb.g * 0.15) : 30;
+            const bgB = removedRgb ? Math.floor(removedRgb.b * 0.15) : 30;
+            const prefix = _chalk2.default.bgHex(removedColor).white(` ${lineNumStr} - `);
+            const content = _chalk2.default.bgRgb(bgR, bgG, bgB)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
+            console.log(prefix + content);
+          } else {
+            console.log(_chalk2.default.hex(contextColor)(` ${lineNumStr}   `) + ` ${highlighted}`);
+          }
+        } else {
+          if (change.type === "add") {
+            const prefix = _chalk2.default.bgGreen.black(` ${lineNumStr} + `);
+            const content = _chalk2.default.bgRgb(30, 50, 30)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
+            console.log(prefix + content);
+          } else if (change.type === "remove") {
+            const prefix = _chalk2.default.bgRed.white(` ${lineNumStr} - `);
+            const content = _chalk2.default.bgRgb(60, 30, 30)(` ${highlighted} `.padEnd(Math.max(termWidth - 10, change.line.length + 2)));
+            console.log(prefix + content);
+          } else {
+            console.log(_chalk2.default.gray(` ${lineNumStr}   `) + ` ${highlighted}`);
+          }
+        }
+      }
+    }
+    console.log();
+  }
+};
+
+
+
+
+
+exports.getAutoCommitInfo = getAutoCommitInfo; exports.ToolsRegistry = ToolsRegistry; exports.ActionExecutor = ActionExecutor;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Syntax Highlighting for Terminal Output
+ * Uses regex-based tokenization for common languages
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Advanced Git Worktree Manager
+ * Provides intelligent worktree automation for parallel development workflows
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * GitHub and GitLab repository browsing capabilities.
+ */
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Plan File Storage
+ * Saves/loads plans to/from .autohand/plans/ directory
+ */