aiwcli 0.15.5 → 0.17.0

package/dist/commands/launch.js

@@ -1,44 +1,64 @@
-import { execSync } from 'node:child_process';
-import { basename } from 'node:path';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as os from 'node:os';
 import { Flags } from '@oclif/core';
-import BaseCommand from '../lib/base-command.js';
-import { ProcessSpawnError } from '../lib/errors.js';
-import { spawnProcess } from '../lib/spawn.js';
-import { launchTerminal } from '../lib/terminal.js';
-import { checkVersionCompatibility, getClaudeCodeVersion } from '../lib/version.js';
-import { EXIT_CODES } from '../types/index.js';
+import { executeLaunch } from '../capabilities/launch/control-plane/execute-launch.js';
+import BaseCommand from '../cli/base-command.js';
 /**
- * Launch Claude Code or Codex with AIW configuration.
+ * Launch Claude Code, Codex, or Devin with AIW configuration.
  *
  * Spawns Claude Code CLI with --dangerously-skip-permissions flag,
- * or Codex CLI with --yolo flag, enabling unattended execution.
- * Designed for AIW hook system safety guardrails (requires aiw setup).
- * Supports multiple parallel sessions.
+ * Codex CLI with --yolo flag, or Devin CLI with --permission-mode dangerous,
+ * enabling unattended execution. Supports multiple parallel sessions.
+ *
+ * ## Multiplexer-first launch (preferred)
+ *
+ * When a terminal multiplexer is available (psmux on Windows, tmux on Unix),
+ * the launch flow is:
+ *   - **Inside an existing session** → split a new pane in the current session
+ *   - **Outside any session** → create a new multiplexer session with the REPL
+ *
+ * This gives persistent sessions, pane splitting, and scrollback.
+ * Use `--no-tmux` to bypass the multiplexer and launch inline.
+ *
+ * ## Inline fallback
+ *
+ * When no multiplexer is available (or `--no-tmux` is set), the REPL launches
+ * directly in the current terminal.
+ *
+ * ## Install multiplexer
+ *   - Windows: `winget install psmux`  (native ConPTY multiplexer)
+ *   - Unix:    `apt install tmux` / `brew install tmux`
  */
 export default class LaunchCommand extends BaseCommand {
-    static description = 'Launch Claude Code or Codex with AIW configuration (sandbox disabled, tmux-first by default)\n\n' +
+    static description = 'Launch Claude Code, Codex, or Devin with AIW configuration (sandbox disabled, tmux-first; Windows opens mintty window first with inline fallback)\n\n' +
         'FLAGS\n' +
         '  --codex/-c: Launch Codex instead of Claude Code (uses --yolo flag)\n' +
+        '  --devin/-e: Launch Devin CLI instead of Claude Code (uses --permission-mode dangerous)\n' +
         '  --new/-n: Open a new terminal in the current directory and launch there\n' +
         '  --no-tmux/-t: Launch directly in current shell instead of auto-launching tmux\n' +
-        '  --tmux-session/-s: tmux session name to reuse when auto-launching tmux (default is fresh session per launch)\n\n' +
+        '  --tmux-session/-s: tmux session name to reuse when auto-launching tmux\n' +
+        '  --prompt/-p: Initial prompt to pass to the AI REPL at startup\n' +
+        '  --wait: Block until launched pane exits (for scripted callers)\n' +
+        '  --json: JSON output (paneId, backend, exitCode, sentinel)\n' +
+        '  --split: Split direction when in tmux (auto|h|v, default: auto)\n' +
+        '  --env: Extra env vars as JSON string\n' +
+        '  --prompt-path: Path to prompt file for REPL-mode tools\n\n' +
         'EXIT CODES\n' +
         '  0  Success - AI assistant launched and exited successfully\n' +
         '  1  General error - unexpected runtime failure\n' +
         '  2  Invalid usage - check your arguments and flags\n' +
-        '  3  Environment error - CLI not found (install Claude Code from https://claude.ai/download, Codex from npm)';
+        '  3  Environment error - CLI not found (install Claude Code from https://claude.ai/download, Codex from npm, Devin from https://cli.devin.ai)';
     static examples = [
         '<%= config.bin %> <%= command.id %>  # Auto-launches tmux with a fresh session when not already in tmux',
         '<%= config.bin %> <%= command.id %> --codex  # Launch Codex with --yolo flag',
-        '<%= config.bin %> <%= command.id %> -c  # Short form for --codex',
+        '<%= config.bin %> <%= command.id %> --devin  # Launch Devin CLI with --permission-mode dangerous',
         '<%= config.bin %> <%= command.id %> --new  # Launch in a new terminal window',
-        '<%= config.bin %> <%= command.id %> -n  # Short form for --new',
-        '<%= config.bin %> <%= command.id %> --codex --new  # Launch Codex in new terminal',
         '<%= config.bin %> <%= command.id %> --no-tmux  # Run directly in current shell',
         '<%= config.bin %> <%= command.id %> --tmux-session aiw-main  # Reuse/attach explicit tmux session name',
+        '<%= config.bin %> <%= command.id %> --prompt "Fix the login bug"  # Launch with initial prompt',
+        '<%= config.bin %> <%= command.id %> --wait --json  # Block until pane exits, output JSON result',
+        '<%= config.bin %> <%= command.id %> --split h  # Force horizontal split in tmux',
         '<%= config.bin %> <%= command.id %> --debug  # Enable verbose logging',
-        '# Check exit code in Bash\n<%= config.bin %> <%= command.id %>\necho $?',
-        '# Check exit code in PowerShell\n<%= config.bin %> <%= command.id %>\necho $LASTEXITCODE',
     ];
     static flags = {
         ...BaseCommand.baseFlags,
@@ -46,6 +66,21 @@ export default class LaunchCommand extends BaseCommand {
             char: 'c',
             description: 'Launch Codex instead of Claude Code (uses --yolo flag for full auto mode)',
             default: false,
+            exclusive: ['devin'],
+        }),
+        devin: Flags.boolean({
+            char: 'e',
+            description: 'Launch Devin CLI instead of Claude Code (uses --permission-mode dangerous)',
+            default: false,
+            exclusive: ['codex'],
+        }),
+        env: Flags.string({
+            description: 'Extra env vars as JSON object string (e.g. \'{"FOO":"bar"}\')',
+            required: false,
+        }),
+        json: Flags.boolean({
+            description: 'JSON output (paneId, backend, exitCode, sentinel)',
+            default: false,
         }),
         new: Flags.boolean({
             char: 'n',
@@ -57,159 +92,65 @@ export default class LaunchCommand extends BaseCommand {
             description: 'Launch directly in current shell instead of auto-launching tmux',
             default: false,
         }),
+        prompt: Flags.string({
+            char: 'p',
+            description: 'Initial prompt to pass to the AI REPL at startup',
+            required: false,
+        }),
+        'prompt-file': Flags.string({
+            description: 'Path to file containing initial prompt (internal)',
+            required: false,
+            hidden: true,
+        }),
+        'spawned-window': Flags.boolean({
+            description: 'Internal: marks launch as re-entered in a spawned terminal window',
+            required: false,
+            hidden: true,
+            default: false,
+        }),
+        'prompt-path': Flags.string({
+            description: 'Path to prompt file for REPL-mode tools',
+            required: false,
+        }),
+        split: Flags.string({
+            description: 'Split direction when in multiplexer (auto|horizontal|vertical, default: auto)',
+            options: ['auto', 'horizontal', 'vertical'],
+            required: false,
+        }),
         'tmux-session': Flags.string({
             char: 's',
             description: 'tmux session name to reuse when auto-launching tmux (default: new aiw-<current-dir>-<unique> session)',
             required: false,
         }),
+        wait: Flags.boolean({
+            description: 'Block until launched pane exits; output result',
+            default: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(LaunchCommand);
-        // Determine which CLI to launch
-        const useCodex = flags.codex;
-        const cliCommand = useCodex ? 'codex' : 'claude';
-        const cliArgs = useCodex ? ['--yolo'] : ['--dangerously-skip-permissions'];
-        const launchFlag = useCodex ? '--codex' : '';
-        const disableTmux = flags['no-tmux'];
-        const insideTmux = Boolean(process.env.TMUX);
-        const interactiveTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-        const shouldAutoTmux = !flags.new && !disableTmux && !insideTmux && interactiveTty;
-        // Handle --new flag: launch in a new terminal
-        if (flags.new) {
-            const cwd = process.cwd();
-            this.debug(`Launching new terminal in: ${cwd}`);
-            const launchCmd = useCodex ? 'aiw launch --codex' : 'aiw launch';
-            const result = await launchTerminal({
-                cwd,
-                command: launchCmd,
-                debugLog: (msg) => this.debug(msg),
-            });
-            if (!result.success) {
-                this.error(`Failed to launch new terminal: ${result.error}`, { exit: EXIT_CODES.GENERAL_ERROR });
-            }
-            this.log(`New terminal launched with aiw launch${launchFlag ? ` ${launchFlag}` : ''}`);
-            return;
-        }
-        // Normal launch flow
-        let exitCode;
-        try {
-            // Version check only applies to Claude Code (not Codex)
-            if (useCodex) {
-                this.debug('Launching Codex with --yolo flag');
-            }
-            else {
-                // Check Claude Code version compatibility (non-blocking)
-                const version = await getClaudeCodeVersion();
-                const versionCheck = checkVersionCompatibility(version);
-                // Debug logging: show version information
-                this.debug(`Claude Code version: ${versionCheck.version ?? 'unknown'}`);
-                this.debug(`Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`);
-                // Non-blocking warning for incompatibility or unknown version
-                if (versionCheck.warning) {
-                    this.warn(versionCheck.warning);
-                }
-            }
-            // Spawn AI CLI with sandbox permissions disabled
-            // AIW hook system provides safety guardrails
-            // Continue launch regardless of version check result (graceful degradation)
-            if (shouldAutoTmux && this.isTmuxAvailable()) {
-                const shellCommand = this.buildTmuxShellCommand(cliCommand, cliArgs);
-                const sessionFromFlag = flags['tmux-session']?.trim();
-                if (sessionFromFlag && sessionFromFlag.length > 0) {
-                    const sessionName = this.sanitizeTmuxSessionName(sessionFromFlag);
-                    this.logInfo(`Launching in tmux session: ${sessionName} (reuse/attach)`);
-                    exitCode = await spawnProcess('tmux', ['new-session', '-A', '-s', sessionName, shellCommand]);
-                }
-                else {
-                    const sessionBase = `aiw-${basename(process.cwd())}`;
-                    const sessionName = this.buildUniqueTmuxSessionName(sessionBase);
-                    this.logInfo(`Launching in new tmux session: ${sessionName}`);
-                    exitCode = await spawnProcess('tmux', ['new-session', '-s', sessionName, shellCommand]);
-                }
-            }
-            else if (shouldAutoTmux && this.isWindowsTerminalAvailable()) {
-                this.logInfo('tmux unavailable; launching in Windows Terminal split pane');
-                exitCode = await spawnProcess('wt', ['split-pane', '--', cliCommand, ...cliArgs]);
-            }
-            else {
-                if (shouldAutoTmux) {
-                    this.logInfo('No pane launcher available. Launching directly.');
-                }
-                else if (disableTmux) {
-                    this.debug('tmux launch disabled via --no-tmux');
-                }
-                else if (insideTmux) {
-                    this.debug('Already inside tmux; launching directly in current pane');
-                    this.enableTmuxMouseIfPossible();
-                }
-                else if (!interactiveTty) {
-                    this.debug('Non-interactive terminal detected; launching directly');
-                }
-                exitCode = await spawnProcess(cliCommand, cliArgs);
-            }
-        }
-        catch (error) {
-            if (error instanceof ProcessSpawnError) {
-                // Actionable error message (already includes installation link)
-                this.error(error.message, { exit: EXIT_CODES.ENVIRONMENT_ERROR });
-            }
-            // Unexpected error
-            this.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
-        }
-        // Pass through Claude Code's exit code (outside try-catch to avoid catching exit)
-        this.exit(exitCode);
-    }
-    buildTmuxShellCommand(command, args) {
-        const launchCommand = [command, ...args].map((part) => this.shellQuote(part)).join(' ');
-        return `tmux set-option -g mouse on >/dev/null 2>&1 || true; exec ${launchCommand}`;
-    }
-    isTmuxAvailable() {
-        try {
-            const cmd = process.platform === 'win32' ? 'where tmux' : 'which tmux';
-            execSync(cmd, { stdio: 'ignore' });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    isWindowsTerminalAvailable() {
-        if (process.platform !== 'win32')
-            return false;
-        try {
-            execSync('where wt', { stdio: 'ignore' });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    sanitizeTmuxSessionName(input) {
-        const trimmed = input.trim().toLowerCase();
-        const safe = trimmed
-            .replaceAll(/[^a-z0-9_-]/g, '-')
-            .replaceAll(/-+/g, '-')
-            .replaceAll(/^[-_]+|[-_]+$/g, '');
-        return safe || 'aiw';
-    }
-    buildUniqueTmuxSessionName(base) {
-        const safeBase = this.sanitizeTmuxSessionName(base);
-        const timestamp = Date.now().toString(36);
-        const pid = process.pid.toString(36);
-        return this.sanitizeTmuxSessionName(`${safeBase}-${timestamp}-${pid}`);
-    }
-    enableTmuxMouseIfPossible() {
-        if (!this.isTmuxAvailable())
-            return;
-        try {
-            execSync('tmux set-option -g mouse on', { stdio: 'ignore' });
-            this.debug('Enabled tmux mouse support (set-option -g mouse on)');
-        }
-        catch {
-            this.debug('Could not enable tmux mouse support automatically');
-        }
-    }
-    shellQuote(input) {
-        return `'${input.replaceAll("'", `'"'"'`)}'`;
+        await executeLaunch({
+            cwd: process.cwd(),
+            flags: flags,
+            interactiveTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+            platform: process.platform,
+            readPromptFile: (filePath) => (existsSync(filePath) ? readFileSync(filePath, 'utf8') : undefined),
+        }, {
+            host: {
+                debug: (message, ...args) => this.debug([message, ...args.map(String)].join(' ')),
+                error: (input, options) => this.error(input, options),
+                exit: (code) => this.exit(code),
+                log: (message) => this.log(message),
+                logInfo: (message) => this.logInfo(message),
+                logWarning: (message) => this.logWarning(message),
+                warn: (input) => this.warn(input),
+            },
+            now: () => Date.now(),
+            pid: process.pid,
+            tempDir: os.tmpdir(),
+            writePromptFile(filePath, content) {
+                writeFileSync(filePath, content, { encoding: 'utf8', mode: 0o600 });
+            },
+        });
     }
 }

package/dist/lib/claude-settings-types.d.ts

@@ -8,6 +8,8 @@
 export interface HookCommand {
     /** If true, runs in background without blocking */
     async?: boolean;
+    /** If false, hook failure will not block tool execution */
+    blockOnFail?: boolean;
     /** Command to execute */
     command: string;
     /** Optional timeout in seconds */
@@ -15,14 +17,31 @@ export interface HookCommand {
     /** Type of hook action */
     type: 'command';
 }
+/**
+ * Hook prompt configuration
+ */
+export interface HookPrompt {
+    /** If true, runs in background without blocking */
+    async?: boolean;
+    /** Prompt text shown to the model */
+    prompt: string;
+    /** Optional timeout in seconds */
+    timeout?: number;
+    /** Type of hook action */
+    type: 'prompt';
+}
+/**
+ * Hook action configuration
+ */
+export type HookAction = HookCommand | HookPrompt;
 /**
  * Hook matcher configuration
  */
 export interface HookMatcher {
     /** Array of hook commands to execute */
-    hooks: HookCommand[];
+    hooks: HookAction[];
     /** Tool name pattern to match (regex supported) */
-    matcher: string;
+    matcher?: string;
     /** Execute only once per session */
     once?: boolean;
 }
@@ -52,20 +71,6 @@ export type EnabledPlugins = Record<string, boolean>;
  * Environment variables configuration
  */
 export type EnvConfig = Record<string, string>;
-/**
- * Method installation tracking metadata
- */
-interface MethodTracking {
-    /** IDEs configured for this method */
-    ides?: string[];
-    /** ISO timestamp when method was installed */
-    installedAt: string;
-}
-/**
- * Methods tracking object
- * Maps method names to their installation metadata
- */
-export type MethodsConfig = Record<string, MethodTracking>;
 /**
  * Complete Claude Code settings.json structure
  */
@@ -76,16 +81,24 @@ export interface ClaudeSettings {
     enabledPlugins?: EnabledPlugins;
     /** Environment variables */
     env?: EnvConfig;
+    /** File suggestion command configuration */
+    fileSuggestion?: {
+        command: string;
+        type: 'command';
+    };
     /** Hook configurations */
     hooks?: HooksConfig;
-    /** Installed methods tracking */
-    methods?: MethodsConfig;
     /** Default model to use */
     model?: string;
     /** Tool permissions */
     permissions?: Permissions;
     /** Spinner tips enabled */
     spinnerTipsEnabled?: boolean;
+    /** Status line command configuration */
+    statusLine?: {
+        command: string;
+        type: 'command';
+    };
 }
 /**
  * Settings file types in hierarchy
@@ -102,4 +115,3 @@ export interface SettingsLocation {
     /** Type of settings file */
     type: SettingsFileType;
 }
-export {};

package/dist/lib/config.js

@@ -2,7 +2,6 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from './debug.js';
-import { getAiwDir as getAiwDirFromEnv } from './env-compat.js';
 import { ConfigNotFoundError } from './errors.js';
 /**
  * Resolve AI Workflow CLI home directory.
@@ -10,7 +9,7 @@ import { ConfigNotFoundError } from './errors.js';
  */
 export function getAiwDir() {
     // Try env var first, then default
-    const envHome = getAiwDirFromEnv();
+    const envHome = process.env['AIW_DIR'];
     if (envHome) {
         return envHome;
     }

package/dist/lib/context/context-formatter.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Formatting module for context display output.
+ * See SPEC.md §11
+ *
+ * All functions accept a ContextState with fields:
+ *   id, summary, mode, last_active, plan_path, handoff_path,
+ *   tasks[], last_session, session_ids, status, method, tags
+ */
+import type { ContextState } from "../types.js";
+/**
+ * Get bracketed display string for mode, or empty for idle.
+ * See SPEC.md §11.2
+ */
+export declare function getModeDisplay(mode: string): string;
+/**
+ * Format ISO timestamp as '2 hours ago', 'yesterday', etc.
+ * See SPEC.md §11.3
+ */
+export declare function formatRelativeTime(isoTimestamp: string | null): string;
+/**
+ * Build restore sections from last_session, tasks, and plan_path.
+ * See SPEC.md §11.4
+ */
+export declare function buildRestoreSections(ctx: ContextState, projectRoot?: string, inlinePlan?: boolean): string;
+/**
+ * Format output when resuming a context with a pending handoff.
+ * See SPEC.md §11.5
+ */
+export declare function formatHandoffContinuation(ctx: ContextState, projectRoot?: string): string;
+/**
+ * Build lightweight orientation for external agents (Codex, etc.).
+ * Tells the agent where the context folder and key paths are — no session state.
+ */
+export declare function buildExternalAgentContext(ctx: ContextState, projectRoot: string): string;
+/**
+ * Format output for pending plan implementation (mode=has_plan).
+ * See SPEC.md §11.6
+ */
+export declare function formatPlanContinuation(ctx: ContextState, projectRoot?: string): string;
+/**
+ * Format output for ongoing implementation (mode=active).
+ * See SPEC.md §11.7
+ */
+export declare function formatActiveContinuation(ctx: ContextState, projectRoot?: string): string;
+/**
+ * Format list of contexts for display.
+ * See SPEC.md §11.8
+ */
+export declare function formatContextList(contexts: ContextState[]): string;
+/**
+ * Format notification for a newly created context.
+ * See SPEC.md §11.9
+ */
+export declare function formatContextCreated(ctx: ContextState): string;
+/**
+ * Format system reminder: lightweight (per-prompt) or rich (first-bind restore).
+ * See SPEC.md §11.10
+ */
+export declare function formatActiveContextReminder(ctx: ContextState, projectRoot?: string, includeRestore?: boolean): string;
+/**
+ * Format the boxed picker shown on stderr when blocking for selection.
+ * See SPEC.md §11.11
+ */
+export declare function formatContextPickerStderr(contexts: ContextState[]): string;
+/**
+ * Format feedback about caret command operations performed.
+ * See SPEC.md §11.12
+ */
+export declare function formatCommandFeedback(endedContexts: ContextState[], selectedContext: ContextState | null): string;
+/**
+ * Build a markdown inventory of resources available in the context folder.
+ * Returns null if the context folder doesn't exist yet (brand new context).
+ */
+export declare function buildContextInventory(state: ContextState, projectRoot: string): string | null;