@aurorajs.dev/catalyst-cli 1.0.0

package/dist/ai/domain/reader.js

@@ -0,0 +1,51 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Discover all contexts with .ai/CONTEXT.md (root + immediate children).
+ * Optionally filter by target name.
+ */
+export function discoverContexts(rootDir, targetFilter) {
+    const contexts = [];
+    const rootAiDir = join(rootDir, '.ai');
+    const rootContextFile = join(rootAiDir, 'CONTEXT.md');
+    if (existsSync(rootContextFile) && !targetFilter) {
+        contexts.push({
+            aiDir: rootAiDir,
+            contextDir: rootDir,
+            contextFile: rootContextFile,
+            hasAgents: existsSync(join(rootAiDir, 'agents')),
+            hasCommands: existsSync(join(rootAiDir, 'commands')),
+            hasSkills: existsSync(join(rootAiDir, 'skills')),
+            isRoot: true,
+            name: 'root',
+        });
+    }
+    const entries = readdirSync(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+            continue;
+        if (targetFilter && entry.name !== targetFilter)
+            continue;
+        const childDir = join(rootDir, entry.name);
+        const childAiDir = join(childDir, '.ai');
+        const childContextFile = join(childAiDir, 'CONTEXT.md');
+        if (!existsSync(childContextFile))
+            continue;
+        contexts.push({
+            aiDir: childAiDir,
+            contextDir: childDir,
+            contextFile: childContextFile,
+            hasAgents: existsSync(join(childAiDir, 'agents')),
+            hasCommands: existsSync(join(childAiDir, 'commands')),
+            hasSkills: existsSync(join(childAiDir, 'skills')),
+            isRoot: false,
+            name: entry.name,
+        });
+    }
+    return contexts;
+}
+export function readContextFile(context) {
+    return readFileSync(context.contextFile, 'utf8');
+}

package/dist/ai/domain/skills-indexer.d.ts

@@ -0,0 +1,3 @@
+import type { SkillGroup } from './types.js';
+/** Generate the Claude-specific skills index block (between SKILLS-INDEX-START/END markers). */
+export declare function generateSkillsIndex(groups: SkillGroup[], providerSkillsDir: string): string;

package/dist/ai/domain/skills-indexer.js

@@ -0,0 +1,9 @@
+const MARKER_START = '<!-- SKILLS-INDEX-START -->';
+const MARKER_END = '<!-- SKILLS-INDEX-END -->';
+/** Generate the Claude-specific skills index block (between SKILLS-INDEX-START/END markers). */
+export function generateSkillsIndex(groups, providerSkillsDir) {
+    const root = providerSkillsDir.replace(/\/$/, '');
+    const header = `[Project Skills Index]|root:${root}|IMPORTANT:Prefer retrieval-led reasoning over pre-training.Read SKILL.md first,then related files.`;
+    const lines = groups.map((g) => `|${g.relativePath}:{${g.files.join(',')}}`);
+    return MARKER_START + '\n' + header + lines.join('') + '\n' + MARKER_END;
+}

package/dist/ai/domain/skills-scanner.d.ts

@@ -0,0 +1,8 @@
+import type { SkillGroup, SkillStats } from './types.js';
+/** Recursively scan a directory for .md files (ignoring logs/, scripts/, docs/). Paths are relative to `baseDir`. */
+export declare function scanMdFiles(dir: string, baseDir: string): string[];
+/** Group scanned files by category. Sort order: skills → commands → agents. */
+export declare function groupFiles(files: string[]): SkillGroup[];
+/** Merge context + root skills; context wins on name conflict. */
+export declare function mergeSkillDirs(contextSkillsDir: string, rootSkillsDir: string): SkillGroup[];
+export declare function computeStats(groups: SkillGroup[]): SkillStats;

package/dist/ai/domain/skills-scanner.js

