aiwcli 0.15.5 → 0.15.7

package/dist/lib/spawn.js

@@ -41,6 +41,7 @@
 import { execSync, spawn as nodeSpawn } from 'node:child_process';
 import { debug, debugSpawn } from './debug.js';
 import { ProcessSpawnError } from './errors.js';
+import { classifySpawnError, resolveWindowsSpawnArgs } from './spawn-errors.js';
 /**
  * Spawn an external process and return its exit code.
  *
@@ -94,9 +95,10 @@ export async function spawnProcess(command, args = [], options = {}) {
         catch (error) {
             // If command not found and .cmd file exists, use cmd.exe wrapper
             // This avoids DEP0190 deprecation warning while supporting npm-installed commands
-            if (error instanceof ProcessSpawnError && error.code === 'ENOENT' && commandExistsInPath(`${command}.cmd`)) {
+            const windowsSpawnArgs = resolveWindowsSpawnArgs(command, args, commandExistsInPath);
+            if (error instanceof ProcessSpawnError && error.code === 'ENOENT' && windowsSpawnArgs) {
                 // Use cmd.exe /c to execute .cmd file without shell mode or deprecation warning
-                return attemptSpawn('cmd.exe', ['/c', command, ...args], { cwd, stdio, detached, shell: false });
+                return attemptSpawn(windowsSpawnArgs.command, windowsSpawnArgs.args, { cwd, stdio, detached, shell: false });
             }
             throw error;
         }
@@ -126,15 +128,7 @@ function attemptSpawn(command, args, spawnOptions) {
             const childProcess = nodeSpawn(command, args, spawnOptions);
             // Handle spawn errors (ENOENT, EACCES, etc.)
             childProcess.on('error', (error) => {
-                if (error.code === 'ENOENT') {
-                    reject(new ProcessSpawnError(`Command not found: ${command}. Install Claude Code from https://claude.ai/download.`, 'ENOENT'));
-                }
-                else if (error.code === 'EACCES') {
-                    reject(new ProcessSpawnError(`Permission denied: ${command}. Check file permissions.`, 'EACCES'));
-                }
-                else {
-                    reject(new ProcessSpawnError(`Failed to spawn ${command}: ${error.message}. Check that the command exists and is executable.`, error.code));
-                }
+                reject(classifySpawnError(command, error));
             });
             // Capture exit code on process close
             childProcess.on('close', (code, signal) => {

package/dist/lib/template-installer.d.ts

@@ -34,10 +34,10 @@ interface TemplateInstallationStatus {
     existing: TemplateItemStatus[];
     /** Items that are missing from target directory */
     missing: TemplateItemStatus[];
