fraim 2.0.100

package/dist/src/core/types.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * FRAIM Configuration Types
+ * TypeScript types for the workspace FRAIM config file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FRAIM_CONFIG = void 0;
+/**
+ * Default configuration values
+ */
+exports.DEFAULT_FRAIM_CONFIG = {
+    version: '2.0.47',
+    project: {
+        name: 'Untitled Project'
+    },
+    repository: {
+        provider: 'github',
+        owner: '',
+        name: '',
+        defaultBranch: 'main'
+    },
+    customizations: {}
+};

package/dist/src/core/utils/git-utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPort = getPort;
+exports.determineDatabaseName = determineDatabaseName;
+exports.getCurrentGitBranch = getCurrentGitBranch;
+exports.determineSchema = determineSchema;
+exports.getDefaultBranch = getDefaultBranch;
+const child_process_1 = require("child_process");
+/**
+ * Gets a unique port based on the current git branch name (if it's an issue branch)
+ * Default to 15302 if not on an issue branch
+ */
+function getPort() {
+    try {
+        const branchName = process.env.FRAIM_BRANCH || (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+        // Match issue-123 or 123-feature-name or feature/123-name
+        const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/(\d+)-/);
+        if (issueMatch) {
+            const issueNum = parseInt(issueMatch[1], 10);
+            // Ensure port is in a safe range (10000-65535)
+            return 10000 + (issueNum % 55535);
+        }
+    }
+    catch (e) {
+        // Silently fail and use default
+    }
+    return Number(process.env.PORT) || Number(process.env.WEBSITES_PORT) || Number(process.env.FRAIM_MCP_PORT) || 15302;
+}
+/**
+ * Determines the database name based on the git branch
+ */
+function determineDatabaseName() {
+    try {
+        const branchName = process.env.FRAIM_BRANCH || process.env.FRAIM_BRANCH_NAME || (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+        const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/(\d+)-/);
+        if (issueMatch) {
+            return `fraim_issue_${issueMatch[1]}`;
+        }
+    }
+    catch (e) {
+        // Silently fail
+    }
+    return process.env.MONGODB_DB_NAME || (process.env.NODE_ENV === 'production' ? 'fraim_prod' : 'fraim_dev');
+}
+/**
+ * Gets the current git branch name
+ */
+function getCurrentGitBranch() {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            timeout: 2000, // 2 second timeout
+            stdio: 'pipe'
+        }).toString().trim();
+    }
+    catch (e) {
+        return 'master';
+    }
+}
+/**
+ * Determines the database schema prefix based on the branch
+ */
+function determineSchema(branchName) {
+    const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/(\d+)-/);
+    if (issueMatch) {
+        return `issue_${issueMatch[1]}`;
+    }
+    return 'prod';
+}
+/**
+ * Gets the default branch name from git remote
+ */
+function getDefaultBranch() {
+    try {
+        // Try to get the default branch from remote HEAD
+        const remoteHead = (0, child_process_1.execSync)('git symbolic-ref refs/remotes/origin/HEAD', {
+            timeout: 2000, // 2 second timeout
+            stdio: 'pipe'
+        }).toString().trim();
+        const match = remoteHead.match(/refs\/remotes\/origin\/(.+)$/);
+        if (match) {
+            return match[1];
+        }
+    }
+    catch (e) {
+        // If that fails, try to get it from the current branch
+        try {
+            return getCurrentGitBranch();
+        }
+        catch (e2) {
+            // Fall back to common defaults
+        }
+    }
+    // Default fallback
+    return 'main';
+}

