@fission-ai/openspec 0.1.0

package/dist/core/converters/json-converter.js

@@ -0,0 +1,48 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { MarkdownParser } from '../parsers/markdown-parser.js';
+import { ChangeParser } from '../parsers/change-parser.js';
+export class JsonConverter {
+    convertSpecToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const parser = new MarkdownParser(content);
+        const specName = this.extractNameFromPath(filePath);
+        const spec = parser.parseSpec(specName);
+        const jsonSpec = {
+            ...spec,
+            metadata: {
+                ...spec.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonSpec, null, 2);
+    }
+    async convertChangeToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const changeName = this.extractNameFromPath(filePath);
+        const changeDir = path.dirname(filePath);
+        const parser = new ChangeParser(content, changeDir);
+        const change = await parser.parseChangeWithDeltas(changeName);
+        const jsonChange = {
+            ...change,
+            metadata: {
+                ...change.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonChange, null, 2);
+    }
+    extractNameFromPath(filePath) {
+        const parts = filePath.split('/');
+        for (let i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] === 'specs' || parts[i] === 'changes') {
+                if (i < parts.length - 1) {
+                    return parts[i + 1];
+                }
+            }
+        }
+        const fileName = parts[parts.length - 1];
+        return fileName.replace('.md', '');
+    }
+}
+//# sourceMappingURL=json-converter.js.map

package/dist/core/diff.d.ts

@@ -0,0 +1,11 @@
+export declare class DiffCommand {
+    private filesChanged;
+    private linesAdded;
+    private linesRemoved;
+    execute(changeName?: string): Promise<void>;
+    private selectChange;
+    private showDiffs;
+    private walkAndDiff;
+    private diffFile;
+}
+//# sourceMappingURL=diff.d.ts.map

package/dist/core/diff.js

