synarcx 0.1.0

package/dist/commands/validate.js

@@ -0,0 +1,295 @@
+import ora from 'ora';
+import path from 'path';
+import { Validator } from '../core/validation/validator.js';
+import { isInteractive, resolveNoInteractive } from '../utils/interactive.js';
+import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
+import { nearestMatches } from '../utils/match.js';
+import { SYNSPEC_DIR_NAME } from '../core/config.js';
+export class ValidateCommand {
+    async execute(itemName, options = {}) {
+        const interactive = isInteractive(options);
+        // Handle bulk flags first
+        if (options.all || options.changes || options.specs) {
+            await this.runBulkValidation({
+                changes: !!options.all || !!options.changes,
+                specs: !!options.all || !!options.specs,
+            }, { strict: !!options.strict, json: !!options.json, concurrency: options.concurrency, noInteractive: resolveNoInteractive(options) });
+            return;
+        }
+        // No item and no flags
+        if (!itemName) {
+            if (interactive) {
+                await this.runInteractiveSelector({ strict: !!options.strict, json: !!options.json, concurrency: options.concurrency });
+                return;
+            }
+            this.printNonInteractiveHint();
+            process.exitCode = 1;
+            return;
+        }
+        // Direct item validation with type detection or override
+        const typeOverride = this.normalizeType(options.type);
+        await this.validateDirectItem(itemName, { typeOverride, strict: !!options.strict, json: !!options.json });
+    }
+    normalizeType(value) {
+        if (!value)
+            return undefined;
+        const v = value.toLowerCase();
+        if (v === 'change' || v === 'spec')
+            return v;
+        return undefined;
+    }
+    async runInteractiveSelector(opts) {
+        const { select } = await import('@inquirer/prompts');
+        const choice = await select({
+            message: 'What would you like to validate?',
+            choices: [
+                { name: 'All (changes + specs)', value: 'all' },
+                { name: 'All changes', value: 'changes' },
+                { name: 'All specs', value: 'specs' },
+                { name: 'Pick a specific change or spec', value: 'one' },
+            ],
+        });
+        if (choice === 'all')
+            return this.runBulkValidation({ changes: true, specs: true }, opts);
+        if (choice === 'changes')
+            return this.runBulkValidation({ changes: true, specs: false }, opts);
+        if (choice === 'specs')
+            return this.runBulkValidation({ changes: false, specs: true }, opts);
+        // one
+        const [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
+        const items = [];
+        items.push(...changes.map(id => ({ name: `change/${id}`, value: { type: 'change', id } })));
+        items.push(...specs.map(id => ({ name: `spec/${id}`, value: { type: 'spec', id } })));
+        if (items.length === 0) {
+            console.error('No items found to validate.');
+            process.exitCode = 1;
+            return;
+        }
+        const picked = await select({ message: 'Pick an item', choices: items });
+        await this.validateByType(picked.type, picked.id, opts);
+    }
+    printNonInteractiveHint() {
+        console.error('Nothing to validate. Try one of:');
+        console.error('  synarcx validate --all');
+        console.error('  synarcx validate --changes');
+        console.error('  synarcx validate --specs');
+        console.error('  synarcx validate <item-name>');
+        console.error('Or run in an interactive terminal.');
+    }
+    async validateDirectItem(itemName, opts) {
+        const [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
+        const isChange = changes.includes(itemName);
+        const isSpec = specs.includes(itemName);
+        const type = opts.typeOverride ?? (isChange ? 'change' : isSpec ? 'spec' : undefined);
+        if (!type) {
+            console.error(`Unknown item '${itemName}'`);
+            const suggestions = nearestMatches(itemName, [...changes, ...specs]);
+            if (suggestions.length)
+                console.error(`Did you mean: ${suggestions.join(', ')}?`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!opts.typeOverride && isChange && isSpec) {
+            console.error(`Ambiguous item '${itemName}' matches both a change and a spec.`);
+            console.error('Pass --type change|spec, or use: synarcx change validate / synarcx spec validate');
+            process.exitCode = 1;
+            return;
+        }
+        await this.validateByType(type, itemName, opts);
+    }
+    async validateByType(type, id, opts) {
+        const validator = new Validator(opts.strict);
+        if (type === 'change') {
+            const changeDir = path.join(process.cwd(), SYNSPEC_DIR_NAME, 'changes', id);
+            const start = Date.now();
+            const report = await validator.validateChangeDeltaSpecs(changeDir);
+            const durationMs = Date.now() - start;
+            this.printReport('change', id, report, durationMs, opts.json);
+            // Non-zero exit if invalid (keeps enriched output test semantics)
+            process.exitCode = report.valid ? 0 : 1;
+            return;
+        }
+        const file = path.join(process.cwd(), SYNSPEC_DIR_NAME, 'specs', id, 'spec.md');
+        const start = Date.now();
+        const report = await validator.validateSpec(file);
+        const durationMs = Date.now() - start;
+        this.printReport('spec', id, report, durationMs, opts.json);
+        process.exitCode = report.valid ? 0 : 1;
+    }
+    printReport(type, id, report, durationMs, json) {
+        if (json) {
+            const out = { items: [{ id, type, valid: report.valid, issues: report.issues, durationMs }], summary: { totals: { items: 1, passed: report.valid ? 1 : 0, failed: report.valid ? 0 : 1 }, byType: { [type]: { items: 1, passed: report.valid ? 1 : 0, failed: report.valid ? 0 : 1 } } }, version: '1.0' };
+            console.log(JSON.stringify(out, null, 2));
+            return;
+        }
+        if (report.valid) {
+            console.log(`${type === 'change' ? 'Change' : 'Specification'} '${id}' is valid`);
+        }
+        else {
+            console.error(`${type === 'change' ? 'Change' : 'Specification'} '${id}' has issues`);
+            for (const issue of report.issues) {
+                const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
+                const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+                console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
+            }
+            this.printNextSteps(type);
+        }
+    }
+    printNextSteps(type) {
+        const bullets = [];
+        if (type === 'change') {
+            bullets.push('- Ensure change has deltas in specs/: use headers ## ADDED/MODIFIED/REMOVED/RENAMED Requirements');
+            bullets.push('- Each requirement MUST include at least one #### Scenario: block');
+            bullets.push('- Debug parsed deltas: synarcx change show <id> --json --deltas-only');
+        }
+        else {
+            bullets.push('- Ensure spec includes ## Purpose and ## Requirements sections');
+            bullets.push('- Each requirement MUST include at least one #### Scenario: block');
+            bullets.push('- Re-run with --json to see structured report');
+        }
+        console.error('Next steps:');
+        bullets.forEach(b => console.error(`  ${b}`));
+    }
+    async runBulkValidation(scope, opts) {
+        const spinner = !opts.json && !opts.noInteractive ? ora('Validating...').start() : undefined;
+        const [changeIds, specIds] = await Promise.all([
+            scope.changes ? getActiveChangeIds() : Promise.resolve([]),
+            scope.specs ? getSpecIds() : Promise.resolve([]),
+        ]);
+        const DEFAULT_CONCURRENCY = 6;
+        const maxSuggestions = 5; // used by nearestMatches
+        const concurrency = normalizeConcurrency(opts.concurrency) ?? normalizeConcurrency(process.env.SYNARCX_CONCURRENCY) ?? DEFAULT_CONCURRENCY;
+        const validator = new Validator(opts.strict);
+        const queue = [];
+        for (const id of changeIds) {
+            queue.push(async () => {
+                const start = Date.now();
+                const changeDir = path.join(process.cwd(), SYNSPEC_DIR_NAME, 'changes', id);
+                const report = await validator.validateChangeDeltaSpecs(changeDir);
+                const durationMs = Date.now() - start;
+                return { id, type: 'change', valid: report.valid, issues: report.issues, durationMs };
+            });
+        }
+        for (const id of specIds) {
+            queue.push(async () => {
+                const start = Date.now();
+                const file = path.join(process.cwd(), SYNSPEC_DIR_NAME, 'specs', id, 'spec.md');
+                const report = await validator.validateSpec(file);
+                const durationMs = Date.now() - start;
+                return { id, type: 'spec', valid: report.valid, issues: report.issues, durationMs };
+            });
+        }
+        if (queue.length === 0) {
+            spinner?.stop();
+            const summary = {
+                totals: { items: 0, passed: 0, failed: 0 },
+                byType: {
+                    ...(scope.changes ? { change: { items: 0, passed: 0, failed: 0 } } : {}),
+                    ...(scope.specs ? { spec: { items: 0, passed: 0, failed: 0 } } : {}),
+                },
+            };
+            if (opts.json) {
+                const out = { items: [], summary, version: '1.0' };
+                console.log(JSON.stringify(out, null, 2));
+            }
+            else {
+                console.log('No items found to validate.');
+            }
+            process.exitCode = 0;
+            return;
+        }
+        const results = [];
+        let index = 0;
+        let running = 0;
+        let passed = 0;
+        let failed = 0;
+        await new Promise((resolve) => {
+            const next = () => {
+                while (running < concurrency && index < queue.length) {
+                    const currentIndex = index++;
+                    const task = queue[currentIndex];
+                    running++;
+                    if (spinner)
+                        spinner.text = `Validating (${currentIndex + 1}/${queue.length})...`;
+                    task()
+                        .then(res => {
+                        results.push(res);
+                        if (res.valid)
+                            passed++;
+                        else
+                            failed++;
+                    })
+                        .catch((error) => {
+                        const message = error?.message || 'Unknown error';
+                        const res = { id: getPlannedId(currentIndex, changeIds, specIds) ?? 'unknown', type: getPlannedType(currentIndex, changeIds, specIds) ?? 'change', valid: false, issues: [{ level: 'ERROR', path: 'file', message }], durationMs: 0 };
+                        results.push(res);
+                        failed++;
+                    })
+                        .finally(() => {
+                        running--;
+                        if (index >= queue.length && running === 0)
+                            resolve();
+                        else
+                            next();
+                    });
+                }
+            };
+            next();
+        });
+        spinner?.stop();
+        results.sort((a, b) => a.id.localeCompare(b.id));
+        const summary = {
+            totals: { items: results.length, passed, failed },
+            byType: {
+                ...(scope.changes ? { change: summarizeType(results, 'change') } : {}),
+                ...(scope.specs ? { spec: summarizeType(results, 'spec') } : {}),
+            },
+        };
+        if (opts.json) {
+            const out = { items: results, summary, version: '1.0' };
+            console.log(JSON.stringify(out, null, 2));
+        }
+        else {
+            for (const res of results) {
+                if (res.valid)
+                    console.log(`✓ ${res.type}/${res.id}`);
+                else
+                    console.error(`✗ ${res.type}/${res.id}`);
+            }
+            console.log(`Totals: ${summary.totals.passed} passed, ${summary.totals.failed} failed (${summary.totals.items} items)`);
+        }
+        process.exitCode = failed > 0 ? 1 : 0;
+    }
+}
+function summarizeType(results, type) {
+    const filtered = results.filter(r => r.type === type);
+    const items = filtered.length;
+    const passed = filtered.filter(r => r.valid).length;
+    const failed = items - passed;
+    return { items, passed, failed };
+}
+function normalizeConcurrency(value) {
+    if (!value)
+        return undefined;
+    const n = parseInt(value, 10);
+    if (Number.isNaN(n) || n <= 0)
+        return undefined;
+    return n;
+}
+function getPlannedId(index, changeIds, specIds) {
+    const totalChanges = changeIds.length;
+    if (index < totalChanges)
+        return changeIds[index];
+    const specIndex = index - totalChanges;
+    return specIds[specIndex];
+}
+function getPlannedType(index, changeIds, specIds) {
+    const totalChanges = changeIds.length;
+    if (index < totalChanges)
+        return 'change';
+    const specIndex = index - totalChanges;
+    if (specIndex >= 0 && specIndex < specIds.length)
+        return 'spec';
+    return undefined;
+}
+//# sourceMappingURL=validate.js.map

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

@@ -0,0 +1,17 @@
+/**
+ * Workflow CLI Commands
+ *
+ * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
+ */
+export { statusCommand } from './status.js';
+export type { StatusOptions } from './status.js';
+export { instructionsCommand, applyInstructionsCommand } from './instructions.js';
+export type { InstructionsOptions } from './instructions.js';
+export { templatesCommand } from './templates.js';
+export type { TemplatesOptions } from './templates.js';
+export { schemasCommand } from './schemas.js';
+export type { SchemasOptions } from './schemas.js';
+export { newChangeCommand } from './new-change.js';
+export type { NewChangeOptions } from './new-change.js';
+export { DEFAULT_SCHEMA } from './shared.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.js

@@ -0,0 +1,12 @@
+/**
+ * Workflow CLI Commands
+ *
+ * Commands for the artifact-driven workflow: status, instructions, templates, schemas, new change.
+ */
+export { statusCommand } from './status.js';
+export { instructionsCommand, applyInstructionsCommand } from './instructions.js';
+export { templatesCommand } from './templates.js';
+export { schemasCommand } from './schemas.js';
+export { newChangeCommand } from './new-change.js';
+export { DEFAULT_SCHEMA } from './shared.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,29 @@
+/**
+ * Instructions Command
+ *
+ * Generates enriched instructions for creating artifacts or applying tasks.
+ * Includes both artifact instructions and apply instructions.
+ */
+import { type ArtifactInstructions } from '../../core/artifact-graph/index.js';
+import { type ApplyInstructions } from './shared.js';
+export interface InstructionsOptions {
+    change?: string;
+    schema?: string;
+    json?: boolean;
+}
+export interface ApplyInstructionsOptions {
+    change?: string;
+    schema?: string;
+    json?: boolean;
+}
+export declare function instructionsCommand(artifactId: string | undefined, options: InstructionsOptions): Promise<void>;
+export declare function printInstructionsText(instructions: ArtifactInstructions, isBlocked: boolean): void;
+/**
+ * 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 declare function generateApplyInstructions(projectRoot: string, changeName: string, schemaName?: string): Promise<ApplyInstructions>;
+export declare function applyInstructionsCommand(options: ApplyInstructionsOptions): Promise<void>;
+export declare function printApplyInstructionsText(instructions: ApplyInstructions): void;
+//# sourceMappingURL=instructions.d.ts.map

package/dist/commands/workflow/instructions.js

@@ -0,0 +1,327 @@
+/**
+ * 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 { validateChangeExists, validateSchemaExists, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Artifact Instructions Command
+// -----------------------------------------------------------------------------
+export async function instructionsCommand(artifactId, options) {
+    const spinner = options.json ? undefined : ora('Generating instructions...').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);
+        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 instructions = generateInstructions(context, artifactId, projectRoot);
+        const isBlocked = instructions.dependencies.some((d) => !d.done);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(instructions, null, 2));
+            return;
+        }
+        printInstructionsText(instructions, isBlocked);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printInstructionsText(instructions, isBlocked) {
+    const { artifactId, changeName, schemaName, changeDir, outputPath, 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();
+    }
+    // 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: ${path.join(changeDir, outputPath)}`);
+    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) {
+    // loadChangeContext will auto-detect schema from metadata if not provided
+    const context = loadChangeContext(projectRoot, changeName, schemaName);
+    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 syn:propose command 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 /syn:propose 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 /syn:propose.`;
+    }
+    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.';
+    }
+    return {
+        changeName,
+        changeDir,
+        schemaName: context.schemaName,
+        contextFiles,
+        progress: { total, complete, remaining },
+        tasks,
+        state,
+        missingArtifacts: missingArtifacts.length > 0 ? missingArtifacts : undefined,
+        instruction,
+    };
+}
+export async function applyInstructionsCommand(options) {
+    const spinner = options.json ? undefined : ora('Generating apply instructions...').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);
+        }
+        // generateApplyInstructions uses loadChangeContext which auto-detects schema
+        const instructions = await generateApplyInstructions(projectRoot, changeName, options.schema);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(instructions, null, 2));
+            return;
+        }
+        printApplyInstructionsText(instructions);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printApplyInstructionsText(instructions) {
+    const { changeName, schemaName, contextFiles, progress, tasks, state, missingArtifacts, instruction } = instructions;
+    console.log(`## Apply: ${changeName}`);
+    console.log(`Schema: ${schemaName}`);
+    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 syn:propose command to create these first.');
+        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