@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/services/approve.service.d.ts

@@ -0,0 +1,20 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class ApproveService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, featureId: string, stage: any, options?: {
+        by?: string;
+        note?: string;
+        render?: boolean;
+    }): Promise<{
+        feature_id: string;
+        stage: any;
+        status: any;
+        approved_at: any;
+        approved_by: any;
+        current_stage: "proposta" | "planejamento" | "tarefas" | "execucao" | "consolidacao";
+        planned_workspace_path: string;
+        generated_docs: string[];
+    }>;
+}
+//# sourceMappingURL=approve.service.d.ts.map

package/dist/core/sdd/services/approve.service.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { runLifecycleHooks } from "../domain/lifecycle-hooks.js";
+import { loadStateSnapshot, loadSkillCatalogState, nowIso, saveBacklogState } from "../state.js";
+import { bundlesForSkills, getRuntime, persistAndRender, ensureFeaturePlannedWorkspace, resolveFeat, resolveRoutedSkills } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class ApproveService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, featureId, stage, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const catalog = await loadSkillCatalogState(paths);
+            const feature = resolveFeat(snapshot.backlog.items, featureId);
+            const now = nowIso();
+            await runLifecycleHooks('before-approve', {
+                projectRoot,
+                featureId: feature.id,
+                entityId: feature.id,
+                stage,
+                options: options,
+                metadata: {
+                    current_stage: feature.current_stage,
+                },
+            });
+            if (feature.flow_mode === 'direto' && (stage === 'proposta' || stage === 'planejamento')) {
+                feature.gates[stage].status = 'nao_exigida';
+                feature.gates[stage].approved_at = now;
+                feature.gates[stage].approved_by = options?.by || '';
+                feature.gates[stage].note = options?.note || 'Etapa nao exigida no fluxo direto.';
+            }
+            else {
+                feature.gates[stage].status = 'aprovada';
+                feature.gates[stage].approved_at = now;
+                feature.gates[stage].approved_by = options?.by || '';
+                feature.gates[stage].note = options?.note || '';
+            }
+            if (stage === 'proposta')
+                feature.current_stage = 'planejamento';
+            if (stage === 'planejamento')
+                feature.current_stage = 'tarefas';
+            if (stage === 'tarefas')
+                feature.current_stage = 'execucao';
+            feature.last_sync_at = now;
+            let plannedWorkspacePath = '';
+            let generatedDocs = [];
+            if (stage === 'planejamento') {
+                feature.recommended_skills = resolveRoutedSkills(snapshot, feature.touches);
+                const recommendedBundles = bundlesForSkills(catalog, feature.recommended_skills);
+                const workspace = await ensureFeaturePlannedWorkspace(paths, config, feature, recommendedBundles);
+                plannedWorkspacePath = path.relative(paths.projectRoot, workspace.plannedPath);
+                generatedDocs = workspace.generatedDocs;
+            }
+            await saveBacklogState(paths, snapshot.backlog);
+            await persistAndRender(paths, config, options?.render);
+            await runLifecycleHooks('after-approve', {
+                projectRoot,
+                featureId: feature.id,
+                entityId: feature.id,
+                stage,
+                options: options,
+                metadata: {
+                    current_stage: feature.current_stage,
+                    planned_workspace_path: plannedWorkspacePath,
+                },
+            });
+            return {
+                feature_id: feature.id,
+                stage,
+                status: feature.gates[stage].status,
+                approved_at: feature.gates[stage].approved_at || '',
+                approved_by: feature.gates[stage].approved_by || '',
+                current_stage: feature.current_stage,
+                planned_workspace_path: plannedWorkspacePath,
+                generated_docs: generatedDocs,
+            };
+        });
+    }
+}
+//# sourceMappingURL=approve.service.js.map

package/dist/core/sdd/services/audit.service.d.ts

