@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/services/frontend-gap.service.d.ts

@@ -0,0 +1,23 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class FrontendGapService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    add(projectRoot: string, title: string, options?: {
+        originFeature?: string;
+        routes?: string[];
+        menu?: string[];
+        render?: boolean;
+    }): Promise<{
+        id: string;
+    }>;
+    resolve(projectRoot: string, gapId: string, options?: {
+        feature?: string;
+        files?: string[];
+        routes?: string[];
+        render?: boolean;
+    }): Promise<{
+        id: string;
+        status: "DONE";
+    }>;
+}
+//# sourceMappingURL=frontend-gap.service.d.ts.map

package/dist/core/sdd/services/frontend-gap.service.js

@@ -0,0 +1,117 @@
+import { CLI_NAME } from "../../branding.js";
+import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
+import { slugify, getRuntime, persistAndRender } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class FrontendGapService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async add(projectRoot, title, options) {
+        if (!title.trim()) {
+            throw new Error('Titulo do gap vazio.');
+        }
+        const { config, paths } = await getRuntime(projectRoot);
+        if (!config.frontend.enabled) {
+            throw new Error(`Modulo de frontend desativado. Execute "${CLI_NAME} sdd init --frontend".`);
+        }
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const id = await allocateEntityId(paths, 'FGAP');
+            const now = nowIso();
+            snapshot.frontendGaps.items.push({
+                id,
+                title: title.trim(),
+                status: 'OPEN',
+                origin_kind: 'manual',
+                detection_sources: ['manual'],
+                origin_feature: options?.originFeature || '',
+                backend_refs: [],
+                frontend_scope: '',
+                route_targets: options?.routes || [],
+                menu_targets: options?.menu || [],
+                suggested_files: [],
+                implemented_files: [],
+                resolved_by_feature: '',
+                related_route_ids: [],
+                notes: '',
+                created_at: now,
+                updated_at: now,
+            });
+            for (const routePath of options?.routes || []) {
+                const routeId = `route-${slugify(routePath) || 'root'}`;
+                const existing = snapshot.frontendMap.routes.find((route) => route.id === routeId);
+                if (existing) {
+                    existing.ui_status = existing.ui_status === 'OK' ? 'PARTIAL' : existing.ui_status;
+                    existing.source_gap_ids = Array.from(new Set([...existing.source_gap_ids, id]));
+                }
+                else {
+                    snapshot.frontendMap.routes.push({
+                        id: routeId,
+                        path: routePath,
+                        parent_id: '',
+                        label: '',
+                        nav_surface: '',
+                        ui_status: 'GAP',
+                        source_gap_ids: [id],
+                        implemented_files: [],
+                        notes: '',
+                    });
+                }
+            }
+            await saveStateTransaction(paths, {
+                frontendGaps: snapshot.frontendGaps,
+                frontendMap: snapshot.frontendMap,
+            });
+            await persistAndRender(paths, config, options?.render);
+            return { id };
+        });
+    }
+    async resolve(projectRoot, gapId, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        if (!config.frontend.enabled) {
+            throw new Error(`Modulo de frontend desativado. Execute "${CLI_NAME} sdd init --frontend".`);
+        }
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const gap = snapshot.frontendGaps.items.find((item) => item.id === gapId);
+            if (!gap) {
+                throw new Error(`Gap ${gapId} nao encontrado.`);
+            }
+            const now = nowIso();
+            gap.status = 'DONE';
+            gap.resolved_by_feature = options?.feature || '';
+            gap.implemented_files = options?.files || [];
+            gap.updated_at = now;
+            const routeTargets = new Set([...(gap.route_targets || []), ...(options?.routes || [])]);
+            for (const routePath of routeTargets) {
+                const routeId = `route-${slugify(routePath) || 'root'}`;
+                const route = snapshot.frontendMap.routes.find((entry) => entry.id === routeId);
+                if (!route) {
+                    snapshot.frontendMap.routes.push({
+                        id: routeId,
+                        path: routePath,
+                        parent_id: '',
+                        label: '',
+                        nav_surface: '',
+                        ui_status: 'OK',
+                        source_gap_ids: [gap.id],
+                        implemented_files: options?.files || [],
+                        notes: '',
+                    });
+                    continue;
+                }
+                route.ui_status = 'OK';
+                route.implemented_files = Array.from(new Set([...(route.implemented_files || []), ...(options?.files || [])]));
+                route.source_gap_ids = Array.from(new Set([...(route.source_gap_ids || []), gap.id]));
+            }
+            await saveStateTransaction(paths, {
+                frontendGaps: snapshot.frontendGaps,
+                frontendMap: snapshot.frontendMap,
+            });
+            await persistAndRender(paths, config, options?.render);
+            return { id: gap.id, status: gap.status };
+        });
+    }
+}
+//# sourceMappingURL=frontend-gap.service.js.map

