@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/domain/transition-engine.js

@@ -0,0 +1,120 @@
+export class TransitionEngine {
+    transitionLogStore;
+    static allowedTransitions = {
+        INS: {
+            NEW: ['DEBATED', 'DISCARDED'],
+        },
+        DEB: {
+            OPEN: ['APPROVED', 'DISCARDED'],
+        },
+        EPIC: {
+            READY: ['PLANNED', 'SPLIT', 'IN_PROGRESS', 'ARCHIVED'],
+            PLANNED: ['IN_PROGRESS', 'ARCHIVED'],
+            SPLIT: ['DONE', 'ARCHIVED'],
+            IN_PROGRESS: ['DONE', 'ARCHIVED'],
+            DONE: ['ARCHIVED'],
+        },
+        RAD: {
+            READY: ['PLANNED', 'SPLIT', 'IN_PROGRESS', 'ARCHIVED'],
+            PLANNED: ['IN_PROGRESS', 'ARCHIVED'],
+            SPLIT: ['DONE', 'ARCHIVED'],
+            IN_PROGRESS: ['DONE', 'ARCHIVED'],
+            DONE: ['ARCHIVED'],
+        },
+        FEAT: {
+            READY: ['IN_PROGRESS', 'BLOCKED', 'ARCHIVED'],
+            BLOCKED: ['READY', 'IN_PROGRESS', 'ARCHIVED'],
+            IN_PROGRESS: ['DONE', 'BLOCKED', 'ARCHIVED'],
+            DONE: ['ARCHIVED'],
+            ARCHIVED: [],
+        },
+    };
+    constructor(transitionLogStore) {
+        this.transitionLogStore = transitionLogStore;
+    }
+    /**
+     * Valida se a transição de estado desejada é logicamente permitida pelo grafo de transições,
+     * e bloqueia transições caso haja violações arquiteturais ou de lente documental.
+     */
+    static assertValid(entityType, fromStatus, toStatus, options) {
+        const typeGraph = TransitionEngine.allowedTransitions[entityType];
+        if (!typeGraph) {
+            throw new Error(`Tipo de entidade não reconhecido pelo motor de transição: ${entityType}`);
+        }
+        const permittedTargets = typeGraph[fromStatus];
+        if (!permittedTargets) {
+            throw new Error(`Status de origem '${fromStatus}' inválido para a entidade ${entityType}.`);
+        }
+        if (!permittedTargets.includes(toStatus)) {
+            throw new Error(`Transição estrutural bloqueada (Transition Engine): ${entityType} não pode transitar de '${fromStatus}' para '${toStatus}'. (Permitidos: ${permittedTargets.join(', ')})`);
+        }
+        if (options?.lensViolations && options.lensViolations.length > 0) {
+            if (!options.forceTransition) {
+                throw new Error(`Transição de estado negada. Artefatos bloqueados pelas Lentes Estruturais:\n- ${options.lensViolations.join('\n- ')}\n\nUtilize a flag --force-transition se julgar tratar-se de um bypass válido.`);
+            }
+            else {
+                console.warn(`[WARNING] Transição forçada de ${entityType} para ${toStatus} ignorando as seguintes violações de Lente:\n- ${options.lensViolations.join('\n- ')}`);
+            }
+        }
+    }
+    /**
+     * LEGACY: Synchronous transition for operations.ts monolithic snapshot logic.
+     * Do not use in new Domain Services.
+     */
+    static legacyApplyTransition(entityType, entity, toStatus, transitionLog, options) {
+        const fromStatus = entity.status;
+        TransitionEngine.assertValid(entityType, fromStatus, toStatus, options);
+        const event = {
+            entity_type: entityType,
+            entity_id: entity.id,
+            from: fromStatus,
+            to: toStatus,
+            actor: options?.actor || 'system',
+            reason: options?.reason || '',
+            timestamp: options?.timestamp || new Date().toISOString(),
+            source_command: options?.sourceCommand || 'unknown',
+            force_transition: Boolean(options?.forceTransition),
+            lens_violations: options?.lensViolations || [],
+        };
+        entity.status = toStatus;
+        options?.afterTransition?.(entity);
+        transitionLog.push(event);
+        return event;
+    }
+    async applyTransition(entityType, entity, toStatus, options) {
+        const fromStatus = entity.status;
+        TransitionEngine.assertValid(entityType, fromStatus, toStatus, options);
+        const event = {
+            entity_type: entityType,
+            entity_id: entity.id,
+            from: fromStatus,
+            to: toStatus,
+            actor: options?.actor || 'system',
+            reason: options?.reason || '',
+            timestamp: options?.timestamp || new Date().toISOString(),
+            source_command: options?.sourceCommand || 'unknown',
+            force_transition: Boolean(options?.forceTransition),
+            lens_violations: options?.lensViolations || [],
+        };
+        entity.status = toStatus;
+        options?.afterTransition?.(entity);
+        // Save to StateStore
+        const logState = await this.transitionLogStore.load();
+        logState.events.push(event);
+        await this.transitionLogStore.save(logState);
+        return event;
+    }
+    /**
+     * Validações de negócio granulares antes de finalizações ou progressos de FEAT.
+     */
+    validateFeatureStartGuardrails(feature) {
+        // Estas são verificações já implementadas parcialmente nas operações,
+        // mas a extração as prepara para regras mais determinísticas futuramente.
+        return {
+            forced: false,
+            lock_check: { ok: true, conflicts: [] },
+            blocked_check: { ok: true, unresolved: [] },
+        };
+    }
+}
+//# sourceMappingURL=transition-engine.js.map