@@ -0,0 +1,53 @@
+import { MetaEvolutionConfig } from "../legacy-operations.js";
+import { SddStores } from "../store/sdd-stores.js";
+export interface AuditHistoryAppendResult {
+    path: string;
+    appended: boolean;
+    total_runs: number;
+    run_id: string;
+}
+export declare class AuditService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string): Promise<{
+        audit_history: {
+            path: string;
+            appended: true;
+            total_runs: number;
+            run_id: string;
+        };
+        generated_at: string;
+        meta_evolution: MetaEvolutionConfig;
+        metrics: {
+            artifacts_without_placeholder: {
+                ok: number;
+                total: number;
+                percent: number;
+            };
+            debates_with_real_deliberation: {
+                ok: number;
+                total: number;
+                percent: number;
+            };
+            adrs_generated_vs_expected: {
+                ok: number;
+                total: number;
+                percent: number;
+            };
+            quality_contracts_ready: {
+                ok: number;
+                total: number;
+                percent: number;
+            };
+            forced_transitions: {
+                total: number;
+                feature_refs: string[];
+            };
+        };
+        score: number;
+        healthy: boolean;
+        should_open_insight: boolean;
+        recommendation: string;
+    }>;
+}
+//# sourceMappingURL=audit.service.d.ts.map

package/dist/core/sdd/services/audit.service.js

@@ -0,0 +1,136 @@
+import path from "node:path";
+import { existsSync, promises as fs } from "node:fs";
+import { CLI_NAME } from "../../branding.js";
+import { adrFileName } from "../adr.js";
+import { loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
+import { normalizePercent, readMetaEvolutionConfig, hasPlaceholder, collectAuditArtifacts, debateHasRealDeliberation, collectForcedTransitions, getRuntime, relProjectPath, evaluateFeatureQuality } from "../legacy-operations.js";
+function auditRunId(timestamp) {
+    const compact = timestamp.replace(/\D/g, '');
+    return `AUD-${compact || Date.now()}`;
+}
+function toAuditHistoryEntry(result) {
+    return {
+        run_id: auditRunId(result.generated_at),
+        generated_at: result.generated_at,
+        score: result.score,
+        healthy: result.healthy,
+        should_open_insight: result.should_open_insight,
+        metrics: result.metrics,
+        recommendation: result.recommendation,
+    };
+}
+export class AuditService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot) {
+        const { config, paths } = await getRuntime(projectRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const metaEvolution = await readMetaEvolutionConfig(paths);
+        const artifacts = await collectAuditArtifacts(paths);
+        let placeholderFreeCount = 0;
+        for (const artifact of artifacts) {
+            const content = await fs.readFile(artifact, 'utf-8').catch(() => '');
+            if (!hasPlaceholder(content, metaEvolution.placeholder_markers)) {
+                placeholderFreeCount += 1;
+            }
+        }
+        const debateFiles = await fs.readdir(paths.discoveryDebatesDir).catch(() => []);
+        let debatesWithRealDeliberation = 0;
+        for (const fileName of debateFiles) {
+            if (!fileName.endsWith('.md'))
+                continue;
+            const debateContent = await fs
+                .readFile(path.join(paths.discoveryDebatesDir, fileName), 'utf-8')
+                .catch(() => '');
+            if (debateHasRealDeliberation(debateContent)) {
+                debatesWithRealDeliberation += 1;
+            }
+        }
+        const expectedAdrFeatures = snapshot.backlog.items.filter((item) => item.requires_adr);
+        let generatedAdrCount = 0;
+        for (const feature of expectedAdrFeatures) {
+            const adrPath = path.join(paths.coreDir, 'adrs', adrFileName(feature.id));
+            if (existsSync(adrPath)) {
+                generatedAdrCount += 1;
+            }
+        }
+        const forcedTransitions = await collectForcedTransitions(paths);
+        const qualityTargets = snapshot.backlog.items.filter((item) => item.quality_contract || item.status === 'IN_PROGRESS');
+        let qualityReadyCount = 0;
+        for (const feature of qualityTargets) {
+            const quality = await evaluateFeatureQuality(paths, config, feature);
+            if (quality.ok || (feature.status !== 'IN_PROGRESS' && !!feature.quality_contract)) {
+                qualityReadyCount += 1;
+            }
+        }
+        const placeholdersMetric = {
+            ok: placeholderFreeCount,
+            total: artifacts.length,
+            percent: normalizePercent(placeholderFreeCount, artifacts.length),
+        };
+        const debateMetric = {
+            ok: debatesWithRealDeliberation,
+            total: debateFiles.filter((name) => name.endsWith('.md')).length,
+            percent: normalizePercent(debatesWithRealDeliberation, debateFiles.filter((name) => name.endsWith('.md')).length),
+        };
+        const adrMetric = {
+            ok: generatedAdrCount,
+            total: expectedAdrFeatures.length,
+            percent: normalizePercent(generatedAdrCount, expectedAdrFeatures.length),
+        };
+        const qualityMetric = {
+            ok: qualityReadyCount,
+            total: qualityTargets.length,
+            percent: normalizePercent(qualityReadyCount, qualityTargets.length),
+        };
+        const scoreBase = placeholdersMetric.percent * 0.32 +
+            debateMetric.percent * 0.28 +
+            adrMetric.percent * 0.2 +
+            qualityMetric.percent * 0.2;
+        const forcedPenalty = Math.min(forcedTransitions.total * 2, 20);
+        const score = Math.max(0, Math.round((scoreBase - forcedPenalty) * 100) / 100);
+        const healthy = score >= metaEvolution.health_alert_threshold;
+        const shouldOpenInsight = !healthy && metaEvolution.enabled;
+        const recommendation = shouldOpenInsight
+            ? `Cycle health is below threshold (${metaEvolution.health_alert_threshold}%). Suggestion: open an INS with "${CLI_NAME} sdd insight \\"SDD meta-evolution: reduce placeholders and strengthen deliberation\\"".`
+            : 'Cycle is within the configured threshold. Keep semiannual monitoring.';
+        const result = {
+            generated_at: nowIso(),
+            meta_evolution: metaEvolution,
+            metrics: {
+                artifacts_without_placeholder: placeholdersMetric,
+                debates_with_real_deliberation: debateMetric,
+                adrs_generated_vs_expected: adrMetric,
+                quality_contracts_ready: qualityMetric,
+                forced_transitions: {
+                    total: forcedTransitions.total,
+                    feature_refs: forcedTransitions.featureRefs,
+                },
+            },
+            score,
+            healthy,
+            should_open_insight: shouldOpenInsight,
+            recommendation,
+        };
+        const entry = toAuditHistoryEntry(result);
+        const auditHistory = {
+            ...snapshot.auditHistory,
+            runs: [...snapshot.auditHistory.runs, entry],
+        };
+        await saveStateTransaction(paths, {
+            auditHistory,
+        });
+        return {
+            ...result,
+            audit_history: {
+                path: relProjectPath(paths, paths.stateFiles.auditHistory),
+                appended: true,
+                total_runs: auditHistory.runs.length,
+                run_id: entry.run_id,
+            },
+        };
+    }
+}
+//# sourceMappingURL=audit.service.js.map