@@ -0,0 +1,102 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+const IGNORED_DIRS = new Set(['docs', 'logs', 'scripts']);
+function catOrder(k) {
+    if (k.startsWith('skills/'))
+        return 0;
+    if (k === 'commands')
+        return 1;
+    if (k.startsWith('agents'))
+        return 2;
+    return 3;
+}
+/** Recursively scan a directory for .md files (ignoring logs/, scripts/, docs/). Paths are relative to `baseDir`. */
+export function scanMdFiles(dir, baseDir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        const rel = relative(baseDir, fullPath);
+        const topDir = rel.split(sep)[0];
+        if (IGNORED_DIRS.has(topDir))
+            continue;
+        if (entry.isDirectory()) {
+            results.push(...scanMdFiles(fullPath, baseDir));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.md')) {
+            results.push(rel);
+        }
+    }
+    return results;
+}
+/** Group scanned files by category. Sort order: skills → commands → agents. */
+export function groupFiles(files) {
+    const groupMap = new Map();
+    for (const file of files) {
+        const parts = file.split(sep);
+        let groupKey;
+        if (parts[0] === 'skills' && parts.length > 2) {
+            groupKey = `${parts[0]}/${parts[1]}`;
+        }
+        else if (parts[0] === 'agents' &&
+            parts.length > 2 &&
+            parts[1] === 'assets') {
+            groupKey = 'agents/assets';
+        }
+        else {
+            groupKey = parts[0];
+        }
+        if (!groupMap.has(groupKey))
+            groupMap.set(groupKey, []);
+        groupMap.get(groupKey).push(parts.at(-1));
+    }
+    const sortedKeys = [...groupMap.keys()].sort((a, b) => {
+        const diff = catOrder(a) - catOrder(b);
+        return diff === 0 ? a.localeCompare(b) : diff;
+    });
+    return sortedKeys.map((key) => {
+        const rawFiles = groupMap.get(key);
+        const sorted = rawFiles.sort((a, b) => {
+            if (a === 'SKILL.md')
+                return -1;
+            if (b === 'SKILL.md')
+                return 1;
+            return a.localeCompare(b);
+        });
+        return { files: [...new Set(sorted)], relativePath: key };
+    });
+}
+/** Merge context + root skills; context wins on name conflict. */
+export function mergeSkillDirs(contextSkillsDir, rootSkillsDir) {
+    const contextFiles = scanMdFiles(contextSkillsDir, contextSkillsDir);
+    const rootFiles = scanMdFiles(rootSkillsDir, rootSkillsDir);
+    const contextGroups = groupFiles(contextFiles);
+    const rootGroups = groupFiles(rootFiles);
+    const contextPaths = new Set(contextGroups.map((g) => g.relativePath));
+    const merged = [
+        ...contextGroups,
+        ...rootGroups.filter((g) => !contextPaths.has(g.relativePath)),
+    ];
+    return merged.sort((a, b) => {
+        const diff = catOrder(a.relativePath) - catOrder(b.relativePath);
+        return diff === 0 ? a.relativePath.localeCompare(b.relativePath) : diff;
+    });
+}
+export function computeStats(groups) {
+    let totalSkills = 0;
+    let totalCommands = 0;
+    let totalAgents = 0;
+    let totalFiles = 0;
+    for (const g of groups) {
+        totalFiles += g.files.length;
+        if (g.relativePath.startsWith('skills/'))
+            totalSkills++;
+        else if (g.relativePath === 'commands')
+            totalCommands = g.files.length;
+        else if (g.relativePath.startsWith('agents'))
+            totalAgents++;
+    }
+    return { groups, totalAgents, totalCommands, totalFiles, totalSkills };
+}

package/dist/ai/domain/templates.d.ts

@@ -0,0 +1,6 @@
+import type { AiProviderName } from './types.js';
+/**
+ * Copy config files from templates to the target directory.
+ * Never overwrites — only copies files that do NOT already exist.
+ */
+export declare function copyConfigFiles(providerName: AiProviderName, targetDir: string, dryRun: boolean): string[];

package/dist/ai/domain/templates.js

