@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/project-config.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { parse as parseYaml } from 'yaml';
 import { z } from 'zod';
-import { resolveOpenSpecSubpath } from './sdd/services/legacy-capability.service.js';
+import { resolveLegacySpecSubpath } from './sdd/services/legacy-capability.service.js';
 /**
  * Zod schema for project configuration.
  *
@@ -11,9 +11,9 @@ import { resolveOpenSpecSubpath } from './sdd/services/legacy-capability.service
  * 3. Runtime validation - uses safeParse() for resilient field-by-field validation
  *
  * Why Zod over manual validation:
- * - Helps understand OpenSpec's data interfaces at a glance
+ * - Helps understand CodeSDD's data interfaces at a glance
  * - Single source of truth for type and validation
- * - Consistent with other OpenSpec schemas
+ * - Consistent with other CodeSDD schemas
  */
 export const ProjectConfigSchema = z.object({
     // Required: which schema to use (e.g., "spec-driven", or project-local schema name)
@@ -37,7 +37,7 @@ export const ProjectConfigSchema = z.object({
 });
 const MAX_CONTEXT_SIZE = 50 * 1024; // 50KB hard limit
 /**
- * Read and parse openspec/config.yaml from project root.
+ * Read and parse legacy-spec/config.yaml from project root.
  * Uses resilient parsing - validates each field independently using Zod safeParse.
  * Returns null if file doesn't exist.
  * Returns partial config if some fields are invalid (with warnings).
@@ -52,14 +52,14 @@ const MAX_CONTEXT_SIZE = 50 * 1024; // 50KB hard limit
  * invalidation logic) for negligible benefit. Direct reads also ensure config
  * changes are reflected immediately without stale cache issues.
  *
- * @param projectRoot - The root directory of the project (where `openspec/` lives)
+ * @param projectRoot - The root directory of the project (where `legacy-spec/` lives)
  * @returns Parsed config or null if file doesn't exist
  */
 export function readProjectConfig(projectRoot) {
     // Try both .yaml and .yml, prefer .yaml
-    let configPath = resolveOpenSpecSubpath(projectRoot, 'config.yaml');
+    let configPath = resolveLegacySpecSubpath(projectRoot, 'config.yaml');
     if (!existsSync(configPath)) {
-        configPath = resolveOpenSpecSubpath(projectRoot, 'config.yml');
+        configPath = resolveLegacySpecSubpath(projectRoot, 'config.yml');
         if (!existsSync(configPath)) {
             return null; // No config is OK
         }
@@ -68,7 +68,7 @@ export function readProjectConfig(projectRoot) {
         const content = readFileSync(configPath, 'utf-8');
         const raw = parseYaml(content);
         if (!raw || typeof raw !== 'object') {
-            console.warn(`openspec/config.yaml is not a valid YAML object`);
+            console.warn(`legacy-spec/config.yaml is not a valid YAML object`);
             return null;
         }
         const config = {};
@@ -135,7 +135,7 @@ export function readProjectConfig(projectRoot) {
         return Object.keys(config).length > 0 ? config : null;
     }
     catch (error) {
-        console.warn(`Failed to parse openspec/config.yaml:`, error);
+        console.warn(`Failed to parse legacy-spec/config.yaml:`, error);
         return null;
     }
 }
@@ -198,7 +198,7 @@ export function suggestSchemas(invalidSchemaName, availableSchemas) {
         .slice(0, 3);
     const builtIn = availableSchemas.filter((s) => s.isBuiltIn).map((s) => s.name);
     const projectLocal = availableSchemas.filter((s) => !s.isBuiltIn).map((s) => s.name);
-    let message = `Schema '${invalidSchemaName}' not found in openspec/config.yaml\n\n`;
+    let message = `Schema '${invalidSchemaName}' not found in legacy-spec/config.yaml\n\n`;
     if (suggestions.length > 0) {
         message += `Did you mean one of these?\n`;
         suggestions.forEach((s) => {
@@ -217,7 +217,7 @@ export function suggestSchemas(invalidSchemaName, availableSchemas) {
     else {
         message += `  Project-local: (none found)\n`;
     }
-    message += `\nFix: Edit openspec/config.yaml and change 'schema: ${invalidSchemaName}' to a valid schema name`;
+    message += `\nFix: Edit legacy-spec/config.yaml and change 'schema: ${invalidSchemaName}' to a valid schema name`;
     return message;
 }
 //# sourceMappingURL=project-config.js.map

package/dist/core/schemas/change.schema.d.ts

@@ -63,7 +63,7 @@ export declare const ChangeSchema: z.ZodObject<{
     }, z.core.$strip>>;
     metadata: z.ZodOptional<z.ZodObject<{
         version: z.ZodDefault<z.ZodString>;
-        format: z.ZodLiteral<"openspec-change">;
+        format: z.ZodLiteral<"codesdd-change">;
         sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/core/schemas/change.schema.js

@@ -24,7 +24,7 @@ export const ChangeSchema = z.object({
         .max(MAX_DELTAS_PER_CHANGE, VALIDATION_MESSAGES.CHANGE_TOO_MANY_DELTAS),
     metadata: z.object({
         version: z.string().default('1.0.0'),
-        format: z.literal('openspec-change'),
+        format: z.literal('codesdd-change'),
         sourcePath: z.string().optional(),
     }).optional(),
 });

package/dist/core/schemas/spec.schema.d.ts

@@ -10,7 +10,7 @@ export declare const SpecSchema: z.ZodObject<{
     }, z.core.$strip>>;
     metadata: z.ZodOptional<z.ZodObject<{
         version: z.ZodDefault<z.ZodString>;
-        format: z.ZodLiteral<"openspec">;
+        format: z.ZodLiteral<"codesdd">;
         sourcePath: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/core/schemas/spec.schema.js

@@ -8,7 +8,7 @@ export const SpecSchema = z.object({
         .min(1, VALIDATION_MESSAGES.SPEC_NO_REQUIREMENTS),
     metadata: z.object({
         version: z.string().default('1.0.0'),
-        format: z.literal('openspec'),
+        format: z.literal('codesdd'),
         sourcePath: z.string().optional(),
     }).optional(),
 });

package/dist/core/sdd/adr.js

@@ -1,10 +1,32 @@
+import * as yaml from 'yaml';
 export function adrFileName(featureId) {
     return `ADR-${featureId}.md`;
 }
 export function generateAdrTemplate(feature, createdAtIso) {
     const refs = [feature.id, feature.origin_ref].filter(Boolean);
     const refsText = refs.length > 0 ? refs.join(', ') : '-';
-    return `# ADR ${feature.id}: ${feature.title}
+    const frontmatter = yaml
+        .stringify({
+        schema_version: 1,
+        artifact_type: 'ADR',
+        id: `ADR-${feature.id}`,
+        feature_id: feature.id,
+        title: `ADR ${feature.id}: ${feature.title}`,
+        status: feature.status,
+        origin: { type: 'feature', ref: feature.id },
+        related_ids: refs,
+        created_at: createdAtIso,
+        updated_at: createdAtIso,
+        decision_status: feature.status === 'DONE' ? 'ACCEPTED' : 'PROPOSED',
+        supersedes: [],
+        superseded_by: [],
+        references: refs,
+    })
+        .trim();
+    return `---
+${frontmatter}
+---
+# ADR ${feature.id}: ${feature.title}
 
 ## Context
 Describe the context that motivated this architecture decision, including constraints and trade-offs.

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

@@ -0,0 +1,346 @@
+import { z } from 'zod';
+declare const agentProviderSchema: z.ZodEnum<{
+    codex: "codex";
+    opencode: "opencode";
+    deepagents: "deepagents";
+    fake: "fake";
+    "claude-code": "claude-code";
+    cloudcode: "cloudcode";
+}>;
+declare const agentTaskKindSchema: z.ZodEnum<{
+    validation: "validation";
+    planning: "planning";
+    "reverse-engineering": "reverse-engineering";
+    implementation: "implementation";
+    review: "review";
+    "plugin-execution": "plugin-execution";
+    "adr-governance": "adr-governance";
+    "quality-witness": "quality-witness";
+    "documentation-sync": "documentation-sync";
+}>;
+declare const trustTierSchema: z.ZodEnum<{
+    experimental: "experimental";
+    blocked: "blocked";
+    "local-dev": "local-dev";
+    "enterprise-approved": "enterprise-approved";
+}>;
+declare const riskTierSchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    critical: "critical";
+}>;
+export declare const agentBindingCapabilitySchema: z.ZodObject<{
+    task_kind: z.ZodEnum<{
+        validation: "validation";
+        planning: "planning";
+        "reverse-engineering": "reverse-engineering";
+        implementation: "implementation";
+        review: "review";
+        "plugin-execution": "plugin-execution";
+        "adr-governance": "adr-governance";
+        "quality-witness": "quality-witness";
+        "documentation-sync": "documentation-sync";
+    }>;
+    description: z.ZodString;
+    read_only: z.ZodBoolean;
+    edits: z.ZodBoolean;
+    background: z.ZodBoolean;
+    worktree_isolation: z.ZodBoolean;
+    mcp: z.ZodBoolean;
+    skills: z.ZodBoolean;
+    structured_evidence: z.ZodBoolean;
+    risk_tier: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>>;
+}, z.core.$strip>;
+export declare const agentBindingAdapterSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    id: z.ZodString;
+    provider: z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+        fake: "fake";
+        "claude-code": "claude-code";
+        cloudcode: "cloudcode";
+    }>;
+    label: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        experimental: "experimental";
+        disabled: "disabled";
+        active: "active";
+    }>>;
+    execution: z.ZodObject<{
+        mode: z.ZodEnum<{
+            "local-cli": "local-cli";
+            cloud: "cloud";
+            "test-double": "test-double";
+        }>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        network: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            restricted: "restricted";
+            enabled: "enabled";
+        }>>;
+        evidence_contract: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        task_kind: z.ZodEnum<{
+            validation: "validation";
+            planning: "planning";
+            "reverse-engineering": "reverse-engineering";
+            implementation: "implementation";
+            review: "review";
+            "plugin-execution": "plugin-execution";
+            "adr-governance": "adr-governance";
+            "quality-witness": "quality-witness";
+            "documentation-sync": "documentation-sync";
+        }>;
+        description: z.ZodString;
+        read_only: z.ZodBoolean;
+        edits: z.ZodBoolean;
+        background: z.ZodBoolean;
+        worktree_isolation: z.ZodBoolean;
+        mcp: z.ZodBoolean;
+        skills: z.ZodBoolean;
+        structured_evidence: z.ZodBoolean;
+        risk_tier: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>>;
+    }, z.core.$strip>>;
+    governance: z.ZodObject<{
+        owner: z.ZodString;
+        trust_tier: z.ZodEnum<{
+            experimental: "experimental";
+            blocked: "blocked";
+            "local-dev": "local-dev";
+            "enterprise-approved": "enterprise-approved";
+        }>;
+        approval: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            maintainer: "maintainer";
+            security: "security";
+            "architecture-board": "architecture-board";
+        }>>;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const agentBindingResolutionRequestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    feature_ref: z.ZodString;
+    task_kind: z.ZodEnum<{
+        validation: "validation";
+        planning: "planning";
+        "reverse-engineering": "reverse-engineering";
+        implementation: "implementation";
+        review: "review";
+        "plugin-execution": "plugin-execution";
+        "adr-governance": "adr-governance";
+        "quality-witness": "quality-witness";
+        "documentation-sync": "documentation-sync";
+    }>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+        fake: "fake";
+        "claude-code": "claude-code";
+        cloudcode: "cloudcode";
+    }>>;
+    allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+        fake: "fake";
+        "claude-code": "claude-code";
+        cloudcode: "cloudcode";
+    }>>>;
+    statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        experimental: "experimental";
+        disabled: "disabled";
+        active: "active";
+    }>>>;
+    trust_tiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        experimental: "experimental";
+        blocked: "blocked";
+        "local-dev": "local-dev";
+        "enterprise-approved": "enterprise-approved";
+    }>>>;
+    require_edits: z.ZodDefault<z.ZodBoolean>;
+    require_background: z.ZodDefault<z.ZodBoolean>;
+    require_worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+    require_mcp: z.ZodDefault<z.ZodBoolean>;
+    require_skills: z.ZodDefault<z.ZodBoolean>;
+    require_structured_evidence: z.ZodDefault<z.ZodBoolean>;
+    created_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const agentBindingCandidateSchema: z.ZodObject<{
+    adapter_ref: z.ZodObject<{
+        id: z.ZodString;
+        provider: z.ZodEnum<{
+            codex: "codex";
+            opencode: "opencode";
+            deepagents: "deepagents";
+            fake: "fake";
+            "claude-code": "claude-code";
+            cloudcode: "cloudcode";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    task_kind: z.ZodEnum<{
+        validation: "validation";
+        planning: "planning";
+        "reverse-engineering": "reverse-engineering";
+        implementation: "implementation";
+        review: "review";
+        "plugin-execution": "plugin-execution";
+        "adr-governance": "adr-governance";
+        "quality-witness": "quality-witness";
+        "documentation-sync": "documentation-sync";
+    }>;
+    rank: z.ZodNumber;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const agentBindingResolutionSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    created_at: z.ZodString;
+    status: z.ZodEnum<{
+        resolved: "resolved";
+        fallback: "fallback";
+    }>;
+    request: z.ZodObject<{
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+        feature_ref: z.ZodString;
+        task_kind: z.ZodEnum<{
+            validation: "validation";
+            planning: "planning";
+            "reverse-engineering": "reverse-engineering";
+            implementation: "implementation";
+            review: "review";
+            "plugin-execution": "plugin-execution";
+            "adr-governance": "adr-governance";
+            "quality-witness": "quality-witness";
+            "documentation-sync": "documentation-sync";
+        }>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            codex: "codex";
+            opencode: "opencode";
+            deepagents: "deepagents";
+            fake: "fake";
+            "claude-code": "claude-code";
+            cloudcode: "cloudcode";
+        }>>;
+        allowed_providers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            codex: "codex";
+            opencode: "opencode";
+            deepagents: "deepagents";
+            fake: "fake";
+            "claude-code": "claude-code";
+            cloudcode: "cloudcode";
+        }>>>;
+        statuses: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            experimental: "experimental";
+            disabled: "disabled";
+            active: "active";
+        }>>>;
+        trust_tiers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            experimental: "experimental";
+            blocked: "blocked";
+            "local-dev": "local-dev";
+            "enterprise-approved": "enterprise-approved";
+        }>>>;
+        require_edits: z.ZodDefault<z.ZodBoolean>;
+        require_background: z.ZodDefault<z.ZodBoolean>;
+        require_worktree_isolation: z.ZodDefault<z.ZodBoolean>;
+        require_mcp: z.ZodDefault<z.ZodBoolean>;
+        require_skills: z.ZodDefault<z.ZodBoolean>;
+        require_structured_evidence: z.ZodDefault<z.ZodBoolean>;
+        created_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    selected: z.ZodOptional<z.ZodObject<{
+        adapter_ref: z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodEnum<{
+                codex: "codex";
+                opencode: "opencode";
+                deepagents: "deepagents";
+                fake: "fake";
+                "claude-code": "claude-code";
+                cloudcode: "cloudcode";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        task_kind: z.ZodEnum<{
+            validation: "validation";
+            planning: "planning";
+            "reverse-engineering": "reverse-engineering";
+            implementation: "implementation";
+            review: "review";
+            "plugin-execution": "plugin-execution";
+            "adr-governance": "adr-governance";
+            "quality-witness": "quality-witness";
+            "documentation-sync": "documentation-sync";
+        }>;
+        rank: z.ZodNumber;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        adapter_ref: z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodEnum<{
+                codex: "codex";
+                opencode: "opencode";
+                deepagents: "deepagents";
+                fake: "fake";
+                "claude-code": "claude-code";
+                cloudcode: "cloudcode";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        task_kind: z.ZodEnum<{
+            validation: "validation";
+            planning: "planning";
+            "reverse-engineering": "reverse-engineering";
+            implementation: "implementation";
+            review: "review";
+            "plugin-execution": "plugin-execution";
+            "adr-governance": "adr-governance";
+            "quality-witness": "quality-witness";
+            "documentation-sync": "documentation-sync";
+        }>;
+        rank: z.ZodNumber;
+        reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    reasons: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fallback: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodEnum<{
+            "manual-agent-selection": "manual-agent-selection";
+            "local-human-execution": "local-human-execution";
+            "no-compatible-agent": "no-compatible-agent";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentProvider = z.infer<typeof agentProviderSchema>;
+export type AgentTaskKind = z.infer<typeof agentTaskKindSchema>;
+export type AgentTrustTier = z.infer<typeof trustTierSchema>;
+export type AgentRiskTier = z.infer<typeof riskTierSchema>;
+export type AgentBindingCapability = z.infer<typeof agentBindingCapabilitySchema>;
+export type AgentBindingAdapter = z.infer<typeof agentBindingAdapterSchema>;
+export type AgentBindingAdapterInput = z.input<typeof agentBindingAdapterSchema>;
+export type AgentBindingResolutionRequest = z.infer<typeof agentBindingResolutionRequestSchema>;
+export type AgentBindingResolutionRequestInput = z.input<typeof agentBindingResolutionRequestSchema>;
+export type AgentBindingCandidate = z.infer<typeof agentBindingCandidateSchema>;
+export type AgentBindingResolution = z.infer<typeof agentBindingResolutionSchema>;
+export declare function builtInAgentBindingAdapters(): AgentBindingAdapter[];
+export declare function resolveAgentBindingAdapter(adapters: AgentBindingAdapterInput[], request: AgentBindingResolutionRequestInput): AgentBindingResolution;
+export {};
+//# sourceMappingURL=agent-binding.d.ts.map