@shareai-lab/kode 1.1.12 → 1.1.13

package/dist/utils/PersistentShell.js

@@ -0,0 +1,382 @@
+import * as fs from "fs";
+import { existsSync } from "fs";
+import shellquote from "shell-quote";
+import { spawn, execSync } from "child_process";
+import { isAbsolute, resolve, join } from "path";
+import { logError } from "./log.js";
+import * as os from "os";
+import { logEvent } from "../services/statsig.js";
+import { PRODUCT_COMMAND } from "../constants/product.js";
+const TEMPFILE_PREFIX = os.tmpdir() + `/${PRODUCT_COMMAND}-`;
+const DEFAULT_TIMEOUT = 30 * 60 * 1e3;
+const SIGTERM_CODE = 143;
+const FILE_SUFFIXES = {
+  STATUS: "-status",
+  STDOUT: "-stdout",
+  STDERR: "-stderr",
+  CWD: "-cwd"
+};
+const SHELL_CONFIGS = {
+  "/bin/bash": ".bashrc",
+  "/bin/zsh": ".zshrc"
+};
+function quoteForBash(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+function toBashPath(pathStr, type) {
+  if (pathStr.startsWith("/")) return pathStr;
+  if (type === "posix") return pathStr;
+  const normalized = pathStr.replace(/\\/g, "/").replace(/\\\\/g, "/");
+  const driveMatch = /^[A-Za-z]:/.exec(normalized);
+  if (driveMatch) {
+    const drive = normalized[0].toLowerCase();
+    const rest = normalized.slice(2);
+    if (type === "msys") {
+      return `/` + drive + (rest.startsWith("/") ? rest : `/${rest}`);
+    }
+    return `/mnt/` + drive + (rest.startsWith("/") ? rest : `/${rest}`);
+  }
+  return normalized;
+}
+function fileExists(p) {
+  return !!p && existsSync(p);
+}
+function splitPathEntries(pathEnv, platform) {
+  if (!pathEnv) return [];
+  if (platform !== "win32") {
+    return pathEnv.split(":").map((s) => s.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  }
+  const entries = [];
+  let current = "";
+  const pushCurrent = () => {
+    const cleaned = current.trim().replace(/^"|"$/g, "");
+    if (cleaned) entries.push(cleaned);
+    current = "";
+  };
+  for (let i = 0; i < pathEnv.length; i++) {
+    const ch = pathEnv[i];
+    if (ch === ";") {
+      pushCurrent();
+      continue;
+    }
+    if (ch === ":") {
+      const segmentLength = current.length;
+      const firstChar = current[0];
+      const isDriveLetterPrefix = segmentLength === 1 && /[A-Za-z]/.test(firstChar || "");
+      if (!isDriveLetterPrefix) {
+        pushCurrent();
+        continue;
+      }
+    }
+    current += ch;
+  }
+  pushCurrent();
+  return entries;
+}
+function detectShell() {
+  const isWin = process.platform === "win32";
+  if (!isWin) {
+    const bin = process.env.SHELL || "/bin/bash";
+    return { bin, args: ["-l"], type: "posix" };
+  }
+  if (process.env.SHELL && /bash\.exe$/i.test(process.env.SHELL) && existsSync(process.env.SHELL)) {
+    return { bin: process.env.SHELL, args: ["-l"], type: "msys" };
+  }
+  if (process.env.KODE_BASH && existsSync(process.env.KODE_BASH)) {
+    return { bin: process.env.KODE_BASH, args: ["-l"], type: "msys" };
+  }
+  const programFiles = [
+    process.env["ProgramFiles"],
+    process.env["ProgramFiles(x86)"],
+    process.env["ProgramW6432"]
+  ].filter(Boolean);
+  const localAppData = process.env["LocalAppData"];
+  const candidates = [];
+  for (const base of programFiles) {
+    candidates.push(
+      join(base, "Git", "bin", "bash.exe"),
+      join(base, "Git", "usr", "bin", "bash.exe")
+    );
+  }
+  if (localAppData) {
+    candidates.push(
+      join(localAppData, "Programs", "Git", "bin", "bash.exe"),
+      join(localAppData, "Programs", "Git", "usr", "bin", "bash.exe")
+    );
+  }
+  candidates.push("C:/msys64/usr/bin/bash.exe");
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      return { bin: c, args: ["-l"], type: "msys" };
+    }
+  }
+  const pathEnv = process.env.PATH || process.env.Path || process.env.path || "";
+  const pathEntries = splitPathEntries(pathEnv, process.platform);
+  for (const p of pathEntries) {
+    const candidate = join(p, "bash.exe");
+    if (existsSync(candidate)) {
+      return { bin: candidate, args: ["-l"], type: "msys" };
+    }
+  }
+  try {
+    execSync('wsl.exe -e bash -lc "echo KODE_OK"', { stdio: "ignore", timeout: 1500 });
+    return { bin: "wsl.exe", args: ["-e", "bash", "-l"], type: "wsl" };
+  } catch {
+  }
+  const hint = [
+    "\u65E0\u6CD5\u627E\u5230\u53EF\u7528\u7684 bash\u3002\u8BF7\u5B89\u88C5 Git for Windows \u6216\u542F\u7528 WSL\u3002",
+    "\u63A8\u8350\u5B89\u88C5 Git: https://git-scm.com/download/win",
+    "\u6216\u542F\u7528 WSL \u5E76\u5B89\u88C5 Ubuntu: https://learn.microsoft.com/windows/wsl/install"
+  ].join("\n");
+  throw new Error(hint);
+}
+class PersistentShell {
+  commandQueue = [];
+  isExecuting = false;
+  shell;
+  isAlive = true;
+  commandInterrupted = false;
+  statusFile;
+  stdoutFile;
+  stderrFile;
+  cwdFile;
+  cwd;
+  binShell;
+  shellArgs;
+  shellType;
+  statusFileBashPath;
+  stdoutFileBashPath;
+  stderrFileBashPath;
+  cwdFileBashPath;
+  constructor(cwd) {
+    const { bin, args, type } = detectShell();
+    this.binShell = bin;
+    this.shellArgs = args;
+    this.shellType = type;
+    this.shell = spawn(this.binShell, this.shellArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd,
+      env: {
+        ...process.env,
+        GIT_EDITOR: "true"
+      }
+    });
+    this.cwd = cwd;
+    this.shell.on("exit", (code, signal) => {
+      if (code) {
+        logError(`Shell exited with code ${code} and signal ${signal}`);
+        logEvent("persistent_shell_exit", {
+          code: code?.toString() || "null",
+          signal: signal || "null"
+        });
+      }
+      for (const file of [
+        this.statusFile,
+        this.stdoutFile,
+        this.stderrFile,
+        this.cwdFile
+      ]) {
+        if (fs.existsSync(file)) {
+          fs.unlinkSync(file);
+        }
+      }
+      this.isAlive = false;
+    });
+    const id = Math.floor(Math.random() * 65536).toString(16).padStart(4, "0");
+    this.statusFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STATUS;
+    this.stdoutFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDOUT;
+    this.stderrFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDERR;
+    this.cwdFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.CWD;
+    for (const file of [this.statusFile, this.stdoutFile, this.stderrFile]) {
+      fs.writeFileSync(file, "");
+    }
+    fs.writeFileSync(this.cwdFile, cwd);
+    this.statusFileBashPath = toBashPath(this.statusFile, this.shellType);
+    this.stdoutFileBashPath = toBashPath(this.stdoutFile, this.shellType);
+    this.stderrFileBashPath = toBashPath(this.stderrFile, this.shellType);
+    this.cwdFileBashPath = toBashPath(this.cwdFile, this.shellType);
+    this.sendToShell("[ -f ~/.bashrc ] && source ~/.bashrc || true");
+  }
+  static instance = null;
+  static restart() {
+    if (PersistentShell.instance) {
+      PersistentShell.instance.close();
+      PersistentShell.instance = null;
+    }
+  }
+  static getInstance() {
+    if (!PersistentShell.instance || !PersistentShell.instance.isAlive) {
+      PersistentShell.instance = new PersistentShell(process.cwd());
+    }
+    return PersistentShell.instance;
+  }
+  killChildren() {
+    const parentPid = this.shell.pid;
+    try {
+      const childPids = execSync(`pgrep -P ${parentPid}`).toString().trim().split("\n").filter(Boolean);
+      if (childPids.length > 0) {
+        logEvent("persistent_shell_command_interrupted", {
+          numChildProcesses: childPids.length.toString()
+        });
+      }
+      childPids.forEach((pid) => {
+        try {
+          process.kill(Number(pid), "SIGTERM");
+        } catch (error) {
+          logError(`Failed to kill process ${pid}: ${error}`);
+          logEvent("persistent_shell_kill_process_error", {
+            error: error.message.substring(0, 10)
+          });
+        }
+      });
+    } catch {
+    } finally {
+      this.commandInterrupted = true;
+    }
+  }
+  async processQueue() {
+    if (this.isExecuting || this.commandQueue.length === 0) return;
+    this.isExecuting = true;
+    const { command, abortSignal, timeout, resolve: resolve2, reject } = this.commandQueue.shift();
+    const killChildren = () => this.killChildren();
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", killChildren);
+    }
+    try {
+      const result = await this.exec_(command, timeout);
+      resolve2(result);
+    } catch (error) {
+      logEvent("persistent_shell_command_error", {
+        error: error.message.substring(0, 10)
+      });
+      reject(error);
+    } finally {
+      this.isExecuting = false;
+      if (abortSignal) {
+        abortSignal.removeEventListener("abort", killChildren);
+      }
+      this.processQueue();
+    }
+  }
+  async exec(command, abortSignal, timeout) {
+    return new Promise((resolve2, reject) => {
+      this.commandQueue.push({ command, abortSignal, timeout, resolve: resolve2, reject });
+      this.processQueue();
+    });
+  }
+  async exec_(command, timeout) {
+    const quotedCommand = shellquote.quote([command]);
+    try {
+      if (this.shellType === "wsl") {
+        execSync(`wsl.exe -e bash -n -c ${quotedCommand}`, {
+          stdio: "ignore",
+          timeout: 1e3
+        });
+      } else {
+        execSync(`${this.binShell} -n -c ${quotedCommand}`, {
+          stdio: "ignore",
+          timeout: 1e3
+        });
+      }
+    } catch (stderr) {
+      const errorStr = typeof stderr === "string" ? stderr : String(stderr || "");
+      logEvent("persistent_shell_syntax_error", {
+        error: errorStr.substring(0, 10)
+      });
+      return Promise.resolve({
+        stdout: "",
+        stderr: errorStr,
+        code: 128,
+        interrupted: false
+      });
+    }
+    const commandTimeout = timeout || DEFAULT_TIMEOUT;
+    this.commandInterrupted = false;
+    return new Promise((resolve2) => {
+      fs.writeFileSync(this.stdoutFile, "");
+      fs.writeFileSync(this.stderrFile, "");
+      fs.writeFileSync(this.statusFile, "");
+      const commandParts = [];
+      commandParts.push(
+        `eval ${quotedCommand} < /dev/null > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`
+      );
+      commandParts.push(`EXEC_EXIT_CODE=$?`);
+      commandParts.push(`pwd > ${quoteForBash(this.cwdFileBashPath)}`);
+      commandParts.push(`echo $EXEC_EXIT_CODE > ${quoteForBash(this.statusFileBashPath)}`);
+      this.sendToShell(commandParts.join("\n"));
+      const start = Date.now();
+      const checkCompletion = setInterval(() => {
+        try {
+          let statusFileSize = 0;
+          if (fs.existsSync(this.statusFile)) {
+            statusFileSize = fs.statSync(this.statusFile).size;
+          }
+          if (statusFileSize > 0 || Date.now() - start > commandTimeout || this.commandInterrupted) {
+            clearInterval(checkCompletion);
+            const stdout = fs.existsSync(this.stdoutFile) ? fs.readFileSync(this.stdoutFile, "utf8") : "";
+            let stderr = fs.existsSync(this.stderrFile) ? fs.readFileSync(this.stderrFile, "utf8") : "";
+            let code;
+            if (statusFileSize) {
+              code = Number(fs.readFileSync(this.statusFile, "utf8"));
+            } else {
+              this.killChildren();
+              code = SIGTERM_CODE;
+              stderr += (stderr ? "\n" : "") + "Command execution timed out";
+              logEvent("persistent_shell_command_timeout", {
+                command: command.substring(0, 10),
+                timeout: commandTimeout.toString()
+              });
+            }
+            resolve2({
+              stdout,
+              stderr,
+              code,
+              interrupted: this.commandInterrupted
+            });
+          }
+        } catch {
+        }
+      }, 10);
+    });
+  }
+  sendToShell(command) {
+    try {
+      this.shell.stdin.write(command + "\n");
+    } catch (error) {
+      const errorString = error instanceof Error ? error.message : String(error || "Unknown error");
+      logError(`Error in sendToShell: ${errorString}`);
+      logEvent("persistent_shell_write_error", {
+        error: errorString.substring(0, 100),
+        command: command.substring(0, 30)
+      });
+      throw error;
+    }
+  }
+  pwd() {
+    try {
+      const newCwd = fs.readFileSync(this.cwdFile, "utf8").trim();
+      if (newCwd) {
+        this.cwd = newCwd;
+      }
+    } catch (error) {
+      logError(`Shell pwd error ${error}`);
+    }
+    return this.cwd;
+  }
+  async setCwd(cwd) {
+    const resolved = isAbsolute(cwd) ? cwd : resolve(process.cwd(), cwd);
+    if (!existsSync(resolved)) {
+      throw new Error(`Path "${resolved}" does not exist`);
+    }
+    const bashPath = toBashPath(resolved, this.shellType);
+    await this.exec(`cd ${quoteForBash(bashPath)}`);
+  }
+  close() {
+    this.shell.stdin.end();
+    this.shell.kill();
+  }
+}
+export {
+  PersistentShell
+};
+//# sourceMappingURL=PersistentShell.js.map