package/dist/src/core/utils/include-resolver.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Resolve {{include:path}} directives in registry content.
+ *
+ * Used by: MCP service (get_fraim_file, get_fraim_workflow), AI Mentor (phase instructions),
+ * and any other server-side content that needs includes resolved.
+ *
+ * - Resolves recursively (e.g. skills can include other skills)
+ * - MAX_PASSES prevents infinite loops from circular includes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_INCLUDE_PASSES = void 0;
+exports.resolveIncludesWithIndex = resolveIncludesWithIndex;
+exports.resolveIncludes = resolveIncludes;
+const fs_1 = require("fs");
+/** Maximum resolution passes to prevent infinite loops from circular includes */
+exports.MAX_INCLUDE_PASSES = 10;
+/**
+ * Resolve {{include:path}} directives in content.
+ * Looks up referenced files in the fileIndex and inlines their content.
+ *
+ * @param content - Raw content that may contain {{include:path}} directives
+ * @param fileIndex - Map of path -> { fullPath, ... } for registry files
+ * @returns Content with all resolvable includes inlined (recursive, up to MAX_PASSES)
+ */
+function resolveIncludesWithIndex(content, fileIndex) {
+    let result = content;
+    let pass = 0;
+    while (result.includes('{{include:') && pass < exports.MAX_INCLUDE_PASSES) {
+        result = result.replace(/\{\{include:([^}]+)\}\}/g, (match, filePath) => {
+            const trimmedPath = filePath.trim();
+            const fileEntry = fileIndex.get(trimmedPath);
+            if (fileEntry?.fullPath) {
+                try {
+                    return (0, fs_1.readFileSync)(fileEntry.fullPath, 'utf-8');
+                }
+                catch (error) {
+                    console.error(`❌ Failed to read included file: ${trimmedPath}`, error);
+                    return match;
+                }
+            }
+            console.warn(`⚠️ Include file not found in fileIndex: ${trimmedPath}`);
+            return match;
+        });
+        pass++;
+    }
+    return result;
+}
+/**
+ * Asynchronously resolve {{include:path}} directives in content using a RegistryResolver.
+ *
+ * @param content - Raw content that may contain {{include:path}} directives
+ * @param resolver - RegistryResolver instance
+ * @returns Content with all resolvable includes inlined
+ */
+async function resolveIncludes(content, resolver, basePath) {
+    let result = content;
+    let pass = 0;
+    while (result.includes('{{include:') && pass < exports.MAX_INCLUDE_PASSES) {
+        // Collect all unique includes in this pass
+        const matches = result.match(/\{\{include:([^}]+)\}\}/g);
+        if (!matches)
+            break;
+        const uniqueMatches = Array.from(new Set(matches));
+        for (const match of uniqueMatches) {
+            const filePath = match.match(/\{\{include:([^}]+)\}\}/)[1].trim();
+            let targetPath = filePath;
+            if (filePath.startsWith('./') && basePath) {
+                // Resolve relative to the directory of the current file
+                const dir = basePath.includes('/') ? basePath.substring(0, basePath.lastIndexOf('/')) : '';
+                targetPath = dir ? `${dir}/${filePath.substring(2)}` : filePath.substring(2);
+            }
+            try {
+                const fileContent = await resolver.getFile(targetPath);
+                if (fileContent !== null) {
+                    // Recursively resolve includes in the newly fetched content
+                    const resolvedContent = await resolveIncludes(fileContent, resolver, targetPath);
+                    // Replace all occurrences of this specific include
+                    result = result.split(match).join(resolvedContent);
+                }
+                else {
+                    console.warn(`⚠️ Include file not found via resolver: ${targetPath} (original: ${filePath}, base: ${basePath})`);
+                }
+            }
+            catch (error) {
+                console.error(`❌ Failed to resolve include via resolver: ${targetPath}`, error);
+            }
+        }
+        pass++;
+    }
+    return result;
+}

