synarcx 0.1.0

package/dist/core/profile-sync-drift.js

@@ -0,0 +1,197 @@
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS } from './config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { COMMAND_IDS, getConfiguredTools } from './shared/index.js';
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export const WORKFLOW_TO_SKILL_DIR = {
+    'explore': 'syn-explore',
+    'apply': 'syn-apply',
+    'archive': 'syn-archive',
+    'propose': 'syn-propose',
+    'sync': 'syn-sync',
+    'clarify': 'syn-clarify',
+    'analyze': 'syn-analyze',
+    'debug': 'syn-debug',
+};
+function toKnownWorkflows(workflows) {
+    return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));
+}
+/**
+ * Checks whether a tool has at least one generated synarcx command file.
+ */
+export function toolHasAnyConfiguredCommand(projectPath, toolId) {
+    const adapter = CommandAdapterRegistry.get(toolId);
+    if (!adapter)
+        return false;
+    for (const commandId of COMMAND_IDS) {
+        const cmdPath = adapter.getFilePath(commandId);
+        const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+        if (fs.existsSync(fullPath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Returns tools with at least one generated command file on disk.
+ */
+export function getCommandConfiguredTools(projectPath) {
+    return AI_TOOLS
+        .filter((tool) => {
+        if (!tool.skillsDir)
+            return false;
+        const toolDir = path.join(projectPath, tool.skillsDir);
+        try {
+            return fs.statSync(toolDir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map((tool) => tool.value)
+        .filter((toolId) => toolHasAnyConfiguredCommand(projectPath, toolId));
+}
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export function getConfiguredToolsForProfileSync(projectPath) {
+    const skillConfigured = getConfiguredTools(projectPath);
+    const commandConfigured = getCommandConfiguredTools(projectPath);
+    return [...new Set([...skillConfigured, ...commandConfigured])];
+}
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool?.skillsDir)
+        return false;
+    const knownDesiredWorkflows = toKnownWorkflows(desiredWorkflows);
+    const desiredWorkflowSet = new Set(knownDesiredWorkflows);
+    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    const adapter = CommandAdapterRegistry.get(toolId);
+    const shouldGenerateSkills = delivery !== 'commands';
+    const shouldGenerateCommands = delivery !== 'skills';
+    if (shouldGenerateSkills) {
+        for (const workflow of knownDesiredWorkflows) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (!fs.existsSync(skillFile)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (fs.existsSync(skillDir)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (fs.existsSync(skillDir)) {
+                return true;
+            }
+        }
+    }
+    if (shouldGenerateCommands && adapter) {
+        for (const workflow of knownDesiredWorkflows) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (!fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+    }
+    else if (!shouldGenerateCommands && adapter) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (fs.existsSync(fullPath)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools) {
+    const tools = configuredTools ? [...new Set(configuredTools)] : getConfiguredToolsForProfileSync(projectPath);
+    return tools.filter((toolId) => hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery));
+}
+function getInstalledWorkflowsForTool(projectPath, toolId, options) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool?.skillsDir)
+        return [];
+    const installed = new Set();
+    const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+    if (options.includeSkills) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflow);
+            }
+        }
+    }
+    if (options.includeCommands) {
+        const adapter = CommandAdapterRegistry.get(toolId);
+        if (adapter) {
+            for (const workflow of ALL_WORKFLOWS) {
+                const cmdPath = adapter.getFilePath(workflow);
+                const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+                if (fs.existsSync(fullPath)) {
+                    installed.add(workflow);
+                }
+            }
+        }
+    }
+    return [...installed];
+}
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export function hasProjectConfigDrift(projectPath, desiredWorkflows, delivery) {
+    const configuredTools = getConfiguredToolsForProfileSync(projectPath);
+    if (getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools).length > 0) {
+        return true;
+    }
+    const desiredSet = new Set(toKnownWorkflows(desiredWorkflows));
+    const includeSkills = delivery !== 'commands';
+    const includeCommands = delivery !== 'skills';
+    for (const toolId of configuredTools) {
+        const installed = getInstalledWorkflowsForTool(projectPath, toolId, { includeSkills, includeCommands });
+        if (installed.some((workflow) => !desiredSet.has(workflow))) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=profile-sync-drift.js.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Profile System
+ *
+ * Defines workflow profiles that control which workflows are installed.
+ * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
+ */
+import type { Profile } from './global-config.js';
+/**
+ * Core workflows included in the 'core' profile.
+ * These provide the streamlined experience for new users.
+ */
+export declare const CORE_WORKFLOWS: readonly ["explore", "propose", "clarify", "analyze", "apply", "debug", "archive", "sync"];
+/**
+ * All available workflows in the system.
+ */
+export declare const ALL_WORKFLOWS: readonly ["explore", "propose", "clarify", "analyze", "apply", "debug", "archive", "sync"];
+export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
+/**
+ * Resolves which workflows should be active for a given profile configuration.
+ *
+ * - 'core' profile always returns CORE_WORKFLOWS
+ * - 'custom' profile returns the provided customWorkflows, or empty array if not provided
+ */
+export declare function getProfileWorkflows(profile: Profile, customWorkflows?: string[]): readonly string[];
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/profiles.js

@@ -0,0 +1,37 @@
+/**
+ * Profile System
+ *
+ * Defines workflow profiles that control which workflows are installed.
+ * Profiles determine WHICH workflows; delivery (in global config) determines HOW.
+ */
+/**
+ * Core workflows included in the 'core' profile.
+ * These provide the streamlined experience for new users.
+ */
+export const CORE_WORKFLOWS = ['explore', 'propose', 'clarify', 'analyze', 'apply', 'debug', 'archive', 'sync'];
+/**
+ * All available workflows in the system.
+ */
+export const ALL_WORKFLOWS = [
+    'explore',
+    'propose',
+    'clarify',
+    'analyze',
+    'apply',
+    'debug',
+    'archive',
+    'sync',
+];
+/**
+ * Resolves which workflows should be active for a given profile configuration.
+ *
+ * - 'core' profile always returns CORE_WORKFLOWS
+ * - 'custom' profile returns the provided customWorkflows, or empty array if not provided
+ */
+export function getProfileWorkflows(profile, customWorkflows) {
+    if (profile === 'custom') {
+        return customWorkflows ?? [];
+    }
+    return CORE_WORKFLOWS;
+}
+//# sourceMappingURL=profiles.js.map

package/dist/core/project-config.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+/**
+ * Zod schema for project configuration.
+ *
+ * Purpose:
+ * 1. Documentation - clearly defines the config file structure
+ * 2. Type safety - TypeScript infers ProjectConfig type from schema
+ * 3. Runtime validation - uses safeParse() for resilient field-by-field validation
+ *
+ * Why Zod over manual validation:
+ * - Helps understand synarcx's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other synarcx schemas
+ */
+export declare const ProjectConfigSchema: z.ZodObject<{
+    schema: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+/**
+ * Read and parse synspec/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).
+ *
+ * Performance note (Jan 2025):
+ * Benchmarks showed direct file reads are fast enough without caching:
+ * - Typical config (1KB): ~0.5ms per read
+ * - Large config (50KB): ~1.6ms per read
+ * - Missing config: ~0.01ms per read
+ * Config is read 1-2 times per command (schema resolution + instruction loading),
+ * adding ~1-3ms total overhead. Caching would add complexity (mtime checks,
+ * 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 `synspec/` lives)
+ * @returns Parsed config or null if file doesn't exist
+ */
+export declare function readProjectConfig(projectRoot: string): ProjectConfig | null;
+/**
+ * Validate artifact IDs in rules against a schema's artifacts.
+ * Called during instruction loading (when schema is known).
+ * Returns warnings for unknown artifact IDs.
+ *
+ * @param rules - The rules object from config
+ * @param validArtifactIds - Set of valid artifact IDs from the schema
+ * @param schemaName - Name of the schema for error messages
+ * @returns Array of warning messages for unknown artifact IDs
+ */
+export declare function validateConfigRules(rules: Record<string, string[]>, validArtifactIds: Set<string>, schemaName: string): string[];
+/**
+ * Suggest valid schema names when user provides invalid schema.
+ * Uses fuzzy matching to find similar names.
+ *
+ * @param invalidSchemaName - The invalid schema name from config
+ * @param availableSchemas - List of available schemas with their type (built-in or project-local)
+ * @returns Error message with suggestions and available schemas
+ */
+export declare function suggestSchemas(invalidSchemaName: string, availableSchemas: {
+    name: string;
+    isBuiltIn: boolean;
+}[]): string;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/core/project-config.js

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
+import { z } from 'zod';
+import { SYNSPEC_DIR_NAME } from './config.js';
+/**
+ * Zod schema for project configuration.
+ *
+ * Purpose:
+ * 1. Documentation - clearly defines the config file structure
+ * 2. Type safety - TypeScript infers ProjectConfig type from schema
+ * 3. Runtime validation - uses safeParse() for resilient field-by-field validation
+ *
+ * Why Zod over manual validation:
+ * - Helps understand synarcx's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other synarcx schemas
+ */
+export const ProjectConfigSchema = z.object({
+    // Required: which schema to use (e.g., "synarcx", or project-local schema name)
+    schema: z
+        .string()
+        .min(1)
+        .describe('The workflow schema to use (e.g., "synarcx")'),
+    // Optional: project context (injected into all artifact instructions)
+    // Max size: 50KB (enforced during parsing)
+    context: z
+        .string()
+        .optional()
+        .describe('Project context injected into all artifact instructions'),
+    // Optional: per-artifact rules (additive to schema's built-in guidance)
+    rules: z
+        .record(z.string(), // artifact ID
+    z.array(z.string()) // list of rules
+    )
+        .optional()
+        .describe('Per-artifact rules, keyed by artifact ID'),
+});
+const MAX_CONTEXT_SIZE = 50 * 1024; // 50KB hard limit
+/**
+ * Read and parse synspec/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).
+ *
+ * Performance note (Jan 2025):
+ * Benchmarks showed direct file reads are fast enough without caching:
+ * - Typical config (1KB): ~0.5ms per read
+ * - Large config (50KB): ~1.6ms per read
+ * - Missing config: ~0.01ms per read
+ * Config is read 1-2 times per command (schema resolution + instruction loading),
+ * adding ~1-3ms total overhead. Caching would add complexity (mtime checks,
+ * 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 `synspec/` lives)
+ * @returns Parsed config or null if file doesn't exist
+ */
+export function readProjectConfig(projectRoot) {
+    // Try both .yaml and .yml, prefer .yaml
+    let configPath = path.join(projectRoot, SYNSPEC_DIR_NAME, 'config.yaml');
+    if (!existsSync(configPath)) {
+        configPath = path.join(projectRoot, SYNSPEC_DIR_NAME, 'config.yml');
+        if (!existsSync(configPath)) {
+            return null; // No config is OK
+        }
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const raw = parseYaml(content);
+        if (!raw || typeof raw !== 'object') {
+            console.warn(`synspec/config.yaml is not a valid YAML object`);
+            return null;
+        }
+        const config = {};
+        // Parse schema field using Zod
+        const schemaField = z.string().min(1);
+        const schemaResult = schemaField.safeParse(raw.schema);
+        if (schemaResult.success) {
+            config.schema = schemaResult.data;
+        }
+        else if (raw.schema !== undefined) {
+            console.warn(`Invalid 'schema' field in config (must be non-empty string)`);
+        }
+        // Parse context field with size limit
+        if (raw.context !== undefined) {
+            const contextField = z.string();
+            const contextResult = contextField.safeParse(raw.context);
+            if (contextResult.success) {
+                const contextSize = Buffer.byteLength(contextResult.data, 'utf-8');
+                if (contextSize > MAX_CONTEXT_SIZE) {
+                    console.warn(`Context too large (${(contextSize / 1024).toFixed(1)}KB, limit: ${MAX_CONTEXT_SIZE / 1024}KB)`);
+                    console.warn(`Ignoring context field`);
+                }
+                else {
+                    config.context = contextResult.data;
+                }
+            }
+            else {
+                console.warn(`Invalid 'context' field in config (must be string)`);
+            }
+        }
+        // Parse rules field using Zod
+        if (raw.rules !== undefined) {
+            const rulesField = z.record(z.string(), z.array(z.string()));
+            // First check if it's an object structure (guard against null since typeof null === 'object')
+            if (typeof raw.rules === 'object' && raw.rules !== null && !Array.isArray(raw.rules)) {
+                const parsedRules = {};
+                let hasValidRules = false;
+                for (const [artifactId, rules] of Object.entries(raw.rules)) {
+                    const rulesArrayResult = z.array(z.string()).safeParse(rules);
+                    if (rulesArrayResult.success) {
+                        // Filter out empty strings
+                        const validRules = rulesArrayResult.data.filter((r) => r.length > 0);
+                        if (validRules.length > 0) {
+                            parsedRules[artifactId] = validRules;
+                            hasValidRules = true;
+                        }
+                        if (validRules.length < rulesArrayResult.data.length) {
+                            console.warn(`Some rules for '${artifactId}' are empty strings, ignoring them`);
+                        }
+                    }
+                    else {
+                        console.warn(`Rules for '${artifactId}' must be an array of strings, ignoring this artifact's rules`);
+                    }
+                }
+                if (hasValidRules) {
+                    config.rules = parsedRules;
+                }
+            }
+            else {
+                console.warn(`Invalid 'rules' field in config (must be object)`);
+            }
+        }
+        // Return partial config even if some fields failed
+        return Object.keys(config).length > 0 ? config : null;
+    }
+    catch (error) {
+        console.warn(`Failed to parse synspec/config.yaml:`, error);
+        return null;
+    }
+}
+/**
+ * Validate artifact IDs in rules against a schema's artifacts.
+ * Called during instruction loading (when schema is known).
+ * Returns warnings for unknown artifact IDs.
+ *
+ * @param rules - The rules object from config
+ * @param validArtifactIds - Set of valid artifact IDs from the schema
+ * @param schemaName - Name of the schema for error messages
+ * @returns Array of warning messages for unknown artifact IDs
+ */
+export function validateConfigRules(rules, validArtifactIds, schemaName) {
+    const warnings = [];
+    for (const artifactId of Object.keys(rules)) {
+        if (!validArtifactIds.has(artifactId)) {
+            const validIds = Array.from(validArtifactIds).sort().join(', ');
+            warnings.push(`Unknown artifact ID in rules: "${artifactId}". ` +
+                `Valid IDs for schema "${schemaName}": ${validIds}`);
+        }
+    }
+    return warnings;
+}
+/**
+ * Suggest valid schema names when user provides invalid schema.
+ * Uses fuzzy matching to find similar names.
+ *
+ * @param invalidSchemaName - The invalid schema name from config
+ * @param availableSchemas - List of available schemas with their type (built-in or project-local)
+ * @returns Error message with suggestions and available schemas
+ */
+export function suggestSchemas(invalidSchemaName, availableSchemas) {
+    // Simple fuzzy match: Levenshtein distance
+    function levenshtein(a, b) {
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    // Find closest matches (distance <= 3)
+    const suggestions = availableSchemas
+        .map((s) => ({ ...s, distance: levenshtein(invalidSchemaName, s.name) }))
+        .filter((s) => s.distance <= 3)
+        .sort((a, b) => a.distance - b.distance)
+        .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 synspec/config.yaml\n\n`;
+    if (suggestions.length > 0) {
+        message += `Did you mean one of these?\n`;
+        suggestions.forEach((s) => {
+            const type = s.isBuiltIn ? 'built-in' : 'project-local';
+            message += `  - ${s.name} (${type})\n`;
+        });
+        message += '\n';
+    }
+    message += `Available schemas:\n`;
+    if (builtIn.length > 0) {
+        message += `  Built-in: ${builtIn.join(', ')}\n`;
+    }
+    if (projectLocal.length > 0) {
+        message += `  Project-local: ${projectLocal.join(', ')}\n`;
+    }
+    else {
+        message += `  Project-local: (none found)\n`;
+    }
+    message += `\nFix: Edit synspec/config.yaml and change 'schema: ${invalidSchemaName}' to a valid schema name`;
+    return message;
+}
+//# sourceMappingURL=project-config.js.map

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const ScenarioSchema: z.ZodObject<{
+    rawText: z.ZodString;
+}, z.core.$strip>;
+export declare const RequirementSchema: z.ZodObject<{
+    text: z.ZodString;
+    scenarios: z.ZodArray<z.ZodObject<{
+        rawText: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Scenario = z.infer<typeof ScenarioSchema>;
+export type Requirement = z.infer<typeof RequirementSchema>;
+//# sourceMappingURL=base.schema.d.ts.map

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { VALIDATION_MESSAGES } from '../validation/constants.js';
+export const ScenarioSchema = z.object({
+    rawText: z.string().min(1, VALIDATION_MESSAGES.SCENARIO_EMPTY),
+});
+export const RequirementSchema = z.object({
+    text: z.string()
+        .min(1, VALIDATION_MESSAGES.REQUIREMENT_EMPTY)
+        .refine((text) => text.includes('SHALL') || text.includes('MUST'), VALIDATION_MESSAGES.REQUIREMENT_NO_SHALL),
+    scenarios: z.array(ScenarioSchema)
+        .min(1, VALIDATION_MESSAGES.REQUIREMENT_NO_SCENARIOS),
+});
+//# sourceMappingURL=base.schema.js.map

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export declare const DeltaOperationType: z.ZodEnum<{
+    ADDED: "ADDED";
+    MODIFIED: "MODIFIED";
+    REMOVED: "REMOVED";
+    RENAMED: "RENAMED";
+}>;
+export declare const DeltaSchema: z.ZodObject<{
+    spec: z.ZodString;
+    operation: z.ZodEnum<{
+        ADDED: "ADDED";
+        MODIFIED: "MODIFIED";
+        REMOVED: "REMOVED";
+        RENAMED: "RENAMED";
+    }>;
+    description: z.ZodString;
+    requirement: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    rename: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ChangeSchema: z.ZodObject<{
+    name: z.ZodString;
+    why: z.ZodString;
+    whatChanges: z.ZodString;
+    deltas: z.ZodArray<z.ZodObject<{
+        spec: z.ZodString;
+        operation: z.ZodEnum<{
+            ADDED: "ADDED";
+            MODIFIED: "MODIFIED";
+            REMOVED: "REMOVED";
+            RENAMED: "RENAMED";
+        }>;
+        description: z.ZodString;
+        requirement: z.ZodOptional<z.ZodObject<{
+            text: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                rawText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        requirements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            scenarios: z.ZodArray<z.ZodObject<{
+                rawText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        rename: z.ZodOptional<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        format: z.ZodLiteral<"synarcx-change">;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DeltaOperation = z.infer<typeof DeltaOperationType>;
+export type Delta = z.infer<typeof DeltaSchema>;
+export type Change = z.infer<typeof ChangeSchema>;
+//# sourceMappingURL=change.schema.d.ts.map

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { RequirementSchema } from './base.schema.js';
+import { MIN_WHY_SECTION_LENGTH, MAX_WHY_SECTION_LENGTH, MAX_DELTAS_PER_CHANGE, VALIDATION_MESSAGES } from '../validation/constants.js';
+export const DeltaOperationType = z.enum(['ADDED', 'MODIFIED', 'REMOVED', 'RENAMED']);
+export const DeltaSchema = z.object({
+    spec: z.string().min(1, VALIDATION_MESSAGES.DELTA_SPEC_EMPTY),
+    operation: DeltaOperationType,
+    description: z.string().min(1, VALIDATION_MESSAGES.DELTA_DESCRIPTION_EMPTY),
+    requirement: RequirementSchema.optional(),
+    requirements: z.array(RequirementSchema).optional(),
+    rename: z.object({
+        from: z.string(),
+        to: z.string(),
+    }).optional(),
+});
+export const ChangeSchema = z.object({
+    name: z.string().min(1, VALIDATION_MESSAGES.CHANGE_NAME_EMPTY),
+    why: z.string()
+        .min(MIN_WHY_SECTION_LENGTH, VALIDATION_MESSAGES.CHANGE_WHY_TOO_SHORT)
+        .max(MAX_WHY_SECTION_LENGTH, VALIDATION_MESSAGES.CHANGE_WHY_TOO_LONG),
+    whatChanges: z.string().min(1, VALIDATION_MESSAGES.CHANGE_WHAT_EMPTY),
+    deltas: z.array(DeltaSchema)
+        .min(1, VALIDATION_MESSAGES.CHANGE_NO_DELTAS)
+        .max(MAX_DELTAS_PER_CHANGE, VALIDATION_MESSAGES.CHANGE_TOO_MANY_DELTAS),
+    metadata: z.object({
+        version: z.string().default('1.0.0'),
+        format: z.literal('synarcx-change'),
+        sourcePath: z.string().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=change.schema.js.map