package/dist/utils/PersistentShell.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/PersistentShell.ts"],
+  "sourcesContent": ["import * as fs from 'fs'\nimport { homedir } from 'os'\nimport { existsSync } from 'fs'\nimport shellquote from 'shell-quote'\nimport { spawn, execSync, type ChildProcess } from 'child_process'\nimport { isAbsolute, resolve, join } from 'path'\nimport { logError } from './log'\nimport * as os from 'os'\nimport { logEvent } from '../services/statsig'\nimport { PRODUCT_COMMAND } from '../constants/product'\n\ntype ExecResult = {\n  stdout: string\n  stderr: string\n  code: number\n  interrupted: boolean\n}\ntype QueuedCommand = {\n  command: string\n  abortSignal?: AbortSignal\n  timeout?: number\n  resolve: (result: ExecResult) => void\n  reject: (error: Error) => void\n}\n\nconst TEMPFILE_PREFIX = os.tmpdir() + `/${PRODUCT_COMMAND}-`\nconst DEFAULT_TIMEOUT = 30 * 60 * 1000\nconst SIGTERM_CODE = 143 // Standard exit code for SIGTERM\nconst FILE_SUFFIXES = {\n  STATUS: '-status',\n  STDOUT: '-stdout',\n  STDERR: '-stderr',\n  CWD: '-cwd',\n}\nconst SHELL_CONFIGS: Record<string, string> = {\n  '/bin/bash': '.bashrc',\n  '/bin/zsh': '.zshrc',\n}\n\ntype DetectedShell = {\n  bin: string\n  args: string[]\n  type: 'posix' | 'msys' | 'wsl'\n}\n\nfunction quoteForBash(str: string): string {\n  return `'${str.replace(/'/g, \"'\\\\''\")}'`\n}\n\nfunction toBashPath(pathStr: string, type: 'posix' | 'msys' | 'wsl'): string {\n  // Already POSIX absolute path\n  if (pathStr.startsWith('/')) return pathStr\n  if (type === 'posix') return pathStr\n\n  // Normalize backslashes\n  const normalized = pathStr.replace(/\\\\/g, '/').replace(/\\\\\\\\/g, '/')\n  const driveMatch = /^[A-Za-z]:/.exec(normalized)\n  if (driveMatch) {\n    const drive = normalized[0].toLowerCase()\n    const rest = normalized.slice(2)\n    if (type === 'msys') {\n      return `/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)\n    }\n    // wsl\n    return `/mnt/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)\n  }\n  // Relative path: just convert slashes\n  return normalized\n}\n\nfunction fileExists(p: string | undefined): p is string {\n  return !!p && existsSync(p)\n}\n\n// Robust PATH splitter for Windows and POSIX\nfunction splitPathEntries(pathEnv: string, platform: NodeJS.Platform): string[] {\n  if (!pathEnv) return []\n\n  // POSIX: ':' is the separator\n  if (platform !== 'win32') {\n    return pathEnv\n      .split(':')\n      .map(s => s.trim().replace(/^\"|\"$/g, ''))\n      .filter(Boolean)\n  }\n\n  // Windows: primarily ';', but some environments may use ':'\n  // We must not split drive letters like 'C:\\\\' or 'D:foo\\\\bar'\n  const entries: string[] = []\n  let current = ''\n  const pushCurrent = () => {\n    const cleaned = current.trim().replace(/^\"|\"$/g, '')\n    if (cleaned) entries.push(cleaned)\n    current = ''\n  }\n\n  for (let i = 0; i < pathEnv.length; i++) {\n    const ch = pathEnv[i]\n\n    if (ch === ';') {\n      pushCurrent()\n      continue\n    }\n\n    if (ch === ':') {\n      const segmentLength = current.length\n      const firstChar = current[0]\n      const isDriveLetterPrefix = segmentLength === 1 && /[A-Za-z]/.test(firstChar || '')\n      // Treat ':' as separator only if it's NOT the drive letter colon\n      if (!isDriveLetterPrefix) {\n        pushCurrent()\n        continue\n      }\n    }\n\n    current += ch\n  }\n\n  // Flush the final segment\n  pushCurrent()\n\n  return entries\n}\n\nfunction detectShell(): DetectedShell {\n  const isWin = process.platform === 'win32'\n  if (!isWin) {\n    const bin = process.env.SHELL || '/bin/bash'\n    return { bin, args: ['-l'], type: 'posix' }\n  }\n\n  // 1) Respect SHELL if it points to a bash.exe that exists\n  if (process.env.SHELL && /bash\\.exe$/i.test(process.env.SHELL) && existsSync(process.env.SHELL)) {\n    return { bin: process.env.SHELL, args: ['-l'], type: 'msys' }\n  }\n\n  // 1.1) Explicit override\n  if (process.env.KODE_BASH && existsSync(process.env.KODE_BASH)) {\n    return { bin: process.env.KODE_BASH, args: ['-l'], type: 'msys' }\n  }\n\n  // 2) Common Git Bash/MSYS2 locations\n  const programFiles = [\n    process.env['ProgramFiles'],\n    process.env['ProgramFiles(x86)'],\n    process.env['ProgramW6432'],\n  ].filter(Boolean) as string[]\n\n  const localAppData = process.env['LocalAppData']\n\n  const candidates: string[] = []\n  for (const base of programFiles) {\n    candidates.push(\n      join(base, 'Git', 'bin', 'bash.exe'),\n      join(base, 'Git', 'usr', 'bin', 'bash.exe'),\n    )\n  }\n  if (localAppData) {\n    candidates.push(\n      join(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'),\n      join(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'),\n    )\n  }\n  // MSYS2 default\n  candidates.push('C:/msys64/usr/bin/bash.exe')\n\n  for (const c of candidates) {\n    if (existsSync(c)) {\n      return { bin: c, args: ['-l'], type: 'msys' }\n    }\n  }\n\n  // 2.1) Search in PATH for bash.exe\n  const pathEnv = process.env.PATH || process.env.Path || process.env.path || ''\n  const pathEntries = splitPathEntries(pathEnv, process.platform)\n  for (const p of pathEntries) {\n    const candidate = join(p, 'bash.exe')\n    if (existsSync(candidate)) {\n      return { bin: candidate, args: ['-l'], type: 'msys' }\n    }\n  }\n\n  // 3) WSL\n  try {\n    // Quick probe to ensure WSL+bash exists\n    execSync('wsl.exe -e bash -lc \"echo KODE_OK\"', { stdio: 'ignore', timeout: 1500 })\n    return { bin: 'wsl.exe', args: ['-e', 'bash', '-l'], type: 'wsl' }\n  } catch {}\n\n  // 4) Last resort: meaningful error\n  const hint = [\n    '\u65E0\u6CD5\u627E\u5230\u53EF\u7528\u7684 bash\u3002\u8BF7\u5B89\u88C5 Git for Windows \u6216\u542F\u7528 WSL\u3002',\n    '\u63A8\u8350\u5B89\u88C5 Git: https://git-scm.com/download/win',\n    '\u6216\u542F\u7528 WSL \u5E76\u5B89\u88C5 Ubuntu: https://learn.microsoft.com/windows/wsl/install',\n  ].join('\\n')\n  throw new Error(hint)\n}\n\nexport class PersistentShell {\n  private commandQueue: QueuedCommand[] = []\n  private isExecuting: boolean = false\n  private shell: ChildProcess\n  private isAlive: boolean = true\n  private commandInterrupted: boolean = false\n  private statusFile: string\n  private stdoutFile: string\n  private stderrFile: string\n  private cwdFile: string\n  private cwd: string\n  private binShell: string\n  private shellArgs: string[]\n  private shellType: 'posix' | 'msys' | 'wsl'\n  private statusFileBashPath: string\n  private stdoutFileBashPath: string\n  private stderrFileBashPath: string\n  private cwdFileBashPath: string\n\n  constructor(cwd: string) {\n    const { bin, args, type } = detectShell()\n    this.binShell = bin\n    this.shellArgs = args\n    this.shellType = type\n\n    this.shell = spawn(this.binShell, this.shellArgs, {\n      stdio: ['pipe', 'pipe', 'pipe'],\n      cwd,\n      env: {\n        ...process.env,\n        GIT_EDITOR: 'true',\n      },\n    })\n\n    this.cwd = cwd\n\n    this.shell.on('exit', (code, signal) => {\n      if (code) {\n        // TODO: It would be nice to alert the user that shell crashed\n        logError(`Shell exited with code ${code} and signal ${signal}`)\n        logEvent('persistent_shell_exit', {\n          code: code?.toString() || 'null',\n          signal: signal || 'null',\n        })\n      }\n      for (const file of [\n        this.statusFile,\n        this.stdoutFile,\n        this.stderrFile,\n        this.cwdFile,\n      ]) {\n        if (fs.existsSync(file)) {\n          fs.unlinkSync(file)\n        }\n      }\n      this.isAlive = false\n    })\n\n    const id = Math.floor(Math.random() * 0x10000)\n      .toString(16)\n      .padStart(4, '0')\n\n    this.statusFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STATUS\n    this.stdoutFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDOUT\n    this.stderrFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.STDERR\n    this.cwdFile = TEMPFILE_PREFIX + id + FILE_SUFFIXES.CWD\n    for (const file of [this.statusFile, this.stdoutFile, this.stderrFile]) {\n      fs.writeFileSync(file, '')\n    }\n    // Initialize CWD file with initial directory\n    fs.writeFileSync(this.cwdFile, cwd)\n\n    // Compute bash-visible paths for redirections\n    this.statusFileBashPath = toBashPath(this.statusFile, this.shellType)\n    this.stdoutFileBashPath = toBashPath(this.stdoutFile, this.shellType)\n    this.stderrFileBashPath = toBashPath(this.stderrFile, this.shellType)\n    this.cwdFileBashPath = toBashPath(this.cwdFile, this.shellType)\n\n    // Source ~/.bashrc when available (works for bash on POSIX/MSYS/WSL)\n    this.sendToShell('[ -f ~/.bashrc ] && source ~/.bashrc || true')\n  }\n\n  private static instance: PersistentShell | null = null\n\n  static restart() {\n    if (PersistentShell.instance) {\n      PersistentShell.instance.close()\n      PersistentShell.instance = null\n    }\n  }\n\n  static getInstance(): PersistentShell {\n    if (!PersistentShell.instance || !PersistentShell.instance.isAlive) {\n      PersistentShell.instance = new PersistentShell(process.cwd())\n    }\n    return PersistentShell.instance\n  }\n\n  killChildren() {\n    const parentPid = this.shell.pid\n    try {\n      const childPids = execSync(`pgrep -P ${parentPid}`)\n        .toString()\n        .trim()\n        .split('\\n')\n        .filter(Boolean) // Filter out empty strings\n\n      if (childPids.length > 0) {\n        logEvent('persistent_shell_command_interrupted', {\n          numChildProcesses: childPids.length.toString(),\n        })\n      }\n\n      childPids.forEach(pid => {\n        try {\n          process.kill(Number(pid), 'SIGTERM')\n        } catch (error) {\n          logError(`Failed to kill process ${pid}: ${error}`)\n          logEvent('persistent_shell_kill_process_error', {\n            error: (error as Error).message.substring(0, 10),\n          })\n        }\n      })\n    } catch {\n      // pgrep returns non-zero when no processes are found - this is expected\n    } finally {\n      this.commandInterrupted = true\n    }\n  }\n\n  private async processQueue() {\n    /**\n     * Processes commands from the queue one at a time.\n     * Concurrency invariants:\n     * - Only one instance runs at a time (controlled by isExecuting)\n     * - Is the only caller of updateCwd() in the system\n     * - Calls updateCwd() after each command completes\n     * - Ensures commands execute serially via the queue\n     * - Handles interruption via abortSignal by calling killChildren()\n     * - Cleans up abortSignal listeners after command completion or interruption\n     */\n    if (this.isExecuting || this.commandQueue.length === 0) return\n\n    this.isExecuting = true\n    const { command, abortSignal, timeout, resolve, reject } =\n      this.commandQueue.shift()!\n\n    const killChildren = () => this.killChildren()\n    if (abortSignal) {\n      abortSignal.addEventListener('abort', killChildren)\n    }\n\n    try {\n      const result = await this.exec_(command, timeout)\n\n      // No need to update cwd - it's handled in exec_ via the CWD file\n\n      resolve(result)\n    } catch (error) {\n      logEvent('persistent_shell_command_error', {\n        error: (error as Error).message.substring(0, 10),\n      })\n      reject(error as Error)\n    } finally {\n      this.isExecuting = false\n      if (abortSignal) {\n        abortSignal.removeEventListener('abort', killChildren)\n      }\n      // Process next command in queue\n      this.processQueue()\n    }\n  }\n\n  async exec(\n    command: string,\n    abortSignal?: AbortSignal,\n    timeout?: number,\n  ): Promise<ExecResult> {\n    return new Promise((resolve, reject) => {\n      this.commandQueue.push({ command, abortSignal, timeout, resolve, reject })\n      this.processQueue()\n    })\n  }\n\n  private async exec_(command: string, timeout?: number): Promise<ExecResult> {\n    /**\n     * Direct command execution without going through the queue.\n     * Concurrency invariants:\n     * - Not safe for concurrent calls (uses shared files)\n     * - Called only when queue is idle\n     * - Relies on file-based IPC to handle shell interaction\n     * - Does not modify the command queue state\n     * - Tracks interruption state via commandInterrupted flag\n     * - Resets interruption state at start of new command\n     * - Reports interruption status in result object\n     *\n     * Exit Code & CWD Handling:\n     * - Executes command and immediately captures its exit code into a shell variable\n     * - Updates the CWD file with the working directory after capturing exit code\n     * - Writes the preserved exit code to the status file as the final step\n     * - This sequence eliminates race conditions between exit code capture and CWD updates\n     * - The pwd() method reads the CWD file directly for current directory info\n     */\n    const quotedCommand = shellquote.quote([command])\n\n    // Check the syntax of the command\n    try {\n      if (this.shellType === 'wsl') {\n        execSync(`wsl.exe -e bash -n -c ${quotedCommand}`, {\n          stdio: 'ignore',\n          timeout: 1000,\n        })\n      } else {\n        execSync(`${this.binShell} -n -c ${quotedCommand}`, {\n          stdio: 'ignore',\n          timeout: 1000,\n        })\n      }\n    } catch (stderr) {\n      // If there's a syntax error, return an error and log it\n      const errorStr =\n        typeof stderr === 'string' ? stderr : String(stderr || '')\n      logEvent('persistent_shell_syntax_error', {\n        error: errorStr.substring(0, 10),\n      })\n      return Promise.resolve({\n        stdout: '',\n        stderr: errorStr,\n        code: 128,\n        interrupted: false,\n      })\n    }\n\n    const commandTimeout = timeout || DEFAULT_TIMEOUT\n    // Reset interrupted state for new command\n    this.commandInterrupted = false\n    return new Promise<ExecResult>(resolve => {\n      // Truncate output files\n      fs.writeFileSync(this.stdoutFile, '')\n      fs.writeFileSync(this.stderrFile, '')\n      fs.writeFileSync(this.statusFile, '')\n      // Break up the command sequence for clarity using an array of commands\n      const commandParts = []\n\n      // 1. Execute the main command with redirections\n      commandParts.push(\n        `eval ${quotedCommand} < /dev/null > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`,\n      )\n\n      // 2. Capture exit code immediately after command execution to avoid losing it\n      commandParts.push(`EXEC_EXIT_CODE=$?`)\n\n      // 3. Update CWD file\n      commandParts.push(`pwd > ${quoteForBash(this.cwdFileBashPath)}`)\n\n      // 4. Write the preserved exit code to status file to avoid race with pwd\n      commandParts.push(`echo $EXEC_EXIT_CODE > ${quoteForBash(this.statusFileBashPath)}`)\n\n      // Send the combined commands as a single operation to maintain atomicity\n      this.sendToShell(commandParts.join('\\n'))\n\n      // Check for command completion or timeout\n      const start = Date.now()\n      const checkCompletion = setInterval(() => {\n        try {\n          let statusFileSize = 0\n          if (fs.existsSync(this.statusFile)) {\n            statusFileSize = fs.statSync(this.statusFile).size\n          }\n\n          if (\n            statusFileSize > 0 ||\n            Date.now() - start > commandTimeout ||\n            this.commandInterrupted\n          ) {\n            clearInterval(checkCompletion)\n            const stdout = fs.existsSync(this.stdoutFile)\n              ? fs.readFileSync(this.stdoutFile, 'utf8')\n              : ''\n            let stderr = fs.existsSync(this.stderrFile)\n              ? fs.readFileSync(this.stderrFile, 'utf8')\n              : ''\n            let code: number\n            if (statusFileSize) {\n              code = Number(fs.readFileSync(this.statusFile, 'utf8'))\n            } else {\n              // Timeout occurred - kill any running processes\n              this.killChildren()\n              code = SIGTERM_CODE\n              stderr += (stderr ? '\\n' : '') + 'Command execution timed out'\n              logEvent('persistent_shell_command_timeout', {\n                command: command.substring(0, 10),\n                timeout: commandTimeout.toString(),\n              })\n            }\n            resolve({\n              stdout,\n              stderr,\n              code,\n              interrupted: this.commandInterrupted,\n            })\n          }\n        } catch {\n          // Ignore file system errors during polling - they are expected\n          // as we check for completion before files exist\n        }\n      }, 10) // increasing this will introduce latency\n    })\n  }\n\n  private sendToShell(command: string) {\n    try {\n      this.shell!.stdin!.write(command + '\\n')\n    } catch (error) {\n      const errorString =\n        error instanceof Error\n          ? error.message\n          : String(error || 'Unknown error')\n      logError(`Error in sendToShell: ${errorString}`)\n      logEvent('persistent_shell_write_error', {\n        error: errorString.substring(0, 100),\n        command: command.substring(0, 30),\n      })\n      throw error\n    }\n  }\n\n  pwd(): string {\n    try {\n      const newCwd = fs.readFileSync(this.cwdFile, 'utf8').trim()\n      if (newCwd) {\n        this.cwd = newCwd\n      }\n    } catch (error) {\n      logError(`Shell pwd error ${error}`)\n    }\n    // Always return the cached value\n    return this.cwd\n  }\n\n  async setCwd(cwd: string) {\n    const resolved = isAbsolute(cwd) ? cwd : resolve(process.cwd(), cwd)\n    if (!existsSync(resolved)) {\n      throw new Error(`Path \"${resolved}\" does not exist`)\n    }\n    const bashPath = toBashPath(resolved, this.shellType)\n    await this.exec(`cd ${quoteForBash(bashPath)}`)\n  }\n\n  close(): void {\n    this.shell!.stdin!.end()\n    this.shell.kill()\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["resolve"]
+}

