flavor-code 1.4.1 → 1.4.3-beta.2

package/dist/chunk-K7UGGWJV.js

@@ -0,0 +1,1003 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  execFileNoThrow
+} from "./chunk-IU3UBETC.js";
+import {
+  prepareSpawnInvocation,
+  resolveExecutablePath
+} from "./chunk-PZ5NKRVA.js";
+import {
+  fetchLatestVersion
+} from "./chunk-6F66UXBI.js";
+import {
+  gte
+} from "./chunk-3UX2CGDW.js";
+import {
+  PluginManifestSchema
+} from "./chunk-CVP5OUHD.js";
+import {
+  packageVersion
+} from "./chunk-RV3EXUXM.js";
+import {
+  loadConfig
+} from "./chunk-HGTCIHWA.js";
+import {
+  external_exports
+} from "./chunk-EWD7FWTH.js";
+
+// src/doctor.ts
+import { constants } from "fs";
+import { access, lstat, readFile, readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+
+// node_modules/@vscode/ripgrep/lib/index.js
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var arch = process.env.npm_config_arch || process.arch;
+var binaryName = process.platform === "win32" ? "rg.exe" : "rg";
+var platformPkg = `@vscode/ripgrep-${process.platform}-${arch}`;
+var resolved;
+try {
+  resolved = require2.resolve(`${platformPkg}/bin/${binaryName}`);
+} catch {
+  throw new Error(
+    `Could not find ${platformPkg}. Ensure optionalDependencies are installed for this platform (${process.platform}-${arch}).`
+  );
+}
+var rgPath = resolved;
+
+// src/tools/shell.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync } from "fs";
+import { basename, delimiter, isAbsolute, join, relative, resolve, sep } from "path";
+
+// src/tools/jobs.ts
+var JobId = external_exports.string().regex(/^job-[a-f0-9-]+$/);
+var ReadInput = external_exports.object({ id: JobId, cursor: external_exports.coerce.number().int().min(0).optional() });
+var IdInput = external_exports.object({ id: JobId });
+function createJobTools(registry) {
+  const tools = [
+    {
+      name: "JobList",
+      description: "List background jobs owned by this agent",
+      inputSchema: external_exports.object({}),
+      paths: () => [],
+      execute: async (_input, _signal, context) => registry.list(owner(context)),
+      presentResult: (output) => jobListPresentation(output)
+    },
+    {
+      name: "JobRead",
+      description: "Read incremental output from an owned background job",
+      inputSchema: ReadInput,
+      paths: () => [],
+      execute: async (input, _signal, context) => registry.read(input.id, owner(context), input.cursor ?? 0),
+      renderForModel: (output) => JSON.stringify(output),
+      presentResult: (output) => jobPresentation("read", output)
+    },
+    {
+      name: "JobWait",
+      description: "Wait for an owned background job to finish",
+      inputSchema: IdInput,
+      paths: () => [],
+      execute: async (input, signal, context) => registry.wait(input.id, owner(context), signal),
+      presentResult: (output) => jobPresentation("wait", output)
+    },
+    {
+      name: "JobKill",
+      description: "Cancel an owned background job and its process tree",
+      inputSchema: IdInput,
+      paths: () => [],
+      execute: async (input, _signal, context) => {
+        await registry.kill(input.id, owner(context));
+        return registry.read(input.id, owner(context));
+      },
+      presentResult: (output) => jobPresentation("kill", output)
+    }
+  ];
+  return tools;
+}
+function jobPresentation(action, job) {
+  const read = "output" in job ? job : void 0;
+  return {
+    kind: "job",
+    action,
+    id: job.id,
+    jobKind: job.kind,
+    label: job.label,
+    state: job.state,
+    ...job.exitCode === void 0 ? {} : { exitCode: job.exitCode },
+    ...job.error === void 0 ? {} : { error: job.error },
+    ...read === void 0 ? {} : { output: read.output, cursor: read.cursor },
+    ...job.truncated ? { truncated: true } : {}
+  };
+}
+function jobListPresentation(jobs) {
+  return {
+    kind: "job",
+    action: "list",
+    jobs: jobs.map((job) => ({
+      id: job.id,
+      kind: job.kind,
+      label: job.label,
+      state: job.state,
+      ...job.exitCode === void 0 ? {} : { exitCode: job.exitCode }
+    }))
+  };
+}
+function owner(context) {
+  return context?.ownerId ?? context?.agent ?? "main";
+}
+
+// src/utils/process-tree.ts
+import { spawn } from "child_process";
+async function terminateProcessTree(pid) {
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    await new Promise((resolve3) => {
+      const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { shell: false, windowsHide: true });
+      const finish = () => {
+        clearTimeout(timer);
+        resolve3();
+      };
+      const timer = setTimeout(finish, 5e3);
+      timer.unref();
+      child.once("error", finish);
+      child.once("close", finish);
+    });
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 250));
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+
+// src/tools/shell.ts
+var DEFAULT_MAX_OUTPUT_BYTES = 1048576;
+var DEFAULT_SHELL_TIMEOUT_MS = 10 * 6e4;
+var ELLIPSIS = "\u2026";
+var TERMINATION_FAILURE_MS = 5e3;
+var STREAM_CLOSE_GRACE_MS = 500;
+var ShellInput = external_exports.object({
+  command: external_exports.string().trim().min(1).refine((value) => !value.includes("\0"), "command cannot contain a null byte").describe("Executable name or path. Put each argument in args; use a shell expression here only for pipes, redirects, or other shell syntax."),
+  args: external_exports.array(external_exports.string().refine((value) => !value.includes("\0"), "argument cannot contain a null byte").describe("One logical argument without surrounding shell quotes.")),
+  cwd: external_exports.string().min(1).nullable().optional(),
+  timeoutMs: external_exports.coerce.number().int().positive().max(864e5).nullable().optional(),
+  // Accepts booleans and their string forms (weak-typed models emit "true");
+  // kept transform-free so the schema converts to JSON Schema for providers.
+  background: external_exports.union([external_exports.boolean(), external_exports.string().refine((value) => value === "true" || value === "false")]).optional()
+});
+function normalizeShellCommand(input) {
+  const command = unquoteToken(input.command.trim());
+  const args = [...input.args];
+  const executable = basename(command).toLowerCase();
+  if ((executable === "cmd" || executable === "cmd.exe") && /^\/[ck]$/iu.test(args[0] ?? "")) {
+    return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
+  }
+  if (!/\s/u.test(command) || containsShellSyntax(command)) return { command, args };
+  const tokens = tokenizeCommandLine(command);
+  if (tokens.length <= 1) return { command, args };
+  const head = unquoteToken(tokens[0]);
+  if (head.includes("/") || head.includes("\\")) return { command, args };
+  return { command: head, args: [...tokens.slice(1).map(unquoteToken), ...args] };
+}
+function tokenizeCommandLine(command) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === "\\" && quote === '"' && command[index + 1] !== void 0) {
+      current += `${char}${command[index + 1]}`;
+      index += 1;
+    } else if (char === '"' || char === "'") {
+      if (quote === void 0) quote = char;
+      else if (quote === char) quote = void 0;
+      current += char;
+    } else if (/\s/u.test(char) && quote === void 0) {
+      if (current !== "") {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current !== "") tokens.push(current);
+  return tokens;
+}
+function unquoteToken(token) {
+  const trimmed = token.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  return (first === '"' || first === "'") && trimmed.endsWith(first) ? trimmed.slice(1, -1) : trimmed;
+}
+function serializeCmdCommand(args) {
+  return args.map((arg) => {
+    const value = unquoteToken(arg);
+    return /[\s&|<>^()]/u.test(value) ? `"${value.replace(/"/gu, '""')}"` : value;
+  }).join(" ");
+}
+function serializeCmdPayload(args) {
+  if (args.length === 1) return unquoteToken(args[0]);
+  return args.map((arg) => /^(?:&&|\|\||[|&<>])$/u.test(arg) ? arg : serializeCmdCommand([arg])).join(" ");
+}
+function containsShellSyntax(command, platform = process.platform) {
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (quote !== void 0) {
+      if (char === quote) quote = void 0;
+      else if (char === "\\" && quote === '"') index += 1;
+      else if (char === "$" && quote === '"') return true;
+      continue;
+    }
+    if (char === "\\" && platform !== "win32") {
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/[|&;<>`$*?()\n\r]/u.test(char)) return true;
+    if (char === "[" && command.indexOf("]", index + 1) > index) return true;
+    if (char === "~" && (index === 0 || /\s/u.test(command[index - 1])) && /[\\/]/u.test(command[index + 1] ?? "")) return true;
+    if (platform === "win32" && char === "%" && /^%[A-Za-z_][A-Za-z0-9_]*%/u.test(command.slice(index))) return true;
+  }
+  return quote !== void 0;
+}
+function hasUnmatchedShellQuote(command) {
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === "\\" && quote !== "'") {
+      index += 1;
+      continue;
+    }
+    if (char !== '"' && char !== "'") continue;
+    if (quote === void 0) quote = char;
+    else if (quote === char) quote = void 0;
+  }
+  return quote !== void 0;
+}
+function resolveRuntimeShell(platform = process.platform, environment = process.env) {
+  if (platform === "win32") {
+    for (const candidate of ["pwsh", "powershell"]) {
+      const command2 = resolveExecutablePath(candidate, { platform: "win32", env: environment });
+      if (command2 !== void 0) return { kind: candidate, command: command2 };
+    }
+    const configured = environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe";
+    const command = resolveExecutablePath(configured, { platform: "win32", env: environment });
+    return command === void 0 ? void 0 : { kind: "cmd", command };
+  }
+  for (const candidate of [environment.SHELL, "/bin/sh"]) {
+    if (!candidate) continue;
+    const command = resolveExecutablePath(candidate, { platform, env: environment });
+    if (command !== void 0) return { kind: "posix", command };
+  }
+  return void 0;
+}
+function psQuote(token) {
+  return `'${token.replace(/'/g, "''")}'`;
+}
+function shellInvocation(input, cwd, environment) {
+  const resolved2 = resolveExecutablePath(input.command, { cwd, env: environment });
+  if (resolved2 !== void 0) {
+    const executable = basename(resolved2).toLowerCase();
+    if (process.platform === "win32" && (executable === "cmd" || executable === "cmd.exe")) {
+      const commandFlag = input.args.findIndex((arg) => /^\/[ck]$/iu.test(arg));
+      if (commandFlag >= 0 && input.args[commandFlag + 1] !== void 0) {
+        const payload = serializeCmdPayload(input.args.slice(commandFlag + 1));
+        return {
+          command: resolved2,
+          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`],
+          windowsVerbatimArguments: true
+        };
+      }
+    }
+    return prepareSpawnInvocation(resolved2, input.args, { cwd, env: environment });
+  }
+  const isScript = containsShellSyntax(input.command);
+  if (!isScript && (isAbsolute(input.command) || /[\\/]/u.test(input.command))) {
+    return { command: input.command, args: [...input.args] };
+  }
+  const shell = resolveRuntimeShell(process.platform, environment);
+  if (shell === void 0) return { command: input.command, args: [...input.args] };
+  const script = isScript ? appendShellArguments(shell, input.command, input.args) : structuredShellScript(shell, input.command, input.args);
+  if (shell.kind === "posix") return { command: shell.command, args: ["-c", script] };
+  if (shell.kind === "cmd") return {
+    command: shell.command,
+    args: ["/d", "/s", "/c", `chcp 65001>nul & ${script}`],
+    windowsVerbatimArguments: true
+  };
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  return {
+    command: shell.command,
+    args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded]
+  };
+}
+function appendShellArguments(shell, script, args) {
+  if (args.length === 0) return script;
+  if (shell.kind === "posix") return `${script} ${args.map(posixQuote).join(" ")}`;
+  if (shell.kind === "cmd") return `${script} ${serializeCmdCommand(args)}`;
+  return `${script} ${args.map(psQuote).join(" ")}`;
+}
+var POSIX_SHELL_BUILTINS = /* @__PURE__ */ new Set([".", ":", "alias", "cd", "command", "eval", "exec", "export", "read", "set", "source", "trap", "type", "ulimit", "umask", "unalias", "unset", "wait"]);
+function executionEnvironmentCommand(environment, command, args) {
+  if (environment.kind !== "docker") return { command, args: [...args] };
+  const script = containsShellSyntax(command, "linux") ? appendShellArguments({ kind: "posix", command: "/bin/sh" }, command, args) : POSIX_SHELL_BUILTINS.has(command) ? structuredShellScript({ kind: "posix", command: "/bin/sh" }, command, args) : void 0;
+  return script === void 0 ? { command, args: [...args] } : { command: "/bin/sh", args: ["-c", script] };
+}
+function structuredShellScript(shell, command, args) {
+  if (shell.kind === "posix") return [command, ...args].map(posixQuote).join(" ");
+  if (shell.kind === "cmd") return serializeCmdCommand([command, ...args]);
+  const invocation = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map((arg) => /^-[A-Za-z][A-Za-z0-9-]*$/u.test(arg) ? arg : psQuote(arg)).join(" ")}` : ""}`;
+  return `$ErrorActionPreference='Stop'; try { ${invocation}; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 0 } } catch { [Console]::Error.WriteLine($_.Exception.Message); if ($_.Exception -is [System.Management.Automation.CommandNotFoundException]) { exit 127 } else { exit 1 } }`;
+}
+function posixQuote(value) {
+  return `'${value.replace(/'/gu, `'"'"'`)}'`;
+}
+function withShellDiagnostic(result, command, spawnError) {
+  const diagnostic = classifyShellFailure(result, command, spawnError);
+  if (diagnostic === void 0) return result;
+  return { ...result, diagnostic };
+}
+function classifyShellFailure(result, command, spawnError) {
+  if (result.terminationReason === "timeout") return {
+    kind: "timeout",
+    message: `Command exceeded its timeout and was terminated.`,
+    hint: "Increase timeoutMs only if this command is expected to take longer."
+  };
+  if (result.terminationReason === "cancelled") return { kind: "cancelled", message: "Command was cancelled." };
+  if (result.exitCode === 0 && result.signal === null && spawnError === void 0) return void 0;
+  if (hasUnmatchedShellQuote(command)) return {
+    kind: "shell-syntax",
+    message: "The command contains an unmatched shell quote.",
+    hint: "Close the quoted value, or pass it as one unquoted args item when shell expansion is not required."
+  };
+  const detail = `${spawnError?.message ?? ""}
+${result.stderr}`;
+  const code = errorCode(spawnError);
+  if (code === "ENOENT" && (isAbsolute(command) || /[\\/]/u.test(command))) {
+    return { kind: "path-not-found", message: `Executable path "${command}" does not exist.` };
+  }
+  if (code === "ENOENT" || /(?:not recognized as (?:an internal|(?:a|the) name)|command not found|not found\s*$|无法将.+识别为|术语.+不会被识别为|不会被识别为|不是内部或外部命令)/imu.test(detail)) {
+    return {
+      kind: "command-not-found",
+      message: `Executable "${command}" was not found by the selected runtime shell.`,
+      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes. For an unavailable PowerShell cmdlet, check Get-Command and its module in the selected shell; do not keep retrying the same command."
+    };
+  }
+  if (code === "EACCES" || /(?:permission denied|access is denied|拒绝访问)/iu.test(detail)) {
+    return { kind: "permission-denied", message: `Command "${command}" could not be executed because access was denied.` };
+  }
+  if (/(?:no such file or directory|cannot find (?:the )?path|system cannot find|系统找不到指定的路径)/iu.test(detail)) {
+    return { kind: "path-not-found", message: "The command referenced a path that does not exist." };
+  }
+  if (/(?:syntax\s*error|unexpected token|parsererror|unterminated (?:regexp|string)|语法错误)/iu.test(detail)) {
+    return {
+      kind: "shell-syntax",
+      message: "The command or interpreter rejected the syntax.",
+      hint: 'Pass normal arguments through args. For JavaScript use command="node", args=["-e", "<complete script>"] without an extra shell or surrounding quotes. Legacy Windows PowerShell can strip quotes when forwarding native arguments.'
+    };
+  }
+  return {
+    kind: "non-zero-exit",
+    message: result.signal === null ? `Command exited with code ${result.exitCode ?? "unknown"}.` : `Command was terminated by signal ${result.signal}.`
+  };
+}
+function errorCode(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : void 0;
+}
+function createShellTool(workspace, options = {}) {
+  const root = resolve(workspace);
+  const environment = shellEnvironment(root, options.environment ?? process.env);
+  const maxBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new Error("maxOutputBytes must be a positive integer");
+  if (!Number.isSafeInteger(defaultTimeoutMs) || defaultTimeoutMs <= 0 || defaultTimeoutMs > 864e5) {
+    throw new Error("defaultTimeoutMs must be a positive integer no greater than 86400000");
+  }
+  return {
+    name: "Shell",
+    description: 'Run a bounded command reliably inside the workspace. Pass a bare executable in command and one logical value per args entry, without adding surrounding shell quotes. For Node scripts use command="node", args=["-e", "<complete JavaScript>"]; do not wrap native commands in cmd /c or PowerShell -Command unless shell syntax is needed, since legacy PowerShell can strip embedded quotes. Use Grep for text searches and Read/Edit for file changes. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.',
+    inputSchema: ShellInput,
+    paths: (input) => [workingDirectory(root, input.cwd ?? void 0)],
+    summarize: (input) => [input.command, ...input.args].join(" "),
+    presentCall: (input) => ({ kind: "terminal", variant: "command", title: backgroundFlag(input.background) ? "Starting background command" : "Running command", command: [input.command, ...input.args].join(" "), state: "running" }),
+    permissions: (input) => {
+      const normalized = normalizeShellCommand(input);
+      return {
+        paths: [workingDirectory(root, input.cwd ?? void 0)],
+        command: normalized.command,
+        args: normalized.args,
+        cwd: workingDirectory(root, input.cwd ?? void 0)
+      };
+    },
+    presentResult: (output, input) => output && "jobId" in output ? {
+      kind: "job",
+      action: "start",
+      id: output.jobId,
+      jobKind: "shell",
+      label: [input.command, ...input.args].join(" "),
+      state: "running"
+    } : { kind: "terminal", variant: "command", title: [input.command, ...input.args].join(" "), command: [input.command, ...input.args].join(" "), stdout: output.stdout, stderr: output.stderr, ...output.diagnostic === void 0 ? {} : { diagnostic: output.diagnostic.message }, exitCode: output.exitCode, state: output.terminationReason === "cancelled" ? "cancelled" : output.exitCode === 0 ? "completed" : "failed", truncated: output.truncated },
+    execute: async (input, signal, context) => {
+      const normalized = normalizeShellCommand(input);
+      const effective = { ...input, command: normalized.command, args: normalized.args };
+      const timeoutMs = effective.timeoutMs ?? defaultTimeoutMs;
+      if (backgroundFlag(effective.background)) {
+        if (options.jobs === void 0) throw new Error("Background shell requires a JobRegistry");
+        const cancellation = new AbortController();
+        const job = options.jobs.create({
+          kind: "shell",
+          owner: owner(context),
+          label: [effective.command, ...effective.args].join(" "),
+          cancel: () => cancellation.abort(new Error("Background job cancelled"))
+        });
+        void (async () => {
+          try {
+            let result2;
+            if (options.executionEnvironment === void 0) {
+              result2 = await executeShell(root, { ...effective, timeoutMs }, cancellation.signal, maxBytes, environment, (stream, text) => job.append(stream === "stderr" ? `[stderr] ${text}` : text));
+            } else {
+              const invocation2 = executionEnvironmentCommand(options.executionEnvironment, effective.command, effective.args);
+              const raw = await options.executionEnvironment.exec({
+                ...invocation2,
+                cwd: workingDirectory(root, effective.cwd ?? void 0),
+                timeoutMs,
+                maxOutputBytes: maxBytes
+              }, cancellation.signal);
+              result2 = boundedExecutionResult(raw, maxBytes, effective.command);
+              job.append(result2.stdout);
+              if (result2.stderr !== "") job.append(`[stderr] ${result2.stderr}`);
+            }
+            job.complete({
+              exitCode: result2.exitCode,
+              ...result2.diagnostic === void 0 ? {} : { error: result2.diagnostic.message }
+            });
+          } catch (error) {
+            job.fail(error);
+          }
+        })();
+        return {
+          jobId: job.id,
+          state: "running",
+          command: [effective.command, ...effective.args].join(" "),
+          exitCode: null,
+          signal: null,
+          stdout: "",
+          stderr: "",
+          truncated: false,
+          truncation: {
+            stdout: { truncated: false, originalBytes: 0, limitBytes: maxBytes },
+            stderr: { truncated: false, originalBytes: 0, limitBytes: maxBytes }
+          },
+          terminationReason: null
+        };
+      }
+      if (options.executionEnvironment === void 0) {
+        return executeShell(root, { ...effective, timeoutMs }, signal, maxBytes, environment);
+      }
+      const invocation = executionEnvironmentCommand(options.executionEnvironment, effective.command, effective.args);
+      const result = await options.executionEnvironment.exec({
+        ...invocation,
+        cwd: workingDirectory(root, effective.cwd ?? void 0),
+        timeoutMs,
+        maxOutputBytes: maxBytes
+      }, signal);
+      return boundedExecutionResult(result, maxBytes, effective.command);
+    }
+  };
+}
+async function executeShell(root, input, cancellation, maxBytes, environment = process.env, onOutput) {
+  const cwd = workingDirectory(root, input.cwd ?? void 0);
+  const stdout = new BoundedOutput(maxBytes);
+  const stderr = new BoundedOutput(maxBytes);
+  return new Promise((resolvePromise, reject) => {
+    if (cancellation.aborted) {
+      reject(cancellation.reason);
+      return;
+    }
+    const invocation = shellInvocation(input, cwd, environment);
+    const child = spawn2(invocation.command, invocation.args, {
+      cwd,
+      shell: false,
+      windowsHide: true,
+      detached: process.platform !== "win32",
+      env: environment,
+      ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
+    });
+    let exitObserved = false;
+    let observedExitCode = null;
+    let observedSignal = null;
+    let settled = false;
+    let terminationReason = null;
+    let termination;
+    let terminalTimer;
+    let streamCloseTimer;
+    const stdoutDecoder = onOutput === void 0 ? void 0 : new AdaptiveOutputDecoder();
+    const stderrDecoder = onOutput === void 0 ? void 0 : new AdaptiveOutputDecoder();
+    const terminate = (reason) => {
+      if (termination !== void 0 || settled) return;
+      terminationReason = reason;
+      if (exitObserved || child.exitCode !== null || child.signalCode !== null) {
+        child.stdout.destroy();
+        child.stderr.destroy();
+        void finishResolve(observedExitCode ?? child.exitCode, observedSignal ?? child.signalCode);
+        return;
+      }
+      termination = terminateProcessTree(child.pid);
+      terminalTimer = setTimeout(() => finishReject(new Error(`Process did not close after ${reason} termination`)), TERMINATION_FAILURE_MS);
+      terminalTimer.unref();
+    };
+    const timeoutMs = input.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS;
+    let timer;
+    child.once("spawn", () => {
+      if (timeoutMs === void 0 || exitObserved || settled) return;
+      timer = setTimeout(() => terminate("timeout"), timeoutMs);
+      timer.unref();
+    });
+    const onCancel = () => terminate("cancelled");
+    cancellation.addEventListener("abort", onCancel, { once: true });
+    child.stdout.on("data", (chunk) => {
+      stdout.add(chunk);
+      if (stdoutDecoder !== void 0) {
+        const text = stdoutDecoder.write(chunk);
+        if (text !== "") onOutput?.("stdout", text);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr.add(chunk);
+      if (stderrDecoder !== void 0) {
+        const text = stderrDecoder.write(chunk);
+        if (text !== "") onOutput?.("stderr", text);
+      }
+    });
+    child.once("exit", (exitCode, exitSignal) => {
+      exitObserved = true;
+      observedExitCode = exitCode;
+      observedSignal = exitSignal;
+      if (timer !== void 0) clearTimeout(timer);
+      streamCloseTimer = setTimeout(() => {
+        child.stdout.destroy();
+        child.stderr.destroy();
+        void finishResolve(observedExitCode, observedSignal);
+      }, STREAM_CLOSE_GRACE_MS);
+      streamCloseTimer.unref();
+    });
+    child.once("error", (error) => {
+      void finishResolve(errorCode(error) === "ENOENT" ? 127 : 1, null, error);
+    });
+    child.once("close", (exitCode, signal) => {
+      void finishResolve(exitCode, signal);
+    });
+    async function finishResolve(exitCode, exitSignal, spawnError) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (termination !== void 0) await termination;
+      const stdoutTail = stdoutDecoder?.end() ?? "";
+      const stderrTail = stderrDecoder?.end() ?? "";
+      if (stdoutTail !== "") onOutput?.("stdout", stdoutTail);
+      if (stderrTail !== "") onOutput?.("stderr", stderrTail);
+      resolvePromise(withShellDiagnostic({
+        exitCode,
+        signal: exitSignal,
+        stdout: stdout.text(),
+        stderr: stderr.text(),
+        truncated: stdout.truncated || stderr.truncated,
+        truncation: { stdout: stdout.metadata(), stderr: stderr.metadata() },
+        terminationReason
+      }, input.command, spawnError));
+    }
+    function finishReject(error) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    }
+    function cleanup() {
+      if (timer !== void 0) clearTimeout(timer);
+      if (terminalTimer !== void 0) clearTimeout(terminalTimer);
+      if (streamCloseTimer !== void 0) clearTimeout(streamCloseTimer);
+      cancellation.removeEventListener("abort", onCancel);
+    }
+  });
+}
+var BoundedOutput = class {
+  #limit;
+  #headLimit;
+  #tailLimit;
+  #head = Buffer.alloc(0);
+  #tailChunks = [];
+  #tailBytes = 0;
+  #complete = Buffer.alloc(0);
+  #bytes = 0;
+  constructor(limit) {
+    this.#limit = limit;
+    this.#headLimit = Math.ceil(limit / 2);
+    this.#tailLimit = Math.floor(limit / 2);
+  }
+  get truncated() {
+    return this.#bytes > this.#limit;
+  }
+  add(chunk) {
+    this.#bytes += chunk.length;
+    if (this.#complete.length < this.#limit) {
+      this.#complete = Buffer.concat([this.#complete, chunk]).subarray(0, this.#limit);
+    }
+    if (this.#head.length < this.#headLimit) {
+      const count = Math.min(this.#headLimit - this.#head.length, chunk.length);
+      this.#head = Buffer.concat([this.#head, chunk.subarray(0, count)]);
+    }
+    if (this.#tailLimit > 0) {
+      this.#tailChunks.push(chunk);
+      this.#tailBytes += chunk.length;
+      if (this.#tailBytes >= this.#tailLimit * 2) {
+        const merged = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
+        this.#tailChunks = [merged];
+        this.#tailBytes = merged.length;
+      }
+    }
+  }
+  metadata() {
+    return { truncated: this.truncated, originalBytes: this.#bytes, limitBytes: this.#limit };
+  }
+  text() {
+    if (!this.truncated) return decodeOutput(this.#complete);
+    const tail = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
+    const encoding = outputEncoding(this.#complete);
+    return `${decodePrefix(this.#head, encoding)}${ELLIPSIS}${decodeSuffix(tail, encoding)}`;
+  }
+};
+var AdaptiveOutputDecoder = class {
+  #pending = Buffer.alloc(0);
+  #decoder;
+  write(chunk) {
+    if (this.#decoder !== void 0) return this.#decoder.decode(chunk, { stream: true });
+    this.#pending = Buffer.concat([this.#pending, chunk]);
+    if (this.#pending.length === 1 && (this.#pending[0] === 255 || this.#pending[0] === 254)) return "";
+    if (!this.#pending.includes(0) && this.#pending.every((byte) => byte < 128)) {
+      const ascii = this.#pending.toString("ascii");
+      this.#pending = Buffer.alloc(0);
+      return ascii;
+    }
+    const classification = classifyUtf8(this.#pending);
+    if (classification === "incomplete") return "";
+    const encoding = outputEncoding(this.#pending, classification);
+    this.#decoder = new TextDecoder(encoding);
+    const text = this.#decoder.decode(this.#pending, { stream: true });
+    this.#pending = Buffer.alloc(0);
+    return text;
+  }
+  end() {
+    if (this.#decoder !== void 0) return this.#decoder.decode();
+    const text = decodeOutput(this.#pending);
+    this.#pending = Buffer.alloc(0);
+    return text;
+  }
+};
+function backgroundFlag(value) {
+  return value === true || value === "true";
+}
+function workingDirectory(root, cwd = ".") {
+  const candidate = resolve(root, cwd);
+  const delta = relative(root, candidate);
+  if (delta === ".." || delta.startsWith(`..${sep}`) || isAbsolute(delta)) throw new Error("Working directory is outside the workspace");
+  return candidate;
+}
+function decodeOutput(buffer) {
+  const encoding = outputEncoding(buffer);
+  return new TextDecoder(encoding).decode(buffer);
+}
+function shellEnvironment(root, environment) {
+  const localBin = join(root, "node_modules", ".bin");
+  if (!existsSync(localBin)) return environment;
+  const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
+  const current = environment[pathKey] ?? "";
+  const entries = current.split(delimiter).filter(Boolean);
+  if (entries.some((entry) => resolve(entry) === resolve(localBin))) return environment;
+  return { ...environment, [pathKey]: [localBin, ...entries].join(delimiter) };
+}
+function boundedExecutionResult(result, maxBytes, command) {
+  if (result.truncation !== void 0) {
+    return withShellDiagnostic({
+      ...result,
+      truncated: result.truncated ?? (result.truncation.stdout.truncated || result.truncation.stderr.truncated),
+      truncation: result.truncation
+    }, command);
+  }
+  const stdout = new BoundedOutput(maxBytes);
+  const stderr = new BoundedOutput(maxBytes);
+  stdout.add(Buffer.from(result.stdout));
+  stderr.add(Buffer.from(result.stderr));
+  return withShellDiagnostic({
+    ...result,
+    stdout: stdout.text(),
+    stderr: stderr.text(),
+    truncated: stdout.truncated || stderr.truncated,
+    truncation: { stdout: stdout.metadata(), stderr: stderr.metadata() }
+  }, command);
+}
+function outputEncoding(buffer, utf8 = classifyUtf8(buffer)) {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 255 && buffer[1] === 254) return "utf-16le";
+    if (buffer[0] === 254 && buffer[1] === 255) return "utf-16be";
+  }
+  const sampleLength = Math.min(buffer.length, 256);
+  let evenZeros = 0;
+  let oddZeros = 0;
+  for (let index = 0; index < sampleLength; index += 1) {
+    if (buffer[index] !== 0) continue;
+    if (index % 2 === 0) evenZeros += 1;
+    else oddZeros += 1;
+  }
+  const threshold = Math.max(2, Math.floor(sampleLength / 8));
+  if (oddZeros >= threshold && oddZeros > evenZeros * 2) return "utf-16le";
+  if (evenZeros >= threshold && evenZeros > oddZeros * 2) return "utf-16be";
+  return utf8 === "valid" || process.platform !== "win32" ? "utf-8" : "gb18030";
+}
+function decodePrefix(buffer, encoding) {
+  for (let end = buffer.length; end >= Math.max(0, buffer.length - 3); end -= 1) {
+    const candidate = buffer.subarray(0, end);
+    try {
+      return new TextDecoder(encoding, { fatal: true }).decode(candidate);
+    } catch {
+    }
+  }
+  return new TextDecoder(encoding).decode(buffer);
+}
+function decodeSuffix(buffer, encoding) {
+  for (let start = 0; start <= Math.min(3, buffer.length); start += 1) {
+    const candidate = buffer.subarray(start);
+    try {
+      return new TextDecoder(encoding, { fatal: true }).decode(candidate);
+    } catch {
+    }
+  }
+  return new TextDecoder(encoding).decode(buffer);
+}
+function classifyUtf8(buffer) {
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+    return "valid";
+  } catch {
+    const suffixLength = incompleteUtf8SuffixLength(buffer);
+    if (suffixLength === 0) return "invalid";
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, buffer.length - suffixLength));
+      return "incomplete";
+    } catch {
+      return "invalid";
+    }
+  }
+}
+function incompleteUtf8SuffixLength(buffer) {
+  for (let start = Math.max(0, buffer.length - 3); start < buffer.length; start += 1) {
+    const lead = buffer[start];
+    const expected = lead >= 194 && lead <= 223 ? 2 : lead >= 224 && lead <= 239 ? 3 : lead >= 240 && lead <= 244 ? 4 : 0;
+    if (expected === 0 || buffer.length - start >= expected) continue;
+    let continuation = true;
+    for (let index = start + 1; index < buffer.length; index += 1) {
+      if ((buffer[index] & 192) !== 128) {
+        continuation = false;
+        break;
+      }
+    }
+    if (continuation) return buffer.length - start;
+  }
+  return 0;
+}
+
+// src/doctor.ts
+async function runDoctor(options = {}, dependencies = {}) {
+  const workspace = resolve2(options.workspace ?? process.cwd());
+  const home = resolve2(options.home ?? homedir());
+  const environment = options.environment ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch2 = options.arch ?? process.arch;
+  const nodeVersion = options.nodeVersion ?? process.version;
+  const checks = [];
+  checks.push(runtimeCheck(nodeVersion, platform, arch2));
+  checks.push(await directoryCheck("workspace", workspace, false));
+  checks.push(await directoryCheck("state directory", join2(home, ".flavor-code"), true, home));
+  let loaded;
+  try {
+    loaded = await (dependencies.loadConfig ?? loadConfig)({
+      cwd: workspace,
+      home,
+      environment,
+      seedGlobalEnv: false
+    });
+    checks.push({
+      name: "configuration",
+      status: "pass",
+      message: loaded.sources.length === 0 ? "defaults are valid; no config files found" : `valid (${loaded.sources.length} source${loaded.sources.length === 1 ? "" : "s"})`
+    });
+  } catch (error) {
+    checks.push({ name: "configuration", status: "fail", message: errorMessage(error) });
+  }
+  checks.push(providerCheck(loaded?.config, environment));
+  checks.push(await searchCheck(dependencies.rgPath ?? rgPath));
+  try {
+    const shell = await (dependencies.probeShell ?? probeShell)(platform, environment);
+    checks.push(shell === void 0 ? { name: "shell", status: "fail", message: "no usable command shell found" } : { name: "shell", status: "pass", message: shell });
+  } catch (error) {
+    checks.push({ name: "shell", status: "fail", message: errorMessage(error) });
+  }
+  checks.push(await pluginCheck([
+    join2(home, ".flavor-code", "plugins"),
+    join2(workspace, ".flavor", "plugins")
+  ]));
+  try {
+    const latest = await (dependencies.fetchLatestVersion ?? fetchLatestVersion)({
+      timeoutMs: options.registryTimeoutMs ?? 3e3
+    });
+    checks.push(latest === void 0 ? { name: "npm registry", status: "warn", message: "unreachable or returned an invalid response" } : { name: "npm registry", status: "pass", message: `reachable; latest flavor-code is v${latest}` });
+  } catch (error) {
+    checks.push({ name: "npm registry", status: "warn", message: errorMessage(error) });
+  }
+  const summary = {
+    passed: checks.filter(({ status }) => status === "pass").length,
+    warnings: checks.filter(({ status }) => status === "warn").length,
+    failed: checks.filter(({ status }) => status === "fail").length
+  };
+  return {
+    version: packageVersion(),
+    platform,
+    arch: arch2,
+    workspace,
+    checks,
+    summary,
+    ok: summary.failed === 0
+  };
+}
+function formatDoctorReport(report) {
+  const labels = { pass: "ok", warn: "warn", fail: "fail" };
+  const lines = [
+    `Flavor Doctor v${report.version}`,
+    `Platform: ${report.platform} ${report.arch}`,
+    `Workspace: ${report.workspace}`,
+    "",
+    ...report.checks.map((check) => `[${labels[check.status]}] ${check.name}: ${check.message}`),
+    "",
+    `Summary: ${report.summary.passed} passed, ${report.summary.warnings} warning${report.summary.warnings === 1 ? "" : "s"}, ${report.summary.failed} failed`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function runtimeCheck(version, platform, arch2) {
+  const major = Number.parseInt(version.replace(/^v/u, "").split(".")[0] ?? "", 10);
+  if (!Number.isInteger(major) || !gte(`${major}.0.0`, "20.0.0")) {
+    return { name: "runtime", status: "fail", message: `Node ${version} is unsupported; Node 20+ is required` };
+  }
+  return { name: "runtime", status: "pass", message: `Node ${version} (${platform} ${arch2})` };
+}
+async function directoryCheck(name, path, mayBeCreated, parent = path) {
+  try {
+    const info = await stat(path);
+    if (!info.isDirectory()) return { name, status: "fail", message: `${path} is not a directory` };
+    await access(path, constants.R_OK | constants.W_OK);
+    return { name, status: "pass", message: `${path} is readable and writable` };
+  } catch (error) {
+    if (mayBeCreated && errorCode2(error) === "ENOENT") {
+      try {
+        await access(parent, constants.R_OK | constants.W_OK);
+        return { name, status: "pass", message: `${path} can be created` };
+      } catch (parentError) {
+        return { name, status: "fail", message: errorMessage(parentError) };
+      }
+    }
+    return { name, status: "fail", message: errorMessage(error) };
+  }
+}
+function providerCheck(config, environment) {
+  if (config === void 0) return { name: "providers", status: "warn", message: "skipped because configuration is invalid" };
+  const configured = Object.keys(config.providers);
+  const environmentProviders = [
+    environment.OPENAI_API_KEY ? "openai env" : void 0,
+    environment.ANTHROPIC_API_KEY ? "anthropic env" : void 0
+  ].filter((value) => value !== void 0);
+  if (configured.length === 0 && environmentProviders.length === 0) {
+    return { name: "providers", status: "warn", message: "no provider or API credential detected" };
+  }
+  const parts = [
+    configured.length > 0 ? `${configured.length} configured` : void 0,
+    environmentProviders.length > 0 ? environmentProviders.join(", ") : void 0
+  ].filter((value) => value !== void 0);
+  return { name: "providers", status: "pass", message: parts.join("; ") };
+}
+async function searchCheck(path) {
+  try {
+    await access(path, constants.R_OK);
+    return { name: "search", status: "pass", message: `bundled ripgrep found at ${path}` };
+  } catch (error) {
+    return { name: "search", status: "fail", message: `bundled ripgrep is unavailable: ${errorMessage(error)}` };
+  }
+}
+async function probeShell(platform, environment) {
+  const shell = resolveRuntimeShell(platform, environment);
+  if (shell === void 0) return void 0;
+  const sentinel = "flavor-shell-ok";
+  const args = shell.kind === "posix" ? ["-c", `printf '${sentinel}'`] : shell.kind === "cmd" ? ["/d", "/s", "/c", `echo|set /p=${sentinel}`] : ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", `[Console]::Out.Write('${sentinel}')`];
+  const result = await execFileNoThrow(shell.command, args, { timeout: 2e3, useCwd: false, env: environment });
+  if (result.code !== 0 || result.stdout !== sentinel) {
+    const detail = result.stderr.trim() || result.error || `unexpected output ${JSON.stringify(result.stdout)}`;
+    throw new Error(`${shell.command} was found but failed its execution probe: ${detail}`);
+  }
+  return `${shell.command} (${shell.kind}; execution probe passed)`;
+}
+async function pluginCheck(directories) {
+  let valid = 0;
+  const diagnostics = [];
+  for (const directory of directories) {
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (errorCode2(error) !== "ENOENT") diagnostics.push(`${directory}: ${errorMessage(error)}`);
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const root = resolve2(directory, entry.name);
+      try {
+        const rootInfo = await lstat(root);
+        if (rootInfo.isSymbolicLink()) throw new Error("plugin directory must not be a symbolic link");
+        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile(join2(root, "flavor-plugin.json"), "utf8")));
+        const main = resolve2(root, manifest.main);
+        const delta = relative2(root, main);
+        if (delta === ".." || delta.startsWith(`..${sep2}`) || isAbsolute2(delta)) throw new Error("plugin entry escapes its root");
+        const mainInfo = await lstat(main);
+        if (!mainInfo.isFile() || mainInfo.isSymbolicLink()) throw new Error("plugin entry must be a regular file");
+        valid += 1;
+      } catch (error) {
+        diagnostics.push(`${entry.name}: ${errorMessage(error)}`);
+      }
+    }
+  }
+  if (diagnostics.length > 0) {
+    return { name: "plugins", status: "warn", message: `${valid} valid; ${diagnostics.join("; ")}` };
+  }
+  return { name: "plugins", status: "pass", message: valid === 0 ? "no project or global plugins found" : `${valid} manifest${valid === 1 ? "" : "s"} valid` };
+}
+function errorCode2(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  rgPath,
+  createJobTools,
+  owner,
+  terminateProcessTree,
+  DEFAULT_MAX_OUTPUT_BYTES,
+  resolveRuntimeShell,
+  createShellTool,
+  executeShell,
+  runDoctor,
+  formatDoctorReport
+};