@@ -0,0 +1,55 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Resolve the absolute path to a provider's template directory.
+ * Templates live in src/templates/ai/{provider}/ (dev) or dist/templates/ai/{provider}/ (prod).
+ * __dirname is src/ai/domain or dist/ai/domain → go up 2 levels to src/ or dist/.
+ */
+function getTemplatesDir(providerName) {
+    return join(__dirname, '..', '..', 'templates', 'ai', providerName);
+}
+function scanFiles(dir, baseDir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...scanFiles(fullPath, baseDir));
+        }
+        else if (entry.isFile()) {
+            results.push(relative(baseDir, fullPath));
+        }
+    }
+    return results;
+}
+/**
+ * Copy config files from templates to the target directory.
+ * Never overwrites — only copies files that do NOT already exist.
+ */
+export function copyConfigFiles(providerName, targetDir, dryRun) {
+    const templatesDir = getTemplatesDir(providerName);
+    if (!existsSync(templatesDir))
+        return [];
+    const files = scanFiles(templatesDir, templatesDir);
+    const messages = [];
+    for (const relPath of files) {
+        const destPath = join(targetDir, relPath);
+        if (existsSync(destPath)) {
+            messages.push(`[skip] ${relPath} (already exists)`);
+            continue;
+        }
+        if (dryRun) {
+            messages.push(`[dry-run] ${relPath}`);
+            continue;
+        }
+        mkdirSync(dirname(destPath), { recursive: true });
+        copyFileSync(join(templatesDir, relPath), destPath);
+        messages.push(relPath);
+    }
+    return messages;
+}

package/dist/ai/domain/types.d.ts

@@ -0,0 +1,50 @@
+export type AiProviderName = 'claude' | 'codex' | 'copilot' | 'gemini' | 'opencode';
+export interface AiProviderConfig {
+    instructionFile: string;
+    label: string;
+    /** Whether this provider only supports root context (no per-target files) */
+    rootOnly?: boolean;
+    skillsDir: string;
+}
+export declare const PROVIDER_CONFIGS: Record<AiProviderName, AiProviderConfig>;
+export interface AiContext {
+    /** Absolute path to .ai/ directory */
+    aiDir: string;
+    /** Absolute path to the context directory (project root for 'root') */
+    contextDir: string;
+    /** Absolute path to CONTEXT.md */
+    contextFile: string;
+    /** Whether .ai/agents/ exists */
+    hasAgents: boolean;
+    /** Whether .ai/commands/ exists */
+    hasCommands: boolean;
+    /** Whether .ai/skills/ exists */
+    hasSkills: boolean;
+    /** Whether this is the root context */
+    isRoot: boolean;
+    /** Display name: 'root' | 'backend' | 'frontend' | etc. */
+    name: string;
+}
+export interface GeneratedFile {
+    /** Generated content (for instruction files) */
+    content?: string;
+    /** Absolute output path */
+    path: string;
+    /** Symlink target (for symlinks) */
+    symlinkTarget?: string;
+    /** File type */
+    type: 'instruction' | 'symlink';
+}
+export interface SkillGroup {
+    /** .md files found in this group */
+    files: string[];
+    /** Relative path from skills dir (e.g. "skills/aurora-cqrs") */
+    relativePath: string;
+}
+export interface SkillStats {
+    groups: SkillGroup[];
+    totalAgents: number;
+    totalCommands: number;
+    totalFiles: number;
+    totalSkills: number;
+}

package/dist/ai/domain/types.js

@@ -0,0 +1,28 @@
+export const PROVIDER_CONFIGS = {
+    claude: {
+        instructionFile: 'CLAUDE.md',
+        label: 'Claude Code',
+        skillsDir: '.claude/',
+    },
+    codex: {
+        instructionFile: 'AGENTS.md',
+        label: 'Codex',
+        skillsDir: '.codex/',
+    },
+    copilot: {
+        instructionFile: '.github/copilot-instructions.md',
+        label: 'GitHub Copilot',
+        rootOnly: true,
+        skillsDir: '.github/',
+    },
+    gemini: {
+        instructionFile: 'GEMINI.md',
+        label: 'Gemini CLI',
+        skillsDir: '.gemini/',
+    },
+    opencode: {
+        instructionFile: 'AGENTS.md',
+        label: 'OpenCode',
+        skillsDir: '.opencode/',
+    },
+};

