openspec-cn 0.23.0

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", "tdd", or project-local schema name)
+    schema: z
+        .string()
+        .min(1)
+        .describe('The workflow schema to use (e.g., "spec-driven", "tdd")'),
+    // 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

package/dist/core/shared/index.js

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

package/dist/core/shared/skill-generation.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Skill Generation Utilities
+ *
+ * Shared utilities for generating skill and command files.
+ */
+import { getOpsxExploreCommandTemplate, type SkillTemplate } from '../templates/skill-templates.js';
+import type { CommandContent } from '../command-generation/index.js';
+/**
+ * Skill template with directory name mapping.
+ */
+export interface SkillTemplateEntry {
+    template: SkillTemplate;
+    dirName: string;
+}
+/**
+ * Command template with ID mapping.
+ */
+export interface CommandTemplateEntry {
+    template: ReturnType<typeof getOpsxExploreCommandTemplate>;
+    id: string;
+}
+/**
+ * Gets all skill templates with their directory names.
+ */
+export declare function getSkillTemplates(): SkillTemplateEntry[];
+/**
+ * Gets all command templates with their IDs.
+ */
+export declare function getCommandTemplates(): CommandTemplateEntry[];
+/**
+ * Converts command templates to CommandContent array.
+ */
+export declare function getCommandContents(): CommandContent[];
+/**
+ * Generates skill file content with YAML frontmatter.
+ *
+ * @param template - The skill template
+ * @param generatedByVersion - The OpenSpec version to embed in the file
+ */
+export declare function generateSkillContent(template: SkillTemplate, generatedByVersion: string): string;
+//# sourceMappingURL=skill-generation.d.ts.map

package/dist/core/shared/skill-generation.js

@@ -0,0 +1,74 @@
+/**
+ * Skill Generation Utilities
+ *
+ * Shared utilities for generating skill and command files.
+ */
+import { getExploreSkillTemplate, getNewChangeSkillTemplate, getContinueChangeSkillTemplate, getApplyChangeSkillTemplate, getFfChangeSkillTemplate, getSyncSpecsSkillTemplate, getArchiveChangeSkillTemplate, getBulkArchiveChangeSkillTemplate, getVerifyChangeSkillTemplate, getOpsxExploreCommandTemplate, getOpsxNewCommandTemplate, getOpsxContinueCommandTemplate, getOpsxApplyCommandTemplate, getOpsxFfCommandTemplate, getOpsxSyncCommandTemplate, getOpsxArchiveCommandTemplate, getOpsxBulkArchiveCommandTemplate, getOpsxVerifyCommandTemplate, } from '../templates/skill-templates.js';
+/**
+ * Gets all skill templates with their directory names.
+ */
+export function getSkillTemplates() {
+    return [
+        { template: getExploreSkillTemplate(), dirName: 'openspec-explore' },
+        { template: getNewChangeSkillTemplate(), dirName: 'openspec-new-change' },
+        { template: getContinueChangeSkillTemplate(), dirName: 'openspec-continue-change' },
+        { template: getApplyChangeSkillTemplate(), dirName: 'openspec-apply-change' },
+        { template: getFfChangeSkillTemplate(), dirName: 'openspec-ff-change' },
+        { template: getSyncSpecsSkillTemplate(), dirName: 'openspec-sync-specs' },
+        { template: getArchiveChangeSkillTemplate(), dirName: 'openspec-archive-change' },
+        { template: getBulkArchiveChangeSkillTemplate(), dirName: 'openspec-bulk-archive-change' },
+        { template: getVerifyChangeSkillTemplate(), dirName: 'openspec-verify-change' },
+    ];
+}
+/**
+ * Gets all command templates with their IDs.
+ */
+export function getCommandTemplates() {
+    return [
+        { template: getOpsxExploreCommandTemplate(), id: 'explore' },
+        { template: getOpsxNewCommandTemplate(), id: 'new' },
+        { template: getOpsxContinueCommandTemplate(), id: 'continue' },
+        { template: getOpsxApplyCommandTemplate(), id: 'apply' },
+        { template: getOpsxFfCommandTemplate(), id: 'ff' },
+        { template: getOpsxSyncCommandTemplate(), id: 'sync' },
+        { template: getOpsxArchiveCommandTemplate(), id: 'archive' },
+        { template: getOpsxBulkArchiveCommandTemplate(), id: 'bulk-archive' },
+        { template: getOpsxVerifyCommandTemplate(), id: 'verify' },
+    ];
+}
+/**
+ * Converts command templates to CommandContent array.
+ */
+export function getCommandContents() {
+    const commandTemplates = getCommandTemplates();
+    return commandTemplates.map(({ template, id }) => ({
+        id,
+        name: template.name,
+        description: template.description,
+        category: template.category,
+        tags: template.tags,
+        body: template.content,
+    }));
+}
+/**
+ * Generates skill file content with YAML frontmatter.
+ *
+ * @param template - The skill template
+ * @param generatedByVersion - The OpenSpec version to embed in the file
+ */
+export function generateSkillContent(template, generatedByVersion) {
+    return `---
+name: ${template.name}
+description: ${template.description}
+license: ${template.license || 'MIT'}
+compatibility: ${template.compatibility || 'Requires openspec CLI.'}
+metadata:
+  author: ${template.metadata?.author || 'openspec'}
+  version: "${template.metadata?.version || '1.0'}"
+  generatedBy: "${generatedByVersion}"
+---
+
+${template.instructions}
+`;
+}
+//# sourceMappingURL=skill-generation.js.map