package/dist/core/sdd/services/breakdown.service.d.ts

@@ -0,0 +1,35 @@
+import { Scale } from "../types.js";
+import { SddStores } from "../store/sdd-stores.js";
+export declare class BreakdownService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, radarId: string, options?: {
+        titles?: string[];
+        scale?: Scale;
+        mode?: 'graph' | 'flat';
+        incremental?: boolean;
+        dedupe?: 'strict' | 'normal' | 'off';
+        render?: boolean;
+    }): Promise<{
+        radarId: string;
+        created: string[];
+        linked_existing: string[];
+        rewired_dependencies: {
+            feature_id: string;
+            added_blocked_by: string[];
+        }[];
+        skipped_duplicates: {
+            title: string;
+            existing_feature_id: string;
+        }[];
+        warnings: {
+            title: string;
+            severity: "warning";
+            candidates: Array<{
+                id: string;
+                score: number;
+            }>;
+        }[];
+    }>;
+}
+//# sourceMappingURL=breakdown.service.d.ts.map

package/dist/core/sdd/services/breakdown.service.js

@@ -0,0 +1,185 @@
+import { allocateEntityId, loadStateSnapshot, loadSkillCatalogState, nowIso, saveStateTransaction } from "../state.js";
+import { warnAndLink } from "../dedup.js";
+import { findDiscoveryRecord, syncCounterFromId, getRuntime, persistAndRender, resolveRadar, buildBacklogItem, classifyFeatureShape, stackContextTokens, normalizeTitle, intersects, updateDependencyMetadata, resolveRoutedSkills, applyLoggedTransition } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class BreakdownService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, radarId, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const radar = findDiscoveryRecord(snapshot.discoveryIndex.records, radarId);
+            resolveRadar(radar);
+            const catalog = await loadSkillCatalogState(paths);
+            const mode = options?.mode || 'graph';
+            const dedupe = options?.dedupe || 'normal';
+            const incremental = options?.incremental ?? false;
+            const titles = options?.titles && options.titles.length > 0 ? options.titles : [radar.title || `Feature de ${radar.id}`];
+            const created = [];
+            const linkedExisting = [];
+            const rewiredMap = new Map();
+            const skippedDuplicates = [];
+            const semanticWarnings = [];
+            const parallelGroup = `${radar.type.toLowerCase()}-${radar.id.toLowerCase()}`;
+            const existingItems = snapshot.backlog.items.slice();
+            for (const rawTitle of titles) {
+                const title = rawTitle.trim();
+                if (!title)
+                    continue;
+                const shape = classifyFeatureShape(title, stackContextTokens(snapshot));
+                const normalizedTitle = normalizeTitle(title);
+                const duplicate = existingItems.find((item) => {
+                    if (dedupe !== 'strict')
+                        return false;
+                    const sameOrigin = item.origin_ref === radar.id;
+                    const itemNorm = normalizeTitle(item.title);
+                    return sameOrigin && itemNorm === normalizedTitle;
+                });
+                if (duplicate) {
+                    linkedExisting.push(duplicate.id);
+                    skippedDuplicates.push({ title, existing_feature_id: duplicate.id });
+                    continue;
+                }
+                const semanticMatch = dedupe === 'off'
+                    ? { severity: 'none', warningLinks: [], candidates: [] }
+                    : warnAndLink('FEAT', title, existingItems
+                        .filter((item) => item.origin_ref === radar.id || intersects(item.touches, shape.touches))
+                        .map((item) => ({
+                        id: item.id,
+                        title: item.title,
+                    })));
+                const id = await allocateEntityId(paths, 'FEAT');
+                syncCounterFromId(snapshot.discoveryIndex, id);
+                const recommended = resolveRoutedSkills(snapshot, shape.touches);
+                const item = buildBacklogItem(id, title, 'radar', radar.id, options?.scale || 'STANDARD', recommended, {
+                    parallelGroup,
+                    executionKind: shape.executionKind,
+                    planningMode: shape.planningMode,
+                    acceptanceRefs: [radar.id],
+                    touches: shape.touches,
+                    lockDomains: shape.lockDomains,
+                    produces: shape.produces,
+                    consumes: shape.consumes,
+                });
+                if (semanticMatch.severity === 'warning') {
+                    item.warning_links = semanticMatch.warningLinks;
+                    semanticWarnings.push({
+                        title,
+                        severity: 'warning',
+                        candidates: semanticMatch.candidates.map((candidate) => ({
+                            id: candidate.id,
+                            score: candidate.score,
+                        })),
+                    });
+                }
+                snapshot.backlog.items.push(item);
+                existingItems.push(item);
+                created.push(item);
+            }
+            if (created.length === 0 && linkedExisting.length === 0) {
+                throw new Error('Nenhuma feature criada no breakdown. Informe pelo menos um titulo valido.');
+            }
+            if (mode === 'graph') {
+                const domainOrMigration = created
+                    .filter((item) => item.execution_kind === 'migration' || item.title.toLowerCase().includes('modelo'))
+                    .map((item) => item.id);
+                const apiOrBackend = created
+                    .filter((item) => item.execution_kind === 'feature' || item.title.toLowerCase().includes('api'))
+                    .map((item) => item.id);
+                for (const item of created) {
+                    if (item.execution_kind === 'feature') {
+                        item.blocked_by = Array.from(new Set([...item.blocked_by, ...domainOrMigration.filter((dep) => dep !== item.id)]));
+                    }
+                    if (item.execution_kind === 'frontend_coverage') {
+                        item.blocked_by = Array.from(new Set([...item.blocked_by, ...apiOrBackend.filter((dep) => dep !== item.id)]));
+                    }
+                    if (item.execution_kind === 'documentation') {
+                        item.blocked_by = created
+                            .filter((other) => other.id !== item.id && other.execution_kind !== 'documentation')
+                            .map((other) => other.id);
+                    }
+                    if (item.blocked_by.length > 0) {
+                        item.consumes = Array.from(new Set([...item.consumes, ...item.blocked_by]));
+                        applyLoggedTransition(snapshot.transitionLog.events, 'FEAT', item, 'BLOCKED', {
+                            sourceCommand: 'sdd breakdown',
+                            reason: `Dependencias definidas no breakdown ${radar.id}`,
+                            timestamp: nowIso(),
+                        });
+                    }
+                }
+            }
+            if (incremental && created.length > 0) {
+                for (const createdItem of created) {
+                    const addedDeps = new Set();
+                    for (const existing of snapshot.backlog.items) {
+                        if (existing.id === createdItem.id)
+                            continue;
+                        if (intersects(createdItem.consumes, existing.produces) && existing.status !== 'DONE') {
+                            createdItem.blocked_by = Array.from(new Set([...createdItem.blocked_by, existing.id]));
+                            addedDeps.add(existing.id);
+                        }
+                        if (intersects(existing.consumes, createdItem.produces) && createdItem.status !== 'DONE') {
+                            existing.blocked_by = Array.from(new Set([...existing.blocked_by, createdItem.id]));
+                            if (existing.status === 'READY')
+                                existing.status = 'BLOCKED';
+                            const deps = rewiredMap.get(existing.id) || new Set();
+                            deps.add(createdItem.id);
+                            rewiredMap.set(existing.id, deps);
+                        }
+                        if (existing.status === 'IN_PROGRESS' &&
+                            intersects(createdItem.lock_domains, existing.lock_domains)) {
+                            createdItem.status = 'BLOCKED';
+                            createdItem.summary = `${createdItem.summary || ''}\nLOCK_CONFLICT com ${existing.id}`.trim();
+                        }
+                    }
+                    if (addedDeps.size > 0) {
+                        applyLoggedTransition(snapshot.transitionLog.events, 'FEAT', createdItem, 'BLOCKED', {
+                            sourceCommand: 'sdd breakdown',
+                            reason: `Dependencias incrementais detectadas para ${createdItem.id}`,
+                            timestamp: nowIso(),
+                        });
+                        const deps = rewiredMap.get(createdItem.id) || new Set();
+                        for (const dep of addedDeps)
+                            deps.add(dep);
+                        rewiredMap.set(createdItem.id, deps);
+                    }
+                }
+            }
+            updateDependencyMetadata(snapshot.backlog.items);
+            if (radar.status !== 'SPLIT') {
+                applyLoggedTransition(snapshot.transitionLog.events, radar.type, radar, 'SPLIT', {
+                    sourceCommand: 'sdd breakdown',
+                    reason: `EPIC/RAD ${radar.id} quebrado em features`,
+                    timestamp: nowIso(),
+                    afterTransition: (currentRadar) => {
+                        currentRadar.updated_at = nowIso();
+                    },
+                });
+            }
+            radar.related_ids = Array.from(new Set([...radar.related_ids, ...created.map((item) => item.id)]));
+            await saveStateTransaction(paths, {
+                backlog: snapshot.backlog,
+                discoveryIndex: snapshot.discoveryIndex,
+                transitionLog: snapshot.transitionLog,
+            });
+            await persistAndRender(paths, config, options?.render);
+            return {
+                radarId: radar.id,
+                created: created.map((item) => item.id),
+                linked_existing: linkedExisting,
+                rewired_dependencies: Array.from(rewiredMap.entries())
+                    .sort((a, b) => a[0].localeCompare(b[0]))
+                    .map(([feature_id, deps]) => ({
+                    feature_id,
+                    added_blocked_by: Array.from(deps).sort(),
+                })),
+                skipped_duplicates: skippedDuplicates,
+                warnings: semanticWarnings,
+            };
+        });
+    }
+}
+//# sourceMappingURL=breakdown.service.js.map