@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/plugin-cli.js

@@ -0,0 +1,265 @@
+import path from 'node:path';
+import { buildDevTrackApiScaffoldDryRunPlan, } from './devtrack-api-appliance.js';
+import { FeatureLintService } from './services/feature-lint.service.js';
+import { buildPluginRuntimeInvocationPlan, pluginRuntimeInvocationRequestSchema, } from './plugin-broker.js';
+import { loadPluginManifest } from './plugin-manifest.js';
+import { createPluginRegistryState } from './plugin-registry.js';
+import { validatePluginPackageGovernance } from './plugin-sdk-contract.js';
+import { classifyCodesddStoragePath, validateCodesddStoragePaths, } from './runtime-boundary-contract.js';
+export async function inspectPluginManifestFromFile(manifestPath) {
+    const manifest = await loadPluginManifest(manifestPath);
+    return buildInspectResult(manifest, manifestPath);
+}
+export async function planPluginInvocationFromFile(manifestPath, options) {
+    const manifest = await loadPluginManifest(manifestPath);
+    const createdAt = options.created_at ?? new Date().toISOString();
+    const registry = createPluginRegistryState([
+        {
+            manifest,
+            source: {
+                type: 'workspace',
+                uri: normalizeManifestPath(manifestPath),
+                checksum: manifest.supply_chain.checksum,
+            },
+            registered_at: createdAt,
+        },
+    ], createdAt);
+    const request = pluginRuntimeInvocationRequestSchema.parse({
+        feature_ref: options.feature_ref,
+        capability: options.capability,
+        inputs: options.inputs ?? {},
+        skill_ref: options.skill_ref,
+        technology: options.technology,
+        requested_write_scope: options.requested_write_scope ?? [],
+        require_apply: options.mode === 'apply',
+        created_at: createdAt,
+        mode: options.mode ?? 'dry-run',
+        operation_id: options.operation_id,
+        approval_grants: options.approval_grants ?? [],
+        source_checksum: options.source_checksum,
+        planned_writes: options.planned_writes ?? [],
+        requested_env: options.requested_env ?? [],
+        network_domains: options.network_domains ?? [],
+        process_spawn_requested: options.process_spawn_requested ?? false,
+    });
+    const plan = buildPluginRuntimeInvocationPlan(registry, request);
+    const projectRoot = path.resolve(options.project_root ?? process.cwd());
+    const plannedStoragePaths = [
+        ...(options.requested_write_scope ?? []),
+        ...(options.planned_writes ?? []),
+    ].map((entry) => path.resolve(projectRoot, entry));
+    const standalone = buildStandaloneRunnerPolicy(manifest, plan, {
+        projectRoot,
+        plannedStoragePaths,
+    });
+    return {
+        schema_version: 1,
+        manifest_path: normalizeManifestPath(manifestPath),
+        plan,
+        workcell_runner: buildWorkcellRunner(manifest, plan, standalone),
+    };
+}
+export async function planDevTrackApiScaffoldDryRunFromFile(manifestPath, options) {
+    const foundationLintGate = await evaluateFoundationScaffoldGate(options.feature_ref);
+    if (foundationLintGate.blocked) {
+        return {
+            schema_version: 1,
+            manifest_path: normalizeManifestPath(manifestPath),
+            plan: {
+                schema_version: 1,
+                status: 'blocked',
+                created_at: options.created_at ?? new Date().toISOString(),
+                operation_id: options.operation_id,
+                project_name: options.project_name,
+                package_name: options.package_name ?? options.project_name,
+                artifacts: [],
+                issues: foundationLintGate.issues,
+            },
+        };
+    }
+    const manifest = await loadPluginManifest(manifestPath);
+    return {
+        schema_version: 1,
+        manifest_path: normalizeManifestPath(manifestPath),
+        plan: buildDevTrackApiScaffoldDryRunPlan(manifest, options),
+    };
+}
+async function evaluateFoundationScaffoldGate(featureRef) {
+    if (!/^FEAT-\d{4}$/u.test(featureRef)) {
+        return { blocked: false, issues: [] };
+    }
+    try {
+        const report = await new FeatureLintService().execute(process.cwd(), featureRef);
+        const foundationErrors = report.findings
+            .filter((finding) => finding.severity === 'error' && finding.code.startsWith('foundation_'))
+            .map((finding) => `${finding.code}: ${finding.message}`);
+        return {
+            blocked: foundationErrors.length > 0,
+            issues: foundationErrors,
+        };
+    }
+    catch {
+        return { blocked: false, issues: [] };
+    }
+}
+function buildInspectResult(manifest, manifestPath) {
+    return {
+        schema_version: 1,
+        manifest_path: normalizeManifestPath(manifestPath),
+        plugin_ref: {
+            id: manifest.id,
+            version: manifest.version,
+        },
+        contract_version: manifest.contract_version,
+        technology: manifest.technology,
+        capabilities: manifest.capabilities.map((capability) => ({
+            name: capability.name,
+            supports_dry_run: capability.supports_dry_run,
+            supports_apply: capability.supports_apply,
+            supports_rollback: capability.supports_rollback,
+            write_scope: capability.write_scope,
+            approval: capability.approval,
+            risk_tier: capability.risk_tier,
+        })),
+        execution: {
+            command: manifest.execution.command,
+            args: manifest.execution.args,
+            timeout_seconds: manifest.execution.timeout_seconds,
+            network: manifest.execution.network,
+            process_spawn: manifest.execution.process_spawn,
+        },
+        governance: {
+            owner: manifest.governance.owner,
+            trust_tier: manifest.governance.trust_tier,
+            risk_tier: manifest.governance.risk_tier,
+            policy_packs: manifest.governance.policy_packs,
+        },
+        validation: manifest.validation,
+        compression: manifest.compression,
+    };
+}
+function buildWorkcellRunner(manifest, plan, standalone) {
+    const capability = manifest.capabilities.find((entry) => entry.name === plan.request.capability);
+    const envelope = plan.envelope;
+    const executable = envelope?.command.executable ?? manifest.execution.command;
+    const args = envelope?.command.args ?? manifest.execution.args;
+    const workingDirectory = envelope?.command.working_directory ?? manifest.execution.working_directory;
+    const commandExcluded = isCompressionExcluded(executable, manifest.compression.exclude_commands);
+    const compressionEnabled = manifest.compression.enabled && manifest.compression.engine !== 'none';
+    const compressionApplied = compressionEnabled && !commandExcluded;
+    const wrappedCommand = compressionApplied
+        ? {
+            executable: 'codesdd-compress',
+            args: [
+                '--engine',
+                manifest.compression.engine,
+                '--tee',
+                manifest.compression.tee,
+                '--max-output-tokens',
+                String(manifest.compression.max_output_tokens),
+                '--',
+                executable,
+                ...args,
+            ],
+        }
+        : null;
+    return {
+        schema_version: 1,
+        status: plan.status === 'ready' && standalone.status === 'blocked' ? 'blocked' : plan.status,
+        parameterization: {
+            owner: 'llm',
+            source: 'runtime-plan-request',
+            feature_ref: plan.request.feature_ref,
+            capability: plan.request.capability,
+        },
+        execution: {
+            owner: 'plugin-cli',
+            mode: plan.request.mode,
+            command: {
+                executable,
+                args,
+                working_directory: workingDirectory,
+            },
+            compression: {
+                mode: manifest.compression.mode,
+                enabled: compressionEnabled,
+                engine: manifest.compression.engine,
+                tee: manifest.compression.tee,
+                max_output_tokens: manifest.compression.max_output_tokens,
+                exclude_commands: manifest.compression.exclude_commands,
+                applied: compressionApplied,
+                wrapped_command: wrappedCommand,
+            },
+        },
+        evidence: {
+            required: envelope?.evidence_requirements ?? [],
+        },
+        rollback: {
+            supported: capability?.supports_rollback ?? false,
+        },
+        standalone,
+    };
+}
+function buildStandaloneRunnerPolicy(manifest, plan, options) {
+    const packageGovernance = evaluatePackageGovernance(manifest);
+    const storageValidation = validateCodesddStoragePaths(options.plannedStoragePaths, {
+        projectRoot: options.projectRoot,
+    });
+    const status = plan.status === 'ready' &&
+        packageGovernance.status === 'passed' &&
+        storageValidation.valid
+        ? 'ready'
+        : 'blocked';
+    return {
+        schema_version: 1,
+        status,
+        package_governance: packageGovernance,
+        language_runtime: {
+            bridge: manifest.language_runtime?.bridge,
+            input_transport: manifest.language_runtime?.input_transport,
+            output_transport: manifest.language_runtime?.output_transport,
+            command: manifest.language_runtime?.command ?? manifest.execution.command,
+        },
+        storage_boundary: {
+            status: storageValidation.valid ? 'passed' : 'blocked',
+            project_root: options.projectRoot,
+            classifications: storageValidation.classifications.length > 0
+                ? storageValidation.classifications
+                : [classifyCodesddStoragePath(options.projectRoot, { projectRoot: options.projectRoot })],
+            findings: storageValidation.findings,
+        },
+    };
+}
+function evaluatePackageGovernance(manifest) {
+    if (!manifest.package_governance) {
+        return {
+            status: 'blocked',
+            issues: ['PACKAGE_GOVERNANCE_MISSING: standalone plugins must declare package_governance.'],
+        };
+    }
+    try {
+        const governance = validatePluginPackageGovernance(manifest.package_governance, `${manifest.id} package_governance`);
+        return {
+            status: 'passed',
+            package_name: governance.package_name,
+            sdk_package: governance.sdk_package,
+            versioning: governance.versioning,
+            registry: governance.registry,
+            issues: [],
+        };
+    }
+    catch (error) {
+        return {
+            status: 'blocked',
+            issues: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}
+function isCompressionExcluded(executable, excludes) {
+    const baseName = path.basename(executable);
+    return excludes.some((entry) => entry === executable || entry === baseName);
+}
+function normalizeManifestPath(manifestPath) {
+    return path.normalize(manifestPath);
+}
+//# sourceMappingURL=plugin-cli.js.map

package/dist/core/sdd/plugin-evidence.d.ts

@@ -0,0 +1,348 @@
+import { z } from 'zod';
+import { type PluginArtifactManifest } from './plugin-broker.js';
+import { type PluginManifest } from './plugin-manifest.js';
+import { type PluginPolicyEvaluation } from './plugin-policy.js';
+import { type PluginPolicyPackEvaluation } from './plugin-policy-pack.js';
+export declare const pluginValidationEvidenceSchema: z.ZodObject<{
+    command: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        passed: "passed";
+        skipped: "skipped";
+    }>;
+    evidence_ref: z.ZodOptional<z.ZodString>;
+    coverage: z.ZodOptional<z.ZodObject<{
+        statements: z.ZodOptional<z.ZodNumber>;
+        branches: z.ZodOptional<z.ZodNumber>;
+        functions: z.ZodOptional<z.ZodNumber>;
+        lines: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const pluginValidationManifestSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    operation_id: z.ZodString;
+    generated_at: z.ZodString;
+    feature_ref: z.ZodString;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    capability: z.ZodString;
+    status: z.ZodEnum<{
+        partial: "partial";
+        failed: "failed";
+        pending: "pending";
+        passed: "passed";
+    }>;
+    validations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            passed: "passed";
+            skipped: "skipped";
+        }>;
+        evidence_ref: z.ZodOptional<z.ZodString>;
+        coverage: z.ZodOptional<z.ZodObject<{
+            statements: z.ZodOptional<z.ZodNumber>;
+            branches: z.ZodOptional<z.ZodNumber>;
+            functions: z.ZodOptional<z.ZodNumber>;
+            lines: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const pluginEvidenceManifestSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    operation_id: z.ZodString;
+    generated_at: z.ZodString;
+    feature_ref: z.ZodString;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    capability: z.ZodString;
+    artifact_manifest: z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        operation_id: z.ZodString;
+        generated_at: z.ZodString;
+        feature_ref: z.ZodString;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        capability: z.ZodString;
+        mode: z.ZodEnum<{
+            apply: "apply";
+            "dry-run": "dry-run";
+            rollback: "rollback";
+        }>;
+        status: z.ZodEnum<{
+            planned: "planned";
+            applied: "applied";
+            rolled_back: "rolled_back";
+            failed: "failed";
+        }>;
+        artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                created: "created";
+                planned: "planned";
+                modified: "modified";
+                deleted: "deleted";
+                unchanged: "unchanged";
+                validated: "validated";
+            }>;
+            reason: z.ZodString;
+            checksum_before: z.ZodOptional<z.ZodString>;
+            checksum_after: z.ZodOptional<z.ZodString>;
+            content_type: z.ZodOptional<z.ZodString>;
+            artifact_kind: z.ZodOptional<z.ZodEnum<{
+                documentation: "documentation";
+                schema: "schema";
+                configuration: "configuration";
+                source: "source";
+                migration: "migration";
+                evidence: "evidence";
+                test: "test";
+                asset: "asset";
+                "package-metadata": "package-metadata";
+            }>>;
+            role: z.ZodOptional<z.ZodEnum<{
+                documentation: "documentation";
+                type: "type";
+                validator: "validator";
+                evidence: "evidence";
+                test: "test";
+                interface: "interface";
+                implementation: "implementation";
+                abstraction: "abstraction";
+                "business-object": "business-object";
+                "value-object": "value-object";
+                entity: "entity";
+                "repository-port": "repository-port";
+                "use-case": "use-case";
+                service: "service";
+                handler: "handler";
+                adapter: "adapter";
+                mapper: "mapper";
+                module: "module";
+                controller: "controller";
+                dto: "dto";
+                policy: "policy";
+                manifest: "manifest";
+                fixture: "fixture";
+            }>>;
+            layer: z.ZodOptional<z.ZodEnum<{
+                sdd: "sdd";
+                config: "config";
+                domain: "domain";
+                docs: "docs";
+                root: "root";
+                application: "application";
+                infrastructure: "infrastructure";
+                presentation: "presentation";
+                shared: "shared";
+                tests: "tests";
+                assets: "assets";
+            }>>;
+            language: z.ZodOptional<z.ZodEnum<{
+                shell: "shell";
+                other: "other";
+                typescript: "typescript";
+                javascript: "javascript";
+                python: "python";
+                java: "java";
+                go: "go";
+                rust: "rust";
+                csharp: "csharp";
+                php: "php";
+                ruby: "ruby";
+            }>>;
+            context: z.ZodOptional<z.ZodString>;
+            implementation: z.ZodOptional<z.ZodEnum<{
+                contract: "contract";
+                manual: "manual";
+                concrete: "concrete";
+                abstract: "abstract";
+                generated: "generated";
+            }>>;
+            decision_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            source_refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        validation_evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            evidence_ref: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    validation_manifest: z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        operation_id: z.ZodString;
+        generated_at: z.ZodString;
+        feature_ref: z.ZodString;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        capability: z.ZodString;
+        status: z.ZodEnum<{
+            partial: "partial";
+            failed: "failed";
+            pending: "pending";
+            passed: "passed";
+        }>;
+        validations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                pending: "pending";
+                passed: "passed";
+                skipped: "skipped";
+            }>;
+            evidence_ref: z.ZodOptional<z.ZodString>;
+            coverage: z.ZodOptional<z.ZodObject<{
+                statements: z.ZodOptional<z.ZodNumber>;
+                branches: z.ZodOptional<z.ZodNumber>;
+                functions: z.ZodOptional<z.ZodNumber>;
+                lines: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    policy_evaluation: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        capability: z.ZodString;
+        mode: z.ZodEnum<{
+            apply: "apply";
+            "dry-run": "dry-run";
+            rollback: "rollback";
+        }>;
+        decision: z.ZodEnum<{
+            deny: "deny";
+            warn: "warn";
+            allow: "allow";
+        }>;
+        issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                deny: "deny";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    policy_pack_evaluation: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        plugin_ref: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strip>;
+        decision: z.ZodEnum<{
+            deny: "deny";
+            warn: "warn";
+            allow: "allow";
+        }>;
+        declared_policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        applied_policy_packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            severity: z.ZodEnum<{
+                deny: "deny";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+            policy_pack: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    traceability_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    quality_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    residual_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        description: z.ZodString;
+        mitigation: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const pluginComplianceCriterionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    status: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>;
+    score: z.ZodNumber;
+    max_score: z.ZodNumber;
+    evidence: z.ZodString;
+    issues: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const pluginComplianceIndexSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    feature_ref: z.ZodString;
+    operation_id: z.ZodString;
+    plugin_ref: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+    capability: z.ZodString;
+    score: z.ZodNumber;
+    decision: z.ZodEnum<{
+        warning: "warning";
+        compliant: "compliant";
+        "non-compliant": "non-compliant";
+    }>;
+    criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            warn: "warn";
+        }>;
+        score: z.ZodNumber;
+        max_score: z.ZodNumber;
+        evidence: z.ZodString;
+        issues: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    evidence_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PluginValidationManifest = z.infer<typeof pluginValidationManifestSchema>;
+export type PluginEvidenceManifest = z.infer<typeof pluginEvidenceManifestSchema>;
+export type PluginComplianceCriterion = z.infer<typeof pluginComplianceCriterionSchema>;
+export type PluginComplianceIndex = z.infer<typeof pluginComplianceIndexSchema>;
+export interface BuildPluginEvidenceManifestInput {
+    artifact_manifest: PluginArtifactManifest;
+    validation_manifest?: PluginValidationManifest;
+    policy_evaluation?: PluginPolicyEvaluation;
+    policy_pack_evaluation?: PluginPolicyPackEvaluation;
+    traceability_refs?: string[];
+    quality_refs?: string[];
+    residual_risks?: PluginEvidenceManifest['residual_risks'];
+    metadata?: Record<string, unknown>;
+}
+export interface BuildPluginComplianceIndexInput {
+    manifest: PluginManifest;
+    evidence_manifest: PluginEvidenceManifest;
+    generated_at?: string;
+}
+export declare function buildPluginEvidenceManifest(input: BuildPluginEvidenceManifestInput): PluginEvidenceManifest;
+export declare function buildPluginComplianceIndex(input: BuildPluginComplianceIndexInput): PluginComplianceIndex;
+//# sourceMappingURL=plugin-evidence.d.ts.map