openspec-cn 0.23.0

package/dist/core/artifact-graph/schema.d.ts

@@ -0,0 +1,13 @@
+import { type SchemaYaml } from './types.js';
+export declare class SchemaValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Loads and validates an artifact schema from a YAML file.
+ */
+export declare function loadSchema(filePath: string): SchemaYaml;
+/**
+ * Parses and validates an artifact schema from YAML content.
+ */
+export declare function parseSchema(yamlContent: string): SchemaYaml;
+//# sourceMappingURL=schema.d.ts.map

package/dist/core/artifact-graph/schema.js

@@ -0,0 +1,108 @@
+import * as fs from 'node:fs';
+import { parse as parseYaml } from 'yaml';
+import { SchemaYamlSchema } from './types.js';
+export class SchemaValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SchemaValidationError';
+    }
+}
+/**
+ * Loads and validates an artifact schema from a YAML file.
+ */
+export function loadSchema(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseSchema(content);
+}
+/**
+ * Parses and validates an artifact schema from YAML content.
+ */
+export function parseSchema(yamlContent) {
+    const parsed = parseYaml(yamlContent);
+    // Validate with Zod
+    const result = SchemaYamlSchema.safeParse(parsed);
+    if (!result.success) {
+        const errors = result.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ');
+        throw new SchemaValidationError(`Invalid schema: ${errors}`);
+    }
+    const schema = result.data;
+    // Check for duplicate artifact IDs
+    validateNoDuplicateIds(schema.artifacts);
+    // Check that all requires references are valid
+    validateRequiresReferences(schema.artifacts);
+    // Check for cycles
+    validateNoCycles(schema.artifacts);
+    return schema;
+}
+/**
+ * Validates that there are no duplicate artifact IDs.
+ */
+function validateNoDuplicateIds(artifacts) {
+    const seen = new Set();
+    for (const artifact of artifacts) {
+        if (seen.has(artifact.id)) {
+            throw new SchemaValidationError(`Duplicate artifact ID: ${artifact.id}`);
+        }
+        seen.add(artifact.id);
+    }
+}
+/**
+ * Validates that all `requires` references point to valid artifact IDs.
+ */
+function validateRequiresReferences(artifacts) {
+    const validIds = new Set(artifacts.map(a => a.id));
+    for (const artifact of artifacts) {
+        for (const req of artifact.requires) {
+            if (!validIds.has(req)) {
+                throw new SchemaValidationError(`Invalid dependency reference in artifact '${artifact.id}': '${req}' does not exist`);
+            }
+        }
+    }
+}
+/**
+ * Validates that there are no cyclic dependencies.
+ * Uses DFS to detect cycles and reports the full cycle path.
+ */
+function validateNoCycles(artifacts) {
+    const artifactMap = new Map(artifacts.map(a => [a.id, a]));
+    const visited = new Set();
+    const inStack = new Set();
+    const parent = new Map();
+    function dfs(id) {
+        visited.add(id);
+        inStack.add(id);
+        const artifact = artifactMap.get(id);
+        if (!artifact)
+            return null;
+        for (const dep of artifact.requires) {
+            if (!visited.has(dep)) {
+                parent.set(dep, id);
+                const cycle = dfs(dep);
+                if (cycle)
+                    return cycle;
+            }
+            else if (inStack.has(dep)) {
+                // Found a cycle - reconstruct the path
+                const cyclePath = [dep];
+                let current = id;
+                while (current !== dep) {
+                    cyclePath.unshift(current);
+                    current = parent.get(current);
+                }
+                cyclePath.unshift(dep);
+                return cyclePath.join(' → ');
+            }
+        }
+        inStack.delete(id);
+        return null;
+    }
+    for (const artifact of artifacts) {
+        if (!visited.has(artifact.id)) {
+            const cycle = dfs(artifact.id);
+            if (cycle) {
+                throw new SchemaValidationError(`Cyclic dependency detected: ${cycle}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=schema.js.map

package/dist/core/artifact-graph/state.d.ts

@@ -0,0 +1,12 @@
+import type { CompletedSet } from './types.js';
+import type { ArtifactGraph } from './graph.js';
+/**
+ * Detects which artifacts are completed by checking file existence in the change directory.
+ * Returns a Set of completed artifact IDs.
+ *
+ * @param graph - The artifact graph to check
+ * @param changeDir - The change directory to scan for files
+ * @returns Set of artifact IDs whose generated files exist
+ */
+export declare function detectCompleted(graph: ArtifactGraph, changeDir: string): CompletedSet;
+//# sourceMappingURL=state.d.ts.map

package/dist/core/artifact-graph/state.js

@@ -0,0 +1,54 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import fg from 'fast-glob';
+import { FileSystemUtils } from '../../utils/file-system.js';
+/**
+ * Detects which artifacts are completed by checking file existence in the change directory.
+ * Returns a Set of completed artifact IDs.
+ *
+ * @param graph - The artifact graph to check
+ * @param changeDir - The change directory to scan for files
+ * @returns Set of artifact IDs whose generated files exist
+ */
+export function detectCompleted(graph, changeDir) {
+    const completed = new Set();
+    // Handle missing change directory gracefully
+    if (!fs.existsSync(changeDir)) {
+        return completed;
+    }
+    for (const artifact of graph.getAllArtifacts()) {
+        if (isArtifactComplete(artifact.generates, changeDir)) {
+            completed.add(artifact.id);
+        }
+    }
+    return completed;
+}
+/**
+ * Checks if an artifact is complete by checking if its generated file(s) exist.
+ * Supports both simple paths and glob patterns.
+ */
+function isArtifactComplete(generates, changeDir) {
+    const fullPattern = path.join(changeDir, generates);
+    // Check if it's a glob pattern
+    if (isGlobPattern(generates)) {
+        return hasGlobMatches(fullPattern);
+    }
+    // Simple file path - check if file exists
+    return fs.existsSync(fullPattern);
+}
+/**
+ * Checks if a path contains glob pattern characters.
+ */
+function isGlobPattern(pattern) {
+    return pattern.includes('*') || pattern.includes('?') || pattern.includes('[');
+}
+/**
+ * Checks if a glob pattern has any matches.
+ * Normalizes Windows backslashes to forward slashes for cross-platform glob compatibility.
+ */
+function hasGlobMatches(pattern) {
+    const normalizedPattern = FileSystemUtils.toPosixPath(pattern);
+    const matches = fg.sync(normalizedPattern, { onlyFiles: true });
+    return matches.length > 0;
+}
+//# sourceMappingURL=state.js.map

package/dist/core/artifact-graph/types.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const ArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    generates: z.ZodString;
+    description: z.ZodString;
+    template: z.ZodString;
+    instruction: z.ZodOptional<z.ZodString>;
+    requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ApplyPhaseSchema: z.ZodObject<{
+    requires: z.ZodArray<z.ZodString>;
+    tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instruction: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const SchemaYamlSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        generates: z.ZodString;
+        description: z.ZodString;
+        template: z.ZodString;
+        instruction: z.ZodOptional<z.ZodString>;
+        requires: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    apply: z.ZodOptional<z.ZodObject<{
+        requires: z.ZodArray<z.ZodString>;
+        tracks: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        instruction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Artifact = z.infer<typeof ArtifactSchema>;
+export type ApplyPhase = z.infer<typeof ApplyPhaseSchema>;
+export type SchemaYaml = z.infer<typeof SchemaYamlSchema>;
+export declare const ChangeMetadataSchema: z.ZodObject<{
+    schema: z.ZodString;
+    created: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ChangeMetadata = z.infer<typeof ChangeMetadataSchema>;
+export type CompletedSet = Set<string>;
+export interface BlockedArtifacts {
+    [artifactId: string]: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/artifact-graph/types.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+// Artifact definition schema
+export const ArtifactSchema = z.object({
+    id: z.string().min(1, { error: 'Artifact ID is required' }),
+    generates: z.string().min(1, { error: 'generates field is required' }),
+    description: z.string(),
+    template: z.string().min(1, { error: 'template field is required' }),
+    instruction: z.string().optional(),
+    requires: z.array(z.string()).default([]),
+});
+// Apply phase configuration for schema-aware apply instructions
+export const ApplyPhaseSchema = z.object({
+    // Artifact IDs that must exist before apply is available
+    requires: z.array(z.string()).min(1, { error: 'At least one required artifact' }),
+    // Path to file with checkboxes for progress (relative to change dir), or null if no tracking
+    tracks: z.string().nullable().optional(),
+    // Custom guidance for the apply phase
+    instruction: z.string().optional(),
+});
+// Full schema YAML structure
+export const SchemaYamlSchema = z.object({
+    name: z.string().min(1, { error: 'Schema name is required' }),
+    version: z.number().int().positive({ error: 'Version must be a positive integer' }),
+    description: z.string().optional(),
+    artifacts: z.array(ArtifactSchema).min(1, { error: 'At least one artifact required' }),
+    // Optional apply phase configuration (for schema-aware apply instructions)
+    apply: ApplyPhaseSchema.optional(),
+});
+// Per-change metadata schema
+// Note: schema field is validated at parse time against available schemas
+// using a lazy import to avoid circular dependencies
+export const ChangeMetadataSchema = z.object({
+    // Required: which workflow schema this change uses
+    schema: z.string().min(1, { message: 'schema is required' }),
+    // Optional: creation timestamp (ISO date string)
+    created: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, {
+        message: 'created must be YYYY-MM-DD format',
+    })
+        .optional(),
+});
+//# sourceMappingURL=types.js.map

package/dist/core/command-generation/adapters/amazon-q.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Amazon Q Developer Command Adapter
+ *
+ * Formats commands for Amazon Q Developer following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Amazon Q adapter for command generation.
+ * File path: .amazonq/prompts/opsx-<id>.md
+ * Frontmatter: description
+ */
+export declare const amazonQAdapter: ToolCommandAdapter;
+//# sourceMappingURL=amazon-q.d.ts.map

package/dist/core/command-generation/adapters/amazon-q.js

@@ -0,0 +1,26 @@
+/**
+ * Amazon Q Developer Command Adapter
+ *
+ * Formats commands for Amazon Q Developer following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Amazon Q adapter for command generation.
+ * File path: .amazonq/prompts/opsx-<id>.md
+ * Frontmatter: description
+ */
+export const amazonQAdapter = {
+    toolId: 'amazon-q',
+    getFilePath(commandId) {
+        return path.join('.amazonq', 'prompts', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=amazon-q.js.map

package/dist/core/command-generation/adapters/antigravity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Antigravity Command Adapter
+ *
+ * Formats commands for Antigravity following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Antigravity adapter for command generation.
+ * File path: .agent/workflows/opsx-<id>.md
+ * Frontmatter: description
+ */
+export declare const antigravityAdapter: ToolCommandAdapter;
+//# sourceMappingURL=antigravity.d.ts.map

package/dist/core/command-generation/adapters/antigravity.js

@@ -0,0 +1,26 @@
+/**
+ * Antigravity Command Adapter
+ *
+ * Formats commands for Antigravity following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Antigravity adapter for command generation.
+ * File path: .agent/workflows/opsx-<id>.md
+ * Frontmatter: description
+ */
+export const antigravityAdapter = {
+    toolId: 'antigravity',
+    getFilePath(commandId) {
+        return path.join('.agent', 'workflows', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=antigravity.js.map

package/dist/core/command-generation/adapters/auggie.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Auggie (Augment CLI) Command Adapter
+ *
+ * Formats commands for Auggie following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Auggie adapter for command generation.
+ * File path: .augment/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const auggieAdapter: ToolCommandAdapter;
+//# sourceMappingURL=auggie.d.ts.map

package/dist/core/command-generation/adapters/auggie.js

@@ -0,0 +1,27 @@
+/**
+ * Auggie (Augment CLI) Command Adapter
+ *
+ * Formats commands for Auggie following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Auggie adapter for command generation.
+ * File path: .augment/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export const auggieAdapter = {
+    toolId: 'auggie',
+    getFilePath(commandId) {
+        return path.join('.augment', 'commands', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=auggie.js.map

package/dist/core/command-generation/adapters/claude.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export declare const claudeAdapter: ToolCommandAdapter;
+//# sourceMappingURL=claude.d.ts.map

package/dist/core/command-generation/adapters/claude.js

@@ -0,0 +1,50 @@
+/**
+ * Claude Code Command Adapter
+ *
+ * Formats commands for Claude Code following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Escapes a string value for safe YAML output.
+ * Quotes the string if it contains special YAML characters.
+ */
+function escapeYamlValue(value) {
+    // Check if value needs quoting (contains special YAML characters or starts/ends with whitespace)
+    const needsQuoting = /[:\n\r#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value);
+    if (needsQuoting) {
+        // Use double quotes and escape internal double quotes and backslashes
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return `"${escaped}"`;
+    }
+    return value;
+}
+/**
+ * Formats a tags array as a YAML array with proper escaping.
+ */
+function formatTagsArray(tags) {
+    const escapedTags = tags.map((tag) => escapeYamlValue(tag));
+    return `[${escapedTags.join(', ')}]`;
+}
+/**
+ * Claude Code adapter for command generation.
+ * File path: .claude/commands/opsx/<id>.md
+ * Frontmatter: name, description, category, tags
+ */
+export const claudeAdapter = {
+    toolId: 'claude',
+    getFilePath(commandId) {
+        return path.join('.claude', 'commands', 'opsx', `${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${escapeYamlValue(content.name)}
+description: ${escapeYamlValue(content.description)}
+category: ${escapeYamlValue(content.category)}
+tags: ${formatTagsArray(content.tags)}
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=claude.js.map

package/dist/core/command-generation/adapters/cline.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cline Command Adapter
+ *
+ * Formats commands for Cline following its workflow specification.
+ * Cline uses markdown headers instead of YAML frontmatter.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Cline adapter for command generation.
+ * File path: .clinerules/workflows/opsx-<id>.md
+ * Format: Markdown header with description
+ */
+export declare const clineAdapter: ToolCommandAdapter;
+//# sourceMappingURL=cline.d.ts.map

package/dist/core/command-generation/adapters/cline.js

@@ -0,0 +1,27 @@
+/**
+ * Cline Command Adapter
+ *
+ * Formats commands for Cline following its workflow specification.
+ * Cline uses markdown headers instead of YAML frontmatter.
+ */
+import path from 'path';
+/**
+ * Cline adapter for command generation.
+ * File path: .clinerules/workflows/opsx-<id>.md
+ * Format: Markdown header with description
+ */
+export const clineAdapter = {
+    toolId: 'cline',
+    getFilePath(commandId) {
+        return path.join('.clinerules', 'workflows', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `# ${content.name}
+
+${content.description}
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=cline.js.map

package/dist/core/command-generation/adapters/codebuddy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CodeBuddy Command Adapter
+ *
+ * Formats commands for CodeBuddy following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * CodeBuddy adapter for command generation.
+ * File path: .codebuddy/commands/opsx/<id>.md
+ * Frontmatter: name, description, argument-hint
+ */
+export declare const codebuddyAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codebuddy.d.ts.map

package/dist/core/command-generation/adapters/codebuddy.js

@@ -0,0 +1,28 @@
+/**
+ * CodeBuddy Command Adapter
+ *
+ * Formats commands for CodeBuddy following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * CodeBuddy adapter for command generation.
+ * File path: .codebuddy/commands/opsx/<id>.md
+ * Frontmatter: name, description, argument-hint
+ */
+export const codebuddyAdapter = {
+    toolId: 'codebuddy',
+    getFilePath(commandId) {
+        return path.join('.codebuddy', 'commands', 'opsx', `${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+name: ${content.name}
+description: "${content.description}"
+argument-hint: "[command arguments]"
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codebuddy.js.map

package/dist/core/command-generation/adapters/codex.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Codex adapter for command generation.
+ * File path: .codex/prompts/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const codexAdapter: ToolCommandAdapter;
+//# sourceMappingURL=codex.d.ts.map

package/dist/core/command-generation/adapters/codex.js

@@ -0,0 +1,27 @@
+/**
+ * Codex Command Adapter
+ *
+ * Formats commands for Codex following its frontmatter specification.
+ */
+import path from 'path';
+/**
+ * Codex adapter for command generation.
+ * File path: .codex/prompts/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export const codexAdapter = {
+    toolId: 'codex',
+    getFilePath(commandId) {
+        return path.join('.codex', 'prompts', `opsx-${commandId}.md`);
+    },
+    formatFile(content) {
+        return `---
+description: ${content.description}
+argument-hint: command arguments
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=codex.js.map

package/dist/core/command-generation/adapters/continue.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Continue Command Adapter
+ *
+ * Formats commands for Continue following its .prompt specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * Continue adapter for command generation.
+ * File path: .continue/prompts/opsx-<id>.prompt
+ * Frontmatter: name, description, invokable
+ */
+export declare const continueAdapter: ToolCommandAdapter;
+//# sourceMappingURL=continue.d.ts.map

package/dist/core/command-generation/adapters/continue.js

@@ -0,0 +1,28 @@
+/**
+ * Continue Command Adapter
+ *
+ * Formats commands for Continue following its .prompt specification.
+ */
+import path from 'path';
+/**
+ * Continue adapter for command generation.
+ * File path: .continue/prompts/opsx-<id>.prompt
+ * Frontmatter: name, description, invokable
+ */
+export const continueAdapter = {
+    toolId: 'continue',
+    getFilePath(commandId) {
+        return path.join('.continue', 'prompts', `opsx-${commandId}.prompt`);
+    },
+    formatFile(content) {
+        return `---
+name: opsx-${content.id}
+description: ${content.description}
+invokable: true
+---
+
+${content.body}
+`;
+    },
+};
+//# sourceMappingURL=continue.js.map

package/dist/core/command-generation/adapters/costrict.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CoStrict Command Adapter
+ *
+ * Formats commands for CoStrict following its frontmatter specification.
+ */
+import type { ToolCommandAdapter } from '../types.js';
+/**
+ * CoStrict adapter for command generation.
+ * File path: .cospec/openspec/commands/opsx-<id>.md
+ * Frontmatter: description, argument-hint
+ */
+export declare const costrictAdapter: ToolCommandAdapter;
+//# sourceMappingURL=costrict.d.ts.map