fraim-framework 2.0.86 → 2.0.88

package/dist/src/core/ai-mentor.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIMentor = void 0;
+const include_resolver_1 = require("./utils/include-resolver");
+class AIMentor {
+    constructor(resolver) {
+        this.workflowCache = new Map();
+        this.resolver = resolver;
+    }
+    /**
+     * Handle mentoring/coaching request from agent
+     */
+    async handleMentoringRequest(args) {
+        const workflow = await this.getOrLoadWorkflow(args.workflowType);
+        if (!workflow) {
+            throw new Error(`Workflow "${args.workflowType}" not found or invalid.`);
+        }
+        const validStatus = ['starting', 'complete', 'incomplete', 'failure'].includes(args.status);
+        if (!validStatus) {
+            throw new Error(`Invalid status: ${args.status}. Must be one of: starting, complete, incomplete, failure.`);
+        }
+        // For simple workflows, skip phase validation
+        if (!workflow.isSimple) {
+            const phases = workflow.metadata.phases || {};
+            const hasMetadata = !!phases[args.currentPhase];
+            const hasMarkdown = workflow.phases.has(args.currentPhase);
+            if (!hasMetadata && !hasMarkdown && args.currentPhase !== 'starting') {
+                throw new Error(`Phase "${args.currentPhase}" not found in workflow "${args.workflowType}".`);
+            }
+        }
+        // Handle different statuses
+        if (args.status === 'starting') {
+            return await this.generateStartingMessage(workflow, args.currentPhase, args.skipIncludes);
+        }
+        else if (args.status === 'complete') {
+            return await this.generateCompletionMessage(workflow, args.currentPhase, args.findings, args.evidence, args.skipIncludes);
+        }
+        else {
+            return await this.generateHelpMessage(workflow, args.currentPhase, args.status, args.skipIncludes);
+        }
+    }
+    async getOrLoadWorkflow(workflowType, preferredType) {
+        if (this.workflowCache.has(workflowType)) {
+            return this.workflowCache.get(workflowType);
+        }
+        const workflow = await this.resolver.getWorkflow(workflowType, preferredType);
+        if (workflow) {
+            this.workflowCache.set(workflowType, workflow);
+            return workflow;
+        }
+        return null;
+    }
+    async resolveIncludes(content, basePath) {
+        return (0, include_resolver_1.resolveIncludes)(content, this.resolver, basePath);
+    }
+    assertNoUnresolvedIncludes(content, context) {
+        const matches = content.match(/\{\{include:[^}]+\}\}/g);
+        if (!matches || matches.length === 0)
+            return;
+        const unique = Array.from(new Set(matches));
+        throw new Error(`Unresolved include directives in ${context}: ${unique.join(', ')}`);
+    }
+    buildReportBackFooter(workflowType, phaseId, phaseFlow) {
+        if (!phaseFlow)
+            return '';
+        const base = `seekMentoring({
+  workflowType: "${workflowType}",
+  issueNumber: "<issue_number>",
+  currentPhase: "${phaseId}",
+  status: "complete",`;
+        const onSuccess = phaseFlow.onSuccess;
+        let successBlock;
+        if (!onSuccess) {
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n>   // This is the final phase.\n> })\n> \`\`\``;
+        }
+        else if (typeof onSuccess === 'string') {
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> When you have finished all steps above, call:\n> \`\`\`javascript\n> ${base}\n> })\n> \`\`\``;
+        }
+        else {
+            const validOutcomes = Object.keys(onSuccess)
+                .filter(k => k !== 'default')
+                .map(k => `"${k}"`)
+                .join(' | ');
+            successBlock = `\n\n---\n\n> **⚑ Phase Complete — Report Back**\n> The next phase depends on your outcome. Set \`findings.issueType\` (or \`findings.phaseOutcome\`) to one of: ${validOutcomes}\n>\n> Then call:\n> \`\`\`javascript\n> ${base}\n>   findings: { issueType: "<Outcome>" }\n> })\n> \`\`\``;
+        }
+        return successBlock;
+    }
+    /** Phase-authority content injected for all phased workflows. Loaded from orchestration/phase-authority.md. */
+    async getPhaseAuthorityContent() {
+        try {
+            const content = await this.resolver.getFile('orchestration/phase-authority.md');
+            return content?.trim() || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async prependPhaseAuthority(message, isPhased) {
+        if (!isPhased)
+            return message;
+        const block = await this.getPhaseAuthorityContent();
+        if (!block)
+            return message;
+        return `${block}\n\n---\n\n${message}`;
+    }
+    async generateStartingMessage(workflow, phaseId, skipIncludes) {
+        const isJob = workflow.metadata.type === 'job';
+        const entityType = isJob ? 'Job' : 'Workflow';
+        if (workflow.isSimple) {
+            const message = `🚀 **Starting ${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (starting)`);
+            return {
+                message,
+                nextPhase: null,
+                status: 'starting'
+            };
+        }
+        const isVeryFirstCall = phaseId === 'starting';
+        const targetPhase = isVeryFirstCall ? (workflow.metadata.initialPhase || 'starting') : phaseId;
+        let message = '';
+        if (!isJob) {
+            message += `🚀 **Starting Workflow: ${workflow.metadata.name}**\n\n`;
+            if (isVeryFirstCall) {
+                message += `${workflow.overview}\n\n---\n\n`;
+            }
+        }
+        let instructions = workflow.phases.get(targetPhase);
+        if (instructions) {
+            instructions = skipIncludes ? instructions : await this.resolveIncludes(instructions, workflow.path);
+            message += `${instructions}`;
+        }
+        else {
+            message += `⚠️ No specific instructions found for phase: ${targetPhase}`;
+        }
+        if (isJob) {
+            const phaseFlow = workflow.metadata.phases?.[targetPhase];
+            message += this.buildReportBackFooter(workflow.metadata.name, targetPhase, phaseFlow);
+        }
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${targetPhase} (starting)`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: targetPhase,
+            status: 'starting'
+        };
+    }
+    async generateCompletionMessage(workflow, phaseId, findings, evidence, skipIncludes) {
+        const isJob = workflow.metadata.type === 'job';
+        const entityType = isJob ? 'Job' : 'Workflow';
+        if (workflow.isSimple) {
+            const message = `✅ **${entityType} Complete: ${workflow.metadata.name}**\n\n🎉 Great work! You have completed the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (complete)`);
+            return {
+                message,
+                nextPhase: null,
+                status: 'complete'
+            };
+        }
+        const phaseFlow = workflow.metadata.phases?.[phaseId];
+        let nextPhaseId = null;
+        if (phaseFlow && phaseFlow.onSuccess) {
+            if (typeof phaseFlow.onSuccess === 'string') {
+                nextPhaseId = phaseFlow.onSuccess;
+            }
+            else {
+                const outcome = findings?.phaseOutcome ?? findings?.issueType ?? evidence?.issueType ?? evidence?.phaseOutcome ?? 'default';
+                nextPhaseId = phaseFlow.onSuccess[outcome] ?? phaseFlow.onSuccess['default'] ?? null;
+            }
+        }
+        let message = '';
+        if (nextPhaseId) {
+            if (isJob) {
+                message += `Great work. Moving to the next phase: **${nextPhaseId}**.\n\n`;
+            }
+            else {
+                message += `✅ **Phase Complete: ${phaseId}**\n\nMoving to the next phase: **${nextPhaseId}**.\n\n`;
+            }
+            let nextInstructions = workflow.phases.get(nextPhaseId);
+            if (nextInstructions) {
+                nextInstructions = skipIncludes ? nextInstructions : await this.resolveIncludes(nextInstructions, workflow.path);
+                message += nextInstructions;
+            }
+            if (isJob) {
+                const nextPhaseFlow = workflow.metadata.phases?.[nextPhaseId];
+                message += this.buildReportBackFooter(workflow.metadata.name, nextPhaseId, nextPhaseFlow);
+            }
+        }
+        else {
+            message += `🎉 **${entityType} Accomplished!** You have completed all phases of the ${workflow.metadata.name} ${entityType.toLowerCase()}.`;
+        }
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${phaseId} (complete)`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: nextPhaseId,
+            status: 'complete'
+        };
+    }
+    async generateHelpMessage(workflow, phaseId, status, skipIncludes) {
+        const entityType = workflow.metadata.type === 'job' ? 'Job' : 'Workflow';
+        if (workflow.isSimple) {
+            const message = `**${entityType}: ${workflow.metadata.name}**\n\n${workflow.overview}`;
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name} (${status})`);
+            return {
+                message,
+                nextPhase: null,
+                status
+            };
+        }
+        const phaseMeta = workflow.metadata.phases?.[phaseId];
+        const targetPhaseId = status === 'failure' ? (phaseMeta?.onFailure || phaseId) : phaseId;
+        let message = `### Current Phase: ${targetPhaseId}\n\n`;
+        let instructions = workflow.phases.get(targetPhaseId);
+        if (instructions) {
+            instructions = skipIncludes ? instructions : await this.resolveIncludes(instructions, workflow.path);
+            message += instructions;
+        }
+        if (!skipIncludes) {
+            this.assertNoUnresolvedIncludes(message, `${workflow.metadata.name}:${targetPhaseId} (${status})`);
+        }
+        return {
+            message: await this.prependPhaseAuthority(message, true),
+            nextPhase: targetPhaseId,
+            status
+        };
+    }
+    async getWorkflowOverview(workflowType) {
+        const workflow = await this.getOrLoadWorkflow(workflowType, 'workflow');
+        return workflow ? { overview: workflow.overview, isSimple: workflow.isSimple } : null;
+    }
+    async getJobOverview(jobName) {
+        const job = await this.getOrLoadWorkflow(jobName, 'job');
+        return job ? { overview: job.overview, isSimple: job.isSimple } : null;
+    }
+    async getAllWorkflowMetadata() {
+        const items = await this.resolver.listItems('workflow');
+        const workflows = [];
+        for (const item of items) {
+            const wf = await this.resolver.getWorkflow(item.name, 'workflow');
+            if (wf)
+                workflows.push(wf);
+        }
+        return workflows;
+    }
+}
+exports.AIMentor = AIMentor;

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

