@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

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

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+import { pluginCapabilitySchema, pluginManifestSchema, } from './plugin-manifest.js';
+const TRUST_RANK = {
+    'enterprise-approved': 3,
+    'local-dev': 2,
+    experimental: 1,
+    blocked: 0,
+};
+const RISK_RANK = {
+    low: 4,
+    medium: 3,
+    high: 2,
+    critical: 1,
+};
+export const pluginRegistrySourceSchema = z.object({
+    type: z.enum(['local', 'workspace', 'enterprise-catalog']),
+    uri: z.string().min(1),
+    checksum: z.string().optional(),
+});
+export const pluginRegistryEntrySchema = z.object({
+    manifest: pluginManifestSchema,
+    source: pluginRegistrySourceSchema,
+    status: z.enum(['active', 'disabled', 'blocked', 'deprecated']).default('active'),
+    registered_at: z.string().datetime(),
+    notes: z.array(z.string()).default([]),
+});
+export const pluginRegistryStateSchema = z
+    .object({
+    schema_version: z.literal(1),
+    generated_at: z.string().datetime(),
+    entries: z.array(pluginRegistryEntrySchema).default([]),
+})
+    .superRefine((state, context) => {
+    const seen = new Set();
+    for (const [index, entry] of state.entries.entries()) {
+        const key = `${entry.manifest.id}@${entry.manifest.version}`;
+        if (seen.has(key)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['entries', index, 'manifest', 'id'],
+                message: `Duplicate plugin registration: ${key}.`,
+            });
+        }
+        seen.add(key);
+    }
+});
+export function createPluginRegistryState(plugins, generatedAt = new Date().toISOString()) {
+    return pluginRegistryStateSchema.parse({
+        schema_version: 1,
+        generated_at: generatedAt,
+        entries: plugins.map((plugin) => ({
+            manifest: plugin.manifest,
+            source: plugin.source,
+            status: plugin.status ?? 'active',
+            registered_at: plugin.registered_at ?? generatedAt,
+            notes: plugin.notes ?? [],
+        })),
+    });
+}
+export function resolvePluginCapability(registryState, request) {
+    const registry = pluginRegistryStateSchema.parse(registryState);
+    const statuses = request.statuses ?? ['active'];
+    const trustTiers = request.trust_tiers ?? ['enterprise-approved', 'local-dev', 'experimental'];
+    const requireDryRun = request.require_dry_run ?? true;
+    const reasons = [];
+    const candidates = [];
+    for (const entry of registry.entries) {
+        const pluginRef = `${entry.manifest.id}@${entry.manifest.version}`;
+        const entryReasons = collectEntryRejectionReasons(entry, request, statuses, trustTiers);
+        if (entryReasons.length > 0) {
+            reasons.push(...entryReasons.map((reason) => `${pluginRef}: ${reason}`));
+            continue;
+        }
+        const capability = entry.manifest.capabilities.find((candidate) => candidate.name === request.capability);
+        if (!capability) {
+            reasons.push(`${pluginRef}: capability ${request.capability} is not advertised.`);
+            continue;
+        }
+        const capabilityReasons = collectCapabilityRejectionReasons(capability, request, requireDryRun);
+        if (capabilityReasons.length > 0) {
+            reasons.push(...capabilityReasons.map((reason) => `${pluginRef}/${capability.name}: ${reason}`));
+            continue;
+        }
+        candidates.push({
+            entry,
+            capability: pluginCapabilitySchema.parse(capability),
+            score: scoreCandidate(entry, capability),
+        });
+    }
+    const [winner] = candidates.sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        return `${left.entry.manifest.id}@${left.entry.manifest.version}`.localeCompare(`${right.entry.manifest.id}@${right.entry.manifest.version}`);
+    });
+    if (!winner) {
+        return {
+            status: 'unresolved',
+            reasons: reasons.length > 0 ? reasons : [`No registered plugins are available for ${request.capability}.`],
+        };
+    }
+    return {
+        status: 'resolved',
+        entry: winner.entry,
+        capability: winner.capability,
+        reasons: [`Resolved ${request.capability} to ${winner.entry.manifest.id}@${winner.entry.manifest.version}.`],
+    };
+}
+function collectEntryRejectionReasons(entry, request, statuses, trustTiers) {
+    const reasons = [];
+    if (!statuses.includes(entry.status)) {
+        reasons.push(`status ${entry.status} is not eligible.`);
+    }
+    if (!trustTiers.includes(entry.manifest.governance.trust_tier)) {
+        reasons.push(`trust tier ${entry.manifest.governance.trust_tier} is not eligible.`);
+    }
+    if (request.technology?.language && entry.manifest.technology.language !== request.technology.language) {
+        reasons.push(`language ${entry.manifest.technology.language} does not match ${request.technology.language}.`);
+    }
+    if (request.technology?.framework && entry.manifest.technology.framework !== request.technology.framework) {
+        reasons.push(`framework ${entry.manifest.technology.framework ?? '<none>'} does not match ${request.technology.framework}.`);
+    }
+    return reasons;
+}
+function collectCapabilityRejectionReasons(capability, request, requireDryRun) {
+    const reasons = [];
+    if (request.require_apply && !capability.supports_apply) {
+        reasons.push('apply mode is required but not supported.');
+    }
+    if (requireDryRun && !capability.supports_dry_run) {
+        reasons.push('dry-run mode is required but not supported.');
+    }
+    return reasons;
+}
+function scoreCandidate(entry, capability) {
+    return TRUST_RANK[entry.manifest.governance.trust_tier] * 100 + RISK_RANK[capability.risk_tier] * 10;
+}
+//# sourceMappingURL=plugin-registry.js.map

