aiwcli 0.15.5 → 0.17.0

package/dist/templates/core/lib-ts/runtime/sentinel-ipc.ts

@@ -0,0 +1,91 @@
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import path from 'node:path'
+
+export interface SentinelIpcPaths {
+  tmpDir: string
+  inputPath: string
+  stdoutPath: string
+  stderrPath: string
+  sentinelPath: string
+}
+
+function sanitizePrefix(prefix: string): string {
+  return prefix.replaceAll(/[^a-zA-Z0-9_-]/g, '-')
+}
+
+export function createSentinelIpcPaths(prefix: string): SentinelIpcPaths {
+  const safePrefix = sanitizePrefix(prefix)
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `${safePrefix}-`))
+
+  return {
+    tmpDir,
+    inputPath: path.join(tmpDir, 'input.txt'),
+    stdoutPath: path.join(tmpDir, 'stdout.txt'),
+    stderrPath: path.join(tmpDir, 'stderr.txt'),
+    sentinelPath: path.join(tmpDir, 'sentinel.txt'),
+  }
+}
+
+export function buildShellCaptureScript(
+  command: string,
+  paths: Pick<SentinelIpcPaths, 'inputPath' | 'stdoutPath' | 'stderrPath' | 'sentinelPath'>,
+  quote: (input: string) => string,
+): string {
+  return [
+    command,
+    `< ${quote(paths.inputPath)}`,
+    `> ${quote(paths.stdoutPath)}`,
+    `2> ${quote(paths.stderrPath)}`,
+    `; echo $? > ${quote(paths.sentinelPath)}`,
+  ].join(' ')
+}
+
+export async function waitForSentinelFile(
+  sentinelPath: string,
+  timeoutMs: number,
+  pollIntervalMs = 250,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    if (fs.existsSync(sentinelPath)) return true
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, pollIntervalMs)
+    })
+  }
+
+  return fs.existsSync(sentinelPath)
+}
+
+export function readSentinelExitCode(sentinelPath: string, fallback = 1): number {
+  if (!fs.existsSync(sentinelPath)) return fallback
+
+  const raw = fs.readFileSync(sentinelPath, 'utf8').trim()
+  const parsed = Number.parseInt(raw, 10)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+export function readTextIfExists(filePath: string): string {
+  if (!filePath || !fs.existsSync(filePath)) return ''
+  return fs.readFileSync(filePath, 'utf8')
+}
+
+export function cleanupSentinelIpc(paths: Pick<SentinelIpcPaths, 'tmpDir'>): void {
+  try {
+    fs.rmSync(paths.tmpDir, { recursive: true, force: true })
+  } catch {
+    // Best-effort cleanup.
+  }
+}
+
+export function cleanupSentinelPath(sentinelPath: string | undefined): void {
+  if (!sentinelPath) return
+
+  try {
+    fs.rmSync(path.dirname(sentinelPath), { recursive: true, force: true })
+  } catch {
+    // Best-effort cleanup.
+  }
+}
+
+

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

@@ -5,11 +5,12 @@
  */
 
 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";
 import { logWarn } from "./logger.js";
+import { ContextStateSchema } from "../schemas.js";
 import type { ContextState, Mode } from "../types.js";
 
 /** Mode migration from legacy context_manager values. */
@@ -34,12 +35,13 @@ interface LegacyStateData {
 
 /**
  * Serialize a ContextState for JSON output.
- * Omits null/undefined keys but keeps false, 0, empty string, and empty arrays.
+ * Omits undefined keys but preserves null (semantically meaningful in the schema).
+ * Keeps false, 0, empty string, and empty arrays.
  */
 export function toDict(state: ContextState): Record<string, unknown> {
   const result: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(state)) {
-    if (value !== null && value !== undefined) {
+    if (value !== undefined) {
       result[key] = value;
     }
   }
@@ -118,11 +120,16 @@ 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
+    const parsed = ContextStateSchema.safeParse(data);
+    if (!parsed.success) {
+      logWarn("state_io", `Schema validation failed for '${contextId}': ${parsed.error.message}`);
+      // Fail-open: still attempt to reconstruct state from raw data
+    }
     return dictToState(data);
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("state_io", `Failed to read state.json for '${contextId}': ${error}`);
     return null;
   }
@@ -138,11 +145,10 @@ export function writeStateJson(
   projectRoot?: string,
 ): [boolean, string | null] {
   const sp = statePath(contextId, projectRoot);
-  const dir = path.dirname(sp);
-  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 +165,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 +205,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

@@ -3,6 +3,9 @@
  * See SPEC.md §14.2, §14.3
  */
 
+import * as fs from "node:fs";
+import path from "node:path";
+
 import { sanitizeTitle } from "./constants.js";
 import { logDebug, logError, logWarn } from "./logger.js";
 import { STOP_WORDS } from "./stop-words.js";
@@ -10,7 +13,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");
 }
 
@@ -110,7 +113,7 @@ export function generateSlug(
   // Tier 1: AI inference via generateContextIdSlug (sync — uses execFileSync)
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef
-    const { generateContextIdSlug } = require("./inference.js");
+    const { generateContextIdSlug } = require("./inference");
     const aiSlug = generateContextIdSlug(text);
     if (aiSlug) {
       const filteredWords = aiSlug
@@ -127,7 +130,7 @@ export function generateSlug(
         );
       }
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     logWarn("utils", `AI slug generation failed, using fallback: ${error}`);
   }
 
@@ -171,7 +174,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 +193,30 @@ export function generateContextId(
 
   return `${baseId}-${counter}`;
 }
+
+/**
+ * Get .md files in a directory sorted by mtime (newest first).
+ */
+export function getMdFilesByMtime(dir: string): string[] {
+  try {
+    if (!fs.existsSync(dir)) return [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    return entries
+      .filter(e => e.isFile() && e.name.endsWith(".md"))
+      .map(e => {
+        const fullPath = path.join(dir, e.name);
+        const stat = fs.statSync(fullPath);
+        return { path: fullPath, mtime: stat.mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+      .map(f => f.path);
+  } catch { return []; }
+}
+
+/**
+ * Get the most recently modified .md file in a directory.
+ */
+export function mostRecentMd(dir: string): string | null {
+  return getMdFilesByMtime(dir)[0] ?? null;
+}
+