package/dist/core/sdd/services/frontend-impact.service.d.ts

@@ -0,0 +1,19 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class FrontendImpactService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, featureId: string, options: {
+        status: 'unknown' | 'none' | 'required';
+        reason?: string;
+        routes?: string[];
+        surfaces?: string[];
+        render?: boolean;
+    }): Promise<{
+        feature_id: string;
+        frontend_impact_status: "unknown" | "none" | "required";
+        frontend_impact_reason: string;
+        frontend_impact_declared_at: string;
+        frontend_surface_tokens: string[];
+    }>;
+}
+//# sourceMappingURL=frontend-impact.service.d.ts.map

package/dist/core/sdd/services/frontend-impact.service.js

@@ -0,0 +1,46 @@
+import { CLI_NAME } from "../../branding.js";
+import { loadStateSnapshot, nowIso, saveBacklogState } from "../state.js";
+import { getRuntime, persistAndRender, resolveFeat } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class FrontendImpactService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, featureId, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        if (!config.frontend.enabled && options.status !== 'none') {
+            throw new Error(`Modulo de frontend desativado. Execute "${CLI_NAME} sdd init --frontend".`);
+        }
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const feature = resolveFeat(snapshot.backlog.items, featureId);
+            const status = options.status;
+            const reason = (options.reason || '').trim();
+            if (status === 'none' && reason.length < 20) {
+                throw new Error('Para frontend_impact=none, informe --reason com no minimo 20 caracteres.');
+            }
+            const routeTokens = (options.routes || [])
+                .map((route) => route.trim())
+                .filter(Boolean)
+                .map((route) => (route.startsWith('/') ? route : `/${route}`))
+                .map((route) => `route:${route}`);
+            const extraSurfaces = (options.surfaces || []).map((surface) => surface.trim()).filter(Boolean);
+            feature.frontend_surface_tokens = Array.from(new Set([...(feature.frontend_surface_tokens || []), ...routeTokens, ...extraSurfaces]));
+            feature.frontend_impact_status = status;
+            feature.frontend_impact_reason = reason;
+            feature.frontend_impact_declared_at = nowIso();
+            feature.last_sync_at = feature.frontend_impact_declared_at;
+            await saveBacklogState(paths, snapshot.backlog);
+            await persistAndRender(paths, config, options.render);
+            return {
+                feature_id: feature.id,
+                frontend_impact_status: feature.frontend_impact_status,
+                frontend_impact_reason: feature.frontend_impact_reason || '',
+                frontend_impact_declared_at: feature.frontend_impact_declared_at || '',
+                frontend_surface_tokens: feature.frontend_surface_tokens,
+            };
+        });
+    }
+}
+//# sourceMappingURL=frontend-impact.service.js.map

package/dist/core/sdd/services/ingest-deposito.service.d.ts

@@ -0,0 +1,32 @@
+import { FlowMode, Scale } from "../types.js";
+import { SddStores } from "../store/sdd-stores.js";
+export declare class IngestDepositoService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    private computeSourceFingerprint;
+    execute(projectRoot: string, options?: {
+        sourceDir?: string;
+        title?: string;
+        radarId?: string;
+        titles?: string[];
+        scale?: Scale;
+        flowMode?: FlowMode;
+        start?: boolean;
+        render?: boolean;
+    }): Promise<{
+        source_dir: string;
+        scanned_files: number;
+        indexed_created: number;
+        indexed_updated: number;
+        radar_id: string;
+        created_features: string[];
+        linked_existing: string[];
+        started_feature_id: string;
+        active_path: string;
+        generated_docs: string[];
+        start_warning: string;
+        used_skills: string[];
+        recommended_prompt: string;
+    }>;
+}
+//# sourceMappingURL=ingest-deposito.service.d.ts.map

