@ai-coders/context 0.2.1 → 0.3.0

package/dist/index.js

@@ -38,739 +38,1430 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runGenerate = runGenerate;
-exports.runGuidelines = runGuidelines;
 exports.runAnalyze = runAnalyze;
 exports.runUpdate = runUpdate;
 exports.runPreview = runPreview;
+exports.runGuidelines = runGuidelines;
+exports.runInit = runInit;
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
-const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs-extra"));
+const glob_1 = require("glob");
 const dotenv = __importStar(require("dotenv"));
-// Load environment variables from .env file
-dotenv.config();
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const fileMapper_1 = require("./utils/fileMapper");
 const documentationGenerator_1 = require("./generators/documentation/documentationGenerator");
 const agentGenerator_1 = require("./generators/agents/agentGenerator");
-const guidelinesGenerator_1 = require("./generators/guidelines/guidelinesGenerator");
-const incrementalDocumentationGenerator_1 = require("./generators/documentation/incrementalDocumentationGenerator");
+const planGenerator_1 = require("./generators/plans/planGenerator");
+const shared_1 = require("./generators/shared");
 const cliUI_1 = require("./utils/cliUI");
+const i18n_1 = require("./utils/i18n");
 const llmClientFactory_1 = require("./services/llmClientFactory");
-const gitService_1 = require("./utils/gitService");
-const changeAnalyzer_1 = require("./services/changeAnalyzer");
-const tokenEstimator_1 = require("./utils/tokenEstimator");
-const interactiveMode_1 = require("./utils/interactiveMode");
+const guideRegistry_1 = require("./generators/documentation/guideRegistry");
+const agentTypes_1 = require("./generators/agents/agentTypes");
+dotenv.config();
+const initialLocale = (0, i18n_1.detectLocale)(process.argv.slice(2), process.env.AI_CONTEXT_LANG);
+let currentLocale = initialLocale;
+let translateFn = (0, i18n_1.createTranslator)(initialLocale);
+const t = (key, params) => translateFn(key, params);
+const localeLabelKeys = {
+    en: 'prompts.language.option.en',
+    'pt-BR': 'prompts.language.option.pt-BR'
+};
 const program = new commander_1.Command();
-const ui = new cliUI_1.CLIInterface();
+const ui = new cliUI_1.CLIInterface(t);
+const VERSION = '0.3.0';
+const DEFAULT_MODEL = 'x-ai/grok-4-fast:free';
+const DOC_CHOICES = guideRegistry_1.DOCUMENT_GUIDES.map(guide => ({
+    name: `${guide.title} (${guide.key})`,
+    value: guide.key
+}));
+const AGENT_CHOICES = agentTypes_1.AGENT_TYPES.map(agent => ({
+    name: formatAgentLabel(agent),
+    value: agent
+}));
 program
     .name('ai-context')
-    .description('AI-powered CLI for generating codebase documentation and agent prompts')
-    .version('0.1.0');
+    .description(t('cli.description'))
+    .version(VERSION);
+program.option('-l, --lang <locale>', t('global.options.lang'), initialLocale);
 program
     .command('init')
-    .description('Initialize documentation and agent prompts for a repository')
-    .argument('<repo-path>', 'Path to the repository to analyze')
-    .argument('[type]', 'Type to initialize: "docs", "agents", "guidelines", or "both" (default: "both")', 'both')
-    .option('-o, --output <dir>', 'Output directory', './.context')
-    .option('-k, --api-key <key>', 'API key for the LLM provider')
-    .option('-m, --model <model>', 'LLM model to use', 'google/gemini-2.5-flash-preview-05-20')
-    .option('-p, --provider <provider>', 'LLM provider (openrouter, openai, anthropic, gemini, grok)', 'openrouter')
-    .option('--exclude <patterns...>', 'Patterns to exclude from analysis')
-    .option('--include <patterns...>', 'Patterns to include in analysis')
-    .option('-v, --verbose', 'Verbose output')
+    .description(t('commands.init.description'))
+    .argument('<repo-path>', t('commands.init.arguments.repoPath'))
+    .argument('[type]', t('commands.init.arguments.type'), 'both')
+    .option('-o, --output <dir>', t('commands.init.options.output'), './.context')
+    .option('--docs <keys...>', t('commands.init.options.docs'))
+    .option('--agents <keys...>', t('commands.init.options.agents'))
+    .option('--exclude <patterns...>', t('commands.init.options.exclude'))
+    .option('--include <patterns...>', t('commands.init.options.include'))
+    .option('-v, --verbose', t('commands.init.options.verbose'))
     .action(async (repoPath, type, options) => {
     try {
-        // Validate type argument
-        if (!['docs', 'agents', 'guidelines', 'both'].includes(type)) {
-            ui.displayError(`Invalid type "${type}". Must be "docs", "agents", "guidelines", or "both".`);
-            process.exit(1);
-        }
-        // Set options based on type argument
-        if (type === 'docs') {
-            options.docsOnly = true;
-        }
-        else if (type === 'agents') {
-            options.agentsOnly = true;
-        }
-        else if (type === 'guidelines') {
-            options.guidelinesOnly = true;
-        }
-        // For 'both', neither flag is set
-        await runGenerate(repoPath, options);
+        await runInit(repoPath, type, options);
     }
     catch (error) {
-        ui.displayError('Failed to initialize', error);
+        ui.displayError(t('errors.init.scaffoldFailed'), error);
         process.exit(1);
     }
 });
 program
