aiwcli 0.10.3 → 0.11.0

package/dist/templates/_shared/lib-ts/base/logger.ts

@@ -5,6 +5,11 @@
  * Log location: _output/hook-log.jsonl (global, all sessions)
  * Filter by session using the "sid" field.
  *
+ * stderr is OPT-IN: convenience functions (logDebug, logInfo, logWarn, logError)
+ * write to file only by default. To also write to stderr (visible to Claude Code
+ * as "hook error"), pass { stderr: true } or use logBlocking().
+ * logHookError() always writes to stderr (unhandled errors must be visible).
+ *
  * Environment variables:
  * - HOOK_LOG_DISABLE=1: Disable all file logging
  * - HOOK_LOG_LEVEL=warn: Minimum level to log (default: debug)
@@ -27,31 +32,32 @@ const LEVELS: Record<string, number> = {
 const MAX_LOG_LINES = 10_000; // Max lines in global log before pruning
 
 // Module-level session ID cache
-let _cachedSessionId: string | null = null;
+let _cachedSessionId: null | string = null;
 
 // Module-level context path cache (kept for external callers)
-let _cachedContextPath: string | null = null;
+let _cachedContextPath: null | string = null;
 let _contextResolved = false;
 
 /**
  * Set the session ID for this process. All subsequent log calls include it.
  */
-export function setSessionId(sessionId: string | null): void {
+export function setSessionId(sessionId: null | string): void {
   _cachedSessionId = sessionId;
 }
 
 /**
  * Set the context path for this process. Kept for external callers.
  */
-export function setContextPath(contextPath: string | null): void {
+export function setContextPath(contextPath: null | string): void {
   _cachedContextPath = contextPath;
   _contextResolved = true;
 }
 
-export function getContextPath(): string | null {
+export function getContextPath(): null | string {
   if (!_contextResolved) {
     _contextResolved = true; // Don't retry
-  }
+  }
+
   return _cachedContextPath;
 }
 
@@ -85,8 +91,8 @@ export function hookLog(
   opts?: {
     component?: string;
     data?: any;
-    traceback_str?: string;
     stderr?: boolean;
+    traceback_str?: string;
   },
 ): void {
   try {
@@ -94,7 +100,7 @@ export function hookLog(
     const levelNum = LEVELS[levelLower] ?? 0;
     const component = opts?.component ?? "";
     const tracebackStr = opts?.traceback_str ?? "";
-    const stderrEnabled = opts?.stderr !== false;
+    const stderrEnabled = opts?.stderr === true;
 
     // Write to stderr
     if (stderrEnabled) {
@@ -131,7 +137,8 @@ export function hookLog(
       } catch {
         entry.data = String(opts.data);
       }
-    }
+    }
+
     if (tracebackStr) entry.tb = tracebackStr.trimEnd();
 
     const line = JSON.stringify(entry) + "\n";
@@ -146,7 +153,7 @@ export function hookLog(
     // Line-count guard: prune to last MAX_LOG_LINES
     try {
       if (fs.existsSync(logPath)) {
-        const content = fs.readFileSync(logPath, "utf-8");
+        const content = fs.readFileSync(logPath, "utf8");
         const lines = content.split("\n");
         if (lines.length > MAX_LOG_LINES) {
           fs.writeFileSync(
@@ -182,6 +189,14 @@ export function logError(hookName: string, message: string, opts?: Record<string
   hookLog("error", hookName, message, opts);
 }
 
+/**
+ * Log an error that SHOULD be visible to user/model via stderr.
+ * Use for real problems needing attention, not routine diagnostics.
+ */
+export function logBlocking(hookName: string, message: string, opts?: Record<string, any>): void {
+  hookLog("error", hookName, message, { ...opts, stderr: true });
+}
+
 /**
  * Log a structured diagnostic entry at a hook decision point.
  * See SPEC.md §3.8
@@ -191,11 +206,11 @@ export function logDiagnostic(
   phase: string,
   summary: string,
   opts?: {
-    inputs?: any;
-    decision?: any;
-    reasoning?: any;
     component?: string;
     data?: any;
+    decision?: any;
+    inputs?: any;
+    reasoning?: any;
   },
 ): void {
   const diagData: Record<string, any> = { phase };
@@ -204,7 +219,8 @@ export function logDiagnostic(
   if (opts?.reasoning !== undefined) diagData.reasoning = opts.reasoning;
   if (opts?.data && typeof opts.data === "object") {
     Object.assign(diagData, opts.data);
-  }
+  }
+
   hookLog("debug", hookName, `[DIAG:${phase}] ${summary}`, {
     component: opts?.component ?? "diag",
     data: diagData,
@@ -222,7 +238,7 @@ export function logHookError(
   tracebackStr = "",
 ): void {
   const errStr = typeof error === "string" ? error : String(error);
-  const msg = errStr.replace(/[\n\r]/g, " ").slice(0, 200);
+  const msg = errStr.replaceAll(/[\n\r]/g, " ").slice(0, 200);
   const errType =
     typeof error === "object" && error !== null
       ? error.constructor.name

package/dist/templates/_shared/lib-ts/base/state-io.ts

@@ -5,9 +5,10 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
-import { getContextDir } from "./constants.js";
+import * as path from "node:path";
+
 import { atomicWrite } from "./atomic-write.js";
+import { getContextDir } from "./constants.js";
 import { logWarn } from "./logger.js";
 import type { ContextState, Mode } from "../types.js";
 
@@ -29,7 +30,8 @@ export function toDict(state: ContextState): Record<string, unknown> {
     if (value !== null && value !== undefined) {
       result[key] = value;
     }
-  }
+  }
+
   return result;
 }
 
@@ -52,11 +54,11 @@ export function readStateJson(
   if (!fs.existsSync(sp)) return null;
 
   try {
-    const raw = fs.readFileSync(sp, "utf-8");
+    const raw = fs.readFileSync(sp, "utf8");
     const data = JSON.parse(raw) as Record<string, any>;
     return dictToState(data);
-  } catch (e: any) {
-    logWarn("state_io", `Failed to read state.json for '${contextId}': ${e}`);
+  } catch (error: any) {
+    logWarn("state_io", `Failed to read state.json for '${contextId}': ${error}`);
     return null;
   }
 }
@@ -69,7 +71,7 @@ export function writeStateJson(
   contextId: string,
   state: ContextState,
   projectRoot?: string,
-): [boolean, string | null] {
+): [boolean, null | string] {
   const sp = statePath(contextId, projectRoot);
   const dir = path.dirname(sp);
   fs.mkdirSync(dir, { recursive: true });

package/dist/templates/_shared/lib-ts/base/stop-words.ts

@@ -14,161 +14,161 @@
 
 export const STOP_WORDS: ReadonlySet<string> = new Set([
   // ARTICLES
-  "a", "an", "the",
+  "a", "about", "above",
 
-  // PREPOSITIONS
-  "to", "for", "in", "on", "at", "by", "with", "from", "of", "about",
-  "into", "over", "under", "between", "through", "during", "before", "after",
-  "above", "below", "against", "among", "around", "behind", "beside", "besides",
-  "beyond", "down", "inside", "outside", "near", "off", "onto", "out",
-  "since", "toward", "towards", "until", "upon", "within", "without",
-  "across", "along", "via", "per",
-
-  // PRONOUNS - Personal
-  "i", "you", "he", "she", "it", "we", "they",
-  "me", "him", "her", "us", "them",
-  "myself", "yourself", "himself", "herself", "itself", "ourselves", "themselves",
+  "absolutely", "accordingly", "across", "active", "actually", "after", "afterwards", "against", "ago", "ah",
+  "aiw", "all", "allow", "almost", "along", "already", "alright", "also",
+  "alternatively", "although", "always", // AUXILIARY/MODAL VERBS
+  "am", "among", "an", // CONJUNCTIONS
+  "and", "another",
+  "any", "anybody", "anyone", "anything", "anyway", "anyways", "apparently", "appear",
+  "are", "aren", "arent", "args", "around", "as", "ask",
+  "assert", "async", "at", // SINGLE LETTERS
+  "b",
 
-  // PRONOUNS - Possessive
-  "my", "your", "his", "her", "its", "our", "their",
-  "mine", "yours", "hers", "ours", "theirs",
+  "based", "basic", "basically", "bat", "be", "because", "become",
+  "been", "before", "begin", "behind", "being",
+  "below", "below", "beside", "besides", "between", "beyond", "block",
 
-  // PRONOUNS - Demonstrative
-  "this", "that", "these", "those",
+  "both", "but", "by", "c", "can", "cant", "case",
+  "cases", "cause", "cc", "certainly", "chunk",
 
-  // PRONOUNS - Relative
-  "who", "whom", "whose", "which",
-
-  // PRONOUNS - Indefinite
-  "someone", "somebody", "something", "anyone", "anybody", "anything",
-  "everyone", "everybody", "everything", "no one", "nobody", "nothing",
-  "one", "ones",
-
-  // AUXILIARY/MODAL VERBS
-  "am", "is", "are", "was", "were", "be", "been", "being",
-  "have", "has", "had", "having",
-  "do", "does", "did", "doing", "done",
-  "can", "could", "will", "would", "shall", "should", "may", "might", "must",
-
-  // CONJUNCTIONS
-  "and", "or", "but", "nor", "so", "yet",
-  "if", "then", "else", "whether", "unless", "although", "though",
-  "because", "while", "whereas", "whenever", "wherever",
-
-  // QUESTION WORDS
-  "what", "when", "where", "why", "how",
-
-  // ADVERBS OF PLACE/TIME
-  "here", "there", "now", "always", "never", "often", "sometimes",
-  "already", "still", "soon", "later", "ago", "today", "tomorrow",
-  "yesterday", "currently", "previously", "recently", "immediately",
-  "finally", "eventually", "meanwhile", "afterwards",
-
-  // NEGATION
-  "no", "not", "none", "neither",
-  "don", "doesn", "didn", "won", "wouldn", "couldn", "shouldn",
-  "isn", "aren", "wasn", "weren", "hasn", "haven", "hadn",
-
-  // QUANTIFIERS
-  "some", "any", "all", "each", "every", "both", "few", "more", "most",
-  "many", "much", "several", "other", "another", "enough", "less", "least",
-  "either", "such",
+  "clarification", "class", "clearly", "come",
 
-  // FILLER/HEDGE WORDS
-  "just", "also", "only", "really", "actually", "basically", "simply",
-  "very", "quite", "rather", "pretty", "somewhat", "almost", "nearly",
-  "exactly", "completely", "entirely", "totally", "absolutely",
-  "probably", "possibly", "maybe", "perhaps", "definitely", "certainly",
-  "apparently", "obviously", "clearly", "literally", "essentially",
-
-  // SPEECH-TO-TEXT FILLERS (STT artifacts from voice input)
-  "um", "uh", "ah", "oh", "hmm", "hm", "er", "eh", "huh",
-  "hey", "hi", "hello", "yeah", "yep", "yup", "nah", "nope",
-  "gonna", "gotta", "wanna", "kinda", "sorta",
-  "stuff", "anyway", "anyways", "alright", "right", "well",
-
-  // COMMON REQUEST PHRASES
-  "want", "need", "help", "please", "like", "let", "get",
-  "think", "know", "see", "try", "make", "give", "take",
-  "look", "looking", "trying", "going", "getting", "making",
+  "complete", "completely", "consequently", "consider",
 
-  // COMMON NON-ACTION VERBS
-  "go", "come", "put", "say", "tell", "ask", "find", "keep",
-  "seem", "appear", "become", "remain", "stay", "feel", "show", "mean",
-  "include", "provide", "require", "allow", "expect", "cause",
-  "follow", "consider", "continue", "start", "begin", "end",
-  "contain", "contains",
+  "const", "contain", "contains", "continue", "conversely", "correct",
+  "correctly", "could", "couldn", "couldnt", "critical", "current",
+  "currently", "d",
 
-  // LINKING/TRANSITION WORDS
-  "however", "therefore", "thus", "hence", "otherwise", "instead",
-  "moreover", "furthermore", "nevertheless", "nonetheless", "accordingly",
-  "consequently", "similarly", "likewise", "conversely", "alternatively",
+  "def", "definitely", "dict", "did", "didn", "didnt", "different", "directory",
+  "do", "does", "doesn", "doesn",
+  "doesnt", "doing", "don", "done", "dont",
+  "down", "during", "e", "each", "eh", "eight", "either", "elif", "else",
 
-  // FILE EXTENSIONS
-  "py", "md", "ts", "json", "js", "yaml", "toml", "exe", "bat",
+  "empty", "end", "enough", "entirely", "eprint", "er",
+  "essentially", // SHORT NOISE
+  "etc", "eventually", "every", "everybody", "everyone", "everything",
+  "exactly", "example", "examples", "except", "exe",
 
-  // COMMON CODING TERMS
-  "using", "used", "uses",
-  "based", "following",
-  "same", "different", "specific", "existing", "new", "current", "first",
-  "full", "complete", "single", "multiple", "simple",
-  "needed", "required", "provided", "expected", "correctly",
-  "works", "working", "work",
+  "existing", "expect", "expected", "f", "false",
 
-  // STRUCTURAL WORDS
-  "step", "steps", "phase", "below",
+  "feature", "features", "feel", "few", "finally", "find", "first",
+  "five", "folder", "follow", "following", "footer", "for", "format",
+  "four", "from", "full", "furthermore", "g",
+  "general", "get", "getting", "give",
 
-  // QUERY LANGUAGE
-  "questions", "question", "clarification",
+  // COMMON NON-ACTION VERBS
+  "go", "going", "gonna", "gotta",
+  "group", "h", "had", "hadn", "hadnt", "has", "hasn",
+  "hasnt", "have", "haven", "havent", "having", "he", "header",
 
-  // OVERLY GENERIC TERMS
-  "thing", "things", "way", "ways", "kind", "type", "types",
-  "example", "examples", "case", "cases",
-  "part", "parts", "point", "points",
-  "time", "times", "next", "last",
-  "set", "list", "group", "item", "items",
+  "hello", "help", "hence", "her", "her", // ADVERBS OF PLACE/TIME
+  "here", "heres", "hers", "herself",
+  "hes", "hey", "hi", // GENERIC ADJECTIVES
+  "high", "him", "himself", "his", "hm",
+  "hmm", "how",
 
-  // PROGRAMMING KEYWORDS
-  "self", "def", "return", "import", "true", "false", "none", "str",
-  "const", "async", "class", "assert", "except", "dict", "len", "args",
-  "sys", "eprint", "elif", "lambda", "yield", "pass",
+  // LINKING/TRANSITION WORDS
+  "however", "huh", // PRONOUNS - Personal
+  "i", "id", "if", "ill", // CONTRACTED FORMS
+  "im",
+  "immediately", "import", "important", "in", "include", "index", // GENERIC TECHNICAL NOUNS
+  "information",
+  "inside", "instead", "into", "is", "isn",
+  "isnt", "issue", "it", "item", "items", "its",
+  "itself", "ive", "j", "js", "json",
 
-  // GENERIC ADJECTIVES
-  "high", "low", "important", "critical", "optional", "manual",
-  "real", "empty", "stable", "active", "proper", "correct",
-  "basic", "main", "primary", "secondary", "general", "overall",
+  // FILLER/HEDGE WORDS
+  "just", "k", "keep", "kind", "kinda", "know", "l", "lambda", "last",
+  "later", "least", "len", "less", "let", "lets", "level", "like",
+  "likewise", "line", "lines", "list", "literally",
+  "ll", "look", "looking", "low", "m", "main",
 
-  // GENERIC TECHNICAL NOUNS
-  "information", "format", "status", "method", "purpose", "result",
-  "source", "value", "option", "options", "feature", "features", "issue",
-  "process", "version", "mode", "state",
+  "make", "making", "manual", "many", "may", "maybe", "md",
+  "me", "mean", "meanwhile", "method", "might", "mine", "mode",
+  "more", "moreover", "most", "much", "multiple", "must",
 
-  // DOCUMENT/CODE STRUCTURE
-  "section", "lines", "line", "folder", "directory", "index",
-  "level", "block", "chunk", "region", "header", "footer",
+  // PRONOUNS - Possessive
+  "my", "myself", "n", "nah", "near", "nearly", "need", "needed",
+  "neither", "never", "nevertheless", "new", "next", "nine", // NEGATION
+  "no", "nobody",
+  "none", "none", "nonetheless", "no one", "nope", "nor",
+  "not", "nothing", "now", "o", "obviously", "of",
+  "off", "often",
+
+  "oh", "ok", "okay", "on", "one", "ones",
+  "only", "onto", "option", "optional", "options",
+  "or", "other", "otherwise", "our", "ours",
+
+  "ourselves", "out", "outside", "over", "overall", "p", "part", "parts", "pass",
+
+  "per", "perhaps", "phase",
+  "pl", "please",
+  "point", "points", "possibly", "pretty", "previously", "primary", "probably",
+  "process", "proper", "provide", "provided", "purpose",
+  "put", // FILE EXTENSIONS
+  "py", "q", "question", // QUERY LANGUAGE
+  "questions",
+  "quite", "r", "rather",
 
   // FRAGMENT WORDS
-  "re", "pl", "aiw", "ve", "ll", "doesn", "t", "s",
+  "re", "real", "really", "recently",
+
+  "region", "remain", "require",
 
-  // CONTRACTED FORMS
-  "im", "ive", "id", "ill", "youre", "youve", "youll",
-  "hes", "shes", "weve", "theyre", "theyve", "dont", "doesnt",
-  "didnt", "wont", "wouldnt", "cant", "couldnt", "shouldnt", "isnt",
-  "arent", "wasnt", "werent", "hasnt", "havent", "hadnt", "lets",
-  "thats", "whats", "heres", "theres", "whos",
+  "required", "result", "return", "right", "s", "same", "say",
+  "secondary", // DOCUMENT/CODE STRUCTURE
+  "section", "see", "seem",
+  // PROGRAMMING KEYWORDS
+  "self", "set", "seven", "several",
+  "shall", "she", "shes", "should",
+  "shouldn", "shouldnt", "show", "similarly", "simple",
+
+  "simply", "since", "single", "six", "so", // QUANTIFIERS
+  "some", "somebody", // PRONOUNS - Indefinite
+  "someone",
+  "something", "sometimes", "somewhat", "soon", "sorta", "source", "specific", "stable",
+  "start", "state", "status", "stay", // STRUCTURAL WORDS
+  "step", "steps",
+
+  "still", "str", "stuff", "such", "sys", "t",
+  "take", "tell", "ten", "that", "thats", "the",
+  "their", "theirs", "them", "themselves", "then", "there",
+
+  "therefore", "theres", "these", "they", "theyre", "theyve",
+  // OVERLY GENERIC TERMS
+  "thing", "things", "think", // PRONOUNS - Demonstrative
+  "this", "those", "though", "three",
+  "through", "thus", "time", "times",
 
-  // SHORT NOISE
-  "etc", "up", "as", "cc",
+  // PREPOSITIONS
+  "to", "today", "toml", "tomorrow", // SHORT FILLER
+  "too", "totally",
+  "toward", "towards", "true", "try", "trying", "ts",
 
   // NUMBER WORDS
-  "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
+  "two", "type", "types", "u", "uh", // SPEECH-TO-TEXT FILLERS (STT artifacts from voice input)
+  "um", "under", "unless",
+
+  "until", "up", "upon", "us", "used", "uses", // COMMON CODING TERMS
+  "using",
+  "v", "value", "ve", "version", "very", "via", "w",
+  "wanna", // COMMON REQUEST PHRASES
+  "want", "was", "wasn", "wasnt", "way", "ways",
+  "we", "well", "were", "weren", "werent", "weve", // QUESTION WORDS
+  "what",
+  "whats", "when", "whenever", "where", "whereas",
+
+  "wherever", "whether", "which", "while",
+
+  // PRONOUNS - Relative
+  "who", "whom", "whos", "whose", "why", "will", "with", "within", "without",
 
-  // SINGLE LETTERS
-  "b", "c", "d", "e", "f", "g", "h", "j", "k", "l", "m", "n", "o", "p",
-  "q", "r", "u", "v", "w", "x", "y", "z",
+  "won", "wont", "work", "working", "works", "would", "wouldn", "wouldnt", "x", "y", "yaml", "yeah", "yep", "yes",
+  "yesterday", "yet", "yield", "you", "youll", "your", "youre", "yours",
 
-  // SHORT FILLER
-  "too", "yes", "ok", "okay",
+  "yourself", "youve", "yup", "z",
 ]);
 
 /**

package/dist/templates/_shared/lib-ts/base/subprocess-utils.ts

@@ -3,6 +3,8 @@
  * See SPEC.md §5.10
  */
 
+import { execFile, execSync } from "node:child_process";
+
 /**
  * Check if this is an internal subprocess call.
  * All hooks should check this and return early to prevent recursion.
@@ -21,3 +23,140 @@ export function getInternalSubprocessEnv(): Record<string, string | undefined> {
     AIWCLI_INTERNAL_CALL: "true",
   };
 }
+
+/**
+ * Find an executable on the system PATH.
+ * Uses `where` on Windows, `which` on Unix.
+ * On Windows, prefers .cmd/.exe over extensionless shims since
+ * execFileSync cannot spawn extensionless shell scripts.
+ * Returns the first match or null if not found.
+ */
+export function findExecutable(name: string): null | string {
+  try {
+    const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
+    const lines = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] })
+      .trim()
+      .split(/\r?\n/)
+      .map((l) => l.trim())
+      .filter(Boolean);
+
+    if (lines.length === 0) return null;
+
+    // On Windows, `where` may return an extensionless shim first (e.g. npm creates
+    // both `claude` and `claude.cmd`). execFileSync can't spawn the extensionless
+    // one, so prefer .cmd or .exe.
+    if (process.platform === "win32") {
+      const preferred = lines.find((l) => /\.(cmd|exe)$/i.test(l));
+      return preferred ?? lines[0] ?? null;
+    }
+
+    return lines[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Type guard for Node.js child_process exec errors.
+ * ExecSync throws objects with these extra properties on non-zero exit or timeout.
+ */
+export interface ExecSyncError {
+  killed: boolean;
+  message: string;
+  signal: null | string;
+  status: null | number;
+  stderr: Buffer | string;
+  stdout: Buffer | string;
+}
+
+/** Check if an unknown error is an ExecSync error with process info. */
+export function isExecSyncError(e: unknown): e is ExecSyncError {
+  return (
+    typeof e === "object" &&
+    e !== null &&
+    "killed" in e &&
+    "signal" in e
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Async Subprocess Execution
+// ---------------------------------------------------------------------------
+
+/**
+ * Result from an async subprocess execution.
+ * Never throws — callers inspect fields to determine outcome.
+ */
+export interface ExecResult {
+  exitCode: number;
+  killed: boolean;
+  signal: null | string;
+  stderr: string;
+  stdout: string;
+}
+
+/** Options for execFileAsync. */
+export interface ExecAsyncOptions {
+  /** Environment variables for the child process. */
+  env?: Record<string, string | undefined>;
+  /** Data piped to the child's stdin. */
+  input?: string;
+  /** Maximum bytes on stdout/stderr. Default: 10 MB. */
+  maxBuffer?: number;
+  /** Timeout in milliseconds (not seconds). */
+  timeout?: number;
+}
+
+/**
+ * Async subprocess execution that does NOT block the event loop.
+ * Drop-in replacement for execFileSync in Promise-based parallel patterns.
+ *
+ * Returns ExecResult on both success and non-zero exit.
+ * On timeout: result.killed = true, result.signal = "SIGTERM".
+ * On spawn failure: result.exitCode = -1, result.stderr contains error.
+ */
+export function execFileAsync(
+  file: string,
+  args: string[],
+  options?: ExecAsyncOptions,
+): Promise<ExecResult> {
+  return new Promise((resolve) => {
+    const child = execFile(
+      file,
+      args,
+      {
+        encoding: "utf-8",
+        timeout: options?.timeout ?? 0,
+        env: options?.env as NodeJS.ProcessEnv,
+        maxBuffer: options?.maxBuffer ?? 10 * 1024 * 1024,
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          // execFile callback error includes process exit info
+          const errObj = error as unknown as Record<string, unknown>;
+          resolve({
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? ""),
+            exitCode: typeof errObj.code === "number" ? errObj.code : (error as any).status ?? 1,
+            killed: Boolean(errObj.killed),
+            signal: typeof errObj.signal === "string" ? errObj.signal : null,
+          });
+        } else {
+          resolve({
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? ""),
+            exitCode: 0,
+            killed: false,
+            signal: null,
+          });
+        }
+      },
+    );
+
+    // Pipe input to stdin if provided
+    if (options?.input !== null && options?.input !== undefined && child.stdin) {
+      child.stdin.write(options.input);
+      child.stdin.end();
+    }
+  });
+}