aiwcli 0.9.0

package/dist/commands/launch.d.ts

@@ -0,0 +1,21 @@
+import BaseCommand from '../lib/base-command.js';
+/**
+ * Launch Claude Code or Codex 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.
+ */
+export default class LaunchCommand extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        codex: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        new: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/launch.js

@@ -0,0 +1,108 @@
+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';
+/**
+ * Launch Claude Code or Codex 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.
+ */
+export default class LaunchCommand extends BaseCommand {
+    static description = 'Launch Claude Code or Codex with AIW configuration (sandbox disabled, supports parallel sessions)\n\n' +
+        'FLAGS\n' +
+        '  --codex/-c: Launch Codex instead of Claude Code (uses --yolo flag)\n' +
+        '  --new/-n: Open a new terminal in the current directory and launch there\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 or Codex from npm)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --codex  # Launch Codex with --yolo flag',
+        '<%= config.bin %> <%= command.id %> -c  # Short form for --codex',
+        '<%= 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 %> --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,
+        codex: Flags.boolean({
+            char: 'c',
+            description: 'Launch Codex instead of Claude Code (uses --yolo flag for full auto mode)',
+            default: false,
+        }),
+        new: Flags.boolean({
+            char: 'n',
+            description: 'Open a new terminal in the current directory and run aiw launch there',
+            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' : '';
+        // 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)
+            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);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/base-command.d.ts

@@ -0,0 +1,114 @@
+import { Command } from '@oclif/core';
+import { type Ora } from 'ora';
+/**
+ * Base command class that all AI Workflow CLI commands should extend.
+ * Provides global --debug flag support for verbose logging.
+ *
+ * @example Basic command with debug support
+ * import {debug} from '../lib/debug.js'
+ *
+ * export default class MyCommand extends BaseCommand {
+ *   static override flags = {
+ *     ...BaseCommand.baseFlags,
+ *     // command-specific flags
+ *   }
+ *
+ *   async run() {
+ *     // debug mode is already enabled if --debug flag was passed
+ *     // version info is automatically logged when debug enabled
+ *     debug('My debug message')
+ *   }
+ * }
+ *
+ * @example Command with spinner progress feedback
+ * import {ux} from '@oclif/core'
+ *
+ * export default class LongCommand extends BaseCommand {
+ *   async run() {
+ *     // Check if output is piped (suppress spinners for piped output)
+ *     const isPiped = !process.stdout.isTTY
+ *
+ *     if (!isPiped) {
+ *       // Show spinner for long operations in interactive terminal
+ *       ux.action.start('Processing')
+ *       await longRunningOperation()
+ *       ux.action.stop()
+ *     } else {
+ *       // Piped output - suppress spinner
+ *       await longRunningOperation()
+ *     }
+ *   }
+ * }
+ *
+ * @example Spinner with status updates
+ * import {ux} from '@oclif/core'
+ *
+ * export default class MultiStepCommand extends BaseCommand {
+ *   async run() {
+ *     if (process.stdout.isTTY) {
+ *       ux.action.start('Installing packages')
+ *       await installPackages()
+ *
+ *       // Update spinner status
+ *       ux.action.status = 'Configuring'
+ *       await configure()
+ *
+ *       ux.action.stop('Done!')
+ *     } else {
+ *       await installPackages()
+ *       await configure()
+ *     }
+ *   }
+ * }
+ */
+export default abstract class BaseCommand extends Command {
+    /**
+     * Global flags inherited by all AI Workflow CLI commands.
+     * All command classes should spread these flags into their own flag definitions:
+     * `static override flags = { ...BaseCommand.baseFlags, /* command-specific flags *\/ }`
+     *
+     * @see Command Development Guide in README.md for usage patterns
+     */
+    static baseFlags: {
+        debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        help: import("@oclif/core/interfaces").BooleanFlag<void>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    /**
+     * Check if quiet mode is enabled.
+     * Returns true if --quiet/-q flag was passed.
+     */
+    protected isQuiet(): boolean;
+    /**
+     * Log debug message (stdout, dim in TTY).
+     * Debug output is independent of quiet mode.
+     */
+    protected logDebug(message: string): void;
+    /**
+     * Log error message (stderr, red in TTY).
+     * Errors are NEVER suppressed, even in quiet mode.
+     */
+    protected logError(message: string): void;
+    /**
+     * Log informational message (stdout, no color).
+     * Suppressed in quiet mode.
+     */
+    protected logInfo(message: string): void;
+    /**
+     * Log success message (stdout, green in TTY).
+     * Suppressed in quiet mode.
+     */
+    protected logSuccess(message: string): void;
+    /**
+     * Log warning message (stdout, yellow in TTY).
+     * Suppressed in quiet mode.
+     */
+    protected logWarning(message: string): void;
+    abstract run(): Promise<void>;
+    /**
+     * Create a TTY-aware spinner for long-running operations.
+     * Automatically disabled when output is piped, in CI environments, or in quiet mode.
+     */
+    protected spinner(text: string): Ora;
+}

package/dist/lib/base-command.js

@@ -0,0 +1,153 @@
+import { Command, Flags } from '@oclif/core';
+import { debugVersion, setDebugEnabled } from '../lib/debug.js';
+import { logDebug, logError, logInfo, logSuccess, logWarning } from '../lib/output.js';
+import { isQuietMode, setQuietMode } from '../lib/quiet.js';
+import { createSpinner } from '../lib/spinner.js';
+/**
+ * Base command class that all AI Workflow CLI commands should extend.
+ * Provides global --debug flag support for verbose logging.
+ *
+ * @example Basic command with debug support
+ * import {debug} from '../lib/debug.js'
+ *
+ * export default class MyCommand extends BaseCommand {
+ *   static override flags = {
+ *     ...BaseCommand.baseFlags,
+ *     // command-specific flags
+ *   }
+ *
+ *   async run() {
+ *     // debug mode is already enabled if --debug flag was passed
+ *     // version info is automatically logged when debug enabled
+ *     debug('My debug message')
+ *   }
+ * }
+ *
+ * @example Command with spinner progress feedback
+ * import {ux} from '@oclif/core'
+ *
+ * export default class LongCommand extends BaseCommand {
+ *   async run() {
+ *     // Check if output is piped (suppress spinners for piped output)
+ *     const isPiped = !process.stdout.isTTY
+ *
+ *     if (!isPiped) {
+ *       // Show spinner for long operations in interactive terminal
+ *       ux.action.start('Processing')
+ *       await longRunningOperation()
+ *       ux.action.stop()
+ *     } else {
+ *       // Piped output - suppress spinner
+ *       await longRunningOperation()
+ *     }
+ *   }
+ * }
+ *
+ * @example Spinner with status updates
+ * import {ux} from '@oclif/core'
+ *
+ * export default class MultiStepCommand extends BaseCommand {
+ *   async run() {
+ *     if (process.stdout.isTTY) {
+ *       ux.action.start('Installing packages')
+ *       await installPackages()
+ *
+ *       // Update spinner status
+ *       ux.action.status = 'Configuring'
+ *       await configure()
+ *
+ *       ux.action.stop('Done!')
+ *     } else {
+ *       await installPackages()
+ *       await configure()
+ *     }
+ *   }
+ * }
+ */
+export default class BaseCommand extends Command {
+    /**
+     * Global flags inherited by all AI Workflow CLI commands.
+     * All command classes should spread these flags into their own flag definitions:
+     * `static override flags = { ...BaseCommand.baseFlags, /* command-specific flags *\/ }`
+     *
+     * @see Command Development Guide in README.md for usage patterns
+     */
+    static baseFlags = {
+        debug: Flags.boolean({
+            char: 'd',
+            description: 'Enable verbose debug logging',
+            default: false,
+        }),
+        help: Flags.help({
+            char: 'h',
+            description: 'Show help for command',
+        }),
+        quiet: Flags.boolean({
+            char: 'q',
+            description: 'Suppress informational output (errors still shown)',
+            default: false,
+        }),
+    };
+    async init() {
+        await super.init();
+        const { flags } = await this.parse(this.constructor);
+        const debugEnabled = flags.debug ?? false;
+        const quietEnabled = flags.quiet ?? false;
+        setDebugEnabled(debugEnabled);
+        setQuietMode(quietEnabled);
+        // Automatically show version info in debug mode (AC4, FR24)
+        if (debugEnabled) {
+            debugVersion();
+        }
+    }
+    /**
+     * Check if quiet mode is enabled.
+     * Returns true if --quiet/-q flag was passed.
+     */
+    isQuiet() {
+        // Access via module-level state (set in init())
+        return isQuietMode();
+    }
+    /**
+     * Log debug message (stdout, dim in TTY).
+     * Debug output is independent of quiet mode.
+     */
+    logDebug(message) {
+        logDebug(message);
+    }
+    /**
+     * Log error message (stderr, red in TTY).
+     * Errors are NEVER suppressed, even in quiet mode.
+     */
+    logError(message) {
+        logError(message);
+    }
+    /**
+     * Log informational message (stdout, no color).
+     * Suppressed in quiet mode.
+     */
+    logInfo(message) {
+        logInfo(message, this.isQuiet());
+    }
+    /**
+     * Log success message (stdout, green in TTY).
+     * Suppressed in quiet mode.
+     */
+    logSuccess(message) {
+        logSuccess(message, this.isQuiet());
+    }
+    /**
+     * Log warning message (stdout, yellow in TTY).
+     * Suppressed in quiet mode.
+     */
+    logWarning(message) {
+        logWarning(message, this.isQuiet());
+    }
+    /**
+     * Create a TTY-aware spinner for long-running operations.
+     * Automatically disabled when output is piped, in CI environments, or in quiet mode.
+     */
+    spinner(text) {
+        return createSpinner(text, { quiet: isQuietMode() });
+    }
+}

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

@@ -0,0 +1,38 @@
+/**
+ * BMAD installation configuration
+ */
+export interface BmadInstallConfig {
+    projectName: string;
+    targetDir: string;
+    username: string;
+}
+/**
+ * Generate core module configuration YAML
+ */
+export declare function generateCoreConfig(username: string): string;
+/**
+ * Generate BMM module configuration YAML
+ */
+export declare function generateBmmConfig(projectName: string, username: string): string;
+/**
+ * Generate installation manifest YAML
+ */
+export declare function generateManifest(): string;
+/**
+ * Install BMAD structure in target directory
+ */
+export declare function installBmad(config: BmadInstallConfig): Promise<void>;
+/**
+ * Generate BMAD configuration files in the target directory.
+ * Used as a post-install hook after template installation.
+ *
+ * @param targetDir - Directory where BMAD was installed
+ * @param username - Username for configuration
+ * @param projectName - Project name for configuration
+ */
+export declare function generateBmadConfigs(targetDir: string, username: string, projectName: string): Promise<void>;
+/**
+ * Detect username from git config or environment variables.
+ * Priority: git config user.name > USER env > USERNAME env > fallback to "User"
+ */
+export declare function detectUsername(): Promise<string>;

package/dist/lib/bmad-installer.js

@@ -0,0 +1,145 @@
+import { execSync } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { copyDir } from './template-installer.js';
+import { getTemplatePath } from './template-resolver.js';
+/**
+ * BMAD version to install
+ */
+const BMAD_VERSION = '6.0.0-alpha.22';
+/**
+ * Generate core module configuration YAML
+ */
+export function generateCoreConfig(username) {
+    const now = new Date().toISOString();
+    return `# CORE Module Configuration
+# Generated by AI Workflow CLI
+# Version: ${BMAD_VERSION}
+# Date: ${now}
+
+user_name: ${username}
+communication_language: English
+document_output_language: English
+output_folder: "{project-root}/_bmad-output"
+`;
+}
+/**
+ * Generate BMM module configuration YAML
+ */
+export function generateBmmConfig(projectName, username) {
+    const now = new Date().toISOString();
+    return `# BMM Module Configuration
+# Generated by AI Workflow CLI
+# Version: ${BMAD_VERSION}
+# Date: ${now}
+
+project_name: ${projectName}
+user_skill_level: intermediate
+planning_artifacts: "{project-root}/_bmad-output/planning-artifacts"
+implementation_artifacts: "{project-root}/_bmad-output/implementation-artifacts"
+project_knowledge: "{project-root}/docs"
+tea_use_mcp_enhancements: false
+tea_use_playwright_utils: false
+
+# Core Configuration Values
+user_name: ${username}
+communication_language: English
+document_output_language: English
+output_folder: "{project-root}/_bmad-output"
+`;
+}
+/**
+ * Generate installation manifest YAML
+ */
+export function generateManifest() {
+    const now = new Date().toISOString();
+    return `installation:
+  version: ${BMAD_VERSION}
+  installDate: ${now}
+  lastUpdated: ${now}
+  installedBy: aiwcli
+modules:
+  - core
+  - bmm
+ides:
+  - claude-code
+`;
+}
+/**
+ * Install BMAD structure in target directory
+ */
+export async function installBmad(config) {
+    const { projectName, targetDir, username } = config;
+    // Get bundled BMAD template path (parent directory containing _bmad/ and .claude/)
+    const templateRootPath = await getTemplatePath('bmad');
+    const bmadPath = join(targetDir, '_bmad');
+    const claudePath = join(targetDir, '.claude');
+    // Create main _bmad directories
+    await fs.mkdir(join(bmadPath, '_config'), { recursive: true });
+    await fs.mkdir(join(bmadPath, 'core'), { recursive: true });
+    await fs.mkdir(join(bmadPath, 'bmm'), { recursive: true });
+    // Create output directories
+    await fs.mkdir(join(targetDir, '_bmad-output', 'planning-artifacts'), { recursive: true });
+    await fs.mkdir(join(targetDir, '_bmad-output', 'implementation-artifacts'), { recursive: true });
+    // Copy _bmad/ structure from template
+    const templateBmadPath = join(templateRootPath, '_bmad');
+    // Copy core module from template
+    const templateCorePath = join(templateBmadPath, 'core');
+    const targetCorePath = join(bmadPath, 'core');
+    await copyDir(templateCorePath, targetCorePath);
+    // Copy BMM module from template
+    const templateBmmPath = join(templateBmadPath, 'bmm');
+    const targetBmmPath = join(bmadPath, 'bmm');
+    await copyDir(templateBmmPath, targetBmmPath);
+    // Copy _config directory (manifest CSVs, ides, etc.) from template
+    const templateConfigPath = join(templateBmadPath, '_config');
+    const targetConfigPath = join(bmadPath, '_config');
+    await copyDir(templateConfigPath, targetConfigPath);
+    // Copy .claude/commands/bmad/ structure from template
+    const templateClaudeBmadPath = join(templateRootPath, '.claude', 'commands', 'bmad');
+    const targetClaudeBmadPath = join(claudePath, 'commands', 'bmad');
+    await copyDir(templateClaudeBmadPath, targetClaudeBmadPath);
+    // Generate and write custom configuration files (overwrite template configs)
+    await fs.writeFile(join(targetCorePath, 'config.yaml'), generateCoreConfig(username), 'utf8');
+    await fs.writeFile(join(targetBmmPath, 'config.yaml'), generateBmmConfig(projectName, username), 'utf8');
+    await fs.writeFile(join(targetConfigPath, 'manifest.yaml'), generateManifest(), 'utf8');
+}
+/**
+ * Generate BMAD configuration files in the target directory.
+ * Used as a post-install hook after template installation.
+ *
+ * @param targetDir - Directory where BMAD was installed
+ * @param username - Username for configuration
+ * @param projectName - Project name for configuration
+ */
+export async function generateBmadConfigs(targetDir, username, projectName) {
+    const bmadPath = join(targetDir, '_bmad');
+    const coreConfigPath = join(bmadPath, 'core', 'config.yaml');
+    const bmmConfigPath = join(bmadPath, 'bmm', 'config.yaml');
+    const manifestPath = join(bmadPath, '_config', 'manifest.yaml');
+    await fs.writeFile(coreConfigPath, generateCoreConfig(username), 'utf8');
+    await fs.writeFile(bmmConfigPath, generateBmmConfig(projectName, username), 'utf8');
+    await fs.writeFile(manifestPath, generateManifest(), 'utf8');
+}
+/**
+ * Detect username from git config or environment variables.
+ * Priority: git config user.name > USER env > USERNAME env > fallback to "User"
+ */
+export async function detectUsername() {
+    // Try git config first
+    try {
+        const gitUser = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const username = gitUser.trim();
+        if (username)
+            return username;
+    }
+    catch {
+        // Git command failed or not configured, continue to env vars
+    }
+    // Try environment variables
+    const envUser = process.env['USER'] ?? process.env['USERNAME'];
+    if (envUser)
+        return envUser;
+    // Fallback
+    return 'User';
+}

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

@@ -0,0 +1,102 @@
+/**
+ * TypeScript interfaces for Claude Code settings.json structure
+ * Based on Claude Code documentation and research
+ */
+/**
+ * Hook command configuration
+ */
+export interface HookCommand {
+    /** Command to execute */
+    command: string;
+    /** Optional timeout in seconds */
+    timeout?: number;
+    /** Type of hook action */
+    type: 'command';
+}
+/**
+ * Hook matcher configuration
+ */
+export interface HookMatcher {
+    /** Array of hook commands to execute */
+    hooks: HookCommand[];
+    /** Tool name pattern to match (regex supported) */
+    matcher: string;
+    /** Execute only once per session */
+    once?: boolean;
+}
+/**
+ * Hook event types supported by Claude Code
+ */
+export type HookEventType = 'Notification' | 'PermissionRequest' | 'PostToolUse' | 'PreCompact' | 'PreToolUse' | 'SessionEnd' | 'SessionStart' | 'Stop' | 'SubagentStop' | 'UserPromptSubmit';
+/**
+ * Hooks configuration
+ * Maps event types to arrays of hook matchers
+ */
+export type HooksConfig = Partial<Record<HookEventType, HookMatcher[]>>;
+/**
+ * Permission patterns for tool access
+ */
+export interface Permissions {
+    /** Allowed tool patterns */
+    allow?: string[];
+    /** Denied tool patterns */
+    deny?: string[];
+}
+/**
+ * Enabled plugins configuration
+ */
+export type EnabledPlugins = Record<string, boolean>;
+/**
+ * Environment variables configuration
+ */
+export type EnvConfig = Record<string, string>;
+/**
+ * Method installation tracking metadata
+ */
+export 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
+ */
+export interface ClaudeSettings {
+    /** Cleanup period in days */
+    cleanupPeriodDays?: number;
+    /** Enabled plugins */
+    enabledPlugins?: EnabledPlugins;
+    /** Environment variables */
+    env?: EnvConfig;
+    /** Hook configurations */
+    hooks?: HooksConfig;
+    /** Installed methods tracking */
+    methods?: MethodsConfig;
+    /** Default model to use */
+    model?: string;
+    /** Tool permissions */
+    permissions?: Permissions;
+    /** Spinner tips enabled */
+    spinnerTipsEnabled?: boolean;
+}
+/**
+ * Settings file types in hierarchy
+ */
+export type SettingsFileType = 'local' | 'project' | 'user';
+/**
+ * Settings file location
+ */
+export interface SettingsLocation {
+    /** Whether file exists */
+    exists: boolean;
+    /** Absolute path to settings file */
+    path: string;
+    /** Type of settings file */
+    type: SettingsFileType;
+}