package/dist/core/sdd/fingerprint.d.ts

@@ -0,0 +1,23 @@
+export interface RequirementFingerprint {
+    capability: string;
+    requirement_id: string;
+    base_hash: string;
+    base_text: string;
+    captured_at: string;
+    source_change_id: string;
+    reconstructed?: boolean;
+}
+export interface ChangeFingerprintMeta {
+    requirements: RequirementFingerprint[];
+}
+export interface CaptureFingerprintsOptions {
+    sourceChangeId?: string;
+    reconstructed?: boolean;
+    capturedAt?: string;
+}
+export declare function computeRequirementHash(text: string): string;
+export declare function readMeta(changeDir: string): Promise<ChangeFingerprintMeta | null>;
+export declare function writeMeta(changeDir: string, meta: ChangeFingerprintMeta): Promise<void>;
+export declare function hasEquivalentRequirementsFingerprint(a: ChangeFingerprintMeta, b: ChangeFingerprintMeta): boolean;
+export declare function captureFingerprintsForChange(changeDir: string, mainSpecsDir: string, options?: CaptureFingerprintsOptions): Promise<ChangeFingerprintMeta>;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/core/sdd/fingerprint.js

@@ -0,0 +1,146 @@
+/**
+ * Change fingerprint helpers.
+ *
+ * Fingerprints preserve the original requirement body used as the base for a change.
+ * They are used to detect stale deltas when parallel work edits the same
+ * requirement between validation and archive.
+ */
+import path from 'path';
+import { promises as fs } from 'fs';
+import { createHash } from 'crypto';
+import { extractRequirementsSection, normalizeRequirementName, parseDeltaSpec, } from '../parsers/requirement-blocks.js';
+import { findSpecUpdates } from '../specs-apply.js';
+const META_FILE = 'meta.json';
+export function computeRequirementHash(text) {
+    const normalized = text.replace(/\r\n?/g, '\n').trim();
+    return createHash('sha256').update(normalized).digest('hex');
+}
+function buildMetaPath(changeDir) {
+    return path.join(changeDir, META_FILE);
+}
+function normalizeRequirementForMap(name) {
+    return normalizeRequirementName(name);
+}
+function requirementKey(capability, name) {
+    return `${capability}::${normalizeRequirementForMap(name)}`;
+}
+function getTouchedRequirementsFromPlan(plan, capability) {
+    const touched = [];
+    for (const modified of plan.modified) {
+        touched.push({ capability, name: modified.name });
+    }
+    for (const removed of plan.removed) {
+        touched.push({ capability, name: removed });
+    }
+    for (const renamed of plan.renamed) {
+        touched.push({ capability, name: renamed.from });
+    }
+    return touched;
+}
+async function getCurrentRequirementBlock(specPath, requirementName) {
+    const content = await fs.readFile(specPath, 'utf-8');
+    const parts = extractRequirementsSection(content);
+    const key = normalizeRequirementForMap(requirementName);
+    for (const block of parts.bodyBlocks) {
+        if (normalizeRequirementForMap(block.name) === key) {
+            return { raw: block.raw };
+        }
+    }
+    return null;
+}
+export async function readMeta(changeDir) {
+    const metaPath = buildMetaPath(changeDir);
+    try {
+        const raw = await fs.readFile(metaPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.requirements)) {
+            return null;
+        }
+        const requirements = parsed.requirements.filter((entry) => {
+            return (entry &&
+                typeof entry.requirement_id === 'string' &&
+                typeof entry.base_hash === 'string' &&
+                typeof entry.base_text === 'string' &&
+                typeof entry.captured_at === 'string' &&
+                typeof entry.source_change_id === 'string');
+        });
+        if (requirements.length !== parsed.requirements.length) {
+            return null;
+        }
+        return { requirements };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return null;
+        }
+        return null;
+    }
+}
+export async function writeMeta(changeDir, meta) {
+    const metaPath = buildMetaPath(changeDir);
+    const payload = {
+        requirements: [...meta.requirements].sort((a, b) => `${a.capability}/${a.requirement_id}`.localeCompare(`${b.capability}/${b.requirement_id}`)),
+    };
+    await fs.writeFile(metaPath, JSON.stringify(payload, null, 2), 'utf-8');
+}
+export function hasEquivalentRequirementsFingerprint(a, b) {
+    const normalize = (meta) => {
+        const normalized = [...meta.requirements].sort((left, right) => `${left.capability}/${left.requirement_id}`.localeCompare(`${right.capability}/${right.requirement_id}`));
+        return normalized.map((entry) => [
+            entry.capability,
+            entry.requirement_id,
+            entry.base_hash,
+            entry.base_text,
+            entry.source_change_id,
+        ].join('|'));
+    };
+    const left = normalize(a);
+    const right = normalize(b);
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+export async function captureFingerprintsForChange(changeDir, mainSpecsDir, options = {}) {
+    const changeId = options.sourceChangeId ?? path.basename(changeDir);
+    const capturedAt = options.capturedAt ?? new Date().toISOString();
+    const updates = await findSpecUpdates(changeDir, mainSpecsDir);
+    const requirementEntries = [];
+    const seen = new Set();
+    for (const update of updates) {
+        const capability = path.basename(path.dirname(update.target));
+        const plan = parseDeltaSpec(await fs.readFile(update.source, 'utf-8'));
+        const touched = getTouchedRequirementsFromPlan(plan, capability);
+        if (touched.length === 0) {
+            continue;
+        }
+        try {
+            await fs.readFile(update.target, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const item of touched) {
+            const key = requirementKey(item.capability, item.name);
+            if (seen.has(key)) {
+                continue;
+            }
+            const block = await getCurrentRequirementBlock(update.target, item.name);
+            if (!block) {
+                continue;
+            }
+            requirementEntries.push({
+                capability: item.capability,
+                requirement_id: normalizeRequirementForMap(item.name),
+                base_hash: computeRequirementHash(block.raw),
+                base_text: block.raw,
+                captured_at: capturedAt,
+                source_change_id: changeId,
+                reconstructed: options.reconstructed,
+            });
+            seen.add(key);
+        }
+    }
+    return { requirements: requirementEntries };
+}
+//# sourceMappingURL=fingerprint.js.map

package/dist/core/sdd/import-openspec.d.ts

@@ -0,0 +1,31 @@
+export interface SddImportOpenSpecOptions {
+    dryRun?: boolean;
+    remove?: boolean;
+    yes?: boolean;
+    render?: boolean;
+}
+export interface ImportedOpenSpecFile {
+    source_path: string;
+    target_path: string;
+    sha256: string;
+    bytes: number;
+    category: string;
+    indexed_source_id: string;
+}
+export interface SddImportOpenSpecResult {
+    project_root: string;
+    source_root: string;
+    target_root: string;
+    report_path: string;
+    dry_run: boolean;
+    removed_source_root: boolean;
+    files_seen: number;
+    files_copied: number;
+    sources_indexed: number;
+    categories: Record<string, number>;
+    files: ImportedOpenSpecFile[];
+}
+export declare class SddImportOpenSpecCommand {
+    execute(projectRoot: string, options?: SddImportOpenSpecOptions): Promise<SddImportOpenSpecResult>;
+}
+//# sourceMappingURL=import-openspec.d.ts.map

package/dist/core/sdd/import-openspec.js

@@ -0,0 +1,232 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { stringify as stringifyYaml } from 'yaml';
+import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, saveSourceIndexState, } from './state.js';
+import { renderViews } from './views.js';
+import { nextSourceId } from './legacy-operations.js';
+import { OPENSPEC_LEGACY_CAPABILITY, resolveLegacyCapabilityImportedDepositoRoot, resolveLegacyCapabilityLiveRoot, } from './services/legacy-capability.service.js';
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listFiles(rootDir) {
+    const entries = await fs.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+    const files = [];
+    for (const entry of entries) {
+        const absolute = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(absolute)));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(absolute);
+        }
+    }
+    files.sort((a, b) => a.localeCompare(b));
+    return files;
+}
+async function sha256(filePath) {
+    const content = await fs.readFile(filePath);
+    return {
+        hash: createHash('sha256').update(content).digest('hex'),
+        bytes: content.byteLength,
+    };
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, '/');
+}
+function categoryForOpenSpecPath(relativePath) {
+    const normalized = normalizePath(relativePath).toLowerCase();
+    if (normalized.startsWith('specs/'))
+        return 'spec';
+    if (normalized.startsWith('changes/archive/'))
+        return 'archived-change';
+    if (normalized.startsWith('changes/'))
+        return 'active-change';
+    if (normalized.startsWith('schemas/'))
+        return 'schema';
+    if (normalized.startsWith('explorations/'))
+        return 'exploration';
+    if (normalized === 'config.yaml' || normalized === 'config.yml' || normalized === 'project.md') {
+        return 'project-config';
+    }
+    return 'other';
+}
+function titleFromOpenSpecPath(relativePath) {
+    const normalized = normalizePath(relativePath);
+    const parts = normalized.split('/');
+    const meaningful = parts.length >= 2 ? parts.slice(0, -1).join(' / ') : normalized;
+    return `Legacy spec corpus: ${meaningful || normalized}`;
+}
+function targetRelativePath(relativePath) {
+    return normalizePath(relativePath);
+}
+export class SddImportOpenSpecCommand {
+    async execute(projectRoot, options = {}) {
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const sourceRoot = resolveLegacyCapabilityLiveRoot(projectRoot, OPENSPEC_LEGACY_CAPABILITY);
+        const targetRoot = resolveLegacyCapabilityImportedDepositoRoot(paths.depositoDir, OPENSPEC_LEGACY_CAPABILITY);
+        const reportPath = path.join(targetRoot, '_codesdd-import-report.yaml');
+        const dryRun = options.dryRun ?? false;
+        if (!(await pathExists(sourceRoot))) {
+            return {
+                project_root: projectRoot,
+                source_root: normalizePath(path.relative(projectRoot, sourceRoot)),
+                target_root: normalizePath(path.relative(projectRoot, targetRoot)),
+                report_path: normalizePath(path.relative(projectRoot, reportPath)),
+                dry_run: dryRun,
+                removed_source_root: false,
+                files_seen: 0,
+                files_copied: 0,
+                sources_indexed: 0,
+                categories: {},
+                files: [],
+            };
+        }
+        if (options.remove && !options.yes) {
+            throw new Error('Refusing to remove openspec/. Re-run with --remove --yes after reviewing the import report.');
+        }
+        const absoluteFiles = await listFiles(sourceRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const sourceIndex = snapshot.sourceIndex;
+        const existingByPath = new Map(sourceIndex.sources.map((source) => [source.path, source]));
+        const categories = {};
+        const imported = [];
+        let filesCopied = 0;
+        let sourcesIndexed = 0;
+        for (const absoluteSource of absoluteFiles) {
+            const relativeOpenSpec = normalizePath(path.relative(sourceRoot, absoluteSource));
+            const relativeTarget = targetRelativePath(relativeOpenSpec);
+            const absoluteTarget = path.join(targetRoot, relativeTarget);
+            const category = categoryForOpenSpecPath(relativeOpenSpec);
+            const sourceHash = await sha256(absoluteSource);
+            const indexedPath = normalizePath(path.relative(projectRoot, absoluteTarget));
+            const now = new Date().toISOString();
+            categories[category] = (categories[category] ?? 0) + 1;
+            let sourceRecord = existingByPath.get(indexedPath);
+            if (!sourceRecord) {
+                const created = {
+                    id: nextSourceId(sourceIndex.sources.map((source) => source.id)),
+                    type: 'legado',
+                    path: indexedPath,
+                    title: titleFromOpenSpecPath(relativeOpenSpec),
+                    status: 'INDEXED',
+                    source_version: 1,
+                    source_fingerprint: sourceHash.hash,
+                    authority: 'internal',
+                    source_url: '',
+                    source_classification: 'technical_best_practice',
+                    jurisdiction_tags: [],
+                    last_verified_at: now.slice(0, 10),
+                    verification_status: 'verified',
+                    verification_notes: 'Imported from repository-local legacy spec corpus.',
+                    legal_validation_required: false,
+                    summary: `Imported from legacy-spec/${relativeOpenSpec}`,
+                    imported_at: now,
+                    updated_at: now,
+                    used_by: [],
+                    notes: [],
+                    consolidation_targets: ['source-index', 'legacy-spec-corpus-import', category],
+                };
+                sourceRecord = created;
+                sourceIndex.sources.push(sourceRecord);
+                existingByPath.set(indexedPath, sourceRecord);
+                sourcesIndexed += 1;
+            }
+            sourceRecord.type = 'legado';
+            sourceRecord.status = 'INDEXED';
+            sourceRecord.source_version = sourceRecord.source_version || 1;
+            sourceRecord.source_fingerprint = sourceHash.hash;
+            sourceRecord.authority = sourceRecord.authority || 'internal';
+            sourceRecord.source_url = sourceRecord.source_url || '';
+            sourceRecord.source_classification = sourceRecord.source_classification || 'technical_best_practice';
+            sourceRecord.jurisdiction_tags = Array.isArray(sourceRecord.jurisdiction_tags)
+                ? sourceRecord.jurisdiction_tags
+                : [];
+            sourceRecord.last_verified_at = sourceRecord.last_verified_at || now.slice(0, 10);
+            sourceRecord.verification_status = sourceRecord.verification_status || 'verified';
+            sourceRecord.verification_notes =
+                sourceRecord.verification_notes || 'Imported from repository-local legacy spec corpus.';
+            sourceRecord.legal_validation_required = Boolean(sourceRecord.legal_validation_required);
+            sourceRecord.summary = `Imported from legacy-spec/${relativeOpenSpec}`;
+            sourceRecord.updated_at = now;
+            sourceRecord.notes = Array.from(new Set([
+                ...sourceRecord.notes.filter((note) => !note.startsWith('openspec-import:') && !note.startsWith('legacy-spec-import:')),
+                `legacy-spec-import:source=legacy-spec/${relativeOpenSpec}`,
+                `legacy-spec-import:category=${category}`,
+                `legacy-spec-import:sha256=${sourceHash.hash}`,
+                `legacy-spec-import:bytes=${sourceHash.bytes}`,
+            ]));
+            sourceRecord.consolidation_targets = Array.from(new Set([
+                ...sourceRecord.consolidation_targets.filter((target) => target !== 'legacy-openspec-import' && target !== 'legacy-spec-corpus-import'),
+                'source-index',
+                'legacy-spec-corpus-import',
+                category,
+            ]));
+            if (!dryRun) {
+                await fs.mkdir(path.dirname(absoluteTarget), { recursive: true });
+                await fs.copyFile(absoluteSource, absoluteTarget);
+                const copiedHash = await sha256(absoluteTarget);
+                if (copiedHash.hash !== sourceHash.hash) {
+                    throw new Error(`OpenSpec import checksum mismatch for ${relativeOpenSpec}`);
+                }
+                filesCopied += 1;
+            }
+            imported.push({
+                source_path: `legacy-spec/${relativeOpenSpec}`,
+                target_path: indexedPath,
+                sha256: sourceHash.hash,
+                bytes: sourceHash.bytes,
+                category,
+                indexed_source_id: sourceRecord.id,
+            });
+        }
+        const report = {
+            version: 1,
+            generated_at: new Date().toISOString(),
+            source_root: 'legacy-spec',
+            target_root: normalizePath(path.relative(projectRoot, targetRoot)),
+            dry_run: dryRun,
+            remove_requested: options.remove ?? false,
+            files_seen: imported.length,
+            files_copied: dryRun ? 0 : filesCopied,
+            sources_indexed: sourcesIndexed,
+            categories,
+            files: imported,
+        };
+        if (!dryRun) {
+            await saveSourceIndexState(paths, sourceIndex);
+            await fs.mkdir(targetRoot, { recursive: true });
+            await fs.writeFile(reportPath, stringifyYaml(report), 'utf-8');
+            if (options.remove) {
+                await fs.rm(sourceRoot, { recursive: true, force: true });
+            }
+            const shouldRender = options.render ?? config.views.autoRender;
+            if (shouldRender) {
+                const updated = await loadStateSnapshot(paths, config);
+                await renderViews(paths, config, updated);
+            }
+        }
+        return {
+            project_root: projectRoot,
+            source_root: 'legacy-spec',
+            target_root: normalizePath(path.relative(projectRoot, targetRoot)),
+            report_path: normalizePath(path.relative(projectRoot, reportPath)),
+            dry_run: dryRun,
+            removed_source_root: Boolean(options.remove && !dryRun),
+            files_seen: imported.length,
+            files_copied: dryRun ? 0 : filesCopied,
+            sources_indexed: sourcesIndexed,
+            categories,
+            files: imported,
+        };
+    }
+}
+//# sourceMappingURL=import-openspec.js.map

package/dist/core/sdd/init.d.ts

@@ -0,0 +1,36 @@
+import { type SddLanguage, type SddLayout } from './state.js';
+import { type BootstrapContextReport } from './bootstrap.js';
+export interface SddInitOptions {
+    frontendEnabled?: boolean;
+    language?: SddLanguage;
+    layout?: SddLayout;
+    render?: boolean;
+}
+export interface SddInitResult {
+    projectRoot: string;
+    memoryDir: string;
+    frontendEnabled: boolean;
+    rendered: boolean;
+    skillsSeeded: number;
+    localSkillsMaterialized: number;
+    syncedTools: string[];
+    sddBootstrap: BootstrapContextReport;
+}
+export interface SddInitContextOptions {
+    mode?: 'merge' | 'replace';
+    deep?: boolean;
+    render?: boolean;
+}
+export interface SddInitContextResult {
+    projectRoot: string;
+    memoryDir: string;
+    rendered: boolean;
+    sddBootstrap: BootstrapContextReport;
+}
+export declare class SddInitCommand {
+    execute(projectRoot: string, options?: SddInitOptions): Promise<SddInitResult>;
+}
+export declare class SddInitContextCommand {
+    execute(projectRoot: string, options?: SddInitContextOptions): Promise<SddInitContextResult>;
+}
+//# sourceMappingURL=init.d.ts.map

package/dist/core/sdd/init.js

@@ -0,0 +1,65 @@
+import { loadProjectSddConfig, loadStateSnapshot, ensureBaseFiles, ensureBaseStructure, resolveSddPaths, upsertProjectSddConfig, } from './state.js';
+import { renderViews } from './views.js';
+import { syncSddGuideDocs } from './docs-sync.js';
+import { bootstrapInitialContext } from './bootstrap.js';
+import { SkillsSyncService } from './services/skills-sync.service.js';
+import { createSddStores } from './store/sdd-stores.js';
+export class SddInitCommand {
+    async execute(projectRoot, options = {}) {
+        const config = await upsertProjectSddConfig(projectRoot, {
+            frontendEnabled: options.frontendEnabled,
+            language: options.language,
+            layout: options.layout,
+        });
+        const paths = resolveSddPaths(projectRoot, config);
+        await ensureBaseStructure(paths);
+        await ensureBaseFiles(paths, config);
+        const sddBootstrap = await bootstrapInitialContext(projectRoot, paths, config, {
+            mode: 'empty-only',
+            deep: false,
+        });
+        const skillsSync = await new SkillsSyncService(createSddStores(paths)).execute(projectRoot, { all: true });
+        const shouldRender = options.render ?? config.views.autoRender;
+        if (shouldRender) {
+            const state = await loadStateSnapshot(paths, config);
+            await renderViews(paths, config, state);
+        }
+        await syncSddGuideDocs(projectRoot, paths, config);
+        return {
+            projectRoot,
+            memoryDir: paths.memoryRoot,
+            frontendEnabled: config.frontend.enabled,
+            rendered: shouldRender,
+            skillsSeeded: skillsSync.synced,
+            localSkillsMaterialized: skillsSync.local_synced,
+            syncedTools: skillsSync.tools,
+            sddBootstrap,
+        };
+    }
+}
+export class SddInitContextCommand {
+    async execute(projectRoot, options = {}) {
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const stores = createSddStores(paths);
+        await ensureBaseStructure(paths);
+        await ensureBaseFiles(paths, config);
+        const sddBootstrap = await bootstrapInitialContext(projectRoot, paths, config, {
+            mode: options.mode || 'merge',
+            deep: options.deep ?? true,
+        });
+        const shouldRender = options.render ?? config.views.autoRender;
+        if (shouldRender) {
+            const state = await loadStateSnapshot(paths, config);
+            await renderViews(paths, config, state);
+        }
+        await syncSddGuideDocs(projectRoot, paths, config);
+        return {
+            projectRoot,
+            memoryDir: paths.memoryRoot,
+            rendered: shouldRender,
+            sddBootstrap,
+        };
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/core/sdd/json-schema.d.ts

@@ -0,0 +1,6 @@
+import { type WorkspaceDocumentFileName } from './workspace-schemas.js';
+type JsonSchemaDocument = Record<string, unknown>;
+export declare function buildWorkspaceJsonSchemas(): Record<WorkspaceDocumentFileName, JsonSchemaDocument>;
+export declare function buildWorkspaceJsonSchemaCatalog(): Record<string, unknown>;
+export {};
+//# sourceMappingURL=json-schema.d.ts.map