-    /** The method-specific workflow folder name (e.g., '_gsd', '_bmad') */
-    workflowFolder: null | string;
-    /** Whether the workflow folder exists */
-    workflowFolderExists: boolean;
+    /** The method-specific runtime folder name (e.g., '_gsd', '_bmad') */
+    runtimeFolder: null | string;
+    /** Whether the runtime folder exists */
+    runtimeFolderExists: boolean;
 }
 /**
  * Result of template installation
@@ -79,7 +79,6 @@ export declare function copyDir(src: string, dest: string, excludeIdeFolders?: b
  *
  * Template structure:
  * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
- * - _shared/ → .aiwcli/_shared/ (always overwritten)
  * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
  *
  * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().

package/dist/lib/template-installer.js

@@ -1,5 +1,5 @@
 import { promises as fs } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
 import { pathExists } from './paths.js';
 /**
@@ -17,11 +17,11 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
     const missing = [];
     // Scan template directory
     const entries = await fs.readdir(templatePath, { withFileTypes: true });
-    // Identify workflow folder based on template name
+    // Identify method runtime folder based on template name
     // Convention: _templatename (e.g., _gsd, _bmad)
-    const workflowFolderName = `_${templateName}`;
-    let workflowFolder = null;
-    let workflowFolderExists = false;
+    const runtimeFolderName = `_${templateName}`;
+    let runtimeFolder = null;
+    let runtimeFolderExists = false;
     // Filter entries to only include relevant items (skip non-selected IDE folders and excluded patterns)
     const relevantEntries = entries.filter((entry) => {
         // Skip excluded patterns (test files, cache, etc.)
@@ -58,17 +58,17 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
         else {
             missing.push(status);
         }
-        // Track workflow folder
-        if (status.name === workflowFolderName) {
-            workflowFolder = workflowFolderName;
-            workflowFolderExists = status.exists;
+        // Track method runtime folder
+        if (status.name === runtimeFolderName) {
+            runtimeFolder = runtimeFolderName;
+            runtimeFolderExists = status.exists;
         }
     }
     return {
         existing,
         missing,
-        workflowFolder,
-        workflowFolderExists,
+        runtimeFolder,
+        runtimeFolderExists,
     };
 }
 /**
@@ -101,7 +101,7 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
         if (shouldExclude(entry.name)) {
             return false;
         }
-        // Exclude IDE config folders if requested (used for _shared folder)
+        // Exclude IDE config folders if requested (used for core folder)
         // These folders are used for settings merging, not direct installation
         if (excludeIdeFolders && entry.isDirectory() && entry.name.startsWith('.')) {
             return false;
@@ -150,7 +150,6 @@ async function mergeDirectory(src, dest) {
  *
  * Template structure:
  * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
- * - _shared/ → .aiwcli/_shared/ (always overwritten)
  * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
  *
  * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().
@@ -205,27 +204,6 @@ export async function installTemplate(config) {
     });
     const nonDotResults = await Promise.all(nonDotInstalls);
     installedFolders.push(...nonDotResults);
-    // Install root-level _shared directory (shared across all templates)
-    // Exclude IDE config folders (.claude, .windsurf) - they are used for settings merging only
-    const templatesRoot = dirname(templatePath);
-    const rootSharedSrc = join(templatesRoot, '_shared');
-    const rootSharedDest = join(containerDir, '_shared');
-    if (await pathExists(rootSharedSrc)) {
-        await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
-        installedFolders.push('_shared');
-        // Copy shared IDE content (e.g., _shared/.claude/commands/handoff.md)
-        // These are non-method-owned files that live in IDE folders
-        const sharedIdeInstalls = ides.map(async (ide) => {
-            const sharedIdeFolder = join(rootSharedSrc, `.${ide}`);
-            if (await pathExists(sharedIdeFolder)) {
-                const destIdeFolder = resolver.getIdeDir(ide);
-                await fs.mkdir(destIdeFolder, { recursive: true });
-                // Merge shared IDE content, skipping files that already exist
-                await mergeDirectory(sharedIdeFolder, destIdeFolder);
-            }
-        });
-        await Promise.all(sharedIdeInstalls);
-    }
     // Install method-owned IDE content (decomposed approach)
     // Instead of copying entire .claude/ from template, only copy method-namespaced subdirectories
     const ideInstalls = ides.map(async (ide) => {
@@ -260,9 +238,33 @@ export async function installTemplate(config) {
     const ideResults = (await Promise.all(ideInstalls)).filter((result) => result !== null);
     installedFolders.push(...ideResults);
     // Settings reconstruction is handled by the caller via reconstructIdeSettings()
+    // Write resolved CLI binary path so template scripts can shell out to `aiw`
+    await writeAiwBinPath(containerDir);
     return {
         installedFolders,
         sharedSettingsMerged: false,
         templatePath,
     };
 }
+/**
+ * Write the resolved `aiw` binary path to `.aiwcli/.aiw-bin-path`.
+ * Template scripts read this file to find the CLI binary for `aiw launch`.
+ */
+async function writeAiwBinPath(containerDir) {
+    try {
+        // process.argv[1] is the main script entry point (e.g., /path/to/aiw/bin/run.js)
+        // Resolve to the bin directory to find the actual `aiw` executable
+        const { execSync } = await import('node:child_process');
+        const cmd = process.platform === 'win32' ? 'where aiw' : 'which aiw';
+        const resolved = execSync(cmd, { encoding: 'utf8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] })
+            .trim()
+            .split(/\r?\n/)[0]
+            ?.trim();
+        if (resolved) {
+            await fs.writeFile(join(containerDir, '.aiw-bin-path'), resolved, 'utf8');
+        }
+    }
+    catch {
+        // Best-effort — aiw will still be found on PATH at runtime
+    }
+}

package/dist/lib/template-resolver.d.ts

@@ -12,15 +12,14 @@
  */
 export declare function getTemplatePath(templateName: string): Promise<string>;
 /**
- * Get list of available template names by scanning the templates directory.
+ * Get list of available method template names by scanning the templates directory.
  *
- * @returns Array of template names (e.g., ['bmad', 'gsr'])
+ * @returns Array of method template names (e.g., ['bmad', 'cc-native'])
  * @throws Error if templates directory cannot be read (indicates corrupted installation)
  */
+export declare function getAvailableTemplates(): Promise<string[]>;
 /**
- * Get the absolute path to the _shared template directory.
- *
- * @returns Absolute path to the _shared template
+ * Discover IDE names available in a template path by scanning top-level dot-folders.
+ * Example: .claude, .codex -> ['claude', 'codex']
  */
-export declare function getSharedTemplatePath(): string;
-export declare function getAvailableTemplates(): Promise<string[]>;
+export declare function getTemplateIdeNamesByPath(templatePath: string): Promise<string[]>;

package/dist/lib/template-resolver.js

@@ -1,6 +1,12 @@
 import { promises as fs } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+function getTemplatesRootDir() {
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const currentDir = dirname(currentFilePath);
+    return join(currentDir, '..', 'templates');
+}
 /**
  * Resolve the absolute path to a bundled template root.
  * Works in both development (src/) and production (dist/) contexts.
@@ -21,13 +27,10 @@ export async function getTemplatePath(templateName) {
     // Get the directory of this file
     // In dev: .../aiwcli/src/lib/
     // In prod: .../aiwcli/dist/lib/
-    const currentFileUrl = import.meta.url;
-    const currentFilePath = fileURLToPath(currentFileUrl);
-    const currentDir = dirname(currentFilePath);
     // Go up one level and into templates/<templateName>
     // src/lib/ → src/templates/<templateName>/
     // dist/lib/ → dist/templates/<templateName>/
-    const templatePath = join(currentDir, '..', 'templates', templateName);
+    const templatePath = join(getTemplatesRootDir(), templateName);
     // Validate template exists
     try {
         await fs.access(templatePath);
@@ -38,29 +41,18 @@ export async function getTemplatePath(templateName) {
     return templatePath;
 }
 /**
- * Get list of available template names by scanning the templates directory.
+ * Get list of available method template names by scanning the templates directory.
  *
- * @returns Array of template names (e.g., ['bmad', 'gsr'])
+ * @returns Array of method template names (e.g., ['bmad', 'cc-native'])
  * @throws Error if templates directory cannot be read (indicates corrupted installation)
  */
-/**
- * Get the absolute path to the _shared template directory.
- *
- * @returns Absolute path to the _shared template
- */
-export function getSharedTemplatePath() {
-    const currentFilePath = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentFilePath);
-    return join(currentDir, '..', 'templates', '_shared');
-}
 export async function getAvailableTemplates() {
-    const currentFileUrl = import.meta.url;
-    const currentFilePath = fileURLToPath(currentFileUrl);
-    const currentDir = dirname(currentFilePath);
-    const templatesDir = join(currentDir, '..', 'templates');
+    const templatesDir = getTemplatesRootDir();
     try {
         const entries = await fs.readdir(templatesDir, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        return entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('_') && !RESERVED_TEMPLATE_NAMES.has(entry.name))
+            .map((entry) => entry.name);
     }
     catch (error) {
         const err = error;
@@ -68,3 +60,16 @@ export async function getAvailableTemplates() {
             `This indicates a corrupted installation. Please reinstall aiwcli.`);
     }
 }
+/**
+ * Discover IDE names available in a template path by scanning top-level dot-folders.
+ * Example: .claude, .codex -> ['claude', 'codex']
+ */
+export async function getTemplateIdeNamesByPath(templatePath) {
+    const entries = await fs.readdir(templatePath, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith('.'))
+        .map((entry) => entry.name.slice(1))
+        .filter((name) => name.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+}
+const RESERVED_TEMPLATE_NAMES = new Set(['core']);

package/dist/lib/template-settings-reconstructor.d.ts

@@ -13,13 +13,17 @@
  *
  * @module lib/template-settings-reconstructor
  */
+import type { ClaudeSettings } from './claude-settings-types.js';
 /**
  * Reconstruct .claude/settings.json and .windsurf/hooks.json from the union
  * of all specified templates.
  *
+ * Note: Codex content is file-based today (`.codex/skills/*`) and does not
+ * have a merged settings artifact, so it is intentionally ignored here.
+ *
  * The function:
  * 1. Starts with empty settings
- * 2. Merges _shared template settings (when active templates exist)
+ * 2. Merges core template settings (when active templates exist)
  * 3. For each active template, merges its template-source settings
  * 4. Writes the result to the IDE settings file
  *
@@ -30,6 +34,7 @@
  *
  * @param targetDir - Project root directory
  * @param activeTemplates - Template names to include (e.g., ['cc-native', 'bmad'])
- * @param ides - IDEs to reconstruct for (e.g., ['claude', 'windsurf'])
+ * @param ides - IDEs to reconstruct for (currently claude/windsurf)
  */
 export declare function reconstructIdeSettings(targetDir: string, activeTemplates: string[], ides: string[]): Promise<void>;
+export declare function normalizeTemplateSettingsPaths(settings: ClaudeSettings): ClaudeSettings;

package/dist/lib/template-settings-reconstructor.js

@@ -14,19 +14,24 @@
  * @module lib/template-settings-reconstructor
  */
 import { join } from 'node:path';
+import { getCoreClaudeSettingsBase, getCoreWindsurfHooksBase } from './core-ide-base.js';
 import { mergeClaudeSettings } from './hooks-merger.js';
 import { IdePathResolver } from './ide-path-resolver.js';
+import { adaptHookCommand, validateCommandsForPlatform } from './platform-commands.js';
 import { readClaudeSettings, writeClaudeSettings } from './settings-hierarchy.js';
-import { getSharedTemplatePath, getTemplatePath } from './template-resolver.js';
+import { getTemplatePath } from './template-resolver.js';
 import { getTargetHooksFile, readWindsurfHooks, writeWindsurfHooks } from './windsurf-hooks-hierarchy.js';
 import { mergeWindsurfHooks } from './windsurf-hooks-merger.js';
 /**
  * Reconstruct .claude/settings.json and .windsurf/hooks.json from the union
  * of all specified templates.
  *
+ * Note: Codex content is file-based today (`.codex/skills/*`) and does not
+ * have a merged settings artifact, so it is intentionally ignored here.
+ *
  * The function:
  * 1. Starts with empty settings
- * 2. Merges _shared template settings (when active templates exist)
+ * 2. Merges core template settings (when active templates exist)
  * 3. For each active template, merges its template-source settings
  * 4. Writes the result to the IDE settings file
  *
@@ -37,87 +42,113 @@ import { mergeWindsurfHooks } from './windsurf-hooks-merger.js';
  *
  * @param targetDir - Project root directory
  * @param activeTemplates - Template names to include (e.g., ['cc-native', 'bmad'])
- * @param ides - IDEs to reconstruct for (e.g., ['claude', 'windsurf'])
+ * @param ides - IDEs to reconstruct for (currently claude/windsurf)
  */
 export async function reconstructIdeSettings(targetDir, activeTemplates, ides) {
-    const sharedTemplatePath = getSharedTemplatePath();
     if (ides.includes('claude')) {
-        await reconstructClaudeSettings(targetDir, activeTemplates, sharedTemplatePath);
+        await reconstructClaudeSettings(targetDir, activeTemplates);
     }
     if (ides.includes('windsurf')) {
-        await reconstructWindsurfHooks(targetDir, activeTemplates, sharedTemplatePath);
+        await reconstructWindsurfHooks(targetDir, activeTemplates);
     }
 }
 /**
  * Reconstruct .claude/settings.json from scratch using template sources.
  */
-async function reconstructClaudeSettings(targetDir, activeTemplates, sharedTemplatePath) {
+async function reconstructClaudeSettings(targetDir, activeTemplates) {
     const resolver = new IdePathResolver(targetDir);
     const settingsPath = resolver.getClaudeSettings();
-    // Read existing settings to preserve non-template fields (methods tracking, etc.)
-    const existingSettings = await readClaudeSettings(settingsPath);
-    // Preserve the methods tracking from existing settings
-    const methodsTracking = existingSettings?.methods;
-    // Start from empty and merge all template settings
-    let reconstructed = {};
-    // 1. Merge _shared template settings (only when active templates exist that need them)
-    if (activeTemplates.length > 0) {
-        const sharedSettingsPath = join(sharedTemplatePath, '.claude', 'settings.json');
-        const sharedSettings = await readClaudeSettings(sharedSettingsPath);
-        if (sharedSettings) {
-            reconstructed = mergeClaudeSettings(reconstructed, sharedSettings);
-        }
-    }
-    // 2. Merge each active template's settings (sequential for deterministic merge order)
+    // Start from core-owned base settings, then merge method templates.
+    let reconstructed = getCoreClaudeSettingsBase();
+    // Merge each active template's settings (sequential for deterministic merge order)
     for (const template of activeTemplates) {
+        let templateSettingsPath = `<unresolved:${template}>/.claude/settings.json`;
         try {
             const templatePath = await getTemplatePath(template); // eslint-disable-line no-await-in-loop
-            const templateSettingsPath = join(templatePath, '.claude', 'settings.json');
+            templateSettingsPath = join(templatePath, '.claude', 'settings.json');
             const templateSettings = await readClaudeSettings(templateSettingsPath); // eslint-disable-line no-await-in-loop
             if (templateSettings) {
-                reconstructed = mergeClaudeSettings(reconstructed, templateSettings);
+                reconstructed = mergeClaudeSettings(reconstructed, normalizeTemplateSettingsPaths(templateSettings));
             }
         }
-        catch {
-            // Template not found — skip
+        catch (error) {
+            reportTemplateMergeFailure('claude', template, templateSettingsPath, error);
         }
     }
-    // 3. Restore methods tracking
-    if (methodsTracking && Object.keys(methodsTracking).length > 0) {
-        reconstructed.methods = methodsTracking;
-    }
+    // 3. Platform-adapt hook commands (Windows cmd.exe compatibility)
+    reconstructed = adaptSettingsForPlatform(reconstructed);
     // 4. Write reconstructed settings
     await writeClaudeSettings(settingsPath, reconstructed);
 }
 /**
  * Reconstruct .windsurf/hooks.json from scratch using template sources.
  */
-async function reconstructWindsurfHooks(targetDir, activeTemplates, sharedTemplatePath) {
+async function reconstructWindsurfHooks(targetDir, activeTemplates) {
     const hooksPath = getTargetHooksFile(targetDir);
-    // Start from empty
-    let reconstructed = { hooks: {} };
-    // 1. Merge _shared template hooks (only when active templates exist that need them)
-    if (activeTemplates.length > 0) {
-        const sharedHooksPath = join(sharedTemplatePath, '.windsurf', 'hooks.json');
-        const sharedHooks = await readWindsurfHooks(sharedHooksPath);
-        if (sharedHooks) {
-            reconstructed = mergeWindsurfHooks(reconstructed, sharedHooks);
-        }
-    }
-    // 2. Merge each active template's hooks (sequential for deterministic merge order)
+    // Start from core-owned base hooks.
+    let reconstructed = getCoreWindsurfHooksBase();
+    // Merge each active template's hooks (sequential for deterministic merge order)
     for (const template of activeTemplates) {
+        let templateHooksPath = `<unresolved:${template}>/.windsurf/hooks.json`;
         try {
             const templatePath = await getTemplatePath(template); // eslint-disable-line no-await-in-loop
-            const templateHooksPath = join(templatePath, '.windsurf', 'hooks.json');
+            templateHooksPath = join(templatePath, '.windsurf', 'hooks.json');
             const templateHooks = await readWindsurfHooks(templateHooksPath); // eslint-disable-line no-await-in-loop
             if (templateHooks) {
                 reconstructed = mergeWindsurfHooks(reconstructed, templateHooks);
             }
         }
-        catch {
-            // Template not found — skip
+        catch (error) {
+            reportTemplateMergeFailure('windsurf', template, templateHooksPath, error);
         }
     }
     // 3. Write reconstructed hooks
     await writeWindsurfHooks(hooksPath, reconstructed);
 }
+/**
+ * Adapt all command strings in settings for the current platform.
+ * On Windows: rewrites commands for cmd.exe compatibility.
+ * Validates adapted commands and fails fast if unknown remain non-portable.
+ */
+function adaptSettingsForPlatform(settings) {
+    const result = { ...settings };
+    const allCommands = [];
+    // Adapt top-level command configs
+    if (result.statusLine && 'command' in result.statusLine) {
+        result.statusLine = { ...result.statusLine, command: adaptHookCommand(result.statusLine.command) };
+        allCommands.push(result.statusLine.command);
+    }
+    if (result.fileSuggestion && 'command' in result.fileSuggestion) {
+        result.fileSuggestion = { ...result.fileSuggestion, command: adaptHookCommand(result.fileSuggestion.command) };
+        allCommands.push(result.fileSuggestion.command);
+    }
+    // Adapt all hook commands
+    if (result.hooks) {
+        const adapted = {};
+        for (const [event, matchers] of Object.entries(result.hooks)) {
+            if (!matchers)
+                continue;
+            adapted[event] = matchers.map((matcher) => ({
+                ...matcher,
+                hooks: matcher.hooks.map((hook) => {
+                    if (hook.type !== 'command')
+                        return hook;
+                    const adaptedCmd = adaptHookCommand(hook.command);
+                    allCommands.push(adaptedCmd);
+                    return { ...hook, command: adaptedCmd };
+                }),
+            }));
+        }
+        result.hooks = adapted;
+    }
+    // Validate: fail fast if unknown command still contains bash-only syntax on Windows
+    validateCommandsForPlatform(allCommands);
+    return result;
+}
+function reportTemplateMergeFailure(ide, template, settingsPath, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[warn] Failed to merge ${ide} template "${template}" from ${settingsPath}: ${reason}\n`);
+}
+export function normalizeTemplateSettingsPaths(settings) {
+    return structuredClone(settings);
+}

package/dist/lib/terminal-strategy.d.ts

@@ -0,0 +1,11 @@
+export interface TerminalConfig {
+    cmd: string;
+    getArgs: (command: string) => string[];
+}
+export type WindowsShellPreference = 'default' | 'git-bash' | 'mintty';
+export type WindowsTerminalStrategy = 'git-bash-in-wt' | 'mintty' | 'powershell-fallback' | 'windows-terminal';
+export declare const LINUX_TERMINALS: TerminalConfig[];
+export declare function resolveWindowsTerminalStrategy(preference: WindowsShellPreference, gitBashPath: null | string, minttyExists: boolean, powershellCmd: string): WindowsTerminalStrategy[];
+export declare function detectPowerShell(isAvailable: (command: string) => boolean): string;
+export declare function isWSL(env?: NodeJS.ProcessEnv): boolean;
+export declare function findAvailableLinuxTerminal(isAvailable: (command: string, platform?: NodeJS.Platform) => boolean): null | TerminalConfig;

package/dist/lib/terminal-strategy.js

@@ -0,0 +1,49 @@
+export const LINUX_TERMINALS = [
+    { cmd: 'gnome-terminal', getArgs: (command) => ['--', 'bash', '-c', `${command}; exec bash`] },
+    { cmd: 'konsole', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
+    { cmd: 'xterm', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
+    { cmd: 'x-terminal-emulator', getArgs: (command) => ['-e', `bash -c "${command}; exec bash"`] },
+];
+export function resolveWindowsTerminalStrategy(preference, gitBashPath, minttyExists, powershellCmd) {
+    const strategies = [];
+    if (preference === 'mintty') {
+        if (minttyExists && gitBashPath) {
+            strategies.push('mintty');
+        }
+        if (gitBashPath) {
+            strategies.push('git-bash-in-wt');
+        }
+        else {
+            strategies.push('windows-terminal');
+        }
+    }
+    else if (preference === 'git-bash') {
+        if (gitBashPath) {
+            strategies.push('git-bash-in-wt');
+        }
+        else {
+            strategies.push('windows-terminal');
+        }
+    }
+    else {
+        strategies.push('windows-terminal');
+    }
+    if (powershellCmd) {
+        strategies.push('powershell-fallback');
+    }
+    return [...new Set(strategies)];
+}
+export function detectPowerShell(isAvailable) {
+    return isAvailable('pwsh') ? 'pwsh' : 'powershell';
+}
+export function isWSL(env = process.env) {
+    return Boolean(env['WSL_DISTRO_NAME']);
+}
+export function findAvailableLinuxTerminal(isAvailable) {
+    for (const terminal of LINUX_TERMINALS) {
+        if (isAvailable(terminal.cmd, 'linux')) {
+            return terminal;
+        }
+    }
+    return null;
+}

package/dist/lib/terminal.d.ts

@@ -27,6 +27,27 @@
  *
  * @module lib/terminal
  */
+import { type WindowsShellPreference } from './terminal-strategy.js';
+/** @internal */
+export interface SpawnArgs {
+    args: string[];
+    command: string;
+}
+/** @internal */
+export declare function resolveTerminalPlatform(platform: NodeJS.Platform, isWSLResult: boolean): 'darwin' | 'linux' | 'windows' | 'wsl';
+/** @internal */
+export declare function buildMacTerminalSpawnArgs(cwd: string, command: string): SpawnArgs;
+/** @internal */
+export declare function buildWindowsTerminalSpawnArgs(cwd: string, command: string, powershellCmd: string): SpawnArgs;
+/** @internal */
+export declare function buildPowerShellFallbackSpawnArgs(cwd: string, command: string, powershellCmd: string): SpawnArgs;
+/** @internal */
+export declare function buildLinuxTerminalSpawnArgs(cwd: string, command: string, terminalInfo: {
+    cmd: string;
+    getArgs: (cmd: string) => string[];
+}): SpawnArgs;
+/** @internal */
+export declare function buildWSLTerminalSpawnArgs(cwd: string, command: string): SpawnArgs;
 /**
  * Options for launching a new terminal window.
  */
@@ -44,6 +65,13 @@ interface TerminalLaunchOptions {
      * If provided, debug messages will be passed to this function.
      */
     debugLog?: (message: string) => void;
+    /**
+     * Preferred shell when launching on Windows.
+     * - default: Existing behavior (PowerShell in wt or fallback)
+     * - mintty: Prefer mintty + Git Bash, fallback to git-bash in wt, then PowerShell
+     * - git-bash: Prefer Git Bash in wt, fallback to PowerShell if unavailable
+     */
+    windowsShellPreference?: WindowsShellPreference;
 }
 /**
  * Result of a terminal launch operation.