aiwcli 0.15.4 → 0.15.7

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/runtime}/state-io.ts

@@ -5,7 +5,7 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import path from "node:path";
 
 import { atomicWrite } from "./atomic-write.js";
 import { getContextDir } from "./constants.js";
@@ -118,11 +118,11 @@ export function readStateJson(
   if (!fs.existsSync(sp)) return null;
 
   try {
-    const raw = fs.readFileSync(sp, "utf-8");
-    const data = JSON.parse(raw) as Record<string, any>;
+    const raw = fs.readFileSync(sp, "utf8");
+    const data = JSON.parse(raw) as Record<string, unknown>;
     migrateConsumedFlags(data); // Migrate before dictToState
     return dictToState(data);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("state_io", `Failed to read state.json for '${contextId}': ${error}`);
     return null;
   }
@@ -142,7 +142,8 @@ export function writeStateJson(
   fs.mkdirSync(dir, { recursive: true });
 
   const content = JSON.stringify(toDict(state), null, 2);
-  return atomicWrite(sp, content);
+  // fsync: false — state.json is reconstructable from context folder contents
+  return atomicWrite(sp, content, 2, [500, 1000], false);
 }
 
 /**
@@ -159,7 +160,7 @@ export function dictToState(data: Record<string, unknown>): ContextState {
     typeof data.mode === "string" ? data.mode : "idle";
   const mode: Mode = (MODE_MIGRATION[rawMode] ?? rawMode) as Mode;
 
-  const state: any = {
+  const state: Record<string, unknown> = {
     id: data.id,
     status: data.status ?? "active",
     summary: data.summary ?? "",
@@ -199,5 +200,8 @@ export function dictToState(data: Record<string, unknown>): ContextState {
     }
   }
 
-  return state as ContextState;
+  return state as unknown as ContextState;
 }
+
+
+

package/dist/templates/core/lib-ts/runtime/stop-words.ts

@@ -0,0 +1,185 @@
+/**
+ * Stop words for context ID generation.
+ *
+ * Generated from analysis of 1,424 prompts, context summaries, and plan files.
+ * Words that appear frequently but don't help identify the specific task.
+ *
+ * ACTION VERBS ARE INTENTIONALLY EXCLUDED:
+ * add, fix, update, create, implement, refactor, migrate, debug, remove, change,
+ * move, rename, delete, build, test, deploy, verify, analyze, modify, write, run,
+ * check, replace, save, sync, load, extract, install, clean, merge, etc.
+ *
+ * See SPEC.md §14.1
+ */
+
+export const STOP_WORDS: ReadonlySet<string> = new Set([
+  // ARTICLES
+  "a", "about", "above",
+
+  "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",
+  "anybody", "anyone", "anything", "anyway", "anyways", "apparently", "appear", "are",
+  "aren", "arent", "args", "around", "as", "ask", "assert",
+  "async", "at", "b", // SINGLE LETTERS
+  "based",
+
+  "basic", "basically", "bat", "be", "because", "become", "been",
+  "before", "begin", "behind", "being", "below",
+  "below", "beside", "besides", "between", "beyond", "block", "both",
+
+  "but", "by", "c", "can", "cant", "case", "cases",
+  "cause", "cc", "certainly", "chunk", "clarification",
+
+  "class", "clearly", "come", "complete",
+
+  "completely", "consequently", "consider", "const",
+
+  "contain", "contains", "continue", "conversely", "correct", "correctly",
+  "could", "couldn", "couldnt", "critical", "current", "currently",
+  "d", "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", "empty",
+
+  "end", "enough", "entirely", "eprint", "er", "essentially", // SHORT NOISE
+  "etc",
+  "eventually", "every", "everybody", "everyone", "everything", "exactly",
+  "example", "examples", "except", "exe", "existing",
+
+  "expect", "expected", "f", "false", "feature",
+
+  "features", "feel", "few", "finally", "find", "first", "five",
+  "folder", "follow", "following", "footer", "for", "format", "four",
+  "from", "full", "furthermore", "g", "general",
+  "get", "getting", "give", // COMMON NON-ACTION VERBS
+  "go",
+
+  "going", "gonna", "gotta", "group",
+  "h", "had", "hadn", "hadnt", "has", "hasn", "hasnt",
+  "have", "haven", "havent", "having", "he", "header", "hello",
+
+  "help", "hence", "her", "her", "here", // ADVERBS OF PLACE/TIME
+  "heres", "hers", "herself", "hes",
+  "hey", "hi", "high", // GENERIC ADJECTIVES
+  "him", "himself", "his", "hm", "hmm",
+  "how", // LINKING/TRANSITION WORDS
+  "however",
+
+  "huh", "i", // PRONOUNS - Personal
+  "id", "if", "ill", "im", // CONTRACTED FORMS
+  "immediately",
+  "import", "important", "in", "include", "index", "information", // GENERIC TECHNICAL NOUNS
+  "inside",
+  "instead", "into", "is", "isn", "isnt",
+  "issue", "it", "item", "items", "its", "itself",
+  "ive", "j", "js", "json", // 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", "make",
+
+  "making", "manual", "many", "may", "maybe", "md", "me",
+  "mean", "meanwhile", "method", "might", "mine", "mode", "more",
+  "moreover", "most", "much", "multiple", "must", // PRONOUNS - Possessive
+  "my",
+
+  "myself", "n", "nah", "near", "nearly", "need", "needed", "neither",
+  "never", "nevertheless", "new", "next", "nine", "no", // NEGATION
+  "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", "questions", // QUERY LANGUAGE
+  "quite",
+  "r", "rather", // FRAGMENT WORDS
+  "re",
+
+  "real", "really", "recently", "region",
+
+  "remain", "require", "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", "some", // QUANTIFIERS
+  "somebody", "someone", // PRONOUNS - Indefinite
+  "something",
+  "sometimes", "somewhat", "soon", "sorta", "source", "specific", "stable", "start",
+  "state", "status", "stay", "step", // STRUCTURAL WORDS
+  "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", "this", // PRONOUNS - Demonstrative
+  "those", "though", "three", "through",
+  "thus", "time", "times", // PREPOSITIONS
+  "to",
+
+  "today", "toml", "tomorrow", "too", // SHORT FILLER
+  "totally", "toward",
+  "towards", "true", "try", "trying", "ts", // NUMBER WORDS
+  "two",
+
+  "type", "types", "u", "uh", "um", // SPEECH-TO-TEXT FILLERS (STT artifacts from voice input)
+  "under", "unknown", "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",
+
+  "won", "wont", "work", "working", "works", "would", "wouldn", "wouldnt", "x", "y", "yaml", "yeah", "yep", "yes",
+  "yesterday", "yet", "yield", "you", "youll", "your", "youre", "yours",
+
+  "yourself", "youve", "yup", "z",
+]);
+
+/**
+ * Filter stop words from text.
+ * Splits on whitespace, removes words in STOP_WORDS set and single-char words.
+ * See SPEC.md §6.4
+ */
+export function filterStopWords(text: string): string {
+  return text
+    .split(/\s+/)
+    .filter((word) => word.length > 1 && !STOP_WORDS.has(word.toLowerCase()))
+    .join(" ");
+}
+

package/dist/templates/core/lib-ts/runtime/subprocess-utils.ts

@@ -0,0 +1,147 @@
+import { execFile } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+
+import { resolveExecutable } from './executable-policy.js'
+
+const childProcesses = new Set<ChildProcess>()
+
+function cleanupChildren(): void {
+  for (const child of childProcesses) {
+    try {
+      child.kill('SIGKILL')
+    } catch {
+      // Child may have already exited.
+    }
+  }
+
+  childProcesses.clear()
+}
+
+process.on('exit', () => {
+  cleanupChildren()
+})
+
+process.on('SIGINT', () => {
+  cleanupChildren()
+  process.exit(130)
+})
+
+process.on('SIGTERM', () => {
+  cleanupChildren()
+  process.exit(143)
+})
+
+export function isInternalCall(): boolean {
+  return process.env.AIWCLI_INTERNAL_CALL === 'true'
+}
+
+export function getInternalSubprocessEnv(): Record<string, string | undefined> {
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    AIWCLI_INTERNAL_CALL: 'true',
+  }
+
+  delete env.CLAUDECODE
+  delete env.CLAUDE_CODE_ENTRYPOINT
+  return env
+}
+
+export function findExecutable(name: string): string | null {
+  return resolveExecutable(name, { windowsProfile: 'cmdOrExeFirst' })
+}
+
+export interface ExecSyncError {
+  killed: boolean
+  signal: string | null
+  stdout: Buffer | string
+  stderr: Buffer | string
+  status: number | null
+  message: string
+}
+
+export function isExecSyncError(error: unknown): error is ExecSyncError {
+  return typeof error === 'object' && error !== null && 'killed' in error && 'signal' in error
+}
+
+export function normalizePathForCli(pathValue: string): string {
+  if (process.platform !== 'win32') return pathValue
+  return pathValue.replaceAll('\\', '/')
+}
+
+export function shellQuoteWin(arg: string): string {
+  if (process.platform !== 'win32') return arg
+  return '"' + arg.replaceAll('"', '""') + '"'
+}
+
+export interface ExecResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+  killed: boolean
+  signal: string | null
+}
+
+export interface ExecAsyncOptions {
+  input?: string | undefined
+  timeout?: number | undefined
+  env?: Record<string, string | undefined> | undefined
+  maxBuffer?: number | undefined
+  shell?: boolean | undefined
+}
+
+export function execFileAsync(
+  file: string,
+  args: string[],
+  options?: ExecAsyncOptions,
+): Promise<ExecResult> {
+  return new Promise((resolve) => {
+    const child = execFile(
+      file,
+      args,
+      {
+        encoding: 'utf8',
+        timeout: options?.timeout ?? 0,
+        env: options?.env as NodeJS.ProcessEnv,
+        maxBuffer: options?.maxBuffer ?? 10 * 1024 * 1024,
+        shell: options?.shell,
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          const errObj = error as unknown as Record<string, unknown>
+          resolve({
+            stdout: String(stdout ?? ''),
+            stderr: String(stderr ?? ''),
+            exitCode:
+              typeof errObj.code === 'number'
+                ? errObj.code
+                : typeof errObj.status === 'number'
+                  ? errObj.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,
+          })
+        }
+      },
+    )
+
+    childProcesses.add(child)
+    child.on('exit', () => {
+      childProcesses.delete(child)
+    })
+
+    if (options?.input !== null && options?.input !== undefined && child.stdin) {
+      child.stdin.write(options.input)
+      child.stdin.end()
+    }
+  })
+}
+
+

