@devtrack-solution/codesdd 1.2.2

package/dist/core/sdd/json-schema.js

@@ -0,0 +1,59 @@
+import { toJSONSchema } from 'zod';
+import { workspaceChangelogSchema, workspacePlanSchema, workspaceQualitySchema, workspaceSpecSchema, workspaceTasksSchema, } from './workspace-schemas.js';
+const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
+const WORKSPACE_JSON_SCHEMA_DESCRIPTORS = [
+    {
+        fileName: '1-spec.yaml',
+        title: 'OpenSDD Workspace Spec',
+        description: 'Machine-readable contract for the active/planned/archived FEAT spec workspace document.',
+        schema: workspaceSpecSchema,
+    },
+    {
+        fileName: '2-plan.yaml',
+        title: 'OpenSDD Workspace Plan',
+        description: 'Machine-readable contract for the FEAT execution plan workspace document.',
+        schema: workspacePlanSchema,
+    },
+    {
+        fileName: '3-tasks.yaml',
+        title: 'OpenSDD Workspace Tasks',
+        description: 'Machine-readable contract for the phased FEAT task roadmap workspace document.',
+        schema: workspaceTasksSchema,
+    },
+    {
+        fileName: '4-changelog.yaml',
+        title: 'OpenSDD Workspace Changelog',
+        description: 'Machine-readable contract for the FEAT execution changelog workspace document.',
+        schema: workspaceChangelogSchema,
+    },
+    {
+        fileName: '5-quality.yaml',
+        title: 'OpenSDD Workspace Quality',
+        description: 'Machine-readable contract for the FEAT quality evidence and remediation workspace document.',
+        schema: workspaceQualitySchema,
+    },
+];
+function normalizeJsonSchemaDocument(schema, title, description) {
+    return {
+        ...schema,
+        $schema: JSON_SCHEMA_DRAFT,
+        title,
+        description,
+    };
+}
+export function buildWorkspaceJsonSchemas() {
+    return Object.fromEntries(WORKSPACE_JSON_SCHEMA_DESCRIPTORS.map((descriptor) => [
+        descriptor.fileName,
+        normalizeJsonSchemaDocument(toJSONSchema(descriptor.schema), descriptor.title, descriptor.description),
+    ]));
+}
+export function buildWorkspaceJsonSchemaCatalog() {
+    return {
+        $schema: JSON_SCHEMA_DRAFT,
+        schema_version: 1,
+        contract: 'opensdd-workspace-documents',
+        generated_from: 'src/core/sdd/workspace-schemas.ts',
+        documents: buildWorkspaceJsonSchemas(),
+    };
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/core/sdd/legacy-operations.d.ts

@@ -0,0 +1,286 @@
+import { execFile } from 'node:child_process';
+import { loadStateSnapshot, type SddPaths, type SddRuntimeConfig, type SddStateSnapshot } from './state.js';
+import type { BacklogItem, DiscoveryRecord, ExecutionKind, FinalizeQueueItem, FlowMode, PlanningMode, QualityContract, Scale, SkillCatalogEntry, SourceDocumentRecord, TransitionLogEvent } from './types.js';
+export declare const execFileAsync: typeof execFile.__promisify__;
+export declare const RADAR_TO_DISCOVERY_STATUS: Record<string, DiscoveryRecord['status']>;
+export declare function slugify(value: string): string;
+export declare function stripFunctionalTitlePrefixes(value: string): string;
+export declare function computeCanonicalTitle(value: string): string;
+export declare function ensureMemoryInitialized(paths: SddPaths): Promise<void>;
+export declare function findDiscoveryRecord(records: DiscoveryRecord[], id: string): DiscoveryRecord | undefined;
+export declare function markdownDebateTemplate(insight: DiscoveryRecord, debateId: string): string;
+export declare function markdownInsightTemplate(id: string, title: string, text: string): string;
+export declare function markdownRadarTemplate(debate: DiscoveryRecord, radarId: string, rationale?: string): string;
+export declare function markdownRadarFromDepositoTemplate(radarId: string, title: string, sourceCount: number, rationale?: string): string;
+export declare function markdownDiscardTemplate(debate: DiscoveryRecord, rationale?: string): string;
+export interface MetaEvolutionConfig {
+    enabled: boolean;
+    audit_interval_days: number;
+    placeholder_markers: string[];
+    health_alert_threshold: number;
+}
+export declare const DEFAULT_META_EVOLUTION_CONFIG: MetaEvolutionConfig;
+export declare function buildDefaultQualityContract(options?: {
+    inheritedFrom?: string;
+    scope?: string;
+    stackProfile?: string;
+    enforcement?: QualityContract['enforcement'];
+    evidenceMode?: QualityContract['evidence_mode'];
+}): QualityContract;
+export declare function ensureFeatureQualityContract(feature: BacklogItem, inheritedFrom?: string): QualityContract;
+export declare const FORCED_TRANSITION_MARKERS: string[];
+export declare function normalizePercent(part: number, total: number): number;
+export declare function readMetaEvolutionConfig(paths: SddPaths): Promise<MetaEvolutionConfig>;
+export declare function listFilesRecursive(rootDir: string): Promise<string[]>;
+export declare function hasPlaceholder(content: string, markers: string[]): boolean;
+export declare function collectAuditArtifacts(paths: SddPaths): Promise<string[]>;
+export declare function debateHasRealDeliberation(content: string): boolean;
+export declare function collectForcedTransitions(paths: SddPaths): Promise<{
+    total: number;
+    featureRefs: string[];
+}>;
+export declare function sourceTypeFromRelativePath(relativePath: string): SourceDocumentRecord['type'];
+export declare function defaultConsolidationTargets(type: SourceDocumentRecord['type']): string[];
+export declare function deriveInitialFeatureTitles(sources: SourceDocumentRecord[], frontendEnabled: boolean): string[];
+export declare function listFilesRecursively(rootDir: string): Promise<string[]>;
+export declare function sourceTitleFromPath(filePath: string): string;
+export declare function normalizeSourceStatus(current: SourceDocumentRecord['status'], desired: SourceDocumentRecord['status']): SourceDocumentRecord['status'];
+export declare function nextSourceId(existingIds: string[]): string;
+export declare function extractSourceSummary(filePath: string): Promise<string>;
+export declare function findDebateFile(paths: SddPaths, debateId: string): Promise<string | null>;
+export declare function validateDebateDocument(content: string): string[];
+export declare function pickTopSkills(catalogSkills: SkillCatalogEntry[], ids: string[] | undefined, max?: number): string[];
+export declare function bundlesForSkills(catalog: {
+    skills: SkillCatalogEntry[];
+}, skillIds: string[]): string[];
+export declare function syncCounterFromId(discoveryIndex: {
+    counters: Record<'INS' | 'DEB' | 'RAD' | 'EPIC' | 'FEAT' | 'FGAP' | 'TD', number>;
+}, id: string): void;
+export declare function getRuntime(projectRoot: string): Promise<{
+    config: SddRuntimeConfig;
+    paths: SddPaths;
+}>;
+export declare function persistAndRender(paths: SddPaths, config: SddRuntimeConfig, render: boolean | undefined): Promise<void>;
+export declare function relProjectPath(paths: SddPaths, absolutePath: string): string;
+export declare function coreDocRef(paths: SddPaths, name: string): string;
+export declare function planningDocRef(paths: SddPaths, name: string): string;
+export declare function activeFeatureRef(paths: SddPaths, featureId: string, fileName: string): string;
+export declare function featureActiveDir(paths: SddPaths, featureId: string): string;
+export declare function featurePlannedDir(paths: SddPaths, featureId: string): string;
+export interface ActiveDocNames {
+    spec: string;
+    plan: string;
+    quality: string;
+    tasks: string;
+    changelog: string;
+}
+export declare function activeDocNamesForLayout(config: SddRuntimeConfig): ActiveDocNames;
+export declare function activeDocCandidateNames(config: SddRuntimeConfig): string[];
+export declare function resolveActiveDocRefs(paths: SddPaths, featureId: string, config: SddRuntimeConfig): Promise<string[]>;
+export declare function stackContextTokens(snapshot: Pick<SddStateSnapshot, 'techStack'>): string[];
+export declare function buildActiveSpecDoc(feature: BacklogItem): string;
+export declare function buildActivePlanDoc(feature: BacklogItem, recommendedBundles: string[]): string;
+export declare function buildActiveQualityDoc(feature: BacklogItem): string;
+export declare function buildActiveTasksDoc(feature: BacklogItem, paths: SddPaths): string;
+export declare function buildActiveChangelogDoc(feature: BacklogItem): string;
+export declare function ensureFeaturePlannedWorkspace(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem, recommendedBundles: string[]): Promise<{
+    plannedPath: string;
+    generatedDocs: string[];
+    handoffSeedRefs: string[];
+}>;
+export declare function ensureFeatureActiveWorkspace(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem, recommendedBundles: string[]): Promise<{
+    activePath: string;
+    generatedDocs: string[];
+    handoffSeedRefs: string[];
+}>;
+export declare function resolveRadar(record: DiscoveryRecord | undefined): asserts record is DiscoveryRecord;
+export declare function resolveFeat(items: BacklogItem[], id: string): BacklogItem;
+export declare function buildBacklogItem(id: string, title: string, originType: BacklogItem['origin_type'], originRef: string | undefined, scale: Scale, recommendedSkills: string[], options?: {
+    parallelGroup?: string;
+    executionKind?: ExecutionKind;
+    planningMode?: PlanningMode;
+    flowMode?: FlowMode;
+    acceptanceRefs?: string[];
+    touches?: string[];
+    lockDomains?: string[];
+    produces?: string[];
+    consumes?: string[];
+}): BacklogItem;
+export declare function includesAny(haystack: string, needles: string[]): boolean;
+export declare function classifyFeatureShape(title: string, contextTokens?: string[]): {
+    executionKind: ExecutionKind;
+    touches: string[];
+    lockDomains: string[];
+    produces: string[];
+    consumes: string[];
+    planningMode: PlanningMode;
+};
+export declare function normalizeTitle(value: string): string;
+export declare function intersects(a: string[], b: string[]): boolean;
+export declare function unresolvedDependencies(item: BacklogItem, all: BacklogItem[]): string[];
+export declare function lockConflictWithActive(item: BacklogItem, all: BacklogItem[]): string[];
+export declare function featureReadiness(item: BacklogItem, all: BacklogItem[]): 'READY' | 'BLOCKED' | 'LOCK_CONFLICT';
+export declare function updateDependencyMetadata(items: BacklogItem[]): void;
+export declare function parseRouteToken(value: string): string | null;
+export declare function inferRouteTargetsFromFeature(feature: BacklogItem): string[];
+export declare function inferSurfaceTargetsFromFeature(feature: BacklogItem): string[];
+export declare function gitHeadCommit(projectRoot: string): Promise<string>;
+export declare function gitChangedFiles(projectRoot: string, baseRef: string): Promise<{
+    files: string[];
+    warning: string;
+}>;
+export declare function isFrontendPath(filePath: string): boolean;
+export declare function detectFrontendImpactEvidence(feature: BacklogItem, changedFiles: string[]): {
+    metadata_routes: string[];
+    metadata_surfaces: string[];
+    diff_files: string[];
+    evidence_sources: Array<'metadata' | 'diff'>;
+    has_frontend_evidence: boolean;
+};
+export declare function ensureRouteInFrontendMap(snapshot: Awaited<ReturnType<typeof loadStateSnapshot>>, routePath: string, gapId: string): void;
+export declare function maybeCreateAutomaticFrontendGap(paths: SddPaths, snapshot: Awaited<ReturnType<typeof loadStateSnapshot>>, feature: BacklogItem, options?: {
+    force?: boolean;
+    routeTargets?: string[];
+    detectionSources?: Array<'metadata' | 'diff' | 'manual'>;
+}): Promise<string>;
+export declare function resolveRoutedSkills(snapshot: SddStateSnapshot, touches: string[]): string[];
+export declare function inferOriginType(input: string): BacklogItem['origin_type'];
+export declare function buildFinalizeQueue(paths: SddPaths, backlogItems: BacklogItem[], queueItems: FinalizeQueueItem[]): Promise<FinalizeQueueItem[]>;
+export declare function evaluateFeatureQuality(paths: SddPaths, config: SddRuntimeConfig, feature: BacklogItem): Promise<{
+    ok: boolean;
+    blocking: boolean;
+    reasons: string[];
+    artifact: string;
+}>;
+export declare function buildAdrMarkdown(feature: BacklogItem, unlocked: string[], timestamp: string): string;
+export declare function applyLoggedTransition<T extends {
+    id: string;
+    status: string;
+}>(transitionLog: TransitionLogEvent[], entityType: string, entity: T, toStatus: string, options: {
+    sourceCommand: string;
+    actor?: string;
+    reason?: string;
+    timestamp?: string;
+    forceTransition?: boolean;
+    lensViolations?: string[];
+    afterTransition?: (entity: T) => void;
+}): void;
+export declare function gateSatisfied(status: string): boolean;
+export interface SddAuditResult {
+    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;
+}
+export type ContextEntityType = 'FEAT' | 'RAD' | 'EPIC' | 'FGAP' | 'TD';
+export declare function detectContextType(ref: string): ContextEntityType | null;
+export declare function pathExists(targetPath: string): Promise<boolean>;
+export declare function listAdrRefs(paths: SddPaths, refs: string[]): Promise<string[]>;
+export type ApprovalStage = 'proposta' | 'planejamento' | 'tarefas';
+export declare function computeReadyFeatures(items: BacklogItem[], options?: {
+    maxAgents?: number;
+    rank?: NextRankMode;
+}): {
+    ready: BacklogItem[];
+    blocked: BacklogItem[];
+    conflicts: BacklogItem[];
+    waves: string[][];
+    deferred: Array<{
+        id: string;
+        reasons: string[];
+    }>;
+};
+export interface SessionPackManifest {
+    version: 1;
+    feature_id: string;
+    project_root: string;
+    created_at: string;
+    state_fingerprint: string;
+    active_feature_ids: string[];
+    lock_domain_snapshot: string[];
+}
+export interface SessionPackCleanupResult {
+    removed: boolean;
+    already_absent: boolean;
+    reason: string;
+}
+export interface NextFeatureCandidate {
+    item: BacklogItem;
+    score: number;
+    score_reasons: string[];
+}
+export declare function buildSessionStateFingerprint(items: BacklogItem[]): string;
+export declare function buildSessionManifest(featureId: string, projectRoot: string, items: BacklogItem[]): SessionPackManifest;
+export declare function isSessionPackStale(manifest: SessionPackManifest, items: BacklogItem[]): {
+    stale: boolean;
+    reasons: string[];
+};
+export declare function isSafeSessionTempPath(projectRoot: string, candidatePath: string): boolean;
+export declare function cleanupSessionPath(sessionRoot: string, candidatePath: string): Promise<SessionPackCleanupResult>;
+export declare function computeReadyFeatureWaves(items: BacklogItem[], options?: {
+    maxAgents?: number;
+    rank?: NextRankMode;
+}): {
+    ready: BacklogItem[];
+    blocked: BacklogItem[];
+    conflicts: BacklogItem[];
+    waves: string[][];
+    deferred: Array<{
+        id: string;
+        reasons: string[];
+    }>;
+};
+export type NextRankMode = 'impact' | 'criticality' | 'fifo';
+export declare function extractFeatureNumber(featureId: string): number;
+export declare function buildDependentsMap(items: BacklogItem[]): Map<string, string[]>;
+export declare function countIndirectDependents(featureId: string, dependentsMap: Map<string, string[]>): {
+    direct: number;
+    indirect: number;
+};
+export declare function lockCriticality(lockDomains: string[]): number;
+export declare function lockConflictRisk(item: BacklogItem, items: BacklogItem[]): number;
+export declare function scoreReadyItem(item: BacklogItem, items: BacklogItem[], dependentsMap: Map<string, string[]>, rank: NextRankMode): {
+    score: number;
+    reasons: string[];
+};
+export declare function buildCuratedSkillContent(entry: SkillCatalogEntry): string;
+export declare function resolveSkillFileRef(paths: SddPaths, skillId: string): Promise<string>;
+export declare function buildSkillInvocationPrompt(input: {
+    objective?: string;
+    ref?: string;
+    skills: Array<{
+        id: string;
+        path: string;
+        reason: string;
+    }>;
+}): string;
+export {};
+//# sourceMappingURL=legacy-operations.d.ts.map