-    .command('update')
-    .description('Update documentation for changed files since last run or specified commit')
-    .argument('<repo-path>', 'Path to the repository to analyze')
-    .option('-o, --output <dir>', 'Output directory', './.context')
-    .option('-k, --api-key <key>', 'API key for the LLM provider')
-    .option('-m, --model <model>', 'LLM model to use', 'google/gemini-2.5-flash-preview-05-20')
-    .option('-p, --provider <provider>', 'LLM provider (openrouter, openai, anthropic, gemini, grok)', 'openrouter')
-    .option('--since <commit>', 'Compare against specific commit/branch (default: last processed commit)')
-    .option('--staged', 'Only process staged files (for pre-commit hooks)')
-    .option('--force', 'Force regeneration even if no changes detected')
-    .option('--exclude <patterns...>', 'Patterns to exclude from analysis')
-    .option('--include <patterns...>', 'Patterns to include in analysis')
-    .option('-v, --verbose', 'Verbose output')
-    .action(async (repoPath, options) => {
+    .command('scaffold')
+    .description(t('commands.scaffold.description'))
+    .argument('<repo-path>', t('commands.init.arguments.repoPath'))
+    .argument('[type]', t('commands.init.arguments.type'), 'both')
+    .option('-o, --output <dir>', t('commands.init.options.output'), './.context')
+    .option('--docs <keys...>', t('commands.init.options.docs'))
+    .option('--agents <keys...>', t('commands.init.options.agents'))
+    .option('--exclude <patterns...>', t('commands.init.options.exclude'))
+    .option('--include <patterns...>', t('commands.init.options.include'))
+    .option('-v, --verbose', t('commands.init.options.verbose'))
+    .action(async (repoPath, type, options) => {
     try {
-        await runUpdate(repoPath, options);
+        await runInit(repoPath, type, options);
     }
     catch (error) {
-        ui.displayError('Failed to update documentation', error);
+        ui.displayError(t('errors.init.scaffoldFailed'), error);
         process.exit(1);
     }
 });
 program
-    .command('analyze')
-    .description('Analyze repository structure without generating content')
-    .argument('<repo-path>', 'Path to the repository to analyze')
-    .option('--exclude <patterns...>', 'Patterns to exclude from analysis')
-    .option('--include <patterns...>', 'Patterns to include in analysis')
-    .option('--input-price <price>', 'Input token price per 1M tokens (e.g., 2.50)', parseFloat)
-    .option('--output-price <price>', 'Output token price per 1M tokens (e.g., 10.00)', parseFloat)
-    .option('-v, --verbose', 'Verbose output')
+    .command('fill')
+    .description(t('commands.fill.description'))
+    .argument('<repo-path>', t('commands.fill.arguments.repoPath'))
+    .option('-o, --output <dir>', t('commands.fill.options.output'), './.context')
+    .option('-k, --api-key <key>', t('commands.fill.options.apiKey'))
+    .option('-m, --model <model>', t('commands.fill.options.model'), DEFAULT_MODEL)
+    .option('-p, --provider <provider>', t('commands.fill.options.provider'))
+    .option('--base-url <url>', t('commands.fill.options.baseUrl'))
+    .option('--prompt <file>', t('commands.fill.options.prompt'), path.join(__dirname, '../prompts/update_scaffold_prompt.md'))
+    .option('--dry-run', t('commands.fill.options.dryRun'), false)
+    .option('--all', t('commands.fill.options.all'), false)
+    .option('--limit <number>', t('commands.fill.options.limit'), (value) => parseInt(value, 10))
+    .option('--docs <keys...>', t('commands.fill.options.docs'))
+    .option('--agents <keys...>', t('commands.fill.options.agents'))
+    .option('--exclude <patterns...>', t('commands.fill.options.exclude'))
+    .option('--include <patterns...>', t('commands.fill.options.include'))
+    .option('-v, --verbose', t('commands.fill.options.verbose'))
     .action(async (repoPath, options) => {
     try {
-        await runAnalyze(repoPath, options);
+        await runLlmFill(repoPath, options);
     }
     catch (error) {
-        ui.displayError('Failed to analyze repository', error);
+        ui.displayError(t('errors.fill.failed'), error);
         process.exit(1);
     }
 });
 program
-    .command('preview')
-    .description('Preview what documentation updates would be made without actually updating')
-    .argument('<repo-path>', 'Path to the repository to analyze')
-    .option('--since <commit>', 'Compare against specific commit/branch (default: last processed commit)')
-    .option('--staged', 'Only analyze staged files (for pre-commit hooks)')
-    .option('--exclude <patterns...>', 'Patterns to exclude from analysis')
-    .option('--include <patterns...>', 'Patterns to include in analysis')
-    .option('--input-price <price>', 'Input token price per 1M tokens (e.g., 2.50)', parseFloat)
-    .option('--output-price <price>', 'Output token price per 1M tokens (e.g., 10.00)', parseFloat)
-    .option('-v, --verbose', 'Verbose output with detailed file lists')
-    .addHelpText('after', `
-Examples:
-  $ ai-context preview ./                     # Preview changes since last run
-  $ ai-context preview ./ --staged           # Preview staged files only
-  $ ai-context preview ./ --since HEAD~3     # Preview changes since 3 commits ago
-  $ ai-context preview ./ --verbose          # Show detailed file change lists
-  $ ai-context preview ./ --input-price 2.50 --output-price 10.00`)
-    .action(async (repoPath, options) => {
-    try {
-        await runPreview(repoPath, options);
+    .command('plan')
+    .description(t('commands.plan.description'))
+    .argument('<plan-name>', t('commands.plan.arguments.planName'))
+    .option('-o, --output <dir>', t('commands.plan.options.output'), './.context')
+    .option('--title <title>', t('commands.plan.options.title'))
+    .option('--summary <text>', t('commands.plan.options.summary'))
+    .option('--agents <types...>', t('commands.plan.options.agents'))
+    .option('--docs <keys...>', t('commands.plan.options.docs'))
+    .option('-f, --force', t('commands.plan.options.force'))
+    .option('--fill', t('commands.plan.options.fill'))
+    .option('-r, --repo <path>', t('commands.plan.options.repo'))
+    .option('-k, --api-key <key>', t('commands.plan.options.apiKey'))
+    .option('-m, --model <model>', t('commands.plan.options.model'), DEFAULT_MODEL)
+    .option('-p, --provider <provider>', t('commands.plan.options.provider'))
+    .option('--base-url <url>', t('commands.plan.options.baseUrl'))
+    .option('--prompt <file>', t('commands.plan.options.prompt'), path.join(__dirname, '../prompts/update_plan_prompt.md'))
+    .option('--dry-run', t('commands.plan.options.dryRun'), false)
+    .option('--include <patterns...>', t('commands.plan.options.include'))
+    .option('--exclude <patterns...>', t('commands.plan.options.exclude'))
+    .option('-v, --verbose', t('commands.plan.options.verbose'))
+    .action(async (planName, rawOptions) => {
+    const agentSelection = parseAgentSelection(rawOptions.agents);
+    if (agentSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.agents.unknown', { values: agentSelection.invalid.join(', ') }));
     }
-    catch (error) {
-        ui.displayError('Failed to preview updates', error);
-        process.exit(1);
+    const docSelection = parseDocSelection(rawOptions.docs);
+    if (docSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.docs.unknown', { values: docSelection.invalid.join(', ') }));
     }
-});
-program
-    .command('guidelines')
-    .description('Generate software development guidelines for a repository')
-    .argument('<repo-path>', 'Path to the repository to analyze')
-    .argument('[categories...]', 'Specific guideline categories to generate (testing, frontend, backend, database, security, performance, code-style, git-workflow, deployment, monitoring, documentation, architecture)')
-    .option('-o, --output <dir>', 'Output directory', './.context')
-    .option('-k, --api-key <key>', 'API key for the LLM provider')
-    .option('-m, --model <model>', 'LLM model to use', 'google/gemini-2.5-flash-preview-05-20')
-    .option('-p, --provider <provider>', 'LLM provider (openrouter, openai, anthropic, gemini, grok)', 'openrouter')
-    .option('--project-type <type>', 'Project type (frontend, backend, fullstack, mobile, desktop, library)', 'auto')
-    .option('--complexity <level>', 'Project complexity (simple, moderate, complex)', 'auto')
-    .option('--team-size <size>', 'Team size (small, medium, large)', 'auto')
-    .option('--include-examples', 'Include code examples in guidelines', false)
-    .option('--include-tools', 'Include tool recommendations in guidelines', false)
-    .option('--exclude <patterns...>', 'Patterns to exclude from analysis')
-    .option('--include <patterns...>', 'Patterns to include in analysis')
-    .option('-v, --verbose', 'Verbose output')
-    .addHelpText('after', `
-Examples:
-  $ ai-context guidelines ./                           # Generate comprehensive guidelines
-  $ ai-context guidelines ./ testing security         # Generate only testing and security guidelines
-  $ ai-context guidelines ./ --project-type frontend  # Generate guidelines for frontend project
-  $ ai-context guidelines ./ --include-examples       # Include code examples in guidelines`)
-    .action(async (repoPath, categories, options) => {
+    const outputDir = path.resolve(rawOptions.output || './.context');
+    if (rawOptions.fill) {
+        try {
+            await scaffoldPlanIfNeeded(planName, outputDir, {
+                title: rawOptions.title,
+                summary: rawOptions.summary,
+                agentSelection,
+                docSelection,
+                force: Boolean(rawOptions.force),
+                verbose: Boolean(rawOptions.verbose)
+            });
+            await runPlanFill(planName, { ...rawOptions, output: outputDir });
+        }
+        catch (error) {
+            ui.displayError(t('errors.plan.fillFailed'), error);
+            process.exit(1);
+        }
+        return;
+    }
+    const generator = new planGenerator_1.PlanGenerator();
+    ui.startSpinner(t('spinner.plan.creating'));
     try {
-        await runGuidelines(repoPath, categories, options);
+        const result = await generator.generatePlan({
+            planName,
+            outputDir,
+            title: rawOptions.title,
+            summary: rawOptions.summary,
+            selectedAgentTypes: agentSelection.explicitNone ? null : agentSelection.selected,
+            selectedDocKeys: docSelection.explicitNone ? null : docSelection.selected,
+            force: Boolean(rawOptions.force),
+            verbose: Boolean(rawOptions.verbose)
+        });
+        ui.updateSpinner(t('spinner.plan.created'), 'success');
+        ui.displaySuccess(t('success.plan.createdAt', { path: chalk_1.default.cyan(result.relativePath) }));
     }
     catch (error) {
-        ui.displayError('Failed to generate guidelines', error);
+        ui.updateSpinner(t('spinner.plan.creationFailed'), 'fail');
+        ui.displayError(t('errors.plan.creationFailed'), error);
         process.exit(1);
     }
+    finally {
+        ui.stopSpinner();
+    }
 });
-async function runGenerate(repoPath, options) {
-    const provider = options.provider || llmClientFactory_1.LLMClientFactory.detectProviderFromModel(options.model);
-    // Get API key from options or environment variables
-    let apiKey = options.apiKey;
-    if (!apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        for (const envVar of envVars) {
-            apiKey = process.env[envVar];
-            if (apiKey)
-                break;
-        }
+async function runInit(repoPath, type, rawOptions) {
+    const resolvedType = resolveScaffoldType(type, rawOptions);
+    const docSelection = parseDocSelection(rawOptions.docs);
+    const agentSelection = parseAgentSelection(rawOptions.agents);
+    if (docSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.docs.unknown', { values: docSelection.invalid.join(', ') }));
     }
-    const cliOptions = {
-        repoPath: path.resolve(repoPath),
-        outputDir: path.resolve(options.output),
-        model: options.model,
-        apiKey,
-        provider,
-        exclude: options.exclude || [],
-        include: options.include,
-        verbose: options.verbose || false
-    };
-    if (!cliOptions.apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        ui.displayError(`${provider.toUpperCase()} API key is required. Set one of these environment variables: ${envVars.join(', ')} or use --api-key option.`);
-        process.exit(1);
+    if (agentSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.agents.unknown', { values: agentSelection.invalid.join(', ') }));
     }
-    // Display welcome message
-    ui.displayWelcome('0.1.0');
-    ui.displayProjectInfo(cliOptions.repoPath, cliOptions.outputDir, cliOptions.model, cliOptions.provider);
-    // Show usage warning for expensive models
-    if (cliOptions.model && ['anthropic/claude-3-opus', 'openai/gpt-4'].includes(cliOptions.model)) {
-        ui.displayUsageWarning(2.0); // Estimate high cost for warning
-    }
-    // Initialize components
-    const fileMapper = new fileMapper_1.FileMapper(cliOptions.exclude);
-    const llmConfig = {
-        apiKey: cliOptions.apiKey,
-        model: cliOptions.model || 'google/gemini-2.5-flash-preview-05-20',
-        provider: cliOptions.provider || 'openrouter'
+    const options = {
+        repoPath: path.resolve(repoPath),
+        outputDir: path.resolve(rawOptions.output || './.context'),
+        include: rawOptions.include,
+        exclude: rawOptions.exclude || [],
+        verbose: rawOptions.verbose || false,
+        scaffoldDocs: shouldGenerateDocs(resolvedType, docSelection),
+        scaffoldAgents: shouldGenerateAgents(resolvedType, agentSelection),
+        selectedDocKeys: docSelection.selected,
+        selectedAgentTypes: agentSelection.selected
     };
-    const llmClient = llmClientFactory_1.LLMClientFactory.createClient(llmConfig);
-    const docGenerator = new documentationGenerator_1.DocumentationGenerator(fileMapper, llmClient);
-    const agentGenerator = new agentGenerator_1.AgentGenerator(fileMapper, llmClient);
-    const guidelinesGenerator = new guidelinesGenerator_1.GuidelinesGenerator(fileMapper, llmClient);
-    // Step 1: Map repository structure
-    ui.displayStep(1, 4, 'Analyzing repository structure');
-    ui.startSpinner('Scanning files and directories...');
-    const repoStructure = await fileMapper.mapRepository(cliOptions.repoPath, cliOptions.include);
-    ui.updateSpinner(`Found ${repoStructure.totalFiles} files in ${repoStructure.directories.length} directories`, 'success');
-    // Display analysis results
-    if (cliOptions.verbose) {
-        ui.displayAnalysisResults(repoStructure.totalFiles, repoStructure.directories.length, ui.formatBytes(repoStructure.totalSize));
-        // Show file distribution
-        const extensions = new Map();
-        repoStructure.files.forEach(file => {
-            const ext = file.extension || 'no-extension';
-            extensions.set(ext, (extensions.get(ext) || 0) + 1);
-        });
-        ui.displayFileTypeDistribution(extensions, repoStructure.totalFiles);
+    if (!options.scaffoldDocs && !options.scaffoldAgents) {
+        ui.displayWarning(t('warnings.scaffold.noneSelected'));
+        return;
     }
+    await ensurePaths(options);
+    ui.displayWelcome(VERSION);
+    ui.displayProjectInfo(options.repoPath, options.outputDir, resolvedType);
+    const fileMapper = new fileMapper_1.FileMapper(options.exclude);
+    ui.displayStep(1, 3, t('steps.init.analyze'));
+    ui.startSpinner(t('spinner.repo.scanning'));
+    const repoStructure = await fileMapper.mapRepository(options.repoPath, options.include);
+    ui.updateSpinner(t('spinner.repo.scanComplete', {
+        fileCount: repoStructure.totalFiles,
+        directoryCount: repoStructure.directories.length
+    }), 'success');
     let docsGenerated = 0;
     let agentsGenerated = 0;
-    let guidelinesGenerated = 0;
-    // Step 2: Generate documentation
-    if (!options.agentsOnly && !options.guidelinesOnly) {
-        ui.displayStep(2, 4, 'Generating documentation');
-        ui.startSpinner('Creating comprehensive documentation...');
-        try {
-            await docGenerator.generateDocumentation(repoStructure, cliOptions.outputDir, {}, // Default config
-            false // We'll handle our own progress display
-            );
-            docsGenerated = 10; // Number of doc files generated (README, STRUCTURE, DEVELOPMENT, API, DEPLOYMENT, TROUBLESHOOTING, configuration + modules)
-            ui.updateSpinner('Documentation generated successfully', 'success');
+    const docGenerator = new documentationGenerator_1.DocumentationGenerator();
+    const agentGenerator = new agentGenerator_1.AgentGenerator();
+    if (options.scaffoldDocs) {
+        ui.displayStep(2, 3, t('steps.init.docs'));
+        ui.startSpinner(t('spinner.docs.creating'));
+        docsGenerated = await docGenerator.generateDocumentation(repoStructure, options.outputDir, { selectedDocs: options.selectedDocKeys }, options.verbose);
+        ui.updateSpinner(t('spinner.docs.created', { count: docsGenerated }), 'success');
+    }
+    if (options.scaffoldAgents) {
+        ui.displayStep(3, options.scaffoldDocs ? 3 : 2, t('steps.init.agents'));
+        ui.startSpinner(t('spinner.agents.creating'));
+        agentsGenerated = await agentGenerator.generateAgentPrompts(repoStructure, options.outputDir, options.selectedAgentTypes, options.verbose);
+        ui.updateSpinner(t('spinner.agents.created', { count: agentsGenerated }), 'success');
+    }
+    ui.displayGenerationSummary(docsGenerated, agentsGenerated);
+    ui.displaySuccess(t('success.scaffold.ready', { path: chalk_1.default.cyan(options.outputDir) }));
+}
+function resolveScaffoldType(type, rawOptions) {
+    const normalized = (type || 'both').toLowerCase();
+    const allowed = ['docs', 'agents', 'both'];
+    if (!allowed.includes(normalized)) {
+        throw new Error(t('errors.init.invalidType', { value: type, allowed: allowed.join(', ') }));
+    }
+    if (rawOptions.docsOnly) {
+        return 'docs';
+    }
+    if (rawOptions.agentsOnly) {
+        return 'agents';
+    }
+    return normalized;
+}
+async function ensurePaths(options) {
+    const exists = await fs.pathExists(options.repoPath);
+    if (!exists) {
+        throw new Error(t('errors.common.repoMissing', { path: options.repoPath }));
+    }
+    await fs.ensureDir(options.outputDir);
+}
+async function runGenerate(repoPath, options) {
+    const type = options?.docsOnly ? 'docs' : options?.agentsOnly ? 'agents' : (options?.type || 'both');
+    await runInit(repoPath, type, {
+        output: options?.output ?? options?.outputDir ?? './.context',
+        include: options?.include,
+        exclude: options?.exclude,
+        verbose: options?.verbose,
+        docs: options?.docs,
+        agents: options?.agents,
+        docsOnly: options?.docsOnly,
+        agentsOnly: options?.agentsOnly
+    });
+}
+async function runAnalyze(..._args) {
+    throw new Error(t('errors.commands.analyzeRemoved'));
+}
+async function runUpdate(..._args) {
+    throw new Error(t('errors.commands.updateRemoved'));
+}
+async function runPreview(..._args) {
+    throw new Error(t('errors.commands.previewRemoved'));
+}
+async function runGuidelines(..._args) {
+    throw new Error(t('errors.commands.guidelinesRemoved'));
+}
+async function resolveLlmConfig(rawOptions, defaults) {
+    const promptPath = path.resolve(rawOptions.prompt || defaults.promptPath);
+    if (!(await fs.pathExists(promptPath))) {
+        throw new Error(t('errors.fill.promptMissing', { path: promptPath }));
+    }
+    const providerEnvMap = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables();
+    const defaultModels = llmClientFactory_1.LLMClientFactory.getDefaultModels();
+    let provider = rawOptions.provider;
+    let model = rawOptions.model;
+    let apiKey = rawOptions.apiKey;
+    if (!apiKey) {
+        if (provider) {
+            for (const envVar of providerEnvMap[provider]) {
+                const value = process.env[envVar];
+                if (value) {
+                    apiKey = value;
+                    break;
+                }
+            }
         }
-        catch (error) {
-            ui.updateSpinner('Failed to generate documentation', 'fail');
-            throw error;
+        else {
+            outer: for (const [prov, envVars] of Object.entries(providerEnvMap)) {
+                for (const envVar of envVars) {
+                    const value = process.env[envVar];
+                    if (value) {
+                        apiKey = value;
+                        provider = prov;
+                        break outer;
+                    }
+                }
+            }
         }
     }
-    // Step 3: Generate agent prompts
-    if (!options.docsOnly && !options.guidelinesOnly) {
-        ui.displayStep(3, 4, 'Generating AI agent prompts');
-        ui.startSpinner('Creating specialized agent prompts...');
-        try {
-            await agentGenerator.generateAgentPrompts(repoStructure, cliOptions.outputDir, false // We'll handle our own progress display
-            );
-            agentsGenerated = 9; // Number of agent files generated
-            ui.updateSpinner('Agent prompts generated successfully', 'success');
+    if (!provider) {
+        if (model) {
+            provider = llmClientFactory_1.LLMClientFactory.detectProviderFromModel(model);
         }
-        catch (error) {
-            ui.updateSpinner('Failed to generate agent prompts', 'fail');
-            throw error;
+        else if (apiKey) {
+            provider = llmClientFactory_1.LLMClientFactory.getProviderFromApiKey(apiKey);
         }
     }
-    // Step 3/4: Generate guidelines (if guidelines-only or as part of comprehensive generation)
-    if (options.guidelinesOnly) {
-        ui.displayStep(3, 4, 'Generating software development guidelines');
-        ui.startSpinner('Creating comprehensive development guidelines...');
-        try {
-            await guidelinesGenerator.generateGuidelines(repoStructure, cliOptions.outputDir, {}, // Default config
-            false // We'll handle our own progress display
-            );
-            guidelinesGenerated = 12; // Number of guideline categories
-            ui.updateSpinner('Guidelines generated successfully', 'success');
+    if (!model) {
+        if (provider === 'openrouter' && process.env.OPENROUTER_MODEL) {
+            model = process.env.OPENROUTER_MODEL;
         }
-        catch (error) {
-            ui.updateSpinner('Failed to generate guidelines', 'fail');
-            throw error;
+        else if (provider && defaultModels[provider]?.length) {
+            model = defaultModels[provider][0];
+        }
+        else {
+            model = defaults.fallbackModel;
+            provider = llmClientFactory_1.LLMClientFactory.detectProviderFromModel(model);
         }
     }
-    // Step 4: Complete
-    ui.displayStep(4, 4, 'Finalizing output');
-    // Get usage statistics from the LLM client
-    const usageStats = llmClient.getUsageStats();
-    ui.displayGenerationSummary(docsGenerated, agentsGenerated, usageStats);
-    if (options.guidelinesOnly && guidelinesGenerated > 0) {
-        ui.displaySuccess(`Guidelines generated! Output saved to: ${cliOptions.outputDir}`);
-    }
-    else {
-        ui.displaySuccess(`Output saved to: ${cliOptions.outputDir}`);
+    if (!provider) {
+        provider = llmClientFactory_1.LLMClientFactory.detectProviderFromModel(model || defaults.fallbackModel);
     }
-}
-async function runGuidelines(repoPath, categories, options) {
-    const provider = options.provider || llmClientFactory_1.LLMClientFactory.detectProviderFromModel(options.model);
-    // Get API key from options or environment variables
-    let apiKey = options.apiKey;
     if (!apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        for (const envVar of envVars) {
-            apiKey = process.env[envVar];
-            if (apiKey)
+        for (const envVar of providerEnvMap[provider]) {
+            const value = process.env[envVar];
+            if (value) {
+                apiKey = value;
                 break;
+            }
         }
     }
-    const cliOptions = {
-        repoPath: path.resolve(repoPath),
-        outputDir: path.resolve(options.output),
-        model: options.model,
-        apiKey,
+    if (!apiKey) {
+        const envVars = providerEnvMap[provider];
+        throw new Error(t('errors.fill.apiKeyMissing', {
+            provider: provider.toUpperCase(),
+            envVars: envVars.join(', ')
+        }));
+    }
+    return {
         provider,
-        exclude: options.exclude || [],
-        include: options.include,
-        verbose: options.verbose || false
+        model: model || defaults.fallbackModel,
+        apiKey,
+        promptPath,
+        baseUrl: rawOptions.baseUrl
     };
-    if (!cliOptions.apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        ui.displayError(`${provider.toUpperCase()} API key is required. Set one of these environment variables: ${envVars.join(', ')} or use --api-key option.`);
-        process.exit(1);
+}
+async function runLlmFill(repoPath, rawOptions) {
+    const resolvedRepo = path.resolve(repoPath);
+    const outputDir = path.resolve(rawOptions.output || './.context');
+    const docsDir = path.join(outputDir, 'docs');
+    const agentsDir = path.join(outputDir, 'agents');
+    await ensureDirectoryExists(docsDir, t('errors.fill.missingDocsScaffold'));
+    await ensureDirectoryExists(agentsDir, t('errors.fill.missingAgentsScaffold'));
+    const docSelection = parseDocSelection(rawOptions.docs);
+    const agentSelection = parseAgentSelection(rawOptions.agents);
+    if (docSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.docs.unknown', { values: docSelection.invalid.join(', ') }));
+    }
+    if (agentSelection.invalid.length > 0) {
+        ui.displayWarning(t('warnings.agents.unknown', { values: agentSelection.invalid.join(', ') }));
     }
-    // Display welcome message
-    ui.displayWelcome('0.1.0');
-    ui.displayProjectInfo(cliOptions.repoPath, cliOptions.outputDir, cliOptions.model, cliOptions.provider);
-    // Show usage warning for expensive models
-    if (cliOptions.model && ['anthropic/claude-3-opus', 'openai/gpt-4'].includes(cliOptions.model)) {
-        ui.displayUsageWarning(1.0); // Lower estimate for guidelines only
-    }
-    // Initialize components
-    const fileMapper = new fileMapper_1.FileMapper(cliOptions.exclude);
-    const llmConfig = {
-        apiKey: cliOptions.apiKey,
-        model: cliOptions.model || 'google/gemini-2.5-flash-preview-05-20',
-        provider: cliOptions.provider || 'openrouter'
+    const { provider, model, apiKey, promptPath, baseUrl } = await resolveLlmConfig(rawOptions, {
+        promptPath: path.join(__dirname, '../prompts/update_scaffold_prompt.md'),
+        fallbackModel: DEFAULT_MODEL
+    });
+    const docAllowlist = docSelection.explicitNone
+        ? new Set()
+        : (0, guideRegistry_1.getDocFilesByKeys)(docSelection.selected);
+    const agentAllowlist = agentSelection.explicitNone
+        ? new Set()
+        : getAgentFilesByTypes(agentSelection.selected);
+    const options = {
+        repoPath: resolvedRepo,
+        outputDir,
+        promptPath,
+        provider,
+        model,
+        apiKey,
+        baseUrl,
+        include: rawOptions.include,
+        exclude: rawOptions.exclude,
+        verbose: rawOptions.verbose || false,
+        dryRun: rawOptions.dryRun || false,
+        processAll: rawOptions.all || false,
+        limit: rawOptions.limit,
+        selectedDocKeys: docSelection.selected,
+        selectedAgentTypes: agentSelection.selected,
+        selectedDocFiles: docAllowlist,
+        selectedAgentFiles: agentAllowlist
     };
-    const llmClient = llmClientFactory_1.LLMClientFactory.createClient(llmConfig);
-    const guidelinesGenerator = new guidelinesGenerator_1.GuidelinesGenerator(fileMapper, llmClient);
-    // Step 1: Map repository structure
-    ui.displayStep(1, 4, 'Analyzing repository structure');
-    ui.startSpinner('Scanning files and directories...');
-    const repoStructure = await fileMapper.mapRepository(cliOptions.repoPath, cliOptions.include);
-    ui.updateSpinner(`Found ${repoStructure.totalFiles} files in ${repoStructure.directories.length} directories`, 'success');
-    // Display analysis results
-    if (cliOptions.verbose) {
-        ui.displayAnalysisResults(repoStructure.totalFiles, repoStructure.directories.length, ui.formatBytes(repoStructure.totalSize));
-    }
-    // Step 2: Analyze codebase for guidelines
-    ui.displayStep(2, 4, 'Analyzing codebase for guideline recommendations');
-    ui.startSpinner('Detecting technologies and patterns...');
+    ui.displayWelcome(VERSION);
+    ui.displayProjectInfo(options.repoPath, options.outputDir, `fill:${options.provider}`);
+    const fileMapper = new fileMapper_1.FileMapper(options.exclude);
+    ui.displayStep(1, 3, t('steps.fill.analyze'));
+    ui.startSpinner(t('spinner.repo.scanning'));
+    const repoStructure = await fileMapper.mapRepository(options.repoPath, options.include);
+    ui.updateSpinner(t('spinner.repo.scanComplete', {
+        fileCount: repoStructure.totalFiles,
+        directoryCount: repoStructure.directories.length
+    }), 'success');
+    const systemPrompt = await fs.readFile(options.promptPath, 'utf-8');
+    const llmClient = llmClientFactory_1.LLMClientFactory.createClient({
+        apiKey: options.apiKey,
+        model: options.model,
+        provider: options.provider,
+        baseUrl: options.baseUrl
+    });
+    const targets = await collectTargets(docsDir, agentsDir, options.processAll, options.limit, options.selectedDocFiles, options.selectedAgentFiles);
+    if (targets.length === 0) {
+        ui.displayWarning(t('warnings.fill.noTargets'));
+        return;
+    }
+    const contextSummary = buildContextSummary(repoStructure);
+    const results = [];
+    ui.displayStep(2, 3, t('steps.fill.processFiles', { count: targets.length, model: options.model }));
+    for (const target of targets) {
+        const relativePath = path.relative(options.outputDir, target.fullPath);
+        ui.startSpinner(t('spinner.fill.processing', { path: relativePath }));
+        try {
+            const currentContent = await fs.readFile(target.fullPath, 'utf-8');
+            const userPrompt = buildUserPrompt(relativePath, currentContent, contextSummary, target.isAgent);
+            const updatedContent = await llmClient.generateText(userPrompt, systemPrompt);
+            if (!updatedContent || !updatedContent.trim()) {
+                ui.updateSpinner(t('spinner.fill.noContent', { path: relativePath }), 'warn');
+                results.push({ file: relativePath, status: 'skipped', message: t('messages.fill.emptyResponse') });
+                continue;
+            }
+            if (options.dryRun) {
+                ui.updateSpinner(t('spinner.fill.dryRunPreview', { path: relativePath }), 'info');
+                console.log(chalk_1.default.gray(`\n${t('messages.fill.previewStart')}`));
+                console.log(updatedContent.trim());
+                console.log(chalk_1.default.gray(`${t('messages.fill.previewEnd')}\n`));
+            }
+            else {
+                await fs.writeFile(target.fullPath, ensureTrailingNewline(updatedContent));
+                ui.updateSpinner(t('spinner.fill.updated', { path: relativePath }), 'success');
+            }
+            results.push({ file: relativePath, status: options.dryRun ? 'skipped' : 'updated' });
+        }
+        catch (error) {
+            ui.updateSpinner(t('spinner.fill.failed', { path: relativePath }), 'fail');
+            results.push({
+                file: relativePath,
+                status: 'failed',
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    ui.displayStep(3, 3, t('steps.fill.summary'));
+    printLlmSummary(llmClient.getUsageStats(), results, options.dryRun);
+    ui.displaySuccess(t('success.fill.completed'));
+}
+async function scaffoldPlanIfNeeded(planName, outputDir, options) {
+    const resolvedOutput = path.resolve(outputDir);
+    const plansDir = path.join(resolvedOutput, 'plans');
+    const normalizedInput = planName.replace(/\.md$/i, '');
+    const slug = shared_1.GeneratorUtils.slugify(normalizedInput);
+    if (!slug) {
+        throw new Error(t('errors.plan.invalidName'));
+    }
+    const planPath = path.join(plansDir, `${slug}.md`);
+    const planExists = await fs.pathExists(planPath);
+    if (planExists && !options.force) {
+        return;
+    }
+    const generator = new planGenerator_1.PlanGenerator();
+    const result = await generator.generatePlan({
+        planName,
+        outputDir: resolvedOutput,
+        title: options.title,
+        summary: options.summary,
+        selectedAgentTypes: options.agentSelection
+            ? options.agentSelection.explicitNone
+                ? null
+                : options.agentSelection.selected
+            : undefined,
+        selectedDocKeys: options.docSelection
+            ? options.docSelection.explicitNone
+                ? null
+                : options.docSelection.selected
+            : undefined,
+        force: Boolean(options.force),
+        verbose: Boolean(options.verbose)
+    });
+    const relativePath = result.relativePath;
+    const message = planExists && options.force
+        ? t('messages.plan.regenerated', { path: relativePath })
+        : t('messages.plan.created', { path: relativePath });
+    ui.displayInfo(t('info.plan.scaffolded.title'), message);
+}
+async function runPlanFill(planName, rawOptions) {
+    const outputDir = path.resolve(rawOptions.output || './.context');
+    const plansDir = path.join(outputDir, 'plans');
+    await ensureDirectoryExists(plansDir, t('errors.plan.missingPlansDir'));
+    const normalizedInput = planName.replace(/\.md$/i, '');
+    const slug = shared_1.GeneratorUtils.slugify(normalizedInput);
+    if (!slug) {
+        throw new Error(t('errors.plan.invalidName'));
+    }
+    const candidateFiles = new Set();
+    candidateFiles.add(path.join(plansDir, `${slug}.md`));
+    if (planName.toLowerCase().endsWith('.md')) {
+        candidateFiles.add(path.join(plansDir, planName));
+    }
+    let planPath;
+    for (const candidate of candidateFiles) {
+        if (await fs.pathExists(candidate)) {
+            planPath = candidate;
+            break;
+        }
+    }
+    if (!planPath) {
+        const expected = Array.from(candidateFiles).map(file => path.relative(process.cwd(), file)).join(' or ');
+        throw new Error(t('errors.plan.notFound', { expected }));
+    }
+    const docsDir = path.join(outputDir, 'docs');
+    const agentsDir = path.join(outputDir, 'agents');
+    await ensureDirectoryExists(docsDir, t('errors.fill.missingDocsScaffold'));
+    await ensureDirectoryExists(agentsDir, t('errors.fill.missingAgentsScaffold'));
+    const repoPath = path.resolve(rawOptions.repo || process.cwd());
+    if (!(await fs.pathExists(repoPath))) {
+        throw new Error(t('errors.common.repoMissing', { path: repoPath }));
+    }
+    const { provider, model, apiKey, promptPath, baseUrl } = await resolveLlmConfig(rawOptions, {
+        promptPath: path.join(__dirname, '../prompts/update_plan_prompt.md'),
+        fallbackModel: DEFAULT_MODEL
+    });
+    const planContent = await fs.readFile(planPath, 'utf-8');
+    const docsIndexPath = path.join(docsDir, 'README.md');
+    const agentsIndexPath = path.join(agentsDir, 'README.md');
+    const docsIndex = (await fs.pathExists(docsIndexPath)) ? await fs.readFile(docsIndexPath, 'utf-8') : undefined;
+    const agentsIndex = (await fs.pathExists(agentsIndexPath)) ? await fs.readFile(agentsIndexPath, 'utf-8') : undefined;
+    const referencedDocs = await loadReferencedMarkdown(docsDir, extractPlanReferences(planContent, 'docs'));
+    const referencedAgents = await loadReferencedMarkdown(agentsDir, extractPlanReferences(planContent, 'agents'));
+    ui.displayWelcome(VERSION);
+    ui.displayProjectInfo(repoPath, outputDir, `plan-fill:${provider}`);
+    const fileMapper = new fileMapper_1.FileMapper(rawOptions.exclude);
+    ui.displayStep(1, 3, t('steps.plan.summary'));
+    ui.startSpinner(t('spinner.planFill.analyzingRepo'));
+    const repoStructure = await fileMapper.mapRepository(repoPath, rawOptions.include);
+    const contextSummary = buildContextSummary(repoStructure);
+    ui.updateSpinner(t('spinner.planFill.summaryReady'), 'success');
+    const systemPrompt = await fs.readFile(promptPath, 'utf-8');
+    const llmClient = llmClientFactory_1.LLMClientFactory.createClient({
+        apiKey,
+        model,
+        provider,
+        baseUrl
+    });
+    const planRelativePath = path.relative(outputDir, planPath);
+    const results = [];
+    ui.displayStep(2, 3, t('steps.plan.update', { path: planRelativePath, model }));
+    ui.startSpinner(t('spinner.planFill.updating', { path: planRelativePath }));
     try {
-        const analysis = await guidelinesGenerator.analyzeCodebaseOnly(repoStructure, cliOptions.verbose);
-        ui.updateSpinner('Technology analysis complete', 'success');
-        if (cliOptions.verbose) {
-            console.log(chalk_1.default.bold('\n📊 Analysis Results:'));
-            console.log(chalk_1.default.gray('─'.repeat(50)));
-            console.log(`${chalk_1.default.blue('Project Type:')} ${analysis.projectType}`);
-            console.log(`${chalk_1.default.blue('Complexity:')} ${analysis.complexity}`);
-            console.log(`${chalk_1.default.blue('Technologies:')} ${analysis.technologies.map(t => t.name).join(', ')}`);
-            console.log(`${chalk_1.default.blue('Recommended Categories:')} ${analysis.recommendedCategories.join(', ')}`);
+        const userPrompt = buildPlanUserPrompt({
+            relativePath: planRelativePath,
+            planContent,
+            contextSummary,
+            docsIndex,
+            agentsIndex,
+            docs: referencedDocs,
+            agents: referencedAgents
+        });
+        const updatedContent = await llmClient.generateText(userPrompt, systemPrompt);
+        if (!updatedContent || !updatedContent.trim()) {
+            ui.updateSpinner(t('spinner.planFill.noContent'), 'warn');
+            results.push({ file: planRelativePath, status: 'skipped', message: t('messages.fill.emptyResponse') });
+        }
+        else if (rawOptions.dryRun) {
+            ui.updateSpinner(t('spinner.planFill.dryRun'), 'info');
+            console.log(chalk_1.default.gray(`\n${t('messages.fill.previewStart')}`));
+            console.log(updatedContent.trim());
+            console.log(chalk_1.default.gray(`${t('messages.fill.previewEnd')}\n`));
+            results.push({ file: planRelativePath, status: 'skipped', message: 'dry-run' });
+        }
+        else {
+            await fs.writeFile(planPath, ensureTrailingNewline(updatedContent));
+            ui.updateSpinner(t('spinner.planFill.updated', { path: planRelativePath }), 'success');
+            results.push({ file: planRelativePath, status: 'updated' });
         }
     }
     catch (error) {
-        ui.updateSpinner('Failed to analyze codebase', 'fail');
-        throw error;
+        ui.updateSpinner(t('spinner.planFill.failed'), 'fail');
+        results.push({
+            file: planRelativePath,
+            status: 'failed',
+            message: error instanceof Error ? error.message : String(error)
+        });
     }
-    // Step 3: Generate guidelines
-    ui.displayStep(3, 4, 'Generating software development guidelines');
-    ui.startSpinner('Creating comprehensive development guidelines...');
-    try {
-        // Build configuration from CLI options
-        const guidelineConfig = {};
-        // Set specific categories if provided
-        if (categories && categories.length > 0) {
-            // Validate categories
-            const validCategories = ['testing', 'frontend', 'backend', 'database', 'security', 'performance', 'code-style', 'git-workflow', 'deployment', 'monitoring', 'documentation', 'architecture'];
-            const invalidCategories = categories.filter(cat => !validCategories.includes(cat));
-            if (invalidCategories.length > 0) {
-                ui.displayError(`Invalid categories: ${invalidCategories.join(', ')}. Valid categories are: ${validCategories.join(', ')}`);
-                process.exit(1);
+    finally {
+        ui.stopSpinner();
+    }
+    ui.displayStep(3, 3, t('steps.plan.summaryResults'));
+    printLlmSummary(llmClient.getUsageStats(), results, Boolean(rawOptions.dryRun));
+    ui.displaySuccess(t('success.plan.filled'));
+}
+async function ensureDirectoryExists(dir, message) {
+    const exists = await fs.pathExists(dir);
+    if (!exists) {
+        throw new Error(message);
+    }
+}
+async function collectTargets(docsDir, agentsDir, processAll, limit, docAllowlist, agentAllowlist) {
+    const docFiles = await (0, glob_1.glob)('**/*.md', { cwd: docsDir, absolute: true });
+    const agentFiles = await (0, glob_1.glob)('**/*.md', { cwd: agentsDir, absolute: true });
+    const candidates = [...docFiles, ...agentFiles];
+    const targets = [];
+    for (const fullPath of candidates) {
+        const content = await fs.readFile(fullPath, 'utf-8');
+        const hasMarkers = /<!--\s*ai-task:/.test(content) || /<!--\s*ai-slot:/.test(content) || /TODO/.test(content);
+        const isAgent = fullPath.includes(`${path.sep}agents${path.sep}`);
+        const fileName = path.basename(fullPath);
+        if (isAgent) {
+            if (agentAllowlist && !agentAllowlist.has(fileName)) {
+                continue;
+            }
+        }
+        else {
+            if (docAllowlist && !docAllowlist.has(fileName)) {
+                continue;
             }
-            guidelineConfig.categories = categories;
         }
-        // Set project configuration from CLI options
-        if (options.projectType && options.projectType !== 'auto') {
-            guidelineConfig.projectType = options.projectType;
+        const explicitSelection = isAgent ? !!agentAllowlist : !!docAllowlist;
+        const shouldInclude = processAll ||
+            hasMarkers ||
+            (explicitSelection && (isAgent ? agentAllowlist.has(fileName) : docAllowlist.has(fileName)));
+        if (!shouldInclude) {
+            continue;
+        }
+        targets.push({ fullPath, hasMarkers, isAgent });
+        if (limit && targets.length >= limit) {
+            break;
+        }
+    }
+    return targets;
+}
+function buildContextSummary(repoStructure) {
+    const directories = new Set();
+    repoStructure.directories.forEach(dir => {
+        const [first] = dir.relativePath.split(/[\\/]/).filter(Boolean);
+        if (first) {
+            directories.add(first);
         }
-        if (options.complexity && options.complexity !== 'auto') {
-            guidelineConfig.complexity = options.complexity;
+    });
+    const topDirs = Array.from(directories).sort().slice(0, 12);
+    const totalSizeMb = (repoStructure.totalSize / (1024 * 1024)).toFixed(2);
+    return [
+        `Top-level directories: ${topDirs.length ? topDirs.join(', ') : 'n/a'}`,
+        `Total files scanned: ${repoStructure.totalFiles}`,
+        `Repository size (approx.): ${totalSizeMb} MB`
+    ].join('\n');
+}
+function buildUserPrompt(relativePath, currentContent, contextSummary, isAgent) {
+    const guidance = [
+        '- Preserve YAML front matter and existing `ai-task` sections.',
+        '- Replace TODOs and resolve `ai-slot` placeholders with concrete information.',
+        '- Ensure success criteria in the front matter are satisfied.',
+        '- Return only the full updated Markdown for this file.'
+    ];
+    if (isAgent) {
+        guidance.push('- Keep agent responsibilities, best practices, and documentation touchpoints aligned with the latest docs.');
+    }
+    else {
+        guidance.push('- Maintain accurate cross-links between docs and referenced resources.');
+    }
+    return [
+        `Target file: ${relativePath}`,
+        'Repository summary:',
+        contextSummary,
+        '',
+        'Guidance:',
+        ...guidance,
+        '',
+        'Current content:',
+        '<file>',
+        currentContent,
+        '</file>'
+    ].join('\n');
+}
+function buildPlanUserPrompt(context) {
+    const guidance = [
+        '- Preserve the YAML front matter and `ai-task` wrapper already in the plan.',
+        '- Replace TODOs with concrete steps that align with the provided documentation and agent playbooks.',
+        '- Keep the Agent Lineup and Documentation Touchpoints tables accurate and sorted.',
+        '- Ensure stages include owners, deliverables, and evidence expectations.',
+        '- Return only the full updated Markdown for this plan.'
+    ];
+    const sections = [
+        `Target file: ${context.relativePath}`,
+        'Repository summary:',
+        context.contextSummary,
+        '',
+        'Guidance:',
+        ...guidance,
+        '',
+        'Current plan:',
+        '<plan>',
+        context.planContent,
+        '</plan>'
+    ];
+    if (context.docsIndex) {
+        sections.push('', 'Documentation index (docs/README.md):', '<docs-index>', context.docsIndex, '</docs-index>');
+    }
+    if (context.agentsIndex) {
+        sections.push('', 'Agent handbook (agents/README.md):', '<agents-index>', context.agentsIndex, '</agents-index>');
+    }
+    context.docs.forEach(doc => {
+        sections.push('', `Referenced documentation (${doc.path}):`, '<doc>', doc.content, '</doc>');
+    });
+    context.agents.forEach(agent => {
+        sections.push('', `Referenced agent playbook (${agent.path}):`, '<agent>', agent.content, '</agent>');
+    });
+    return sections.join('\n');
+}
+function extractPlanReferences(content, type) {
+    const regex = type === 'docs'
+        ? /\]\(\.\.\/docs\/([^)#]+)(?:#[^)]*)?\)/g
+        : /\]\(\.\.\/agents\/([^)#]+)(?:#[^)]*)?\)/g;
+    const references = [];
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const rawPath = match[1].trim();
+        if (!rawPath)
+            continue;
+        const normalized = rawPath.replace(/^\.\//, '').replace(/#.*$/, '');
+        if (!normalized || normalized.includes('..'))
+            continue;
+        if (!references.includes(normalized)) {
+            references.push(normalized);
         }
-        if (options.teamSize && options.teamSize !== 'auto') {
-            guidelineConfig.teamSize = options.teamSize;
+    }
+    return references;
+}
+async function loadReferencedMarkdown(baseDir, fileNames) {
+    const results = [];
+    const seen = new Set();
+    for (const name of fileNames) {
+        const cleanName = name.replace(/#.*$/, '');
+        if (!cleanName || seen.has(cleanName)) {
+            continue;
         }
-        // Set feature flags
-        if (options.includeExamples) {
-            guidelineConfig.includeExamples = true;
+        const normalized = path.normalize(cleanName).replace(/^\.\//, '');
+        if (normalized.includes('..')) {
+            continue;
         }
-        if (options.includeTools) {
-            guidelineConfig.includeTools = true;
+        const fullPath = path.join(baseDir, normalized);
+        if (!(await fs.pathExists(fullPath))) {
+            continue;
         }
-        await guidelinesGenerator.generateGuidelines(repoStructure, cliOptions.outputDir, guidelineConfig, cliOptions.verbose);
-        ui.updateSpinner('Guidelines generated successfully', 'success');
+        const content = await fs.readFile(fullPath, 'utf-8');
+        results.push({ path: normalized, content });
+        seen.add(cleanName);
     }
-    catch (error) {
-        ui.updateSpinner('Failed to generate guidelines', 'fail');
-        throw error;
-    }
-    // Step 4: Complete
-    ui.displayStep(4, 4, 'Finalizing output');
-    // Get usage statistics from the LLM client
-    const usageStats = llmClient.getUsageStats();
-    ui.displayGenerationSummary(0, 0, usageStats); // No docs or agents generated
-    const guidelinesPath = path.join(cliOptions.outputDir, 'guidelines');
-    ui.displaySuccess(`Guidelines generated! Output saved to: ${guidelinesPath}`);
-    // Display helpful next steps
-    console.log(chalk_1.default.bold('\n💡 Next Steps:'));
+    return results;
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith('\n') ? content : `${content}\n`;
+}
+function printLlmSummary(usage, results, dryRun) {
+    const updated = results.filter(r => r.status === 'updated').length;
+    const skipped = results.filter(r => r.status === 'skipped').length;
+    const failed = results.filter(r => r.status === 'failed');
+    console.log('\n' + chalk_1.default.bold('📄 LLM Fill Summary'));
     console.log(chalk_1.default.gray('─'.repeat(50)));
-    console.log(`${chalk_1.default.blue('1. Review:')} Check the generated guidelines in ${guidelinesPath}`);
-    console.log(`${chalk_1.default.blue('2. Customize:')} Modify guidelines to match your team's specific needs`);
-    console.log(`${chalk_1.default.blue('3. Share:')} Distribute guidelines to your development team`);
-    console.log(`${chalk_1.default.blue('4. Integrate:')} Include guidelines in your project documentation`);
-}
-async function runAnalyze(repoPath, options) {
-    const resolvedPath = path.resolve(repoPath);
-    // Display welcome
-    ui.displayWelcome('0.1.0');
-    ui.startSpinner('Analyzing repository structure...');
-    const fileMapper = new fileMapper_1.FileMapper(options.exclude || []);
-    const repoStructure = await fileMapper.mapRepository(resolvedPath, options.include);
-    ui.stopSpinner();
-    // Display analysis results
-    ui.displayAnalysisResults(repoStructure.totalFiles, repoStructure.directories.length, ui.formatBytes(repoStructure.totalSize));
-    // File type distribution
-    const extensions = new Map();
-    repoStructure.files.forEach(file => {
-        const ext = file.extension || 'no-extension';
-        extensions.set(ext, (extensions.get(ext) || 0) + 1);
-    });
-    ui.displayFileTypeDistribution(extensions, repoStructure.totalFiles);
-    // Directory structure (top level)
-    const topDirs = repoStructure.directories
-        .filter(dir => !dir.relativePath.includes('/'))
-        .slice(0, 10);
-    if (topDirs.length > 0) {
-        console.log(chalk_1.default.bold('\n📂 Top-level Directories:'));
+    console.log(`${chalk_1.default.blue('Updated files:')} ${chalk_1.default.white(updated.toString())}`);
+    console.log(`${chalk_1.default.blue('Skipped files:')} ${chalk_1.default.white(skipped.toString())}${dryRun ? chalk_1.default.gray(' (dry run)') : ''}`);
+    console.log(`${chalk_1.default.blue('Failures:')} ${failed.length}`);
+    if (usage.totalCalls > 0) {
         console.log(chalk_1.default.gray('─'.repeat(50)));
-        topDirs.forEach(dir => {
-            console.log(`  ${chalk_1.default.blue('▸')} ${chalk_1.default.white(dir.relativePath)}`);
+        console.log(`${chalk_1.default.blue('LLM calls:')} ${usage.totalCalls}`);
+        console.log(`${chalk_1.default.blue('Prompt tokens:')} ${usage.totalPromptTokens}`);
+        console.log(`${chalk_1.default.blue('Completion tokens:')} ${usage.totalCompletionTokens}`);
+        console.log(`${chalk_1.default.blue('Estimated cost:')} ${usage.estimatedCost.toFixed(4)}`);
+        console.log(`${chalk_1.default.blue('Model:')} ${usage.model}`);
+    }
+    if (failed.length > 0) {
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        failed.forEach(f => {
+            console.log(`${chalk_1.default.red('✖')} ${chalk_1.default.white(f.file)} — ${chalk_1.default.gray(f.message || 'Unknown error')}`);
         });
     }
-    // Token estimation for full documentation generation
-    ui.startSpinner('Estimating token usage for full documentation generation...');
-    // Create pricing if provided (optional for analyze command)
-    let pricing = undefined;
-    if (options.inputPrice !== undefined && options.outputPrice !== undefined) {
-        pricing = {
-            input: options.inputPrice,
-            output: options.outputPrice
-        };
+}
+function parseDocSelection(input) {
+    if (input === undefined) {
+        return { selected: undefined, invalid: [], provided: false, explicitNone: false };
     }
-    else if (options.inputPrice !== undefined || options.outputPrice !== undefined) {
-        ui.displayError('Pricing requires both options: --input-price and --output-price');
-        process.exit(1);
+    if (Array.isArray(input) && input.length === 0) {
+        return { selected: [], invalid: [], provided: true, explicitNone: true };
     }
-    const tokenEstimator = new tokenEstimator_1.TokenEstimator(fileMapper, pricing);
-    const tokenEstimate = await tokenEstimator.estimateTokensForFullGeneration(repoStructure);
-    ui.stopSpinner();
-    console.log(tokenEstimator.formatTokenEstimate(tokenEstimate));
-    ui.displaySuccess('Analysis complete!');
+    const values = toStringArray(input);
+    const normalized = values.map(value => value.toLowerCase().replace(/\.md$/, ''));
+    const valid = Array.from(new Set(normalized.filter(key => guideRegistry_1.DOCUMENT_GUIDE_KEYS.includes(key))));
+    const invalid = normalized.filter(key => !guideRegistry_1.DOCUMENT_GUIDE_KEYS.includes(key));
+    if (values.length > 0 && valid.length === 0 && invalid.length > 0) {
+        return { selected: undefined, invalid, provided: true, explicitNone: false };
+    }
+    return { selected: valid.length > 0 ? valid : undefined, invalid, provided: true, explicitNone: false };
 }
-async function runUpdate(repoPath, options) {
-    const provider = options.provider || llmClientFactory_1.LLMClientFactory.detectProviderFromModel(options.model);
-    // Get API key from options or environment variables
-    let apiKey = options.apiKey;
-    if (!apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        for (const envVar of envVars) {
-            apiKey = process.env[envVar];
-            if (apiKey)
-                break;
+function parseAgentSelection(input) {
+    if (input === undefined) {
+        return { selected: undefined, invalid: [], provided: false, explicitNone: false };
+    }
+    if (Array.isArray(input) && input.length === 0) {
+        return { selected: [], invalid: [], provided: true, explicitNone: true };
+    }
+    const values = toStringArray(input);
+    const normalized = values.map(value => value.toLowerCase().replace(/\.md$/, ''));
+    const allowed = new Set(agentTypes_1.AGENT_TYPES);
+    const valid = Array.from(new Set(normalized.filter(value => allowed.has(value))));
+    const invalid = normalized.filter(value => !allowed.has(value));
+    if (values.length > 0 && valid.length === 0 && invalid.length > 0) {
+        return { selected: undefined, invalid, provided: true, explicitNone: false };
+    }
+    return { selected: valid.length > 0 ? valid : undefined, invalid, provided: true, explicitNone: false };
+}
+function shouldGenerateDocs(resolvedType, selection) {
+    if (selection.explicitNone) {
+        return false;
+    }
+    if (resolvedType === 'agents') {
+        return false;
+    }
+    if (!selection.provided) {
+        return resolvedType === 'docs' || resolvedType === 'both';
+    }
+    if (selection.selected && selection.selected.length === 0) {
+        return false;
+    }
+    return resolvedType === 'docs' || resolvedType === 'both';
+}
+function shouldGenerateAgents(resolvedType, selection) {
+    if (selection.explicitNone) {
+        return false;
+    }
+    if (resolvedType === 'docs') {
+        return false;
+    }
+    if (!selection.provided) {
+        return resolvedType === 'agents' || resolvedType === 'both';
+    }
+    if (selection.selected && selection.selected.length === 0) {
+        return false;
+    }
+    return resolvedType === 'agents' || resolvedType === 'both';
+}
+function toStringArray(input) {
+    if (Array.isArray(input)) {
+        return input.map(item => item.toString().trim()).filter(Boolean);
+    }
+    if (input === null || input === undefined) {
+        return [];
+    }
+    return input
+        .toString()
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+function formatAgentLabel(value) {
+    return value
+        .split('-')
+        .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+async function runInteractive() {
+    const { locale } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'locale',
+            message: t('prompts.language.select'),
+            default: currentLocale,
+            choices: i18n_1.SUPPORTED_LOCALES.map(option => ({
+                value: option,
+                name: t(localeLabelKeys[option])
+            }))
         }
+    ]);
+    const normalizedLocale = (0, i18n_1.normalizeLocale)(locale);
+    currentLocale = normalizedLocale;
+    translateFn = (0, i18n_1.createTranslator)(normalizedLocale);
+    ui.displayWelcome(VERSION);
+    const { action } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: t('prompts.main.action'),
+            choices: [
+                { name: t('prompts.main.choice.scaffold'), value: 'scaffold' },
+                { name: t('prompts.main.choice.fill'), value: 'fill' },
+                { name: t('prompts.main.choice.plan'), value: 'plan' }
+            ]
+        }
+    ]);
+    if (action === 'scaffold') {
+        await runInteractiveScaffold();
     }
-    const cliOptions = {
-        repoPath: path.resolve(repoPath),
-        outputDir: path.resolve(options.output),
-        model: options.model,
-        apiKey,
-        provider,
-        exclude: options.exclude || [],
-        include: options.include,
-        verbose: options.verbose || false,
-        since: options.since,
-        staged: options.staged || false,
-        force: options.force || false
-    };
-    if (!cliOptions.apiKey) {
-        const envVars = llmClientFactory_1.LLMClientFactory.getEnvironmentVariables()[provider];
-        ui.displayError(`${provider.toUpperCase()} API key is required. Set one of these environment variables: ${envVars.join(', ')} or use --api-key option.`);
-        process.exit(1);
+    else if (action === 'fill') {
+        await runInteractiveLlmFill();
     }
-    // Initialize git service
-    const gitService = new gitService_1.GitService(cliOptions.repoPath);
-    if (!gitService.isGitRepository()) {
-        ui.displayError('This command requires a Git repository. Initialize git first or use the generate command instead.');
-        process.exit(1);
+    else {
+        await runInteractivePlan();
     }
-    // Check if context has been initialized
-    if (!gitService.hasContextBeenInitialized(cliOptions.outputDir)) {
-        ui.displayError('No documentation context found. You should run analyze and init before updating.');
-        console.log(chalk_1.default.bold('\n💡 Getting Started:'));
-        console.log(chalk_1.default.gray('─'.repeat(50)));
-        console.log(`${chalk_1.default.blue('1. Analyze:')} ai-context analyze ${cliOptions.repoPath}`);
-        console.log(`${chalk_1.default.blue('2. Initialize:')} ai-context init ${cliOptions.repoPath}`);
-        console.log(`${chalk_1.default.blue('3. Update:')} ai-context update ${cliOptions.repoPath}`);
-        console.log(chalk_1.default.gray('─'.repeat(50)));
-        console.log(chalk_1.default.gray('The analyze command shows token estimates and costs.'));
-        console.log(chalk_1.default.gray('The init command creates the initial documentation.'));
-        console.log(chalk_1.default.gray('The update command incrementally updates existing documentation.'));
-        process.exit(1);
+}
+async function runInteractiveScaffold() {
+    const { repoPath } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'repoPath',
+            message: t('prompts.scaffold.repoPath'),
+            default: process.cwd()
+        }
+    ]);
+    const resolvedRepo = path.resolve(repoPath.trim() || '.');
+    const defaultOutput = path.resolve(resolvedRepo, '.context');
+    const { outputDir } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'outputDir',
+            message: t('commands.init.options.output'),
+            default: defaultOutput
+        }
+    ]);
+    const { includeDocs } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeDocs',
+            message: t('prompts.scaffold.includeDocs'),
+            default: true
+        }
+    ]);
+    let selectedDocs;
+    if (includeDocs) {
+        const { docs } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'docs',
+                message: t('prompts.scaffold.selectDocs'),
+                choices: DOC_CHOICES,
+                default: DOC_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedDocs = docs;
     }
-    // Display welcome message
-    ui.displayWelcome('0.1.0');
-    ui.displayProjectInfo(cliOptions.repoPath, cliOptions.outputDir, cliOptions.model, cliOptions.provider);
-    // Initialize components
-    const fileMapper = new fileMapper_1.FileMapper(cliOptions.exclude);
-    const llmConfig = {
-        apiKey: cliOptions.apiKey,
-        model: cliOptions.model || 'google/gemini-2.5-flash-preview-05-20',
-        provider: cliOptions.provider || 'openrouter'
-    };
-    const llmClient = llmClientFactory_1.LLMClientFactory.createClient(llmConfig);
-    const incrementalGenerator = new incrementalDocumentationGenerator_1.IncrementalDocumentationGenerator(fileMapper, llmClient, gitService);
-    // Step 1: Analyze repository structure
-    ui.displayStep(1, 4, 'Analyzing repository structure');
-    ui.startSpinner('Scanning files and directories...');
-    const repoStructure = await fileMapper.mapRepository(cliOptions.repoPath, cliOptions.include);
-    ui.updateSpinner(`Found ${repoStructure.totalFiles} files in ${repoStructure.directories.length} directories`, 'success');
-    // Step 2: Detect changes
-    ui.displayStep(2, 4, 'Detecting changes');
-    // Display commit tracking info in verbose mode
-    if (cliOptions.verbose) {
-        gitService.displayCommitTrackingInfo(true);
-    }
-    ui.startSpinner('Analyzing git changes...');
-    let changes;
-    if (cliOptions.staged) {
-        // For pre-commit hooks - analyze only staged files
-        changes = gitService.getStagedChanges();
-    }
-    else if (cliOptions.since) {
-        // Compare against specific commit
-        changes = gitService.getChangedFiles(cliOptions.since);
+    else {
+        selectedDocs = [];
+    }
+    const { includeAgents } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeAgents',
+            message: t('prompts.scaffold.includeAgents'),
+            default: true
+        }
+    ]);
+    let selectedAgents;
+    if (includeAgents) {
+        const { agents } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'agents',
+                message: t('prompts.scaffold.selectAgents'),
+                choices: AGENT_CHOICES,
+                default: AGENT_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedAgents = agents;
     }
     else {
-        // Compare against last processed commit
-        changes = gitService.getChangedFiles();
+        selectedAgents = [];
     }
-    const totalChanges = changes.added.length + changes.modified.length + changes.deleted.length + changes.renamed.length;
-    if (totalChanges === 0 && !cliOptions.force) {
-        ui.updateSpinner('No changes detected since last run', 'info');
-        ui.displaySuccess('Documentation is up to date!');
+    if ((selectedDocs?.length ?? 0) === 0 && (selectedAgents?.length ?? 0) === 0) {
+        ui.displayWarning(t('warnings.interactive.nothingSelected'));
         return;
     }
-    ui.updateSpinner(`Found ${totalChanges} changed files`, 'success');
-    // Step 3: Update documentation
-    ui.displayStep(3, 4, 'Updating documentation');
-    ui.startSpinner('Processing changed files...');
-    const result = await incrementalGenerator.updateDocumentation(repoStructure, cliOptions.outputDir, changes, cliOptions.verbose);
-    ui.updateSpinner(`Updated ${result.updated} files, removed ${result.removed} files`, 'success');
-    // Step 4: Save state (only if documentation was actually updated)
-    ui.displayStep(4, 4, 'Saving state');
-    const currentCommit = gitService.getCurrentCommit();
-    if (result.updated > 0 || result.removed > 0) {
-        gitService.saveState(currentCommit);
-        if (cliOptions.verbose) {
-            console.log(chalk_1.default.gray(`State saved: tracking commit ${currentCommit.substring(0, 8)}`));
+    const { verbose } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'verbose',
+            message: t('prompts.common.verbose'),
+            default: false
+        }
+    ]);
+    const scaffoldType = determineScaffoldType(selectedDocs, selectedAgents);
+    await runInit(resolvedRepo, scaffoldType, {
+        output: outputDir,
+        docs: selectedDocs,
+        agents: selectedAgents,
+        verbose
+    });
+}
+function determineScaffoldType(docSelection, agentSelection) {
+    const docsSelected = docSelection === undefined ? true : docSelection.length > 0;
+    const agentsSelected = agentSelection === undefined ? true : agentSelection.length > 0;
+    if (docsSelected && agentsSelected)
+        return 'both';
+    if (docsSelected)
+        return 'docs';
+    return 'agents';
+}
+async function runInteractiveLlmFill() {
+    const { repoPath } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'repoPath',
+            message: t('prompts.fill.repoPath'),
+            default: process.cwd()
+        }
+    ]);
+    const resolvedRepo = path.resolve(repoPath.trim() || '.');
+    const defaultOutput = path.resolve(resolvedRepo, '.context');
+    const defaultPrompt = path.resolve(process.cwd(), 'prompts/update_scaffold_prompt.md');
+    const { outputDir, promptPath } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'outputDir',
+            message: t('commands.fill.options.output'),
+            default: defaultOutput
+        },
+        {
+            type: 'input',
+            name: 'promptPath',
+            message: t('prompts.fill.promptPath'),
+            default: defaultPrompt
+        }
+    ]);
+    const { dryRun, processAll } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'dryRun',
+            message: t('prompts.fill.dryRun'),
+            default: true
+        },
+        {
+            type: 'confirm',
+            name: 'processAll',
+            message: t('prompts.fill.processAll'),
+            default: false
+        }
+    ]);
+    const { limit } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'limit',
+            message: t('prompts.fill.limit'),
+            filter: (value) => value.trim()
+        }
+    ]);
+    const limitValue = limit ? parseInt(limit, 10) : undefined;
+    const parsedLimit = Number.isNaN(limitValue) ? undefined : limitValue;
+    const { includeDocs } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeDocs',
+            message: t('prompts.fill.includeDocs'),
+            default: true
         }
+    ]);
+    let selectedDocs;
+    if (includeDocs) {
+        const { docs } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'docs',
+                message: t('prompts.fill.selectDocs'),
+                choices: DOC_CHOICES,
+                default: DOC_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedDocs = docs;
     }
     else {
-        if (cliOptions.verbose) {
-            console.log(chalk_1.default.gray('No documentation changes made, state not updated'));
-        }
+        selectedDocs = [];
     }
-    // Display summary of changed files
-    if (result.updatedFiles.length > 0 || result.removedFiles.length > 0) {
-        console.log(chalk_1.default.bold('\n📄 Documentation Files Changed:'));
-        console.log(chalk_1.default.gray('─'.repeat(50)));
-        if (result.updatedFiles.length > 0) {
-            console.log(chalk_1.default.green('\n✅ Updated/Created:'));
-            result.updatedFiles.forEach(file => {
-                console.log(`  ${chalk_1.default.green('●')} ${file}`);
-            });
+    const { includeAgents } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeAgents',
+            message: t('prompts.fill.includeAgents'),
+            default: true
         }
-        if (result.removedFiles.length > 0) {
-            console.log(chalk_1.default.red('\n🗑️  Removed:'));
-            result.removedFiles.forEach(file => {
-                console.log(`  ${chalk_1.default.red('●')} ${file}`);
-            });
-        }
-        console.log(chalk_1.default.gray('─'.repeat(50)));
+    ]);
+    let selectedAgents;
+    if (includeAgents) {
+        const { agents } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'agents',
+                message: t('prompts.fill.selectAgents'),
+                choices: AGENT_CHOICES,
+                default: AGENT_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedAgents = agents;
     }
-    // Get usage statistics
-    const usageStats = llmClient.getUsageStats();
-    ui.displayGenerationSummary(result.updated, 0, usageStats, true);
-    ui.displaySuccess(`Documentation updated! Processed ${result.updated} files.`);
-}
-async function runPreview(repoPath, options) {
-    const resolvedPath = path.resolve(repoPath);
-    // Display welcome
-    ui.displayWelcome('0.1.0');
-    ui.startSpinner('Initializing analysis...');
-    // Initialize services
-    const fileMapper = new fileMapper_1.FileMapper(options.exclude || []);
-    const gitService = new gitService_1.GitService(resolvedPath);
-    const changeAnalyzer = new changeAnalyzer_1.ChangeAnalyzer(gitService, fileMapper);
-    // Check if it's a git repository
-    if (!gitService.isGitRepository()) {
-        ui.updateSpinner('Not a git repository', 'fail');
-        ui.displayError('The specified path is not a git repository. Preview requires git tracking.');
-        process.exit(1);
+    else {
+        selectedAgents = [];
     }
-    // Check if context has been initialized
-    const outputDir = path.resolve(options.output || './.context');
-    if (!gitService.hasContextBeenInitialized(outputDir)) {
-        ui.updateSpinner('Context not initialized', 'fail');
-        ui.displayError('No documentation context found. You should run analyze and init before previewing changes to update.');
-        console.log(chalk_1.default.bold('\n💡 Getting Started:'));
-        console.log(chalk_1.default.gray('─'.repeat(50)));
-        console.log(`${chalk_1.default.blue('1. Analyze:')} ai-context analyze ${repoPath}`);
-        console.log(`${chalk_1.default.blue('2. Initialize:')} ai-context init ${repoPath}`);
-        console.log(`${chalk_1.default.blue('3. Preview:')} ai-context preview ${repoPath}`);
-        console.log(chalk_1.default.gray('─'.repeat(50)));
-        console.log(chalk_1.default.gray('The analyze command shows token estimates and costs.'));
-        console.log(chalk_1.default.gray('The init command creates the initial documentation.'));
-        console.log(chalk_1.default.gray('The preview command shows what would change in updates.'));
-        process.exit(1);
+    if ((selectedDocs?.length ?? 0) === 0 && (selectedAgents?.length ?? 0) === 0) {
+        ui.displayWarning(t('warnings.interactive.nothingSelected'));
+        return;
     }
-    ui.updateSpinner('Mapping repository structure...');
-    // Map repository structure
-    const repoStructure = await fileMapper.mapRepository(resolvedPath, options.include);
-    ui.updateSpinner('Analyzing changes...');
-    // Detect changes
-    let changes;
-    if (options.staged) {
-        // For pre-commit hooks - analyze only staged files
-        changes = gitService.getStagedChanges();
+    const { specifyModel } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'specifyModel',
+            message: t('prompts.fill.overrideModel'),
+            default: false
+        }
+    ]);
+    let provider;
+    let model;
+    if (specifyModel) {
+        const providerAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: t('prompts.fill.provider'),
+                choices: ['openrouter', 'openai', 'anthropic', 'gemini', 'grok']
+            }
+        ]);
+        provider = providerAnswer.provider;
+        const modelAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'model',
+                message: t('prompts.fill.model'),
+                default: DEFAULT_MODEL
+            }
+        ]);
+        model = modelAnswer.model.trim();
     }
-    else if (options.since) {
-        // Compare against specific commit
-        changes = gitService.getChangedFiles(options.since);
+    const { provideApiKey } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'provideApiKey',
+            message: t('prompts.fill.provideApiKey'),
+            default: false
+        }
+    ]);
+    let apiKey;
+    if (provideApiKey) {
+        const apiKeyAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: t('prompts.fill.apiKey'),
+                mask: '*'
+            }
+        ]);
+        apiKey = apiKeyAnswer.apiKey.trim();
     }
-    else {
-        // Compare against last processed commit
-        changes = gitService.getChangedFiles();
-    }
-    // Analyze the changes
-    const analysis = await changeAnalyzer.analyzeChanges(repoStructure, changes);
-    ui.stopSpinner();
-    // Display the analysis
-    changeAnalyzer.displayAnalysis(analysis, options.verbose);
-    // Add token estimation if there are changes to process
-    if (analysis.affectedModules.length > 0) {
-        ui.startSpinner('Estimating token usage and costs for affected changes...');
-        // Create a subset structure with only affected files
-        const affectedFiles = new Set();
-        // Add all files from affected modules
-        for (const module of analysis.affectedModules) {
-            module.affectedFiles.forEach(filePath => {
-                // Convert to absolute path to match repoStructure.files format
-                const absolutePath = path.resolve(resolvedPath, filePath);
-                if (fileMapper.isTextFile(absolutePath)) {
-                    affectedFiles.add(absolutePath);
+    const { verbose } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'verbose',
+            message: t('prompts.common.verbose'),
+            default: false
+        }
+    ]);
+    await runLlmFill(resolvedRepo, {
+        output: outputDir,
+        prompt: promptPath,
+        docs: selectedDocs,
+        agents: selectedAgents,
+        dryRun,
+        all: processAll,
+        limit: parsedLimit,
+        model,
+        provider,
+        apiKey,
+        verbose
+    });
+}
+async function runInteractivePlan() {
+    const { planName } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'planName',
+            message: t('prompts.plan.name'),
+            default: 'new-plan'
+        }
+    ]);
+    const defaultOutput = path.resolve(process.cwd(), '.context');
+    const { mode } = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'mode',
+            message: t('prompts.plan.mode'),
+            choices: [
+                { name: t('prompts.plan.modeScaffold'), value: 'scaffold' },
+                { name: t('prompts.plan.modeFill'), value: 'fill' }
+            ],
+            default: 'scaffold'
+        }
+    ]);
+    const { outputDir } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'outputDir',
+            message: t('commands.plan.options.output'),
+            default: defaultOutput
+        }
+    ]);
+    if (mode === 'fill') {
+        const { summary } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'summary',
+                message: t('prompts.plan.summary'),
+                filter: (value) => value.trim()
+            }
+        ]);
+        const { includeAgents } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'includeAgents',
+                message: t('prompts.plan.includeAgents'),
+                default: true
+            }
+        ]);
+        let selectedAgents = [];
+        if (includeAgents) {
+            const { agents } = await inquirer_1.default.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'agents',
+                    message: t('prompts.plan.selectAgents'),
+                    choices: AGENT_CHOICES,
+                    default: AGENT_CHOICES.map(choice => choice.value)
                 }
