wyrm-mcp 7.2.0 → 7.2.2

package/dist/handlers/skill.js

@@ -1,449 +1,67 @@
-/**
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
-import { currentReadCacheKey } from "./boundary.js";
-import { cache } from "../performance.js";
-import { sanitizeFtsQuery } from "../security.js";
-import { deploySkill, validateAtomicSkill } from "../skill-author.js";
-export const skillToolSpecs = [
-    {
-        name: "wyrm_skill_create",
-        description: "Author + deploy + register an ATOMIC skill in one clean step. Validates atomicity (one focused capability, discoverable 12–280 char description, proper frontmatter), writes <skillsDir>/<slug>/SKILL.md, and registers it so it's instantly findable via wyrm_skill_search. Refuses to clobber an existing skill unless force=true. Use this to create skills as they're needed instead of leaving them un-deployed.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name (slugified to kebab-case)" },
-                description: { type: "string", description: "One-line description, 12–280 chars — used for discovery/recall ranking" },
-                body: { type: "string", description: "The SKILL.md markdown body (the actual skill content; should be ONE focused capability)" },
-                argumentHint: { type: "string", description: "Optional argument-hint frontmatter (for user-invocable skills)" },
-                userInvocable: { type: "boolean", description: "Whether it's a user-invocable slash command" },
-                category: { type: "string", description: "Optional category" },
-                tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
-                force: { type: "boolean", description: "Overwrite an existing skill of the same slug (default false)" },
-                register: { type: "boolean", description: "Register in the skill registry for discovery (default true)" },
-            },
-            required: ["name", "description", "body"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_create"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const a = args || {};
-            const requireArgs = (fields) => {
-                const missing = fields.filter(f => !a[f] && a[f] !== 0 && a[f] !== false);
-                if (missing.length > 0) {
-                    return { content: [{ type: "text", text: `Missing required arguments: ${missing.join(', ')}` }], isError: true };
-                }
-                return null;
-            };
-            const argErr = requireArgs(['name', 'description', 'body']);
-            if (argErr)
-                return argErr;
-            const { name, description, body, argumentHint, userInvocable, category, tags, force, register } = args;
-            const spec = { name, description, body, argumentHint, userInvocable, category, tags };
-            const v = validateAtomicSkill(spec);
-            if (!v.ok) {
-                return { content: [{ type: "text", text: `❌ Skill rejected (not clean/atomic):\n- ${v.errors.join('\n- ')}` }] };
-            }
-            let deploy;
-            try {
-                deploy = deploySkill(spec, { force });
-            }
-            catch (e) {
-                return { content: [{ type: "text", text: `❌ Deploy failed: ${e instanceof Error ? e.message : String(e)}` }] };
-            }
-            let registered = false;
-            if (register !== false) {
-                try {
-                    db.registerSkill(v.slug, description, deploy.path, category, 'Ghost Protocol', '1.0.0', (tags || []).join(','));
-                    registered = true;
-                }
-                catch { /* registry optional; file is deployed regardless */ }
-            }
-            const warn = v.warnings.length ? `\n\n⚠️  ${v.warnings.join('\n⚠️  ')}` : '';
-            return { content: [{ type: "text", text: `󱅝 Skill "${v.slug}" ${deploy.action}${registered ? ' + registered (discoverable via wyrm_skill_search)' : ''}\n   ${deploy.path}${warn}` }] };
-        },
-    },
-    {
-        name: "wyrm_skill_register",
-        description: "Register or update a skill and store metadata in Wyrm. Supports GOD-SKILL SPEC v2 apex tiers (god > mega > atomic) with governs/composes routing.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name (e.g., 'professional-lead-scraping')" },
-                description: { type: "string", description: "Skill description" },
-                skillPath: { type: "string", description: "File path to skill (e.g., ~/.copilot/skills/name or project relative path)" },
-                category: { type: "string", description: "Skill category (e.g., 'data-extraction', 'testing', 'documentation')" },
-                author: { type: "string", description: "Skill author or creator" },
-                version: { type: "string", description: "Skill version" },
-                tags: { type: "string", description: "Comma-separated tags (e.g., 'scraping,leads,email-validation')" },
-                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "GOD-SKILL SPEC v2 apex tier. Default 'atomic'. 'mega' composes atomics; 'god' governs megas." },
-                governs: { type: "array", items: { type: "string" }, description: "Skill names this node routes DOWN to (god→megas, mega→atomics). Default []." },
-                composes: { type: "array", items: { type: "string" }, description: "Skill names this node pulls in laterally. Default []." },
-            },
-            required: ["name", "description", "skillPath"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_register"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { name, description, skillPath, category, author, version, tags, tier, governs, composes } = args;
-            const governance = (tier || governs || composes)
-                ? { tier, governs, composes }
-                : undefined;
-            const skill = db.registerSkill(name, description, skillPath, category, author, version, tags, governance);
-            cache.invalidate('wyrm_skill_list');
-            cache.invalidate('wyrm_skill_stats');
-            const governsList = skill.governs ? JSON.parse(skill.governs) : [];
-            const composesList = skill.composes ? JSON.parse(skill.composes) : [];
-            let text = `󱅝 **Skill Registered**\n\nName: ${skill.name}\nPath: ${skill.skill_path}\nCategory: ${skill.category || 'uncategorized'}\nVersion: ${skill.version || '1.0.0'}\nTier: ${skill.tier}\nStatus: ${skill.is_active ? 'Active' : 'Inactive'}`;
-            if (governsList.length)
-                text += `\nGoverns: ${governsList.join(', ')}`;
-            if (composesList.length)
-                text += `\nComposes: ${composesList.join(', ')}`;
-            return { content: [{ type: "text", text }] };
-        },
-    },
-    {
-        name: "wyrm_skill_list",
-        description: "List registered skills with filtering options",
-        inputSchema: {
-            type: "object",
-            properties: {
-                active: { type: "boolean", description: "Filter by active status" },
-                category: { type: "string", description: "Filter by category" },
-                search: { type: "string", description: "Full-text search by name, description, or tags" },
-                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "Filter by GOD-SKILL SPEC v2 tier (atomic|mega|god)" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_list"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { active, category, search, tier } = args;
-            const skills = db.listSkills(active, category, search, tier);
-            if (skills.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skills**\n\nNo skills found matching your criteria.`
-                        }]
-                };
-            }
-            let text = `󱅝 **Skills Registry** (${skills.length} total)\n\n`;
-            for (const skill of skills) {
-                const tierBadge = skill.tier && skill.tier !== 'atomic' ? ` [${skill.tier.toUpperCase()}]` : '';
-                text += `### ${skill.name}${tierBadge} ${skill.is_active ? '✅' : '❌'}\n`;
-                text += `Category: ${skill.category || 'uncategorized'}\n`;
-                text += `Description: ${skill.description}\n`;
-                if (skill.version)
-                    text += `Version: ${skill.version}\n`;
-                if (skill.author)
-                    text += `Author: ${skill.author}\n`;
-                if (skill.tags)
-                    text += `Tags: ${skill.tags}\n`;
-                text += `Path: \`${skill.skill_path}\`\n`;
-                text += `Used: ${skill.usage_count} times`;
-                if (skill.last_used)
-                    text += ` (last: ${skill.last_used})`;
-                text += '\n\n';
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_skill_get",
-        description: "Get detailed information about a specific skill",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name" },
-            },
-            required: ["name"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_get"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { name } = args;
-            const skill = db.getSkill(name);
-            if (!skill) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Not Found**: ${name}`
-                        }]
-                };
-            }
-            let text = `󱅝 **Skill: ${skill.name}** ${skill.is_active ? '✅ Active' : '❌ Inactive'}\n\n`;
-            text += `**Description:** ${skill.description}\n`;
-            text += `**Path:** \`${skill.skill_path}\`\n`;
-            text += `**Category:** ${skill.category || 'uncategorized'}\n`;
-            if (skill.author)
-                text += `**Author:** ${skill.author}\n`;
-            if (skill.version)
-                text += `**Version:** ${skill.version}\n`;
-            if (skill.tags)
-                text += `**Tags:** ${skill.tags}\n`;
-            text += `**Usage Count:** ${skill.usage_count}\n`;
-            if (skill.last_used)
-                text += `**Last Used:** ${skill.last_used}\n`;
-            text += `**Created:** ${skill.created_at}\n`;
-            text += `**Updated:** ${skill.updated_at}\n`;
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_skill_delete",
-        description: "Delete a skill from Wyrm registry",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name" },
-            },
-            required: ["name"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_delete"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { name } = args;
-            const success = db.deleteSkill(name);
-            cache.invalidate('wyrm_skill_list');
-            cache.invalidate('wyrm_skill_stats');
-            if (success) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Deleted**: ${name}`
-                        }]
-                };
-            }
-            else {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Not Found**: ${name}`
-                        }]
-                };
-            }
-        },
-    },
-    {
-        name: "wyrm_skill_activate",
-        description: "Activate a skill (mark as active)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name" },
-            },
-            required: ["name"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_activate"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { name } = args;
-            const skill = db.activateSkill(name);
-            cache.invalidate('wyrm_skill_list');
-            cache.invalidate('wyrm_skill_stats');
-            if (skill) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Activated**: ${name}`
-                        }]
-                };
-            }
-            else {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Not Found**: ${name}`
-                        }]
-                };
-            }
-        },
-    },
-    {
-        name: "wyrm_skill_deactivate",
-        description: "Deactivate a skill (mark as inactive)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                name: { type: "string", description: "Skill name" },
-            },
-            required: ["name"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_deactivate"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { name } = args;
-            const skill = db.deactivateSkill(name);
-            cache.invalidate('wyrm_skill_list');
-            cache.invalidate('wyrm_skill_stats');
-            if (skill) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Deactivated**: ${name}`
-                        }]
-                };
-            }
-            else {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Skill Not Found**: ${name}`
-                        }]
-                };
-            }
-        },
-    },
-    {
-        name: "wyrm_skill_search",
-        description: "Search for skills by name, description, or tags. Optionally filter by GOD-SKILL SPEC v2 tier.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Search query" },
-                limit: { type: "number", description: "Max results (default: 20)" },
-                tier: { type: "string", enum: ["atomic", "mega", "god"], description: "Restrict results to a GOD-SKILL SPEC v2 tier (atomic|mega|god)" },
-            },
-            required: ["query"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_search"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { query, limit, tier } = args;
-            const sanitizedQuery = sanitizeFtsQuery(query);
-            const skills = db.searchSkills(sanitizedQuery, limit || 20, tier);
-            if (skills.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `󱅝 **Search Skills**: No results found for "${query}"${tier ? ` (tier=${tier})` : ''}`
-                        }]
-                };
-            }
-            let text = `󱅝 **Skill Search Results for "${query}"** (${skills.length} found)\n\n`;
-            for (const skill of skills) {
-                const tierBadge = skill.tier && skill.tier !== 'atomic' ? ` [${skill.tier.toUpperCase()}]` : '';
-                text += `- **${skill.name}**${tierBadge} (${skill.category || 'uncategorized'}) ${skill.is_active ? '✅' : '❌'}\n`;
-                text += `  ${skill.description}\n\n`;
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_skill_stats",
-        description: "Get statistics on registered skills",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_stats"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const stats = db.getSkillStats();
-            let text = `󱅝 **Skill Statistics**\n\n`;
-            text += `**Total Skills:** ${stats.total}\n`;
-            text += `**Active Skills:** ${stats.active}\n`;
-            text += `**Inactive Skills:** ${stats.total - stats.active}\n\n`;
-            if (Object.keys(stats.byCategory).length > 0) {
-                text += `**By Category:**\n`;
-                for (const [category, count] of Object.entries(stats.byCategory)) {
-                    text += `- ${category}: ${count}\n`;
-                }
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_skill_graph",
-        description: "Return the GOD-SKILL SPEC v2 governance graph: walks god → governs(mega) → governs(atomic) plus each node's composes, as a tree + edge-list the caller can render. Pass a root skill to scope to one apex; omit it to get the forest of every 'god' tier skill.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                root: { type: "string", description: "Optional root skill name to scope the graph (e.g. 'ghost-godhead'). Omit for all god-tier apexes." },
-                format: { type: "string", enum: ["tree", "edges", "both"], description: "Output shape: 'tree' (nested), 'edges' (flat edge-list), or 'both' (default)." },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_skill_graph"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, graph } = ctx;
-            const { root, format } = args;
-            const fmt = format || 'both';
-            const forest = db.getSkillGraph(root);
-            if (forest.length === 0) {
-                const reason = root
-                    ? `Skill "${root}" is not registered (or has no graph).`
-                    : `No god-tier skills registered. Register one with wyrm_skill_register tier='god' + governs=[...].`;
-                return { content: [{ type: "text", text: `󱅝 **Skill Graph**\n\n${reason}` }] };
-            }
-            const edges = [];
-            const walk = (n) => {
-                for (const g of n.governs) {
-                    edges.push({ from: n.name, to: g, kind: 'governs', resolved: n.children.some((c) => c.name === g) });
-                }
-                for (const c of n.composes) {
-                    edges.push({ from: n.name, to: c, kind: 'composes', resolved: false });
-                }
-                for (const child of n.children)
-                    walk(child);
-            };
-            for (const r of forest)
-                walk(r);
-            // Human-readable tree render.
-            const tierIcon = (t) => (t === 'god' ? '👑' : t === 'mega' ? '◆' : '·');
-            const renderTree = (n, depth) => {
-                const indent = '  '.repeat(depth);
-                let out = `${indent}${tierIcon(n.tier)} ${n.name} (${n.tier})\n`;
-                if (n.composes.length)
-                    out += `${indent}    ~composes: ${n.composes.join(', ')}\n`;
-                if (n.missing && n.missing.length)
-                    out += `${indent}    ⚠ missing: ${n.missing.join(', ')}\n`;
-                for (const child of n.children)
-                    out += renderTree(child, depth + 1);
-                return out;
-            };
-            let text = `󱅝 **Skill Governance Graph**${root ? ` (root: ${root})` : ' (all god apexes)'}\n\n`;
-            if (fmt === 'tree' || fmt === 'both') {
-                for (const r of forest)
-                    text += renderTree(r, 0);
-            }
-            if (fmt === 'edges' || fmt === 'both') {
-                text += `\n**Edges (${edges.length}):**\n`;
-                for (const e of edges) {
-                    text += `- ${e.from} —${e.kind}→ ${e.to}${e.kind === 'governs' && !e.resolved ? ' (unresolved)' : ''}\n`;
-                }
-            }
-            // Machine-readable payload appended for programmatic callers.
-            text += `\n\`\`\`json\n${JSON.stringify({ tree: forest, edges }, null, 2)}\n\`\`\``;
-            return { content: [{ type: "text", text }] };
-        },
-    },
-];
-//# sourceMappingURL=skill.js.map
+import{TOOL_ANNOTATIONS as v}from"../tool-annotations.js";import{currentReadCacheKey as $}from"./boundary.js";import{cache as h}from"../performance.js";import{sanitizeFtsQuery as O}from"../security.js";import{deploySkill as j,validateAtomicSkill as L}from"../skill-author.js";const A=[{name:"wyrm_skill_create",description:"Author + deploy + register an ATOMIC skill in one clean step. Validates atomicity (one focused capability, discoverable 12\u2013280 char description, proper frontmatter), writes <skillsDir>/<slug>/SKILL.md, and registers it so it's instantly findable via wyrm_skill_search. Refuses to clobber an existing skill unless force=true. Use this to create skills as they're needed instead of leaving them un-deployed.",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name (slugified to kebab-case)"},description:{type:"string",description:"One-line description, 12\u2013280 chars \u2014 used for discovery/recall ranking"},body:{type:"string",description:"The SKILL.md markdown body (the actual skill content; should be ONE focused capability)"},argumentHint:{type:"string",description:"Optional argument-hint frontmatter (for user-invocable skills)"},userInvocable:{type:"boolean",description:"Whether it's a user-invocable slash command"},category:{type:"string",description:"Optional category"},tags:{type:"array",items:{type:"string"},description:"Optional tags"},force:{type:"boolean",description:"Overwrite an existing skill of the same slug (default false)"},register:{type:"boolean",description:"Register in the skill registry for discovery (default true)"}},required:["name","description","body"]},annotations:v.wyrm_skill_create,aliases:[],handler:async(c,p)=>{const{db:d}=p,n=c||{},o=(S=>{const x=S.filter(_=>!n[_]&&n[_]!==0&&n[_]!==!1);return x.length>0?{content:[{type:"text",text:`Missing required arguments: ${x.join(", ")}`}],isError:!0}:null})(["name","description","body"]);if(o)return o;const{name:t,description:s,body:g,argumentHint:m,userInvocable:a,category:y,tags:i,force:e,register:l}=c,k={name:t,description:s,body:g,argumentHint:m,userInvocable:a,category:y,tags:i},u=L(k);if(!u.ok)return{content:[{type:"text",text:`\u274C Skill rejected (not clean/atomic):
+- ${u.errors.join(`
+- `)}`}]};let f;try{f=j(k,{force:e})}catch(S){return{content:[{type:"text",text:`\u274C Deploy failed: ${S instanceof Error?S.message:String(S)}`}]}}let b=!1;if(l!==!1)try{d.registerSkill(u.slug,s,f.path,y,"Ghost Protocol","1.0.0",(i||[]).join(",")),b=!0}catch{}const w=u.warnings.length?`
+
+\u26A0\uFE0F  ${u.warnings.join(`
+\u26A0\uFE0F  `)}`:"";return{content:[{type:"text",text:`\u{F115D} Skill "${u.slug}" ${f.action}${b?" + registered (discoverable via wyrm_skill_search)":""}
+   ${f.path}${w}`}]}}},{name:"wyrm_skill_register",description:"Register or update a skill and store metadata in Wyrm. Supports GOD-SKILL SPEC v2 apex tiers (god > mega > atomic) with governs/composes routing.",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name (e.g., 'professional-lead-scraping')"},description:{type:"string",description:"Skill description"},skillPath:{type:"string",description:"File path to skill (e.g., ~/.copilot/skills/name or project relative path)"},category:{type:"string",description:"Skill category (e.g., 'data-extraction', 'testing', 'documentation')"},author:{type:"string",description:"Skill author or creator"},version:{type:"string",description:"Skill version"},tags:{type:"string",description:"Comma-separated tags (e.g., 'scraping,leads,email-validation')"},tier:{type:"string",enum:["atomic","mega","god"],description:"GOD-SKILL SPEC v2 apex tier. Default 'atomic'. 'mega' composes atomics; 'god' governs megas."},governs:{type:"array",items:{type:"string"},description:"Skill names this node routes DOWN to (god\u2192megas, mega\u2192atomics). Default []."},composes:{type:"array",items:{type:"string"},description:"Skill names this node pulls in laterally. Default []."}},required:["name","description","skillPath"]},annotations:v.wyrm_skill_register,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n,description:r,skillPath:o,category:t,author:s,version:g,tags:m,tier:a,governs:y,composes:i}=c,e=a||y||i?{tier:a,governs:y,composes:i}:void 0,l=d.registerSkill(n,r,o,t,s,g,m,e);h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats");const k=l.governs?JSON.parse(l.governs):[],u=l.composes?JSON.parse(l.composes):[];let f=`\u{F115D} **Skill Registered**
+
+Name: ${l.name}
+Path: ${l.skill_path}
+Category: ${l.category||"uncategorized"}
+Version: ${l.version||"1.0.0"}
+Tier: ${l.tier}
+Status: ${l.is_active?"Active":"Inactive"}`;return k.length&&(f+=`
+Governs: ${k.join(", ")}`),u.length&&(f+=`
+Composes: ${u.join(", ")}`),{content:[{type:"text",text:f}]}}},{name:"wyrm_skill_list",description:"List registered skills with filtering options",inputSchema:{type:"object",properties:{active:{type:"boolean",description:"Filter by active status"},category:{type:"string",description:"Filter by category"},search:{type:"string",description:"Full-text search by name, description, or tags"},tier:{type:"string",enum:["atomic","mega","god"],description:"Filter by GOD-SKILL SPEC v2 tier (atomic|mega|god)"}}},annotations:v.wyrm_skill_list,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{active:o,category:t,search:s,tier:g}=c,m=n.listSkills(o,t,s,g);if(m.length===0)return{content:[{type:"text",text:`\u{F115D} **Skills**
+
+No skills found matching your criteria.`}]};let a=`\u{F115D} **Skills Registry** (${m.length} total)
+
+`;for(const i of m){const e=i.tier&&i.tier!=="atomic"?` [${i.tier.toUpperCase()}]`:"";a+=`### ${i.name}${e} ${i.is_active?"\u2705":"\u274C"}
+`,a+=`Category: ${i.category||"uncategorized"}
+`,a+=`Description: ${i.description}
+`,i.version&&(a+=`Version: ${i.version}
+`),i.author&&(a+=`Author: ${i.author}
+`),i.tags&&(a+=`Tags: ${i.tags}
+`),a+=`Path: \`${i.skill_path}\`
+`,a+=`Used: ${i.usage_count} times`,i.last_used&&(a+=` (last: ${i.last_used})`),a+=`
+
+`}const y=d(a);return r&&h.set(r,y,3e4),y}},{name:"wyrm_skill_get",description:"Get detailed information about a specific skill",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_get,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{name:o}=c,t=n.getSkill(o);if(!t)return{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${o}`}]};let s=`\u{F115D} **Skill: ${t.name}** ${t.is_active?"\u2705 Active":"\u274C Inactive"}
+
+`;s+=`**Description:** ${t.description}
+`,s+=`**Path:** \`${t.skill_path}\`
+`,s+=`**Category:** ${t.category||"uncategorized"}
+`,t.author&&(s+=`**Author:** ${t.author}
+`),t.version&&(s+=`**Version:** ${t.version}
+`),t.tags&&(s+=`**Tags:** ${t.tags}
+`),s+=`**Usage Count:** ${t.usage_count}
+`,t.last_used&&(s+=`**Last Used:** ${t.last_used}
+`),s+=`**Created:** ${t.created_at}
+`,s+=`**Updated:** ${t.updated_at}
+`;const g=d(s);return r&&h.set(r,g,3e4),g}},{name:"wyrm_skill_delete",description:"Delete a skill from Wyrm registry",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_delete,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.deleteSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Deleted**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_activate",description:"Activate a skill (mark as active)",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_activate,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.activateSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Activated**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_deactivate",description:"Deactivate a skill (mark as inactive)",inputSchema:{type:"object",properties:{name:{type:"string",description:"Skill name"}},required:["name"]},annotations:v.wyrm_skill_deactivate,aliases:[],handler:async(c,p)=>{const{db:d}=p,{name:n}=c,r=d.deactivateSkill(n);return h.invalidate("wyrm_skill_list"),h.invalidate("wyrm_skill_stats"),r?{content:[{type:"text",text:`\u{F115D} **Skill Deactivated**: ${n}`}]}:{content:[{type:"text",text:`\u{F115D} **Skill Not Found**: ${n}`}]}}},{name:"wyrm_skill_search",description:"Search for skills by name, description, or tags. Optionally filter by GOD-SKILL SPEC v2 tier.",inputSchema:{type:"object",properties:{query:{type:"string",description:"Search query"},limit:{type:"number",description:"Max results (default: 20)"},tier:{type:"string",enum:["atomic","mega","god"],description:"Restrict results to a GOD-SKILL SPEC v2 tier (atomic|mega|god)"}},required:["query"]},annotations:v.wyrm_skill_search,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),{query:o,limit:t,tier:s}=c,g=O(o),m=n.searchSkills(g,t||20,s);if(m.length===0)return{content:[{type:"text",text:`\u{F115D} **Search Skills**: No results found for "${o}"${s?` (tier=${s})`:""}`}]};let a=`\u{F115D} **Skill Search Results for "${o}"** (${m.length} found)
+
+`;for(const i of m){const e=i.tier&&i.tier!=="atomic"?` [${i.tier.toUpperCase()}]`:"";a+=`- **${i.name}**${e} (${i.category||"uncategorized"}) ${i.is_active?"\u2705":"\u274C"}
+`,a+=`  ${i.description}
+
+`}const y=d(a);return r&&h.set(r,y,3e4),y}},{name:"wyrm_skill_stats",description:"Get statistics on registered skills",inputSchema:{type:"object",properties:{}},annotations:v.wyrm_skill_stats,aliases:[],handler:async(c,p)=>{const{cachedResponse:d,db:n}=p,r=$(),o=n.getSkillStats();let t=`\u{F115D} **Skill Statistics**
+
+`;if(t+=`**Total Skills:** ${o.total}
+`,t+=`**Active Skills:** ${o.active}
+`,t+=`**Inactive Skills:** ${o.total-o.active}
+
+`,Object.keys(o.byCategory).length>0){t+=`**By Category:**
+`;for(const[g,m]of Object.entries(o.byCategory))t+=`- ${g}: ${m}
+`}const s=d(t);return r&&h.set(r,s,3e4),s}},{name:"wyrm_skill_graph",description:"Return the GOD-SKILL SPEC v2 governance graph: walks god \u2192 governs(mega) \u2192 governs(atomic) plus each node's composes, as a tree + edge-list the caller can render. Pass a root skill to scope to one apex; omit it to get the forest of every 'god' tier skill.",inputSchema:{type:"object",properties:{root:{type:"string",description:"Optional root skill name to scope the graph (e.g. 'ghost-godhead'). Omit for all god-tier apexes."},format:{type:"string",enum:["tree","edges","both"],description:"Output shape: 'tree' (nested), 'edges' (flat edge-list), or 'both' (default)."}}},annotations:v.wyrm_skill_graph,aliases:[],handler:async(c,p)=>{const{db:d,graph:n}=p,{root:r,format:o}=c,t=o||"both",s=d.getSkillGraph(r);if(s.length===0)return{content:[{type:"text",text:`\u{F115D} **Skill Graph**
+
+${r?`Skill "${r}" is not registered (or has no graph).`:"No god-tier skills registered. Register one with wyrm_skill_register tier='god' + governs=[...]."}`}]};const g=[],m=e=>{for(const l of e.governs)g.push({from:e.name,to:l,kind:"governs",resolved:e.children.some(k=>k.name===l)});for(const l of e.composes)g.push({from:e.name,to:l,kind:"composes",resolved:!1});for(const l of e.children)m(l)};for(const e of s)m(e);const a=e=>e==="god"?"\u{1F451}":e==="mega"?"\u25C6":"\xB7",y=(e,l)=>{const k="  ".repeat(l);let u=`${k}${a(e.tier)} ${e.name} (${e.tier})
+`;e.composes.length&&(u+=`${k}    ~composes: ${e.composes.join(", ")}
+`),e.missing&&e.missing.length&&(u+=`${k}    \u26A0 missing: ${e.missing.join(", ")}
+`);for(const f of e.children)u+=y(f,l+1);return u};let i=`\u{F115D} **Skill Governance Graph**${r?` (root: ${r})`:" (all god apexes)"}
+
+`;if(t==="tree"||t==="both")for(const e of s)i+=y(e,0);if(t==="edges"||t==="both"){i+=`
+**Edges (${g.length}):**
+`;for(const e of g)i+=`- ${e.from} \u2014${e.kind}\u2192 ${e.to}${e.kind==="governs"&&!e.resolved?" (unresolved)":""}
+`}return i+=`
+\`\`\`json
+${JSON.stringify({tree:s,edges:g},null,2)}
+\`\`\``,{content:[{type:"text",text:i}]}}}];export{A as skillToolSpecs};