@devtrack-solution/codesdd 1.2.2

package/dist/commands/sdd.js

@@ -0,0 +1,769 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { SddInitCommand, SddInitContextCommand } from '../core/sdd/init.js';
+import { SddCheckCommand } from '../core/sdd/check.js';
+import { loadProjectSddConfig, resolveSddPaths, } from '../core/sdd/state.js';
+import { assessSddMigration, SddMigrateCommand } from '../core/sdd/migrate.js';
+import { MigrateWorkspaceCommand } from '../core/sdd/migrate-workspace.js';
+import { SddImportOpenSpecCommand } from '../core/sdd/import-openspec.js';
+import { isInteractive } from '../utils/interactive.js';
+import { createSddStores } from "../core/sdd/store/sdd-stores.js";
+import { InsightService } from "../core/sdd/services/insight.service.js";
+import { IngestDepositoService } from "../core/sdd/services/ingest-deposito.service.js";
+import { DebateService } from "../core/sdd/services/debate.service.js";
+import { DecideService } from "../core/sdd/services/decide.service.js";
+import { BreakdownService } from "../core/sdd/services/breakdown.service.js";
+import { FrontendGapService } from "../core/sdd/services/frontend-gap.service.js";
+import { SddDiagnoseCommand, formatDiagnosticText } from "../core/sdd/diagnose.js";
+import { SddSanitizeCommand, formatSanitizerText } from "../core/sdd/sanitize.js";
+import { ScanNamingService, formatScanNamingReport } from "../core/sdd/services/scan-naming.service.js";
+import { SddRebuildService, formatSddRebuildReport } from "../core/sdd/services/rebuild.service.js";
+import { SddMetricsService, formatSddMetricsReport } from "../core/sdd/services/metrics.service.js";
+import { FeatureLintService, formatFeatureLintReport } from "../core/sdd/services/feature-lint.service.js";
+import { SddDedupApplyService, formatSddDedupApplyReport } from "../core/sdd/services/dedup-apply.service.js";
+import { captureFingerprintsForChange, writeMeta } from '../core/sdd/fingerprint.js';
+import { ensureMandatorySddMigration, parseCsvOption, parseFlowModeOption, parseLangOption, parseLayoutOption, resolveRoot, } from './sdd/shared.js';
+import { registerExecutionCommands } from './sdd/execution.js';
+import { registerSkillsCommands } from './sdd/skills.js';
+import { displayLegacyOpenSpecPath, resolveOpenSpecSubpath, } from '../core/sdd/services/legacy-capability.service.js';
+export function registerSddCommand(program) {
+    const sddCmd = program.command('sdd').description('SDD memory operations');
+    sddCmd
+        .command('init [path]')
+        .description('Initializes the .sdd structure and base state files')
+        .alias('iniciar')
+        .option('--frontend', 'Enables frontend state files and generated views')
+        .option('--lang <lang>', 'SDD language: pt-BR|en-US')
+        .option('--layout <layout>', 'Folder layout: en-US|legacy|pt-BR')
+        .option('--no-render', 'Does not generate Markdown views after initialization')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        const command = new SddInitCommand();
+        const result = await command.execute(root, {
+            frontendEnabled: options?.frontend,
+            language: parseLangOption(options?.lang),
+            layout: parseLayoutOption(options?.layout),
+            render: options?.render,
+        });
+        console.log(chalk.green('SDD initialized successfully.'));
+        console.log(`Memory directory: ${result.memoryDir}`);
+        if (options?.lang) {
+            console.log(`Language: ${options.lang}`);
+        }
+        if (options?.layout) {
+            console.log(`Layout: ${options.layout}`);
+        }
+        console.log(`Frontend module: ${result.frontendEnabled ? 'enabled' : 'disabled'}`);
+        console.log(`Views generated: ${result.rendered ? 'yes' : 'no'}`);
+        console.log(`Curated skills loaded: ${result.skillsSeeded}`);
+        console.log(`Local skills generated: ${result.localSkillsMaterialized}`);
+        console.log(`Tools synced: ${result.syncedTools.length > 0 ? result.syncedTools.join(', ') : 'none detected'}`);
+    });
+    sddCmd
+        .command('init-context [path]')
+        .description('Inspeciona repositorio existente e preenche contexto inicial canônico')
+        .alias('iniciar-contexto')
+        .option('--mode <mode>', 'Modo de escrita: merge|replace (padrao: merge)')
+        .option('--no-deep', 'Desativa inspecao profunda de estrutura de repositorio')
+        .option('--no-render', 'Nao gera views apos bootstrap de contexto')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        if (options?.mode && options.mode !== 'merge' && options.mode !== 'replace') {
+            throw new Error('Valor invalido em --mode. Use merge ou replace.');
+        }
+        const command = new SddInitContextCommand();
+        const result = await command.execute(root, {
+            mode: options?.mode,
+            deep: options?.deep,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green('Contexto inicial bootstrapado com sucesso.'));
+        console.log(`Diretorio de memoria: ${result.memoryDir}`);
+        console.log(`Views geradas: ${result.rendered ? 'sim' : 'nao'}`);
+        console.log(`Projeto detectado: ${result.sddBootstrap.detected.package_name}`);
+        console.log(`Detectado: stack=${result.sddBootstrap.detected.tech_stack_count}, repo-map=${result.sddBootstrap.detected.repo_map_count}, servicos=${result.sddBootstrap.detected.service_catalog_count}`);
+        console.log(`Atualizado: stack=${result.sddBootstrap.updated.tech_stack ? 'sim' : 'nao'}, repo-map=${result.sddBootstrap.updated.repo_map ? 'sim' : 'nao'}, arquitetura=${result.sddBootstrap.updated.architecture ? 'sim' : 'nao'}, servicos=${result.sddBootstrap.updated.service_catalog ? 'sim' : 'nao'}, contratos=${result.sddBootstrap.updated.integration_contracts ? 'sim' : 'nao'}`);
+        if (result.sddBootstrap.notes.length > 0) {
+            console.log(`Notas: ${result.sddBootstrap.notes.join(' | ')}`);
+        }
+    });
+    sddCmd
+        .command('fingerprint')
+        .description('Gerencia fingerprints de requisitos de changes ativos')
+        .option('--backfill', 'Recalcula meta.json para changes ativos')
+        .option('--ref <changeId>', 'Executa o backfill apenas para um change específico')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        void createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        if (!options?.backfill) {
+            throw new Error('Use --backfill para executar esta operação.');
+        }
+        const changeRoot = resolveOpenSpecSubpath(root, 'changes');
+        const mainSpecsDir = resolveOpenSpecSubpath(root, 'specs');
+        await fs.access(changeRoot);
+        let changeIds;
+        if (options?.ref) {
+            if (!/^FEAT-\d{4,}$/i.test(options.ref)) {
+                throw new Error('Use o formato FEAT-#### em --ref.');
+            }
+            const requestedChangeDir = path.join(changeRoot, options.ref);
+            const stat = await fs.stat(requestedChangeDir);
+            if (!stat.isDirectory()) {
+                throw new Error(`Change '${options.ref}' nao encontrado em ${displayLegacyOpenSpecPath('changes')}`);
+            }
+            changeIds = [options.ref];
+        }
+        else {
+            const entries = await fs.readdir(changeRoot, { withFileTypes: true });
+            changeIds = entries
+                .filter((entry) => entry.isDirectory() && entry.name !== 'archive')
+                .map((entry) => entry.name)
+                .sort();
+        }
+        if (changeIds.length === 0) {
+            console.log('Nenhum change ativo encontrado para backfill.');
+            return;
+        }
+        let processed = 0;
+        for (const changeId of changeIds) {
+            const changeDir = path.join(changeRoot, changeId);
+            const meta = await captureFingerprintsForChange(changeDir, mainSpecsDir, {
+                sourceChangeId: changeId,
+            });
+            await writeMeta(changeDir, meta);
+            processed += 1;
+            console.log(`Fingerprint backfill: ${changeId} (${meta.requirements.length} requirements)`);
+        }
+        if (processed > 0) {
+            console.log(`Fingerprint backfill concluido: ${processed} change(s) processado(s).`);
+        }
+    });
+    sddCmd
+        .command('insight <texto>')
+        .description('Registra um insight no funil de descoberta do SDD')
+        .alias('ideia')
+        .option('--title <title>', 'Titulo curto do insight')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (texto, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new InsightService(stores);
+        const result = await command.execute(root, texto, {
+            title: options?.title,
+            render: options?.render,
+        });
+        console.log(chalk.green(`${result.reused ? 'Insight existente' : 'Insight criado'}: ${result.id}`));
+        console.log(`Titulo: ${result.title}`);
+        console.log(`Arquivo: ${result.filePath}`);
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`Aviso: ${warning.message}`));
+        }
+    });
+    sddCmd
+        .command('ingest-deposito')
+        .description('Scans sources, indexes raw material, and generates the initial executable trail')
+        .alias('ingestao-deposito')
+        .alias('ingest')
+        .option('--source-dir <path>', 'Source directory (default: .sdd/sources in en-US layout)')
+        .option('--title <title>', 'Initial EPIC title when --epic/--radar is not provided')
+        .option('--epic <epicId>', 'Reuse an existing EPIC (EPIC-####)')
+        .option('--radar <radarId>', 'Reuse a legacy RAD alias (RAD-###)')
+        .option('--titles <list>', 'Comma-separated FEAT titles')
+        .option('--scale <scale>', 'Scale QUICK|STANDARD|LARGE')
+        .option('--flow-mode <flowMode>', 'Started FEAT flow: direct|standard|rigorous')
+        .option('--fluxo <flowMode>', 'Legacy Portuguese alias for --flow-mode')
+        .option('--no-start', 'Does not automatically start the first ready FEAT')
+        .option('--json', 'JSON output')
+        .option('--no-render', 'Does not generate views after updating state')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const flow = parseFlowModeOption(options?.flowMode || options?.fluxo);
+        const epicRef = options?.epic || options?.radar;
+        if (epicRef && !/^(?:RAD|EPIC)-\d{3,}$/.test(epicRef)) {
+            throw new Error('Invalid --epic/--radar value. Use EPIC-#### or RAD-###.');
+        }
+        const command = new IngestDepositoService(stores);
+        const result = await command.execute(root, {
+            sourceDir: options?.sourceDir,
+            title: options?.title,
+            radarId: epicRef,
+            titles: parseCsvOption(options?.titles),
+            scale: options?.scale,
+            flowMode: flow,
+            start: options?.start,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green('Ingestao de deposito concluida.'));
+        console.log(`Diretorio varrido: ${result.source_dir}`);
+        console.log(`Arquivos lidos: ${result.scanned_files}`);
+        console.log(`Fontes criadas: ${result.indexed_created}`);
+        console.log(`Fontes atualizadas: ${result.indexed_updated}`);
+        console.log(`EPIC: ${result.radar_id}`);
+        console.log(`FEATs criadas: ${result.created_features.join(', ') || '-'}`);
+        console.log(`FEATs reaproveitadas: ${result.linked_existing.join(', ') || '-'}`);
+        console.log(`FEAT iniciada: ${result.started_feature_id || '-'}`);
+        if (result.active_path) {
+            console.log(`Workspace ativo: ${result.active_path}`);
+        }
+        if (result.generated_docs.length > 0) {
+            console.log(`Docs gerados: ${result.generated_docs.join(', ')}`);
+        }
+        if (result.start_warning) {
+            console.log(chalk.yellow(`Aviso: ${result.start_warning}`));
+        }
+        console.log(`Skills recomendadas no fluxo: ${result.used_skills.join(', ')}`);
+        console.log(`Prompt recomendado: ${result.recommended_prompt}`);
+    });
+    sddCmd
+        .command('debate <insightId>')
+        .description('Abre um debate a partir de um insight')
+        .alias('debater')
+        .option('--title <title>', 'Titulo do debate')
+        .option('--agent <name>', 'Nome do agente que iniciou o debate')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (insightId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new DebateService(stores);
+        const result = await command.execute(root, insightId, {
+            title: options?.title,
+            agent: options?.agent,
+            render: options?.render,
+        });
+        console.log(chalk.green(`${result.reused ? 'Debate existente' : 'Debate criado'}: ${result.id}`));
+        console.log(`Titulo: ${result.title}`);
+        console.log(`Arquivo: ${result.filePath}`);
+    });
+    sddCmd
+        .command('decide <debateId>')
+        .description('Decide o resultado de um debate: epic ou descarte')
+        .alias('decidir')
+        .requiredOption('--outcome <result>', 'Resultado: epic|discard (radar legado ainda aceito)')
+        .option('--title <title>', 'Titulo do epic (quando outcome=epic; radar legado ainda aceito)')
+        .option('--rationale <text>', 'Racional da decisao')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (debateId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const outcome = options?.outcome;
+        if (outcome !== 'radar' && outcome !== 'epic' && outcome !== 'discard') {
+            throw new Error('Valor invalido em --outcome. Use epic, discard ou radar (legado).');
+        }
+        const normalizedOutcome = outcome === 'epic' ? 'radar' : outcome;
+        const command = new DecideService(stores);
+        const result = await command.execute(root, debateId, normalizedOutcome, {
+            title: options?.title,
+            rationale: options?.rationale,
+            render: options?.render,
+        });
+        if (result.outcome === 'radar') {
+            console.log(chalk.green(`Debate ${debateId} aprovado para EPIC ${result.radarId}`));
+            console.log(`Arquivo: ${result.radarPath}`);
+        }
+        else {
+            console.log(chalk.yellow(`Debate ${debateId} descartado.`));
+            console.log(`Arquivo: ${result.discardPath}`);
+        }
+    });
+    sddCmd
+        .command('breakdown <radarId>')
+        .description('Quebra um EPIC em uma ou mais features FEAT (RAD legado ainda aceito)')
+        .alias('quebrar')
+        .alias('desdobrar')
+        .option('--titles <list>', 'Titulos separados por virgula para gerar varias FEAT')
+        .option('--scale <scale>', 'Escala QUICK|STANDARD|LARGE')
+        .option('--mode <mode>', 'Modo de quebra: graph|flat (padrao: graph)')
+        .option('--incremental', 'Integra novas FEATs ao grafo existente')
+        .option('--dedupe <mode>', 'Modo de dedupe: strict|normal|off (padrao: normal)')
+        .option('--json', 'Saida em JSON')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (radarId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        if (options?.mode && options.mode !== 'graph' && options.mode !== 'flat') {
+            throw new Error('Valor invalido em --mode. Use graph ou flat.');
+        }
+        if (options?.dedupe && !['strict', 'normal', 'off'].includes(options.dedupe)) {
+            throw new Error('Valor invalido em --dedupe. Use strict, normal ou off.');
+        }
+        const command = new BreakdownService(stores);
+        const result = await command.execute(root, radarId, {
+            titles: parseCsvOption(options?.titles),
+            scale: options?.scale,
+            mode: options?.mode,
+            incremental: options?.incremental,
+            dedupe: options?.dedupe,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Breakdown concluido para ${result.radarId}`));
+        console.log(`Features criadas: ${result.created.join(', ') || '-'}`);
+        console.log(`Links reaproveitados: ${result.linked_existing.join(', ') || '-'}`);
+        console.log(`Rewires: ${result.rewired_dependencies.length}`);
+        console.log(`Duplicatas puladas: ${result.skipped_duplicates.length}`);
+    });
+    registerExecutionCommands(sddCmd);
+    sddCmd
+        .command('check [path]')
+        .description('Valida arquivos de estado .sdd e opcionalmente gera views')
+        .alias('checar')
+        .option('--render', 'Gera views Markdown apos validacao bem-sucedida')
+        .option('--strict', 'Eleva avisos de integridade referencial a erros')
+        .option('--json', 'Retorna relatorio em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new SddCheckCommand();
+        const report = await command.execute(root, {
+            render: options?.render,
+            strict: options?.strict,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Valido: ${report.valid ? 'sim' : 'nao'}`);
+            console.log(`Registros de discovery: ${report.summary.discovery}`);
+            console.log(`Itens de backlog: ${report.summary.backlog}`);
+            console.log(`Itens de divida tecnica: ${report.summary.techDebt}`);
+            console.log(`Itens na fila de finalize: ${report.summary.finalizeQueue}`);
+            console.log(`Frontend ativado: ${report.summary.frontendEnabled ? 'sim' : 'nao'}`);
+            console.log(`Progresso global: ${report.summary.progress_global.percent}% (${report.summary.progress_global.done}/${report.summary.progress_global.total})`);
+            console.log(`Prontas para paralelo: ${report.summary.ready_for_parallel}`);
+            console.log(`Bloqueadas: ${report.summary.blocked}`);
+            console.log(`Em conflito de lock: ${report.summary.lock_conflicts}`);
+            console.log(`Documentacao sincronizada: ${report.summary.documentation_sync ? 'sim' : 'nao'}`);
+            console.log(`Views core desatualizadas: ${report.summary.core_views_stale ? 'sim' : 'nao'}`);
+            console.log(`Cobertura frontend sincronizada: ${report.summary.frontend_coverage_sync ? 'sim' : 'nao'}`);
+            console.log(`Quality contracts synchronized: ${report.summary.quality_contract_sync ? 'yes' : 'no'}`);
+            if (report.summary.missing_architecture_fields.length > 0) {
+                console.log(`Campos canônicos pendentes: ${report.summary.missing_architecture_fields.join(', ')}`);
+            }
+            if (report.summary.features_missing_frontend_declaration.length > 0) {
+                console.log(`Features sem declaracao frontend: ${report.summary.features_missing_frontend_declaration.join(', ')}`);
+            }
+            if (report.summary.features_with_frontend_conflict.length > 0) {
+                console.log(`Features com conflito frontend: ${report.summary.features_with_frontend_conflict.join(', ')}`);
+            }
+            if (report.summary.features_missing_fgap_link.length > 0) {
+                console.log(`Features required sem FGAP: ${report.summary.features_missing_fgap_link.join(', ')}`);
+            }
+            if (report.summary.features_missing_quality_contract.length > 0) {
+                console.log(`Features missing quality_contract: ${report.summary.features_missing_quality_contract.join(', ')}`);
+            }
+            if (report.summary.features_missing_quality_artifact.length > 0) {
+                console.log(`Features missing quality.md: ${report.summary.features_missing_quality_artifact.join(', ')}`);
+            }
+            if (report.summary.progress_by_radar.length > 0) {
+                console.log('Progresso por EPIC:');
+                for (const radar of report.summary.progress_by_radar) {
+                    console.log(`- ${radar.radar_id}: ${radar.percent}% (${radar.done}/${radar.total})`);
+                }
+            }
+            if (report.summary.frontendEnabled) {
+                console.log(`Gaps de frontend: ${report.summary.frontendGaps}`);
+                console.log(`Rotas de frontend: ${report.summary.frontendRoutes}`);
+            }
+            if (report.warnings.length > 0) {
+                console.log(chalk.yellow('\nAvisos:'));
+                for (const warning of report.warnings) {
+                    console.log(`- ${warning}`);
+                }
+            }
+            if (report.errors.length > 0) {
+                console.log(chalk.red('\nErros:'));
+                for (const error of report.errors) {
+                    console.log(`- ${error}`);
+                }
+            }
+        }
+        if (!report.valid) {
+            throw new Error('Falha na validacao do SDD');
+        }
+    });
+    sddCmd
+        .command('rebuild [path]')
+        .description('Reconstroi state YAML canonico a partir de discovery e workspaces no disco')
+        .option('--from-disk', 'Reconcilia discovery-index.yaml e backlog.yaml a partir de discovery/planned/active/archived')
+        .option('--dry-run', 'Mostra o que seria reconstruido sem gravar estado')
+        .option('--no-render', 'Nao gera views Markdown apos aplicar o rebuild')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const command = new SddRebuildService();
+        const report = await command.execute(root, {
+            fromDisk: options?.fromDisk,
+            dryRun: options?.dryRun,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(chalk.green('Rebuild SDD concluido.'));
+        console.log(formatSddRebuildReport(report));
+    });
+    sddCmd
+        .command('metrics [path]')
+        .description('Calcula lead time, aging e throughput a partir do transition-log')
+        .option('--since <window>', 'Janela relativa (7d, 24h, 2w) ou timestamp ISO')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const service = new SddMetricsService();
+        const report = await service.execute(root, {
+            since: options?.since,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(chalk.green('Metricas SDD calculadas.'));
+        console.log(formatSddMetricsReport(report));
+    });
+    sddCmd
+        .command('dedup [path]')
+        .description('Reconcilia duplicatas historicas a partir de warning_links')
+        .option('--apply', 'Aplica a reconciliacao de warning_links historicos')
+        .option('--dry-run', 'Mostra reconciliacoes sem gravar estado')
+        .option('--no-render', 'Nao gera views Markdown apos aplicar dedup')
+        .option('--json', 'Saida em JSON')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const service = new SddDedupApplyService();
+        const report = await service.execute(root, {
+            apply: options?.apply,
+            dryRun: options?.dryRun,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(chalk.green('Dedup SDD concluido.'));
+        console.log(formatSddDedupApplyReport(report));
+    });
+    const lintCmd = sddCmd
+        .command('lint')
+        .description('Executa lints determinísticos sobre artefatos SDD');
+    lintCmd
+        .command('feature <featId>')
+        .description('Avalia heuristicas de escopo por tasks, lock domains e surfaces')
+        .option('--strict', 'Falha tambem quando houver warnings')
+        .option('--json', 'Saida em JSON')
+        .action(async (featId, options) => {
+        const root = resolveRoot();
+        const service = new FeatureLintService();
+        const report = await service.execute(root, featId, {
+            strict: options?.strict,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(formatFeatureLintReport(report));
+        }
+        if (!report.ok) {
+            process.exitCode = 1;
+        }
+    });
+    sddCmd
+        .command('migrate')
+        .description('Migra entidades legado para os novos formatos SDD')
+        .alias('migrar')
+        .option('--rad-to-epic', 'Migra instancias de RAD para EPIC (4-digitos)')
+        .option('--yes', 'Confirma migracao manual sem prompt interativo')
+        .option('--json', 'Saida em JSON')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        const assessment = await assessSddMigration(root);
+        if (assessment.needsMigration && !options?.yes) {
+            if (!isInteractive()) {
+                throw new Error('Migracao SDD manual exige confirmacao explicita. Reexecute com --yes.');
+            }
+            const { confirm } = await import('@inquirer/prompts');
+            const approved = await confirm({
+                message: `Aplicar migracao SDD manual agora? ${assessment.reasons.join(' | ')}`,
+                default: false,
+            });
+            if (!approved) {
+                throw new Error('Migracao SDD cancelada pelo usuario.');
+            }
+        }
+        const command = new SddMigrateCommand();
+        const result = await command.execute(root, { radToEpic: options?.radToEpic });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(`Migracao concluida.`));
+        for (const msg of result.messages) {
+            console.log(`- ${msg}`);
+        }
+    });
+    sddCmd
+        .command('migrate-workspace')
+        .description('Migra workspaces SDD legados de Markdown para YAML validado')
+        .option('--dry-run', 'Mostra o que seria migrado sem escrever arquivos')
+        .option('--feat <featId>', 'Migra apenas uma FEAT especifica (ex: FEAT-0001)')
+        .option('--json', 'Saida em JSON')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        if (options?.feat && !/^FEAT-\d{4}$/.test(options.feat)) {
+            throw new Error('Invalid --feat value. Use FEAT-####.');
+        }
+        const command = new MigrateWorkspaceCommand();
+        const result = await command.execute(root, {
+            dryRun: options?.dryRun,
+            feat: options?.feat,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green(options?.dryRun ? 'Dry-run de migracao de workspace concluido.' : 'Migracao de workspace concluida.'));
+        console.log(`Workspaces analisados: ${result.scanned}`);
+        console.log(`Arquivos migrados: ${result.migrated}`);
+        for (const feature of result.features) {
+            console.log(`- ${feature.featureId} (${feature.root}): ${feature.workspace}`);
+            for (const file of feature.files) {
+                const mode = file.written ? 'migrado' : 'dry-run';
+                console.log(`  ${mode}: ${file.source} -> ${file.target}`);
+                if (file.missingFields.length > 0) {
+                    console.log(chalk.yellow(`  incompleto: ${file.missingFields.join(', ')}`));
+                }
+                if (file.validationErrors.length > 0) {
+                    console.log(chalk.red(`  validacao: ${file.validationErrors.join(' | ')}`));
+                }
+            }
+        }
+    });
+    sddCmd
+        .command('import-openspec [path]')
+        .description('Imports legacy openspec/ state into .sdd sources and source-index')
+        .alias('importar-openspec')
+        .option('--dry-run', 'Preview import without writing files')
+        .option('--remove', 'Remove openspec/ after successful import verification')
+        .option('--yes', 'Confirm destructive removal when --remove is used')
+        .option('--json', 'JSON output')
+        .option('--no-render', 'Does not generate views after updating state')
+        .action(async (targetPath = '.', options) => {
+        const root = resolveRoot(targetPath);
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new SddImportOpenSpecCommand();
+        const result = await command.execute(root, {
+            dryRun: options?.dryRun,
+            remove: options?.remove,
+            yes: options?.yes,
+            render: options?.render,
+        });
+        if (options?.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(chalk.green('OpenSpec import completed.'));
+        console.log(`Source root: ${result.source_root}`);
+        console.log(`Target root: ${result.target_root}`);
+        console.log(`Report: ${result.report_path}`);
+        console.log(`Dry run: ${result.dry_run ? 'yes' : 'no'}`);
+        console.log(`Files seen: ${result.files_seen}`);
+        console.log(`Files copied: ${result.files_copied}`);
+        console.log(`Sources indexed: ${result.sources_indexed}`);
+        console.log(`Removed openspec/: ${result.removed_source_root ? 'yes' : 'no'}`);
+        const categories = Object.entries(result.categories)
+            .map(([name, count]) => `${name}=${count}`)
+            .join(', ');
+        console.log(`Categories: ${categories || '-'}`);
+    });
+    registerSkillsCommands(sddCmd);
+    sddCmd
+        .command('diagnose')
+        .alias('diagnosticar')
+        .description('Executa o motor de diagnostico estrutural')
+        .option('--strict', 'Falha se houver inconsistencias criticas')
+        .option('--json', 'Saida em formato JSON')
+        .option('--output <path>', 'Caminho para salvar o relatorio JSON')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const command = new SddDiagnoseCommand();
+        const result = await command.execute(root, {
+            strict: options.strict,
+            output: options.output,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result.report, null, 2));
+        }
+        else {
+            console.log(formatDiagnosticText(result.report));
+            console.log(`\nHealth: ${result.health}`);
+        }
+        if (result.outputPath) {
+            console.log(`Report saved to: ${result.outputPath}`);
+        }
+        if (options.strict && result.exitCode !== 0)
+            process.exit(result.exitCode);
+    });
+    sddCmd
+        .command('scan-naming')
+        .alias('escanear-nomenclatura')
+        .description('Scans tracked files for forbidden naming-contract terms')
+        .option('--strict', 'Exit with code 1 if any warnings are found')
+        .option('--json', 'Emit the full report as JSON')
+        .option('--output <path>', 'Write the JSON report to the given path')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const service = new ScanNamingService();
+        const report = await service.execute(root, { strict: options.strict, json: options.json });
+        if (options.output) {
+            await fs.mkdir(path.dirname(path.resolve(root, options.output)), { recursive: true });
+            await fs.writeFile(path.resolve(root, options.output), JSON.stringify(report, null, 2), 'utf-8');
+        }
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(formatScanNamingReport(report));
+        }
+        const fail = report.errorCount > 0 || (options.strict === true && report.warningCount > 0);
+        if (fail) {
+            process.exitCode = 1;
+        }
+    });
+    const sanitizeCmd = sddCmd
+        .command('sanitize')
+        .alias('sanitizar')
+        .description('Sanitiza o workspace SDD')
+        .option('--dry-run', 'Apenas planeja a sanitizacao')
+        .option('--apply', 'Aplica a sanitizacao')
+        .option('--yes', 'Pula confirmacao')
+        .option('--from-report <path>', 'Usa um relatorio de diagnostico salvo')
+        .option('--json', 'Saida em JSON')
+        .action(async (options) => {
+        const root = resolveRoot();
+        const command = new SddSanitizeCommand();
+        const result = await command.execute(root, {
+            apply: options.apply,
+            dryRun: !options.apply,
+            yes: options.yes,
+            fromReport: options.fromReport,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result.report, null, 2));
+        }
+        else {
+            console.log(formatSanitizerText(result.report));
+        }
+    });
+    sanitizeCmd.command('rollback <id>')
+        .description('Reverte uma operacao de sanitizacao')
+        .option('--reason <reason>', 'Motivo da reversao')
+        .action(async (id, options) => {
+        const root = resolveRoot();
+        const command = new SddSanitizeCommand();
+        const result = await command.rollback(root, id, {
+            reason: options.reason || 'Reversao manual',
+        });
+        console.log(`Rollback concluido: ${result.transactionId}`);
+        console.log(`Revertidos: ${result.rolledBack}, Pulados: ${result.skipped}`);
+    });
+    const gapCmd = sddCmd.command('fgap')
+        .description('Operacoes de gaps de frontend');
+    gapCmd.alias('lacunas-frontend');
+    gapCmd
+        .command('add <title>')
+        .description('Abre um novo FGAP')
+        .alias('abrir')
+        .option('--origin <featId>', 'Feature de origem (FEAT-0001)')
+        .option('--routes <list>', 'Rotas separadas por virgula')
+        .option('--menu <list>', 'Alvos de menu separados por virgula')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (title, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new FrontendGapService(stores);
+        const result = await command.add(root, title, {
+            originFeature: options?.origin,
+            routes: parseCsvOption(options?.routes),
+            menu: parseCsvOption(options?.menu),
+            render: options?.render,
+        });
+        console.log(chalk.green(`Gap criado: ${result.id}`));
+    });
+    gapCmd
+        .command('done <gapId>')
+        .description('Marca um FGAP como resolvido')
+        .alias('resolver')
+        .option('--feature <featId>', 'Feature que resolveu o gap')
+        .option('--files <list>', 'Arquivos implementados separados por virgula')
+        .option('--routes <list>', 'Rotas atualizadas separadas por virgula')
+        .option('--no-render', 'Nao gera views apos atualizar estado')
+        .action(async (gapId, options) => {
+        const root = resolveRoot();
+        const __config = await loadProjectSddConfig(root);
+        const __paths = resolveSddPaths(root, __config);
+        const stores = createSddStores(__paths);
+        await ensureMandatorySddMigration(root);
+        const command = new FrontendGapService(stores);
+        const result = await command.resolve(root, gapId, {
+            feature: options?.feature,
+            files: parseCsvOption(options?.files),
+            routes: parseCsvOption(options?.routes),
+            render: options?.render,
+        });
+        console.log(chalk.green(`Gap ${result.id} atualizado para ${result.status}`));
+    });
+}
+//# sourceMappingURL=sdd.js.map