-            });
+            ]);
+            selectedAgents = agents;
         }
-        // Also add directly changed files
-        [...changes.added, ...changes.modified].forEach(filePath => {
-            const fullPath = path.resolve(resolvedPath, filePath);
-            if (fileMapper.isTextFile(fullPath)) {
-                affectedFiles.add(fullPath);
+        const { includeDocs } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'includeDocs',
+                message: t('prompts.plan.includeDocs'),
+                default: true
             }
-        });
-        // Debug: Log the affected files and available files for comparison
-        if (options.verbose) {
-            console.log(chalk_1.default.gray(`\nDebug: Found ${affectedFiles.size} affected files:`));
-            for (const file of Array.from(affectedFiles).slice(0, 5)) {
-                const relativePath = path.relative(resolvedPath, file);
-                console.log(chalk_1.default.gray(`  - ${relativePath}`));
+        ]);
+        let selectedDocs = [];
+        if (includeDocs) {
+            const { docs } = await inquirer_1.default.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'docs',
+                    message: t('prompts.plan.selectDocs'),
+                    choices: DOC_CHOICES,
+                    default: DOC_CHOICES.map(choice => choice.value)
+                }
+            ]);
+            selectedDocs = docs;
+        }
+        const agentSelection = parseAgentSelection(selectedAgents);
+        const docSelection = parseDocSelection(selectedDocs);
+        const { repoPath } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'repoPath',
+                message: t('prompts.plan.repoPath'),
+                default: process.cwd()
             }
