@devtrack-solution/codesdd 1.2.2

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

@@ -0,0 +1,31 @@
+export interface SddRebuildOptions {
+    fromDisk?: boolean;
+    dryRun?: boolean;
+    render?: boolean;
+}
+export interface SddRebuildSectionReport {
+    scanned: number;
+    created: string[];
+    updated: string[];
+    unchanged: string[];
+    skipped: string[];
+}
+export interface SddRebuildReport {
+    mode: 'from-disk';
+    dryRun: boolean;
+    rendered: boolean;
+    discovery: SddRebuildSectionReport;
+    backlog: SddRebuildSectionReport & {
+        workspaces: {
+            planned: number;
+            active: number;
+            archived: number;
+        };
+    };
+    warnings: string[];
+}
+export declare class SddRebuildService {
+    execute(projectRoot?: string, options?: SddRebuildOptions): Promise<SddRebuildReport>;
+}
+export declare function formatSddRebuildReport(report: SddRebuildReport): string;
+//# sourceMappingURL=rebuild.service.d.ts.map

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

@@ -0,0 +1,482 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { isDeepStrictEqual } from 'node:util';
+import { loadProjectSddConfig, loadStateSnapshot, nowIso, resolveSddPaths, saveStateTransaction, } from '../state.js';
+import { BacklogStateSchema, DiscoveryIndexStateSchema, } from '../types.js';
+import { activeDocNamesForLayout, buildBacklogItem, computeCanonicalTitle, ensureFeatureQualityContract, ensureMemoryInitialized, relProjectPath, } from '../legacy-operations.js';
+import { renderViews } from '../views.js';
+import { parseWorkspaceYamlDocument, } from '../workspace-schemas.js';
+const DISCOVERY_STATUSES = new Set([
+    'NEW',
+    'DEBATED',
+    'PROMOTED',
+    'DROPPED',
+    'OPEN',
+    'APPROVED',
+    'DISCARDED',
+    'SUPERSEDED',
+    'READY',
+    'PLANNED',
+    'SPLIT',
+    'IN_PROGRESS',
+    'DONE',
+    'CANCELLED',
+]);
+const DEFAULT_COUNTERS = {
+    INS: 0,
+    DEB: 0,
+    RAD: 0,
+    EPIC: 0,
+    FEAT: 0,
+    FGAP: 0,
+    TD: 0,
+};
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function defaultSectionReport() {
+    return {
+        scanned: 0,
+        created: [],
+        updated: [],
+        unchanged: [],
+        skipped: [],
+    };
+}
+async function pathExists(filePath) {
+    return fs.access(filePath).then(() => true, () => false);
+}
+function syncCounterFromId(counters, id) {
+    const match = /^(INS|DEB|RAD|EPIC|FEAT|FGAP|TD)-(\d+)$/i.exec(id.trim());
+    if (!match)
+        return;
+    const prefix = match[1].toUpperCase();
+    const value = Number(match[2]);
+    if (!Number.isFinite(value))
+        return;
+    counters[prefix] = Math.max(counters[prefix] ?? 0, value);
+}
+function deriveDiscoveryType(id) {
+    const prefix = id.split('-')[0]?.toUpperCase();
+    if (prefix === 'INS' || prefix === 'DEB' || prefix === 'RAD' || prefix === 'EPIC') {
+        return prefix;
+    }
+    return undefined;
+}
+function discoveryStatusFromMarkdown(content, type, discarded) {
+    const statusMatch = /^## Status\s*\n+([A-Z_]+)/im.exec(content);
+    const declared = statusMatch?.[1]?.toUpperCase();
+    if (declared && DISCOVERY_STATUSES.has(declared)) {
+        return declared;
+    }
+    if (discarded)
+        return 'DISCARDED';
+    if (type === 'INS')
+        return 'NEW';
+    if (type === 'DEB')
+        return 'DEBATED';
+    return 'READY';
+}
+function titleFromMarkdown(content, id, fileName) {
+    const titleBlock = /^## Title\s*\n+(.+)$/im.exec(content);
+    const baseTitle = /^\s*-\s*Base title:\s*(.+)$/im.exec(content);
+    const heading = /^#\s+(.+)$/m.exec(content);
+    const slugTitle = path
+        .basename(fileName, path.extname(fileName))
+        .replace(new RegExp(`^${id}-?`, 'i'), '')
+        .replace(/-/g, ' ')
+        .trim();
+    const candidate = (titleBlock?.[1] || baseTitle?.[1] || heading?.[1] || slugTitle || id).trim();
+    const cleaned = candidate
+        .replace(new RegExp(`^(Insight|Debate|Epic)\\s+${id}\\s*:?\\s*`, 'i'), '')
+        .trim();
+    return cleaned || slugTitle || id;
+}
+async function listFeatureDirs(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    return entries
+        .filter((entry) => entry.isDirectory() && /^FEAT-\d{4}$/.test(entry.name))
+        .map((entry) => path.join(dir, entry.name))
+        .sort((left, right) => left.localeCompare(right));
+}
+async function parseWorkspaceDoc(filePath, fileName, warnings, paths) {
+    if (!(await pathExists(filePath)))
+        return undefined;
+    const content = await fs.readFile(filePath, 'utf-8');
+    try {
+        return parseWorkspaceYamlDocument(fileName, content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`${relProjectPath(paths, filePath)} ignored during rebuild: ${message}`);
+        return undefined;
+    }
+}
+function workspaceOriginTypeToBacklog(originType) {
+    if (originType === 'fgap')
+        return 'frontend_gap';
+    if (originType === 'td')
+        return 'tech_debt';
+    return originType;
+}
+function statusForLifecycle(lifecycle) {
+    if (lifecycle === 'active')
+        return 'IN_PROGRESS';
+    if (lifecycle === 'archived')
+        return 'DONE';
+    return 'READY';
+}
+function stageForLifecycle(lifecycle, existing) {
+    if (lifecycle === 'active')
+        return 'execucao';
+    if (lifecycle === 'archived')
+        return 'consolidacao';
+    if (existing?.current_stage === 'proposta' ||
+        existing?.current_stage === 'planejamento' ||
+        existing?.current_stage === 'tarefas') {
+        return existing.current_stage;
+    }
+    return 'planejamento';
+}
+function splitContracts(plan) {
+    const produces = [];
+    const consumes = [];
+    for (const contract of plan?.affected_contracts ?? []) {
+        const changeType = contract.change_type.toLowerCase();
+        if (changeType.includes('produce')) {
+            produces.push(contract.name);
+        }
+        else if (changeType.includes('consume')) {
+            consumes.push(contract.name);
+        }
+    }
+    return {
+        produces: Array.from(new Set(produces)),
+        consumes: Array.from(new Set(consumes)),
+    };
+}
+function preferExistingArray(existing, derived) {
+    return existing && existing.length > 0 ? existing : derived;
+}
+function preferExistingFrontendStatus(existing, plan, fallback) {
+    if (existing && existing.frontend_impact_status !== 'unknown') {
+        return existing.frontend_impact_status;
+    }
+    return plan?.frontend_impact.status ?? existing?.frontend_impact_status ?? fallback.frontend_impact_status;
+}
+function buildFeatureFromEvidence(evidence, existing, warnings, paths, timestamp) {
+    if (!existing && !evidence.spec) {
+        warnings.push(`${relProjectPath(paths, evidence.root)} skipped: missing valid 1-spec.yaml and no backlog item exists.`);
+        return undefined;
+    }
+    const spec = evidence.spec;
+    const plan = evidence.plan;
+    const quality = evidence.quality;
+    const originType = spec ? workspaceOriginTypeToBacklog(spec.origin.type) : existing?.origin_type ?? 'direct';
+    const originRef = spec?.origin.ref || existing?.origin_ref || undefined;
+    if (originType !== 'direct' && originType !== 'fast_track' && !originRef) {
+        warnings.push(`${relProjectPath(paths, evidence.root)} skipped: origin_ref cannot be reconstructed.`);
+        return undefined;
+    }
+    const derivedSkills = Array.from(new Set([
+        ...(plan?.skill_conformance?.selected_skills ?? []),
+        ...(plan?.suggested_skills ?? []),
+        ...(existing?.recommended_skills ?? []),
+    ].filter(Boolean)));
+    const selectedSkills = existing?.recommended_skills.length ? existing.recommended_skills : derivedSkills;
+    const affectedModules = plan?.architectural_impact.affected_modules ?? [];
+    const contracts = splitContracts(plan);
+    const base = buildBacklogItem(evidence.id, spec?.title || existing?.title || evidence.id, originType, originRef, existing?.scale ?? 'STANDARD', selectedSkills, {
+        executionKind: existing?.execution_kind ?? 'feature',
+        planningMode: existing?.planning_mode ?? 'local_plan',
+        flowMode: existing?.flow_mode ?? 'padrao',
+        acceptanceRefs: spec?.acceptance_refs ?? existing?.acceptance_refs ?? [],
+        touches: preferExistingArray(existing?.touches, affectedModules),
+        lockDomains: existing?.lock_domains ?? [],
+        produces: preferExistingArray(existing?.produces, contracts.produces),
+        consumes: preferExistingArray(existing?.consumes, contracts.consumes),
+        parallelGroup: existing?.parallel_group,
+    });
+    const merged = {
+        ...base,
+        ...(existing ? clone(existing) : {}),
+        id: evidence.id,
+        title: existing?.title || spec?.title || base.title,
+        status: statusForLifecycle(evidence.lifecycle),
+        origin_type: originType,
+        origin_ref: originRef,
+        summary: existing?.summary || (!existing ? spec?.objective : undefined) || base.summary,
+        touches: preferExistingArray(existing?.touches, affectedModules.length > 0 ? affectedModules : base.touches),
+        current_stage: stageForLifecycle(evidence.lifecycle, existing),
+        gates: existing?.gates || spec?.gates || base.gates,
+        acceptance_refs: preferExistingArray(existing?.acceptance_refs, spec?.acceptance_refs ?? base.acceptance_refs),
+        recommended_skills: selectedSkills,
+        produces: preferExistingArray(existing?.produces, contracts.produces.length > 0 ? contracts.produces : base.produces),
+        consumes: preferExistingArray(existing?.consumes, contracts.consumes.length > 0 ? contracts.consumes : base.consumes),
+        frontend_impact_status: preferExistingFrontendStatus(existing, plan, base),
+        frontend_impact_reason: existing?.frontend_impact_reason || plan?.frontend_impact.description || base.frontend_impact_reason,
+        last_sync_at: existing?.last_sync_at || timestamp,
+    };
+    const qualityContract = ensureFeatureQualityContract(merged, originRef || evidence.id);
+    if (!existing?.quality_contract) {
+        qualityContract.unit_target_percent =
+            quality?.coverage_targets.unit ?? plan?.quality_strategy.unit_target ?? qualityContract.unit_target_percent;
+        qualityContract.integration_target_percent =
+            quality?.coverage_targets.integration ??
+                plan?.quality_strategy.integration_target ??
+                qualityContract.integration_target_percent;
+        qualityContract.evidence_mode =
+            plan?.quality_strategy.approach === 'coverage' ||
+                plan?.quality_strategy.approach === 'equivalence' ||
+                plan?.quality_strategy.approach === 'hybrid'
+                ? plan.quality_strategy.approach
+                : qualityContract.evidence_mode;
+    }
+    qualityContract.inherited_from = originRef || qualityContract.inherited_from || evidence.id;
+    qualityContract.updated_at = existing?.quality_contract?.updated_at || qualityContract.updated_at || timestamp;
+    merged.quality_contract = qualityContract;
+    if (evidence.lifecycle === 'archived' && !merged.done_at) {
+        merged.done_at = existing?.done_at || '';
+    }
+    return merged;
+}
+async function discoverWorkspaceFeatures(paths, config, warnings) {
+    const names = activeDocNamesForLayout(config);
+    const roots = [
+        { lifecycle: 'planned', dir: paths.plannedDir },
+        { lifecycle: 'active', dir: paths.activeDir },
+        { lifecycle: 'archived', dir: paths.archivedDir },
+    ];
+    const features = [];
+    for (const root of roots) {
+        const dirs = await listFeatureDirs(root.dir);
+        for (const featureRoot of dirs) {
+            const id = path.basename(featureRoot);
+            features.push({
+                id,
+                lifecycle: root.lifecycle,
+                root: featureRoot,
+                spec: await parseWorkspaceDoc(path.join(featureRoot, names.spec), '1-spec.yaml', warnings, paths),
+                plan: await parseWorkspaceDoc(path.join(featureRoot, names.plan), '2-plan.yaml', warnings, paths),
+                quality: await parseWorkspaceDoc(path.join(featureRoot, names.quality), '5-quality.yaml', warnings, paths),
+            });
+        }
+    }
+    return features;
+}
+async function discoverDiscoveryRecords(paths, timestamp, warnings) {
+    const roots = [
+        { dir: paths.discoveryInsightsDir },
+        { dir: paths.discoveryDebatesDir },
+        { dir: paths.discoveryEpicDir },
+        { dir: paths.discoveryDiscardedDir, discarded: true },
+    ];
+    const records = [];
+    const seen = new Set();
+    for (const root of roots) {
+        const entries = await fs.readdir(root.dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isFile() || path.extname(entry.name).toLowerCase() !== '.md')
+                continue;
+            const idMatch = /^(INS|DEB|RAD|EPIC)-\d{3,}/i.exec(entry.name);
+            if (!idMatch)
+                continue;
+            const id = idMatch[0].toUpperCase();
+            if (seen.has(id))
+                continue;
+            const type = deriveDiscoveryType(id);
+            if (!type)
+                continue;
+            const filePath = path.join(root.dir, entry.name);
+            const content = await fs.readFile(filePath, 'utf-8').catch((error) => {
+                warnings.push(`${relProjectPath(paths, filePath)} ignored during discovery rebuild: ${String(error)}`);
+                return '';
+            });
+            records.push({
+                id,
+                type,
+                title: titleFromMarkdown(content, id, entry.name),
+                title_canonical: computeCanonicalTitle(titleFromMarkdown(content, id, entry.name)),
+                status: discoveryStatusFromMarkdown(content, type, root.discarded === true),
+                origin_prompt: `Reconstructed from ${relProjectPath(paths, filePath)}`,
+                related_ids: [],
+                warning_links: [],
+                created_at: timestamp,
+                updated_at: timestamp,
+            });
+            seen.add(id);
+        }
+    }
+    return records;
+}
+function applyDiscoveryRebuild(current, discovered, features, timestamp) {
+    const report = defaultSectionReport();
+    report.scanned = discovered.length;
+    const recordsById = new Map(current.records.map((record) => [record.id, clone(record)]));
+    for (const diskRecord of discovered) {
+        const existing = recordsById.get(diskRecord.id);
+        if (!existing) {
+            recordsById.set(diskRecord.id, diskRecord);
+            report.created.push(diskRecord.id);
+            continue;
+        }
+        const merged = {
+            ...existing,
+            title: existing.title || diskRecord.title,
+            title_canonical: existing.title_canonical || diskRecord.title_canonical || computeCanonicalTitle(existing.title || diskRecord.title),
+            status: existing.status || diskRecord.status,
+            origin_prompt: existing.origin_prompt || diskRecord.origin_prompt,
+            related_ids: Array.from(new Set([...(existing.related_ids ?? []), ...(diskRecord.related_ids ?? [])])),
+            warning_links: existing.warning_links ?? [],
+            created_at: existing.created_at || diskRecord.created_at,
+            updated_at: existing.updated_at || timestamp,
+        };
+        if (isDeepStrictEqual(existing, merged)) {
+            report.unchanged.push(diskRecord.id);
+        }
+        else {
+            recordsById.set(diskRecord.id, merged);
+            report.updated.push(diskRecord.id);
+        }
+    }
+    for (const feature of features) {
+        const originRef = feature.spec?.origin.ref;
+        if (!originRef)
+            continue;
+        const origin = recordsById.get(originRef);
+        if (!origin || origin.related_ids.includes(feature.id))
+            continue;
+        const updated = {
+            ...origin,
+            related_ids: Array.from(new Set([...origin.related_ids, feature.id])),
+            updated_at: timestamp,
+        };
+        recordsById.set(originRef, updated);
+        if (!report.created.includes(originRef) && !report.updated.includes(originRef)) {
+            report.updated.push(originRef);
+        }
+    }
+    const counters = { ...DEFAULT_COUNTERS, ...current.counters };
+    const records = Array.from(recordsById.values()).sort((left, right) => left.id.localeCompare(right.id));
+    for (const record of records) {
+        syncCounterFromId(counters, record.id);
+    }
+    for (const feature of features) {
+        syncCounterFromId(counters, feature.id);
+    }
+    const state = DiscoveryIndexStateSchema.parse({
+        ...current,
+        counters,
+        records,
+    });
+    return { state, report };
+}
+function applyBacklogRebuild(current, features, warnings, paths, timestamp) {
+    const report = {
+        ...defaultSectionReport(),
+        workspaces: {
+            planned: features.filter((feature) => feature.lifecycle === 'planned').length,
+            active: features.filter((feature) => feature.lifecycle === 'active').length,
+            archived: features.filter((feature) => feature.lifecycle === 'archived').length,
+        },
+    };
+    report.scanned = features.length;
+    const itemsById = new Map(current.items.map((item) => [item.id, clone(item)]));
+    for (const feature of features) {
+        const existing = itemsById.get(feature.id);
+        const rebuilt = buildFeatureFromEvidence(feature, existing, warnings, paths, timestamp);
+        if (!rebuilt) {
+            report.skipped.push(feature.id);
+            continue;
+        }
+        if (!existing) {
+            itemsById.set(feature.id, rebuilt);
+            report.created.push(feature.id);
+            continue;
+        }
+        if (isDeepStrictEqual(existing, rebuilt)) {
+            report.unchanged.push(feature.id);
+            continue;
+        }
+        rebuilt.last_sync_at = timestamp;
+        if (rebuilt.quality_contract) {
+            rebuilt.quality_contract.updated_at = timestamp;
+        }
+        itemsById.set(feature.id, rebuilt);
+        report.updated.push(feature.id);
+    }
+    const state = BacklogStateSchema.parse({
+        ...current,
+        items: Array.from(itemsById.values()).sort((left, right) => left.id.localeCompare(right.id)),
+    });
+    return { state, report };
+}
+function shouldRender(config, options) {
+    if (options.dryRun)
+        return false;
+    if (options.render === false)
+        return false;
+    return options.render === true || config.views.autoRender;
+}
+export class SddRebuildService {
+    async execute(projectRoot = '.', options = {}) {
+        if (!options.fromDisk) {
+            throw new Error('Use --from-disk to rebuild canonical SDD state from workspace and discovery files.');
+        }
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        await ensureMemoryInitialized(paths);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const timestamp = nowIso();
+        const warnings = [];
+        const features = await discoverWorkspaceFeatures(paths, config, warnings);
+        const discovered = await discoverDiscoveryRecords(paths, timestamp, warnings);
+        const discovery = applyDiscoveryRebuild(snapshot.discoveryIndex, discovered, features, timestamp);
+        const backlog = applyBacklogRebuild(snapshot.backlog, features, warnings, paths, timestamp);
+        const render = shouldRender(config, options);
+        if (!options.dryRun) {
+            await saveStateTransaction(paths, {
+                discoveryIndex: discovery.state,
+                backlog: backlog.state,
+            });
+            if (render) {
+                const rebuiltSnapshot = {
+                    ...snapshot,
+                    discoveryIndex: discovery.state,
+                    backlog: backlog.state,
+                };
+                await renderViews(paths, config, rebuiltSnapshot);
+            }
+        }
+        return {
+            mode: 'from-disk',
+            dryRun: options.dryRun === true,
+            rendered: render,
+            discovery: discovery.report,
+            backlog: backlog.report,
+            warnings,
+        };
+    }
+}
+export function formatSddRebuildReport(report) {
+    const lines = [
+        `Rebuild mode: ${report.mode}`,
+        `Dry run: ${report.dryRun ? 'yes' : 'no'}`,
+        `Views rendered: ${report.rendered ? 'yes' : 'no'}`,
+        `Discovery scanned: ${report.discovery.scanned}`,
+        `Discovery created: ${report.discovery.created.join(', ') || '-'}`,
+        `Discovery updated: ${report.discovery.updated.join(', ') || '-'}`,
+        `Backlog workspaces: planned=${report.backlog.workspaces.planned}, active=${report.backlog.workspaces.active}, archived=${report.backlog.workspaces.archived}`,
+        `Backlog created: ${report.backlog.created.join(', ') || '-'}`,
+        `Backlog updated: ${report.backlog.updated.join(', ') || '-'}`,
+        `Backlog skipped: ${report.backlog.skipped.join(', ') || '-'}`,
+    ];
+    if (report.warnings.length > 0) {
+        lines.push('Warnings:');
+        for (const warning of report.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=rebuild.service.js.map

package/dist/core/sdd/services/scan-naming.service.d.ts

@@ -0,0 +1,43 @@
+export interface ScanNamingViolation {
+    file: string;
+    term: string;
+    count: number;
+    severity: 'error' | 'warning';
+}
+export interface ScanNamingIdentity {
+    productName: string;
+    cliBin: string;
+    packageName: string;
+}
+export interface ScanNamingReport {
+    scannedFiles: number;
+    violations: ScanNamingViolation[];
+    errorCount: number;
+    warningCount: number;
+    contractVersion: number;
+    contract: {
+        productName: string;
+        cliBin: string;
+        packageName: string;
+        currentIdentity: ScanNamingIdentity;
+        targetIdentity: ScanNamingIdentity;
+        forbiddenTerms: number;
+        allowlistEntries: number;
+        renameRules: number;
+        zeroResidueGate: {
+            enabled: boolean;
+            enforcement: 'error' | 'warning';
+            terms: number;
+            removalPhase: string;
+        };
+    };
+}
+export interface ScanNamingOptions {
+    strict?: boolean;
+    json?: boolean;
+}
+export declare class ScanNamingService {
+    execute(projectRoot: string, options?: ScanNamingOptions): Promise<ScanNamingReport>;
+}
+export declare function formatScanNamingReport(report: ScanNamingReport): string;
+//# sourceMappingURL=scan-naming.service.d.ts.map