fraim-framework 2.0.71 → 2.0.73

package/bin/fraim.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * FRAIM Framework CLI Entry Point

package/dist/src/cli/commands/doctor.js

@@ -8,6 +8,7 @@ const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const inheritance_parser_1 = require("../../core/utils/inheritance-parser");
 exports.doctorCommand = new commander_1.Command('doctor')
     .description('Validate FRAIM installation and configuration')
     .action(async () => {
@@ -71,4 +72,58 @@ exports.doctorCommand = new commander_1.Command('doctor')
     else {
         console.log(chalk_1.default.red(`\n🩹 Found ${issuesFound} issues. See recommendations above.`));
     }
+    // 5. Check for overrides
+    const overridesDir = path_1.default.join(fraimDir, 'overrides');
+    if (fs_1.default.existsSync(overridesDir)) {
+        console.log(chalk_1.default.blue('\n📝 Override Diagnostics:\n'));
+        const overrides = [];
+        const scanDir = (dir, base = '') => {
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const relativePath = path_1.default.join(base, entry.name);
+                if (entry.isDirectory()) {
+                    scanDir(path_1.default.join(dir, entry.name), relativePath);
+                }
+                else {
+                    overrides.push(relativePath.replace(/\\/g, '/'));
+                }
+            }
+        };
+        scanDir(overridesDir);
+        if (overrides.length === 0) {
+            console.log(chalk_1.default.gray('  No active overrides found.'));
+        }
+        else {
+            console.log(chalk_1.default.green(`  Found ${overrides.length} active override(s):\n`));
+            const parser = new inheritance_parser_1.InheritanceParser();
+            for (const override of overrides) {
+                const overridePath = path_1.default.join(overridesDir, override);
+                const content = fs_1.default.readFileSync(overridePath, 'utf-8');
+                const parseResult = parser.parse(content);
+                if (parseResult.hasImports) {
+                    console.log(chalk_1.default.white(`  📄 ${override}`));
+                    console.log(chalk_1.default.gray(`     Inherits from: ${parseResult.imports.join(', ')}`));
+                    // Validate import syntax
+                    let hasErrors = false;
+                    for (const importPath of parseResult.imports) {
+                        try {
+                            parser.sanitizePath(importPath);
+                        }
+                        catch (error) {
+                            console.log(chalk_1.default.red(`     ⚠️ Invalid import: ${error.message}`));
+                            hasErrors = true;
+                        }
+                    }
+                    if (!hasErrors) {
+                        console.log(chalk_1.default.green(`     ✅ Syntax valid`));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.white(`  📄 ${override}`));
+                    console.log(chalk_1.default.gray(`     Full override (no inheritance)`));
+                }
+                console.log('');
+            }
+        }
+    }
 });