package/dist/ai/factories/provider.factory.d.ts

@@ -0,0 +1,2 @@
+import type { AiSetupPorts } from '../services/ai-setup.service.js';
+export declare function createAiSetupPorts(): AiSetupPorts;

package/dist/ai/factories/provider.factory.js

@@ -0,0 +1,18 @@
+import { ClaudeAdapter } from '../adapters/claude.adapter.js';
+import { CodexAdapter } from '../adapters/codex.adapter.js';
+import { CopilotAdapter } from '../adapters/copilot.adapter.js';
+import { GeminiAdapter } from '../adapters/gemini.adapter.js';
+import { InquirerPromptAdapter } from '../adapters/inquirer-prompt.adapter.js';
+import { OpenCodeAdapter } from '../adapters/opencode.adapter.js';
+export function createAiSetupPorts() {
+    const generators = new Map();
+    generators.set('claude', new ClaudeAdapter());
+    generators.set('codex', new CodexAdapter());
+    generators.set('copilot', new CopilotAdapter());
+    generators.set('gemini', new GeminiAdapter());
+    generators.set('opencode', new OpenCodeAdapter());
+    return {
+        generators,
+        prompt: new InquirerPromptAdapter(),
+    };
+}

package/dist/ai/ports/generator.port.d.ts

@@ -0,0 +1,7 @@
+import type { AiContext, AiProviderName, GeneratedFile } from '../domain/types.js';
+export interface AiGeneratorPort {
+    copyConfigFiles(contextDir: string, dryRun: boolean): string[];
+    createSymlinks(context: AiContext, rootDir: string, dryRun: boolean): string[];
+    generate(context: AiContext, rootDir: string): GeneratedFile[];
+    readonly providerName: AiProviderName;
+}

package/dist/ai/ports/generator.port.js

@@ -0,0 +1 @@
+export {};

package/dist/ai/ports/prompt.port.d.ts

@@ -0,0 +1,5 @@
+import type { AiProviderName } from '../domain/types.js';
+export interface AiPromptPort {
+    confirmOverwrite(files: string[]): Promise<boolean>;
+    selectProviders(available: AiProviderName[]): Promise<AiProviderName[]>;
+}

package/dist/ai/ports/prompt.port.js

@@ -0,0 +1 @@
+export {};

package/dist/ai/services/ai-setup.service.d.ts

@@ -0,0 +1,28 @@
+import type { AiContext, AiProviderName } from '../domain/types.js';
+import type { AiGeneratorPort } from '../ports/generator.port.js';
+import type { AiPromptPort } from '../ports/prompt.port.js';
+export interface AiSetupPorts {
+    generators: Map<AiProviderName, AiGeneratorPort>;
+    prompt: AiPromptPort;
+}
+export interface AiSetupOptions {
+    all?: boolean;
+    contexts: AiContext[];
+    dryRun?: boolean;
+    force?: boolean;
+    providers?: AiProviderName[];
+    rootDir: string;
+}
+export interface AiSetupResult {
+    configsCopied: number;
+    filesWritten: number;
+    messages: string[];
+    symlinksCreated: number;
+}
+export declare class AiSetupService {
+    private readonly ports;
+    constructor(ports: AiSetupPorts);
+    execute(options: AiSetupOptions): Promise<AiSetupResult>;
+    private processContext;
+    private resolveProviders;
+}

package/dist/ai/services/ai-setup.service.js

