aiwcli 0.11.0 → 0.12.0

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

@@ -1,162 +1,181 @@
-/**
- * Subprocess environment utilities.
- * 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.
- */
-export function isInternalCall(): boolean {
-  return process.env.AIWCLI_INTERNAL_CALL === "true";
-}
-
-/**
- * Get environment for internal subprocess calls.
- * Returns a copy of process.env with AIWCLI_INTERNAL_CALL=true.
- */
-export function getInternalSubprocessEnv(): Record<string, string | undefined> {
-  return {
-    ...process.env,
-    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();
-    }
-  });
-}
+/**
+ * Subprocess environment utilities.
+ * See SPEC.md §5.10
+ */
+
+import { execSync, execFile } from "node:child_process";
+
+/**
+ * Check if this is an internal subprocess call.
+ * All hooks should check this and return early to prevent recursion.
+ */
+export function isInternalCall(): boolean {
+  return process.env.AIWCLI_INTERNAL_CALL === "true";
+}
+
+/**
+ * Get environment for internal subprocess calls.
+ * Returns a copy of process.env with AIWCLI_INTERNAL_CALL=true and
+ * Claude Code nesting-detection env vars removed so subprocess
+ * claude instances can run without being blocked.
+ */
+export function getInternalSubprocessEnv(): Record<string, string | undefined> {
+  const env = {
+    ...process.env,
+    AIWCLI_INTERNAL_CALL: "true",
+  };
+  // Explicitly delete vars that block subprocess calls (set to undefined does not work)
+  delete env.CLAUDECODE;
+  delete env.CLAUDE_CODE_ENTRYPOINT;
+  return env;
+}
+/**
+ * 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): string | null {
+  try {
+    const cmd = process.platform === "win32" ? `where ${name}` : `which ${name}`;
+    const lines = execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], shell: true })
+      .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;
+  signal: string | null;
+  stdout: Buffer | string;
+  stderr: Buffer | string;
+  status: number | null;
+  message: 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
+  );
+}
+
+/**
+ * Quote a string for use as a cmd.exe argument when shell: true.
+ * Wraps in double quotes and escapes inner double quotes as "".
+ * On non-Windows platforms, returns the string unchanged (execFile
+ * handles quoting automatically without shell).
+ */
+export function shellQuoteWin(arg: string): string {
+  if (process.platform !== "win32") return arg;
+  return '"' + arg.replace(/"/g, '""') + '"';
+}
+
+// ---------------------------------------------------------------------------
+// Async Subprocess Execution
+// ---------------------------------------------------------------------------
+
+/**
+ * Result from an async subprocess execution.
+ * Never throws — callers inspect fields to determine outcome.
+ */
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  killed: boolean;
+  signal: string | null;
+}
+
+/** Options for execFileAsync. */
+export interface ExecAsyncOptions {
+  /** Data piped to the child's stdin. */
+  input?: string;
+  /** Timeout in milliseconds (not seconds). */
+  timeout?: number;
+  /** Environment variables for the child process. */
+  env?: Record<string, string | undefined>;
+  /** Maximum bytes on stdout/stderr. Default: 10 MB. */
+  maxBuffer?: number;
+  /** Use shell for execution. Required on Windows for .cmd files. */
+  shell?: boolean;
+}
+
+/**
+ * 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,
+        shell: options?.shell,
+      },
+      (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 && child.stdin) {
+      child.stdin.write(options.input);
+      child.stdin.end();
+    }
+  });
+}

package/dist/templates/_shared/lib-ts/context/plan-manager.ts

@@ -8,16 +8,14 @@
  * - extractPlanPathFromResult: parse plan path from ExitPlanMode output
  */
 
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-
+import * as crypto from "node:crypto";
+import { getContextDir, getContextPlansDir, sanitizeTitle } from "../base/constants.js";
 import { atomicWrite } from "../base/atomic-write.js";
-import { getContextDir as _getContextDir, getContextPlansDir, sanitizeTitle } from "../base/constants.js";
-import { logDebug, logError, logInfo, logWarn } from "../base/logger.js";
-import { readStateJson } from "../base/state-io.js";
+import { logDebug, logInfo, logWarn, logError } from "../base/logger.js";
 import { generateSlug } from "../base/utils.js";
-import type { ContextState as _ContextState } from "../types.js";
+import type { ContextState } from "../types.js";
 
 // ---------------------------------------------------------------------------
 // Plan archival
@@ -32,11 +30,11 @@ import type { ContextState as _ContextState } from "../types.js";
  * Returns [archivedPath, planHash, planSignature] on success,
  * or [null, null, null] on error.
  */