package/dist/src/cli/commands/list-overridable.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listOverridableCommand = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+exports.listOverridableCommand = new commander_1.Command('list-overridable')
+    .description('List all FRAIM registry paths that can be overridden')
+    .option('--job-category <category>', 'Filter by workflow category (e.g., product-building, customer-development, marketing)')
+    .option('--rules', 'Show all overridable rules')
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    const fraimDir = path_1.default.join(projectRoot, '.fraim');
+    const configPath = path_1.default.join(fraimDir, 'config.json');
+    const overridesDir = path_1.default.join(fraimDir, 'overrides');
+    // Validate .fraim directory exists
+    if (!fs_1.default.existsSync(fraimDir)) {
+        console.log(chalk_1.default.red('❌ .fraim/ directory not found. Run "fraim setup" or "fraim init-project" first.'));
+        process.exit(1);
+    }
+    // Determine registry location (try framework root first, then node_modules)
+    let registryRoot = null;
+    const frameworkRoot = path_1.default.join(__dirname, '..', '..', '..');
+    const frameworkRegistry = path_1.default.join(frameworkRoot, 'registry');
+    if (fs_1.default.existsSync(frameworkRegistry)) {
+        registryRoot = frameworkRegistry;
+    }
+    else {
+        const nodeModulesRegistry = path_1.default.join(process.cwd(), 'node_modules', '@fraim', 'framework', 'registry');
+        if (fs_1.default.existsSync(nodeModulesRegistry)) {
+            registryRoot = nodeModulesRegistry;
+        }
+    }
+    if (!registryRoot) {
+        console.log(chalk_1.default.red('❌ Could not find FRAIM registry. Please ensure @fraim/framework is installed.'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue('📋 Overridable FRAIM Registry Paths:\n'));
+    // Get list of existing overrides
+    const existingOverrides = new Set();
+    if (fs_1.default.existsSync(overridesDir)) {
+        const scanDir = (dir, base = '') => {
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const relativePath = path_1.default.join(base, entry.name);
+                if (entry.isDirectory()) {
+                    scanDir(path_1.default.join(dir, entry.name), relativePath);
+                }
+                else {
+                    existingOverrides.add(relativePath.replace(/\\/g, '/'));
+                }
+            }
+        };
+        scanDir(overridesDir);
+    }
+    // Handle --rules flag
+    if (options.rules) {
+        const rulesDir = path_1.default.join(registryRoot, 'rules');
+        if (fs_1.default.existsSync(rulesDir)) {
+            console.log(chalk_1.default.bold.cyan('Rules:\n'));
+            const ruleFiles = fs_1.default.readdirSync(rulesDir)
+                .filter(f => f.endsWith('.md'))
+                .sort();
+            for (const file of ruleFiles) {
+                const filePath = `rules/${file}`;
+                const hasOverride = existingOverrides.has(filePath);
+                const status = hasOverride
+                    ? chalk_1.default.green('[OVERRIDDEN]')
+                    : chalk_1.default.gray('[OVERRIDABLE]');
+                console.log(`  ${status} ${filePath}`);
+            }
+            console.log('');
+        }
+        showTips();
+        return;
+    }
+    // Handle --job-category flag
+    if (options.jobCategory) {
+        const category = options.jobCategory;
+        const workflowsDir = path_1.default.join(registryRoot, 'workflows', category);
+        const templatesDir = path_1.default.join(registryRoot, 'templates', category);
+        if (!fs_1.default.existsSync(workflowsDir)) {
+            console.log(chalk_1.default.red(`❌ Category "${category}" not found.`));
+            console.log(chalk_1.default.gray('\nAvailable categories:'));
+            const categoriesDir = path_1.default.join(registryRoot, 'workflows');
+            const categories = fs_1.default.readdirSync(categoriesDir, { withFileTypes: true })
+                .filter(d => d.isDirectory())
+                .map(d => d.name)
+                .sort();
+            categories.forEach(c => console.log(chalk_1.default.gray(`  - ${c}`)));
+            process.exit(1);
+        }
+        // Show workflows for this category
+        console.log(chalk_1.default.bold.cyan(`Workflows (${category}):\n`));
+        const workflowFiles = fs_1.default.readdirSync(workflowsDir)
+            .filter(f => f.endsWith('.md'))
+            .sort();
+        for (const file of workflowFiles) {
+            const filePath = `workflows/${category}/${file}`;
+            const hasOverride = existingOverrides.has(filePath);
+            const status = hasOverride
+                ? chalk_1.default.green('[OVERRIDDEN]')
+                : chalk_1.default.gray('[OVERRIDABLE]');
+            console.log(`  ${status} ${filePath}`);
+        }
+        console.log('');
+        // Show templates for this category (if they exist)
+        if (fs_1.default.existsSync(templatesDir)) {
+            console.log(chalk_1.default.bold.cyan(`Templates (${category}):\n`));
+            const templateFiles = fs_1.default.readdirSync(templatesDir)
+                .filter(f => f.endsWith('.md') || f.endsWith('.html') || f.endsWith('.csv') || f.endsWith('.yml'))
+                .sort();
+            for (const file of templateFiles) {
+                const filePath = `templates/${category}/${file}`;
+                const hasOverride = existingOverrides.has(filePath);
+                const status = hasOverride
+                    ? chalk_1.default.green('[OVERRIDDEN]')
+                    : chalk_1.default.gray('[OVERRIDABLE]');
+                console.log(`  ${status} ${filePath}`);
+            }
+            console.log('');
+        }
+        showTips();
+        return;
+    }
+    // Default: Show available categories and existing overrides
+    console.log(chalk_1.default.bold.cyan('Available Workflow Categories:\n'));
+    const workflowsDir = path_1.default.join(registryRoot, 'workflows');
+    const categories = fs_1.default.readdirSync(workflowsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .sort();
+    // Group categories for better display
+    const columns = 3;
+    for (let i = 0; i < categories.length; i += columns) {
+        const row = categories.slice(i, i + columns);
+        const formatted = row.map(cat => chalk_1.default.gray(`  • ${cat.padEnd(30)}`)).join('');
+        console.log(formatted);
+    }
+    console.log('');
+    // Show existing overrides
+    if (existingOverrides.size > 0) {
+        console.log(chalk_1.default.bold.cyan('Your Active Overrides:\n'));
+        // Group by type
+        const overridesByType = {
+            workflows: [],
+            templates: [],
+            rules: [],
+            other: []
+        };
+        for (const override of Array.from(existingOverrides).sort()) {
+            if (override.startsWith('workflows/')) {
+                overridesByType.workflows.push(override);
+            }
+            else if (override.startsWith('templates/')) {
+                overridesByType.templates.push(override);
+            }
+            else if (override.startsWith('rules/')) {
+                overridesByType.rules.push(override);
+            }
+            else {
+                overridesByType.other.push(override);
+            }
+        }
+        if (overridesByType.workflows.length > 0) {
+            console.log(chalk_1.default.gray('  Workflows:'));
+            overridesByType.workflows.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.templates.length > 0) {
+            console.log(chalk_1.default.gray('  Templates:'));
+            overridesByType.templates.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.rules.length > 0) {
+            console.log(chalk_1.default.gray('  Rules:'));
+            overridesByType.rules.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.other.length > 0) {
+            console.log(chalk_1.default.gray('  Other:'));
+            overridesByType.other.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+    }
+    else {
+        console.log(chalk_1.default.gray('No active overrides yet.\n'));
+    }
+    showTips();
+    function showTips() {
+        console.log(chalk_1.default.gray('Tips:'));
+        console.log(chalk_1.default.gray('  • Use "fraim override <path> --inherit" to inherit from global'));
+        console.log(chalk_1.default.gray('  • Use "fraim override <path> --copy" to copy current content'));
+        console.log(chalk_1.default.gray('  • Use --job-category <category> to see category-specific items'));
+        console.log(chalk_1.default.gray('  • Use --rules to see all overridable rules'));
+        console.log(chalk_1.default.gray('  • Overrides are stored in .fraim/overrides/'));
+    }
+});

package/dist/src/cli/commands/override.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideCommand = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const axios_1 = __importDefault(require("axios"));
+const git_utils_1 = require("../../core/utils/git-utils");
+exports.overrideCommand = new commander_1.Command('override')
+    .description('Create a local override for a FRAIM registry file')
+    .argument('<path>', 'Registry path to override (e.g., workflows/product-building/spec.md)')
+    .option('--inherit', 'Create override with {{ import }} directive (inherits from global)')
+    .option('--copy', 'Copy current content from server to local')
+    .option('--local', 'Fetch from local development server (port derived from git branch)')
+    .action(async (registryPath, options) => {
+    const projectRoot = process.cwd();
+    const fraimDir = path_1.default.join(projectRoot, '.fraim');
+    const configPath = path_1.default.join(fraimDir, 'config.json');
+    // Validate .fraim directory exists
+    if (!fs_1.default.existsSync(fraimDir)) {
+        console.log(chalk_1.default.red('❌ .fraim/ directory not found. Run "fraim setup" or "fraim init-project" first.'));
+        process.exit(1);
+    }
+    // Validate path format
+    if (registryPath.includes('..') || path_1.default.isAbsolute(registryPath)) {
+        console.log(chalk_1.default.red('❌ Invalid path. Path must be relative and cannot contain ".."'));
+        process.exit(1);
+    }
+    // Ensure exactly one option is specified
+    if (options.inherit && options.copy) {
+        console.log(chalk_1.default.red('❌ Cannot use both --inherit and --copy. Choose one.'));
+        process.exit(1);
+    }
+    if (!options.inherit && !options.copy) {
+        console.log(chalk_1.default.red('❌ Must specify either --inherit or --copy.'));
+        process.exit(1);
+    }
+    // Create overrides directory structure
+    const overridePath = path_1.default.join(fraimDir, 'overrides', registryPath);
+    const overrideDir = path_1.default.dirname(overridePath);
+    if (!fs_1.default.existsSync(overrideDir)) {
+        fs_1.default.mkdirSync(overrideDir, { recursive: true });
+    }
+    // Check if override already exists
+    if (fs_1.default.existsSync(overridePath)) {
+        console.log(chalk_1.default.yellow(`⚠️ Override already exists: ${registryPath}`));
+        console.log(chalk_1.default.gray(`   Location: ${overridePath}`));
+        process.exit(0);
+    }
+    let content;
+    if (options.inherit) {
+        // Create file with import directive
+        content = `{{ import: ${registryPath} }}\n\n<!-- Add your custom content below -->\n`;
+        console.log(chalk_1.default.blue(`📝 Creating inherited override for: ${registryPath}`));
+    }
+    else {
+        // Fetch current content from server using MCP protocol
+        const isLocal = options.local || false;
+        const serverType = isLocal ? 'local server' : 'remote server';
+        console.log(chalk_1.default.blue(`📥 Fetching current content from ${serverType}: ${registryPath}`));
+        try {
+            // Read config to get remote URL
+            let config = {};
+            if (fs_1.default.existsSync(configPath)) {
+                config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+            }
+            // Determine server URL
+            let serverUrl;
+            if (isLocal) {
+                const localPort = process.env.FRAIM_MCP_PORT ? parseInt(process.env.FRAIM_MCP_PORT) : (0, git_utils_1.getPort)();
+                serverUrl = `http://localhost:${localPort}`;
+            }
+            else {
+                serverUrl = config.remoteUrl || process.env.FRAIM_REMOTE_URL || 'https://fraim.wellnessatwork.me';
+            }
+            const apiKey = isLocal ? 'local-dev' : (config.apiKey || process.env.FRAIM_API_KEY);
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+            if (apiKey) {
+                headers['x-api-key'] = apiKey;
+            }
+            // First, establish session with fraim_connect
+            const connectRequest = {
+                jsonrpc: '2.0',
+                id: 0,
+                method: 'tools/call',
+                params: {
+                    name: 'fraim_connect',
+                    arguments: {
+                        agent: { name: 'fraim-cli', model: 'override-command' },
+                        machine: {
+                            hostname: require('os').hostname(),
+                            platform: process.platform,
+                            memory: require('os').totalmem(),
+                            cpus: require('os').cpus().length
+                        },
+                        repo: {
+                            url: config.repository?.url || 'https://github.com/unknown/unknown',
+                            owner: config.repository?.owner || 'unknown',
+                            name: config.repository?.name || 'unknown',
+                            branch: 'main'
+                        }
+                    }
+                }
+            };
+            await axios_1.default.post(`${serverUrl}/mcp`, connectRequest, { headers, timeout: 30000 });
+            // Now determine MCP tool and arguments based on path
+            let toolName;
+            let toolArgs;
+            if (registryPath.startsWith('workflows/')) {
+                // Extract workflow name from path
+                // e.g., "workflows/product-building/spec.md" -> "spec"
+                const parts = registryPath.split('/');
+                const workflowName = parts[parts.length - 1].replace('.md', '');
+                toolName = 'get_fraim_workflow';
+                toolArgs = { workflow: workflowName };
+            }
+            else {
+                toolName = 'get_fraim_file';
+                toolArgs = { path: registryPath };
+            }
+            console.log(chalk_1.default.gray(`   Using MCP tool: ${toolName}`));
+            // Make MCP JSON-RPC request
+            const mcpRequest = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: {
+                    name: toolName,
+                    arguments: toolArgs
+                }
+            };
+            const response = await axios_1.default.post(`${serverUrl}/mcp`, mcpRequest, {
+                headers,
+                timeout: 30000
+            });
+            // Extract content from MCP response
+            if (response.data.error) {
+                throw new Error(response.data.error.message || 'MCP request failed');
+            }
+            const result = response.data.result;
+            if (!result || !result.content || !Array.isArray(result.content)) {
+                throw new Error('Unexpected MCP response format');
+            }
+            // Extract text content from MCP response
+            const textContent = result.content.find((c) => c.type === 'text');
+            if (!textContent || !textContent.text) {
+                throw new Error('No text content in MCP response');
+            }
+            content = textContent.text;
+            console.log(chalk_1.default.green(`✅ Fetched ${content.length} bytes from ${serverType}`));
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`❌ Failed to fetch content from ${serverType}: ${error.message}`));
+            if (isLocal) {
+                console.log(chalk_1.default.gray(`   Tip: Make sure the FRAIM server is running locally (npm run start:fraim)`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`   Tip: Check your API key and network connection`));
+                console.log(chalk_1.default.gray(`   Or use --local to fetch from a locally running server`));
+            }
+            process.exit(1);
+        }
+    }
+    // Write override file
+    try {
+        fs_1.default.writeFileSync(overridePath, content, 'utf-8');
+        console.log(chalk_1.default.green(`✅ Created override: ${registryPath}`));
+        console.log(chalk_1.default.gray(`   Location: ${overridePath}`));
+        console.log(chalk_1.default.gray(`   Edit this file to customize for your project`));
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`❌ Failed to write override file: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/src/cli/fraim.js

@@ -12,6 +12,8 @@ const setup_1 = require("./commands/setup");
 const init_project_1 = require("./commands/init-project");
 const test_mcp_1 = require("./commands/test-mcp");
 const add_ide_1 = require("./commands/add-ide");
+const override_1 = require("./commands/override");
+const list_overridable_1 = require("./commands/list-overridable");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -46,4 +48,6 @@ program.addCommand(setup_1.setupCommand);
 program.addCommand(init_project_1.initProjectCommand);
 program.addCommand(test_mcp_1.testMCPCommand);
 program.addCommand(add_ide_1.addIDECommand);
+program.addCommand(override_1.overrideCommand);
+program.addCommand(list_overridable_1.listOverridableCommand);
 program.parse(process.argv);

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

@@ -0,0 +1,150 @@
+"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 directives in content recursively
+     *
+     * @param content - Content with {{ import }} directives
+     * @param currentPath - Path of current file (for circular detection)
+     * @param options - Resolution options
+     * @returns Resolved content with all imports replaced
+     *
+     * @throws {InheritanceError} If circular import, 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 import depth exceeded (${maxDepth})`, currentPath);
+        }
+        // Check circular imports (but allow importing 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;
+        }
+        // Resolve each import
+        let resolved = content;
+        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
+            // 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,
+                currentDepth: depth + 1,
+                visited: parentVisited
+            });
+            // Replace import directive with resolved parent content
+            const importDirective = `{{ import: ${importPath} }}`;
+            resolved = resolved.replace(importDirective, resolvedParent);
+        }
+        return resolved;
+    }
+    /**
+     * Parse content and return detailed information about imports
+     */
+    parse(content) {
+        const imports = this.extractImports(content);
+        return {
+            content,
+            imports,
+            hasImports: imports.length > 0
+        };
+    }
+}
+exports.InheritanceParser = InheritanceParser;