@codewalla_india/openspec 1.0.1

package/dist/core/openspec-root.js

@@ -0,0 +1,192 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { serializeConfig } from './config-prompts.js';
+import { makeStoreDiagnostic, } from './store/errors.js';
+export const OPENSPEC_ROOT_DIR = 'openspec';
+export const OPENSPEC_CONFIG_YAML = 'openspec/config.yaml';
+export const OPENSPEC_CONFIG_YML = 'openspec/config.yml';
+export const OPENSPEC_SPECS_DIR = 'openspec/specs';
+export const OPENSPEC_CHANGES_DIR = 'openspec/changes';
+export const OPENSPEC_ARCHIVE_DIR = 'openspec/changes/archive';
+export const DEFAULT_OPENSPEC_SCHEMA = 'spec-driven';
+export const DIRECTORY_ANCHOR_FILE_NAME = '.gitkeep';
+// Git cannot track empty directories, so clones of a fresh store would lose
+// these and fail root-health checks. Anchored at setup time.
+export const ANCHORED_OPENSPEC_DIRS = [OPENSPEC_SPECS_DIR, OPENSPEC_ARCHIVE_DIR];
+async function pathKind(targetPath) {
+    try {
+        const stat = await fs.stat(targetPath);
+        if (stat.isDirectory())
+            return 'directory';
+        if (stat.isFile())
+            return 'file';
+        return 'other';
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return 'missing';
+        }
+        throw error;
+    }
+}
+function relativeArtifact(relativePath, kind) {
+    const normalized = FileSystemUtils.toPosixPath(relativePath);
+    return kind === 'directory' ? `${normalized}/` : normalized;
+}
+function unresolvedInspection() {
+    return {
+        present: null,
+        config: { present: null },
+        specs: { present: null },
+        changes: { present: null },
+        archive: { present: null },
+        healthy: false,
+        diagnostics: [],
+    };
+}
+function missingDirectoryDiagnostic(code, message, target) {
+    return makeStoreDiagnostic('error', code, message, { target });
+}
+export async function inspectOpenSpecRoot(storeRoot) {
+    const rootKind = await pathKind(storeRoot);
+    const inspection = unresolvedInspection();
+    if (rootKind === 'missing') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_store_root_missing', 'Store root does not exist.', 'store.root'));
+        return inspection;
+    }
+    if (rootKind !== 'directory') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_store_root_not_directory', 'Store root is not a directory.', 'store.root'));
+        return inspection;
+    }
+    const openspecPath = path.join(storeRoot, OPENSPEC_ROOT_DIR);
+    const openspecKind = await pathKind(openspecPath);
+    inspection.present = openspecKind === 'directory';
+    if (openspecKind === 'missing') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_root_missing', 'Missing openspec/ directory.', 'openspec.root'));
+        return inspection;
+    }
+    if (openspecKind !== 'directory') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_root_not_directory', 'openspec/ exists but is not a directory.', 'openspec.root'));
+        return inspection;
+    }
+    const configYamlKind = await pathKind(path.join(storeRoot, OPENSPEC_CONFIG_YAML));
+    const configYmlKind = await pathKind(path.join(storeRoot, OPENSPEC_CONFIG_YML));
+    if (configYamlKind === 'file') {
+        inspection.config = { present: true, path: OPENSPEC_CONFIG_YAML };
+    }
+    else if (configYmlKind === 'file') {
+        inspection.config = { present: true, path: OPENSPEC_CONFIG_YML };
+    }
+    else {
+        inspection.config = { present: false };
+        if (configYamlKind !== 'missing' || configYmlKind !== 'missing') {
+            inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_config_not_file', 'OpenSpec config path exists but is not a file.', 'openspec.config'));
+        }
+        else {
+            inspection.diagnostics.push(missingDirectoryDiagnostic('openspec_config_missing', 'Missing openspec/config.yaml or openspec/config.yml.', 'openspec.config'));
+        }
+    }
+    for (const [key, relativePath, code, message, target] of [
+        ['specs', OPENSPEC_SPECS_DIR, 'openspec_specs_missing', 'Missing openspec/specs/.', 'openspec.specs'],
+        ['changes', OPENSPEC_CHANGES_DIR, 'openspec_changes_missing', 'Missing openspec/changes/.', 'openspec.changes'],
+        ['archive', OPENSPEC_ARCHIVE_DIR, 'openspec_archive_missing', 'Missing openspec/changes/archive/.', 'openspec.archive'],
+    ]) {
+        const kind = await pathKind(path.join(storeRoot, relativePath));
+        inspection[key] = { present: kind === 'directory' };
+        if (kind === 'directory')
+            continue;
+        inspection.diagnostics.push(missingDirectoryDiagnostic(kind === 'missing' ? code : code.replace('_missing', '_not_directory'), kind === 'missing' ? message : `${relativePath}/ exists but is not a directory.`, target));
+    }
+    inspection.healthy =
+        inspection.present === true &&
+            inspection.config.present === true &&
+            inspection.specs.present === true &&
+            inspection.changes.present === true &&
+            inspection.archive.present === true;
+    return inspection;
+}
+async function ensureDirectory(storeRoot, relativePath, ledger) {
+    const absolutePath = path.join(storeRoot, relativePath);
+    const kind = await pathKind(absolutePath);
+    if (kind === 'directory')
+        return;
+    if (kind !== 'missing') {
+        throw new Error(`${relativePath}/ exists but is not a directory.`);
+    }
+    await fs.mkdir(absolutePath, { recursive: true });
+    ledger.push({
+        relativePath: relativeArtifact(relativePath, 'directory'),
+        absolutePath,
+        kind: 'directory',
+    });
+}
+async function ensureDefaultConfig(storeRoot, ledger) {
+    const configYamlPath = path.join(storeRoot, OPENSPEC_CONFIG_YAML);
+    const configYmlPath = path.join(storeRoot, OPENSPEC_CONFIG_YML);
+    const yamlKind = await pathKind(configYamlPath);
+    const ymlKind = await pathKind(configYmlPath);
+    if (yamlKind === 'file' || ymlKind === 'file')
+        return;
+    if (yamlKind !== 'missing' || ymlKind !== 'missing') {
+        throw new Error('OpenSpec config path exists but is not a file.');
+    }
+    await FileSystemUtils.writeFile(configYamlPath, serializeConfig({ schema: DEFAULT_OPENSPEC_SCHEMA }));
+    ledger.push({
+        relativePath: relativeArtifact(OPENSPEC_CONFIG_YAML, 'file'),
+        absolutePath: configYamlPath,
+        kind: 'file',
+    });
+}
+async function ensureDirectoryAnchor(storeRoot, relativeDir, ledger) {
+    const directory = path.join(storeRoot, relativeDir);
+    if ((await fs.readdir(directory)).length > 0)
+        return;
+    const relativePath = `${relativeDir}/${DIRECTORY_ANCHOR_FILE_NAME}`;
+    const absolutePath = path.join(directory, DIRECTORY_ANCHOR_FILE_NAME);
+    await fs.writeFile(absolutePath, '', 'utf-8');
+    ledger.push({
+        relativePath: relativeArtifact(relativePath, 'file'),
+        absolutePath,
+        kind: 'file',
+    });
+}
+export async function ensureOpenSpecRoot(storeRoot, options = {}) {
+    const ledger = [];
+    const rootKind = await pathKind(storeRoot);
+    if (rootKind === 'missing') {
+        await fs.mkdir(storeRoot, { recursive: true });
+    }
+    else if (rootKind !== 'directory') {
+        throw new Error('Store root is not a directory.');
+    }
+    await ensureDirectory(storeRoot, OPENSPEC_ROOT_DIR, ledger);
+    await ensureDirectory(storeRoot, OPENSPEC_SPECS_DIR, ledger);
+    await ensureDirectory(storeRoot, OPENSPEC_CHANGES_DIR, ledger);
+    await ensureDirectory(storeRoot, OPENSPEC_ARCHIVE_DIR, ledger);
+    await ensureDefaultConfig(storeRoot, ledger);
+    if (options.anchorEmptyDirectories) {
+        for (const relativeDir of ANCHORED_OPENSPEC_DIRS) {
+            await ensureDirectoryAnchor(storeRoot, relativeDir, ledger);
+        }
+    }
+    return {
+        inspection: await inspectOpenSpecRoot(storeRoot),
+        createdArtifacts: ledger.map((entry) => entry.relativePath),
+        createdPaths: ledger,
+    };
+}
+export async function rollbackCreatedPaths(entries) {
+    for (const entry of [...entries].reverse()) {
+        if (entry.kind === 'file') {
+            await fs.rm(entry.absolutePath, { force: true }).catch(() => undefined);
+        }
+        else {
+            await fs.rmdir(entry.absolutePath).catch(() => undefined);
+        }
+    }
+}
+//# sourceMappingURL=openspec-root.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,197 @@
+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 = ChangeParser.normalizeContent(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 normalizedContent = ChangeParser.normalizeContent(content);
+        const lines = normalizedContent.split('\n');
+        const codeFenceLineMask = ChangeParser.buildCodeFenceMask(lines);
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (codeFenceLineMask[i]) {
+                continue;
+            }
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const contentLines = this.getContentUntilNextHeaderFromLines(lines, codeFenceLineMask, 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, codeFenceLineMask, startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < lines.length; i++) {
+            const line = lines[i];
+            const headerMatch = codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines;
+    }
+}
+//# sourceMappingURL=change-parser.js.map

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

