aiwcli 0.15.5 → 0.17.0

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,12 @@
+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 function defaultShell(): string;
+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,55 @@
+export function defaultShell() {
+    return process.env.SHELL || 'bash';
+}
+export const LINUX_TERMINALS = (() => {
+    const shell = defaultShell();
+    return [
+        { cmd: 'x-terminal-emulator', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+        { cmd: 'gnome-terminal', getArgs: (command) => ['--', shell, '-c', `${command}; exec ${shell}`] },
+        { cmd: 'konsole', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+        { cmd: 'xterm', getArgs: (command) => ['-e', `${shell} -c "${command}; exec ${shell}"`] },
+    ];
+})();
+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

@@ -6,9 +6,9 @@
  *
  * ## Supported Platforms
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell 7 (pwsh) fallback to PowerShell 5.1
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux emulators
- * - **Linux**: gnome-terminal, konsole, xterm, x-terminal-emulator (in order of preference)
+ * - **Linux**: x-terminal-emulator, gnome-terminal, konsole, xterm (in order of preference)
  *
  * ## Usage
  * ```typescript
@@ -27,6 +27,29 @@
  *
  * @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 buildMacTerminalScriptContent(cwd: string, command: string, shellPath?: string): string;
+/** @internal */
+export declare function buildMacTerminalSpawnArgs(scriptPath: 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 +67,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.
@@ -64,9 +94,9 @@ interface TerminalLaunchResult {
  * This function automatically detects the platform and uses the appropriate
  * terminal emulator:
  * - **Windows**: Windows Terminal (wt.exe) with PowerShell, falls back to PowerShell directly
- * - **macOS**: Terminal.app via AppleScript
+ * - **macOS**: Terminal.app via `open` + temporary `.command` script
  * - **WSL**: Windows Terminal (wt.exe) via wsl.exe, falls back to Linux terminals
- * - **Linux**: Tries gnome-terminal, konsole, xterm, x-terminal-emulator in order
+ * - **Linux**: Tries x-terminal-emulator, gnome-terminal, konsole, xterm in order
  *
  * The terminal is launched in detached mode, allowing the parent process to exit
  * without affecting the new terminal.