@a5c-ai/agent-catalog 5.0.1-staging.c9bb2c61

package/dist/discovery.js

@@ -0,0 +1,728 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCatalogDiscoveryCache = clearCatalogDiscoveryCache;
+exports.getCatalogDiscoverySnapshot = getCatalogDiscoverySnapshot;
+exports.refreshCatalogDiscoverySnapshot = refreshCatalogDiscoverySnapshot;
+exports.listCatalogProcesses = listCatalogProcesses;
+exports.getCatalogProcessById = getCatalogProcessById;
+exports.listCatalogSkills = listCatalogSkills;
+exports.getCatalogSkillBySlug = getCatalogSkillBySlug;
+exports.listCatalogAgents = listCatalogAgents;
+exports.listCatalogDomains = listCatalogDomains;
+exports.getCatalogDomainByName = getCatalogDomainByName;
+exports.listCatalogSpecializations = listCatalogSpecializations;
+exports.getCatalogSpecializationByName = getCatalogSpecializationByName;
+exports.searchCatalogDiscovery = searchCatalogDiscovery;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = require("yaml");
+const PROCESS_EXTENSIONS = new Set([".js", ".mjs", ".ts"]);
+let cachedSnapshot;
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function packageRoot() {
+    return node_path_1.default.resolve(__dirname, "..");
+}
+function repoRoot() {
+    return node_path_1.default.resolve(packageRoot(), "..", "..");
+}
+function libraryRoot() {
+    return node_path_1.default.join(repoRoot(), "library");
+}
+function packagedSnapshotPath() {
+    return node_path_1.default.join(packageRoot(), "dist", "discovery-snapshot.json");
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/");
+}
+function toRepoRelative(filePath) {
+    return normalizePath(node_path_1.default.relative(repoRoot(), filePath));
+}
+function toLibraryRelative(filePath) {
+    return normalizePath(node_path_1.default.relative(libraryRoot(), filePath));
+}
+function readDirNames(dirPath) {
+    try {
+        return node_fs_1.default.readdirSync(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+function safeStat(filePath) {
+    try {
+        return node_fs_1.default.statSync(filePath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isoTimestamp(value) {
+    if (!value || Number.isNaN(value.getTime())) {
+        return new Date(0).toISOString();
+    }
+    return value.toISOString();
+}
+function createdAtFor(stats) {
+    const birthtime = stats?.birthtime;
+    if (birthtime && !Number.isNaN(birthtime.getTime()) && birthtime.getTime() > 0) {
+        return birthtime.toISOString();
+    }
+    return isoTimestamp(stats?.mtime);
+}
+function updatedAtFor(stats) {
+    return isoTimestamp(stats?.mtime);
+}
+function fileSize(filePath) {
+    return safeStat(filePath)?.size ?? 0;
+}
+function readFile(filePath) {
+    return node_fs_1.default.readFileSync(filePath, "utf8");
+}
+function isDirectory(filePath) {
+    return safeStat(filePath)?.isDirectory() ?? false;
+}
+function listFilesRecursively(dirPath, predicate) {
+    const results = [];
+    const walk = (currentPath) => {
+        for (const entry of readDirNames(currentPath)) {
+            if (entry.startsWith(".")) {
+                continue;
+            }
+            const entryPath = node_path_1.default.join(currentPath, entry);
+            if (isDirectory(entryPath)) {
+                walk(entryPath);
+                continue;
+            }
+            if (predicate(entryPath)) {
+                results.push(entryPath);
+            }
+        }
+    };
+    walk(dirPath);
+    return results.sort((left, right) => normalizePath(left).localeCompare(normalizePath(right)));
+}
+function fileExists(filePath) {
+    return safeStat(filePath)?.isFile() ?? false;
+}
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/);
+    if (!match) {
+        return { frontmatter: {}, content };
+    }
+    try {
+        const frontmatter = (0, yaml_1.parse)(match[1] ?? "");
+        return {
+            frontmatter: frontmatter && typeof frontmatter === "object" ? frontmatter : {},
+            content: content.slice(match[0].length),
+        };
+    }
+    catch {
+        return { frontmatter: {}, content: content.slice(match[0].length) };
+    }
+}
+function firstMarkdownParagraph(content) {
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("```"));
+    return lines[0] ?? "";
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function extractDomainFromPath(filePath) {
+    const normalized = normalizePath(filePath);
+    const match = normalized.match(/\/specializations\/domains\/([^/]+)/);
+    return match?.[1] ?? null;
+}
+function extractSpecializationFromPath(filePath) {
+    const normalized = normalizePath(filePath);
+    const domainMatch = normalized.match(/\/specializations\/domains\/[^/]+\/([^/]+)/);
+    if (domainMatch?.[1] && domainMatch[1] !== "agents" && domainMatch[1] !== "skills") {
+        return domainMatch[1];
+    }
+    const specMatch = normalized.match(/\/specializations\/([^/]+)/);
+    if (specMatch?.[1] && specMatch[1] !== "domains") {
+        return specMatch[1];
+    }
+    return null;
+}
+function parseMarkdownEntity(filePath) {
+    const raw = readFile(filePath);
+    const parsed = parseFrontmatter(raw);
+    const metadata = asRecord(parsed.frontmatter.metadata);
+    const name = stringValue(parsed.frontmatter.name) ?? node_path_1.default.basename(node_path_1.default.dirname(filePath));
+    const description = stringValue(parsed.frontmatter.description) ??
+        firstMarkdownParagraph(parsed.content) ??
+        "";
+    return {
+        name,
+        description,
+        content: parsed.content,
+        frontmatter: parsed.frontmatter,
+        metadata,
+    };
+}
+function findPrimaryDocPaths(baseDir) {
+    const readmePath = node_path_1.default.join(baseDir, "README.md");
+    const referencesPath = node_path_1.default.join(baseDir, "references.md");
+    return {
+        readmePath: node_fs_1.default.existsSync(readmePath) ? toRepoRelative(readmePath) : null,
+        referencesPath: node_fs_1.default.existsSync(referencesPath) ? toRepoRelative(referencesPath) : null,
+    };
+}
+function parseProcessIo(definition, includeRequired) {
+    if (!definition) {
+        return [];
+    }
+    const cleaned = definition.trim();
+    if (!cleaned.startsWith("{") || !cleaned.endsWith("}")) {
+        return [];
+    }
+    const body = cleaned.slice(1, -1).trim();
+    if (!body) {
+        return [];
+    }
+    const result = [];
+    let current = "";
+    let depth = 0;
+    for (const char of body) {
+        if (char === "{" || char === "[" || char === "(") {
+            depth += 1;
+            current += char;
+            continue;
+        }
+        if (char === "}" || char === "]" || char === ")") {
+            depth -= 1;
+            current += char;
+            continue;
+        }
+        if (char === "," && depth === 0) {
+            const entry = current.trim();
+            if (entry) {
+                const colonIndex = entry.indexOf(":");
+                if (colonIndex > 0) {
+                    let name = entry.slice(0, colonIndex).trim();
+                    const type = entry.slice(colonIndex + 1).trim();
+                    const required = !name.endsWith("?");
+                    if (!required) {
+                        name = name.slice(0, -1);
+                    }
+                    result.push(includeRequired ? { name, type, required } : { name, type });
+                }
+            }
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    const trailing = current.trim();
+    if (trailing) {
+        const colonIndex = trailing.indexOf(":");
+        if (colonIndex > 0) {
+            let name = trailing.slice(0, colonIndex).trim();
+            const type = trailing.slice(colonIndex + 1).trim();
+            const required = !name.endsWith("?");
+            if (!required) {
+                name = name.slice(0, -1);
+            }
+            result.push(includeRequired ? { name, type, required } : { name, type });
+        }
+    }
+    return result;
+}
+function parseProcessFile(filePath) {
+    const content = readFile(filePath);
+    const jsdocMatch = content.match(/\/\*\*[\s\S]*?\*\//);
+    if (!jsdocMatch) {
+        return null;
+    }
+    const jsdoc = jsdocMatch[0]
+        .replace(/\/\*\*/, "")
+        .replace(/\*\//, "")
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^\s*\*\s?/, ""))
+        .join("\n");
+    const processId = jsdoc.match(/@process\s+([^\n]+)/)?.[1]?.trim();
+    if (!processId) {
+        return null;
+    }
+    const description = jsdoc.match(/@description\s+([\s\S]*?)(?=@\w|$)/)?.[1]?.trim() ?? "";
+    const rawInputs = jsdoc.match(/@inputs\s+(\{[\s\S]*?\})/)?.[1];
+    const rawOutputs = jsdoc.match(/@outputs\s+(\{[\s\S]*?\})/)?.[1];
+    const taskMatches = Array.from(content.matchAll(/defineTask\(\s*["'`]([^"'`]+)["'`]/g));
+    const tasks = taskMatches.map((match) => {
+        const taskId = match[1] ?? "task";
+        const window = content.slice(match.index ?? 0, (match.index ?? 0) + 400);
+        const taskType = window.match(/kind:\s*["'`]([^"'`]+)["'`]/)?.[1] ?? "task";
+        return { id: taskId, type: taskType };
+    });
+    const frontmatter = {};
+    const version = jsdoc.match(/@version\s+([^\n]+)/)?.[1]?.trim();
+    const since = jsdoc.match(/@since\s+([^\n]+)/)?.[1]?.trim();
+    const author = jsdoc.match(/@author\s+([^\n]+)/)?.[1]?.trim();
+    if (author)
+        frontmatter.author = author;
+    if (version)
+        frontmatter.version = version;
+    if (since)
+        frontmatter.since = since;
+    const category = processId.includes("/")
+        ? processId.split("/")[0] ?? null
+        : extractSpecializationFromPath(filePath) ?? extractDomainFromPath(filePath);
+    return {
+        processId,
+        description,
+        category,
+        filePath: toRepoRelative(filePath),
+        inputs: parseProcessIo(rawInputs, true),
+        outputs: parseProcessIo(rawOutputs, false),
+        tasks,
+        frontmatter,
+    };
+}
+function catalogSkillSlugFor(filePath) {
+    return toLibraryRelative(node_path_1.default.dirname(filePath)).replace(/\//g, "--");
+}
+function parseSkillFile(filePath) {
+    const parsed = parseMarkdownEntity(filePath);
+    const stats = safeStat(filePath);
+    const domainName = stringValue(parsed.metadata.domain) ?? extractDomainFromPath(filePath);
+    const specializationName = stringValue(parsed.metadata.specialization) ?? extractSpecializationFromPath(filePath);
+    return {
+        slug: catalogSkillSlugFor(filePath),
+        name: parsed.name,
+        description: parsed.description,
+        filePath: toRepoRelative(filePath),
+        directory: toRepoRelative(node_path_1.default.dirname(filePath)),
+        specializationName,
+        domainName,
+        allowedTools: stringArray(parsed.frontmatter["allowed-tools"]),
+        createdAt: createdAtFor(stats),
+        updatedAt: updatedAtFor(stats),
+        content: parsed.content,
+        frontmatter: parsed.frontmatter,
+    };
+}
+function parseAgentFile(filePath) {
+    const parsed = parseMarkdownEntity(filePath);
+    const stats = safeStat(filePath);
+    const domainName = stringValue(parsed.metadata.domain) ?? extractDomainFromPath(filePath);
+    const specializationName = stringValue(parsed.metadata.specialization) ?? extractSpecializationFromPath(filePath);
+    return {
+        name: parsed.name,
+        description: parsed.description,
+        filePath: toRepoRelative(filePath),
+        directory: toRepoRelative(node_path_1.default.dirname(filePath)),
+        role: stringValue(parsed.frontmatter.role) ?? null,
+        expertise: stringArray(parsed.frontmatter.expertise),
+        specializationName,
+        domainName,
+        createdAt: createdAtFor(stats),
+        updatedAt: updatedAtFor(stats),
+        content: parsed.content,
+        frontmatter: parsed.frontmatter,
+    };
+}
+function assignStableIds(items, keyFor) {
+    return items
+        .slice()
+        .sort((left, right) => keyFor(left).localeCompare(keyFor(right)))
+        .map((item, index) => ({ ...item, id: index + 1 }));
+}
+function buildSnapshotFromLibrary(libraryDir) {
+    const methodologiesDir = node_path_1.default.join(libraryDir, "methodologies");
+    const specializationsDir = node_path_1.default.join(libraryDir, "specializations");
+    const domainsDir = node_path_1.default.join(specializationsDir, "domains");
+    const processFiles = [
+        ...listFilesRecursively(methodologiesDir, (filePath) => PROCESS_EXTENSIONS.has(node_path_1.default.extname(filePath))),
+        ...listFilesRecursively(specializationsDir, (filePath) => PROCESS_EXTENSIONS.has(node_path_1.default.extname(filePath)) &&
+            !normalizePath(filePath).includes("/skills/") &&
+            !normalizePath(filePath).includes("/agents/")),
+    ];
+    const skillFiles = listFilesRecursively(libraryDir, (filePath) => normalizePath(filePath).endsWith("/SKILL.md"));
+    const agentFiles = listFilesRecursively(libraryDir, (filePath) => normalizePath(filePath).endsWith("/AGENT.md"));
+    const processes = assignStableIds(processFiles
+        .map((filePath) => {
+        const parsed = parseProcessFile(filePath);
+        if (!parsed) {
+            return null;
+        }
+        const stats = safeStat(filePath);
+        return {
+            ...parsed,
+            createdAt: createdAtFor(stats),
+            updatedAt: updatedAtFor(stats),
+        };
+    })
+        .filter((process) => Boolean(process)), (item) => item.processId);
+    const skills = assignStableIds(skillFiles.map((filePath) => parseSkillFile(filePath)), (item) => `${item.name}:${item.filePath}`);
+    const agents = assignStableIds(agentFiles.map((filePath) => parseAgentFile(filePath)), (item) => `${item.name}:${item.filePath}`);
+    const skillNamesBySpecialization = new Map();
+    const agentNamesBySpecialization = new Map();
+    for (const skill of skills) {
+        if (skill.specializationName) {
+            const bucket = skillNamesBySpecialization.get(skill.specializationName) ?? [];
+            bucket.push(skill);
+            skillNamesBySpecialization.set(skill.specializationName, bucket);
+        }
+    }
+    for (const agent of agents) {
+        if (agent.specializationName) {
+            const bucket = agentNamesBySpecialization.get(agent.specializationName) ?? [];
+            bucket.push(agent);
+            agentNamesBySpecialization.set(agent.specializationName, bucket);
+        }
+    }
+    const specializations = [];
+    for (const filePath of readDirNames(specializationsDir)) {
+        if (filePath === "domains" || filePath.startsWith(".")) {
+            continue;
+        }
+        const absolutePath = node_path_1.default.join(specializationsDir, filePath);
+        if (!isDirectory(absolutePath)) {
+            continue;
+        }
+        const stats = safeStat(absolutePath);
+        const docs = findPrimaryDocPaths(absolutePath);
+        const specializationSkills = (skillNamesBySpecialization.get(filePath) ?? [])
+            .filter((skill) => skill.domainName === null)
+            .slice()
+            .sort((left, right) => left.name.localeCompare(right.name));
+        const specializationAgents = (agentNamesBySpecialization.get(filePath) ?? [])
+            .filter((agent) => agent.domainName === null)
+            .slice()
+            .sort((left, right) => left.name.localeCompare(right.name));
+        specializations.push({
+            id: 0,
+            name: filePath,
+            path: toRepoRelative(absolutePath),
+            domainName: null,
+            agentCount: specializationAgents.length,
+            skillCount: specializationSkills.length,
+            createdAt: createdAtFor(stats),
+            updatedAt: updatedAtFor(stats),
+            readmePath: docs.readmePath,
+            referencesPath: docs.referencesPath,
+            agents: specializationAgents.map((agent) => ({
+                id: agent.id,
+                name: agent.name,
+                description: agent.description,
+                role: agent.role,
+            })),
+            skills: specializationSkills.map((skill) => ({
+                id: skill.id,
+                slug: skill.slug,
+                name: skill.name,
+                description: skill.description,
+            })),
+        });
+    }
+    for (const domainName of readDirNames(domainsDir)) {
+        if (domainName.startsWith(".")) {
+            continue;
+        }
+        const domainPath = node_path_1.default.join(domainsDir, domainName);
+        if (!isDirectory(domainPath)) {
+            continue;
+        }
+        for (const specializationName of readDirNames(domainPath)) {
+            if (["agents", "skills", "README.md", "references.md"].includes(specializationName) || specializationName.startsWith(".")) {
+                continue;
+            }
+            const specializationPath = node_path_1.default.join(domainPath, specializationName);
+            if (!isDirectory(specializationPath)) {
+                continue;
+            }
+            const stats = safeStat(specializationPath);
+            const docs = findPrimaryDocPaths(specializationPath);
+            const specializationSkills = (skillNamesBySpecialization.get(specializationName) ?? [])
+                .filter((skill) => skill.domainName === domainName)
+                .slice()
+                .sort((left, right) => left.name.localeCompare(right.name));
+            const specializationAgents = (agentNamesBySpecialization.get(specializationName) ?? [])
+                .filter((agent) => agent.domainName === domainName)
+                .slice()
+                .sort((left, right) => left.name.localeCompare(right.name));
+            specializations.push({
+                id: 0,
+                name: specializationName,
+                path: toRepoRelative(specializationPath),
+                domainName,
+                agentCount: specializationAgents.length,
+                skillCount: specializationSkills.length,
+                createdAt: createdAtFor(stats),
+                updatedAt: updatedAtFor(stats),
+                readmePath: docs.readmePath,
+                referencesPath: docs.referencesPath,
+                agents: specializationAgents.map((agent) => ({
+                    id: agent.id,
+                    name: agent.name,
+                    description: agent.description,
+                    role: agent.role,
+                })),
+                skills: specializationSkills.map((skill) => ({
+                    id: skill.id,
+                    slug: skill.slug,
+                    name: skill.name,
+                    description: skill.description,
+                })),
+            });
+        }
+    }
+    const finalizedSpecializations = assignStableIds(specializations, (item) => `${item.domainName ?? ""}:${item.name}:${item.path}`);
+    const domains = [];
+    for (const domainName of readDirNames(domainsDir)) {
+        if (domainName.startsWith(".")) {
+            continue;
+        }
+        const domainPath = node_path_1.default.join(domainsDir, domainName);
+        if (!isDirectory(domainPath)) {
+            continue;
+        }
+        const stats = safeStat(domainPath);
+        const docs = findPrimaryDocPaths(domainPath);
+        const childSpecializations = finalizedSpecializations
+            .filter((specialization) => specialization.domainName === domainName)
+            .sort((left, right) => left.name.localeCompare(right.name));
+        const domainSkills = skills.filter((skill) => skill.domainName === domainName);
+        const domainAgents = agents.filter((agent) => agent.domainName === domainName);
+        domains.push({
+            id: 0,
+            name: domainName,
+            path: toRepoRelative(domainPath),
+            category: domainName,
+            specializationCount: childSpecializations.length,
+            agentCount: domainAgents.length,
+            skillCount: domainSkills.length,
+            createdAt: createdAtFor(stats),
+            updatedAt: updatedAtFor(stats),
+            readmePath: docs.readmePath,
+            referencesPath: docs.referencesPath,
+            specializations: childSpecializations.map((specialization) => ({
+                id: specialization.id,
+                name: specialization.name,
+                path: specialization.path,
+                agentCount: specialization.agentCount,
+                skillCount: specialization.skillCount,
+            })),
+        });
+    }
+    const finalizedDomains = assignStableIds(domains, (item) => item.name);
+    const databaseSize = processFiles.reduce((sum, filePath) => sum + fileSize(filePath), 0) +
+        skillFiles.reduce((sum, filePath) => sum + fileSize(filePath), 0) +
+        agentFiles.reduce((sum, filePath) => sum + fileSize(filePath), 0);
+    const generatedAt = new Date().toISOString();
+    return {
+        generatedAt,
+        databaseSize,
+        counts: {
+            domains: finalizedDomains.length,
+            specializations: finalizedSpecializations.length,
+            agents: agents.length,
+            skills: skills.length,
+            processes: processes.length,
+        },
+        processes,
+        skills,
+        agents,
+        domains: finalizedDomains,
+        specializations: finalizedSpecializations,
+    };
+}
+function loadPackagedSnapshot(snapshotPath) {
+    try {
+        return JSON.parse(readFile(snapshotPath));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load packaged discovery snapshot at ${snapshotPath}: ${message}`);
+    }
+}
+function buildSnapshot() {
+    const libraryDir = libraryRoot();
+    if (isDirectory(libraryDir)) {
+        return buildSnapshotFromLibrary(libraryDir);
+    }
+    const snapshotPath = packagedSnapshotPath();
+    if (fileExists(snapshotPath)) {
+        return loadPackagedSnapshot(snapshotPath);
+    }
+    throw new Error(`Discovery assets unavailable for @a5c-ai/agent-catalog. Expected either repo library at ${libraryDir} or packaged snapshot at ${snapshotPath}.`);
+}
+function clearCatalogDiscoveryCache() {
+    cachedSnapshot = undefined;
+}
+function getCatalogDiscoverySnapshot() {
+    if (!cachedSnapshot) {
+        cachedSnapshot = buildSnapshot();
+    }
+    return clone(cachedSnapshot);
+}
+function refreshCatalogDiscoverySnapshot() {
+    clearCatalogDiscoveryCache();
+    return getCatalogDiscoverySnapshot();
+}
+function listCatalogProcesses() {
+    return getCatalogDiscoverySnapshot().processes;
+}
+function getCatalogProcessById(id) {
+    return getCatalogDiscoverySnapshot().processes.find((process) => process.id === id);
+}
+function listCatalogSkills() {
+    return getCatalogDiscoverySnapshot().skills;
+}
+function getCatalogSkillBySlug(slug) {
+    return getCatalogDiscoverySnapshot().skills.find((skill) => skill.slug === slug);
+}
+function listCatalogAgents() {
+    return getCatalogDiscoverySnapshot().agents;
+}
+function listCatalogDomains() {
+    return getCatalogDiscoverySnapshot().domains;
+}
+function getCatalogDomainByName(name) {
+    return getCatalogDiscoverySnapshot().domains.find((domain) => domain.name === name);
+}
+function listCatalogSpecializations() {
+    return getCatalogDiscoverySnapshot().specializations;
+}
+function getCatalogSpecializationByName(name) {
+    return getCatalogDiscoverySnapshot().specializations.find((specialization) => specialization.name === name);
+}
+function scoreMatch(query, ...values) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return 0;
+    }
+    let bestScore = 0;
+    for (const value of values) {
+        const normalizedValue = value?.toLowerCase() ?? "";
+        if (!normalizedValue) {
+            continue;
+        }
+        if (normalizedValue === normalizedQuery) {
+            bestScore = Math.max(bestScore, 100);
+            continue;
+        }
+        if (normalizedValue.startsWith(normalizedQuery)) {
+            bestScore = Math.max(bestScore, 80);
+            continue;
+        }
+        if (normalizedValue.includes(normalizedQuery)) {
+            bestScore = Math.max(bestScore, 60);
+        }
+    }
+    return bestScore;
+}
+function searchCatalogDiscovery(query, types) {
+    const snapshot = getCatalogDiscoverySnapshot();
+    const allowedTypes = new Set(types ?? [
+        "agent",
+        "skill",
+        "process",
+        "domain",
+        "specialization",
+    ]);
+    const results = [];
+    if (allowedTypes.has("agent")) {
+        for (const agent of snapshot.agents) {
+            const score = scoreMatch(query, agent.name, agent.description, agent.role, agent.expertise.join(" "));
+            if (score > 0) {
+                results.push({
+                    type: "agent",
+                    id: agent.id,
+                    name: agent.name,
+                    description: agent.description,
+                    path: agent.filePath,
+                    score,
+                    updatedAt: agent.updatedAt,
+                });
+            }
+        }
+    }
+    if (allowedTypes.has("skill")) {
+        for (const skill of snapshot.skills) {
+            const score = scoreMatch(query, skill.name, skill.description, skill.domainName, skill.specializationName);
+            if (score > 0) {
+                results.push({
+                    type: "skill",
+                    id: skill.id,
+                    name: skill.name,
+                    description: skill.description,
+                    path: skill.filePath,
+                    slug: skill.slug,
+                    score,
+                    updatedAt: skill.updatedAt,
+                });
+            }
+        }
+    }
+    if (allowedTypes.has("process")) {
+        for (const process of snapshot.processes) {
+            const score = scoreMatch(query, process.processId, process.description, process.category);
+            if (score > 0) {
+                results.push({
+                    type: "process",
+                    id: process.id,
+                    name: process.processId,
+                    description: process.description,
+                    path: process.filePath,
+                    score,
+                    updatedAt: process.updatedAt,
+                });
+            }
+        }
+    }
+    if (allowedTypes.has("domain")) {
+        for (const domain of snapshot.domains) {
+            const score = scoreMatch(query, domain.name, domain.category);
+            if (score > 0) {
+                results.push({
+                    type: "domain",
+                    id: domain.id,
+                    name: domain.name,
+                    description: domain.category ?? domain.name,
+                    path: domain.path,
+                    score,
+                    updatedAt: domain.updatedAt,
+                });
+            }
+        }
+    }
+    if (allowedTypes.has("specialization")) {
+        for (const specialization of snapshot.specializations) {
+            const score = scoreMatch(query, specialization.name, specialization.domainName);
+            if (score > 0) {
+                results.push({
+                    type: "specialization",
+                    id: specialization.id,
+                    name: specialization.name,
+                    description: specialization.domainName
+                        ? `${specialization.name} specialization in ${specialization.domainName}`
+                        : `${specialization.name} specialization`,
+                    path: specialization.path,
+                    score,
+                    updatedAt: specialization.updatedAt,
+                });
+            }
+        }
+    }
+    return results.sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        return right.updatedAt.localeCompare(left.updatedAt);
+    });
+}