package/dist/core/sdd/services/ingest-deposito.service.js

@@ -0,0 +1,231 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { CLI_NAME } from "../../branding.js";
+import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
+import { slugify, markdownRadarFromDepositoTemplate, sourceTypeFromRelativePath, defaultConsolidationTargets, deriveInitialFeatureTitles, listFilesRecursively, sourceTitleFromPath, normalizeSourceStatus, nextSourceId, extractSourceSummary, syncCounterFromId, getRuntime, persistAndRender, relProjectPath, resolveRadar, featureReadiness, pathExists } from "../legacy-operations.js";
+import { BreakdownService } from "./breakdown.service.js";
+import { StartService } from "./start.service.js";
+import { withStateLock } from "../state-lock.js";
+export class IngestDepositoService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    computeSourceFingerprint(type, title, summary) {
+        const normalized = `${type}|${title}|${summary}`.trim().toLowerCase();
+        let hash = 0;
+        for (let i = 0; i < normalized.length; i += 1) {
+            hash = ((hash << 5) - hash + normalized.charCodeAt(i)) | 0;
+        }
+        return `fp-${Math.abs(hash)}`;
+    }
+    async execute(projectRoot, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const now = nowIso();
+        const sourceDir = options?.sourceDir
+            ? path.resolve(projectRoot, options.sourceDir)
+            : paths.depositoDir;
+        const sourceDirExists = await pathExists(sourceDir);
+        if (!sourceDirExists) {
+            throw new Error(`Diretorio de deposito nao encontrado: ${sourceDir}`);
+        }
+        const scannedFiles = (await listFilesRecursively(sourceDir))
+            .filter((filePath) => !path.basename(filePath).startsWith('.'))
+            .filter((filePath) => path.basename(filePath).toLowerCase() !== 'readme.md')
+            .sort((a, b) => a.localeCompare(b));
+        if (scannedFiles.length === 0) {
+            throw new Error('Nenhuma fonte encontrada no deposito. Adicione arquivos e rode novamente.');
+        }
+        const sourceByPath = new Map(snapshot.sourceIndex.sources.map((source) => [source.path.replace(/\\/g, '/'), source]));
+        const scannedSourceRefs = new Set();
+        let indexedCreated = 0;
+        let indexedUpdated = 0;
+        for (const filePath of scannedFiles) {
+            const relative = relProjectPath(paths, filePath);
+            const normalizedPath = relative.replace(/\\/g, '/');
+            const type = sourceTypeFromRelativePath(normalizedPath);
+            const title = sourceTitleFromPath(filePath);
+            const summary = await extractSourceSummary(filePath);
+            const fingerprint = this.computeSourceFingerprint(type, title, summary || '');
+            const existing = sourceByPath.get(normalizedPath);
+            if (!existing) {
+                const id = nextSourceId(snapshot.sourceIndex.sources.map((source) => source.id));
+                const created = {
+                    id,
+                    type,
+                    path: normalizedPath,
+                    title,
+                    status: 'INDEXED',
+                    source_version: 1,
+                    source_fingerprint: fingerprint,
+                    authority: 'unknown',
+                    source_url: '',
+                    source_classification: 'other',
+                    jurisdiction_tags: [],
+                    last_verified_at: '',
+                    verification_status: 'unverified',
+                    verification_notes: '',
+                    legal_validation_required: false,
+                    summary,
+                    imported_at: now,
+                    updated_at: now,
+                    used_by: [],
+                    notes: [],
+                    consolidation_targets: defaultConsolidationTargets(type),
+                };
+                snapshot.sourceIndex.sources.push(created);
+                const versionEvent = {
+                    id: `${created.id}-v1`,
+                    source_id: created.id,
+                    version: 1,
+                    changed_at: now,
+                    reason: 'ingest_create',
+                    actor: CLI_NAME,
+                    summary: `Initial source registration from ${normalizedPath}`,
+                };
+                snapshot.sourceIndex.version_events.push(versionEvent);
+                sourceByPath.set(normalizedPath, created);
+                scannedSourceRefs.add(created.id);
+                indexedCreated += 1;
+                continue;
+            }
+            const previousFingerprint = existing.source_fingerprint || '';
+            const previousVersion = typeof existing.source_version === 'number' && existing.source_version > 0
+                ? existing.source_version
+                : 1;
+            existing.type = type;
+            existing.title = existing.title || title;
+            existing.status = normalizeSourceStatus(existing.status, 'INDEXED');
+            existing.summary = existing.summary || summary;
+            existing.updated_at = now;
+            existing.source_classification = existing.source_classification || 'other';
+            existing.authority = existing.authority || 'unknown';
+            existing.verification_status = existing.verification_status || 'unverified';
+            existing.jurisdiction_tags = Array.isArray(existing.jurisdiction_tags)
+                ? existing.jurisdiction_tags
+                : [];
+            existing.legal_validation_required = Boolean(existing.legal_validation_required);
+            existing.source_fingerprint = existing.source_fingerprint || previousFingerprint;
+            existing.source_version = previousVersion;
+            existing.consolidation_targets = Array.from(new Set([...existing.consolidation_targets, ...defaultConsolidationTargets(type)]));
+            if (!existing.source_fingerprint || existing.source_fingerprint !== fingerprint) {
+                existing.source_version = previousVersion + 1;
+                existing.source_fingerprint = fingerprint;
+                snapshot.sourceIndex.version_events.push({
+                    id: `${existing.id}-v${existing.source_version}`,
+                    source_id: existing.id,
+                    version: existing.source_version,
+                    changed_at: now,
+                    reason: 'ingest_update',
+                    actor: CLI_NAME,
+                    summary: `Source metadata or summary changed for ${normalizedPath}`,
+                });
+            }
+            scannedSourceRefs.add(existing.id);
+            indexedUpdated += 1;
+        }
+        let radarId = options?.radarId || '';
+        let radar = radarId
+            ? snapshot.discoveryIndex.records.find((record) => record.id === radarId && (record.type === 'RAD' || record.type === 'EPIC'))
+            : undefined;
+        if (!radar) {
+            radarId = await allocateEntityId(paths, 'EPIC');
+            syncCounterFromId(snapshot.discoveryIndex, radarId);
+            radar = {
+                id: radarId,
+                type: 'EPIC',
+                title: (options?.title || 'Planejamento inicial a partir do deposito').slice(0, 120),
+                status: 'READY',
+                origin_prompt: `Gerado por ingestao de deposito em ${now}`,
+                related_ids: [],
+                warning_links: [],
+                created_at: now,
+                updated_at: now,
+            };
+            snapshot.discoveryIndex.records.push(radar);
+            const radarPath = path.join(paths.discoveryEpicDir, `${radarId}-${slugify(radar.title)}.md`);
+            await fs.writeFile(radarPath, markdownRadarFromDepositoTemplate(radarId, radar.title, scannedFiles.length, options?.title), 'utf-8');
+        }
+        resolveRadar(radar);
+        await withStateLock(paths.stateDir, async () => {
+            await saveStateTransaction(paths, {
+                discoveryIndex: snapshot.discoveryIndex,
+                sourceIndex: snapshot.sourceIndex,
+            });
+        });
+        const plannedTitles = options?.titles && options.titles.length > 0
+            ? options.titles.filter((title) => title.trim().length > 0)
+            : deriveInitialFeatureTitles(snapshot.sourceIndex.sources.filter((source) => scannedSourceRefs.has(source.id)), config.frontend.enabled);
+        const breakdownResult = await new BreakdownService(this.stores).execute(projectRoot, radarId, {
+            titles: plannedTitles,
+            scale: options?.scale || 'STANDARD',
+            mode: 'graph',
+            incremental: true,
+            dedupe: 'normal',
+            render: false,
+        });
+        const postPlan = await loadStateSnapshot(paths, config);
+        const usedByRefs = [radarId, ...breakdownResult.created, ...breakdownResult.linked_existing];
+        for (const source of postPlan.sourceIndex.sources) {
+            if (!scannedSourceRefs.has(source.id))
+                continue;
+            source.used_by = Array.from(new Set([...source.used_by, ...usedByRefs]));
+            source.status = normalizeSourceStatus(source.status, 'PLANNED');
+            source.updated_at = nowIso();
+            source.consolidation_targets = Array.from(new Set([...source.consolidation_targets, 'radar', 'backlog']));
+        }
+        await withStateLock(paths.stateDir, async () => {
+            await saveStateTransaction(paths, { sourceIndex: postPlan.sourceIndex });
+        });
+        const shouldStart = options?.start ?? true;
+        let startedFeatureId = '';
+        let activePath = '';
+        let generatedDocs = [];
+        let startWarning = '';
+        if (shouldStart) {
+            const candidateIds = new Set([...breakdownResult.created, ...breakdownResult.linked_existing]);
+            const candidates = postPlan.backlog.items
+                .filter((item) => candidateIds.has(item.id))
+                .filter((item) => featureReadiness(item, postPlan.backlog.items) === 'READY')
+                .sort((a, b) => a.id.localeCompare(b.id));
+            const candidate = candidates[0];
+            if (candidate) {
+                const started = await new StartService(this.stores).execute(projectRoot, candidate.id, {
+                    scale: options?.scale,
+                    flowMode: options?.flowMode,
+                    render: false,
+                });
+                startedFeatureId = started.featureId;
+                activePath = started.active_path;
+                generatedDocs = started.generated_docs;
+            }
+            else {
+                startWarning =
+                    'Nenhuma FEAT pronta para iniciar automaticamente (dependencias/locks pendentes). Use "opensdd sdd next".';
+            }
+        }
+        await persistAndRender(paths, config, options?.render);
+        return {
+            source_dir: relProjectPath(paths, sourceDir),
+            scanned_files: scannedFiles.length,
+            indexed_created: indexedCreated,
+            indexed_updated: indexedUpdated,
+            radar_id: radarId,
+            created_features: breakdownResult.created,
+            linked_existing: breakdownResult.linked_existing,
+            started_feature_id: startedFeatureId,
+            active_path: activePath,
+            generated_docs: generatedDocs,
+            start_warning: startWarning,
+            used_skills: [
+                'source-intake-sdd',
+                'business-extractor-sdd',
+                'frontend-extractor-sdd',
+                'planning-normalizer-sdd',
+            ],
+            recommended_prompt: relProjectPath(paths, path.join(paths.promptsDir, '01-ingestao-deposito.md')),
+        };
+    }
+}
+//# sourceMappingURL=ingest-deposito.service.js.map

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

