@erenari/supercodex 0.2.0

package/dist/registry/loader.js

@@ -0,0 +1,655 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRegistry = loadRegistry;
+exports.validateRegistry = validateRegistry;
+exports.listCatalogEntries = listCatalogEntries;
+exports.searchCatalogEntries = searchCatalogEntries;
+exports.getCatalogEntry = getCatalogEntry;
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../config");
+const fs_utils_1 = require("../fs-utils");
+const paths_1 = require("../paths");
+const aliases_1 = require("./aliases");
+const builtins_1 = require("./builtins");
+async function loadRegistry(options = {}) {
+    const codexPaths = (0, paths_1.getCodexPaths)(options.codexHome);
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const userOverlayPath = node_path_1.default.join(codexPaths.home, "supercodex", "registry.toml");
+    const projectOverlayPath = node_path_1.default.join(projectRoot, ".codex", "supercodex", "registry.toml");
+    const registry = {
+        modes: (0, fs_utils_1.deepClone)(builtins_1.BUILTIN_MODES),
+        personas: (0, fs_utils_1.deepClone)(builtins_1.BUILTIN_PERSONAS),
+        commands: (0, fs_utils_1.deepClone)(builtins_1.BUILTIN_COMMANDS),
+        catalog: (0, fs_utils_1.deepClone)(builtins_1.BUILTIN_CATALOG),
+        aliases: (0, fs_utils_1.deepClone)(aliases_1.BUILTIN_ALIASES),
+        alias_packs: (0, fs_utils_1.deepClone)(aliases_1.BUILTIN_ALIAS_PACKS)
+    };
+    const issues = [];
+    if (await (0, fs_utils_1.pathExists)(userOverlayPath)) {
+        const overlay = await readOverlayFile(userOverlayPath, issues);
+        if (overlay) {
+            applyOverlay(registry, overlay, userOverlayPath, issues);
+        }
+    }
+    if (await (0, fs_utils_1.pathExists)(projectOverlayPath)) {
+        const overlay = await readOverlayFile(projectOverlayPath, issues);
+        if (overlay) {
+            applyOverlay(registry, overlay, projectOverlayPath, issues);
+        }
+    }
+    return {
+        registry,
+        issues,
+        userOverlayPath,
+        projectOverlayPath
+    };
+}
+function validateRegistry(registry) {
+    const issues = [];
+    for (const [name, mode] of Object.entries(registry.modes)) {
+        if (!mode.description || !mode.description.trim()) {
+            issues.push({
+                level: "error",
+                path: `modes.${name}`,
+                message: "Mode description is required."
+            });
+        }
+    }
+    for (const [name, persona] of Object.entries(registry.personas)) {
+        if (!persona.description || !persona.description.trim()) {
+            issues.push({
+                level: "error",
+                path: `personas.${name}`,
+                message: "Persona description is required."
+            });
+        }
+    }
+    for (const [id, command] of Object.entries(registry.commands)) {
+        if (!command.description || !command.description.trim()) {
+            issues.push({
+                level: "error",
+                path: `commands.${id}`,
+                message: "Command description is required."
+            });
+        }
+    }
+    for (const [id, entry] of Object.entries(registry.catalog)) {
+        if (entry.transport !== "stdio" && entry.transport !== "http") {
+            issues.push({
+                level: "error",
+                path: `catalog.${id}.transport`,
+                message: `Unsupported transport "${String(entry.transport)}".`
+            });
+            continue;
+        }
+        if (entry.transport === "stdio" && (!entry.command || !entry.command.trim())) {
+            issues.push({
+                level: "error",
+                path: `catalog.${id}.command`,
+                message: "STDIO catalog entry requires command."
+            });
+        }
+        if (entry.transport === "http") {
+            if (!entry.url || !entry.url.trim()) {
+                issues.push({
+                    level: "error",
+                    path: `catalog.${id}.url`,
+                    message: "HTTP catalog entry requires url."
+                });
+            }
+            else {
+                try {
+                    // Validate URL shape
+                    // eslint-disable-next-line no-new
+                    new URL(entry.url);
+                }
+                catch {
+                    issues.push({
+                        level: "error",
+                        path: `catalog.${id}.url`,
+                        message: `Invalid URL "${entry.url}".`
+                    });
+                }
+            }
+        }
+    }
+    for (const [aliasName, aliasDefinition] of Object.entries(registry.aliases)) {
+        if (!aliasDefinition.description || !aliasDefinition.description.trim()) {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}`,
+                message: "Alias description is required."
+            });
+        }
+        if (!aliasDefinition.target || !aliasDefinition.target.trim()) {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}.target`,
+                message: "Alias target is required."
+            });
+        }
+        else if (!isValidCommandId(aliasDefinition.target)) {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}.target`,
+                message: `Alias target "${aliasDefinition.target}" has invalid format.`
+            });
+        }
+        else if (!Object.hasOwn(registry.commands, aliasDefinition.target)) {
+            issues.push({
+                level: "warn",
+                path: `aliases.${aliasName}.target`,
+                message: `Alias target "${aliasDefinition.target}" is not a known command id.`
+            });
+        }
+        else {
+            const command = registry.commands[aliasDefinition.target];
+            if (aliasDefinition.default_mode && !isCompatibleMode(command, aliasDefinition.default_mode)) {
+                issues.push({
+                    level: "warn",
+                    path: `aliases.${aliasName}.default_mode`,
+                    message: `Mode "${aliasDefinition.default_mode}" is not compatible with target ` +
+                        `"${aliasDefinition.target}".`
+                });
+            }
+            if (aliasDefinition.default_persona && !isCompatiblePersona(command, aliasDefinition.default_persona)) {
+                issues.push({
+                    level: "warn",
+                    path: `aliases.${aliasName}.default_persona`,
+                    message: `Persona "${aliasDefinition.default_persona}" is not compatible with target ` +
+                        `"${aliasDefinition.target}".`
+                });
+            }
+        }
+        if (aliasDefinition.default_mode && !Object.hasOwn(registry.modes, aliasDefinition.default_mode)) {
+            issues.push({
+                level: "warn",
+                path: `aliases.${aliasName}.default_mode`,
+                message: `Unknown mode "${aliasDefinition.default_mode}" in alias default.`
+            });
+        }
+        if (aliasDefinition.default_persona && !Object.hasOwn(registry.personas, aliasDefinition.default_persona)) {
+            issues.push({
+                level: "warn",
+                path: `aliases.${aliasName}.default_persona`,
+                message: `Unknown persona "${aliasDefinition.default_persona}" in alias default.`
+            });
+        }
+        if (aliasDefinition.output &&
+            aliasDefinition.output !== "normal" &&
+            aliasDefinition.output !== "json") {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}.output`,
+                message: `Unsupported alias output mode "${aliasDefinition.output}".`
+            });
+        }
+        if (aliasDefinition.risk_level &&
+            aliasDefinition.risk_level !== "low" &&
+            aliasDefinition.risk_level !== "medium" &&
+            aliasDefinition.risk_level !== "high") {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}.risk_level`,
+                message: `Unsupported alias risk level "${aliasDefinition.risk_level}".`
+            });
+        }
+        if (aliasDefinition.stability &&
+            aliasDefinition.stability !== "stable" &&
+            aliasDefinition.stability !== "experimental") {
+            issues.push({
+                level: "error",
+                path: `aliases.${aliasName}.stability`,
+                message: `Unsupported alias stability "${aliasDefinition.stability}".`
+            });
+        }
+        if (aliasDefinition.pack) {
+            const aliasPack = registry.alias_packs[aliasDefinition.pack];
+            if (!aliasPack) {
+                issues.push({
+                    level: "warn",
+                    path: `aliases.${aliasName}.pack`,
+                    message: `Alias references unknown pack "${aliasDefinition.pack}".`
+                });
+            }
+            else if (!aliasPack.aliases.includes(aliasName)) {
+                issues.push({
+                    level: "warn",
+                    path: `aliases.${aliasName}.pack`,
+                    message: `Alias "${aliasName}" is not listed in pack "${aliasDefinition.pack}".`
+                });
+            }
+        }
+        if ((0, aliases_1.isReservedTopLevelCommandName)(aliasName)) {
+            issues.push({
+                level: "warn",
+                path: `aliases.${aliasName}`,
+                message: `Alias "${aliasName}" collides with a top-level command name. ` +
+                    `Plain form "supercodex ${aliasName}" will execute the command; use "/sc:${aliasName}" explicitly.`
+            });
+        }
+    }
+    for (const [packName, packDefinition] of Object.entries(registry.alias_packs)) {
+        if (!packDefinition.description || !packDefinition.description.trim()) {
+            issues.push({
+                level: "error",
+                path: `alias_packs.${packName}.description`,
+                message: "Alias pack description is required."
+            });
+        }
+        if (packDefinition.aliases.length === 0) {
+            issues.push({
+                level: "warn",
+                path: `alias_packs.${packName}.aliases`,
+                message: "Alias pack does not contain any aliases."
+            });
+        }
+        const seenAliases = new Set();
+        for (const aliasName of packDefinition.aliases) {
+            if (seenAliases.has(aliasName)) {
+                issues.push({
+                    level: "warn",
+                    path: `alias_packs.${packName}.aliases`,
+                    message: `Alias "${aliasName}" is duplicated in pack "${packName}".`
+                });
+                continue;
+            }
+            seenAliases.add(aliasName);
+            if (!Object.hasOwn(registry.aliases, aliasName)) {
+                issues.push({
+                    level: "warn",
+                    path: `alias_packs.${packName}.aliases`,
+                    message: `Alias "${aliasName}" in pack "${packName}" is not defined.`
+                });
+                continue;
+            }
+            const alias = registry.aliases[aliasName];
+            if (alias.pack && alias.pack !== packName) {
+                issues.push({
+                    level: "warn",
+                    path: `alias_packs.${packName}.aliases`,
+                    message: `Alias "${aliasName}" belongs to "${alias.pack}" but is also listed in "${packName}".`
+                });
+            }
+        }
+    }
+    return issues;
+}
+function listCatalogEntries(registry) {
+    return Object.values(registry.catalog).sort((a, b) => a.id.localeCompare(b.id));
+}
+function searchCatalogEntries(registry, query) {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) {
+        return listCatalogEntries(registry);
+    }
+    return listCatalogEntries(registry).filter((entry) => {
+        const haystack = [
+            entry.id,
+            entry.name,
+            entry.description,
+            ...(entry.tags ?? []),
+            entry.command ?? "",
+            entry.url ?? ""
+        ]
+            .join(" ")
+            .toLowerCase();
+        return haystack.includes(normalized);
+    });
+}
+function getCatalogEntry(registry, id) {
+    return registry.catalog[id] ?? null;
+}
+async function readOverlayFile(overlayPath, issues) {
+    try {
+        const parsed = await (0, config_1.loadConfig)(overlayPath);
+        return (0, fs_utils_1.isPlainObject)(parsed) ? parsed : null;
+    }
+    catch (error) {
+        issues.push({
+            level: "error",
+            path: overlayPath,
+            message: `Failed to parse overlay file: ${error instanceof Error ? error.message : String(error)}`
+        });
+        return null;
+    }
+}
+function applyOverlay(registry, overlay, sourcePath, issues) {
+    if ((0, fs_utils_1.isPlainObject)(overlay.modes)) {
+        for (const [name, raw] of Object.entries(overlay.modes)) {
+            const normalized = normalizeMode(name, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:modes.${name}`,
+                    message: "Skipped invalid mode entry."
+                });
+                continue;
+            }
+            registry.modes[name] = normalized;
+        }
+    }
+    if ((0, fs_utils_1.isPlainObject)(overlay.personas)) {
+        for (const [name, raw] of Object.entries(overlay.personas)) {
+            const normalized = normalizePersona(name, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:personas.${name}`,
+                    message: "Skipped invalid persona entry."
+                });
+                continue;
+            }
+            registry.personas[name] = normalized;
+        }
+    }
+    if ((0, fs_utils_1.isPlainObject)(overlay.commands)) {
+        for (const [id, raw] of Object.entries(overlay.commands)) {
+            const normalized = normalizeCommand(id, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:commands.${id}`,
+                    message: "Skipped invalid command entry."
+                });
+                continue;
+            }
+            registry.commands[id] = normalized;
+        }
+    }
+    if ((0, fs_utils_1.isPlainObject)(overlay.catalog)) {
+        for (const [id, raw] of Object.entries(overlay.catalog)) {
+            const normalized = normalizeCatalogEntry(id, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:catalog.${id}`,
+                    message: "Skipped invalid catalog entry."
+                });
+                continue;
+            }
+            registry.catalog[id] = normalized;
+        }
+    }
+    if ((0, fs_utils_1.isPlainObject)(overlay.aliases)) {
+        for (const [name, raw] of Object.entries(overlay.aliases)) {
+            const normalized = normalizeAlias(name, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:aliases.${name}`,
+                    message: "Skipped invalid alias entry."
+                });
+                continue;
+            }
+            if (Object.hasOwn(registry.aliases, normalized.name)) {
+                const existing = registry.aliases[normalized.name];
+                if (!areAliasesEquivalent(existing, normalized)) {
+                    issues.push({
+                        level: "warn",
+                        path: `${sourcePath}:aliases.${normalized.name}`,
+                        message: `Alias "${normalized.name}" overrides an existing alias definition.`
+                    });
+                }
+            }
+            registry.aliases[normalized.name] = normalized;
+        }
+    }
+    if ((0, fs_utils_1.isPlainObject)(overlay.alias_packs)) {
+        for (const [name, raw] of Object.entries(overlay.alias_packs)) {
+            const normalized = normalizeAliasPack(name, raw);
+            if (!normalized) {
+                issues.push({
+                    level: "warn",
+                    path: `${sourcePath}:alias_packs.${name}`,
+                    message: "Skipped invalid alias pack entry."
+                });
+                continue;
+            }
+            if (Object.hasOwn(registry.alias_packs, name)) {
+                const existing = registry.alias_packs[name];
+                if (!areAliasPacksEquivalent(existing, normalized)) {
+                    issues.push({
+                        level: "warn",
+                        path: `${sourcePath}:alias_packs.${name}`,
+                        message: `Alias pack "${name}" overrides an existing pack definition.`
+                    });
+                }
+            }
+            registry.alias_packs[name] = normalized;
+        }
+    }
+}
+function normalizeMode(name, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const description = asString(raw.description);
+    if (!description) {
+        return null;
+    }
+    const mode = {
+        name,
+        description
+    };
+    const promptOverlay = asString(raw.prompt_overlay);
+    if (promptOverlay) {
+        mode.prompt_overlay = promptOverlay;
+    }
+    const temperature = asNumber(raw.temperature);
+    if (typeof temperature === "number") {
+        mode.temperature = temperature;
+    }
+    const reasoningBudget = asString(raw.reasoning_budget);
+    if (reasoningBudget === "low" || reasoningBudget === "medium" || reasoningBudget === "high") {
+        mode.reasoning_budget = reasoningBudget;
+    }
+    return mode;
+}
+function normalizePersona(name, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const description = asString(raw.description);
+    if (!description) {
+        return null;
+    }
+    const persona = {
+        name,
+        description
+    };
+    const systemPrompt = asString(raw.system_prompt);
+    if (systemPrompt) {
+        persona.system_prompt = systemPrompt;
+    }
+    const tags = asStringArray(raw.policy_tags);
+    if (tags.length > 0) {
+        persona.policy_tags = tags;
+    }
+    return persona;
+}
+function normalizeCommand(id, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const description = asString(raw.description);
+    if (!description) {
+        return null;
+    }
+    return {
+        id,
+        description,
+        enabled: raw.enabled !== false,
+        mode_compatible: asStringArray(raw.mode_compatible),
+        persona_compatible: asStringArray(raw.persona_compatible)
+    };
+}
+function normalizeCatalogEntry(id, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const transport = asString(raw.transport);
+    if (transport !== "stdio" && transport !== "http") {
+        return null;
+    }
+    const description = asString(raw.description) ?? `Catalog entry ${id}`;
+    const name = asString(raw.name) ?? id;
+    const entry = {
+        id,
+        name,
+        description,
+        transport
+    };
+    const command = asString(raw.command);
+    const args = asStringArray(raw.args);
+    const url = asString(raw.url);
+    const tags = asStringArray(raw.tags);
+    if (transport === "stdio") {
+        if (!command) {
+            return null;
+        }
+        entry.command = command;
+        if (args.length > 0) {
+            entry.args = args;
+        }
+    }
+    if (transport === "http") {
+        if (!url) {
+            return null;
+        }
+        entry.url = url;
+    }
+    const env = asStringMap(raw.env);
+    if (Object.keys(env).length > 0) {
+        entry.env = env;
+    }
+    if (tags.length > 0) {
+        entry.tags = tags;
+    }
+    return entry;
+}
+function normalizeAlias(name, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const description = asString(raw.description);
+    const target = asString(raw.target);
+    if (!description || !target) {
+        return null;
+    }
+    const parsedName = (0, aliases_1.normalizeAliasToken)(name);
+    const aliasName = (parsedName ? parsedName.name : name).toLowerCase();
+    if (!aliasName) {
+        return null;
+    }
+    const alias = {
+        name: aliasName,
+        description,
+        target
+    };
+    const pack = asString(raw.pack);
+    if (pack) {
+        alias.pack = pack;
+    }
+    const tags = asStringArray(raw.tags);
+    if (tags.length > 0) {
+        alias.tags = dedupeStrings(tags);
+    }
+    const riskLevel = asString(raw.risk_level);
+    if (riskLevel === "low" || riskLevel === "medium" || riskLevel === "high") {
+        alias.risk_level = riskLevel;
+    }
+    const stability = asString(raw.stability);
+    if (stability === "stable" || stability === "experimental") {
+        alias.stability = stability;
+    }
+    const defaultMode = asString(raw.default_mode);
+    if (defaultMode) {
+        alias.default_mode = defaultMode;
+    }
+    const defaultPersona = asString(raw.default_persona);
+    if (defaultPersona) {
+        alias.default_persona = defaultPersona;
+    }
+    const forwardArgs = asBoolean(raw.forward_args);
+    if (typeof forwardArgs === "boolean") {
+        alias.forward_args = forwardArgs;
+    }
+    const output = asString(raw.output);
+    if (output === "normal" || output === "json") {
+        alias.output = output;
+    }
+    return alias;
+}
+function normalizeAliasPack(name, raw) {
+    if (!(0, fs_utils_1.isPlainObject)(raw)) {
+        return null;
+    }
+    const description = asString(raw.description);
+    if (!description) {
+        return null;
+    }
+    const aliases = dedupeStrings(asStringArray(raw.aliases).map((entry) => entry.toLowerCase()));
+    const defaultEnabled = asBoolean(raw.default_enabled);
+    return {
+        name,
+        description,
+        default_enabled: defaultEnabled ?? true,
+        aliases
+    };
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function asStringMap(value) {
+    if (!(0, fs_utils_1.isPlainObject)(value)) {
+        return {};
+    }
+    const env = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === "string") {
+            env[key] = raw;
+        }
+    }
+    return env;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function dedupeStrings(values) {
+    return Array.from(new Set(values));
+}
+function isValidCommandId(value) {
+    return /^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)*$/.test(value);
+}
+function isCompatibleMode(command, modeName) {
+    if (command.mode_compatible.length === 0) {
+        return true;
+    }
+    return command.mode_compatible.includes(modeName);
+}
+function isCompatiblePersona(command, personaName) {
+    if (command.persona_compatible.length === 0) {
+        return true;
+    }
+    return command.persona_compatible.includes(personaName);
+}
+function areAliasesEquivalent(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function areAliasPacksEquivalent(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+//# sourceMappingURL=loader.js.map