fraim 2.0.177 → 2.0.180

package/dist/src/services/registry-service.js

@@ -0,0 +1,628 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryService = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = __importDefault(require("crypto"));
+const stub_generator_1 = require("../core/utils/stub-generator");
+const job_parser_1 = require("../core/utils/job-parser");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+class RegistryService {
+    constructor() {
+        this.fileIndex = new Map();
+        this.registryPath = this.findRegistryPath();
+        try {
+            this.buildFileIndex();
+        }
+        catch (err) {
+            console.error('❌ RegistryService.buildFileIndex failed:', err?.message ?? err);
+            if (err?.stack)
+                console.error(err.stack);
+            throw err;
+        }
+    }
+    /**
+     * Find registry directory
+     * Checks multiple locations (dist/registry, registry/) and ensures robustness.
+     * Prioritizes source directory in development and dist/ in production.
+     */
+    findRegistryPath() {
+        const isProd = process.env.NODE_ENV === 'production';
+        // Define candidate locations
+        const locations = [
+            // Preference 1: Explicitly from process.cwd() / registry (Development preference)
+            (0, path_1.join)(process.cwd(), 'registry'),
+            // Preference 2: Under dist/ (Production preference)
+            (0, path_1.join)(process.cwd(), 'dist', 'registry'),
+            // Preference 3: Relative to this file's directory (Fallback)
+            // from src/services/ or dist/src/services/
+            (0, path_1.join)(__dirname, '..', '..', 'registry'),
+            (0, path_1.join)(__dirname, '..', '..', '..', 'registry')
+        ];
+        // If we're in production, try dist/ first
+        if (isProd) {
+            locations.unshift((0, path_1.join)(process.cwd(), 'dist', 'registry'));
+        }
+        for (const loc of locations) {
+            if ((0, fs_1.existsSync)(loc)) {
+                // Validation: A valid registry should have some expected subfolders
+                if ((0, fs_1.existsSync)((0, path_1.join)(loc, 'jobs')) || (0, fs_1.existsSync)((0, path_1.join)(loc, 'rules')) || (0, fs_1.existsSync)((0, path_1.join)(loc, 'stubs'))) {
+                    return loc;
+                }
+            }
+        }
+        // Recursive search: Walk up from __dirname to find a valid 'registry'
+        let currentDir = __dirname;
+        while (currentDir !== (0, path_1.resolve)(currentDir, '..')) {
+            const candidate = (0, path_1.join)(currentDir, 'registry');
+            if ((0, fs_1.existsSync)(candidate) && ((0, fs_1.existsSync)((0, path_1.join)(candidate, 'jobs')) || (0, fs_1.existsSync)((0, path_1.join)(candidate, 'rules')))) {
+                return candidate;
+            }
+            const distCandidate = (0, path_1.join)(currentDir, 'dist', 'registry');
+            if ((0, fs_1.existsSync)(distCandidate) && (0, fs_1.existsSync)((0, path_1.join)(distCandidate, 'jobs'))) {
+                return distCandidate;
+            }
+            currentDir = (0, path_1.resolve)(currentDir, '..');
+        }
+        console.warn(`⚠️ RegistryService: registry directory not found in any standard location. Checked: ${locations.join(', ')}`);
+        // Final fallback: try to find something in cwd
+        return (0, path_1.join)(process.cwd(), 'registry');
+    }
+    /**
+     * Build an index of all files in registry directory
+     */
+    buildFileIndex() {
+        this.fileIndex.clear();
+        // 1. Index the main registry
+        if ((0, fs_1.existsSync)(this.registryPath)) {
+            console.log(`🔍 RegistryService: Indexing ${this.registryPath}...`);
+            this.indexDirectory(this.registryPath);
+            console.log(`✅ RegistryService: Indexed ${this.fileIndex.size} files.`);
+        }
+        else {
+            console.warn(`⚠️ RegistryService: registryPath does not exist: ${this.registryPath}`);
+        }
+    }
+    /**
+     * Index files in a directory
+     */
+    indexDirectory(dir, basePath = '') {
+        const indexFile = (dirPath, relativeBase = '') => {
+            let entries;
+            try {
+                entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+            }
+            catch (err) {
+                console.error(`❌ readdirSync failed for ${dirPath}:`, err?.message ?? err);
+                throw err;
+            }
+            for (const entry of entries) {
+                const fullPath = (0, path_1.join)(dirPath, entry.name);
+                // Normalize path separators to forward slashes for internal index
+                const relativePath = relativeBase ? (0, path_1.join)(relativeBase, entry.name) : entry.name;
+                const normalizedPath = relativePath.split(/[\\/]/).join('/');
+                let isFileEntry = entry.isFile();
+                const isDirectoryEntry = entry.isDirectory();
+                // On some environments (e.g., OneDrive/workspace virtualization),
+                // real files are surfaced as symlinks. Treat symlinked files as files.
+                if (!isFileEntry && !isDirectoryEntry && entry.isSymbolicLink()) {
+                    try {
+                        isFileEntry = (0, fs_1.statSync)(fullPath).isFile();
+                    }
+                    catch {
+                        // Ignore broken symlinks
+                        continue;
+                    }
+                }
+                if (isDirectoryEntry) {
+                    // Skip internal/junk directories
+                    const isJunkDir = entry.name.includes('Issue ') ||
+                        entry.name.includes('Master') ||
+                        entry.name === 'dist' ||
+                        entry.name === 'node_modules' ||
+                        entry.name === '.git' ||
+                        entry.name === '.github' ||
+                        entry.name === 'github' ||
+                        entry.name.startsWith('stubs.tmp-') ||
+                        entry.name.endsWith('-phases');
+                    if (isJunkDir) {
+                        continue;
+                    }
+                    indexFile(fullPath, normalizedPath);
+                }
+                else if (isFileEntry) {
+                    const extension = (0, path_1.extname)(entry.name).toLowerCase();
+                    let type = 'other';
+                    let category;
+                    // Determine type and category based on path and extension
+                    if (normalizedPath.includes('.github/')) {
+                        // Skip github workflows
+                        continue;
+                    }
+                    const isJob = normalizedPath.includes('jobs/');
+                    const isSkill = normalizedPath.includes('skills/');
+                    if (isJob) {
+                        type = 'job';
+                        const parts = normalizedPath.split('/');
+                        const jobIdx = parts.lastIndexOf('jobs');
+                        if (jobIdx !== -1 && parts[jobIdx + 1]) {
+                            category = parts[jobIdx + 1];
+                            if ((category === 'ai-employee' || category === 'ai-manager') && parts[jobIdx + 2]) {
+                                category = parts[jobIdx + 2];
+                            }
+                            if (category.endsWith('.md')) {
+                                category = undefined;
+                            }
+                        }
+                    }
+                    else if (isSkill) {
+                        type = 'skill';
+                    }
+                    else if (normalizedPath.includes('rules/')) {
+                        type = 'rule';
+                    }
+                    else if (normalizedPath.includes('templates/')) {
+                        type = 'template';
+                    }
+                    else if (normalizedPath.includes('scripts/')) {
+                        type = 'script';
+                    }
+                    else if (normalizedPath.includes('ai-manager-rules/') || normalizedPath.endsWith('-phases')) {
+                        type = 'phase';
+                    }
+                    // Stubs are identified by path or content
+                    const metadata = {
+                        path: normalizedPath,
+                        name: (0, path_1.basename)(entry.name, extension),
+                        type,
+                        category,
+                        keywords: this.extractKeywords(entry.name, normalizedPath),
+                        fullPath,
+                        isStub: normalizedPath.includes('stubs/')
+                    };
+                    this.fileIndex.set(normalizedPath, metadata);
+                }
+            }
+        };
+        indexFile(dir, basePath);
+    }
+    extractKeywords(filename, path) {
+        const tokens = [...filename.split(/[-_.\s]/), ...path.split('/')];
+        return Array.from(new Set(tokens))
+            .map(t => t.toLowerCase())
+            .filter(t => t.length > 2 && !['fraim', 'rule', 'template', 'md', 'ts', 'js'].includes(t));
+    }
+    collectMarkdownRelativePaths(rootDir, currentRelativeDir = '') {
+        if (!(0, fs_1.existsSync)(rootDir)) {
+            return [];
+        }
+        const results = [];
+        const entries = (0, fs_1.readdirSync)(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relativePath = currentRelativeDir
+                ? (0, path_1.join)(currentRelativeDir, entry.name)
+                : entry.name;
+            const normalizedRelativePath = relativePath.split(/[\\/]/).join('/');
+            const fullPath = (0, path_1.join)(rootDir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...this.collectMarkdownRelativePaths(fullPath, normalizedRelativePath));
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith('.md')) {
+                results.push(normalizedRelativePath);
+            }
+        }
+        return results;
+    }
+    getAvailableJobs() {
+        return Array.from(this.fileIndex.values())
+            .filter(m => m.type === 'job' && !m.path.includes('stubs/'))
+            .map(m => m.name);
+    }
+    getRegistryPath() {
+        return this.registryPath;
+    }
+    getFileIndex() {
+        return this.fileIndex;
+    }
+    findFileByPath(path) {
+        // console.log(`[RegistryService] findFileByPath: ${path}`);
+        return this.findFileByPathInternal(path, new Set());
+    }
+    choosePreferredMatch(matches) {
+        if (matches.length === 0) {
+            return undefined;
+        }
+        return matches.find((match) => !match.isStub) || matches[0];
+    }
+    findFileByPathInternal(path, visited) {
+        const normalized = path.replace(/^\/+/, '').split(/[\\/]/).join('/');
+        if (visited.has(normalized))
+            return undefined;
+        visited.add(normalized);
+        const literal = this.fileIndex.get(normalized);
+        if (literal)
+            return literal;
+        if (!normalized.endsWith('.md')) {
+            const withMd = this.findFileByPathInternal(`${normalized}.md`, visited);
+            if (withMd)
+                return withMd;
+        }
+        // Role-based fallbacks for global registry
+        if (normalized.startsWith('skills/')) {
+            const sub = normalized.substring('skills/'.length);
+            if (!sub.startsWith('ai-employee/') && !sub.startsWith('ai-manager/')) {
+                return this.findFileByPathInternal(`skills/ai-employee/${sub}`, visited);
+            }
+        }
+        if (normalized.startsWith('rules/')) {
+            const sub = normalized.substring('rules/'.length);
+            if (!sub.startsWith('ai-employee/') && !sub.startsWith('ai-manager/')) {
+                return this.findFileByPathInternal(`rules/ai-employee/${sub}`, visited);
+            }
+        }
+        if (normalized.startsWith('jobs/')) {
+            const sub = normalized.substring('jobs/'.length);
+            if (!sub.startsWith('ai-employee/') && !sub.startsWith('ai-manager/')) {
+                return this.findFileByPathInternal(`jobs/ai-employee/${sub}`, visited) ||
+                    this.findFileByPathInternal(`jobs/ai-manager/${sub}`, visited) ||
+                    this.findFileByPathInternal(sub, visited);
+            }
+        }
+        if (normalized.startsWith('ai-employee/') || normalized.startsWith('ai-manager/')) {
+            const isTypePrefixed = normalized.includes('/jobs/') ||
+                normalized.includes('/skills/') || normalized.includes('/rules/');
+            if (!isTypePrefixed) {
+                return this.findFileByPathInternal(`jobs/${normalized}`, visited);
+            }
+        }
+        // Final fallback: suffix match for deeply nested leaf filenames
+        const suffixMatches = [];
+        for (const [indexPath, entry] of this.fileIndex.entries()) {
+            if (indexPath.endsWith(`/${normalized}`) || indexPath === normalized) {
+                suffixMatches.push(entry);
+            }
+        }
+        const preferredSuffixMatch = this.choosePreferredMatch(suffixMatches);
+        if (preferredSuffixMatch) {
+            return preferredSuffixMatch;
+        }
+        // Very desperate fallback: if it's just a filename, try matching it anywhere
+        if (!normalized.includes('/')) {
+            const filenameMatches = [];
+            for (const [indexPath, entry] of this.fileIndex.entries()) {
+                if (indexPath.endsWith(`/${normalized}`)) {
+                    filenameMatches.push(entry);
+                }
+            }
+            return this.choosePreferredMatch(filenameMatches);
+        }
+        return undefined;
+    }
+    getMetadata(path) {
+        return this.fileIndex.get(path);
+    }
+    getSyncBundle() {
+        const files = [];
+        const allFiles = Array.from(this.fileIndex.values());
+        // 1. Add job STUBS (not full jobs) from registry/stubs/jobs
+        const jobStubs = allFiles.filter(f => f.type === 'job' && f.path.includes('stubs/jobs/'));
+        let jobStubCount = 0;
+        for (const stub of jobStubs) {
+            try {
+                const content = (0, fs_1.readFileSync)(stub.fullPath, 'utf8');
+                const relativePath = stub.path.replace('stubs/jobs/', '');
+                files.push({
+                    path: relativePath,
+                    content,
+                    type: 'job'
+                });
+                jobStubCount++;
+            }
+            catch (error) {
+                console.error(`⚠️ Failed to read job stub ${stub.path}:`, error);
+            }
+        }
+        // 2b. Fallback: synthesize job stubs
+        const existingJobPaths = new Set(files.filter(f => f.type === 'job').map(f => f.path));
+        const jobs = allFiles.filter(f => f.type === 'job' && !f.path.includes('stubs/') && f.path.startsWith('jobs/') && f.path.endsWith('.md'));
+        if (jobStubCount < jobs.length) {
+            for (const job of jobs) {
+                try {
+                    const relativePath = job.path.replace('jobs/', '');
+                    if (existingJobPaths.has(relativePath)) {
+                        continue;
+                    }
+                    const content = (0, fs_1.readFileSync)(job.fullPath, 'utf8');
+                    const { intent, outcome, steps } = (0, stub_generator_1.parseRegistryJob)(content);
+                    const stub = (0, stub_generator_1.generateJobStub)(job.name, relativePath, intent, outcome, steps);
+                    files.push({
+                        path: relativePath,
+                        content: stub,
+                        type: 'job'
+                    });
+                    existingJobPaths.add(relativePath);
+                }
+                catch (error) {
+                    console.error(`⚠️ Failed to synthesize job stub ${job.path}:`, error);
+                }
+            }
+        }
+        // 2c. Add skill STUBS from registry/stubs/skills
+        const skillStubs = allFiles.filter(f => f.type === 'skill' && f.path.includes('stubs/skills/'));
+        const existingSkillPaths = new Set(files.filter(f => f.type === 'skill').map(f => f.path));
+        let skillStubCount = 0;
+        for (const stub of skillStubs) {
+            try {
+                const content = (0, fs_1.readFileSync)(stub.fullPath, 'utf8');
+                const relativePath = stub.path.replace('stubs/skills/', '');
+                if (existingSkillPaths.has(relativePath)) {
+                    continue;
+                }
+                files.push({
+                    path: relativePath,
+                    content,
+                    type: 'skill'
+                });
+                existingSkillPaths.add(relativePath);
+                skillStubCount++;
+            }
+            catch (error) {
+                console.error(`⚠️ Failed to read skill stub ${stub.path}:`, error);
+            }
+        }
+        // 2d. Fallback: synthesize skill stubs
+        const skills = allFiles.filter(f => f.type === 'skill' && !f.path.includes('stubs/') && f.path.startsWith('skills/') && f.path.endsWith('.md'));
+        if (skillStubCount < skills.length) {
+            for (const skill of skills) {
+                try {
+                    const relativePath = skill.path.replace('skills/', '');
+                    if (existingSkillPaths.has(relativePath)) {
+                        continue;
+                    }
+                    const content = (0, fs_1.readFileSync)(skill.fullPath, 'utf8');
+                    const { skillInput, skillOutput } = (0, stub_generator_1.parseRegistrySkill)(content);
+                    const stub = (0, stub_generator_1.generateSkillStub)(skill.name, relativePath, skillInput, skillOutput);
+                    files.push({
+                        path: relativePath,
+                        content: stub,
+                        type: 'skill'
+                    });
+                    existingSkillPaths.add(relativePath);
+                }
+                catch (error) {
+                    console.error(`⚠️ Failed to synthesize skill stub ${skill.path}:`, error);
+                }
+            }
+        }
+        // 2e. Add rule STUBS from registry/stubs/rules
+        const ruleStubs = allFiles.filter(f => f.type === 'rule' && f.path.includes('stubs/rules/'));
+        const existingRulePaths = new Set(files.filter(f => f.type === 'rule').map(f => f.path));
+        let ruleStubCount = 0;
+        for (const stub of ruleStubs) {
+            try {
+                const content = (0, fs_1.readFileSync)(stub.fullPath, 'utf8');
+                const relativePath = stub.path.replace('stubs/rules/', '');
+                if (existingRulePaths.has(relativePath)) {
+                    continue;
+                }
+                files.push({
+                    path: relativePath,
+                    content,
+                    type: 'rule'
+                });
+                existingRulePaths.add(relativePath);
+                ruleStubCount++;
+            }
+            catch (error) {
+                console.error(`⚠️ Failed to read rule stub ${stub.path}:`, error);
+            }
+        }
+        // 2f. Fallback: synthesize rule stubs
+        const rules = allFiles.filter(f => f.type === 'rule' && !f.path.includes('stubs/') && f.path.startsWith('rules/') && f.path.endsWith('.md'));
+        if (ruleStubCount < rules.length) {
+            for (const rule of rules) {
+                try {
+                    const relativePath = rule.path.replace('rules/', '');
+                    if (existingRulePaths.has(relativePath)) {
+                        continue;
+                    }
+                    const content = (0, fs_1.readFileSync)(rule.fullPath, 'utf8');
+                    const { intent } = (0, stub_generator_1.parseRegistryRule)(content);
+                    const stub = (0, stub_generator_1.generateRuleStub)(rule.name, relativePath, intent);
+                    files.push({
+                        path: relativePath,
+                        content: stub,
+                        type: 'rule'
+                    });
+                    existingRulePaths.add(relativePath);
+                }
+                catch (error) {
+                    console.error(`⚠️ Failed to synthesize rule stub ${rule.path}:`, error);
+                }
+            }
+        }
+        // 3. Add scripts
+        const scripts = allFiles.filter(f => f.type === 'script');
+        for (const script of scripts) {
+            const ext = (0, path_1.extname)(script.path);
+            // Only skip .js/.js.map files if a corresponding .ts file exists
+            // Allow all other file types (.css, .sh, .py, etc.) to pass through
+            if (ext === '.js' || ext === '.js.map') {
+                const tsPath = script.path.replace(/\.js(\.map)?$/, '.ts');
+                if (Array.from(this.fileIndex.values()).some(f => f.path === tsPath)) {
+                    continue;
+                }
+            }
+            try {
+                const content = (0, fs_1.readFileSync)(script.fullPath, 'utf8');
+                const scriptRelativePath = script.path.startsWith('scripts/')
+                    ? script.path.substring('scripts/'.length)
+                    : script.name;
+                files.push({
+                    path: scriptRelativePath,
+                    content,
+                    type: 'script'
+                });
+            }
+            catch (error) {
+                console.error(`⚠️ Failed to read script ${script.path}:`, error);
+            }
+        }
+        // 5. Add docs
+        const docsDir = (0, path_1.join)(this.registryPath, 'docs');
+        if ((0, fs_1.existsSync)(docsDir)) {
+            try {
+                const docsEntries = (0, fs_1.readdirSync)(docsDir, { withFileTypes: true });
+                for (const entry of docsEntries) {
+                    if (entry.isFile() && entry.name.endsWith('.md')) {
+                        const fullPath = (0, path_1.join)(docsDir, entry.name);
+                        try {
+                            const content = (0, fs_1.readFileSync)(fullPath, 'utf8');
+                            files.push({
+                                path: entry.name,
+                                content,
+                                type: 'docs'
+                            });
+                        }
+                        catch (error) {
+                            console.error(`⚠️ Failed to read docs file ${entry.name}:`, error);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`⚠️ Failed to read docs directory: ${docsDir}`);
+            }
+        }
+        return files;
+    }
+    getGitHubWorkflowBundle() {
+        const workflowsDir = (0, path_1.join)(this.registryPath, 'github', 'workflows');
+        if (!(0, fs_1.existsSync)(workflowsDir)) {
+            return [];
+        }
+        const files = [];
+        const entries = (0, fs_1.readdirSync)(workflowsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.yml')) {
+                continue;
+            }
+            const fullPath = (0, path_1.join)(workflowsDir, entry.name);
+            const content = (0, fs_1.readFileSync)(fullPath, 'utf8');
+            files.push({
+                path: entry.name,
+                content,
+                type: 'github-workflow',
+                digest: `sha256:${crypto_1.default.createHash('sha256').update(content).digest('hex')}`
+            });
+        }
+        return files.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    getPersonalizedTopology() {
+        const personalizedRoot = (0, project_fraim_paths_1.getWorkspaceFraimPath)(process.cwd(), 'personalized-employee');
+        if (!(0, fs_1.existsSync)(personalizedRoot)) {
+            return { nodes: [], edges: [] };
+        }
+        const nodes = [];
+        const edges = [];
+        const seenNodeIds = new Set();
+        const normalize = (value) => value.split(/[\\/]/).join('/');
+        const addNode = (node) => {
+            if (seenNodeIds.has(node.id))
+                return;
+            seenNodeIds.add(node.id);
+            nodes.push(node);
+        };
+        const skillsRoot = (0, path_1.join)(personalizedRoot, 'skills');
+        if ((0, fs_1.existsSync)(skillsRoot)) {
+            for (const relativePath of this.collectMarkdownRelativePaths(skillsRoot)) {
+                const normalizedRelativePath = normalize(relativePath);
+                const skillId = normalizedRelativePath.replace(/\.md$/, '');
+                const category = skillId.split('/')[0] || 'uncategorized';
+                const baselinePath = (0, path_1.join)(this.registryPath, 'skills', normalizedRelativePath);
+                addNode({
+                    id: skillId,
+                    label: (0, path_1.basename)(skillId),
+                    type: 'skill',
+                    category,
+                    group: skillId.includes('/') ? skillId.slice(0, skillId.lastIndexOf('/')) : skillId,
+                    role: null,
+                    path: (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`personalized-employee/skills/${normalizedRelativePath}`),
+                    shadowing: (0, fs_1.existsSync)(baselinePath)
+                });
+            }
+        }
+        const jobsRoot = (0, path_1.join)(personalizedRoot, 'jobs');
+        if ((0, fs_1.existsSync)(jobsRoot)) {
+            for (const relativePath of this.collectMarkdownRelativePaths(jobsRoot)) {
+                const normalizedRelativePath = normalize(relativePath);
+                const jobPathWithoutExt = normalizedRelativePath.replace(/\.md$/, '');
+                const parts = jobPathWithoutExt.split('/');
+                const category = parts[0] || 'uncategorized';
+                const jobId = `job:${jobPathWithoutExt}`;
+                const baselinePath = (0, path_1.join)(this.registryPath, 'jobs', normalizedRelativePath);
+                const fullPath = (0, path_1.join)(jobsRoot, normalizedRelativePath);
+                const content = (0, fs_1.readFileSync)(fullPath, 'utf8');
+                addNode({
+                    id: jobId,
+                    label: (0, path_1.basename)(jobPathWithoutExt),
+                    type: 'job',
+                    category,
+                    group: parts.slice(0, -1).join('/') || category,
+                    role: category === 'ai-manager' ? 'ai-manager' : 'ai-employee',
+                    path: (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(`personalized-employee/jobs/${normalizedRelativePath}`),
+                    shadowing: (0, fs_1.existsSync)(baselinePath)
+                });
+                const includes = [...content.matchAll(/\{\{include:skills\/([^}]+)\.md\}\}/g)];
+                const seenSkills = new Set();
+                for (const match of includes) {
+                    const skillId = match[1];
+                    if (!skillId || seenSkills.has(skillId)) {
+                        continue;
+                    }
+                    seenSkills.add(skillId);
+                    edges.push({ source: jobId, target: skillId });
+                }
+            }
+        }
+        return { nodes, edges };
+    }
+    async getFile(path) {
+        const metadata = this.findFileByPath(path);
+        if (!metadata)
+            return null;
+        try {
+            return (0, fs_1.readFileSync)(metadata.fullPath, 'utf8');
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async getJob(name) {
+        const allMatches = Array.from(this.fileIndex.values()).filter(f => f.name === name && f.type === 'job');
+        if (allMatches.length === 0)
+            return null;
+        const metadata = allMatches.find(f => !f.isStub) || allMatches[0];
+        const def = job_parser_1.JobParser.parse(metadata.fullPath);
+        if (def && !def.metadata.type) {
+            def.metadata.type = 'job';
+        }
+        return def;
+    }
+    async listItems(type) {
+        return Array.from(this.fileIndex.values())
+            .filter(f => !f.isStub && f.type === 'job')
+            .map(f => ({
+            name: f.name,
+            path: f.path,
+            type: f.type,
+            category: f.category,
+            description: job_parser_1.JobParser.extractDescription(f.fullPath)
+        }));
+    }
+}
+exports.RegistryService = RegistryService;