@@ -0,0 +1,21 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class InsightService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, text: string, options?: {
+        title?: string;
+        render?: boolean;
+    }): Promise<{
+        id: string;
+        title: string;
+        filePath: string;
+        warnings: {
+            level: "warning";
+            entity_id: string;
+            score: number;
+            message: string;
+        }[];
+        reused: boolean;
+    }>;
+}
+//# sourceMappingURL=insight.service.d.ts.map

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

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
+import { normalizeSemanticText, warnAndLink } from "../dedup.js";
+import { slugify, computeCanonicalTitle, markdownInsightTemplate, syncCounterFromId, getRuntime, persistAndRender } from "../legacy-operations.js";
+import { withStateLock } from "../state-lock.js";
+export class InsightService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, text, options) {
+        const trimmed = text.trim();
+        if (!trimmed) {
+            throw new Error('Insight vazio. Informe um texto para registrar.');
+        }
+        const { config, paths } = await getRuntime(projectRoot);
+        return withStateLock(paths.stateDir, async () => {
+            const snapshot = await loadStateSnapshot(paths, config);
+            const title = (options?.title || trimmed.split('\n')[0] || 'Insight sem titulo').slice(0, 120);
+            const titleCanonical = computeCanonicalTitle(title);
+            const promptCanonical = normalizeSemanticText(trimmed);
+            const existingInsight = snapshot.discoveryIndex.records.find((existing) => existing.type === 'INS' &&
+                normalizeSemanticText(existing.origin_prompt || '') === promptCanonical &&
+                (existing.title_canonical || computeCanonicalTitle(existing.title)) === titleCanonical);
+            if (existingInsight) {
+                return {
+                    id: existingInsight.id,
+                    title: existingInsight.title,
+                    filePath: path.join(paths.discoveryInsightsDir, `${existingInsight.id}-${slugify(existingInsight.title)}.md`),
+                    warnings: [],
+                    reused: true,
+                };
+            }
+            const id = await allocateEntityId(paths, 'INS');
+            syncCounterFromId(snapshot.discoveryIndex, id);
+            const now = nowIso();
+            const record = {
+                id,
+                type: 'INS',
+                title,
+                title_canonical: titleCanonical,
+                status: 'NEW',
+                origin_prompt: trimmed,
+                related_ids: [],
+                warning_links: [],
+                created_at: now,
+                updated_at: now,
+            };
+            const semanticWarning = warnAndLink('INS', titleCanonical, snapshot.discoveryIndex.records
+                .filter((existing) => existing.type === 'INS' || existing.type === 'DEB')
+                .map((existing) => ({
+                id: existing.id,
+                title: existing.title_canonical || existing.title,
+            })));
+            if (semanticWarning.severity === 'warning') {
+                record.warning_links = semanticWarning.warningLinks;
+            }
+            snapshot.discoveryIndex.records.push(record);
+            await saveStateTransaction(paths, { discoveryIndex: snapshot.discoveryIndex });
+            const filePath = path.join(paths.discoveryInsightsDir, `${id}-${slugify(title)}.md`);
+            await fs.writeFile(filePath, markdownInsightTemplate(id, title, trimmed), 'utf-8');
+            await persistAndRender(paths, config, options?.render);
+            return {
+                id,
+                title,
+                filePath,
+                warnings: semanticWarning.severity === 'warning'
+                    ? semanticWarning.candidates.map((candidate) => ({
+                        level: 'warning',
+                        entity_id: candidate.id,
+                        score: candidate.score,
+                        message: `Possível duplicidade semântica com ${candidate.id} (${candidate.score.toFixed(2)})`,
+                    }))
+                    : [],
+                reused: false,
+            };
+        });
+    }
+}
+//# sourceMappingURL=insight.service.js.map

