@fission-ai/openspec 0.17.2 → 0.19.0

package/dist/core/global-config.js

@@ -4,6 +4,7 @@ import * as os from 'node:os';
 // Constants
 export const GLOBAL_CONFIG_DIR_NAME = 'openspec';
 export const GLOBAL_CONFIG_FILE_NAME = 'config.json';
+export const GLOBAL_DATA_DIR_NAME = 'openspec';
 const DEFAULT_CONFIG = {
     featureFlags: {}
 };
@@ -33,6 +34,33 @@ export function getGlobalConfigDir() {
     // Unix/macOS fallback: ~/.config
     return path.join(os.homedir(), '.config', GLOBAL_CONFIG_DIR_NAME);
 }
+/**
+ * Gets the global data directory path following XDG Base Directory Specification.
+ * Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/openspec/
+ * - Windows fallback: %LOCALAPPDATA%/openspec/
+ */
+export function getGlobalDataDir() {
+    // XDG_DATA_HOME takes precedence on all platforms when explicitly set
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+        return path.join(xdgDataHome, GLOBAL_DATA_DIR_NAME);
+    }
+    const platform = os.platform();
+    if (platform === 'win32') {
+        // Windows: use %LOCALAPPDATA%
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            return path.join(localAppData, GLOBAL_DATA_DIR_NAME);
+        }
+        // Fallback for Windows if LOCALAPPDATA is not set
+        return path.join(os.homedir(), 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.local/share
+    return path.join(os.homedir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
+}
 /**
  * Gets the path to the global config file.
  */

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig } from './global-config.js';
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,3 +1,3 @@
 // Core OpenSpec logic will be implemented here
-export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig } from './global-config.js';
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
 //# sourceMappingURL=index.js.map

package/dist/core/list.d.ts

@@ -1,4 +1,9 @@
+interface ListOptions {
+    sort?: 'recent' | 'name';
+    json?: boolean;
+}
 export declare class ListCommand {
-    execute(targetPath?: string, mode?: 'changes' | 'specs'): Promise<void>;
+    execute(targetPath?: string, mode?: 'changes' | 'specs', options?: ListOptions): Promise<void>;
 }
+export {};
 //# sourceMappingURL=list.d.ts.map

package/dist/core/list.js

