@devtrack-solution/codesdd 1.2.4-rc3 → 1.2.4

package/dist/core/init.js

@@ -1,8 +1,8 @@
 /**
  * Init Command
  *
- * Sets up CodeSDD with Agent Skills and /opsx:* slash commands.
- * This is the unified setup command that replaces both the old init and experimental commands.
+ * Sets up CodeSDD agent skills and compatibility slash commands.
+ * The canonical project lifecycle lives under .sdd and codesdd sdd commands.
  */
 import path from 'path';
 import chalk from 'chalk';
@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import { createRequire } from 'module';
 import { FileSystemUtils } from '../utils/file-system.js';
 import { transformToHyphenCommands } from '../utils/command-references.js';
-import { AI_TOOLS, LEGACY_SPEC_DIR_NAME, } from './config.js';
+import { AI_TOOLS, LEGACY_SPEC_DIR_NAME, getToolInstallGuidance, } from './config.js';
 import { isInteractive } from '../utils/interactive.js';
 import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
 import { CLI_ISSUES_URL, CLI_NAME, CLI_PRODUCT_NAME, CLI_REPOSITORY_URL } from './branding.js';
@@ -515,6 +515,10 @@ export class InitCommand {
         if (results.removedSkillCount > 0) {
             this.log(chalk.dim(`Removed: ${results.removedSkillCount} skill directories (delivery: commands)`));
         }
+        const toolNotes = getToolInstallGuidance(successfulTools.map((tool) => tool.value));
+        for (const note of toolNotes) {
+            this.log(chalk.dim(note));
+        }
         // Config status
         if (configStatus === 'exists') {
             // Show actual filename (config.yaml or config.yml)
@@ -528,21 +532,16 @@ export class InitCommand {
         else {
             this.log(chalk.dim(`Project config: not created (SDD uses .sdd/config.yaml)`));
         }
-        // Getting started (task 7.6: show propose if in profile)
+        // Getting started
         const globalCfg = getGlobalConfig();
         const activeProfile = this.profileOverride ?? globalCfg.profile ?? 'core';
         const activeWorkflows = [...getProfileWorkflows(activeProfile, globalCfg.workflows)];
         this.log();
-        if (activeWorkflows.includes('propose')) {
-            this.log(chalk.bold('Getting started:'));
-            this.log('  Start your first change: /opsx:propose "your idea"');
-        }
-        else if (activeWorkflows.includes('new')) {
-            this.log(chalk.bold('Getting started:'));
-            this.log('  Start your first change: /opsx:new "your idea"');
-        }
-        else {
-            this.log(`Done. Run '${CLI_NAME} config profile' to configure your workflows.`);
+        this.log(chalk.bold('Getting started:'));
+        this.log(`  Full project bootstrap: ${CLI_NAME} install`);
+        this.log(`  Canonical first change: ${CLI_NAME} sdd insight "your idea"`);
+        if (activeWorkflows.includes('propose') || activeWorkflows.includes('new')) {
+            this.log(chalk.dim('  Compatibility slash commands were generated for existing workflows; prefer CodeSDD SDD commands in .sdd-native projects.'));
         }
         // Links
         this.log();

package/dist/core/sdd/agent-binding.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 declare const agentProviderSchema: z.ZodEnum<{
-    codex: "codex";
     opencode: "opencode";
+    codex: "codex";
     deepagents: "deepagents";
     fake: "fake";
     "claude-code": "claude-code";
@@ -61,8 +61,8 @@ export declare const agentBindingAdapterSchema: z.ZodObject<{
     schema_version: z.ZodDefault<z.ZodLiteral<1>>;
     id: z.ZodString;
     provider: z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
@@ -148,16 +148,16 @@ export declare const agentBindingResolutionRequestSchema: z.ZodObject<{
         "documentation-sync": "documentation-sync";
     }>;
     provider: z.ZodOptional<z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
         cloudcode: "cloudcode";
     }>>;
     allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
@@ -186,8 +186,8 @@ export declare const agentBindingCandidateSchema: z.ZodObject<{
     adapter_ref: z.ZodObject<{
         id: z.ZodString;
         provider: z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
@@ -231,16 +231,16 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
             "documentation-sync": "documentation-sync";
         }>;
         provider: z.ZodOptional<z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
             cloudcode: "cloudcode";
         }>>;
         allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
@@ -269,8 +269,8 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
         adapter_ref: z.ZodObject<{
             id: z.ZodString;
             provider: z.ZodEnum<{
-                codex: "codex";
                 opencode: "opencode";
+                codex: "codex";
                 deepagents: "deepagents";
                 fake: "fake";
                 "claude-code": "claude-code";
@@ -296,8 +296,8 @@ export declare const agentBindingResolutionSchema: z.ZodObject<{
         adapter_ref: z.ZodObject<{
             id: z.ZodString;
             provider: z.ZodEnum<{
-                codex: "codex";
                 opencode: "opencode";
+                codex: "codex";
                 deepagents: "deepagents";
                 fake: "fake";
                 "claude-code": "claude-code";

package/dist/core/sdd/agent-runtime-contract.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const agentRuntimeProviderSchema: z.ZodEnum<{
-    codex: "codex";
     opencode: "opencode";
+    codex: "codex";
     deepagents: "deepagents";
 }>;
 export declare const agentRuntimeModeSchema: z.ZodEnum<{
@@ -32,8 +32,8 @@ export declare const agentRuntimeCommandPlanRequestSchema: z.ZodObject<{
     schema_version: z.ZodDefault<z.ZodLiteral<1>>;
     feature_ref: z.ZodString;
     provider: z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
     }>;
     mode: z.ZodDefault<z.ZodEnum<{
@@ -73,8 +73,8 @@ export declare const agentRuntimeCommandPlanSchema: z.ZodObject<{
         schema_version: z.ZodDefault<z.ZodLiteral<1>>;
         feature_ref: z.ZodString;
         provider: z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
         }>;
         mode: z.ZodDefault<z.ZodEnum<{
@@ -104,8 +104,8 @@ export declare const agentRuntimeCommandPlanSchema: z.ZodObject<{
         }>>>;
     }, z.core.$strip>;
     provider: z.ZodEnum<{
-        codex: "codex";
         opencode: "opencode";
+        codex: "codex";
         deepagents: "deepagents";
     }>;
     command: z.ZodOptional<z.ZodObject<{

package/dist/core/sdd/allocator-recovery.d.ts

@@ -0,0 +1,14 @@
+import type { ArtifactIdAllocatorState, ArtifactIdAllocatorType } from './artifact-id-allocator.js';
+export interface AllocatorRecoveryFinding {
+    code: 'counter-behind-reservations' | 'branch-lag';
+    message: string;
+    ref?: string;
+}
+export interface AllocatorRecoveryPlan {
+    recovered_counters: Partial<Record<ArtifactIdAllocatorType, number>>;
+    findings: AllocatorRecoveryFinding[];
+}
+export declare function buildAllocatorRecoveryPlan(state: ArtifactIdAllocatorState, options?: {
+    local_revisions?: Record<string, number>;
+}): AllocatorRecoveryPlan;
+//# sourceMappingURL=allocator-recovery.d.ts.map

package/dist/core/sdd/allocator-recovery.js

@@ -0,0 +1,30 @@
+export function buildAllocatorRecoveryPlan(state, options = {}) {
+    const recovered = { ...state.counters };
+    const findings = [];
+    for (const reservation of state.reservations) {
+        const current = recovered[reservation.artifact_type] ?? 0;
+        if (reservation.sequence > current) {
+            recovered[reservation.artifact_type] = reservation.sequence;
+            findings.push({
+                code: 'counter-behind-reservations',
+                message: `${reservation.artifact_type} counter recovered from ${current} to ${reservation.sequence}.`,
+                ref: reservation.artifact_id,
+            });
+        }
+    }
+    for (const [artifactId, remoteRevision] of Object.entries(state.canonical_revisions)) {
+        const localRevision = options.local_revisions?.[artifactId] ?? remoteRevision;
+        if (localRevision < remoteRevision) {
+            findings.push({
+                code: 'branch-lag',
+                message: `${artifactId} local revision ${localRevision} is behind canonical revision ${remoteRevision}.`,
+                ref: artifactId,
+            });
+        }
+    }
+    return {
+        recovered_counters: recovered,
+        findings,
+    };
+}
+//# sourceMappingURL=allocator-recovery.js.map

package/dist/core/sdd/allocator-security.d.ts

@@ -0,0 +1,18 @@
+import type { ArtifactIdAllocatorState, ArtifactIdAllocatorType } from './artifact-id-allocator.js';
+export interface AllocatorSecurityPolicy {
+    max_reservations_per_tenant?: number;
+    max_reservations_per_type?: Partial<Record<ArtifactIdAllocatorType, number>>;
+    replay_window_ms?: number;
+}
+export interface AllocatorSecurityDecision {
+    allowed: boolean;
+    code: 'allowed' | 'tenant-quota-exceeded' | 'type-quota-exceeded' | 'replay-window-expired';
+    reason: string;
+}
+export declare function evaluateAllocatorSecurityPolicy(state: ArtifactIdAllocatorState, input: {
+    tenant_id?: string;
+    artifact_type: ArtifactIdAllocatorType;
+    idempotency_key: string;
+    now: string;
+}, policy: AllocatorSecurityPolicy): AllocatorSecurityDecision;
+//# sourceMappingURL=allocator-security.d.ts.map

package/dist/core/sdd/allocator-security.js

@@ -0,0 +1,36 @@
+export function evaluateAllocatorSecurityPolicy(state, input, policy) {
+    if (policy.max_reservations_per_tenant !== undefined && input.tenant_id) {
+        const tenantReservations = state.reservations.filter((reservation) => reservation.tenant_id === input.tenant_id).length;
+        if (tenantReservations >= policy.max_reservations_per_tenant) {
+            return {
+                allowed: false,
+                code: 'tenant-quota-exceeded',
+                reason: `Tenant ${input.tenant_id} has reached reservation quota ${policy.max_reservations_per_tenant}.`,
+            };
+        }
+    }
+    const typeQuota = policy.max_reservations_per_type?.[input.artifact_type];
+    if (typeQuota !== undefined && (state.counters[input.artifact_type] ?? 0) >= typeQuota) {
+        return {
+            allowed: false,
+            code: 'type-quota-exceeded',
+            reason: `${input.artifact_type} reservation quota ${typeQuota} has been reached.`,
+        };
+    }
+    if (policy.replay_window_ms !== undefined) {
+        const existing = state.reservations.find((reservation) => reservation.idempotency_key === input.idempotency_key);
+        if (existing && new Date(input.now).getTime() - new Date(existing.reserved_at).getTime() > policy.replay_window_ms) {
+            return {
+                allowed: false,
+                code: 'replay-window-expired',
+                reason: `Idempotency key ${input.idempotency_key} is outside the replay window.`,
+            };
+        }
+    }
+    return {
+        allowed: true,
+        code: 'allowed',
+        reason: 'Allocator security policy allows the request.',
+    };
+}
+//# sourceMappingURL=allocator-security.js.map

package/dist/core/sdd/api-foundation-baseline.d.ts

@@ -0,0 +1,111 @@
+export declare const CODESDD_API_FOUNDATION_SHARED_BASELINE: {
+    readonly id: "foundation-api-shared-baseline";
+    readonly version: 1;
+    readonly foundation_reference: "devtrack-foundation-api";
+};
+export declare const CODESDD_API_SHARED_BASELINE_REQUIREMENTS: readonly ["openapi-swagger-docs", "env-example", "package-json-scripts", "application-usecase-boundary", "dto-validation", "structured-api-errors", "auth-authz-planning", "route-and-usecase-tests"];
+export declare const CODESDD_API_SHARED_BASELINE_QUALITY_GATES: readonly ["openapi-docs-required", "env-example-required", "package-scripts-required", "application-usecase-route-boundary", "dto-validation-required", "structured-error-contract-required", "authz-planning-required", "route-usecase-tests-required"];
+export type CodeSddApiSharedBaselineRequirementId = (typeof CODESDD_API_SHARED_BASELINE_REQUIREMENTS)[number];
+export interface CodeSddApiSharedBaselineRequirement {
+    id: CodeSddApiSharedBaselineRequirementId;
+    title: string;
+    foundation_reference: typeof CODESDD_API_FOUNDATION_SHARED_BASELINE.foundation_reference;
+    severity: 'P0';
+    phase: 'planning' | 'scaffold' | 'implementation' | 'validation';
+    quality_gate: (typeof CODESDD_API_SHARED_BASELINE_QUALITY_GATES)[number];
+    contract_rule_refs: readonly string[];
+    required_artifacts: readonly string[];
+    required_evidence: readonly string[];
+}
+export declare const CODESDD_API_SHARED_BASELINE_REQUIREMENT_DEFINITIONS: {
+    'openapi-swagger-docs': {
+        id: "openapi-swagger-docs";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "scaffold";
+        quality_gate: "openapi-docs-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'env-example': {
+        id: "env-example";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "scaffold";
+        quality_gate: "env-example-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'package-json-scripts': {
+        id: "package-json-scripts";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "scaffold";
+        quality_gate: "package-scripts-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'application-usecase-boundary': {
+        id: "application-usecase-boundary";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "implementation";
+        quality_gate: "application-usecase-route-boundary";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'dto-validation': {
+        id: "dto-validation";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "implementation";
+        quality_gate: "dto-validation-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'structured-api-errors': {
+        id: "structured-api-errors";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "implementation";
+        quality_gate: "structured-error-contract-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'auth-authz-planning': {
+        id: "auth-authz-planning";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "planning";
+        quality_gate: "authz-planning-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'route-and-usecase-tests': {
+        id: "route-and-usecase-tests";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        phase: "validation";
+        quality_gate: "route-usecase-tests-required";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+};
+export declare function getCodeSddApiSharedBaselineRequirements(): CodeSddApiSharedBaselineRequirement[];
+//# sourceMappingURL=api-foundation-baseline.d.ts.map

package/dist/core/sdd/api-foundation-baseline.js

@@ -0,0 +1,151 @@
+export const CODESDD_API_FOUNDATION_SHARED_BASELINE = {
+    id: 'foundation-api-shared-baseline',
+    version: 1,
+    foundation_reference: 'devtrack-foundation-api',
+};
+export const CODESDD_API_SHARED_BASELINE_REQUIREMENTS = [
+    'openapi-swagger-docs',
+    'env-example',
+    'package-json-scripts',
+    'application-usecase-boundary',
+    'dto-validation',
+    'structured-api-errors',
+    'auth-authz-planning',
+    'route-and-usecase-tests',
+];
+export const CODESDD_API_SHARED_BASELINE_QUALITY_GATES = [
+    'openapi-docs-required',
+    'env-example-required',
+    'package-scripts-required',
+    'application-usecase-route-boundary',
+    'dto-validation-required',
+    'structured-error-contract-required',
+    'authz-planning-required',
+    'route-usecase-tests-required',
+];
+export const CODESDD_API_SHARED_BASELINE_REQUIREMENT_DEFINITIONS = {
+    'openapi-swagger-docs': {
+        id: 'openapi-swagger-docs',
+        title: 'Swagger/OpenAPI documentation',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'scaffold',
+        quality_gate: 'openapi-docs-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-OPENAPI-001', 'DTAPI-P0-TOOL-BASELINE-001'],
+        required_artifacts: ['package.json', '.env.example', 'src/main.ts', 'src/presentation/**'],
+        required_evidence: [
+            '@nestjs/swagger dependency is present',
+            'DocumentBuilder and SwaggerModule bootstrap /docs',
+            'controllers and DTOs include Swagger decorators',
+        ],
+    },
+    'env-example': {
+        id: 'env-example',
+        title: '.env.example placeholder contract',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'scaffold',
+        quality_gate: 'env-example-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-TOOL-BASELINE-001'],
+        required_artifacts: ['.env.example'],
+        required_evidence: [
+            'runtime variables have placeholder values',
+            'Swagger server settings are represented when OpenAPI is enabled',
+            'no secret or credential values are emitted',
+        ],
+    },
+    'package-json-scripts': {
+        id: 'package-json-scripts',
+        title: 'Operational package scripts and runtime bootstrap',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'scaffold',
+        quality_gate: 'package-scripts-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-TOOL-BASELINE-001', 'DTAPI-P0-RUNTIME-SCRIPTS-001'],
+        required_artifacts: ['package.json', 'scripts/cleanup.sh', 'scripts/kill-port.js'],
+        required_evidence: [
+            'build, start, start:dev, start:prod, lint, test, coverage, e2e, cleanup, and cleanup:install scripts are present',
+            'cleanup removes dependency installs, build outputs, caches, lockfiles, and compilation residue unless an ADR preserves a canonical lockfile',
+            'start and start:dev run a configured-port preflight that terminates the listener before Nest starts',
+            'scripts can be invoked with npm or pnpm, while nested package-script calls use npm run/npm install so Docker images do not require pnpm',
+            'migration scripts are present when persistence is included',
+        ],
+    },
+    'application-usecase-boundary': {
+        id: 'application-usecase-boundary',
+        title: 'Application use-case and input-port boundary',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'implementation',
+        quality_gate: 'application-usecase-route-boundary',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-USECASE-001', 'DTAPI-P0-TOOL-BASELINE-001'],
+        required_artifacts: ['src/application/**', 'src/presentation/**'],
+        required_evidence: [
+            'each user-facing route calls an application input port',
+            'each input port delegates business orchestration to a use case',
+        ],
+    },
+    'dto-validation': {
+        id: 'dto-validation',
+        title: 'DTO validation and documented request shape',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'implementation',
+        quality_gate: 'dto-validation-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-OPENAPI-001'],
+        required_artifacts: ['src/main.ts', 'src/presentation/**/dtos/**'],
+        required_evidence: [
+            'global validation pipe is configured',
+            'request DTOs use class-validator decorators',
+            'DTOs include Swagger property metadata',
+        ],
+    },
+    'structured-api-errors': {
+        id: 'structured-api-errors',
+        title: 'Structured API error responses',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'implementation',
+        quality_gate: 'structured-error-contract-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-TOOL-BASELINE-001'],
+        required_artifacts: ['src/presentation/dtos/api-error-response.dto.ts', 'src/presentation/**'],
+        required_evidence: [
+            'controllers document error responses',
+            'error DTO avoids leaking internal provider or secret data',
+        ],
+    },
+    'auth-authz-planning': {
+        id: 'auth-authz-planning',
+        title: 'Authentication and authorization planning',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'planning',
+        quality_gate: 'authz-planning-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P0-AUTH-PLAN-001', 'DTAPI-P0-TOOL-BASELINE-001'],
+        required_artifacts: ['FEAT quality evidence', 'src/presentation/**/guards/**'],
+        required_evidence: [
+            'route public/protected decision is recorded',
+            'guard, decorator, role, permission, or policy choice is recorded',
+            'Swagger security scheme is documented for protected routes',
+        ],
+    },
+    'route-and-usecase-tests': {
+        id: 'route-and-usecase-tests',
+        title: 'Route and use-case test evidence',
+        foundation_reference: 'devtrack-foundation-api',
+        severity: 'P0',
+        phase: 'validation',
+        quality_gate: 'route-usecase-tests-required',
+        contract_rule_refs: ['DTAPI-P0-SHARED-BASELINE-001', 'DTAPI-P1-EVIDENCE-001'],
+        required_artifacts: ['test/**', 'coverage/**'],
+        required_evidence: [
+            'route/controller behavior is covered',
+            'application use-case behavior is covered',
+            'validation evidence is recorded in the FEAT quality artifact',
+        ],
+    },
+};
+export function getCodeSddApiSharedBaselineRequirements() {
+    return CODESDD_API_SHARED_BASELINE_REQUIREMENTS.map((requirementId) => CODESDD_API_SHARED_BASELINE_REQUIREMENT_DEFINITIONS[requirementId]);
+}
+//# sourceMappingURL=api-foundation-baseline.js.map

package/dist/core/sdd/api-foundation-parity.d.ts

@@ -0,0 +1,114 @@
+export declare const CODESDD_FULL_FOUNDATION_COMPATIBLE_PROFILE_ID = "full-foundation-compatible";
+export declare const CODESDD_FULL_FOUNDATION_PARITY_MATRIX: {
+    readonly id: "full-foundation-compatible-parity-matrix";
+    readonly version: 1;
+    readonly profile_id: "full-foundation-compatible";
+    readonly foundation_reference: "devtrack-foundation-api";
+};
+export declare const CODESDD_FULL_FOUNDATION_PARITY_DIMENSIONS: readonly ["architecture-roots", "contract-boundaries", "api-documentation", "env-and-runtime-config", "package-scripts", "auth-and-authorization", "persistence-typeorm", "validation-and-errors", "evidence-and-quality-gates"];
+export declare const CODESDD_FULL_FOUNDATION_PARITY_QUALITY_GATES: readonly ["foundation-parity-matrix-required", "foundation-architecture-roots-parity", "foundation-contract-boundaries-parity", "foundation-api-documentation-parity", "foundation-env-runtime-config-parity", "foundation-package-scripts-parity", "foundation-auth-authorization-parity", "foundation-typeorm-persistence-parity", "foundation-validation-errors-parity", "foundation-evidence-quality-gates-parity"];
+export type CodeSddFullFoundationParityDimensionId = (typeof CODESDD_FULL_FOUNDATION_PARITY_DIMENSIONS)[number];
+export interface CodeSddFullFoundationParityDimension {
+    id: CodeSddFullFoundationParityDimensionId;
+    title: string;
+    foundation_reference: typeof CODESDD_FULL_FOUNDATION_PARITY_MATRIX.foundation_reference;
+    severity: 'P0';
+    quality_gate: (typeof CODESDD_FULL_FOUNDATION_PARITY_QUALITY_GATES)[number];
+    contract_rule_refs: readonly string[];
+    required_artifacts: readonly string[];
+    required_evidence: readonly string[];
+}
+export declare const CODESDD_FULL_FOUNDATION_PARITY_DIMENSION_DEFINITIONS: {
+    'architecture-roots': {
+        id: "architecture-roots";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-architecture-roots-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'contract-boundaries': {
+        id: "contract-boundaries";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-contract-boundaries-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'api-documentation': {
+        id: "api-documentation";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-api-documentation-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'env-and-runtime-config': {
+        id: "env-and-runtime-config";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-env-runtime-config-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'package-scripts': {
+        id: "package-scripts";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-package-scripts-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'auth-and-authorization': {
+        id: "auth-and-authorization";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-auth-authorization-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'persistence-typeorm': {
+        id: "persistence-typeorm";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-typeorm-persistence-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'validation-and-errors': {
+        id: "validation-and-errors";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-validation-errors-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+    'evidence-and-quality-gates': {
+        id: "evidence-and-quality-gates";
+        title: string;
+        foundation_reference: "devtrack-foundation-api";
+        severity: "P0";
+        quality_gate: "foundation-evidence-quality-gates-parity";
+        contract_rule_refs: string[];
+        required_artifacts: string[];
+        required_evidence: string[];
+    };
+};
+export declare function getCodeSddFullFoundationParityMatrix(): CodeSddFullFoundationParityDimension[];
+//# sourceMappingURL=api-foundation-parity.d.ts.map