@@ -0,0 +1,193 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { diffStringsUnified } from 'jest-diff';
+import { select } from '@inquirer/prompts';
+import { Validator } from './validation/validator.js';
+// Constants
+const ARCHIVE_DIR = 'archive';
+const MARKDOWN_EXT = '.md';
+const OPENSPEC_DIR = 'openspec';
+const CHANGES_DIR = 'changes';
+const SPECS_DIR = 'specs';
+export class DiffCommand {
+    filesChanged = 0;
+    linesAdded = 0;
+    linesRemoved = 0;
+    async execute(changeName) {
+        const changesDir = path.join(process.cwd(), OPENSPEC_DIR, CHANGES_DIR);
+        try {
+            await fs.access(changesDir);
+        }
+        catch {
+            throw new Error('No OpenSpec changes directory found');
+        }
+        if (!changeName) {
+            changeName = await this.selectChange(changesDir);
+            if (!changeName)
+                return;
+        }
+        const changeDir = path.join(changesDir, changeName);
+        try {
+            await fs.access(changeDir);
+        }
+        catch {
+            throw new Error(`Change '${changeName}' not found`);
+        }
+        const changeSpecsDir = path.join(changeDir, SPECS_DIR);
+        try {
+            await fs.access(changeSpecsDir);
+        }
+        catch {
+            console.log(`No spec changes found for '${changeName}'`);
+            return;
+        }
+        // Validate specs and show warnings (non-blocking)
+        const validator = new Validator();
+        let hasWarnings = false;
+        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');
+                    try {
+                        await fs.access(specFile);
+                        const report = await validator.validateSpec(specFile);
+                        if (report.issues.length > 0) {
+                            const warnings = report.issues.filter(i => i.level === 'WARNING');
+                            const errors = report.issues.filter(i => i.level === 'ERROR');
+                            if (errors.length > 0 || warnings.length > 0) {
+                                if (!hasWarnings) {
+                                    console.log(chalk.yellow('\n⚠️  Validation warnings found:'));
+                                    hasWarnings = true;
+                                }
+                                console.log(chalk.yellow(`\n  ${entry.name}/spec.md:`));
+                                for (const issue of errors) {
+                                    console.log(chalk.red(`    ✗ ${issue.message}`));
+                                }
+                                for (const issue of warnings) {
+                                    console.log(chalk.yellow(`    ⚠ ${issue.message}`));
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Spec file doesn't exist, skip validation
+                    }
+                }
+            }
+            if (hasWarnings) {
+                console.log(chalk.yellow('\nConsider fixing these issues before archiving.\n'));
+            }
+        }
+        catch {
+            // No specs directory, skip validation
+        }
+        // Reset counters
+        this.filesChanged = 0;
+        this.linesAdded = 0;
+        this.linesRemoved = 0;
+        await this.showDiffs(changeSpecsDir);
+        // Show summary
+        if (this.filesChanged > 0) {
+            console.log(chalk.bold(`\n📊 Summary: ${this.filesChanged} file(s) changed, ${chalk.green(`+${this.linesAdded}`)} ${chalk.red(`-${this.linesRemoved}`)}`));
+        }
+    }
+    async selectChange(changesDir) {
+        const entries = await fs.readdir(changesDir, { withFileTypes: true });
+        const changes = entries
+            .filter(entry => entry.isDirectory() && entry.name !== ARCHIVE_DIR)
+            .map(entry => entry.name);
+        if (changes.length === 0) {
+            console.log('No changes found');
+            return undefined;
+        }
+        console.log('Available changes:');
+        const choices = changes.map((name) => ({
+            name: name,
+            value: name
+        }));
+        const answer = await select({
+            message: 'Select a change',
+            choices
+        });
+        return answer;
+    }
+    async showDiffs(changeSpecsDir) {
+        const currentSpecsDir = path.join(process.cwd(), OPENSPEC_DIR, SPECS_DIR);
+        await this.walkAndDiff(changeSpecsDir, currentSpecsDir, '');
+    }
+    async walkAndDiff(changeDir, currentDir, relativePath) {
+        const entries = await fs.readdir(path.join(changeDir, relativePath), { withFileTypes: true });
+        for (const entry of entries) {
+            const entryPath = path.join(relativePath, entry.name);
+            if (entry.isDirectory()) {
+                await this.walkAndDiff(changeDir, currentDir, entryPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(MARKDOWN_EXT)) {
+                await this.diffFile(path.join(changeDir, entryPath), path.join(currentDir, entryPath), entryPath);
+            }
+        }
+    }
+    async diffFile(changePath, currentPath, displayPath) {
+        let changeContent = '';
+        let currentContent = '';
+        let isNewFile = false;
+        let isDeleted = false;
+        try {
+            changeContent = await fs.readFile(changePath, 'utf-8');
+        }
+        catch {
+            changeContent = '';
+        }
+        try {
+            currentContent = await fs.readFile(currentPath, 'utf-8');
+        }
+        catch {
+            currentContent = '';
+            isNewFile = true;
+        }
+        if (changeContent === currentContent) {
+            return;
+        }
+        if (changeContent === '' && currentContent !== '') {
+            isDeleted = true;
+        }
+        // Enhanced header with file status
+        console.log(chalk.bold.cyan(`\n${'═'.repeat(60)}`));
+        console.log(chalk.bold.cyan(`📄 ${displayPath}`));
+        if (isNewFile) {
+            console.log(chalk.green(`   Status: NEW FILE`));
+        }
+        else if (isDeleted) {
+            console.log(chalk.red(`   Status: DELETED`));
+        }
+        else {
+            console.log(chalk.yellow(`   Status: MODIFIED`));
+        }
+        // Use jest-diff for the actual diff with custom options
+        const diffOptions = {
+            aAnnotation: 'Current',
+            bAnnotation: 'Proposed',
+            aColor: chalk.red,
+            bColor: chalk.green,
+            commonColor: chalk.gray,
+            contextLines: 3,
+            expand: false,
+            includeChangeCounts: true,
+        };
+        const diff = diffStringsUnified(currentContent, changeContent, diffOptions);
+        // Count lines for statistics (approximate)
+        const addedLines = (diff.match(/^\+[^+]/gm) || []).length;
+        const removedLines = (diff.match(/^-[^-]/gm) || []).length;
+        console.log(chalk.gray(`   Lines: ${chalk.green(`+${addedLines}`)} ${chalk.red(`-${removedLines}`)}`));
+        console.log(chalk.bold.cyan(`${'─'.repeat(60)}\n`));
+        // Display the diff
+        console.log(diff);
+        // Update counters
+        this.filesChanged++;
+        this.linesAdded += addedLines;
+        this.linesRemoved += removedLines;
+    }
+}
+//# sourceMappingURL=diff.js.map

package/dist/core/index.d.ts

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

package/dist/core/index.js

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

package/dist/core/init.d.ts

@@ -0,0 +1,10 @@
+export declare class InitCommand {
+    execute(targetPath: string): Promise<void>;
+    private validate;
+    private getConfiguration;
+    private createDirectoryStructure;
+    private generateFiles;
+    private configureAITools;
+    private displaySuccessMessage;
+}
+//# sourceMappingURL=init.d.ts.map

package/dist/core/init.js

@@ -0,0 +1,109 @@
+import path from 'path';
+import { select } from '@inquirer/prompts';
+import ora from 'ora';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { TemplateManager } from './templates/index.js';
+import { ToolRegistry } from './configurators/registry.js';
+import { AI_TOOLS, OPENSPEC_DIR_NAME } from './config.js';
+export class InitCommand {
+    async execute(targetPath) {
+        const projectPath = path.resolve(targetPath);
+        const openspecDir = OPENSPEC_DIR_NAME;
+        const openspecPath = path.join(projectPath, openspecDir);
+        // Validation happens silently in the background
+        await this.validate(projectPath, openspecPath);
+        // Get configuration (after validation to avoid prompts if validation fails)
+        const config = await this.getConfiguration();
+        // Step 1: Create directory structure
+        const structureSpinner = ora({ text: 'Creating OpenSpec structure...', stream: process.stdout }).start();
+        await this.createDirectoryStructure(openspecPath);
+        await this.generateFiles(openspecPath, config);
+        structureSpinner.succeed('OpenSpec structure created');
+        // Step 2: Configure AI tools
+        const toolSpinner = ora({ text: 'Configuring AI tools...', stream: process.stdout }).start();
+        await this.configureAITools(projectPath, openspecDir, config.aiTools);
+        toolSpinner.succeed('AI tools configured');
+        // Success message
+        this.displaySuccessMessage(openspecDir, config);
+    }
+    async validate(projectPath, openspecPath) {
+        // Check if OpenSpec already exists
+        if (await FileSystemUtils.directoryExists(openspecPath)) {
+            throw new Error(`OpenSpec seems to already be initialized at ${openspecPath}.\n` +
+                `Use 'openspec update' to update the structure.`);
+        }
+        // Check write permissions
+        if (!await FileSystemUtils.ensureWritePermissions(projectPath)) {
+            throw new Error(`Insufficient permissions to write to ${projectPath}`);
+        }
+    }
+    async getConfiguration() {
+        const config = {
+            aiTools: []
+        };
+        // Single-select for better UX
+        const selectedTool = await select({
+            message: 'Which AI tool do you use?',
+            choices: AI_TOOLS.map(tool => ({
+                name: tool.available ? tool.name : `${tool.name} (coming soon)`,
+                value: tool.value,
+                disabled: !tool.available
+            }))
+        });
+        config.aiTools = [selectedTool];
+        return config;
+    }
+    async createDirectoryStructure(openspecPath) {
+        const directories = [
+            openspecPath,
+            path.join(openspecPath, 'specs'),
+            path.join(openspecPath, 'changes'),
+            path.join(openspecPath, 'changes', 'archive')
+        ];
+        for (const dir of directories) {
+            await FileSystemUtils.createDirectory(dir);
+        }
+    }
+    async generateFiles(openspecPath, config) {
+        const context = {
+        // Could be enhanced with prompts for project details
+        };
+        const templates = TemplateManager.getTemplates(context);
+        for (const template of templates) {
+            const filePath = path.join(openspecPath, template.path);
+            const content = typeof template.content === 'function'
+                ? template.content(context)
+                : template.content;
+            await FileSystemUtils.writeFile(filePath, content);
+        }
+    }
+    async configureAITools(projectPath, openspecDir, toolIds) {
+        for (const toolId of toolIds) {
+            const configurator = ToolRegistry.get(toolId);
+            if (configurator && configurator.isAvailable) {
+                await configurator.configure(projectPath, openspecDir);
+            }
+        }
+    }
+    displaySuccessMessage(openspecDir, config) {
+        console.log(); // Empty line for spacing
+        ora().succeed('OpenSpec initialized successfully!');
+        // Get the selected tool name for display
+        const selectedToolId = config.aiTools[0];
+        const selectedTool = AI_TOOLS.find(t => t.value === selectedToolId);
+        const toolName = selectedTool ? selectedTool.name : 'your AI assistant';
+        console.log(`\nNext steps - Copy these prompts to ${toolName}:\n`);
+        console.log('────────────────────────────────────────────────────────────');
+        console.log('1. Populate your project context:');
+        console.log('   "Please read openspec/project.md and help me fill it out');
+        console.log('    with details about my project, tech stack, and conventions"\n');
+        console.log('2. Create your first change proposal:');
+        console.log('   "I want to add [YOUR FEATURE HERE]. Please create an');
+        console.log('    OpenSpec change proposal for this feature"\n');
+        console.log('3. Learn the OpenSpec workflow:');
+        console.log('   "Please explain the OpenSpec workflow from openspec/README.md');
+        console.log('    and how I should work with you on this project"');
+        console.log('────────────────────────────────────────────────────────────\n');
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/core/list.d.ts

@@ -0,0 +1,4 @@
+export declare class ListCommand {
+    execute(targetPath?: string, mode?: 'changes' | 'specs'): Promise<void>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/core/list.js

@@ -0,0 +1,89 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { MarkdownParser } from './parsers/markdown-parser.js';
+export class ListCommand {
+    async execute(targetPath = '.', mode = 'changes') {
+        if (mode === 'changes') {
+            const changesDir = path.join(targetPath, 'openspec', 'changes');
+            // Check if changes directory exists
+            try {
+                await fs.access(changesDir);
+            }
+            catch {
+                throw new Error("No OpenSpec changes directory found. Run 'openspec init' first.");
+            }
+            // Get all directories in changes (excluding archive)
+            const entries = await fs.readdir(changesDir, { withFileTypes: true });
+            const changeDirs = entries
+                .filter(entry => entry.isDirectory() && entry.name !== 'archive')
+                .map(entry => entry.name);
+            if (changeDirs.length === 0) {
+                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);
+                changes.push({
+                    name: changeDir,
+                    completedTasks: progress.completed,
+                    totalTasks: progress.total
+                });
+            }
+            // Sort alphabetically by name
+            changes.sort((a, b) => a.name.localeCompare(b.name));
+            // Display results
+            console.log('Changes:');
+            const padding = '  ';
+            const nameWidth = Math.max(...changes.map(c => c.name.length));
+            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}`);
+            }
+            return;
+        }
+        // specs mode
+        const specsDir = path.join(targetPath, 'openspec', 'specs');
+        try {
+            await fs.access(specsDir);
+        }
+        catch {
+            console.log('No specs found.');
+            return;
+        }
+        const entries = await fs.readdir(specsDir, { withFileTypes: true });
+        const specDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+        if (specDirs.length === 0) {
+            console.log('No specs found.');
+            return;
+        }
+        const specs = [];
+        for (const id of specDirs) {
+            const specPath = join(specsDir, id, 'spec.md');
+            try {
+                const content = readFileSync(specPath, 'utf-8');
+                const parser = new MarkdownParser(content);
+                const spec = parser.parseSpec(id);
+                specs.push({ id, requirementCount: spec.requirements.length });
+            }
+            catch {
+                // If spec cannot be read or parsed, include with 0 count
+                specs.push({ id, requirementCount: 0 });
+            }
+        }
+        specs.sort((a, b) => a.id.localeCompare(b.id));
+        console.log('Specs:');
+        const padding = '  ';
+        const nameWidth = Math.max(...specs.map(s => s.id.length));
+        for (const spec of specs) {
+            const padded = spec.id.padEnd(nameWidth);
+            console.log(`${padding}${padded}     requirements ${spec.requirementCount}`);
+        }
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/core/parsers/change-parser.d.ts

@@ -0,0 +1,13 @@
+import { MarkdownParser } from './markdown-parser.js';
+import { Change } from '../schemas/index.js';
+export declare class ChangeParser extends MarkdownParser {
+    private changeDir;
+    constructor(content: string, changeDir: string);
+    parseChangeWithDeltas(name: string): Promise<Change>;
+    private parseDeltaSpecs;
+    private parseSpecDeltas;
+    private parseRenames;
+    private parseSectionsFromContent;
+    private getContentUntilNextHeaderFromLines;
+}
+//# sourceMappingURL=change-parser.d.ts.map

package/dist/core/parsers/change-parser.js

@@ -0,0 +1,192 @@
+import { MarkdownParser } from './markdown-parser.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+export class ChangeParser extends MarkdownParser {
+    changeDir;
+    constructor(content, changeDir) {
+        super(content);
+        this.changeDir = changeDir;
+    }
+    async parseChangeWithDeltas(name) {
+        const sections = this.parseSections();
+        const why = this.findSection(sections, 'Why')?.content || '';
+        const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
+        if (!why) {
+            throw new Error('Change must have a Why section');
+        }
+        if (!whatChanges) {
+            throw new Error('Change must have a What Changes section');
+        }
+        // Parse deltas from the What Changes section (simple format)
+        const simpleDeltas = this.parseDeltas(whatChanges);
+        // Check if there are spec files with delta format
+        const specsDir = path.join(this.changeDir, 'specs');
+        const deltaDeltas = await this.parseDeltaSpecs(specsDir);
+        // Combine both types of deltas, preferring delta format if available
+        const deltas = deltaDeltas.length > 0 ? deltaDeltas : simpleDeltas;
+        return {
+            name,
+            why: why.trim(),
+            whatChanges: whatChanges.trim(),
+            deltas,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec-change',
+            },
+        };
+    }
+    async parseDeltaSpecs(specsDir) {
+        const deltas = [];
+        try {
+            const specDirs = await fs.readdir(specsDir, { withFileTypes: true });
+            for (const dir of specDirs) {
+                if (!dir.isDirectory())
+                    continue;
+                const specName = dir.name;
+                const specFile = path.join(specsDir, specName, 'spec.md');
+                try {
+                    const content = await fs.readFile(specFile, 'utf-8');
+                    const specDeltas = this.parseSpecDeltas(specName, content);
+                    deltas.push(...specDeltas);
+                }
+                catch (error) {
+                    // Spec file might not exist, which is okay
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Specs directory might not exist, which is okay
+            return [];
+        }
+        return deltas;
+    }
+    parseSpecDeltas(specName, content) {
+        const deltas = [];
+        const sections = this.parseSectionsFromContent(content);
+        // Parse ADDED requirements
+        const addedSection = this.findSection(sections, 'ADDED Requirements');
+        if (addedSection) {
+            const requirements = this.parseRequirements(addedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'ADDED',
+                    description: `Add requirement: ${req.text}`,
+                    // Provide both single and plural forms for compatibility
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse MODIFIED requirements
+        const modifiedSection = this.findSection(sections, 'MODIFIED Requirements');
+        if (modifiedSection) {
+            const requirements = this.parseRequirements(modifiedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'MODIFIED',
+                    description: `Modify requirement: ${req.text}`,
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse REMOVED requirements
+        const removedSection = this.findSection(sections, 'REMOVED Requirements');
+        if (removedSection) {
+            const requirements = this.parseRequirements(removedSection);
+            requirements.forEach(req => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'REMOVED',
+                    description: `Remove requirement: ${req.text}`,
+                    requirement: req,
+                    requirements: [req],
+                });
+            });
+        }
+        // Parse RENAMED requirements
+        const renamedSection = this.findSection(sections, 'RENAMED Requirements');
+        if (renamedSection) {
+            const renames = this.parseRenames(renamedSection.content);
+            renames.forEach(rename => {
+                deltas.push({
+                    spec: specName,
+                    operation: 'RENAMED',
+                    description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
+                    rename,
+                });
+            });
+        }
+        return deltas;
+    }
+    parseRenames(content) {
+        const renames = [];
+        const lines = content.split('\n');
+        let currentRename = {};
+        for (const line of lines) {
+            const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+            const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+            if (fromMatch) {
+                currentRename.from = fromMatch[1].trim();
+            }
+            else if (toMatch) {
+                currentRename.to = toMatch[1].trim();
+                if (currentRename.from && currentRename.to) {
+                    renames.push({
+                        from: currentRename.from,
+                        to: currentRename.to,
+                    });
+                    currentRename = {};
+                }
+            }
+        }
+        return renames;
+    }
+    parseSectionsFromContent(content) {
+        const lines = content.split('\n');
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, i + 1, level);
+                const section = {
+                    level,
+                    title,
+                    content: contentLines.join('\n').trim(),
+                    children: [],
+                };
+                while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+                    stack.pop();
+                }
+                if (stack.length === 0) {
+                    sections.push(section);
+                }
+                else {
+                    stack[stack.length - 1].children.push(section);
+                }
+                stack.push(section);
+            }
+        }
+        return sections;
+    }
+    getContentUntilNextHeaderFromLines(lines, startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines;
+    }
+}
+//# sourceMappingURL=change-parser.js.map