openspec-cn 0.23.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 OpenSpec Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,153 @@
+<p align="center">
+  <a href="https://github.com/xiangagou163/OpenSpec-cn">
+    <picture>
+      <source srcset="assets/openspec_pixel_dark.svg" media="(prefers-color-scheme: dark)">
+      <source srcset="assets/openspec_pixel_light.svg" media="(prefers-color-scheme: light)">
+      <img src="assets/openspec_pixel_light.svg" alt="OpenSpec logo" height="64">
+    </picture>
+  </a>
+  
+</p>
+<p align="center">Spec-driven development for AI coding assistants.</p>
+<p align="center">
+  <a href="https://github.com/xiangagou163/OpenSpec-cn/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/xiangagou163/OpenSpec-cn/actions/workflows/ci.yml/badge.svg" /></a>
+  <a href="https://www.npmjs.com/package/openspec-cn"><img alt="npm version" src="https://img.shields.io/npm/v/openspec-cn?style=flat-square" /></a>
+  <a href="https://nodejs.org/"><img alt="node version" src="https://img.shields.io/node/v/openspec-cn?style=flat-square" /></a>
+  <a href="./LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" /></a>
+  <a href="https://conventionalcommits.org"><img alt="Conventional Commits" src="https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg?style=flat-square" /></a>
+  <a href="https://discord.gg/YctCnvvshC"><img alt="Discord" src="https://img.shields.io/badge/Discord-Join%20the%20community-5865F2?logo=discord&logoColor=white&style=flat-square" /></a>
+</p>
+
+<p align="center">
+  <img src="assets/openspec_dashboard.png" alt="OpenSpec dashboard preview" width="90%">
+</p>
+
+<p align="center">
+  Follow <a href="https://x.com/0xTab">@0xTab on X</a> for updates · Join the <a href="https://discord.gg/YctCnvvshC">OpenSpec Discord</a> for help and questions.
+</p>
+
+<p align="center">
+  <sub>🧪 <strong>New:</strong> <a href="docs/experimental-workflow.md">Experimental Workflow (OPSX)</a> — schema-driven, hackable, fluid. Iterate on workflows without code changes.</sub>
+</p>
+
+# OpenSpec-cn
+
+OpenSpec alignments humans and AI coding assistants with spec-driven development so you agree on what to build before any code is written. **No API keys required.**
+
+## Why OpenSpec?
+
+AI coding assistants are powerful but unpredictable when requirements live in chat history. OpenSpec adds a lightweight specification workflow that locks intent before implementation, giving you deterministic, reviewable outputs.
+
+Key outcomes:
+- Human and AI stakeholders agree on specs before work begins.
+- Structured change folders (proposals, tasks, and spec updates) keep scope explicit and auditable.
+- Shared visibility into what's proposed, active, or archived.
+- Works with the AI tools you already use: custom slash commands where supported, context rules everywhere else.
+
+## Installation
+
+```bash
+npm install -g openspec-cn
+```
+
+## How OpenSpec compares (at a glance)
+
+- **Lightweight**: simple workflow, no API keys, minimal setup.
+- **Brownfield-first**: works great beyond 0→1. OpenSpec separates the source of truth from proposals: `openspec/specs/` (current truth) and `openspec/changes/` (proposed updates). This keeps diffs explicit and manageable across features.
+- **Change tracking**: proposals, tasks, and spec deltas live together; archiving merges the approved updates back into specs.
+- **Compared to spec-kit & Kiro**: those shine for brand-new features (0→1). OpenSpec also excels when modifying existing behavior (1→n), especially when updates span multiple specs.
+
+See the full comparison in [How OpenSpec Compares](#how-openspec-compares).
+
+## How It Works
+
+```
+┌────────────────────┐
+│ Draft Change       │
+│ Proposal           │
+└────────┬───────────┘
+         │ share intent with your AI
+         ▼
+┌────────────────────┐
+│ Review & Align     │
+│ (edit specs/tasks) │◀──── feedback loop ──────┐
+└────────┬───────────┘                          │
+         │ approved plan                        │
+         ▼                                      │
+┌────────────────────┐                          │
+│ Implement Tasks    │──────────────────────────┘
+│ (AI writes code)   │
+└────────┬───────────┘
+         │ ship the change
+         ▼
+┌────────────────────┐
+│ Archive & Update   │
+│ Specs (source)     │
+└────────────────────┘
+
+1. Draft a change proposal that captures the spec updates you want.
+2. Review the proposal with your AI assistant until everyone agrees.
+3. Implement tasks that reference the agreed specs.
+4. Archive the change to merge the approved updates back into the source-of-truth specs.
+```
+
+## Getting Started
+
+### Supported AI Tools
+
+<details>
+<summary><strong>Native Slash Commands</strong> (click to expand)</summary>
+
+These tools have built-in OpenSpec commands. Select the OpenSpec integration when prompted.
+
+| Tool | Commands |
+|------|----------|
+| **Amazon Q Developer** | `@openspec-proposal`, `@openspec-apply`, `@openspec-archive` (`.amazonq/prompts/`) |
+| **Antigravity** | `/openspec-proposal`, `/openspec-apply`, `/openspec-archive` (`.agent/workflows/`) |
+| **Claude Code** | `/opsx:new`, `/opsx:continue`, `/opsx:apply` (`.claude/commands/`) |
+| **Cursor** | `/opsx:new`, `/opsx:continue`, `/opsx:apply` (`.cursor/commands/`) |
+| **Windsurf** | `/opsx:new`, `/opsx:continue`, `/opsx:apply` (`.windsurf/commands/`) |
+
+</details>
+
+<details>
+<summary><strong>Context Rules</strong> (click to expand)</summary>
+
+For tools without custom commands, use OpenSpec via context rules. Copy the appropriate rules from [docs/context-rules/](docs/context-rules/) into your project's rule file (e.g., `.cursorrules`, `.clinerules`).
+
+</details>
+
+### Quick Start
+
+1. Initialize OpenSpec in your project:
+   ```bash
+   openspec init
+   ```
+2. Start a new change:
+   ```bash
+   openspec change new "my-feature"
+   ```
+   *This creates `openspec/changes/my-feature/proposal.md`*
+3. Collaborate with your AI to refine the specs and tasks.
+4. Implement the change:
+   ```bash
+   openspec change apply "my-feature"
+   ```
+5. Archive when done:
+   ```bash
+   openspec change archive "my-feature"
+   ```
+
+## Documentation
+
+Full documentation is available at [openspec.dev](https://openspec.dev) (TBD).
+
+- [Core Concepts](docs/core-concepts.md)
+- [Workflow Guide](docs/workflow.md)
+- [Experimental Artifact Workflow](docs/experimental-workflow.md)
+- [Configuration](docs/configuration.md)
+- [Troubleshooting](docs/troubleshooting.md)
+
+## License
+
+MIT

package/bin/openspec.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli/index.js';

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,480 @@
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import ora from 'ora';
+import path from 'path';
+import { promises as fs } from 'fs';
+import { AI_TOOLS } from '../core/config.js';
+import { UpdateCommand } from '../core/update.js';
+import { ListCommand } from '../core/list.js';
+import { ArchiveCommand } from '../core/archive.js';
+import { ViewCommand } from '../core/view.js';
+import { registerSpecCommand } from '../commands/spec.js';
+import { ChangeCommand } from '../commands/change.js';
+import { ValidateCommand } from '../commands/validate.js';
+import { ShowCommand } from '../commands/show.js';
+import { CompletionCommand } from '../commands/completion.js';
+import { FeedbackCommand } from '../commands/feedback.js';
+import { registerConfigCommand } from '../commands/config.js';
+import { registerSchemaCommand } from '../commands/schema.js';
+import { statusCommand, instructionsCommand, applyInstructionsCommand, templatesCommand, schemasCommand, newChangeCommand, DEFAULT_SCHEMA, } from '../commands/workflow/index.js';
+import { maybeShowTelemetryNotice, trackCommand, shutdown } from '../telemetry/index.js';
+const program = new Command();
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+/**
+ * Get the full command path for nested commands.
+ * For example: 'change show' -> 'change:show'
+ */
+function getCommandPath(command) {
+    const names = [];
+    let current = command;
+    while (current) {
+        const name = current.name();
+        // Skip the root 'openspec' command
+        if (name && name !== 'openspec') {
+            names.unshift(name);
+        }
+        current = current.parent;
+    }
+    return names.join(':') || 'openspec';
+}
+program
+    .name('openspec')
+    .description('AI-native system for spec-driven development')
+    .version(version);
+// Global options
+program.option('--no-color', 'Disable color output');
+// Apply global flags and telemetry before any command runs
+// Note: preAction receives (thisCommand, actionCommand) where:
+// - thisCommand: the command where hook was added (root program)
+// - actionCommand: the command actually being executed (subcommand)
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.color === false) {
+        process.env.NO_COLOR = '1';
+    }
+    // Show first-run telemetry notice (if not seen)
+    await maybeShowTelemetryNotice();
+    // Track command execution (use actionCommand to get the actual subcommand)
+    const commandPath = getCommandPath(actionCommand);
+    await trackCommand(commandPath, version);
+});
+// Shutdown telemetry after command completes
+program.hook('postAction', async () => {
+    await shutdown();
+});
+const availableToolIds = AI_TOOLS.filter((tool) => tool.skillsDir).map((tool) => tool.value);
+const toolsOptionDescription = `Configure AI tools non-interactively. Use "all", "none", or a comma-separated list of: ${availableToolIds.join(', ')}`;
+program
+    .command('init [path]')
+    .description('Initialize OpenSpec in your project')
+    .option('--tools <tools>', toolsOptionDescription)
+    .option('--force', 'Auto-cleanup legacy files without prompting')
+    .action(async (targetPath = '.', options) => {
+    try {
+        // Validate that the path is a valid directory
+        const resolvedPath = path.resolve(targetPath);
+        try {
+            const stats = await fs.stat(resolvedPath);
+            if (!stats.isDirectory()) {
+                throw new Error(`Path "${targetPath}" is not a directory`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Directory doesn't exist, but we can create it
+                console.log(`Directory "${targetPath}" doesn't exist, it will be created.`);
+            }
+            else if (error.message && error.message.includes('not a directory')) {
+                throw error;
+            }
+            else {
+                throw new Error(`Cannot access path "${targetPath}": ${error.message}`);
+            }
+        }
+        const { InitCommand } = await import('../core/init.js');
+        const initCommand = new InitCommand({
+            tools: options?.tools,
+            force: options?.force,
+        });
+        await initCommand.execute(targetPath);
+    }
+    catch (error) {
+        console.log(); // Empty line for spacing
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Hidden alias: 'experimental' -> 'init' for backwards compatibility
+program
+    .command('experimental', { hidden: true })
+    .description('Alias for init (deprecated)')
+    .option('--tool <tool-id>', 'Target AI tool (maps to --tools)')
+    .option('--no-interactive', 'Disable interactive prompts')
+    .action(async (options) => {
+    try {
+        console.log('Note: "openspec experimental" is deprecated. Use "openspec init" instead.');
+        const { InitCommand } = await import('../core/init.js');
+        const initCommand = new InitCommand({
+            tools: options?.tool,
+            interactive: options?.noInteractive === true ? false : undefined,
+        });
+        await initCommand.execute('.');
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('update [path]')
+    .description('Update OpenSpec instruction files')
+    .option('--force', 'Force update even when tools are up to date')
+    .action(async (targetPath = '.', options) => {
+    try {
+        const resolvedPath = path.resolve(targetPath);
+        const updateCommand = new UpdateCommand({ force: options?.force });
+        await updateCommand.execute(resolvedPath);
+    }
+    catch (error) {
+        console.log(); // Empty line for spacing
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('list')
+    .description('List items (changes by default). Use --specs to list specs.')
+    .option('--specs', 'List specs instead of changes')
+    .option('--changes', 'List changes explicitly (default)')
+    .option('--sort <order>', 'Sort order: "recent" (default) or "name"', 'recent')
+    .option('--json', 'Output as JSON (for programmatic use)')
+    .action(async (options) => {
+    try {
+        const listCommand = new ListCommand();
+        const mode = options?.specs ? 'specs' : 'changes';
+        const sort = options?.sort === 'name' ? 'name' : 'recent';
+        await listCommand.execute('.', mode, { sort, json: options?.json });
+    }
+    catch (error) {
+        console.log(); // Empty line for spacing
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('view')
+    .description('Display an interactive dashboard of specs and changes')
+    .action(async () => {
+    try {
+        const viewCommand = new ViewCommand();
+        await viewCommand.execute('.');
+    }
+    catch (error) {
+        console.log(); // Empty line for spacing
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Change command with subcommands
+const changeCmd = program
+    .command('change')
+    .description('Manage OpenSpec change proposals');
+// Deprecation notice for noun-based commands
+changeCmd.hook('preAction', () => {
+    console.error('Warning: The "openspec change ..." commands are deprecated. Prefer verb-first commands (e.g., "openspec list", "openspec validate --changes").');
+});
+changeCmd
+    .command('show [change-name]')
+    .description('Show a change proposal in JSON or markdown format')
+    .option('--json', 'Output as JSON')
+    .option('--deltas-only', 'Show only deltas (JSON only)')
+    .option('--requirements-only', 'Alias for --deltas-only (deprecated)')
+    .option('--no-interactive', 'Disable interactive prompts')
+    .action(async (changeName, options) => {
+    try {
+        const changeCommand = new ChangeCommand();
+        await changeCommand.show(changeName, options);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exitCode = 1;
+    }
+});
+changeCmd
+    .command('list')
+    .description('List all active changes (DEPRECATED: use "openspec list" instead)')
+    .option('--json', 'Output as JSON')
+    .option('--long', 'Show id and title with counts')
+    .action(async (options) => {
+    try {
+        console.error('Warning: "openspec change list" is deprecated. Use "openspec list".');
+        const changeCommand = new ChangeCommand();
+        await changeCommand.list(options);
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exitCode = 1;
+    }
+});
+changeCmd
+    .command('validate [change-name]')
+    .description('Validate a change proposal')
+    .option('--strict', 'Enable strict validation mode')
+    .option('--json', 'Output validation report as JSON')
+    .option('--no-interactive', 'Disable interactive prompts')
+    .action(async (changeName, options) => {
+    try {
+        const changeCommand = new ChangeCommand();
+        await changeCommand.validate(changeName, options);
+        if (typeof process.exitCode === 'number' && process.exitCode !== 0) {
+            process.exit(process.exitCode);
+        }
+    }
+    catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exitCode = 1;
+    }
+});
+program
+    .command('archive [change-name]')
+    .description('Archive a completed change and update main specs')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .option('--skip-specs', 'Skip spec update operations (useful for infrastructure, tooling, or doc-only changes)')
+    .option('--no-validate', 'Skip validation (not recommended, requires confirmation)')
+    .action(async (changeName, options) => {
+    try {
+        const archiveCommand = new ArchiveCommand();
+        await archiveCommand.execute(changeName, options);
+    }
+    catch (error) {
+        console.log(); // Empty line for spacing
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+registerSpecCommand(program);
+registerConfigCommand(program);
+registerSchemaCommand(program);
+// Top-level validate command
+program
+    .command('validate [item-name]')
+    .description('Validate changes and specs')
+    .option('--all', 'Validate all changes and specs')
+    .option('--changes', 'Validate all changes')
+    .option('--specs', 'Validate all specs')
+    .option('--type <type>', 'Specify item type when ambiguous: change|spec')
+    .option('--strict', 'Enable strict validation mode')
+    .option('--json', 'Output validation results as JSON')
+    .option('--concurrency <n>', 'Max concurrent validations (defaults to env OPENSPEC_CONCURRENCY or 6)')
+    .option('--no-interactive', 'Disable interactive prompts')
+    .action(async (itemName, options) => {
+    try {
+        const validateCommand = new ValidateCommand();
+        await validateCommand.execute(itemName, options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Top-level show command
+program
+    .command('show [item-name]')
+    .description('Show a change or spec')
+    .option('--json', 'Output as JSON')
+    .option('--type <type>', 'Specify item type when ambiguous: change|spec')
+    .option('--no-interactive', 'Disable interactive prompts')
+    // change-only flags
+    .option('--deltas-only', 'Show only deltas (JSON only, change)')
+    .option('--requirements-only', 'Alias for --deltas-only (deprecated, change)')
+    // spec-only flags
+    .option('--requirements', 'JSON only: Show only requirements (exclude scenarios)')
+    .option('--no-scenarios', 'JSON only: Exclude scenario content')
+    .option('-r, --requirement <id>', 'JSON only: Show specific requirement by ID (1-based)')
+    // allow unknown options to pass-through to underlying command implementation
+    .allowUnknownOption(true)
+    .action(async (itemName, options) => {
+    try {
+        const showCommand = new ShowCommand();
+        await showCommand.execute(itemName, options ?? {});
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Feedback command
+program
+    .command('feedback <message>')
+    .description('Submit feedback about OpenSpec')
+    .option('--body <text>', 'Detailed description for the feedback')
+    .action(async (message, options) => {
+    try {
+        const feedbackCommand = new FeedbackCommand();
+        await feedbackCommand.execute(message, options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Completion command with subcommands
+const completionCmd = program
+    .command('completion')
+    .description('Manage shell completions for OpenSpec CLI');
+completionCmd
+    .command('generate [shell]')
+    .description('Generate completion script for a shell (outputs to stdout)')
+    .action(async (shell) => {
+    try {
+        const completionCommand = new CompletionCommand();
+        await completionCommand.generate({ shell });
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+completionCmd
+    .command('install [shell]')
+    .description('Install completion script for a shell')
+    .option('--verbose', 'Show detailed installation output')
+    .action(async (shell, options) => {
+    try {
+        const completionCommand = new CompletionCommand();
+        await completionCommand.install({ shell, verbose: options?.verbose });
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+completionCmd
+    .command('uninstall [shell]')
+    .description('Uninstall completion script for a shell')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(async (shell, options) => {
+    try {
+        const completionCommand = new CompletionCommand();
+        await completionCommand.uninstall({ shell, yes: options?.yes });
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Hidden command for machine-readable completion data
+program
+    .command('__complete <type>', { hidden: true })
+    .description('Output completion data in machine-readable format (internal use)')
+    .action(async (type) => {
+    try {
+        const completionCommand = new CompletionCommand();
+        await completionCommand.complete({ type });
+    }
+    catch (error) {
+        // Silently fail for graceful shell completion experience
+        process.exitCode = 1;
+    }
+});
+// ═══════════════════════════════════════════════════════════
+// Workflow Commands (formerly experimental)
+// ═══════════════════════════════════════════════════════════
+// Status command
+program
+    .command('status')
+    .description('Display artifact completion status for a change')
+    .option('--change <id>', 'Change name to show status for')
+    .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        await statusCommand(options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Instructions command
+program
+    .command('instructions [artifact]')
+    .description('Output enriched instructions for creating an artifact or applying tasks')
+    .option('--change <id>', 'Change name')
+    .option('--schema <name>', 'Schema override (auto-detected from config.yaml)')
+    .option('--json', 'Output as JSON')
+    .action(async (artifactId, options) => {
+    try {
+        // Special case: "apply" is not an artifact, but a command to get apply instructions
+        if (artifactId === 'apply') {
+            await applyInstructionsCommand(options);
+        }
+        else {
+            await instructionsCommand(artifactId, options);
+        }
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Templates command
+program
+    .command('templates')
+    .description('Show resolved template paths for all artifacts in a schema')
+    .option('--schema <name>', `Schema to use (default: ${DEFAULT_SCHEMA})`)
+    .option('--json', 'Output as JSON mapping artifact IDs to template paths')
+    .action(async (options) => {
+    try {
+        await templatesCommand(options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// Schemas command
+program
+    .command('schemas')
+    .description('List available workflow schemas with descriptions')
+    .option('--json', 'Output as JSON (for agent use)')
+    .action(async (options) => {
+    try {
+        await schemasCommand(options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+// New command group with change subcommand
+const newCmd = program.command('new').description('Create new items');
+newCmd
+    .command('change <name>')
+    .description('Create a new change directory')
+    .option('--description <text>', 'Description to add to README.md')
+    .option('--schema <name>', `Workflow schema to use (default: ${DEFAULT_SCHEMA})`)
+    .action(async (name, options) => {
+    try {
+        await newChangeCommand(name, options);
+    }
+    catch (error) {
+        console.log();
+        ora().fail(`Error: ${error.message}`);
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=index.js.map