package/dist/core/sdd/services/legacy-capability.service.d.ts

@@ -0,0 +1,24 @@
+export interface LegacyCapabilityDefinition {
+    id: string;
+    displayName: string;
+    liveRootDir: string;
+    importedRootSegments: string[];
+    importedDepositoSegments: string[];
+    deprecatedImportedRootSegments?: string[][];
+}
+export declare const OPENSPEC_LEGACY_CAPABILITY: LegacyCapabilityDefinition;
+export declare const LEGACY_OPENSPEC_DIR: string;
+export declare const IMPORTED_OPENSPEC_DIR: string;
+export declare function resolveLegacyCapabilityLiveRoot(projectRoot: string, capability?: LegacyCapabilityDefinition): string;
+export declare function resolveLegacyCapabilityLiveSubpath(projectRoot: string, capability: LegacyCapabilityDefinition, ...segments: string[]): string;
+export declare function resolveLegacyCapabilityImportedRoot(projectRoot: string, capability?: LegacyCapabilityDefinition): string;
+export declare function resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot: string, capability?: LegacyCapabilityDefinition): string[];
+export declare function resolveLegacyCapabilityImportedDepositoRoot(depositoDir: string, capability?: LegacyCapabilityDefinition): string;
+export declare function resolveLegacyCapabilityRoot(projectRoot?: string, capability?: LegacyCapabilityDefinition): string;
+export declare function resolveLegacyCapabilitySubpath(projectRoot: string, capability: LegacyCapabilityDefinition, ...segments: string[]): string;
+export declare function displayLegacyCapabilityPath(capability: LegacyCapabilityDefinition, ...segments: string[]): string;
+export declare function resolveOpenSpecRoot(projectRoot?: string): string;
+export declare function resolveOpenSpecSubpath(projectRoot: string, ...segments: string[]): string;
+export declare function resolveOpenSpecLiveSubpath(projectRoot: string, ...segments: string[]): string;
+export declare function displayLegacyOpenSpecPath(...segments: string[]): string;
+//# sourceMappingURL=legacy-capability.service.d.ts.map

