synarcx 0.1.0

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: 'synarcx',
+            },
+        };
+    }
+    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: 'synarcx-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

package/dist/core/parsers/requirement-blocks.d.ts

@@ -0,0 +1,37 @@
+export interface RequirementBlock {
+    headerLine: string;
+    name: string;
+    raw: string;
+}
+export interface RequirementsSectionParts {
+    before: string;
+    headerLine: string;
+    preamble: string;
+    bodyBlocks: RequirementBlock[];
+    after: string;
+}
+export declare function normalizeRequirementName(name: string): string;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export declare function extractRequirementsSection(content: string): RequirementsSectionParts;
+export interface DeltaPlan {
+    added: RequirementBlock[];
+    modified: RequirementBlock[];
+    removed: string[];
+    renamed: Array<{
+        from: string;
+        to: string;
+    }>;
+    sectionPresence: {
+        added: boolean;
+        modified: boolean;
+        removed: boolean;
+        renamed: boolean;
+    };
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export declare function parseDeltaSpec(content: string): DeltaPlan;
+//# sourceMappingURL=requirement-blocks.d.ts.map

package/dist/core/parsers/requirement-blocks.js

@@ -0,0 +1,201 @@
+export function normalizeRequirementName(name) {
+    return name.trim();
+}
+const REQUIREMENT_HEADER_REGEX = /^###\s*Requirement:\s*(.+)\s*$/i;
+/**
+ * Extracts the Requirements section from a spec file and parses requirement blocks.
+ */
+export function extractRequirementsSection(content) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const reqHeaderIndex = lines.findIndex(l => /^##\s+Requirements\s*$/i.test(l));
+    if (reqHeaderIndex === -1) {
+        // No requirements section; create an empty one at the end
+        const before = content.trimEnd();
+        const headerLine = '## Requirements';
+        return {
+            before: before ? before + '\n\n' : '',
+            headerLine,
+            preamble: '',
+            bodyBlocks: [],
+            after: '\n',
+        };
+    }
+    // Find end of this section: next line that starts with '## ' at same or higher level
+    let endIndex = lines.length;
+    for (let i = reqHeaderIndex + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIndex = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, reqHeaderIndex).join('\n');
+    const headerLine = lines[reqHeaderIndex];
+    const sectionBodyLines = lines.slice(reqHeaderIndex + 1, endIndex);
+    // Parse requirement blocks within section body
+    const blocks = [];
+    let cursor = 0;
+    let preambleLines = [];
+    // Collect preamble lines until first requirement header
+    while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor])) {
+        preambleLines.push(sectionBodyLines[cursor]);
+        cursor++;
+    }
+    while (cursor < sectionBodyLines.length) {
+        const headerStart = cursor;
+        const headerLineCandidate = sectionBodyLines[cursor];
+        const headerMatch = headerLineCandidate.match(REQUIREMENT_HEADER_REGEX);
+        if (!headerMatch) {
+            // Not a requirement header; skip line defensively
+            cursor++;
+            continue;
+        }
+        const name = normalizeRequirementName(headerMatch[1]);
+        cursor++;
+        // Gather lines until next requirement header or end of section
+        const bodyLines = [headerLineCandidate];
+        while (cursor < sectionBodyLines.length && !REQUIREMENT_HEADER_REGEX.test(sectionBodyLines[cursor]) && !/^##\s+/.test(sectionBodyLines[cursor])) {
+            bodyLines.push(sectionBodyLines[cursor]);
+            cursor++;
+        }
+        const raw = bodyLines.join('\n').trimEnd();
+        blocks.push({ headerLine: headerLineCandidate, name, raw });
+    }
+    const after = lines.slice(endIndex).join('\n');
+    const preamble = preambleLines.join('\n').trimEnd();
+    return {
+        before: before.trimEnd() ? before + '\n' : before,
+        headerLine,
+        preamble,
+        bodyBlocks: blocks,
+        after: after.startsWith('\n') ? after : '\n' + after,
+    };
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, '\n');
+}
+/**
+ * Parse a delta-formatted spec change file content into a DeltaPlan with raw blocks.
+ */
+export function parseDeltaSpec(content) {
+    const normalized = normalizeLineEndings(content);
+    const sections = splitTopLevelSections(normalized);
+    const addedLookup = getSectionCaseInsensitive(sections, 'ADDED Requirements');
+    const modifiedLookup = getSectionCaseInsensitive(sections, 'MODIFIED Requirements');
+    const removedLookup = getSectionCaseInsensitive(sections, 'REMOVED Requirements');
+    const renamedLookup = getSectionCaseInsensitive(sections, 'RENAMED Requirements');
+    const added = parseRequirementBlocksFromSection(addedLookup.body);
+    const modified = parseRequirementBlocksFromSection(modifiedLookup.body);
+    const removedNames = parseRemovedNames(removedLookup.body);
+    const renamedPairs = parseRenamedPairs(renamedLookup.body);
+    return {
+        added,
+        modified,
+        removed: removedNames,
+        renamed: renamedPairs,
+        sectionPresence: {
+            added: addedLookup.found,
+            modified: modifiedLookup.found,
+            removed: removedLookup.found,
+            renamed: renamedLookup.found,
+        },
+    };
+}
+function splitTopLevelSections(content) {
+    const lines = content.split('\n');
+    const result = {};
+    const indices = [];
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(/^(##)\s+(.+)$/);
+        if (m) {
+            const level = m[1].length; // only care for '##'
+            indices.push({ title: m[2].trim(), index: i, level });
+        }
+    }
+    for (let i = 0; i < indices.length; i++) {
+        const current = indices[i];
+        const next = indices[i + 1];
+        const body = lines.slice(current.index + 1, next ? next.index : lines.length).join('\n');
+        result[current.title] = body;
+    }
+    return result;
+}
+function getSectionCaseInsensitive(sections, desired) {
+    const target = desired.toLowerCase();
+    for (const [title, body] of Object.entries(sections)) {
+        if (title.toLowerCase() === target)
+            return { body, found: true };
+    }
+    return { body: '', found: false };
+}
+function parseRequirementBlocksFromSection(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Seek next requirement header
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]))
+            i++;
+        if (i >= lines.length)
+            break;
+        const headerLine = lines[i];
+        const m = headerLine.match(REQUIREMENT_HEADER_REGEX);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const name = normalizeRequirementName(m[1]);
+        const buf = [headerLine];
+        i++;
+        while (i < lines.length && !REQUIREMENT_HEADER_REGEX.test(lines[i]) && !/^##\s+/.test(lines[i])) {
+            buf.push(lines[i]);
+            i++;
+        }
+        blocks.push({ headerLine, name, raw: buf.join('\n').trimEnd() });
+    }
+    return blocks;
+}
+function parseRemovedNames(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const names = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    for (const line of lines) {
+        const m = line.match(REQUIREMENT_HEADER_REGEX);
+        if (m) {
+            names.push(normalizeRequirementName(m[1]));
+            continue;
+        }
+        // Also support bullet list of headers
+        const bullet = line.match(/^\s*-\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
+        if (bullet) {
+            names.push(normalizeRequirementName(bullet[1]));
+        }
+    }
+    return names;
+}
+function parseRenamedPairs(sectionBody) {
+    if (!sectionBody)
+        return [];
+    const pairs = [];
+    const lines = normalizeLineEndings(sectionBody).split('\n');
+    let current = {};
+    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) {
+            current.from = normalizeRequirementName(fromMatch[1]);
+        }
+        else if (toMatch) {
+            current.to = normalizeRequirementName(toMatch[1]);
+            if (current.from && current.to) {
+                pairs.push({ from: current.from, to: current.to });
+                current = {};
+            }
+        }
+    }
+    return pairs;
+}
+//# sourceMappingURL=requirement-blocks.js.map