package/dist/utils/advancedFuzzyMatcher.js

@@ -0,0 +1,206 @@
+class AdvancedFuzzyMatcher {
+  /**
+   * Main matching function - combines multiple algorithms
+   */
+  match(candidate, query) {
+    const text = candidate.toLowerCase();
+    const pattern = query.toLowerCase();
+    if (text === pattern) {
+      return { score: 1e4, matched: true, algorithm: "exact" };
+    }
+    const algorithms = [
+      this.exactPrefixMatch(text, pattern),
+      this.hyphenAwareMatch(text, pattern),
+      this.wordBoundaryMatch(text, pattern),
+      this.abbreviationMatch(text, pattern),
+      this.numericSuffixMatch(text, pattern),
+      this.subsequenceMatch(text, pattern),
+      this.fuzzySegmentMatch(text, pattern)
+    ];
+    let bestScore = 0;
+    let bestAlgorithm = "none";
+    for (const result of algorithms) {
+      if (result.score > bestScore) {
+        bestScore = result.score;
+        bestAlgorithm = result.algorithm;
+      }
+    }
+    return {
+      score: bestScore,
+      matched: bestScore > 10,
+      algorithm: bestAlgorithm
+    };
+  }
+  /**
+   * Exact prefix matching
+   */
+  exactPrefixMatch(text, pattern) {
+    if (text.startsWith(pattern)) {
+      const coverage = pattern.length / text.length;
+      return { score: 1e3 + coverage * 500, algorithm: "prefix" };
+    }
+    return { score: 0, algorithm: "prefix" };
+  }
+  /**
+   * Hyphen-aware matching (dao → dao-qi-harmony-designer)
+   * Treats hyphens as optional word boundaries
+   */
+  hyphenAwareMatch(text, pattern) {
+    const words = text.split("-");
+    if (words[0].startsWith(pattern)) {
+      const coverage = pattern.length / words[0].length;
+      return { score: 300 + coverage * 100, algorithm: "hyphen-prefix" };
+    }
+    const concatenated = words.join("");
+    if (concatenated.startsWith(pattern)) {
+      const coverage = pattern.length / concatenated.length;
+      return { score: 250 + coverage * 100, algorithm: "hyphen-concat" };
+    }
+    for (let i = 0; i < words.length; i++) {
+      if (words[i].startsWith(pattern)) {
+        return { score: 200 - i * 10, algorithm: "hyphen-word" };
+      }
+    }
+    return { score: 0, algorithm: "hyphen" };
+  }
+  /**
+   * Word boundary matching (dq → dao-qi)
+   * Matches characters at word boundaries
+   */
+  wordBoundaryMatch(text, pattern) {
+    const words = text.split(/[-_\s]+/);
+    let patternIdx = 0;
+    let score = 0;
+    let matched = false;
+    for (const word of words) {
+      if (patternIdx >= pattern.length) break;
+      if (word[0] === pattern[patternIdx]) {
+        score += 50;
+        patternIdx++;
+        matched = true;
+        for (let i = 1; i < word.length && patternIdx < pattern.length; i++) {
+          if (word[i] === pattern[patternIdx]) {
+            score += 20;
+            patternIdx++;
+          }
+        }
+      }
+    }
+    if (matched && patternIdx === pattern.length) {
+      return { score, algorithm: "word-boundary" };
+    }
+    return { score: 0, algorithm: "word-boundary" };
+  }
+  /**
+   * Abbreviation matching (nde → node, daoqi → dao-qi)
+   */
+  abbreviationMatch(text, pattern) {
+    let textIdx = 0;
+    let patternIdx = 0;
+    let score = 0;
+    let lastMatchIdx = -1;
+    while (patternIdx < pattern.length && textIdx < text.length) {
+      if (text[textIdx] === pattern[patternIdx]) {
+        const gap = lastMatchIdx === -1 ? 0 : textIdx - lastMatchIdx - 1;
+        if (textIdx === 0) {
+          score += 50;
+        } else if (lastMatchIdx >= 0 && gap === 0) {
+          score += 30;
+        } else if (text[textIdx - 1] === "-" || text[textIdx - 1] === "_") {
+          score += 40;
+        } else {
+          score += Math.max(5, 20 - gap * 2);
+        }
+        lastMatchIdx = textIdx;
+        patternIdx++;
+      }
+      textIdx++;
+    }
+    if (patternIdx === pattern.length) {
+      const spread = lastMatchIdx / pattern.length;
+      if (spread <= 3) score += 50;
+      else if (spread <= 5) score += 30;
+      return { score, algorithm: "abbreviation" };
+    }
+    return { score: 0, algorithm: "abbreviation" };
+  }
+  /**
+   * Numeric suffix matching (py3 → python3, np18 → node18)
+   */
+  numericSuffixMatch(text, pattern) {
+    const patternMatch = pattern.match(/^(.+?)(\d+)$/);
+    if (!patternMatch) return { score: 0, algorithm: "numeric" };
+    const [, prefix, suffix] = patternMatch;
+    if (!text.endsWith(suffix)) return { score: 0, algorithm: "numeric" };
+    const textWithoutSuffix = text.slice(0, -suffix.length);
+    if (textWithoutSuffix.startsWith(prefix)) {
+      const coverage = prefix.length / textWithoutSuffix.length;
+      return { score: 200 + coverage * 100, algorithm: "numeric-suffix" };
+    }
+    const abbrevResult = this.abbreviationMatch(textWithoutSuffix, prefix);
+    if (abbrevResult.score > 0) {
+      return { score: abbrevResult.score + 50, algorithm: "numeric-abbrev" };
+    }
+    return { score: 0, algorithm: "numeric" };
+  }
+  /**
+   * Subsequence matching - characters appear in order
+   */
+  subsequenceMatch(text, pattern) {
+    let textIdx = 0;
+    let patternIdx = 0;
+    let score = 0;
+    while (patternIdx < pattern.length && textIdx < text.length) {
+      if (text[textIdx] === pattern[patternIdx]) {
+        score += 10;
+        patternIdx++;
+      }
+      textIdx++;
+    }
+    if (patternIdx === pattern.length) {
+      const spread = textIdx / pattern.length;
+      score = Math.max(10, score - spread * 5);
+      return { score, algorithm: "subsequence" };
+    }
+    return { score: 0, algorithm: "subsequence" };
+  }
+  /**
+   * Fuzzy segment matching (dao → dao-qi-harmony)
+   * Matches segments flexibly
+   */
+  fuzzySegmentMatch(text, pattern) {
+    const cleanText = text.replace(/[-_]/g, "");
+    const cleanPattern = pattern.replace(/[-_]/g, "");
+    if (cleanText.startsWith(cleanPattern)) {
+      const coverage = cleanPattern.length / cleanText.length;
+      return { score: 150 + coverage * 100, algorithm: "fuzzy-segment" };
+    }
+    const index = cleanText.indexOf(cleanPattern);
+    if (index !== -1) {
+      const positionPenalty = index * 5;
+      return { score: Math.max(50, 100 - positionPenalty), algorithm: "fuzzy-contains" };
+    }
+    return { score: 0, algorithm: "fuzzy-segment" };
+  }
+}
+const advancedMatcher = new AdvancedFuzzyMatcher();
+function matchAdvanced(candidate, query) {
+  return advancedMatcher.match(candidate, query);
+}
+function matchManyAdvanced(candidates, query, minScore = 10) {
+  return candidates.map((candidate) => {
+    const result = advancedMatcher.match(candidate, query);
+    return {
+      candidate,
+      score: result.score,
+      algorithm: result.algorithm
+    };
+  }).filter((item) => item.score >= minScore).sort((a, b) => b.score - a.score);
+}
+export {
+  AdvancedFuzzyMatcher,
+  advancedMatcher,
+  matchAdvanced,
+  matchManyAdvanced
+};
+//# sourceMappingURL=advancedFuzzyMatcher.js.map