package/dist/core/shared/tool-detection.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Tool Detection Utilities
+ *
+ * Shared utilities for detecting tool configurations and version status.
+ */
+/**
+ * Names of skill directories created by openspec init.
+ */
+export declare const SKILL_NAMES: readonly ["openspec-explore", "openspec-new-change", "openspec-continue-change", "openspec-apply-change", "openspec-ff-change", "openspec-sync-specs", "openspec-archive-change", "openspec-bulk-archive-change", "openspec-verify-change"];
+export type SkillName = (typeof SKILL_NAMES)[number];
+/**
+ * Status of skill configuration for a tool.
+ */
+export interface ToolSkillStatus {
+    /** Whether the tool has any skills configured */
+    configured: boolean;
+    /** Whether all 9 skills are configured */
+    fullyConfigured: boolean;
+    /** Number of skills currently configured (0-9) */
+    skillCount: number;
+}
+/**
+ * Version information for a tool's skills.
+ */
+export interface ToolVersionStatus {
+    /** The tool ID */
+    toolId: string;
+    /** The tool's display name */
+    toolName: string;
+    /** Whether the tool has any skills configured */
+    configured: boolean;
+    /** The generatedBy version found in the skill files, or null if not found */
+    generatedByVersion: string | null;
+    /** Whether the tool needs updating (version mismatch or missing) */
+    needsUpdate: boolean;
+}
+/**
+ * Gets the list of tools with skillsDir configured.
+ */
+export declare function getToolsWithSkillsDir(): string[];
+/**
+ * Checks which skill files exist for a tool.
+ */
+export declare function getToolSkillStatus(projectRoot: string, toolId: string): ToolSkillStatus;
+/**
+ * Gets the skill status for all tools with skillsDir configured.
+ */
+export declare function getToolStates(projectRoot: string): Map<string, ToolSkillStatus>;
+/**
+ * Extracts the generatedBy version from a skill file's YAML frontmatter.
+ * Returns null if the field is not found or the file doesn't exist.
+ */
+export declare function extractGeneratedByVersion(skillFilePath: string): string | null;
+/**
+ * Gets version status for a tool by reading the first available skill file.
+ */
+export declare function getToolVersionStatus(projectRoot: string, toolId: string, currentVersion: string): ToolVersionStatus;
+/**
+ * Gets all configured tools in the project.
+ */
+export declare function getConfiguredTools(projectRoot: string): string[];
+/**
+ * Gets version status for all configured tools.
+ */
+export declare function getAllToolVersionStatus(projectRoot: string, currentVersion: string): ToolVersionStatus[];
+//# sourceMappingURL=tool-detection.d.ts.map