aiwcli 0.15.4 → 0.15.7

package/dist/lib/runtime/stop-words.js

@@ -0,0 +1,150 @@
+/**
+ * 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 = 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) {
+    return text
+        .split(/\s+/)
+        .filter((word) => word.length > 1 && !STOP_WORDS.has(word.toLowerCase()))
+        .join(" ");
+}

package/dist/lib/runtime/subprocess-utils.d.ts

@@ -0,0 +1,29 @@
+export declare function isInternalCall(): boolean;
+export declare function getInternalSubprocessEnv(): Record<string, string | undefined>;
+export declare function findExecutable(name: string): string | null;
+export interface ExecSyncError {
+    killed: boolean;
+    signal: string | null;
+    stdout: Buffer | string;
+    stderr: Buffer | string;
+    status: number | null;
+    message: string;
+}
+export declare function isExecSyncError(error: unknown): error is ExecSyncError;
+export declare function normalizePathForCli(pathValue: string): string;
+export declare function shellQuoteWin(arg: string): string;
+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 declare function execFileAsync(file: string, args: string[], options?: ExecAsyncOptions): Promise<ExecResult>;

package/dist/lib/runtime/subprocess-utils.js

@@ -0,0 +1,96 @@
+import { execFile } from 'node:child_process';
+import { resolveExecutable } from './executable-policy.js';
+const childProcesses = new Set();
+function cleanupChildren() {
+    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() {
+    return process.env.AIWCLI_INTERNAL_CALL === 'true';
+}
+export function getInternalSubprocessEnv() {
+    const env = {
+        ...process.env,
+        AIWCLI_INTERNAL_CALL: 'true',
+    };
+    delete env.CLAUDECODE;
+    delete env.CLAUDE_CODE_ENTRYPOINT;
+    return env;
+}
+export function findExecutable(name) {
+    return resolveExecutable(name, { windowsProfile: 'cmdOrExeFirst' });
+}
+export function isExecSyncError(error) {
+    return typeof error === 'object' && error !== null && 'killed' in error && 'signal' in error;
+}
+export function normalizePathForCli(pathValue) {
+    if (process.platform !== 'win32')
+        return pathValue;
+    return pathValue.replaceAll('\\', '/');
+}
+export function shellQuoteWin(arg) {
+    if (process.platform !== 'win32')
+        return arg;
+    return '"' + arg.replaceAll('"', '""') + '"';
+}
+export function execFileAsync(file, args, options) {
+    return new Promise((resolve) => {
+        const child = execFile(file, args, {
+            encoding: 'utf8',
+            timeout: options?.timeout ?? 0,
+            env: options?.env,
+            maxBuffer: options?.maxBuffer ?? 10 * 1024 * 1024,
+            shell: options?.shell,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const errObj = error;
+                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/lib/runtime/tmux-preflight.d.ts

@@ -0,0 +1,13 @@
+export declare function selectMsysBashFromLookupPaths(paths: string[]): null | string;
+export declare function deriveMsysBashFromGitPath(gitPath: string): null | string;
+export declare function findMsysBash(): null | string;
+export declare function isTmuxReachableViaBash(bashPath: string): boolean;
+export declare function isNativeTmuxAvailable(platform?: NodeJS.Platform): boolean;
+/** Find psmux (native Windows terminal multiplexer) on PATH. */
+export declare function findPsmux(): null | string;
+export interface WindowsTmuxPreflight {
+    available: boolean;
+    bashPath?: string;
+    reason?: string;
+}
+export declare function preflightWindowsTmux(): WindowsTmuxPreflight;

package/dist/lib/runtime/tmux-preflight.js

