@codewalla_india/openspec 1.0.1

package/dist/commands/workflow/instructions.js

@@ -0,0 +1,500 @@
+/**
+ * Instructions Command
+ *
+ * Generates enriched instructions for creating artifacts or applying tasks.
+ * Includes both artifact instructions and apply instructions.
+ */
+import ora from 'ora';
+import path from 'path';
+import * as fs from 'fs';
+import { loadChangeContext, generateInstructions, resolveSchema, resolveArtifactOutputs, } from '../../core/artifact-graph/index.js';
+import { getChangeDir, resolveCurrentPlanningHomeSync, } from '../../core/planning-home.js';
+import { resolveRootForCommand, withStoreFlag, toPlanningHome, toRootOutput, } from '../../core/root-selection.js';
+import { assembleReferenceIndex, renderReferencedStoresBlock, renderReferencedStoresSection, } from '../../core/references.js';
+import { readRegistrySnapshot } from '../../core/store/registry.js';
+import { readProjectConfig } from '../../core/project-config.js';
+import { checkComprehensionGate, ComprehensionPassError, recordComprehensionPass, } from '../../core/comprehension/index.js';
+import { validateChangeExists, validateSchemaExists, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Artifact Instructions Command
+// -----------------------------------------------------------------------------
+/**
+ * Reads the resolved root's config once, assembles the referenced-store
+ * index when references are declared, and resolves the config path for
+ * fix text. Shared by both instruction surfaces.
+ */
+async function loadRootConfigContext(root) {
+    // readProjectConfig never throws: missing/unparseable configs are null.
+    const projectConfig = readProjectConfig(root.path);
+    // One registry read serves every relationship consumer in this
+    // output so it never carries a torn snapshot.
+    const snapshot = await readRegistrySnapshot();
+    const registryEntries = snapshot.entries;
+    const declared = projectConfig?.references ?? [];
+    const index = declared.length > 0
+        ? await assembleReferenceIndex({ references: declared, resolvedRoot: root, registryEntries })
+        : [];
+    // Omitted, not empty: an index emptied by self-reference omission must
+    // look identical to an undeclared one in JSON.
+    return {
+        projectConfig,
+        references: index.length > 0 ? index : undefined,
+    };
+}
+export async function instructionsCommand(artifactId, options) {
+    // Resolve (and banner) before the spinner starts so stderr stays readable.
+    const root = await resolveRootForCommand(options, { json: options.json });
+    if (!root) {
+        return;
+    }
+    const spinner = options.json ? undefined : ora('Generating instructions...').start();
+    try {
+        const planningHome = toPlanningHome(root);
+        const projectRoot = root.path;
+        const changeName = await validateChangeExists(options.change, projectRoot, root.changesDir, { newChangeHint: withStoreFlag(root, 'openspec new change <name>') });
+        // 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, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        });
+        if (!artifactId) {
+            spinner?.stop();
+            const validIds = context.graph.getAllArtifacts().map((a) => a.id);
+            throw new Error(`Missing required argument <artifact>. Valid artifacts:\n  ${validIds.join('\n  ')}`);
+        }
+        const artifact = context.graph.getArtifact(artifactId);
+        if (!artifact) {
+            spinner?.stop();
+            const validIds = context.graph.getAllArtifacts().map((a) => a.id);
+            throw new Error(`Artifact '${artifactId}' not found in schema '${context.schemaName}'. Valid artifacts:\n  ${validIds.join('\n  ')}`);
+        }
+        const { projectConfig, references } = await loadRootConfigContext(root);
+        const instructions = generateInstructions(context, artifactId, projectRoot, {
+            projectConfig,
+            references,
+        });
+        const isBlocked = instructions.dependencies.some((d) => !d.done);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ ...instructions, root: toRootOutput(root) }, null, 2));
+            return;
+        }
+        printInstructionsText(instructions, isBlocked);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printInstructionsText(instructions, isBlocked) {
+    const { artifactId, changeName, schemaName, changeDir, resolvedOutputPath, description, instruction, context, rules, template, dependencies, unlocks, } = instructions;
+    // Opening tag
+    console.log(`<artifact id="${artifactId}" change="${changeName}" schema="${schemaName}">`);
+    console.log();
+    // Warning for blocked artifacts
+    if (isBlocked) {
+        const missing = dependencies.filter((d) => !d.done).map((d) => d.id);
+        console.log('<warning>');
+        console.log('This artifact has unmet dependencies. Complete them first or proceed with caution.');
+        console.log(`Missing: ${missing.join(', ')}`);
+        console.log('</warning>');
+        console.log();
+    }
+    // Task directive
+    console.log('<task>');
+    console.log(`Create the ${artifactId} artifact for change "${changeName}".`);
+    console.log(description);
+    console.log('</task>');
+    console.log();
+    // Project context (AI constraint - do not include in output)
+    if (context) {
+        console.log('<project_context>');
+        console.log('<!-- This is background information for you. Do NOT include this in your output. -->');
+        console.log(context);
+        console.log('</project_context>');
+        console.log();
+    }
+    // Referenced-store index (read-only upstream context)
+    if (instructions.references && instructions.references.length > 0) {
+        console.log(renderReferencedStoresBlock(instructions.references));
+        console.log();
+    }
+    // Rules (AI constraint - do not include in output)
+    if (rules && rules.length > 0) {
+        console.log('<rules>');
+        console.log('<!-- These are constraints for you to follow. Do NOT include this in your output. -->');
+        for (const rule of rules) {
+            console.log(`- ${rule}`);
+        }
+        console.log('</rules>');
+        console.log();
+    }
+    // Dependencies (files to read for context)
+    if (dependencies.length > 0) {
+        console.log('<dependencies>');
+        console.log('Read these files for context before creating this artifact:');
+        console.log();
+        for (const dep of dependencies) {
+            const status = dep.done ? 'done' : 'missing';
+            const fullPath = path.join(changeDir, dep.path);
+            console.log(`<dependency id="${dep.id}" status="${status}">`);
+            console.log(`  <path>${fullPath}</path>`);
+            console.log(`  <description>${dep.description}</description>`);
+            console.log('</dependency>');
+        }
+        console.log('</dependencies>');
+        console.log();
+    }
+    // Output location
+    console.log('<output>');
+    console.log(`Write to: ${resolvedOutputPath}`);
+    console.log('</output>');
+    console.log();
+    // Instruction (guidance)
+    if (instruction) {
+        console.log('<instruction>');
+        console.log(instruction.trim());
+        console.log('</instruction>');
+        console.log();
+    }
+    // Template
+    console.log('<template>');
+    console.log('<!-- Use this as the structure for your output file. Fill in the sections. -->');
+    console.log(template.trim());
+    console.log('</template>');
+    console.log();
+    // Success criteria placeholder
+    console.log('<success_criteria>');
+    console.log('<!-- To be defined in schema validation rules -->');
+    console.log('</success_criteria>');
+    console.log();
+    // Unlocks
+    if (unlocks.length > 0) {
+        console.log('<unlocks>');
+        console.log(`Completing this artifact enables: ${unlocks.join(', ')}`);
+        console.log('</unlocks>');
+        console.log();
+    }
+    // Closing tag
+    console.log('</artifact>');
+}
+// -----------------------------------------------------------------------------
+// Apply Instructions Command
+// -----------------------------------------------------------------------------
+/**
+ * Parses tasks.md content and extracts task items with their completion status.
+ */
+function parseTasksFile(content) {
+    const tasks = [];
+    const lines = content.split('\n');
+    let taskIndex = 0;
+    for (const line of lines) {
+        // Match checkbox patterns: - [ ] or - [x] or - [X]
+        const checkboxMatch = line.match(/^[-*]\s*\[([ xX])\]\s*(.+)\s*$/);
+        if (checkboxMatch) {
+            taskIndex++;
+            const done = checkboxMatch[1].toLowerCase() === 'x';
+            const description = checkboxMatch[2].trim();
+            tasks.push({
+                id: `${taskIndex}`,
+                description,
+                done,
+            });
+        }
+    }
+    return tasks;
+}
+/**
+ * Generates apply instructions for implementing tasks from a change.
+ * Schema-aware: reads apply phase configuration from schema to determine
+ * required artifacts, tracking file, and instruction.
+ */
+export async function generateApplyInstructions(projectRoot, changeName, schemaName, options = {}) {
+    const planningHome = options.planningHome ?? resolveCurrentPlanningHomeSync({ startPath: projectRoot });
+    const references = options.references;
+    // loadChangeContext will auto-detect schema from metadata if not provided
+    const context = loadChangeContext(projectRoot, changeName, schemaName, {
+        changeDir: getChangeDir(planningHome, changeName),
+        planningHome,
+    });
+    const changeDir = context.changeDir;
+    // Get the full schema to access the apply phase configuration
+    const schema = resolveSchema(context.schemaName, projectRoot);
+    const applyConfig = schema.apply;
+    // Determine required artifacts and tracking file from schema
+    // Fallback: if no apply block, require all artifacts
+    const requiredArtifactIds = applyConfig?.requires ?? schema.artifacts.map((a) => a.id);
+    const tracksFile = applyConfig?.tracks ?? null;
+    const schemaInstruction = applyConfig?.instruction ?? null;
+    // Check which required artifacts are missing
+    const missingArtifacts = [];
+    for (const artifactId of requiredArtifactIds) {
+        const artifact = schema.artifacts.find((a) => a.id === artifactId);
+        if (artifact && resolveArtifactOutputs(changeDir, artifact.generates).length === 0) {
+            missingArtifacts.push(artifactId);
+        }
+    }
+    // Build context files from all existing artifacts in schema
+    const contextFiles = {};
+    for (const artifact of schema.artifacts) {
+        const outputs = resolveArtifactOutputs(changeDir, artifact.generates);
+        if (outputs.length > 0) {
+            contextFiles[artifact.id] = outputs;
+        }
+    }
+    // Parse tasks if tracking file exists
+    let tasks = [];
+    let tracksFileExists = false;
+    if (tracksFile) {
+        const tracksPath = path.join(changeDir, tracksFile);
+        tracksFileExists = fs.existsSync(tracksPath);
+        if (tracksFileExists) {
+            const tasksContent = await fs.promises.readFile(tracksPath, 'utf-8');
+            tasks = parseTasksFile(tasksContent);
+        }
+    }
+    // Calculate progress
+    const total = tasks.length;
+    const complete = tasks.filter((t) => t.done).length;
+    const remaining = total - complete;
+    // Determine state and instruction
+    let state;
+    let instruction;
+    if (missingArtifacts.length > 0) {
+        state = 'blocked';
+        instruction = `Cannot apply this change yet. Missing artifacts: ${missingArtifacts.join(', ')}.\nUse the openspec-continue-change skill to create the missing artifacts first.`;
+    }
+    else if (tracksFile && !tracksFileExists) {
+        // Tracking file configured but doesn't exist yet
+        const tracksFilename = path.basename(tracksFile);
+        state = 'blocked';
+        instruction = `The ${tracksFilename} file is missing and must be created.\nUse openspec-continue-change to generate the tracking file.`;
+    }
+    else if (tracksFile && tracksFileExists && total === 0) {
+        // Tracking file exists but contains no tasks
+        const tracksFilename = path.basename(tracksFile);
+        state = 'blocked';
+        instruction = `The ${tracksFilename} file exists but contains no tasks.\nAdd tasks to ${tracksFilename} or regenerate it with openspec-continue-change.`;
+    }
+    else if (tracksFile && remaining === 0 && total > 0) {
+        state = 'all_done';
+        instruction = 'All tasks are complete! This change is ready to be archived.\nConsider running tests and reviewing the changes before archiving.';
+    }
+    else if (!tracksFile) {
+        // No tracking file configured in schema - ready to apply
+        state = 'ready';
+        instruction = schemaInstruction?.trim() ?? 'All required artifacts complete. Proceed with implementation.';
+    }
+    else {
+        state = 'ready';
+        instruction = schemaInstruction?.trim() ?? 'Read context files, work through pending tasks, mark complete as you go.\nPause if you hit blockers or need clarification.';
+    }
+    let missingComprehension;
+    let comprehension;
+    if (state === 'ready') {
+        const specPaths = contextFiles.specs ?? [];
+        const tasksPath = tracksFile && tracksFileExists ? path.join(changeDir, tracksFile) : null;
+        const pendingTaskCount = tasks.filter((task) => !task.done).length;
+        const gate = checkComprehensionGate(changeDir, specPaths, options.projectConfig ?? readProjectConfig(projectRoot), { tasksPath, pendingTaskCount });
+        if (gate.active && !gate.passed && gate.info) {
+            state = 'blocked';
+            missingComprehension = true;
+            comprehension = gate.info;
+            instruction = `Complete the comprehension quiz in /opsx:apply before implementation (score ≥ ${gate.info.thresholdPercent}% on specs and tasks).`;
+        }
+        else if (gate.active && gate.info) {
+            comprehension = gate.info;
+        }
+    }
+    return {
+        changeName,
+        changeDir,
+        schemaName: context.schemaName,
+        contextFiles,
+        progress: { total, complete, remaining },
+        tasks,
+        state,
+        missingArtifacts: missingArtifacts.length > 0 ? missingArtifacts : undefined,
+        missingComprehension,
+        comprehension,
+        instruction,
+        ...(references !== undefined ? { references } : {}),
+    };
+}
+export async function applyInstructionsCommand(options) {
+    // Resolve (and banner) before the spinner starts so stderr stays readable.
+    const root = await resolveRootForCommand(options, { json: options.json });
+    if (!root) {
+        return;
+    }
+    const spinner = options.json ? undefined : ora('Generating apply instructions...').start();
+    try {
+        const planningHome = toPlanningHome(root);
+        const projectRoot = root.path;
+        const changeName = await validateChangeExists(options.change, projectRoot, root.changesDir, { newChangeHint: withStoreFlag(root, 'openspec new change <name>') });
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        const { projectConfig, references } = await loadRootConfigContext(root);
+        if (options.recordComprehensionPass) {
+            if (options.score === undefined) {
+                spinner?.stop();
+                throw new Error('--score is required with --record-comprehension-pass');
+            }
+            const context = loadChangeContext(projectRoot, changeName, options.schema, {
+                changeDir: getChangeDir(planningHome, changeName),
+                planningHome,
+            });
+            const changeDir = context.changeDir;
+            const schema = resolveSchema(context.schemaName, projectRoot);
+            const specPaths = [];
+            const specsArtifact = schema.artifacts.find((a) => a.id === 'specs');
+            if (specsArtifact) {
+                specPaths.push(...resolveArtifactOutputs(changeDir, specsArtifact.generates));
+            }
+            const tracksFile = schema.apply?.tracks ?? null;
+            const tasksPath = tracksFile ? path.join(changeDir, tracksFile) : null;
+            try {
+                const record = recordComprehensionPass({
+                    changeDir,
+                    specPaths,
+                    tasksPath,
+                    projectConfig,
+                    scorePercent: options.score,
+                    attempt: options.attempt ?? 1,
+                    questionCount: options.questionCount ?? 0,
+                });
+                spinner?.stop();
+                if (options.json) {
+                    const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
+                        planningHome,
+                        references,
+                        projectConfig,
+                    });
+                    console.log(JSON.stringify({
+                        recorded: true,
+                        comprehensionPass: record,
+                        ...instructions,
+                        root: toRootOutput(root),
+                    }, null, 2));
+                    return;
+                }
+                console.log(`Comprehension pass recorded (${record.score_percent}%).`);
+                const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
+                    planningHome,
+                    references,
+                    projectConfig,
+                });
+                printApplyInstructionsText(instructions);
+                return;
+            }
+            catch (error) {
+                spinner?.stop();
+                if (error instanceof ComprehensionPassError) {
+                    if (options.json) {
+                        console.log(JSON.stringify({
+                            recorded: false,
+                            status: [
+                                {
+                                    severity: 'error',
+                                    code: 'comprehension_score_below_threshold',
+                                    message: error.message,
+                                },
+                            ],
+                            root: toRootOutput(root),
+                        }, null, 2));
+                        process.exitCode = 1;
+                        return;
+                    }
+                }
+                throw error;
+            }
+        }
+        // generateApplyInstructions uses loadChangeContext which auto-detects schema
+        const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema, {
+            planningHome,
+            references,
+            projectConfig,
+        });
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ ...instructions, root: toRootOutput(root) }, null, 2));
+            return;
+        }
+        printApplyInstructionsText(instructions);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printApplyInstructionsText(instructions) {
+    const { changeName, schemaName, contextFiles, progress, tasks, state, missingArtifacts, missingComprehension, comprehension, instruction, } = instructions;
+    console.log(`## Apply: ${changeName}`);
+    console.log(`Schema: ${schemaName}`);
+    console.log();
+    if (instructions.references && instructions.references.length > 0) {
+        console.log(renderReferencedStoresSection(instructions.references));
+        console.log();
+    }
+    // Warning for blocked state
+    if (state === 'blocked' && missingArtifacts) {
+        console.log('### ⚠️ Blocked');
+        console.log();
+        console.log(`Missing artifacts: ${missingArtifacts.join(', ')}`);
+        console.log('Use the openspec-continue-change skill to create these first.');
+        console.log();
+    }
+    if (state === 'blocked' && missingComprehension && comprehension) {
+        console.log('### ⚠️ Comprehension Required');
+        console.log();
+        console.log(`Pass the spec and task comprehension quiz (score ≥ ${comprehension.thresholdPercent}%) before implementation.`);
+        console.log(`Questions: ${comprehension.questionCount}`);
+        console.log(`Specs: ${comprehension.requirementCount} requirements, ${comprehension.scenarioCount} scenarios; Tasks: ${comprehension.pendingTaskCount} pending`);
+        if (comprehension.bestScorePercent !== undefined) {
+            console.log(`Previous score: ${comprehension.bestScorePercent}% (specs changed — retake required)`);
+        }
+        console.log('Complete the quiz via /opsx:apply.');
+        console.log();
+    }
+    // Context files (dynamically from schema)
+    const contextFileEntries = Object.entries(contextFiles);
+    if (contextFileEntries.length > 0) {
+        console.log('### Context Files');
+        for (const [artifactId, filePaths] of contextFileEntries) {
+            for (const filePath of filePaths) {
+                console.log(`- ${artifactId}: ${filePath}`);
+            }
+        }
+        console.log();
+    }
+    // Progress (only show if we have tracking)
+    if (progress.total > 0 || tasks.length > 0) {
+        console.log('### Progress');
+        if (state === 'all_done') {
+            console.log(`${progress.complete}/${progress.total} complete ✓`);
+        }
+        else {
+            console.log(`${progress.complete}/${progress.total} complete`);
+        }
+        console.log();
+    }
+    // Tasks
+    if (tasks.length > 0) {
+        console.log('### Tasks');
+        for (const task of tasks) {
+            const checkbox = task.done ? '[x]' : '[ ]';
+            console.log(`- ${checkbox} ${task.description}`);
+        }
+        console.log();
+    }
+    // Instruction
+    console.log('### Instruction');
+    console.log(instruction);
+}
+//# sourceMappingURL=instructions.js.map