package/dist/core/parsers/spec-structure.d.ts

@@ -0,0 +1,9 @@
+export interface MainSpecStructureIssue {
+    kind: 'delta-header' | 'requirement-outside-requirements';
+    line: number;
+    header: string;
+    message: string;
+}
+export declare function findMainSpecStructureIssues(content: string): MainSpecStructureIssue[];
+export declare function stripFencedCodeBlocksPreservingLines(content: string): string;
+//# sourceMappingURL=spec-structure.d.ts.map

package/dist/core/parsers/spec-structure.js

@@ -0,0 +1,88 @@
+const REQUIREMENTS_SECTION_HEADER = /^##\s+Requirements\s*$/i;
+const TOP_LEVEL_SECTION_HEADER = /^##\s+/;
+const DELTA_HEADER = /^##\s+(ADDED|MODIFIED|REMOVED|RENAMED)\s+Requirements\s*$/i;
+const REQUIREMENT_HEADER = /^###\s+Requirement:\s*(.+)\s*$/i;
+export function findMainSpecStructureIssues(content) {
+    const normalized = content.replace(/\r\n?/g, '\n');
+    const stripped = stripFencedCodeBlocksPreservingLines(normalized);
+    const lines = stripped.split('\n');
+    const issues = [];
+    const requirementsHeaderIndex = lines.findIndex(line => REQUIREMENTS_SECTION_HEADER.test(line));
+    let requirementsEndIndex = lines.length;
+    if (requirementsHeaderIndex !== -1) {
+        for (let i = requirementsHeaderIndex + 1; i < lines.length; i++) {
+            if (TOP_LEVEL_SECTION_HEADER.test(lines[i])) {
+                requirementsEndIndex = i;
+                break;
+            }
+        }
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (DELTA_HEADER.test(line)) {
+            issues.push({
+                kind: 'delta-header',
+                line: i + 1,
+                header: trimmed,
+                message: `Main spec contains delta header "${trimmed}". ` +
+                    'Delta headers are only valid inside synspec/changes/<name>/specs/<capability>/spec.md ' +
+                    'and truncate the parsed ## Requirements section.',
+            });
+            continue;
+        }
+        const requirementMatch = line.match(REQUIREMENT_HEADER);
+        if (!requirementMatch) {
+            continue;
+        }
+        const insideRequirements = requirementsHeaderIndex !== -1 &&
+            i > requirementsHeaderIndex &&
+            i < requirementsEndIndex;
+        if (!insideRequirements) {
+            issues.push({
+                kind: 'requirement-outside-requirements',
+                line: i + 1,
+                header: trimmed,
+                message: `Requirement header "${trimmed}" appears outside the main ## Requirements section. ` +
+                    'Main specs only parse requirements inside that section, so this requirement is currently invisible to validate, list, and archive.',
+            });
+        }
+    }
+    return issues;
+}
+export function stripFencedCodeBlocksPreservingLines(content) {
+    const lines = content.split('\n');
+    const output = [];
+    let activeFence = null;
+    for (const line of lines) {
+        const fenceMatch = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+        if (!activeFence) {
+            if (fenceMatch) {
+                activeFence = {
+                    marker: fenceMatch[1][0],
+                    length: fenceMatch[1].length,
+                };
+                output.push('');
+            }
+            else {
+                output.push(line);
+            }
+            continue;
+        }
+        output.push('');
+        if (isClosingFence(line, activeFence)) {
+            activeFence = null;
+        }
+    }
+    return output.join('\n');
+}
+function isClosingFence(line, activeFence) {
+    const fenceMatch = line.match(/^\s*(`{3,}|~{3,})\s*$/);
+    return Boolean(fenceMatch &&
+        fenceMatch[1][0] === activeFence.marker &&
+        fenceMatch[1].length >= activeFence.length);
+}
+//# sourceMappingURL=spec-structure.js.map

package/dist/core/profile-sync-drift.d.ts

@@ -0,0 +1,38 @@
+import type { Delivery } from './global-config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
+/**
+ * Checks whether a tool has at least one generated synarcx command file.
+ */
+export declare function toolHasAnyConfiguredCommand(projectPath: string, toolId: string): boolean;
+/**
+ * Returns tools with at least one generated command file on disk.
+ */
+export declare function getCommandConfiguredTools(projectPath: string): string[];
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export declare function getConfiguredToolsForProfileSync(projectPath: string): string[];
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export declare function hasToolProfileOrDeliveryDrift(projectPath: string, toolId: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export declare function getToolsNeedingProfileSync(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery, configuredTools?: readonly string[]): string[];
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export declare function hasProjectConfigDrift(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+export {};
+//# sourceMappingURL=profile-sync-drift.d.ts.map