package/dist/templates/core/lib-ts/runtime/tmux-preflight.ts

@@ -0,0 +1,93 @@
+import { execFileSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+
+import { isCommandAvailable, lookupExecutables } from './executable-policy.js'
+import { isWindowsPlatform } from './platform-adapter.js'
+
+export function selectMsysBashFromLookupPaths(paths: string[]): null | string {
+  for (const candidate of paths) {
+    const trimmed = candidate.trim()
+    if (trimmed && /git|msys|mingw/iu.test(trimmed)) return trimmed
+  }
+
+  return null
+}
+
+export function deriveMsysBashFromGitPath(gitPath: string): null | string {
+  const trimmed = gitPath.trim()
+  if (!trimmed) return null
+
+  const gitMatch = trimmed.match(/^(.+[/\\]Git)[/\\]cmd[/\\]git\.exe$/iu)
+  if (!gitMatch?.[1]) return null
+  return `${gitMatch[1]}\\usr\\bin\\bash.exe`
+}
+
+export function findMsysBash(): null | string {
+  const directBash = selectMsysBashFromLookupPaths(lookupExecutables('bash', { platform: 'win32' }))
+  if (directBash) return directBash
+
+  const gitCandidates = lookupExecutables('git', { platform: 'win32' })
+  for (const candidate of gitCandidates) {
+    const derived = deriveMsysBashFromGitPath(candidate)
+    if (derived && existsSync(derived)) return derived
+  }
+
+  const knownPaths = [
+    String.raw`C:\Program Files\Git\usr\bin\bash.exe`,
+    String.raw`C:\Program Files (x86)\Git\usr\bin\bash.exe`,
+  ]
+
+  for (const knownPath of knownPaths) {
+    if (existsSync(knownPath)) return knownPath
+  }
+
+  return null
+}
+
+export function isTmuxReachableViaBash(bashPath: string): boolean {
+  try {
+    execFileSync(bashPath, ['-lc', 'tmux -V'], {
+      timeout: 3000,
+      stdio: 'ignore',
+      env: { ...process.env, MSYS_NO_PATHCONV: '1' },
+      windowsHide: true,
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function isNativeTmuxAvailable(platform: NodeJS.Platform = process.platform): boolean {
+  return isCommandAvailable('tmux', platform)
+}
+
+/** Find psmux (native Windows terminal multiplexer) on PATH. */
+export function findPsmux(): null | string {
+  if (!isWindowsPlatform()) return null
+  const candidates = lookupExecutables('psmux', { platform: 'win32' })
+  return candidates[0]?.trim() || null
+}
+
+export interface WindowsTmuxPreflight {
+  available: boolean
+  bashPath?: string
+  reason?: string
+}
+
+export function preflightWindowsTmux(): WindowsTmuxPreflight {
+  if (!isWindowsPlatform()) {
+    return { available: false, reason: 'not running on Windows' }
+  }
+
+  const bashPath = findMsysBash()
+  if (!bashPath) {
+    return { available: false, reason: 'Git Bash not found' }
+  }
+
+  if (!isTmuxReachableViaBash(bashPath)) {
+    return { available: false, bashPath, reason: 'tmux not available in Git Bash' }
+  }
+
+  return { available: true, bashPath }
+}

package/dist/templates/{_shared/lib-ts/base → core/lib-ts/runtime}/utils.ts

@@ -10,7 +10,7 @@ import { STOP_WORDS } from "./stop-words.js";
 /**
  * Print to stderr. For terminal-only UX messages, not diagnostics.
  */
-export function eprint(...args: any[]): void {
+export function eprint(...args: unknown[]): void {
   process.stderr.write(args.map(String).join(" ") + "\n");
 }
 
@@ -127,7 +127,7 @@ export function generateSlug(
         );
       }
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("utils", `AI slug generation failed, using fallback: ${error}`);
   }
 
@@ -171,7 +171,7 @@ export function generateContextId(
   try {
     const slug = generateSlug(summary);
     baseId = `${timestamp}-${slug}`;
-  } catch (error: any) {
+  } catch (error: unknown) {
     logError(
       "utils",
       `Context ID generation failed entirely, using timestamp: ${error}`,
@@ -190,3 +190,4 @@ export function generateContextId(
 
   return `${baseId}-${counter}`;
 }
+

package/dist/templates/{_shared → core}/lib-ts/templates/formatters.ts

@@ -32,13 +32,14 @@ export function getStatusIcon(status: string): string {
 
 // §13.3 — Task rendering
 export function renderTaskItem(
-  task: Record<string, any> | Task,
+  task: Record<string, unknown> | Task,
   showDescription = true,
   maxDescriptionLength = 100,
 ): string {
-  const status = (task as any).status ?? "pending";
-  const subject = (task as any).subject ?? "";
-  const description = (task as any).description ?? "";
+  const taskData = task as Partial<Task> & Record<string, unknown>;
+  const status = typeof taskData.status === "string" ? taskData.status : "pending";
+  const subject = typeof taskData.subject === "string" ? taskData.subject : "";
+  const description = typeof taskData.description === "string" ? taskData.description : "";
 
   const icon = getStatusIcon(status);
   const statusText = `[${status.toUpperCase()}]`;
@@ -57,7 +58,7 @@ export function renderTaskItem(
 }
 
 export function renderTaskList(
-  tasks: Array<Record<string, any> | Task>,
+  tasks: Array<Record<string, unknown> | Task>,
   header = "Active Tasks",
   showDescription = true,
 ): string {
@@ -102,3 +103,4 @@ export const REASON_MAP: Record<string, string> = {
 export function formatReason(reason: string): string {
   return REASON_MAP[reason] ?? reason;
 }
+

package/dist/templates/{_shared → core}/lib-ts/templates/plan-context.ts

@@ -29,7 +29,7 @@ What exactly to build or change
 - \`exact/path/to/reference.ext\` — Why relevant (e.g., "pattern to follow at lines 12-30")
 
 ## Steps
-Numbered steps with specific details. For each step, consider whether any of the skills available in your system-reminder messages would help the implementation agent — if so, reference the skill inline at the point of use.
+Numbered steps with specific details. For each step, consider whether unknown of the skills available in your system-reminder messages would help the implementation agent — if so, reference the skill inline at the point of use.
 
 1. [Specific action with function names, patterns, or code snippets]
 2. [Enough detail for someone who never saw this conversation]
@@ -56,3 +56,4 @@ The implementation agent should document these so the next session inherits what
 - [ ] Are relevant skills referenced where they add value?
 - [ ] Are key decisions captured so they survive this session?`;
 }
+

package/dist/templates/{_shared → core}/lib-ts/tsconfig.json

@@ -7,7 +7,9 @@
     "noUncheckedIndexedAccess": true,
     "outDir": "dist",
     "rootDir": ".",
-    "declaration": true
+    "declaration": true,
+    "types": ["node", "bun-types"],
+    "skipLibCheck": true
   },
   "include": ["./**/*.ts"]
 }