package/dist/src/core/utils/inheritance-parser.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * InheritanceParser
+ *
+ * Parses and resolves {{ import: path }} directives in registry files,
+ * enabling local overrides to inherit from global registry files.
+ *
+ * Security features:
+ * - Path traversal protection (rejects .. and absolute paths)
+ * - Circular import detection
+ * - Max depth limit (5 levels)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InheritanceParser = exports.InheritanceError = void 0;
+class InheritanceError extends Error {
+    constructor(message, path) {
+        super(message);
+        this.path = path;
+        this.name = 'InheritanceError';
+    }
+}
+exports.InheritanceError = InheritanceError;
+/**
+ * Regular expression to match {{ import: path }} directives
+ */
+const IMPORT_REGEX = /\{\{\s*import:\s*([^\}]+)\s*\}\}/g;
+class InheritanceParser {
+    constructor(maxDepth = 5) {
+        this.maxDepth = maxDepth;
+    }
+    /**
+     * Extract import directives from content without resolving them
+     */
+    extractImports(content) {
+        const imports = [];
+        let match;
+        // Reset regex state
+        IMPORT_REGEX.lastIndex = 0;
+        while ((match = IMPORT_REGEX.exec(content)) !== null) {
+            imports.push(match[1].trim());
+        }
+        return imports;
+    }
+    /**
+     * Sanitize and validate import path
+     *
+     * @throws {InheritanceError} If path is invalid
+     */
+    sanitizePath(path) {
+        const trimmed = path.trim();
+        // Reject empty paths
+        if (!trimmed) {
+            throw new InheritanceError('Import path cannot be empty');
+        }
+        // Reject absolute paths (Unix and Windows)
+        if (trimmed.startsWith('/') || trimmed.match(/^[A-Za-z]:\\/)) {
+            throw new InheritanceError(`Absolute paths not allowed: ${trimmed}`, trimmed);
+        }
+        // Reject path traversal attempts
+        if (trimmed.includes('..')) {
+            throw new InheritanceError(`Path traversal not allowed: ${trimmed}`, trimmed);
+        }
+        return trimmed;
+    }
+    /**
+     * Detect circular imports
+     *
+     * Special case: If the import path is the same as the current path,
+     * it's not a circular import - it's importing the parent/remote version.
+     * This allows local overrides to inherit from their remote counterparts.
+     *
+     * @throws {InheritanceError} If circular import detected
+     */
+    detectCircularImport(path, visited, isParentImport = false) {
+        // If this is a parent import (same path as current), allow it
+        if (isParentImport) {
+            return;
+        }
+        if (visited.has(path)) {
+            throw new InheritanceError(`Circular import detected: ${path}`, path);
+        }
+    }
+    /**
+     * Resolve all import and extends directives in content recursively
+     *
+     * @param content - Content with {{ import }} or extends frontmatter
+     * @param currentPath - Path of current file (for circular detection)
+     * @param options - Resolution options
+     * @returns Resolved content with all inheritance applied
+     *
+     * @throws {InheritanceError} If circular inheritance, path traversal, or max depth exceeded
+     */
+    async resolve(content, currentPath, options) {
+        const depth = options.currentDepth || 0;
+        const visited = options.visited || new Set();
+        const maxDepth = options.maxDepth || this.maxDepth;
+        // Check depth limit
+        if (depth > maxDepth) {
+            throw new InheritanceError(`Max inheritance depth exceeded (${maxDepth})`, currentPath);
+        }
+        // Check circular inheritance (but allow importing/extending the same path as parent)
+        this.detectCircularImport(currentPath, visited, false);
+        visited.add(currentPath);
+        let resolvedContent = content;
+        // 1. Handle JSON frontmatter 'extends'
+        const metadataMatch = resolvedContent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        if (metadataMatch) {
+            try {
+                const metadata = JSON.parse(metadataMatch[1]);
+                const extendsPath = metadata.extends;
+                if (extendsPath && typeof extendsPath === 'string') {
+                    // Sanitize path
+                    const sanitizedExtends = this.sanitizePath(extendsPath);
+                    const isParentExtends = sanitizedExtends === currentPath;
+                    // Fetch parent content
+                    let parentContent;
+                    try {
+                        parentContent = await options.fetchParent(sanitizedExtends);
+                    }
+                    catch (error) {
+                        throw new InheritanceError(`Failed to fetch extended parent content: ${sanitizedExtends}. ${error.message}`, sanitizedExtends);
+                    }
+                    // Recursively resolve parent
+                    const parentVisited = isParentExtends ? new Set() : new Set(visited);
+                    const resolvedParent = await this.resolve(parentContent, sanitizedExtends, {
+                        ...options,
+                        currentDepth: depth + 1,
+                        visited: parentVisited
+                    });
+                    // Merge current content with resolved parent
+                    resolvedContent = this.mergeContent(resolvedContent, resolvedParent);
+                }
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    // Not JSON or invalid JSON, ignore extends logic but log it
+                    console.warn(`[InheritanceParser] Failed to parse frontmatter for ${currentPath}: ${error.message}`);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        // 2. Handle {{ import: path }}
+        const imports = this.extractImports(resolvedContent);
+        for (const importPath of imports) {
+            // Sanitize path
+            const sanitized = this.sanitizePath(importPath);
+            // Check if this is a parent import (same path as current)
+            const isParentImport = sanitized === currentPath;
+            // Fetch parent content
+            let parentContent;
+            try {
+                parentContent = await options.fetchParent(sanitized);
+            }
+            catch (error) {
+                throw new InheritanceError(`Failed to fetch parent content: ${sanitized}. ${error.message}`, sanitized);
+            }
+            // Recursively resolve parent imports
+            const parentVisited = isParentImport ? new Set() : new Set(visited);
+            const resolvedParent = await this.resolve(parentContent, sanitized, {
+                ...options,
+                currentDepth: depth + 1,
+                visited: parentVisited
+            });
+            // Replace import directive with resolved parent content
+            const importDirective = `{{ import: ${importPath} }}`;
+            resolvedContent = resolvedContent.replace(importDirective, resolvedParent);
+        }
+        return resolvedContent;
+    }
+    /**
+     * Merge two registry files (child override + parent base)
+     *
+     * Merging rules:
+     * 1. Metadata: JSON merge (child overrides parent)
+     * 2. Overview: Parent overview + child overview (if multi-para)
+     * 3. Phases: Phase override (child phase with same ID replaces parent phase)
+     */
+    mergeContent(child, parent) {
+        const childMatch = child.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        const parentMatch = parent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+        if (!childMatch || !parentMatch)
+            return child;
+        // 1. Merge Metadata
+        const childMeta = JSON.parse(childMatch[1]);
+        const parentMeta = JSON.parse(parentMatch[1]);
+        const mergedMeta = { ...parentMeta, ...childMeta };
+        delete mergedMeta.extends; // Remove extends from final merged content
+        // 2. Extract Body (everything after frontmatter)
+        const childBody = this.stripRedundantParentImports(child.substring(childMatch[0].length).trim(), typeof childMeta.extends === 'string' ? childMeta.extends : undefined);
+        const parentBody = parent.substring(parentMatch[0].length).trim();
+        // 3. Parse Phases and Overview
+        const parsePhases = (body) => {
+            const phases = new Map();
+            const sections = body.split(/^##\s+Phase:\s+/m);
+            const overview = sections[0]?.trim() || '';
+            for (let i = 1; i < sections.length; i++) {
+                const section = sections[i];
+                if (!section.trim())
+                    continue;
+                // Extract ID from first line: e.g. "implement-scoping (Primary)" -> "implement-scoping"
+                const firstLine = section.split(/\r?\n/)[0].trim();
+                const id = firstLine.split(/[ (]/)[0].trim().toLowerCase();
+                phases.set(id, `## Phase: ${section.trim()}`);
+            }
+            return { overview, phases };
+        };
+        const childParts = parsePhases(childBody);
+        const parentParts = parsePhases(parentBody);
+        // 4. Merge Overview: retain the parent framing, then append local overview additions.
+        const mergedOverview = childParts.overview
+            ? `${parentParts.overview}\n\n${childParts.overview}`.trim()
+            : parentParts.overview;
+        // 5. Merge Phases
+        const mergedPhases = new Map(parentParts.phases);
+        for (const [id, content] of childParts.phases.entries()) {
+            mergedPhases.set(id, content);
+        }
+        // 6. Reassemble
+        let finalContent = `---\n${JSON.stringify(mergedMeta, null, 2)}\n---\n\n`;
+        if (mergedOverview) {
+            finalContent += `${mergedOverview}\n\n`;
+        }
+        const addedPhases = new Set();
+        // First, add parent phases in order, using child overrides when present.
+        for (const id of parentParts.phases.keys()) {
+            if (mergedPhases.has(id)) {
+                finalContent += `${mergedPhases.get(id)}\n\n`;
+                addedPhases.add(id);
+            }
+        }
+        // Then append child-only phases in the order the child declared them.
+        for (const [id, content] of childParts.phases.entries()) {
+            if (!addedPhases.has(id)) {
+                finalContent += `${content}\n\n`;
+                addedPhases.add(id);
+            }
+        }
+        return finalContent.trim();
+    }
+    /**
+     * Parse content and return detailed information about imports
+     */
+    parse(content) {
+        const imports = this.extractImports(content);
+        const hasExtends = /^---\r?\n[\s\S]*?"extends":\s*"[^"]+"[\s\S]*?\r?\n---/m.test(content);
+        return {
+            content,
+            imports,
+            hasImports: imports.length > 0 || hasExtends
+        };
+    }
+    normalizeImportRef(path) {
+        let normalized = path.trim().replace(/\\/g, '/').replace(/^\/+/, '');
+        if (normalized.endsWith('.md')) {
+            normalized = normalized.slice(0, -3);
+        }
+        return normalized;
+    }
+    stripTypePrefix(path) {
+        return path.replace(/^(jobs|workflows|skills|rules|templates)\//, '');
+    }
+    isEquivalentImportRef(left, right) {
+        const normalizedLeft = this.normalizeImportRef(left);
+        const normalizedRight = this.normalizeImportRef(right);
+        const strippedLeft = this.stripTypePrefix(normalizedLeft);
+        const strippedRight = this.stripTypePrefix(normalizedRight);
+        return normalizedLeft === normalizedRight ||
+            strippedLeft === strippedRight ||
+            normalizedLeft.endsWith(`/${strippedRight}`) ||
+            normalizedRight.endsWith(`/${strippedLeft}`) ||
+            strippedLeft.endsWith(`/${strippedRight}`) ||
+            strippedRight.endsWith(`/${strippedLeft}`);
+    }
+    stripRedundantParentImports(body, extendsPath) {
+        if (!extendsPath) {
+            return body;
+        }
+        return body
+            .replace(/\{\{\s*import:\s*([^\}]+)\s*\}\}\s*\r?\n?/g, (match, importPath) => {
+            return this.isEquivalentImportRef(importPath, extendsPath) ? '' : match;
+        })
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+    }
+}
+exports.InheritanceParser = InheritanceParser;

package/dist/src/core/utils/job-parser.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobParser = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class JobParser {
+    static extractMetadataBlock(content) {
+        // Allow leading comments and whitespace before frontmatter
+        const frontmatterMatch = content.match(/^[\s\S]*?---\r?\n([\s\S]+?)\r?\n---/);
+        if (frontmatterMatch) {
+            try {
+                const startIndex = frontmatterMatch.index || 0;
+                return {
+                    state: 'valid',
+                    metadata: JSON.parse(frontmatterMatch[1]),
+                    bodyStartIndex: startIndex + frontmatterMatch[0].length
+                };
+            }
+            catch {
+                return { state: 'invalid' };
+            }
+        }
+        const trimmedStart = content.search(/\S/);
+        if (trimmedStart === -1 || content[trimmedStart] !== '{') {
+            return { state: 'none' };
+        }
+        let depth = 0;
+        let inString = false;
+        let escaping = false;
+        for (let i = trimmedStart; i < content.length; i++) {
+            const ch = content[i];
+            if (inString) {
+                if (escaping) {
+                    escaping = false;
+                }
+                else if (ch === '\\') {
+                    escaping = true;
+                }
+                else if (ch === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                continue;
+            }
+            if (ch === '{') {
+                depth++;
+                continue;
+            }
+            if (ch === '}') {
+                depth--;
+                if (depth === 0) {
+                    const bodyStartIndex = i + 1;
+                    const remainder = content.slice(bodyStartIndex).trimStart();
+                    // `{...}\n---` is usually malformed frontmatter, not bare JSON metadata.
+                    if (remainder.startsWith('---')) {
+                        return { state: 'none' };
+                    }
+                    try {
+                        return {
+                            state: 'valid',
+                            metadata: JSON.parse(content.slice(trimmedStart, bodyStartIndex)),
+                            bodyStartIndex
+                        };
+                    }
+                    catch {
+                        return { state: 'invalid' };
+                    }
+                }
+            }
+        }
+        return { state: 'none' };
+    }
+    /**
+     * Parse a job markdown file into a structured definition
+     * Supports three formats:
+     * 1. Phase-based jobs with JSON frontmatter
+     * 2. Phase-based jobs with bare leading JSON metadata
+     * 3. Simple jobs without metadata
+     */
+    static parse(filePath) {
+        if (!(0, fs_1.existsSync)(filePath))
+            return null;
+        let content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+        if (content.charCodeAt(0) === 0xfeff) {
+            content = content.slice(1);
+        }
+        const metadataBlock = this.extractMetadataBlock(content);
+        if (metadataBlock.state === 'invalid') {
+            return null;
+        }
+        if (metadataBlock.state === 'valid') {
+            return this.parsePhaseBasedJob(filePath, content, metadataBlock.metadata, metadataBlock.bodyStartIndex);
+        }
+        return this.parseSimpleJob(filePath, content);
+    }
+    static parsePhaseBasedJob(filePath, content, metadata, bodyStartIndex) {
+        const contentAfterMetadata = content.substring(bodyStartIndex).trim();
+        const firstPhaseIndex = contentAfterMetadata.search(/^##\s+Phase:/m);
+        let overview = '';
+        let restOfContent = '';
+        if (firstPhaseIndex !== -1) {
+            overview = contentAfterMetadata.substring(0, firstPhaseIndex).trim();
+            restOfContent = contentAfterMetadata.substring(firstPhaseIndex);
+        }
+        else {
+            overview = contentAfterMetadata;
+        }
+        const phases = new Map();
+        const phaseSections = restOfContent.split(/^##\s+Phase:\s*/im);
+        if (!metadata.phases) {
+            metadata.phases = {};
+        }
+        for (let i = 1; i < phaseSections.length; i++) {
+            const section = phaseSections[i];
+            const sectionLines = section.split('\n');
+            const firstLine = sectionLines[0].trim();
+            const id = firstLine.split(/[ (]/)[0].trim().toLowerCase();
+            phases.set(id, `## Phase: ${section.trim()}`);
+        }
+        return {
+            metadata,
+            overview,
+            phases,
+            isSimple: false,
+            path: filePath
+        };
+    }
+    static parseSimpleJob(filePath, content) {
+        const jobName = (0, path_1.basename)(filePath, '.md');
+        const metadata = {
+            name: jobName
+        };
+        return {
+            metadata,
+            overview: content.trim(),
+            phases: new Map(),
+            isSimple: true,
+            path: filePath
+        };
+    }
+    static parseContent(content, name, path) {
+        if (content.charCodeAt(0) === 0xfeff) {
+            content = content.slice(1);
+        }
+        const metadataBlock = this.extractMetadataBlock(content);
+        if (metadataBlock.state === 'invalid') {
+            return null;
+        }
+        if (metadataBlock.state === 'valid') {
+            return this.parsePhaseBasedJob(path || `content:${name}`, content, metadataBlock.metadata, metadataBlock.bodyStartIndex);
+        }
+        return this.parseSimpleJob(path || `content:${name}`, content);
+    }
+    static getOverviewFromContent(content, name) {
+        const job = this.parseContent(content, name);
+        return job ? job.overview : null;
+    }
+    static getOverview(filePath) {
+        const job = this.parse(filePath);
+        return job ? job.overview : null;
+    }
+    static extractDescription(filePath) {
+        const job = this.parse(filePath);
+        if (!job)
+            return '';
+        const intentMatch = job.overview.match(/## Intent\s+([\s\S]+?)(?:\r?\n##|$)/);
+        if (intentMatch)
+            return intentMatch[1].trim().split(/\r?\n/)[0];
+        const firstPara = job.overview.split(/\r?\n/).find(l => l.trim() !== '' && !l.startsWith('#'));
+        return firstPara ? firstPara.trim() : '';
+    }
+}
+exports.JobParser = JobParser;