-export async function archivePlan(
+export function archivePlan(
   planPath: string,
   contextId: string,
   projectRoot?: string,
-): Promise<[null | string, null | string, null | string]> {
+): [string | null, string | null, string | null] {
   if (!fs.existsSync(planPath)) {
     logWarn("plan_manager", `Plan file not found: ${planPath}`);
     return [null, null, null];
@@ -44,9 +42,9 @@ export async function archivePlan(
 
   let content: string;
   try {
-    content = fs.readFileSync(planPath, "utf8");
-  } catch (error_: any) {
-    logError("plan_manager", `Failed to read plan: ${error_}`);
+    content = fs.readFileSync(planPath, "utf-8");
+  } catch (e: any) {
+    logError("plan_manager", `Failed to read plan: ${e}`);
     return [null, null, null];
   }
 
@@ -106,7 +104,7 @@ export async function archivePlan(
  * text suitable for the AI slug generator (which expects conversational input).
  */
 function extractPlanSummary(content: string): string {
-  const lines = content.split("\n");
+  const lines = content.split(/\r?\n/);
   const parts: string[] = [];
   let firstParagraph = "";
 
@@ -117,12 +115,10 @@ function extractPlanSummary(content: string): string {
       const heading = trimmed.replace(/^#+\s*/, "");
       if (heading.length > 2) parts.push(heading);
     }
-
     // Grab first substantial non-heading line as context
     if (!firstParagraph && !trimmed.startsWith("#") && trimmed.length > 20) {
       firstParagraph = trimmed.slice(0, 120);
     }
-
     // Enough material for the AI
     if (parts.length >= 5) break;
   }
@@ -143,15 +139,17 @@ function extractPlanSummary(content: string): string {
 export function findLatestPlan(
   contextId: string,
   projectRoot?: string,
-): null | string {
+): string | null {
   // 1. Check state.json plan_path first
   try {
-    const state = readStateJson(contextId, projectRoot);
+    // Dynamic import to avoid circular dependency at module level
+    const stateIo = require("../base/state-io.js");
+    const state = stateIo.readStateJson(contextId, projectRoot);
     if (state?.plan_path && fs.existsSync(state.plan_path)) {
       return state.plan_path;
     }
-  } catch (error: any) {
-    logWarn("plan_manager", `Failed to check state.json plan_path: ${error}`);
+  } catch (e: any) {
+    logWarn("plan_manager", `Failed to check state.json plan_path: ${e}`);
   }
 
   // 2. Fall back to most recent .md in plans/ dir
@@ -184,7 +182,7 @@ export function findLatestPlan(
  * See SPEC.md §9.4
  */
 export function generatePlanId(): string {
-  return crypto.randomUUID().replaceAll('-', "").slice(0, 8);
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 8);
 }
 
 /**
@@ -193,8 +191,8 @@ export function generatePlanId(): string {
  * See SPEC.md §9.5
  */
 export function normalizePlanContent(text: string): string {
-  let result = text.replaceAll(/<[^>]+>/g, "");
-  result = result.replaceAll(/\s+/g, " ").trim();
+  let result = text.replace(/<[^>]+>/g, "");
+  result = result.replace(/\s+/g, " ").trim();
   return result;
 }
 
@@ -205,17 +203,15 @@ export function normalizePlanContent(text: string): string {
  */
 export function extractPlanAnchors(content: string, maxAnchors = 5): string[] {
   const anchors: string[] = [];
-  for (const line of content.split("\n")) {
+  for (const line of content.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (trimmed.startsWith("#") && trimmed.length > 3) {
       anchors.push(trimmed.slice(0, 80));
     } else if (anchors.length === 0 && trimmed.length > 20) {
       anchors.push(trimmed.slice(0, 80));
     }
-
     if (anchors.length >= maxAnchors) break;
   }
-
   return anchors;
 }
 
@@ -230,7 +226,7 @@ const MAX_TRANSCRIPT_SIZE = 50 * 1024 * 1024; // 50 MB
  * Searches in reverse for the most recent Write tool call targeting .claude/plans/.
  * See SPEC.md §9.7
  */
-export function findPlanPathInTranscript(transcriptPath: string): null | string {
+export function findPlanPathInTranscript(transcriptPath: string): string | null {
   if (!transcriptPath) return null;
 
   if (!fs.existsSync(transcriptPath)) {
@@ -252,9 +248,9 @@ export function findPlanPathInTranscript(transcriptPath: string): null | string
 
   let lines: string[];
   try {
-    lines = fs.readFileSync(transcriptPath, "utf8").split("\n");
-  } catch (error: any) {
-    logWarn("plan_manager", `Failed to read transcript: ${error}`);
+    lines = fs.readFileSync(transcriptPath, "utf-8").split(/\r?\n/);
+  } catch (e: any) {
+    logWarn("plan_manager", `Failed to read transcript: ${e}`);
     return null;
   }
 
@@ -286,7 +282,7 @@ export function findPlanPathInTranscript(transcriptPath: string): null | string
       if (!filePath) continue;
 
       // Check if path contains .claude/plans/ as consecutive parts
-      const parts = filePath.replaceAll('\\', "/").split("/");
+      const parts = filePath.replace(/\\/g, "/").split("/");
       for (let j = 0; j < parts.length - 1; j++) {
         if (parts[j] === ".claude" && parts[j + 1] === "plans") {
           logInfo("plan_manager", `Extracted plan path from transcript: ${filePath}`);
@@ -309,7 +305,7 @@ export function findPlanPathInTranscript(transcriptPath: string): null | string
  * Parses the pattern: "Your plan has been saved to: <path>"
  * See SPEC.md §9.8
  */
-export function extractPlanPathFromResult(toolResult: string): null | string {
+export function extractPlanPathFromResult(toolResult: string): string | null {
   if (!toolResult) return null;
   const match = toolResult.match(/Your plan has been saved to:\s*(.+\.md)/);
   return match ? match[1]!.trim() : null;

package/dist/templates/_shared/lib-ts/handoff/handoff-reader.ts

@@ -7,8 +7,7 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
-
+import * as path from "node:path";
 import { getContextHandoffsDir } from "../base/constants.js";
 import { getContext } from "../context/context-store.js";
 import type { HandoffSections } from "../types.js";
@@ -19,7 +18,7 @@ import type { HandoffSections } from "../types.js";
  * (YYYY-MM-DD-HHMM format ensures lexicographic = chronological).
  * Returns full path to most recent folder, or null.
  */
-export function findLatestHandoff(contextId: string, projectRoot?: string): null | string {
+export function findLatestHandoff(contextId: string, projectRoot?: string): string | null {
   const handoffsDir = getContextHandoffsDir(contextId, projectRoot);
 
   try {
@@ -30,7 +29,7 @@ export function findLatestHandoff(contextId: string, projectRoot?: string): null
       .sort();
 
     if (entries.length === 0) return null;
-    return path.join(handoffsDir, entries.at(-1)!);
+    return path.join(handoffsDir, entries[entries.length - 1]!);
   } catch {
     return null;
   }
@@ -65,7 +64,7 @@ export function readHandoffSections(handoffFolder: string): HandoffSections {
     const filePath = path.join(handoffFolder, filename);
     try {
       if (fs.existsSync(filePath)) {
-        sections[key as keyof HandoffSections] = fs.readFileSync(filePath, "utf8");
+        sections[key as keyof HandoffSections] = fs.readFileSync(filePath, "utf-8");
       }
     } catch {
       // graceful — leave as null
@@ -87,11 +86,11 @@ export function getHandoffTimestamp(handoffFolder: string): Date | null {
 
   const [, year, month, day, hour, minute] = match;
   const date = new Date(
-    Number.parseInt(year!, 10),
-    Number.parseInt(month!, 10) - 1,
-    Number.parseInt(day!, 10),
-    Number.parseInt(hour!, 10),
-    Number.parseInt(minute!, 10),
+    parseInt(year!, 10),
+    parseInt(month!, 10) - 1,
+    parseInt(day!, 10),
+    parseInt(hour!, 10),
+    parseInt(minute!, 10),
   );
 
   return isNaN(date.getTime()) ? null : date;
@@ -106,12 +105,12 @@ export function getHandoffPlanReference(
   handoffFolder: string,
   contextId: string,
   projectRoot?: string,
-): null | string {
+): string | null {
   // Try plan.md frontmatter
   const planMdPath = path.join(handoffFolder, "plan.md");
   try {
     if (fs.existsSync(planMdPath)) {
-      const content = fs.readFileSync(planMdPath, "utf8");
+      const content = fs.readFileSync(planMdPath, "utf-8");
       const frontmatter = parseFrontmatter(content);
       if (frontmatter["plan_path"]) {
         const pp = frontmatter["plan_path"];
@@ -146,7 +145,7 @@ function parseFrontmatter(content: string): Record<string, string> {
   const parts = content.split("---", 3);
   if (parts.length < 3) return frontmatter;
 
-  for (const line of parts[1]!.trim().split("\n")) {
+  for (const line of parts[1]!.trim().split(/\r?\n/)) {
     const colonIdx = line.indexOf(":");
     if (colonIdx !== -1) {
       const key = line.slice(0, colonIdx).trim();

package/dist/templates/_shared/lib-ts/package.json

@@ -7,8 +7,7 @@
     "test:unit": "mocha '__tests__/base/**/*.test.ts' '__tests__/templates/**/*.test.ts'",
     "test:contract": "mocha '__tests__/context/**/*.test.ts' '__tests__/handoff/**/*.test.ts'",
     "test:integration": "mocha '__tests__/integration/**/*.test.ts'",
-    "test:parity": "mocha '__tests__/integration/python-parity.test.ts'",
-    "fixtures": "python __tests__/fixtures/generate_fixtures.py"
+    "test:parity": "mocha '__tests__/integration/python-parity.test.ts'"
   },
   "devDependencies": {
     "mocha": "^10.0.0",