openspec-cn 0.23.0

package/dist/commands/workflow/status.js

@@ -0,0 +1,58 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { validateChangeExists, validateSchemaExists, getStatusIndicator, getStatusColor, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function statusCommand(options) {
+    const spinner = ora('Loading change status...').start();
+    try {
+        const projectRoot = process.cwd();
+        const changeName = await validateChangeExists(options.change, projectRoot);
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        // loadChangeContext will auto-detect schema from metadata if not provided
+        const context = loadChangeContext(projectRoot, changeName, options.schema);
+        const status = formatChangeStatus(context);
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printStatusText(status);
+    }
+    catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+export function printStatusText(status) {
+    const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
+    const total = status.artifacts.length;
+    console.log(`Change: ${status.changeName}`);
+    console.log(`Schema: ${status.schemaName}`);
+    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    console.log();
+    for (const artifact of status.artifacts) {
+        const indicator = getStatusIndicator(artifact.status);
+        const color = getStatusColor(artifact.status);
+        let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
+            line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
+        }
+        console.log(line);
+    }
+    if (status.isComplete) {
+        console.log();
+        console.log(chalk.green('All artifacts complete!'));
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+export interface TemplatesOptions {
+    schema?: string;
+    json?: boolean;
+}
+export interface TemplateInfo {
+    artifactId: string;
+    templatePath: string;
+    source: 'project' | 'user' | 'package';
+}
+export declare function templatesCommand(options: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/workflow/templates.js

@@ -0,0 +1,68 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function templatesCommand(options) {
+    const spinner = ora('Loading templates...').start();
+    try {
+        const projectRoot = process.cwd();
+        const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        const graph = ArtifactGraph.fromSchema(schema);
+        const schemaDir = getSchemaDir(schemaName, projectRoot);
+        // Determine the source (project, user, or package)
+        const { getUserSchemasDir, getProjectSchemasDir, } = await import('../../core/artifact-graph/resolver.js');
+        const projectSchemasDir = getProjectSchemasDir(projectRoot);
+        const userSchemasDir = getUserSchemasDir();
+        // Determine source by checking if schemaDir is inside each base directory
+        // Using path.relative is more robust than startsWith for path comparisons
+        const isInsideDir = (child, parent) => {
+            const relative = path.relative(parent, child);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        };
+        let source;
+        if (isInsideDir(schemaDir, projectSchemasDir)) {
+            source = 'project';
+        }
+        else if (isInsideDir(schemaDir, userSchemasDir)) {
+            source = 'user';
+        }
+        else {
+            source = 'package';
+        }
+        const templates = graph.getAllArtifacts().map((artifact) => ({
+            artifactId: artifact.id,
+            templatePath: path.join(schemaDir, 'templates', artifact.template),
+            source,
+        }));
+        spinner.stop();
+        if (options.json) {
+            const output = {};
+            for (const t of templates) {
+                output[t.artifactId] = { path: t.templatePath, source: t.source };
+            }
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`Schema: ${schemaName}`);
+        console.log(`Source: ${source}`);
+        console.log();
+        for (const t of templates) {
+            console.log(`${t.artifactId}:`);
+            console.log(`  ${t.templatePath}`);
+        }
+    }
+    catch (error) {
+        spinner.stop();
+        throw error;
+    }
+}
+//# sourceMappingURL=templates.js.map

package/dist/core/archive.d.ts

@@ -0,0 +1,11 @@
+export declare class ArchiveCommand {
+    execute(changeName?: string, options?: {
+        yes?: boolean;
+        skipSpecs?: boolean;
+        noValidate?: boolean;
+        validate?: boolean;
+    }): Promise<void>;
+    private selectChange;
+    private getArchiveDate;
+}
+//# sourceMappingURL=archive.d.ts.map

package/dist/core/archive.js

@@ -0,0 +1,280 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { Validator } from './validation/validator.js';
+import chalk from 'chalk';
+import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from './specs-apply.js';
+export class ArchiveCommand {
+    async execute(changeName, options = {}) {
+        const targetPath = '.';
+        const changesDir = path.join(targetPath, 'openspec', 'changes');
+        const archiveDir = path.join(changesDir, 'archive');
+        const mainSpecsDir = path.join(targetPath, 'openspec', 'specs');
+        // Check if changes directory exists
+        try {
+            await fs.access(changesDir);
+        }
+        catch {
+            throw new Error("No OpenSpec changes directory found. Run 'openspec init' first.");
+        }
+        // Get change name interactively if not provided
+        if (!changeName) {
+            const selectedChange = await this.selectChange(changesDir);
+            if (!selectedChange) {
+                console.log('No change selected. Aborting.');
+                return;
+            }
+            changeName = selectedChange;
+        }
+        const changeDir = path.join(changesDir, changeName);
+        // Verify change exists
+        try {
+            const stat = await fs.stat(changeDir);
+            if (!stat.isDirectory()) {
+                throw new Error(`Change '${changeName}' not found.`);
+            }
+        }
+        catch {
+            throw new Error(`Change '${changeName}' not found.`);
+        }
+        const skipValidation = options.validate === false || options.noValidate === true;
+        // Validate specs and change before archiving
+        if (!skipValidation) {
+            const validator = new Validator();
+            let hasValidationErrors = false;
+            // Validate proposal.md (non-blocking unless strict mode desired in future)
+            const changeFile = path.join(changeDir, 'proposal.md');
+            try {
+                await fs.access(changeFile);
+                const changeReport = await validator.validateChange(changeFile);
+                // Proposal validation is informative only (do not block archive)
+                if (!changeReport.valid) {
+                    console.log(chalk.yellow(`\nProposal warnings in proposal.md (non-blocking):`));
+                    for (const issue of changeReport.issues) {
+                        const symbol = issue.level === 'ERROR' ? '⚠' : (issue.level === 'WARNING' ? '⚠' : 'ℹ');
+                        console.log(chalk.yellow(`  ${symbol} ${issue.message}`));
+                    }
+                }
+            }
+            catch {
+                // Change file doesn't exist, skip validation
+            }
+            // Validate delta-formatted spec files under the change directory if present
+            const changeSpecsDir = path.join(changeDir, 'specs');
+            let hasDeltaSpecs = false;
+            try {
+                const candidates = await fs.readdir(changeSpecsDir, { withFileTypes: true });
+                for (const c of candidates) {
+                    if (c.isDirectory()) {
+                        try {
+                            const candidatePath = path.join(changeSpecsDir, c.name, 'spec.md');
+                            await fs.access(candidatePath);
+                            const content = await fs.readFile(candidatePath, 'utf-8');
+                            if (/^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements/m.test(content)) {
+                                hasDeltaSpecs = true;
+                                break;
+                            }
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch { }
+            if (hasDeltaSpecs) {
+                const deltaReport = await validator.validateChangeDeltaSpecs(changeDir);
+                if (!deltaReport.valid) {
+                    hasValidationErrors = true;
+                    console.log(chalk.red(`\nValidation errors in change delta specs:`));
+                    for (const issue of deltaReport.issues) {
+                        if (issue.level === 'ERROR') {
+                            console.log(chalk.red(`  ✗ ${issue.message}`));
+                        }
+                        else if (issue.level === 'WARNING') {
+                            console.log(chalk.yellow(`  ⚠ ${issue.message}`));
+                        }
+                    }
+                }
+            }
+            if (hasValidationErrors) {
+                console.log(chalk.red('\nValidation failed. Please fix the errors before archiving.'));
+                console.log(chalk.yellow('To skip validation (not recommended), use --no-validate flag.'));
+                return;
+            }
+        }
+        else {
+            // Log warning when validation is skipped
+            const timestamp = new Date().toISOString();
+            if (!options.yes) {
+                const { confirm } = await import('@inquirer/prompts');
+                const proceed = await confirm({
+                    message: chalk.yellow('⚠️  WARNING: Skipping validation may archive invalid specs. Continue? (y/N)'),
+                    default: false
+                });
+                if (!proceed) {
+                    console.log('Archive cancelled.');
+                    return;
+                }
+            }
+            else {
+                console.log(chalk.yellow(`\n⚠️  WARNING: Skipping validation may archive invalid specs.`));
+            }
+            console.log(chalk.yellow(`[${timestamp}] Validation skipped for change: ${changeName}`));
+            console.log(chalk.yellow(`Affected files: ${changeDir}`));
+        }
+        // Show progress and check for incomplete tasks
+        const progress = await getTaskProgressForChange(changesDir, changeName);
+        const status = formatTaskStatus(progress);
+        console.log(`Task status: ${status}`);
+        const incompleteTasks = Math.max(progress.total - progress.completed, 0);
+        if (incompleteTasks > 0) {
+            if (!options.yes) {
+                const { confirm } = await import('@inquirer/prompts');
+                const proceed = await confirm({
+                    message: `Warning: ${incompleteTasks} incomplete task(s) found. Continue?`,
+                    default: false
+                });
+                if (!proceed) {
+                    console.log('Archive cancelled.');
+                    return;
+                }
+            }
+            else {
+                console.log(`Warning: ${incompleteTasks} incomplete task(s) found. Continuing due to --yes flag.`);
+            }
+        }
+        // Handle spec updates unless skipSpecs flag is set
+        if (options.skipSpecs) {
+            console.log('Skipping spec updates (--skip-specs flag provided).');
+        }
+        else {
+            // Find specs to update
+            const specUpdates = await findSpecUpdates(changeDir, mainSpecsDir);
+            if (specUpdates.length > 0) {
+                console.log('\nSpecs to update:');
+                for (const update of specUpdates) {
+                    const status = update.exists ? 'update' : 'create';
+                    const capability = path.basename(path.dirname(update.target));
+                    console.log(`  ${capability}: ${status}`);
+                }
+                let shouldUpdateSpecs = true;
+                if (!options.yes) {
+                    const { confirm } = await import('@inquirer/prompts');
+                    shouldUpdateSpecs = await confirm({
+                        message: 'Proceed with spec updates?',
+                        default: true
+                    });
+                    if (!shouldUpdateSpecs) {
+                        console.log('Skipping spec updates. Proceeding with archive.');
+                    }
+                }
+                if (shouldUpdateSpecs) {
+                    // Prepare all updates first (validation pass, no writes)
+                    const prepared = [];
+                    try {
+                        for (const update of specUpdates) {
+                            const built = await buildUpdatedSpec(update, changeName);
+                            prepared.push({ update, rebuilt: built.rebuilt, counts: built.counts });
+                        }
+                    }
+                    catch (err) {
+                        console.log(String(err.message || err));
+                        console.log('Aborted. No files were changed.');
+                        return;
+                    }
+                    // All validations passed; pre-validate rebuilt full spec and then write files and display counts
+                    let totals = { added: 0, modified: 0, removed: 0, renamed: 0 };
+                    for (const p of prepared) {
+                        const specName = path.basename(path.dirname(p.update.target));
+                        if (!skipValidation) {
+                            const report = await new Validator().validateSpecContent(specName, p.rebuilt);
+                            if (!report.valid) {
+                                console.log(chalk.red(`\nValidation errors in rebuilt spec for ${specName} (will not write changes):`));
+                                for (const issue of report.issues) {
+                                    if (issue.level === 'ERROR')
+                                        console.log(chalk.red(`  ✗ ${issue.message}`));
+                                    else if (issue.level === 'WARNING')
+                                        console.log(chalk.yellow(`  ⚠ ${issue.message}`));
+                                }
+                                console.log('Aborted. No files were changed.');
+                                return;
+                            }
+                        }
+                        await writeUpdatedSpec(p.update, p.rebuilt, p.counts);
+                        totals.added += p.counts.added;
+                        totals.modified += p.counts.modified;
+                        totals.removed += p.counts.removed;
+                        totals.renamed += p.counts.renamed;
+                    }
+                    console.log(`Totals: + ${totals.added}, ~ ${totals.modified}, - ${totals.removed}, → ${totals.renamed}`);
+                    console.log('Specs updated successfully.');
+                }
+            }
+        }
+        // Create archive directory with date prefix
+        const archiveName = `${this.getArchiveDate()}-${changeName}`;
+        const archivePath = path.join(archiveDir, archiveName);
+        // Check if archive already exists
+        try {
+            await fs.access(archivePath);
+            throw new Error(`Archive '${archiveName}' already exists.`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        // Create archive directory if needed
+        await fs.mkdir(archiveDir, { recursive: true });
+        // Move change to archive
+        await fs.rename(changeDir, archivePath);
+        console.log(`Change '${changeName}' archived as '${archiveName}'.`);
+    }
+    async selectChange(changesDir) {
+        const { select } = await import('@inquirer/prompts');
+        // Get all directories in changes (excluding archive)
+        const entries = await fs.readdir(changesDir, { withFileTypes: true });
+        const changeDirs = entries
+            .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+            .map(entry => entry.name)
+            .sort();
+        if (changeDirs.length === 0) {
+            console.log('No active changes found.');
+            return null;
+        }
+        // Build choices with progress inline to avoid duplicate lists
+        let choices = changeDirs.map(name => ({ name, value: name }));
+        try {
+            const progressList = [];
+            for (const id of changeDirs) {
+                const progress = await getTaskProgressForChange(changesDir, id);
+                const status = formatTaskStatus(progress);
+                progressList.push({ id, status });
+            }
+            const nameWidth = Math.max(...progressList.map(p => p.id.length));
+            choices = progressList.map(p => ({
+                name: `${p.id.padEnd(nameWidth)}     ${p.status}`,
+                value: p.id
+            }));
+        }
+        catch {
+            // If anything fails, fall back to simple names
+            choices = changeDirs.map(name => ({ name, value: name }));
+        }
+        try {
+            const answer = await select({
+                message: 'Select a change to archive',
+                choices
+            });
+            return answer;
+        }
+        catch (error) {
+            // User cancelled (Ctrl+C)
+            return null;
+        }
+    }
+    getArchiveDate() {
+        // Returns date in YYYY-MM-DD format
+        return new Date().toISOString().split('T')[0];
+    }
+}
+//# sourceMappingURL=archive.js.map

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

@@ -0,0 +1,56 @@
+import type { Artifact, SchemaYaml, CompletedSet, BlockedArtifacts } from './types.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export declare class ArtifactGraph {
+    private artifacts;
+    private schema;
+    private constructor();
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema: SchemaYaml): ArtifactGraph;
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id: string): Artifact | undefined;
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts(): Artifact[];
+    /**
+     * Gets the schema name.
+     */
+    getName(): string;
+    /**
+     * Gets the schema version.
+     */
+    getVersion(): number;
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder(): string[];
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed: CompletedSet): string[];
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed: CompletedSet): boolean;
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed: CompletedSet): BlockedArtifacts;
+}
+//# sourceMappingURL=graph.d.ts.map

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

@@ -0,0 +1,141 @@
+import { loadSchema, parseSchema } from './schema.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export class ArtifactGraph {
+    artifacts;
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+        this.artifacts = new Map(schema.artifacts.map(a => [a.id, a]));
+    }
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath) {
+        const schema = loadSchema(filePath);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent) {
+        const schema = parseSchema(yamlContent);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema) {
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id) {
+        return this.artifacts.get(id);
+    }
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts() {
+        return Array.from(this.artifacts.values());
+    }
+    /**
+     * Gets the schema name.
+     */
+    getName() {
+        return this.schema.name;
+    }
+    /**
+     * Gets the schema version.
+     */
+    getVersion() {
+        return this.schema.version;
+    }
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder() {
+        const inDegree = new Map();
+        const dependents = new Map();
+        // Initialize all artifacts
+        for (const artifact of this.artifacts.values()) {
+            inDegree.set(artifact.id, artifact.requires.length);
+            dependents.set(artifact.id, []);
+        }
+        // Build reverse adjacency (who depends on whom)
+        for (const artifact of this.artifacts.values()) {
+            for (const req of artifact.requires) {
+                dependents.get(req).push(artifact.id);
+            }
+        }
+        // Start with roots (in-degree 0), sorted for determinism
+        const queue = [...this.artifacts.keys()]
+            .filter(id => inDegree.get(id) === 0)
+            .sort();
+        const result = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            // Collect newly ready artifacts, then sort before adding
+            const newlyReady = [];
+            for (const dep of dependents.get(current)) {
+                const newDegree = inDegree.get(dep) - 1;
+                inDegree.set(dep, newDegree);
+                if (newDegree === 0) {
+                    newlyReady.push(dep);
+                }
+            }
+            queue.push(...newlyReady.sort());
+        }
+        return result;
+    }
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed) {
+        const ready = [];
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const allDepsCompleted = artifact.requires.every(req => completed.has(req));
+            if (allDepsCompleted) {
+                ready.push(artifact.id);
+            }
+        }
+        // Sort for deterministic ordering
+        return ready.sort();
+    }
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed) {
+        for (const artifact of this.artifacts.values()) {
+            if (!completed.has(artifact.id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed) {
+        const blocked = {};
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const unmetDeps = artifact.requires.filter(req => !completed.has(req));
+            if (unmetDeps.length > 0) {
+                blocked[artifact.id] = unmetDeps.sort();
+            }
+        }
+        return blocked;
+    }
+}
+//# sourceMappingURL=graph.js.map

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

@@ -0,0 +1,7 @@
+export { ArtifactSchema, SchemaYamlSchema, type Artifact, type SchemaYaml, type CompletedSet, type BlockedArtifacts, } from './types.js';
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+export { ArtifactGraph } from './graph.js';
+export { detectCompleted } from './state.js';
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, } from './instruction-loader.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,13 @@
+// Types
+export { ArtifactSchema, SchemaYamlSchema, } from './types.js';
+// Schema loading and validation
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+// Graph operations
+export { ArtifactGraph } from './graph.js';
+// State detection
+export { detectCompleted } from './state.js';
+// Schema resolution
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, } from './resolver.js';
+// Instruction loading
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, } from './instruction-loader.js';
+//# sourceMappingURL=index.js.map