@@ -12,9 +12,9 @@ const child_process_1 = require("child_process");
  */
 function getPort() {
     try {
-        const branchName = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
-        // Match issue-123 or 123-feature-name
-        const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/^(\d+)-/);
+        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)
@@ -31,8 +31,8 @@ function getPort() {
  */
 function determineDatabaseName() {
     try {
-        const branchName = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
-        const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/^(\d+)-/);
+        const branchName = process.env.FRAIM_BRANCH || (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]}`;
         }
@@ -60,7 +60,7 @@ function getCurrentGitBranch() {
  * Determines the database schema prefix based on the branch
  */
 function determineSchema(branchName) {
-    const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/^(\d+)-/);
+    const issueMatch = branchName.match(/issue-(\d+)/i) || branchName.match(/(\d+)-/);
     if (issueMatch) {
         return `issue_${issueMatch[1]}`;
     }

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

@@ -11,6 +11,7 @@
 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;
@@ -45,3 +46,47 @@ function resolveIncludesWithIndex(content, fileIndex) {
     }
     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

@@ -81,14 +81,14 @@ class InheritanceParser {
         }
     }
     /**
-     * Resolve all import directives in content recursively
+     * Resolve all import and extends directives in content recursively
      *
-     * @param content - Content with {{ import }} directives
+     * @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 imports replaced
+     * @returns Resolved content with all inheritance applied
      *
-     * @throws {InheritanceError} If circular import, path traversal, or max depth exceeded
+     * @throws {InheritanceError} If circular inheritance, path traversal, or max depth exceeded
      */
     async resolve(content, currentPath, options) {
         const depth = options.currentDepth || 0;
@@ -96,18 +96,53 @@ class InheritanceParser {
         const maxDepth = options.maxDepth || this.maxDepth;
         // Check depth limit
         if (depth > maxDepth) {
-            throw new InheritanceError(`Max import depth exceeded (${maxDepth})`, currentPath);
+            throw new InheritanceError(`Max inheritance depth exceeded (${maxDepth})`, currentPath);
         }
-        // Check circular imports (but allow importing the same path as parent)
+        // Check circular inheritance (but allow importing/extending the same path as parent)
         this.detectCircularImport(currentPath, visited, false);
         visited.add(currentPath);
-        // Extract imports
-        const imports = this.extractImports(content);
-        if (imports.length === 0) {
-            return content;
+        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;
+                }
+            }
         }
-        // Resolve each import
-        let resolved = content;
+        // 2. Handle {{ import: path }}
+        const imports = this.extractImports(resolvedContent);
         for (const importPath of imports) {
             // Sanitize path
             const sanitized = this.sanitizePath(importPath);
@@ -122,7 +157,6 @@ class InheritanceParser {
                 throw new InheritanceError(`Failed to fetch parent content: ${sanitized}. ${error.message}`, sanitized);
             }
             // Recursively resolve parent imports
-            // For parent imports, use a fresh visited set to allow the same path
             const parentVisited = isParentImport ? new Set() : new Set(visited);
             const resolvedParent = await this.resolve(parentContent, sanitized, {
                 ...options,
@@ -131,20 +165,124 @@ class InheritanceParser {
             });
             // Replace import directive with resolved parent content
             const importDirective = `{{ import: ${importPath} }}`;
-            resolved = resolved.replace(importDirective, resolvedParent);
+            resolvedContent = resolvedContent.replace(importDirective, resolvedParent);
         }
-        return resolved;
+        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
+            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;