@@ -0,0 +1,94 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { relative } from 'node:path';
+export class AiSetupService {
+    ports;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async execute(options) {
+        const { contexts, dryRun = false, force = false, rootDir } = options;
+        const providers = await this.resolveProviders(options);
+        if (providers.length === 0) {
+            return {
+                configsCopied: 0,
+                filesWritten: 0,
+                messages: ['No providers selected.'],
+                symlinksCreated: 0,
+            };
+        }
+        const messages = [];
+        let configsCopied = 0;
+        let filesWritten = 0;
+        let symlinksCreated = 0;
+        for (const providerName of providers) {
+            const generator = this.ports.generators.get(providerName);
+            if (!generator)
+                continue;
+            messages.push(`\n[${providerName}]`);
+            for (const context of contexts) {
+                // eslint-disable-next-line no-await-in-loop
+                const result = await this.processContext({
+                    context,
+                    dryRun,
+                    force,
+                    generator,
+                    messages,
+                    rootDir,
+                });
+                configsCopied += result.configs;
+                filesWritten += result.files;
+                symlinksCreated += result.symlinks;
+            }
+        }
+        messages.push('', `${providers.length} provider(s) x ${contexts.length} context(s) = ${filesWritten} files + ${symlinksCreated} symlinks + ${configsCopied} configs`);
+        return { configsCopied, filesWritten, messages, symlinksCreated };
+    }
+    async processContext(params) {
+        const { context, dryRun, force, generator, messages, rootDir } = params;
+        let files = 0;
+        for (const file of generator.generate(context, rootDir)) {
+            if (file.type !== 'instruction' || !file.content)
+                continue;
+            const relPath = relative(rootDir, file.path);
+            if (!dryRun && !force && existsSync(file.path)) {
+                // eslint-disable-next-line no-await-in-loop
+                const shouldOverwrite = await this.ports.prompt.confirmOverwrite([
+                    relPath,
+                ]);
+                if (!shouldOverwrite) {
+                    messages.push(`  ${context.name}: skipped ${relPath} (existing)`);
+                    continue;
+                }
+            }
+            if (dryRun) {
+                messages.push(`  ${context.name}: [dry-run] ${relPath}`);
+            }
+            else {
+                writeFileSync(file.path, file.content, 'utf8');
+                messages.push(`  ${context.name}: ${relPath}`);
+            }
+            files++;
+        }
+        const symlinks = generator.createSymlinks(context, rootDir, dryRun);
+        for (const s of symlinks) {
+            messages.push(`  ${context.name}: ${s}`);
+        }
+        let configs = 0;
+        if (context.isRoot) {
+            const configResults = generator.copyConfigFiles(context.contextDir, dryRun);
+            configs = configResults.length;
+            for (const c of configResults) {
+                messages.push(`  ${context.name}: config ${c}`);
+            }
+        }
+        return { configs, files, symlinks: symlinks.length };
+    }
+    async resolveProviders(options) {
+        const allProviders = [...this.ports.generators.keys()];
+        if (options.all)
+            return allProviders;
+        if (options.providers && options.providers.length > 0)
+            return options.providers;
+        return this.ports.prompt.selectProviders(allProviders);
+    }
+}