-            if (affectedFiles.size > 5) {
-                console.log(chalk_1.default.gray(`  ... and ${affectedFiles.size - 5} more`));
+        ]);
+        const { dryRun } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'dryRun',
+                message: t('prompts.plan.dryRun'),
+                default: true
             }
+        ]);
+        try {
+            const resolvedOutput = path.resolve(outputDir.trim() || defaultOutput);
+            await scaffoldPlanIfNeeded(planName, resolvedOutput, {
+                summary: summary || undefined,
+                agentSelection,
+                docSelection
+            });
+            await runPlanFill(planName, {
+                output: resolvedOutput,
+                repo: repoPath,
+                dryRun
+            });
         }
-        // Create a reduced repo structure for estimation
-        const matchedFiles = repoStructure.files.filter(file => affectedFiles.has(file.path));
-        const affectedRepoStructure = {
-            ...repoStructure,
-            files: matchedFiles,
-            totalFiles: matchedFiles.length
-        };
-        if (options.verbose) {
-            console.log(chalk_1.default.gray(`Debug: Matched ${matchedFiles.length} files from repo structure`));
-        }
-        // Create pricing if provided (optional for preview command)
-        let pricing = undefined;
-        if (options.inputPrice !== undefined && options.outputPrice !== undefined) {
-            pricing = {
-                input: options.inputPrice,
-                output: options.outputPrice
-            };
-        }
-        else if (options.inputPrice !== undefined || options.outputPrice !== undefined) {
-            ui.displayError('Pricing requires both options: --input-price and --output-price');
-            process.exit(1);
+        catch (error) {
+            ui.displayError(t('errors.plan.fillFailed'), error);
+        }
+        return;
+    }
+    const { summary } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'summary',
+            message: t('prompts.plan.summary'),
+            filter: (value) => value.trim()
+        }
+    ]);
+    const { includeAgents } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeAgents',
+            message: t('prompts.plan.includeAgents'),
+            default: true
+        }
+    ]);
+    let selectedAgents = null;
+    if (includeAgents) {
+        const { agents } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'agents',
+                message: t('prompts.plan.selectAgents'),
+                choices: AGENT_CHOICES,
+                default: AGENT_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedAgents = agents.length > 0 ? agents : null;
+    }
+    const { includeDocs } = await inquirer_1.default.prompt([
+        {
+            type: 'confirm',
+            name: 'includeDocs',
+            message: t('prompts.plan.includeDocs'),
+            default: true
         }
-        const tokenEstimator = new tokenEstimator_1.TokenEstimator(fileMapper, pricing);
-        const tokenEstimate = await tokenEstimator.estimateTokensForFullGeneration(affectedRepoStructure);
+    ]);
+    let selectedDocs = null;
+    if (includeDocs) {
+        const { docs } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'docs',
+                message: t('prompts.plan.selectDocs'),
+                choices: DOC_CHOICES,
+                default: DOC_CHOICES.map(choice => choice.value)
+            }
+        ]);
+        selectedDocs = docs.length > 0 ? docs : null;
+    }
+    const generator = new planGenerator_1.PlanGenerator();
+    ui.startSpinner(t('spinner.plan.creating'));
+    try {
+        const result = await generator.generatePlan({
+            planName,
+            outputDir: path.resolve(outputDir.trim() || defaultOutput),
+            summary: summary || undefined,
+            selectedAgentTypes: selectedAgents,
+            selectedDocKeys: selectedDocs,
+            verbose: false
+        });
+        ui.updateSpinner(t('spinner.plan.created'), 'success');
+        ui.displaySuccess(t('success.plan.createdAt', { path: chalk_1.default.cyan(result.relativePath) }));
+    }
+    catch (error) {
+        ui.updateSpinner(t('spinner.plan.creationFailed'), 'fail');
+        ui.displayError(t('errors.plan.creationFailed'), error);
+    }
+    finally {
         ui.stopSpinner();
-        // Display the token estimate
-        console.log(chalk_1.default.bold('\n🔮 Token & Cost Estimate for Preview Changes:'));
-        console.log(chalk_1.default.gray('═'.repeat(60)));
-        console.log(tokenEstimator.formatTokenEstimate(tokenEstimate));
     }