@@ -4,8 +4,64 @@ import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progre
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import { MarkdownParser } from './parsers/markdown-parser.js';
+/**
+ * Get the most recent modification time of any file in a directory (recursive).
+ * Falls back to the directory's own mtime if no files are found.
+ */
+async function getLastModified(dirPath) {
+    let latest = null;
+    async function walk(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+            }
+            else {
+                const stat = await fs.stat(fullPath);
+                if (latest === null || stat.mtime > latest) {
+                    latest = stat.mtime;
+                }
+            }
+        }
+    }
+    await walk(dirPath);
+    // If no files found, use the directory's own modification time
+    if (latest === null) {
+        const dirStat = await fs.stat(dirPath);
+        return dirStat.mtime;
+    }
+    return latest;
+}
+/**
+ * Format a date as relative time (e.g., "2 hours ago", "3 days ago")
+ */
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffDays > 30) {
+        return date.toLocaleDateString();
+    }
+    else if (diffDays > 0) {
+        return `${diffDays}d ago`;
+    }
+    else if (diffHours > 0) {
+        return `${diffHours}h ago`;
+    }
+    else if (diffMins > 0) {
+        return `${diffMins}m ago`;
+    }
+    else {
+        return 'just now';
+    }
+}
 export class ListCommand {
-    async execute(targetPath = '.', mode = 'changes') {
+    async execute(targetPath = '.', mode = 'changes', options = {}) {
+        const { sort = 'recent', json = false } = options;
         if (mode === 'changes') {
             const changesDir = path.join(targetPath, 'openspec', 'changes');
             // Check if changes directory exists
@@ -21,21 +77,46 @@ export class ListCommand {
                 .filter(entry => entry.isDirectory() && entry.name !== 'archive')
                 .map(entry => entry.name);
             if (changeDirs.length === 0) {
-                console.log('No active changes found.');
+                if (json) {
+                    console.log(JSON.stringify({ changes: [] }));
+                }
+                else {
+                    console.log('No active changes found.');
+                }
                 return;
             }
             // Collect information about each change
             const changes = [];
             for (const changeDir of changeDirs) {
                 const progress = await getTaskProgressForChange(changesDir, changeDir);
+                const changePath = path.join(changesDir, changeDir);
+                const lastModified = await getLastModified(changePath);
                 changes.push({
                     name: changeDir,
                     completedTasks: progress.completed,
-                    totalTasks: progress.total
+                    totalTasks: progress.total,
+                    lastModified
                 });
             }
-            // Sort alphabetically by name
-            changes.sort((a, b) => a.name.localeCompare(b.name));
+            // Sort by preference (default: recent first)
+            if (sort === 'recent') {
+                changes.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+            }
+            else {
+                changes.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            // JSON output for programmatic use
+            if (json) {
+                const jsonOutput = changes.map(c => ({
+                    name: c.name,
+                    completedTasks: c.completedTasks,
+                    totalTasks: c.totalTasks,
+                    lastModified: c.lastModified.toISOString(),
+                    status: c.totalTasks === 0 ? 'no-tasks' : c.completedTasks === c.totalTasks ? 'complete' : 'in-progress'
+                }));
+                console.log(JSON.stringify({ changes: jsonOutput }, null, 2));
+                return;
+            }
             // Display results
             console.log('Changes:');
             const padding = '  ';
@@ -43,7 +124,8 @@ export class ListCommand {
             for (const change of changes) {
                 const paddedName = change.name.padEnd(nameWidth);
                 const status = formatTaskStatus({ total: change.totalTasks, completed: change.completedTasks });
-                console.log(`${padding}${paddedName}     ${status}`);
+                const timeAgo = formatRelativeTime(change.lastModified);
+                console.log(`${padding}${paddedName}     ${status.padEnd(12)}  ${timeAgo}`);
             }
             return;
         }

package/dist/core/specs-apply.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Spec Application Logic
+ *
+ * Extracted from ArchiveCommand to enable standalone spec application.
+ * Applies delta specs from a change to main specs without archiving.
+ */
+export interface SpecUpdate {
+    source: string;
+    target: string;
+    exists: boolean;
+}
+export interface ApplyResult {
+    capability: string;
+    added: number;
+    modified: number;
+    removed: number;
+    renamed: number;
+}
+export interface SpecsApplyOutput {
+    changeName: string;
+    capabilities: ApplyResult[];
+    totals: {
+        added: number;
+        modified: number;
+        removed: number;
+        renamed: number;
+    };
+    noChanges: boolean;
+}
+/**
+ * Find all delta spec files that need to be applied from a change.
+ */
+export declare function findSpecUpdates(changeDir: string, mainSpecsDir: string): Promise<SpecUpdate[]>;
+/**
+ * Build an updated spec by applying delta operations.
+ * Returns the rebuilt content and counts of operations.
+ */
+export declare function buildUpdatedSpec(update: SpecUpdate, changeName: string): Promise<{
+    rebuilt: string;
+    counts: {
+        added: number;
+        modified: number;
+        removed: number;
+        renamed: number;
+    };
+}>;
+/**
+ * Write an updated spec to disk.
+ */
+export declare function writeUpdatedSpec(update: SpecUpdate, rebuilt: string, counts: {
+    added: number;
+    modified: number;
+    removed: number;
+    renamed: number;
+}): Promise<void>;
+/**
+ * Build a skeleton spec for new capabilities.
+ */
+export declare function buildSpecSkeleton(specFolderName: string, changeName: string): string;
+/**
+ * Apply all delta specs from a change to main specs.
+ *
+ * @param projectRoot - The project root directory
+ * @param changeName - The name of the change to apply
+ * @param options - Options for the operation
+ * @returns Result of the operation with counts
+ */
+export declare function applySpecs(projectRoot: string, changeName: string, options?: {
+    dryRun?: boolean;
+    skipValidation?: boolean;
+    silent?: boolean;
+}): Promise<SpecsApplyOutput>;
+//# sourceMappingURL=specs-apply.d.ts.map

package/dist/core/specs-apply.js

@@ -0,0 +1,384 @@
+/**
+ * Spec Application Logic
+ *
+ * Extracted from ArchiveCommand to enable standalone spec application.
+ * Applies delta specs from a change to main specs without archiving.
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { extractRequirementsSection, parseDeltaSpec, normalizeRequirementName, } from './parsers/requirement-blocks.js';
+import { Validator } from './validation/validator.js';
+// -----------------------------------------------------------------------------
+// Public API
+// -----------------------------------------------------------------------------
+/**
+ * Find all delta spec files that need to be applied from a change.
+ */
+export async function findSpecUpdates(changeDir, mainSpecsDir) {
+    const updates = [];
+    const changeSpecsDir = path.join(changeDir, 'specs');
+    try {
+        const entries = await fs.readdir(changeSpecsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const specFile = path.join(changeSpecsDir, entry.name, 'spec.md');
+                const targetFile = path.join(mainSpecsDir, entry.name, 'spec.md');
+                try {
+                    await fs.access(specFile);
+                    // Check if target exists
+                    let exists = false;
+                    try {
+                        await fs.access(targetFile);
+                        exists = true;
+                    }
+                    catch {
+                        exists = false;
+                    }
+                    updates.push({
+                        source: specFile,
+                        target: targetFile,
+                        exists,
+                    });
+                }
+                catch {
+                    // Source spec doesn't exist, skip
+                }
+            }
+        }
+    }
+    catch {
+        // No specs directory in change
+    }
+    return updates;
+}
+/**
+ * Build an updated spec by applying delta operations.
+ * Returns the rebuilt content and counts of operations.
+ */
+export async function buildUpdatedSpec(update, changeName) {
+    // Read change spec content (delta-format expected)
+    const changeContent = await fs.readFile(update.source, 'utf-8');
+    // Parse deltas from the change spec file
+    const plan = parseDeltaSpec(changeContent);
+    const specName = path.basename(path.dirname(update.target));
+    // Pre-validate duplicates within sections
+    const addedNames = new Set();
+    for (const add of plan.added) {
+        const name = normalizeRequirementName(add.name);
+        if (addedNames.has(name)) {
+            throw new Error(`${specName} validation failed - duplicate requirement in ADDED for header "### Requirement: ${add.name}"`);
+        }
+        addedNames.add(name);
+    }
+    const modifiedNames = new Set();
+    for (const mod of plan.modified) {
+        const name = normalizeRequirementName(mod.name);
+        if (modifiedNames.has(name)) {
+            throw new Error(`${specName} validation failed - duplicate requirement in MODIFIED for header "### Requirement: ${mod.name}"`);
+        }
+        modifiedNames.add(name);
+    }
+    const removedNamesSet = new Set();
+    for (const rem of plan.removed) {
+        const name = normalizeRequirementName(rem);
+        if (removedNamesSet.has(name)) {
+            throw new Error(`${specName} validation failed - duplicate requirement in REMOVED for header "### Requirement: ${rem}"`);
+        }
+        removedNamesSet.add(name);
+    }
+    const renamedFromSet = new Set();
+    const renamedToSet = new Set();
+    for (const { from, to } of plan.renamed) {
+        const fromNorm = normalizeRequirementName(from);
+        const toNorm = normalizeRequirementName(to);
+        if (renamedFromSet.has(fromNorm)) {
+            throw new Error(`${specName} validation failed - duplicate FROM in RENAMED for header "### Requirement: ${from}"`);
+        }
+        if (renamedToSet.has(toNorm)) {
+            throw new Error(`${specName} validation failed - duplicate TO in RENAMED for header "### Requirement: ${to}"`);
+        }
+        renamedFromSet.add(fromNorm);
+        renamedToSet.add(toNorm);
+    }
+    // Pre-validate cross-section conflicts
+    const conflicts = [];
+    for (const n of modifiedNames) {
+        if (removedNamesSet.has(n))
+            conflicts.push({ name: n, a: 'MODIFIED', b: 'REMOVED' });
+        if (addedNames.has(n))
+            conflicts.push({ name: n, a: 'MODIFIED', b: 'ADDED' });
+    }
+    for (const n of addedNames) {
+        if (removedNamesSet.has(n))
+            conflicts.push({ name: n, a: 'ADDED', b: 'REMOVED' });
+    }
+    // Renamed interplay: MODIFIED must reference the NEW header, not FROM
+    for (const { from, to } of plan.renamed) {
+        const fromNorm = normalizeRequirementName(from);
+        const toNorm = normalizeRequirementName(to);
+        if (modifiedNames.has(fromNorm)) {
+            throw new Error(`${specName} validation failed - when a rename exists, MODIFIED must reference the NEW header "### Requirement: ${to}"`);
+        }
+        // Detect ADDED colliding with a RENAMED TO
+        if (addedNames.has(toNorm)) {
+            throw new Error(`${specName} validation failed - RENAMED TO header collides with ADDED for "### Requirement: ${to}"`);
+        }
+    }
+    if (conflicts.length > 0) {
+        const c = conflicts[0];
+        throw new Error(`${specName} validation failed - requirement present in multiple sections (${c.a} and ${c.b}) for header "### Requirement: ${c.name}"`);
+    }
+    const hasAnyDelta = plan.added.length + plan.modified.length + plan.removed.length + plan.renamed.length > 0;
+    if (!hasAnyDelta) {
+        throw new Error(`Delta parsing found no operations for ${path.basename(path.dirname(update.source))}. ` +
+            `Provide ADDED/MODIFIED/REMOVED/RENAMED sections in change spec.`);
+    }
+    // Load or create base target content
+    let targetContent;
+    let isNewSpec = false;
+    try {
+        targetContent = await fs.readFile(update.target, 'utf-8');
+    }
+    catch {
+        // Target spec does not exist; MODIFIED and RENAMED are not allowed for new specs
+        // REMOVED will be ignored with a warning since there's nothing to remove
+        if (plan.modified.length > 0 || plan.renamed.length > 0) {
+            throw new Error(`${specName}: target spec does not exist; only ADDED requirements are allowed for new specs. MODIFIED and RENAMED operations require an existing spec.`);
+        }
+        // Warn about REMOVED requirements being ignored for new specs
+        if (plan.removed.length > 0) {
+            console.log(chalk.yellow(`⚠️  Warning: ${specName} - ${plan.removed.length} REMOVED requirement(s) ignored for new spec (nothing to remove).`));
+        }
+        isNewSpec = true;
+        targetContent = buildSpecSkeleton(specName, changeName);
+    }
+    // Extract requirements section and build name->block map
+    const parts = extractRequirementsSection(targetContent);
+    const nameToBlock = new Map();
+    for (const block of parts.bodyBlocks) {
+        nameToBlock.set(normalizeRequirementName(block.name), block);
+    }
+    // Apply operations in order: RENAMED → REMOVED → MODIFIED → ADDED
+    // RENAMED
+    for (const r of plan.renamed) {
+        const from = normalizeRequirementName(r.from);
+        const to = normalizeRequirementName(r.to);
+        if (!nameToBlock.has(from)) {
+            throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.from}" - source not found`);
+        }
+        if (nameToBlock.has(to)) {
+            throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.to}" - target already exists`);
+        }
+        const block = nameToBlock.get(from);
+        const newHeader = `### Requirement: ${to}`;
+        const rawLines = block.raw.split('\n');
+        rawLines[0] = newHeader;
+        const renamedBlock = {
+            headerLine: newHeader,
+            name: to,
+            raw: rawLines.join('\n'),
+        };
+        nameToBlock.delete(from);
+        nameToBlock.set(to, renamedBlock);
+    }
+    // REMOVED
+    for (const name of plan.removed) {
+        const key = normalizeRequirementName(name);
+        if (!nameToBlock.has(key)) {
+            // For new specs, REMOVED requirements are already warned about and ignored
+            // For existing specs, missing requirements are an error
+            if (!isNewSpec) {
+                throw new Error(`${specName} REMOVED failed for header "### Requirement: ${name}" - not found`);
+            }
+            // Skip removal for new specs (already warned above)
+            continue;
+        }
+        nameToBlock.delete(key);
+    }
+    // MODIFIED
+    for (const mod of plan.modified) {
+        const key = normalizeRequirementName(mod.name);
+        if (!nameToBlock.has(key)) {
+            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - not found`);
+        }
+        // Replace block with provided raw (ensure header line matches key)
+        const modHeaderMatch = mod.raw.split('\n')[0].match(/^###\s*Requirement:\s*(.+)\s*$/);
+        if (!modHeaderMatch || normalizeRequirementName(modHeaderMatch[1]) !== key) {
+            throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - header mismatch in content`);
+        }
+        nameToBlock.set(key, mod);
+    }
+    // ADDED
+    for (const add of plan.added) {
+        const key = normalizeRequirementName(add.name);
+        if (nameToBlock.has(key)) {
+            throw new Error(`${specName} ADDED failed for header "### Requirement: ${add.name}" - already exists`);
+        }
+        nameToBlock.set(key, add);
+    }
+    // Duplicates within resulting map are implicitly prevented by key uniqueness.
+    // Recompose requirements section preserving original ordering where possible
+    const keptOrder = [];
+    const seen = new Set();
+    for (const block of parts.bodyBlocks) {
+        const key = normalizeRequirementName(block.name);
+        const replacement = nameToBlock.get(key);
+        if (replacement) {
+            keptOrder.push(replacement);
+            seen.add(key);
+        }
+    }
+    // Append any newly added that were not in original order
+    for (const [key, block] of nameToBlock.entries()) {
+        if (!seen.has(key)) {
+            keptOrder.push(block);
+        }
+    }
+    const reqBody = [parts.preamble && parts.preamble.trim() ? parts.preamble.trimEnd() : '']
+        .filter(Boolean)
+        .concat(keptOrder.map((b) => b.raw))
+        .join('\n\n')
+        .trimEnd();
+    const rebuilt = [parts.before.trimEnd(), parts.headerLine, reqBody, parts.after]
+        .filter((s, idx) => !(idx === 0 && s === ''))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n');
+    return {
+        rebuilt,
+        counts: {
+            added: plan.added.length,
+            modified: plan.modified.length,
+            removed: plan.removed.length,
+            renamed: plan.renamed.length,
+        },
+    };
+}
+/**
+ * Write an updated spec to disk.
+ */
+export async function writeUpdatedSpec(update, rebuilt, counts) {
+    // Create target directory if needed
+    const targetDir = path.dirname(update.target);
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.writeFile(update.target, rebuilt);
+    const specName = path.basename(path.dirname(update.target));
+    console.log(`Applying changes to openspec/specs/${specName}/spec.md:`);
+    if (counts.added)
+        console.log(`  + ${counts.added} added`);
+    if (counts.modified)
+        console.log(`  ~ ${counts.modified} modified`);
+    if (counts.removed)
+        console.log(`  - ${counts.removed} removed`);
+    if (counts.renamed)
+        console.log(`  → ${counts.renamed} renamed`);
+}
+/**
+ * Build a skeleton spec for new capabilities.
+ */
+export function buildSpecSkeleton(specFolderName, changeName) {
+    const titleBase = specFolderName;
+    return `# ${titleBase} Specification\n\n## Purpose\nTBD - created by archiving change ${changeName}. Update Purpose after archive.\n\n## Requirements\n`;
+}
+/**
+ * Apply all delta specs from a change to main specs.
+ *
+ * @param projectRoot - The project root directory
+ * @param changeName - The name of the change to apply
+ * @param options - Options for the operation
+ * @returns Result of the operation with counts
+ */
+export async function applySpecs(projectRoot, changeName, options = {}) {
+    const changeDir = path.join(projectRoot, 'openspec', 'changes', changeName);
+    const mainSpecsDir = path.join(projectRoot, 'openspec', 'specs');
+    // 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.`);
+    }
+    // Find specs to update
+    const specUpdates = await findSpecUpdates(changeDir, mainSpecsDir);
+    if (specUpdates.length === 0) {
+        return {
+            changeName,
+            capabilities: [],
+            totals: { added: 0, modified: 0, removed: 0, renamed: 0 },
+            noChanges: true,
+        };
+    }
+    // Prepare all updates first (validation pass, no writes)
+    const prepared = [];
+    for (const update of specUpdates) {
+        const built = await buildUpdatedSpec(update, changeName);
+        prepared.push({ update, rebuilt: built.rebuilt, counts: built.counts });
+    }
+    // Validate rebuilt specs unless validation is skipped
+    if (!options.skipValidation) {
+        const validator = new Validator();
+        for (const p of prepared) {
+            const specName = path.basename(path.dirname(p.update.target));
+            const report = await validator.validateSpecContent(specName, p.rebuilt);
+            if (!report.valid) {
+                const errors = report.issues
+                    .filter((i) => i.level === 'ERROR')
+                    .map((i) => `  ✗ ${i.message}`)
+                    .join('\n');
+                throw new Error(`Validation errors in rebuilt spec for ${specName}:\n${errors}`);
+            }
+        }
+    }
+    // Build results
+    const capabilities = [];
+    const totals = { added: 0, modified: 0, removed: 0, renamed: 0 };
+    for (const p of prepared) {
+        const capability = path.basename(path.dirname(p.update.target));
+        if (!options.dryRun) {
+            // Write the updated spec
+            const targetDir = path.dirname(p.update.target);
+            await fs.mkdir(targetDir, { recursive: true });
+            await fs.writeFile(p.update.target, p.rebuilt);
+            if (!options.silent) {
+                console.log(`Applying changes to openspec/specs/${capability}/spec.md:`);
+                if (p.counts.added)
+                    console.log(`  + ${p.counts.added} added`);
+                if (p.counts.modified)
+                    console.log(`  ~ ${p.counts.modified} modified`);
+                if (p.counts.removed)
+                    console.log(`  - ${p.counts.removed} removed`);
+                if (p.counts.renamed)
+                    console.log(`  → ${p.counts.renamed} renamed`);
+            }
+        }
+        else if (!options.silent) {
+            console.log(`Would apply changes to openspec/specs/${capability}/spec.md:`);
+            if (p.counts.added)
+                console.log(`  + ${p.counts.added} added`);
+            if (p.counts.modified)
+                console.log(`  ~ ${p.counts.modified} modified`);
+            if (p.counts.removed)
+                console.log(`  - ${p.counts.removed} removed`);
+            if (p.counts.renamed)
+                console.log(`  → ${p.counts.renamed} renamed`);
+        }
+        capabilities.push({
+            capability,
+            ...p.counts,
+        });
+        totals.added += p.counts.added;
+        totals.modified += p.counts.modified;
+        totals.removed += p.counts.removed;
+        totals.renamed += p.counts.renamed;
+    }
+    return {
+        changeName,
+        capabilities,
+        totals,
+        noChanges: false,
+    };
+}
+//# sourceMappingURL=specs-apply.js.map