@bobby_z/openspec 0.0.1

package/dist/core/parsers/requirement-blocks.js

@@ -0,0 +1,201 @@
+export function normalizeRequirementName(name) {
+    return name.trim();
+}
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const reqHeaderIndex = lines.findIndex(l => /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        // No requirements section; create an empty one at the end
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    // Find end of this section: next line that starts with '## ' at same or higher level
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    // Parse requirement blocks within section body
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    // Collect preamble lines until first requirement header
+    while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor])) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerStart = cursor;
+        const headerLineCandidate = sectionBodyLines[cursor];
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        if (!headerMatch) {
+            // Not a requirement header; skip line defensively
+            cursor++;
+            continue;
+        }
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        // Gather lines until next requirement header or end of section
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length && !/^###\s+Requirement:/.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const sections = splitTopLevelSections(normalized);
+    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const added = parseRequirementBlocksFromSection(addedLookup.body);
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body);
+    const removedNames = parseRemovedNames(removedLookup.body);
+    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}
+function splitTopLevelSections(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            const level = m[1].length; // only care for '##'
+            indices.push({ title: m[2].trim(), index: i, level });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const body = lines.slice(current.index + 1, next ? next.index : lines.length).join('\n');
+        result[current.title] = body;
+    }
+    return result;
+}
+function getSectionCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    for (const [title, body] of Object.entries(sections)) {
+        if (title.toLowerCase() === target)
+            return { body, found: true };
+    }
+    return { body: '', found: false };
+}
+function parseRequirementBlocksFromSection(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Seek next requirement header
+        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]))
+            i++;
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length && !/^###\s+Requirement:/.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    return blocks;
+}
+function parseRemovedNames(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const names = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    for (const line of lines) {
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        // Also support bullet list of headers
+        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+function parseRenamedPairs(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const pairs = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    let current = {};
+    for (const line of lines) {
+        const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (fromMatch) {
+            current.from = normalizeRequirementName(fromMatch[1]);
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    return pairs;
+}
+//# sourceMappingURL=requirement-blocks.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 OpenSpec's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other OpenSpec 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 openspec/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 `openspec/` 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,223 @@
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { parse as parseYaml } from 'yaml';
+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 OpenSpec's data interfaces at a glance
+ * - Single source of truth for type and validation
+ * - Consistent with other OpenSpec schemas
+ */
+export const ProjectConfigSchema = z.object({
+    // Required: which schema to use (e.g., "spec-driven", or project-local schema name)
+    schema: z
+        .string()
+        .min(1)
+        .describe('The workflow schema to use (e.g., "spec-driven")'),
+    // 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 openspec/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 `openspec/` 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, 'openspec', 'config.yaml');
+    if (!existsSync(configPath)) {
+        configPath = path.join(projectRoot, 'openspec', '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(`openspec/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 openspec/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 openspec/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 openspec/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<"openspec-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('openspec-change'),
+        sourcePath: z.string().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=change.schema.js.map

package/dist/core/schemas/index.d.ts

@@ -0,0 +1,4 @@
+export { ScenarioSchema, RequirementSchema, type Scenario, type Requirement, } from './base.schema.js';
+export { SpecSchema, type Spec, } from './spec.schema.js';
+export { DeltaOperationType, DeltaSchema, ChangeSchema, type DeltaOperation, type Delta, type Change, } from './change.schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/schemas/index.js

@@ -0,0 +1,4 @@
+export { ScenarioSchema, RequirementSchema, } from './base.schema.js';
+export { SpecSchema, } from './spec.schema.js';
+export { DeltaOperationType, DeltaSchema, ChangeSchema, } from './change.schema.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const SpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    overview: z.ZodString;
+    requirements: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        scenarios: z.ZodArray<z.ZodObject<{
+            rawText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodDefault<z.ZodString>;
+        format: z.ZodLiteral<"openspec">;
+        sourcePath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Spec = z.infer<typeof SpecSchema>;
+//# sourceMappingURL=spec.schema.d.ts.map

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { RequirementSchema } from './base.schema.js';
+import { VALIDATION_MESSAGES } from '../validation/constants.js';
+export const SpecSchema = z.object({
+    name: z.string().min(1, VALIDATION_MESSAGES.SPEC_NAME_EMPTY),
+    overview: z.string().min(1, VALIDATION_MESSAGES.SPEC_PURPOSE_EMPTY),
+    requirements: z.array(RequirementSchema)
+        .min(1, VALIDATION_MESSAGES.SPEC_NO_REQUIREMENTS),
+    metadata: z.object({
+        version: z.string().default('1.0.0'),
+        format: z.literal('openspec'),
+        sourcePath: z.string().optional(),
+    }).optional(),
+});
+//# sourceMappingURL=spec.schema.js.map

package/dist/core/shared/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared Utilities
+ *
+ * Common code shared between init and update commands.
+ */
+export { SKILL_NAMES, type SkillName, type ToolSkillStatus, type ToolVersionStatus, getToolsWithSkillsDir, getToolSkillStatus, getToolStates, extractGeneratedByVersion, getToolVersionStatus, getConfiguredTools, getAllToolVersionStatus, } from './tool-detection.js';
+export { type SkillTemplateEntry, type CommandTemplateEntry, getSkillTemplates, getCommandTemplates, getCommandContents, generateSkillContent, } from './skill-generation.js';
+//# sourceMappingURL=index.d.ts.map