package/dist/commands/add/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Add extends Command {
+    static args: {
+        scope: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private selectPackageDefinition;
+}

package/dist/commands/add/index.js

@@ -0,0 +1,78 @@
+import select from '@inquirer/select';
+import { Args, Command, Flags } from '@oclif/core';
+import ora from 'ora';
+import { BACK_PACKAGES, FRONT_PACKAGES, } from '../../generator/domain/config.js';
+import { addBackPackage } from '../../generator/handlers/back.handler.js';
+import { addFrontPackage } from '../../generator/handlers/front.handler.js';
+export default class Add extends Command {
+    static args = {
+        scope: Args.string({
+            description: 'Scope where the command will act.',
+            options: ['back', 'front'],
+            required: true,
+        }),
+    };
+    static description = 'Add an Aurora package to an existing project.';
+    static examples = [
+        '<%= config.bin %> add back',
+        '<%= config.bin %> add front',
+        '<%= config.bin %> add back --force',
+    ];
+    static flags = {
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Overwrite files that already exist (default: skip existing files).',
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            default: false,
+            description: 'Report all steps on screen.',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        switch (args.scope) {
+            case 'back': {
+                const definition = await this.selectPackageDefinition(BACK_PACKAGES);
+                const spinner = ora(`Installing ${definition.name} package...`).start();
+                try {
+                    const postInstallMessage = await addBackPackage(definition.packageFolder, flags);
+                    spinner.succeed(`Backend package "${definition.name}" added.`);
+                    if (postInstallMessage)
+                        this.log(postInstallMessage);
+                }
+                catch (error) {
+                    spinner.fail(`Failed to install backend package "${definition.name}": ${error.message}`);
+                    throw error;
+                }
+                break;
+            }
+            case 'front': {
+                const definition = await this.selectPackageDefinition(FRONT_PACKAGES);
+                const spinner = ora(`Installing ${definition.name} package...`).start();
+                try {
+                    const postInstallMessage = await addFrontPackage(definition.packageFolder, flags);
+                    spinner.succeed(`Frontend package "${definition.name}" added.`);
+                    if (postInstallMessage)
+                        this.log(postInstallMessage);
+                }
+                catch (error) {
+                    spinner.fail(`Failed to install frontend package "${definition.name}": ${error.message}`);
+                    throw error;
+                }
+                break;
+            }
+        }
+    }
+    async selectPackageDefinition(packages) {
+        const packageFolder = await select({
+            choices: packages.map((pkg) => ({
+                name: pkg.name,
+                value: pkg.packageFolder,
+            })),
+            message: 'Select a package to add:',
+        });
+        return packages.find((p) => p.packageFolder === packageFolder);
+    }
+}

package/dist/commands/ai/setup.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class AiSetup extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        provider: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        target: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/ai/setup.js

@@ -0,0 +1,66 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { discoverContexts } from '../../ai/domain/reader.js';
+import { createAiSetupPorts } from '../../ai/factories/provider.factory.js';
+import { AiSetupService } from '../../ai/services/ai-setup.service.js';
+export default class AiSetup extends Command {
+    static description = 'Generate AI provider instruction files and skill symlinks from .ai/ source of truth.';
+    static examples = [
+        '<%= config.bin %> ai setup --all',
+        '<%= config.bin %> ai setup --provider claude',
+        '<%= config.bin %> ai setup --provider claude --provider opencode',
+        '<%= config.bin %> ai setup --provider claude --target backend',
+        '<%= config.bin %> ai setup --all --dry-run',
+        '<%= config.bin %> ai setup --all --force',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            default: false,
+            description: 'Configure all available providers',
+        }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what would be generated without writing files',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Overwrite existing files without confirmation',
+        }),
+        provider: Flags.string({
+            char: 'p',
+            description: 'Provider(s) to configure (repeatable)',
+            multiple: true,
+            options: ['claude', 'codex', 'copilot', 'gemini', 'opencode'],
+        }),
+        target: Flags.string({
+            char: 't',
+            description: 'Generate only for a specific target directory',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AiSetup);
+        const rootDir = process.cwd();
+        const contexts = discoverContexts(rootDir, flags.target);
+        if (contexts.length === 0) {
+            this.error('No .ai/CONTEXT.md files found. Create .ai/CONTEXT.md in the project root or target directories.');
+        }
+        this.log(chalk.cyan(`Detected ${contexts.length} context(s): ${contexts.map((c) => c.name).join(', ')}`));
+        const ports = createAiSetupPorts();
+        const service = new AiSetupService(ports);
+        const result = await service.execute({
+            all: flags.all,
+            contexts,
+            dryRun: flags['dry-run'],
+            force: flags.force,
+            providers: flags.provider,
+            rootDir,
+        });
+        for (const msg of result.messages) {
+            this.log(msg);
+        }
+        if (result.filesWritten > 0 || result.symlinksCreated > 0) {
+            this.log(chalk.green('\nDone.'));
+        }
+    }
+}