@@ -0,0 +1,78 @@
+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) {
+    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) {
+    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() {
+    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) {
+    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 = process.platform) {
+    return isCommandAvailable('tmux', platform);
+}
+/** Find psmux (native Windows terminal multiplexer) on PATH. */
+export function findPsmux() {
+    if (!isWindowsPlatform())
+        return null;
+    const candidates = lookupExecutables('psmux', { platform: 'win32' });
+    return candidates[0]?.trim() || null;
+}
+export function preflightWindowsTmux() {
+    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/lib/runtime/utils.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Core utilities for shared context management.
+ * See SPEC.md §14.2, §14.3
+ */
+/**
+ * Print to stderr. For terminal-only UX messages, not diagnostics.
+ */
+export declare function eprint(...args: unknown[]): void;
+/**
+ * Get current local datetime as Date.
+ */
+export declare function nowLocal(): Date;
+/**
+ * Get current time as ISO 8601 string (local time, no timezone suffix).
+ * Matches Python datetime.now().isoformat() behavior.
+ */
+export declare function nowIso(): string;
+/**
+ * Format datetime for display.
+ * Returns "YYYY-MM-DD HH:MM:SS"
+ * See SPEC.md §14.3
+ */
+export declare function formatTimestamp(dt?: Date): string;
+/**
+ * Parse ISO 8601 timestamp string.
+ * Returns null if parsing fails.
+ * See SPEC.md §14.3
+ */
+export declare function parseIsoTimestamp(isoStr: string): Date | null;
+/**
+ * Normalize a filesystem path for display — always uses forward slashes.
+ * No-op on Unix; converts backslashes on Windows.
+ */
+export declare function displayPath(p: string): string;
+/**
+ * Clean text for stop-word matching in slug generation.
+ * Strips apostrophes (i'm -> im), removes punctuation, normalizes whitespace.
+ * See SPEC.md §14.2
+ */
+export declare function cleanTextForSlug(text: string): string;
+/**
+ * Generate a slug from text using AI inference with stop-word fallbacks.
+ * Pipeline: AI inference → stop-word post-filter → stop-word fallback → word-length fallback.
+ * Reusable by both context ID generation and plan archival.
+ * See SPEC.md §14.2
+ */
+export declare function generateSlug(text: string, maxLen?: number, fallbackSlug?: string): string;
+/**
+ * Generate a context ID from a summary string.
+ * Format: YYMMDD-HHMM-slug
+ * Delegates slug generation to generateSlug().
+ * See SPEC.md §14.2
+ */
+export declare function generateContextId(summary: string, existingIds?: Set<string>): string;

package/dist/lib/runtime/utils.js

@@ -0,0 +1,162 @@
+/**
+ * Core utilities for shared context management.
+ * See SPEC.md §14.2, §14.3
+ */
+import { sanitizeTitle } from "./constants.js";
+import { logDebug, logError, logWarn } from "./logger.js";
+import { STOP_WORDS } from "./stop-words.js";
+/**
+ * Print to stderr. For terminal-only UX messages, not diagnostics.
+ */
+export function eprint(...args) {
+    process.stderr.write(args.map(String).join(" ") + "\n");
+}
+/**
+ * Get current local datetime as Date.
+ */
+export function nowLocal() {
+    return new Date();
+}
+/**
+ * Get current time as ISO 8601 string (local time, no timezone suffix).
+ * Matches Python datetime.now().isoformat() behavior.
+ */
+export function nowIso() {
+    const d = new Date();
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    const hours = String(d.getHours()).padStart(2, "0");
+    const minutes = String(d.getMinutes()).padStart(2, "0");
+    const seconds = String(d.getSeconds()).padStart(2, "0");
+    const ms = String(d.getMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${ms}`;
+}
+/**
+ * Format datetime for display.
+ * Returns "YYYY-MM-DD HH:MM:SS"
+ * See SPEC.md §14.3
+ */
+export function formatTimestamp(dt) {
+    const d = dt ?? nowLocal();
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    const hours = String(d.getHours()).padStart(2, "0");
+    const minutes = String(d.getMinutes()).padStart(2, "0");
+    const seconds = String(d.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+/**
+ * Parse ISO 8601 timestamp string.
+ * Returns null if parsing fails.
+ * See SPEC.md §14.3
+ */
+export function parseIsoTimestamp(isoStr) {
+    try {
+        const normalized = isoStr.replace("Z", "+00:00");
+        const d = new Date(normalized);
+        if (isNaN(d.getTime()))
+            return null;
+        return d;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Normalize a filesystem path for display — always uses forward slashes.
+ * No-op on Unix; converts backslashes on Windows.
+ */
+export function displayPath(p) {
+    return p.replaceAll("\\", "/");
+}
+/**
+ * Clean text for stop-word matching in slug generation.
+ * Strips apostrophes (i'm -> im), removes punctuation, normalizes whitespace.
+ * See SPEC.md §14.2
+ */
+export function cleanTextForSlug(text) {
+    if (!text)
+        return "";
+    let result = text.toLowerCase();
+    result = result.replaceAll('\'', ""); // i'm -> im, you're -> youre
+    result = result.replaceAll(/[^a-z0-9\s]/g, " "); // punctuation -> spaces
+    result = result.replaceAll(/\s+/g, " ").trim();
+    return result;
+}
+/**
+ * Generate a slug from text using AI inference with stop-word fallbacks.
+ * Pipeline: AI inference → stop-word post-filter → stop-word fallback → word-length fallback.
+ * Reusable by both context ID generation and plan archival.
+ * See SPEC.md §14.2
+ */
+export function generateSlug(text, maxLen = 150, fallbackSlug = "context") {
+    if (!text || !text.trim())
+        return fallbackSlug;
+    let slug = null;
+    const cleanedText = cleanTextForSlug(text);
+    // 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 aiSlug = generateContextIdSlug(text);
+        if (aiSlug) {
+            const filteredWords = aiSlug
+                .split(/\s+/)
+                .filter((w) => !STOP_WORDS.has(w.toLowerCase()) && w.length > 1);
+            if (filteredWords.length >= 5) {
+                slug = sanitizeTitle(filteredWords.join(" "), maxLen);
+            }
+            else {
+                logDebug("utils", `AI slug too generic after stop-word filter (${filteredWords.length} words remain), using fallback`);
+            }
+        }
+    }
+    catch (error) {
+        logWarn("utils", `AI slug generation failed, using fallback: ${error}`);
+    }
+    // Tier 2: Stop-word filtering on cleaned text
+    if (!slug) {
+        const words = cleanedText
+            .split(/\s+/)
+            .filter((w) => !STOP_WORDS.has(w) && w.length > 1)
+            .slice(0, 12);
+        slug = words.length >= 3
+            ? sanitizeTitle(words.join(" "), maxLen)
+            : sanitizeTitle(cleanedText.split(/\s+/).filter((w) => w.length > 2).slice(0, 6).join(" "), maxLen) || fallbackSlug;
+    }
+    return slug;
+}
+/**
+ * Generate a context ID from a summary string.
+ * Format: YYMMDD-HHMM-slug
+ * Delegates slug generation to generateSlug().
+ * See SPEC.md §14.2
+ */
+export function generateContextId(summary, existingIds) {
+    const now = new Date();
+    const yy = String(now.getFullYear()).slice(2);
+    const mm = String(now.getMonth() + 1).padStart(2, "0");
+    const dd = String(now.getDate()).padStart(2, "0");
+    const hh = String(now.getHours()).padStart(2, "0");
+    const min = String(now.getMinutes()).padStart(2, "0");
+    const timestamp = `${yy}${mm}${dd}-${hh}${min}`;
+    let baseId;
+    try {
+        const slug = generateSlug(summary);
+        baseId = `${timestamp}-${slug}`;
+    }
+    catch (error) {
+        logError("utils", `Context ID generation failed entirely, using timestamp: ${error}`);
+        baseId = `${timestamp}-context`;
+    }
+    if (!existingIds || !existingIds.has(baseId)) {
+        return baseId;
+    }
+    let counter = 2;
+    while (existingIds.has(`${baseId}-${counter}`)) {
+        counter++;
+    }
+    return `${baseId}-${counter}`;
+}

package/dist/lib/sentinel-wrapper.d.ts

@@ -0,0 +1,9 @@
+export interface SentinelWrapParams {
+    autoClose: boolean;
+    command: string;
+    holdMessage: string;
+    holdPane: boolean;
+    sentinelPath: string;
+}
+export declare function wrapSentinelSh(params: SentinelWrapParams): string;
+export declare function wrapSentinelPowerShell(params: SentinelWrapParams): string;

package/dist/lib/sentinel-wrapper.js

@@ -0,0 +1,20 @@
+import { quoteForPowerShell, quoteForSh } from './shell-quoting.js';
+export function wrapSentinelSh(params) {
+    const { command, sentinelPath, autoClose, holdPane, holdMessage } = params;
+    const base = `${command}; code=$?; printf '%s' "$code" > ${quoteForSh(sentinelPath)}`;
+    if (autoClose) {
+        return `${base}; tmux kill-pane -t "$TMUX_PANE" >/dev/null 2>&1 || true; exit $code`;
+    }
+    if (holdPane) {
+        return `${base}; echo; echo ${quoteForSh(holdMessage)}; exec bash`;
+    }
+    return `${base}; exit $code`;
+}
+export function wrapSentinelPowerShell(params) {
+    const { command, sentinelPath, autoClose, holdPane, holdMessage } = params;
+    const base = `${command}; $code = $LASTEXITCODE; Set-Content -Path ${quoteForPowerShell(sentinelPath)} -Value $code -NoNewline`;
+    if (holdPane && !autoClose) {
+        return `${base}; Write-Host ''; Write-Host ${quoteForPowerShell(holdMessage)}; Read-Host -Prompt 'Press Enter to close' | Out-Null`;
+    }
+    return `${base}; exit $code`;
+}

package/dist/lib/shell-quoting.d.ts

@@ -0,0 +1,5 @@
+export declare function quoteForSh(input: string): string;
+export declare function quoteForPowerShell(input: string): string;
+/** Wrap a PowerShell command using -EncodedCommand to avoid all quoting issues. */
+export declare function toEncodedPowerShell(command: string): string;
+export declare function escapeSingleQuotedPath(path: string, dialect: 'bash' | 'powershell'): string;

package/dist/lib/shell-quoting.js

@@ -0,0 +1,17 @@
+export function quoteForSh(input) {
+    return `'${input.replaceAll("'", "'\"'\"'")}'`;
+}
+export function quoteForPowerShell(input) {
+    return `'${input.replaceAll("'", "''")}'`;
+}
+/** Wrap a PowerShell command using -EncodedCommand to avoid all quoting issues. */
+export function toEncodedPowerShell(command) {
+    const encoded = Buffer.from(command, 'utf16le').toString('base64');
+    return `powershell.exe -NoProfile -EncodedCommand ${encoded}`;
+}
+export function escapeSingleQuotedPath(path, dialect) {
+    if (dialect === 'powershell') {
+        return path.replaceAll("'", "''");
+    }
+    return path.replaceAll("'", String.raw `'\''`);
+}

package/dist/lib/spawn-errors.d.ts

@@ -0,0 +1,6 @@
+import { ProcessSpawnError } from './errors.js';
+export declare function classifySpawnError(command: string, error: NodeJS.ErrnoException): ProcessSpawnError;
+export declare function resolveWindowsSpawnArgs(command: string, args: string[], cmdExists: (commandName: string) => boolean): null | {
+    args: string[];
+    command: string;
+};

package/dist/lib/spawn-errors.js

@@ -0,0 +1,15 @@
+import { ProcessSpawnError } from './errors.js';
+export function classifySpawnError(command, error) {
+    if (error.code === 'ENOENT') {
+        return new ProcessSpawnError(`Command not found: ${command}. Install Claude Code from https://claude.ai/download.`, 'ENOENT');
+    }
+    if (error.code === 'EACCES') {
+        return new ProcessSpawnError(`Permission denied: ${command}. Check file permissions.`, 'EACCES');
+    }
+    return new ProcessSpawnError(`Failed to spawn ${command}: ${error.message}. Check that the command exists and is executable.`, error.code);
+}
+export function resolveWindowsSpawnArgs(command, args, cmdExists) {
+    if (!cmdExists(`${command}.cmd`))
+        return null;
+    return { command: 'cmd.exe', args: ['/c', command, ...args] };
+}