-    // Summary
-    if (analysis.affectedModules.length > 0) {
-        console.log(chalk_1.default.green('\n✅ Ready to proceed with update command'));
-        console.log(chalk_1.default.gray('Run the same command with "update" instead of "preview" to apply changes'));
+}
+function getAgentFilesByTypes(types) {
+    if (!types || types.length === 0) {
+        return undefined;
     }
-    else {
-        console.log(chalk_1.default.yellow('\n📄 No updates needed - documentation is up to date'));
+    const allowed = new Set(agentTypes_1.AGENT_TYPES);
+    const files = types
+        .filter(type => allowed.has(type))
+        .map(type => `${type}.md`);
+    return files.length ? new Set(files) : undefined;
+}
+function filterOutLocaleArgs(args) {
+    const filtered = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (current === '--lang' || current === '--language' || current === '-l') {
+            index += 1;
+            continue;
+        }
+        if (current.startsWith('--lang=') || current.startsWith('--language=')) {
+            continue;
+        }
+        filtered.push(current);
     }
+    return filtered;
 }
-// Check if no arguments were provided (interactive mode)
-if (process.argv.length === 2) {
-    const interactive = new interactiveMode_1.InteractiveMode();
-    interactive.start().catch((error) => {
-        ui.displayError('Interactive mode failed', error);
+async function main() {
+    const userArgs = process.argv.slice(2);
+    const meaningfulArgs = filterOutLocaleArgs(userArgs);
+    if (meaningfulArgs.length === 0) {
+        await runInteractive();
+        return;
+    }
+    await program.parseAsync(process.argv);
+}
+if (require.main === module) {
+    main().catch(error => {
+        ui.displayError(t('errors.cli.executionFailed'), error);
         process.exit(1);
     });
 }
-else {
-    program.parse();
-}
 //# sourceMappingURL=index.js.map