aiwcli 0.10.3 → 0.11.1

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

@@ -5,6 +5,7 @@
  */
 
 import { execFileSync } from "node:child_process";
+
 import { logDebug, logWarn } from "./logger.js";
 import { STOP_WORDS } from "./stop-words.js";
 import { cleanTextForSlug } from "./utils.js";
@@ -44,19 +45,25 @@ export function inference(
 
   try {
     const isWin = process.platform === "win32";
-    let stdout: string;
+    // On Windows with shell:true, Node.js sets windowsVerbatimArguments —
+    // args are joined with spaces, NOT individually quoted. We must manually
+    // wrap multi-word/special-char args in "..." for cmd.exe parsing.
+    // Inside double quotes: "" = literal ", and |&<> are safe.
+    const empty = isWin ? '""' : "";
+    let promptArg = fullPrompt;
+    if (isWin) {
+      promptArg = '"' + fullPrompt.replaceAll(/\r?\n/g, " ").replaceAll('"', '""') + '"';
+    }
 
-    // Use execFileSync with shell option on Windows for safe argument passing
-    // (no string interpolation — avoids command injection)
-    stdout = execFileSync(
+    const stdout = execFileSync(
       "claude",
-      ["--model", model, "--print", "--setting-sources", "", "-p", fullPrompt],
+      ["--model", model, "--print", "--setting-sources", empty, "-p", promptArg],
       {
         timeout: timeoutSec * 1000,
         env,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
-        shell: isWin, // Windows needs shell for command resolution
+        shell: isWin, // Windows needs shell for .cmd resolution
       },
     );
 
@@ -66,10 +73,10 @@ export function inference(
       output: stdout.trim(),
       latency_ms: latencyMs,
     };
-  } catch (e: any) {
+  } catch (error: any) {
     const latencyMs = Date.now() - startTime;
 
-    if (e.code === "ETIMEDOUT" || e.killed) {
+    if (error.code === "ETIMEDOUT" || error.killed) {
       return {
         success: false,
         output: "",
@@ -78,7 +85,7 @@ export function inference(
       };
     }
 
-    if (e.code === "ENOENT") {
+    if (error.code === "ENOENT") {
       return {
         success: false,
         output: "",
@@ -88,11 +95,11 @@ export function inference(
     }
 
     // Non-zero exit code
-    if (e.status !== undefined && e.status !== 0) {
+    if (error.status !== undefined && error.status !== 0) {
       return {
         success: false,
-        output: (e.stdout ?? "").toString().trim(),
-        error: (e.stderr ?? "").toString().trim() || `Exit code: ${e.status}`,
+        output: (error.stdout ?? "").toString().trim(),
+        error: (error.stderr ?? "").toString().trim() || `Exit code: ${error.status}`,
         latency_ms: latencyMs,
       };
     }
@@ -100,7 +107,7 @@ export function inference(
     return {
       success: false,
       output: "",
-      error: String(e),
+      error: String(error),
       latency_ms: latencyMs,
     };
   }
@@ -126,13 +133,13 @@ Output ONLY the keywords separated by spaces, nothing else.`;
 export function generateSemanticSummary(
   prompt: string,
   timeout = 15,
-): string | null {
+): null | string {
   const result = inference(CONTEXT_ID_SYSTEM_PROMPT, prompt, "standard", timeout);
 
   if (!result.success || !result.output) return null;
 
   let summary = result.output.trim();
-  summary = summary.replace(/^["']+|["']+$/g, "");
+  summary = summary.replaceAll(/^["']+|["']+$/g, "");
   summary = summary.replace(/[.!?]+$/, "");
 
   // Filter stop words
@@ -187,7 +194,7 @@ Respond with ONLY a JSON object: {"slug": "your 8-12 word phrase here"}`;
 export function generateContextIdSlug(
   prompt: string,
   timeout = 3,
-): string | null {
+): null | string {
   const truncated = prompt.slice(0, 500);
 
   const result = inference(CONTEXT_ID_SLUG_PROMPT, truncated, "fast", timeout);
@@ -200,7 +207,7 @@ export function generateContextIdSlug(
   const raw = result.output.trim();
 
   // Parse JSON response, fall back to raw text
-  let slug: string | null = null;
+  let slug: null | string = null;
   try {
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && "slug" in parsed) {
@@ -213,11 +220,11 @@ export function generateContextIdSlug(
   if (!slug) slug = raw;
 
   // Clean up
-  slug = slug.replace(/^["'`]+|["'`]+$/g, "");
+  slug = slug.replaceAll(/^["'`]+|["'`]+$/g, "");
   slug = slug.replace(/[.!?]+$/, "");
-  slug = slug.replace(/-/g, " ");
-  slug = slug.replace(/[^a-zA-Z0-9 ]/g, "");
-  slug = slug.replace(/\s+/g, " ").trim();
+  slug = slug.replaceAll('-', " ");
+  slug = slug.replaceAll(/[^a-zA-Z0-9 ]/g, "");
+  slug = slug.replaceAll(/\s+/g, " ").trim();
 
   const words = slug.split(" ");
 

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)
@@ -94,7 +99,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) {
@@ -147,7 +152,7 @@ export function hookLog(
     try {
       if (fs.existsSync(logPath)) {
         const content = fs.readFileSync(logPath, "utf-8");
-        const lines = content.split("\n");
+        const lines = content.split(/\r?\n/);
         if (lines.length > MAX_LOG_LINES) {
           fs.writeFileSync(
             logPath,
@@ -182,6 +187,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

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",
 ]);
 
 /**