package/dist/core/sdd/services/legacy-capability.service.js

@@ -0,0 +1,59 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+export const OPENSPEC_LEGACY_CAPABILITY = {
+    id: 'openspec',
+    displayName: 'OpenSpec',
+    liveRootDir: 'openspec',
+    importedRootSegments: ['.sdd', 'sources', 'legacy', 'spec-corpus'],
+    importedDepositoSegments: ['legacy', 'spec-corpus'],
+    deprecatedImportedRootSegments: [['.sdd', 'sources', 'legado', 'openspec']],
+};
+export const LEGACY_OPENSPEC_DIR = OPENSPEC_LEGACY_CAPABILITY.liveRootDir;
+export const IMPORTED_OPENSPEC_DIR = path.join(...OPENSPEC_LEGACY_CAPABILITY.importedRootSegments);
+export function resolveLegacyCapabilityLiveRoot(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
+    return path.join(projectRoot, capability.liveRootDir);
+}
+export function resolveLegacyCapabilityLiveSubpath(projectRoot, capability, ...segments) {
+    return path.join(resolveLegacyCapabilityLiveRoot(projectRoot, capability), ...segments);
+}
+export function resolveLegacyCapabilityImportedRoot(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
+    return path.join(projectRoot, ...capability.importedRootSegments);
+}
+export function resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
+    return (capability.deprecatedImportedRootSegments || []).map((segments) => path.join(projectRoot, ...segments));
+}
+export function resolveLegacyCapabilityImportedDepositoRoot(depositoDir, capability = OPENSPEC_LEGACY_CAPABILITY) {
+    return path.join(depositoDir, ...capability.importedDepositoSegments);
+}
+export function resolveLegacyCapabilityRoot(projectRoot = process.cwd(), capability = OPENSPEC_LEGACY_CAPABILITY) {
+    const liveRoot = resolveLegacyCapabilityLiveRoot(projectRoot, capability);
+    if (existsSync(liveRoot))
+        return liveRoot;
+    const importedRoot = resolveLegacyCapabilityImportedRoot(projectRoot, capability);
+    if (existsSync(importedRoot))
+        return importedRoot;
+    for (const deprecatedRoot of resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot, capability)) {
+        if (existsSync(deprecatedRoot))
+            return deprecatedRoot;
+    }
+    return liveRoot;
+}
+export function resolveLegacyCapabilitySubpath(projectRoot, capability, ...segments) {
+    return path.join(resolveLegacyCapabilityRoot(projectRoot, capability), ...segments);
+}
+export function displayLegacyCapabilityPath(capability, ...segments) {
+    return path.join(capability.liveRootDir, ...segments);
+}
+export function resolveOpenSpecRoot(projectRoot = process.cwd()) {
+    return resolveLegacyCapabilityRoot(projectRoot, OPENSPEC_LEGACY_CAPABILITY);
+}
+export function resolveOpenSpecSubpath(projectRoot, ...segments) {
+    return resolveLegacyCapabilitySubpath(projectRoot, OPENSPEC_LEGACY_CAPABILITY, ...segments);
+}
+export function resolveOpenSpecLiveSubpath(projectRoot, ...segments) {
+    return resolveLegacyCapabilityLiveSubpath(projectRoot, OPENSPEC_LEGACY_CAPABILITY, ...segments);
+}
+export function displayLegacyOpenSpecPath(...segments) {
+    return displayLegacyCapabilityPath(OPENSPEC_LEGACY_CAPABILITY, ...segments);
+}
+//# sourceMappingURL=legacy-capability.service.js.map