@@ -0,0 +1,26 @@
+import { Spec, Change, Requirement, Scenario, Delta } from '../schemas/index.js';
+export interface Section {
+    level: number;
+    title: string;
+    content: string;
+    children: Section[];
+}
+export declare class MarkdownParser {
+    private lines;
+    private codeFenceLineMask;
+    private currentLine;
+    constructor(content: string);
+    protected static normalizeContent(content: string): string;
+    protected static buildCodeFenceMask(lines: string[]): boolean[];
+    private static getFenceMarker;
+    private static isClosingFence;
+    parseSpec(name: string): Spec;
+    parseChange(name: string): Change;
+    protected parseSections(): Section[];
+    protected getContentUntilNextHeader(startLine: number, currentLevel: number): string;
+    protected findSection(sections: Section[], title: string): Section | undefined;
+    protected parseRequirements(section: Section): Requirement[];
+    protected parseScenarios(requirementSection: Section): Scenario[];
+    protected parseDeltas(content: string): Delta[];
+}
+//# sourceMappingURL=markdown-parser.d.ts.map

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

@@ -0,0 +1,227 @@
+export class MarkdownParser {
+    lines;
+    codeFenceLineMask;
+    currentLine;
+    constructor(content) {
+        const normalized = MarkdownParser.normalizeContent(content);
+        this.lines = normalized.split('\n');
+        this.codeFenceLineMask = MarkdownParser.buildCodeFenceMask(this.lines);
+        this.currentLine = 0;
+    }
+    static normalizeContent(content) {
+        return content.replace(/\r\n?/g, '\n');
+    }
+    static buildCodeFenceMask(lines) {
+        const mask = new Array(lines.length).fill(false);
+        let activeFence = null;
+        for (let i = 0; i < lines.length; i++) {
+            const fence = MarkdownParser.getFenceMarker(lines[i]);
+            if (!activeFence) {
+                if (fence) {
+                    activeFence = fence;
+                    mask[i] = true;
+                }
+                continue;
+            }
+            mask[i] = true;
+            if (MarkdownParser.isClosingFence(lines[i], activeFence)) {
+                activeFence = null;
+            }
+        }
+        return mask;
+    }
+    static getFenceMarker(line) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
+        if (!fenceMatch) {
+            return null;
+        }
+        return {
+            marker: fenceMatch[1][0],
+            length: fenceMatch[1].length,
+        };
+    }
+    static isClosingFence(line, activeFence) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+        return Boolean(fenceMatch &&
+            fenceMatch[1][0] === activeFence.marker &&
+            fenceMatch[1].length >= activeFence.length);
+    }
+    parseSpec(name) {
+        const sections = this.parseSections();
+        const purpose = this.findSection(sections, 'Purpose')?.content || '';
+        const requirementsSection = this.findSection(sections, 'Requirements');
+        if (!purpose) {
+            throw new Error('Spec must have a Purpose section');
+        }
+        if (!requirementsSection) {
+            throw new Error('Spec must have a Requirements section');
+        }
+        const requirements = this.parseRequirements(requirementsSection);
+        return {
+            name,
+            overview: purpose.trim(),
+            requirements,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec',
+            },
+        };
+    }
+    parseChange(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');
+        }
+        const deltas = this.parseDeltas(whatChanges);
+        return {
+            name,
+            why: why.trim(),
+            whatChanges: whatChanges.trim(),
+            deltas,
+            metadata: {
+                version: '1.0.0',
+                format: 'openspec-change',
+            },
+        };
+    }
+    parseSections() {
+        const sections = [];
+        const stack = [];
+        for (let i = 0; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            if (this.codeFenceLineMask[i]) {
+                continue;
+            }
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+            if (headerMatch) {
+                const level = headerMatch[1].length;
+                const title = headerMatch[2].trim();
+                const content = this.getContentUntilNextHeader(i + 1, level);
+                const section = {
+                    level,
+                    title,
+                    content,
+                    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;
+    }
+    getContentUntilNextHeader(startLine, currentLevel) {
+        const contentLines = [];
+        for (let i = startLine; i < this.lines.length; i++) {
+            const line = this.lines[i];
+            const headerMatch = this.codeFenceLineMask[i] ? null : line.match(/^(#{1,6})\s+/);
+            if (headerMatch && headerMatch[1].length <= currentLevel) {
+                break;
+            }
+            contentLines.push(line);
+        }
+        return contentLines.join('\n').trim();
+    }
+    findSection(sections, title) {
+        for (const section of sections) {
+            if (section.title.toLowerCase() === title.toLowerCase()) {
+                return section;
+            }
+            const child = this.findSection(section.children, title);
+            if (child) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    parseRequirements(section) {
+        const requirements = [];
+        for (const child of section.children) {
+            // Extract requirement text from first non-empty content line, fall back to heading
+            let text = child.title;
+            // Get content before any child sections (scenarios)
+            if (child.content.trim()) {
+                // Split content into lines and find content before any child headers
+                const lines = child.content.split('\n');
+                const contentBeforeChildren = [];
+                for (const line of lines) {
+                    // Stop at child headers (scenarios start with ####)
+                    if (line.trim().startsWith('#')) {
+                        break;
+                    }
+                    contentBeforeChildren.push(line);
+                }
+                // Find first non-empty line
+                const directContent = contentBeforeChildren.join('\n').trim();
+                if (directContent) {
+                    const firstLine = directContent.split('\n').find(l => l.trim());
+                    if (firstLine) {
+                        text = firstLine.trim();
+                    }
+                }
+            }
+            const scenarios = this.parseScenarios(child);
+            requirements.push({
+                text,
+                scenarios,
+            });
+        }
+        return requirements;
+    }
+    parseScenarios(requirementSection) {
+        const scenarios = [];
+        for (const scenarioSection of requirementSection.children) {
+            // Store the raw text content of the scenario section
+            if (scenarioSection.content.trim()) {
+                scenarios.push({
+                    rawText: scenarioSection.content
+                });
+            }
+        }
+        return scenarios;
+    }
+    parseDeltas(content) {
+        const deltas = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            // Match both formats: **spec:** and **spec**:
+            const deltaMatch = line.match(/^\s*-\s*\*\*([^*:]+)(?::\*\*|\*\*:)\s*(.+)$/);
+            if (deltaMatch) {
+                const specName = deltaMatch[1].trim();
+                const description = deltaMatch[2].trim();
+                let operation = 'MODIFIED';
+                const lowerDesc = description.toLowerCase();
+                // Use word boundaries to avoid false matches (e.g., "address" matching "add")
+                // Check RENAMED first since it's more specific than patterns containing "new"
+                if (/\brename(s|d|ing)?\b/.test(lowerDesc) || /\brenamed\s+(to|from)\b/.test(lowerDesc)) {
+                    operation = 'RENAMED';
+                }
+                else if (/\badd(s|ed|ing)?\b/.test(lowerDesc) || /\bcreate(s|d|ing)?\b/.test(lowerDesc) || /\bnew\b/.test(lowerDesc)) {
+                    operation = 'ADDED';
+                }
+                else if (/\bremove(s|d|ing)?\b/.test(lowerDesc) || /\bdelete(s|d|ing)?\b/.test(lowerDesc)) {
+                    operation = 'REMOVED';
+                }
+                deltas.push({
+                    spec: specName,
+                    operation,
+                    description,
+                });
+            }
+        }
+        return deltas;
+    }
+}
+//# sourceMappingURL=markdown-parser.js.map