package/dist/commands/workflow/new-change.d.ts

@@ -0,0 +1,20 @@
+/**
+ * New Change Command
+ *
+ * Creates a new change directory with optional description and schema in the
+ * resolved OpenSpec root. `--store <id>` selects a registered store's
+ * root; initiative linking and workspace affected areas are no longer part of
+ * this command.
+ */
+export interface NewChangeOptions {
+    description?: string;
+    goal?: string;
+    schema?: string;
+    store?: string;
+    storePath?: string;
+    initiative?: string;
+    areas?: string;
+    json?: boolean;
+}
+export declare function newChangeCommand(name: string | undefined, options: NewChangeOptions): Promise<void>;
+//# sourceMappingURL=new-change.d.ts.map

package/dist/commands/workflow/new-change.js

@@ -0,0 +1,106 @@
+/**
+ * New Change Command
+ *
+ * Creates a new change directory with optional description and schema in the
+ * resolved OpenSpec root. `--store <id>` selects a registered store's
+ * root; initiative linking and workspace affected areas are no longer part of
+ * this command.
+ */
+import ora from 'ora';
+import path from 'path';
+import { createChange, validateChangeName } from '../../utils/change-utils.js';
+import { formatChangeLocation } from '../../core/planning-home.js';
+import { resolveRootForCommand, RootSelectionError, toPlanningHome, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../../core/root-selection.js';
+import { printJson, statusFromError, validateSchemaExists } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+function assertRemovedOptionsAbsent(options) {
+    if (options.initiative !== undefined) {
+        throw new RootSelectionError('--initiative is no longer supported. Normal changes no longer attach to initiatives; --store <id> selects the OpenSpec root.', 'initiative_option_removed', { target: 'change.options' });
+    }
+    if (options.areas !== undefined) {
+        throw new RootSelectionError('--areas is no longer supported. Workspace affected areas are not part of the normal OpenSpec root path.', 'areas_option_removed', { target: 'change.options' });
+    }
+}
+function printCreatedChangeHuman(payload, root) {
+    // A relative path is only honest when the root is where the user
+    // stands; a distant ancestor root gets the absolute path.
+    const location = !isStoreSelectedRoot(root) && root.path === process.cwd()
+        ? formatChangeLocation(toPlanningHome(root), payload.change.id)
+        : payload.change.path;
+    console.log(`Created change '${payload.change.id}' at ${location}/`);
+    console.log(`Schema: ${payload.change.schema}`);
+    console.log(`Next: ${withStoreFlag(root, `openspec status --change ${payload.change.id}`)}`);
+}
+export async function newChangeCommand(name, options) {
+    const spinner = options.json ? undefined : ora();
+    try {
+        if (!name) {
+            throw new Error('Missing required argument <name>');
+        }
+        const validation = validateChangeName(name);
+        if (!validation.valid) {
+            throw new Error(validation.error);
+        }
+        assertRemovedOptionsAbsent(options);
+        const root = await resolveRootForCommand(options, {
+            json: options.json,
+            failurePayload: { change: null },
+        });
+        if (!root) {
+            return;
+        }
+        const projectRoot = root.path;
+        // Validate schema if provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        const resolvedSchema = options.schema ?? root.defaultSchema;
+        if (spinner) {
+            spinner.start(`Creating change '${name}' with schema '${resolvedSchema}'...`);
+        }
+        const result = await createChange(projectRoot, name, {
+            schema: options.schema,
+            defaultSchema: root.defaultSchema,
+            changesDir: root.changesDir,
+            metadata: {
+                ...(options.goal ? { goal: options.goal } : {}),
+            },
+        });
+        // If description provided, create README.md with description
+        if (options.description) {
+            const { promises: fs } = await import('fs');
+            const readmePath = path.join(result.changeDir, 'README.md');
+            await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
+        }
+        const payload = {
+            change: {
+                id: name,
+                path: result.changeDir,
+                metadataPath: path.join(result.changeDir, '.openspec.yaml'),
+                schema: result.schema,
+            },
+            root: toRootOutput(root),
+        };
+        if (options.json) {
+            printJson(payload);
+            return;
+        }
+        spinner?.stop();
+        printCreatedChangeHuman(payload, root);
+    }
+    catch (error) {
+        spinner?.stop();
+        if (options.json) {
+            printJson({
+                change: null,
+                status: [statusFromError(error)],
+            });
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=new-change.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Schemas Command
+ *
+ * Lists available workflow schemas with descriptions.
+ */
+export interface SchemasOptions {
+    json?: boolean;
+}
+export declare function schemasCommand(options: SchemasOptions): Promise<void>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/commands/workflow/schemas.js

@@ -0,0 +1,34 @@
+/**
+ * Schemas Command
+ *
+ * Lists available workflow schemas with descriptions.
+ */
+import chalk from 'chalk';
+import { listSchemasWithInfo } from '../../core/artifact-graph/index.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function schemasCommand(options) {
+    const projectRoot = process.cwd();
+    const schemas = listSchemasWithInfo(projectRoot);
+    if (options.json) {
+        console.log(JSON.stringify(schemas, null, 2));
+        return;
+    }
+    console.log('Available schemas:');
+    console.log();
+    for (const schema of schemas) {
+        let sourceLabel = '';
+        if (schema.source === 'project') {
+            sourceLabel = chalk.cyan(' (project)');
+        }
+        else if (schema.source === 'user') {
+            sourceLabel = chalk.dim(' (user override)');
+        }
+        console.log(`  ${chalk.bold(schema.name)}${sourceLabel}`);
+        console.log(`    ${schema.description}`);
+        console.log(`    Artifacts: ${schema.artifacts.join(' → ')}`);
+        console.log();
+    }
+}
+//# sourceMappingURL=schemas.js.map