package/dist/core/sdd/plugin-sdk-contract.d.ts

@@ -0,0 +1,363 @@
+import { z } from 'zod';
+export declare const CODESDD_PLUGIN_SDK_PACKAGE_NAME = "@devtrack-solution/codesdd-plugin-sdk";
+export declare const CODESDD_PLUGIN_PACKAGE_PREFIX = "@devtrack-solution/codesdd-plugin-";
+export declare const pluginRuntimeLanguageSchema: z.ZodEnum<{
+    shell: "shell";
+    other: "other";
+    typescript: "typescript";
+    javascript: "javascript";
+    python: "python";
+    java: "java";
+    go: "go";
+    rust: "rust";
+    csharp: "csharp";
+    php: "php";
+    ruby: "ruby";
+}>;
+export declare const pluginRuntimeBridgeSchema: z.ZodEnum<{
+    "node-library": "node-library";
+    "stdio-json": "stdio-json";
+    "process-cli": "process-cli";
+    "http-local": "http-local";
+    container: "container";
+    wasm: "wasm";
+}>;
+export declare const pluginRuntimeTransportSchema: z.ZodEnum<{
+    "sdk-call": "sdk-call";
+    "stdin-json": "stdin-json";
+    "stdout-json": "stdout-json";
+    "file-envelope": "file-envelope";
+    "http-json": "http-json";
+}>;
+export declare const pluginPackageKindSchema: z.ZodEnum<{
+    frontend: "frontend";
+    backend: "backend";
+    "full-stack": "full-stack";
+    generator: "generator";
+    validator: "validator";
+    evidence: "evidence";
+    "agent-adapter": "agent-adapter";
+    "policy-pack": "policy-pack";
+}>;
+export declare const pluginPackageGovernanceSchema: z.ZodObject<{
+    package_name: z.ZodString;
+    sdk_package: z.ZodDefault<z.ZodString>;
+    sdk_version: z.ZodDefault<z.ZodString>;
+    package_kind: z.ZodEnum<{
+        frontend: "frontend";
+        backend: "backend";
+        "full-stack": "full-stack";
+        generator: "generator";
+        validator: "validator";
+        evidence: "evidence";
+        "agent-adapter": "agent-adapter";
+        "policy-pack": "policy-pack";
+    }>;
+    versioning: z.ZodDefault<z.ZodLiteral<"semver">>;
+    registry: z.ZodDefault<z.ZodEnum<{
+        custom: "custom";
+        workspace: "workspace";
+        npm: "npm";
+        "private-npm": "private-npm";
+        "artifact-registry": "artifact-registry";
+    }>>;
+    keywords: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    internal_package: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const pluginLanguageRuntimeSchema: z.ZodObject<{
+    language: z.ZodEnum<{
+        shell: "shell";
+        other: "other";
+        typescript: "typescript";
+        javascript: "javascript";
+        python: "python";
+        java: "java";
+        go: "go";
+        rust: "rust";
+        csharp: "csharp";
+        php: "php";
+        ruby: "ruby";
+    }>;
+    runtime: z.ZodString;
+    bridge: z.ZodEnum<{
+        "node-library": "node-library";
+        "stdio-json": "stdio-json";
+        "process-cli": "process-cli";
+        "http-local": "http-local";
+        container: "container";
+        wasm: "wasm";
+    }>;
+    input_transport: z.ZodEnum<{
+        "sdk-call": "sdk-call";
+        "stdin-json": "stdin-json";
+        "stdout-json": "stdout-json";
+        "file-envelope": "file-envelope";
+        "http-json": "http-json";
+    }>;
+    output_transport: z.ZodEnum<{
+        "sdk-call": "sdk-call";
+        "stdin-json": "stdin-json";
+        "stdout-json": "stdout-json";
+        "file-envelope": "file-envelope";
+        "http-json": "http-json";
+    }>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    package_manager: z.ZodOptional<z.ZodString>;
+    min_versions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    env_allowlist: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const pluginArtifactLayerSchema: z.ZodEnum<{
+    sdd: "sdd";
+    config: "config";
+    domain: "domain";
+    docs: "docs";
+    root: "root";
+    application: "application";
+    infrastructure: "infrastructure";
+    presentation: "presentation";
+    shared: "shared";
+    tests: "tests";
+    assets: "assets";
+}>;
+export declare const pluginArtifactKindSchema: z.ZodEnum<{
+    documentation: "documentation";
+    schema: "schema";
+    configuration: "configuration";
+    source: "source";
+    migration: "migration";
+    evidence: "evidence";
+    test: "test";
+    asset: "asset";
+    "package-metadata": "package-metadata";
+}>;
+export declare const pluginArtifactRoleSchema: 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";
+}>;
+export declare const pluginArtifactOperationSchema: z.ZodEnum<{
+    created: "created";
+    planned: "planned";
+    modified: "modified";
+    deleted: "deleted";
+    unchanged: "unchanged";
+    validated: "validated";
+}>;
+export declare const pluginArtifactMapEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        created: "created";
+        planned: "planned";
+        modified: "modified";
+        deleted: "deleted";
+        unchanged: "unchanged";
+        validated: "validated";
+    }>;
+    artifact_kind: z.ZodEnum<{
+        documentation: "documentation";
+        schema: "schema";
+        configuration: "configuration";
+        source: "source";
+        migration: "migration";
+        evidence: "evidence";
+        test: "test";
+        asset: "asset";
+        "package-metadata": "package-metadata";
+    }>;
+    role: 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.ZodEnum<{
+        sdd: "sdd";
+        config: "config";
+        domain: "domain";
+        docs: "docs";
+        root: "root";
+        application: "application";
+        infrastructure: "infrastructure";
+        presentation: "presentation";
+        shared: "shared";
+        tests: "tests";
+        assets: "assets";
+    }>;
+    content_type: z.ZodString;
+    reason: z.ZodString;
+    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.ZodDefault<z.ZodEnum<{
+        contract: "contract";
+        manual: "manual";
+        concrete: "concrete";
+        abstract: "abstract";
+        generated: "generated";
+    }>>;
+    decision_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const pluginArtifactMapSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    sdk_package: z.ZodDefault<z.ZodLiteral<"@devtrack-solution/codesdd-plugin-sdk">>;
+    feature_ref: z.ZodOptional<z.ZodString>;
+    operation_id: z.ZodOptional<z.ZodString>;
+    plugin_ref: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+    generated_at: z.ZodString;
+    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";
+        }>;
+        artifact_kind: z.ZodEnum<{
+            documentation: "documentation";
+            schema: "schema";
+            configuration: "configuration";
+            source: "source";
+            migration: "migration";
+            evidence: "evidence";
+            test: "test";
+            asset: "asset";
+            "package-metadata": "package-metadata";
+        }>;
+        role: 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.ZodEnum<{
+            sdd: "sdd";
+            config: "config";
+            domain: "domain";
+            docs: "docs";
+            root: "root";
+            application: "application";
+            infrastructure: "infrastructure";
+            presentation: "presentation";
+            shared: "shared";
+            tests: "tests";
+            assets: "assets";
+        }>;
+        content_type: z.ZodString;
+        reason: z.ZodString;
+        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.ZodDefault<z.ZodEnum<{
+            contract: "contract";
+            manual: "manual";
+            concrete: "concrete";
+            abstract: "abstract";
+            generated: "generated";
+        }>>;
+        decision_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        source_refs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PluginPackageGovernance = z.infer<typeof pluginPackageGovernanceSchema>;
+export type PluginLanguageRuntime = z.infer<typeof pluginLanguageRuntimeSchema>;
+export type PluginArtifactKind = z.infer<typeof pluginArtifactKindSchema>;
+export type PluginArtifactRole = z.infer<typeof pluginArtifactRoleSchema>;
+export type PluginArtifactLayer = z.infer<typeof pluginArtifactLayerSchema>;
+export type PluginArtifactMapEntry = z.infer<typeof pluginArtifactMapEntrySchema>;
+export type PluginArtifactMap = z.infer<typeof pluginArtifactMapSchema>;
+export declare function buildPluginPackageName(pluginId: string): string;
+export declare function validatePluginPackageGovernance(value: unknown, sourceLabel?: string): PluginPackageGovernance;
+export declare function validatePluginArtifactMap(value: unknown, sourceLabel?: string): PluginArtifactMap;
+export declare function buildPluginSdkJsonSchemas(): Record<string, unknown>;
+//# sourceMappingURL=plugin-sdk-contract.d.ts.map