wyrm-mcp 7.2.1 → 7.2.2

package/dist/handlers/datalake.js

@@ -1,187 +1,7 @@
-/**
- * @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 { daemonOr } from "../daemon-writer.js";
-import { cache } from "../performance.js";
-import { sanitizeFtsQuery, sanitizeString, validateBatchSize } from "../security.js";
-export const datalakeToolSpecs = [
-    {
-        name: "wyrm_data_insert",
-        description: "Insert data into the data lake for a project",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-                category: { type: "string", description: "Data category (e.g., 'logs', 'metrics', 'artifacts')" },
-                key: { type: "string", description: "Data key/identifier" },
-                value: { type: "string", description: "Data value (can be JSON string)" },
-                metadata: { type: "object", description: "Optional metadata object" },
-            },
-            required: ["projectPath", "category", "key", "value"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_data_insert"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, vectorStore, wyrmCrypto } = 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(['projectPath', 'category', 'key', 'value']);
-            if (argErr)
-                return argErr;
-            const { projectPath, category, key, value, metadata } = args;
-            const project = db.getProject(projectPath);
-            if (!project) {
-                return { content: [{ type: "text", text: "Project not found" }] };
-            }
-            const sanitizedCategory = sanitizeString(category, 200);
-            const sanitizedKey = sanitizeString(key, 500);
-            const sanitizedValue = sanitizeString(value);
-            const encryptedValue = wyrmCrypto.maybeEncrypt(sanitizedValue);
-            // v7 F2 (T012): canonical write seam — sanitize + encrypt stay
-            // CLIENT-side (the daemon never needs WYRM_ENCRYPTION_KEY); only the
-            // final prepared row crosses the loopback hop. Direct path unchanged.
-            // The idempotency identity is the PLAINTEXT tuple: encrypt() salts +
-            // IVs per call, so the ciphertext differs on every invocation and can
-            // never key the caller-level retry contract (the breadcrumb's stored
-            // bytes make the retry re-send the ORIGINAL ciphertext).
-            const dataPoint = await daemonOr('data_insert', project.id, { category: sanitizedCategory, key: sanitizedKey, value: encryptedValue, metadata }, () => db.insertData(project.id, sanitizedCategory, sanitizedKey, encryptedValue, metadata), { category: sanitizedCategory, key: sanitizedKey, value: sanitizedValue, metadata });
-            // Index in vector store if available
-            if (vectorStore) {
-                vectorStore.addVector(`${category} ${key} ${value}`, 'note', dataPoint.id, project.id).catch(() => { });
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: `󱅝 Data inserted: ${category}/${key} (ID: ${dataPoint.id})${wyrmCrypto.isEnabled() ? ' 🔒' : ''}`
-                    }]
-            };
-        },
-    },
-    {
-        name: "wyrm_data_batch_insert",
-        description: "Batch insert multiple data points efficiently",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-                data: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            category: { type: "string" },
-                            key: { type: "string" },
-                            value: { type: "string" },
-                            metadata: { type: "object" },
-                        },
-                        required: ["category", "key", "value"],
-                    },
-                },
-            },
-            required: ["projectPath", "data"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_data_batch_insert"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, wyrmCrypto } = ctx;
-            const { projectPath, data } = args;
-            validateBatchSize(data);
-            const project = db.getProject(projectPath);
-            if (!project) {
-                return { content: [{ type: "text", text: "Project not found" }] };
-            }
-            const items = data.map(d => ({
-                ...d,
-                projectId: project.id,
-                value: wyrmCrypto.maybeEncrypt(sanitizeString(d.value)),
-            }));
-            const count = db.insertDataBatch(items);
-            return {
-                content: [{
-                        type: "text",
-                        text: `󱅝 Batch inserted ${count} data points${wyrmCrypto.isEnabled() ? ' 🔒' : ''}`
-                    }]
-            };
-        },
-    },
-    {
-        name: "wyrm_data_query",
-        description: "Query data from the data lake",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-                category: { type: "string", description: "Filter by category" },
-                search: { type: "string", description: "Full-text search query" },
-                limit: { type: "number", description: "Max results" },
-                offset: { type: "number", description: "Offset for pagination" },
-            },
-            required: ["projectPath"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_data_query"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db, wyrmCrypto } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { projectPath, category, search, limit, offset } = args;
-            const project = db.getProject(projectPath);
-            if (!project) {
-                return { content: [{ type: "text", text: "Project not found" }] };
-            }
-            let results;
-            if (search) {
-                const sanitizedSearch = sanitizeFtsQuery(search);
-                results = db.searchData(sanitizedSearch, project.id);
-            }
-            else {
-                results = db.queryData(project.id, category, limit || 100, offset || 0);
-            }
-            const text = results.slice(0, 50).map(d => {
-                const val = wyrmCrypto.maybeDecrypt(d.value);
-                return `- **${d.category}/${d.key}:** ${val.slice(0, 100)}${val.length > 100 ? '...' : ''}`;
-            }).join('\n');
-            const response = cachedResponse(`󱅝 **${results.length} Results**\n\n${text}`);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_data_categories",
-        description: "List all data categories for a project",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-            },
-            required: ["projectPath"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_data_categories"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { projectPath } = args;
-            const project = db.getProject(projectPath);
-            if (!project) {
-                return { content: [{ type: "text", text: "Project not found" }] };
-            }
-            const categories = db.getDataCategories(project.id);
-            const text = categories.map(c => `- ${c.category}: ${c.count} items`).join('\n');
-            const response = cachedResponse(`󱅝 **Data Categories for ${project.name}**\n\n${text}`);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000);
-            return response;
-        },
-    },
-];
-//# sourceMappingURL=datalake.js.map
+import{TOOL_ANNOTATIONS as j}from"../tool-annotations.js";import{currentReadCacheKey as x}from"./boundary.js";import{daemonOr as q}from"../daemon-writer.js";import{cache as v}from"../performance.js";import{sanitizeFtsQuery as w,sanitizeString as f,validateBatchSize as D}from"../security.js";const A=[{name:"wyrm_data_insert",description:"Insert data into the data lake for a project",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"},category:{type:"string",description:"Data category (e.g., 'logs', 'metrics', 'artifacts')"},key:{type:"string",description:"Data key/identifier"},value:{type:"string",description:"Data value (can be JSON string)"},metadata:{type:"object",description:"Optional metadata object"}},required:["projectPath","category","key","value"]},annotations:j.wyrm_data_insert,aliases:[],handler:async(c,y)=>{const{db:a,vectorStore:t,wyrmCrypto:n}=y,e=c||{},d=(k=>{const $=k.filter(P=>!e[P]&&e[P]!==0&&e[P]!==!1);return $.length>0?{content:[{type:"text",text:`Missing required arguments: ${$.join(", ")}`}],isError:!0}:null})(["projectPath","category","key","value"]);if(d)return d;const{projectPath:u,category:r,key:s,value:l,metadata:p}=c,m=a.getProject(u);if(!m)return{content:[{type:"text",text:"Project not found"}]};const g=f(r,200),i=f(s,500),h=f(l),b=n.maybeEncrypt(h),_=await q("data_insert",m.id,{category:g,key:i,value:b,metadata:p},()=>a.insertData(m.id,g,i,b,p),{category:g,key:i,value:h,metadata:p});return t&&t.addVector(`${r} ${s} ${l}`,"note",_.id,m.id).catch(()=>{}),{content:[{type:"text",text:`\u{F115D} Data inserted: ${r}/${s} (ID: ${_.id})${n.isEnabled()?" \u{1F512}":""}`}]}}},{name:"wyrm_data_batch_insert",description:"Batch insert multiple data points efficiently",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"},data:{type:"array",items:{type:"object",properties:{category:{type:"string"},key:{type:"string"},value:{type:"string"},metadata:{type:"object"}},required:["category","key","value"]}}},required:["projectPath","data"]},annotations:j.wyrm_data_batch_insert,aliases:[],handler:async(c,y)=>{const{db:a,wyrmCrypto:t}=y,{projectPath:n,data:e}=c;D(e);const o=a.getProject(n);if(!o)return{content:[{type:"text",text:"Project not found"}]};const d=e.map(r=>({...r,projectId:o.id,value:t.maybeEncrypt(f(r.value))}));return{content:[{type:"text",text:`\u{F115D} Batch inserted ${a.insertDataBatch(d)} data points${t.isEnabled()?" \u{1F512}":""}`}]}}},{name:"wyrm_data_query",description:"Query data from the data lake",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"},category:{type:"string",description:"Filter by category"},search:{type:"string",description:"Full-text search query"},limit:{type:"number",description:"Max results"},offset:{type:"number",description:"Offset for pagination"}},required:["projectPath"]},annotations:j.wyrm_data_query,aliases:[],handler:async(c,y)=>{const{cachedResponse:a,db:t,wyrmCrypto:n}=y,e=x(),{projectPath:o,category:d,search:u,limit:r,offset:s}=c,l=t.getProject(o);if(!l)return{content:[{type:"text",text:"Project not found"}]};let p;if(u){const i=w(u);p=t.searchData(i,l.id)}else p=t.queryData(l.id,d,r||100,s||0);const m=p.slice(0,50).map(i=>{const h=n.maybeDecrypt(i.value);return`- **${i.category}/${i.key}:** ${h.slice(0,100)}${h.length>100?"...":""}`}).join(`
+`),g=a(`\u{F115D} **${p.length} Results**
+
+${m}`);return e&&v.set(e,g,3e4),g}},{name:"wyrm_data_categories",description:"List all data categories for a project",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"}},required:["projectPath"]},annotations:j.wyrm_data_categories,aliases:[],handler:async(c,y)=>{const{cachedResponse:a,db:t}=y,n=x(),{projectPath:e}=c,o=t.getProject(e);if(!o)return{content:[{type:"text",text:"Project not found"}]};const u=t.getDataCategories(o.id).map(s=>`- ${s.category}: ${s.count} items`).join(`
+`),r=a(`\u{F115D} **Data Categories for ${o.name}**
+
+${u}`);return n&&v.set(n,r,3e4),r}}];export{A as datalakeToolSpecs};

package/dist/handlers/dispatch-context.js

@@ -1,22 +0,0 @@
-/**
- * Dispatcher context (v7 F4 T036 — the monolith drain).
- *
- * The remaining non-hot domains were lifted VERBATIM out of the index.ts
- * `switch (name)` into per-domain ToolSpec modules (handlers/<domain>.ts).
- * Those case bodies referenced module-scoped subsystem singletons by bare
- * name (`db`, `graph`, `mcpClient`, …) and a handful of index.ts helper
- * closures (`cachedResponse`, `runCompanionBuddy`, …). To move the bodies
- * with ZERO behavior drift, this context carries every one of those names —
- * index.ts wires the live singletons + closures into `dispatcherCtx`, and each
- * handler destructures the ones it uses from `ctx`.
- *
- * It EXTENDS `HandlerContext` (the hot-path slice) so an extracted handler can
- * also reach the narrow capabilities the hot domains use (`store`, `raw()`,
- * `cache`, `getActor`, …). The hot-path domains keep their narrow slices; this
- * broad context is only the drain seam for the formerly-switch-resident tools.
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-export {};
-//# sourceMappingURL=dispatch-context.js.map

package/dist/handlers/entity.js

@@ -1,256 +1,25 @@
-/**
- * @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";
-export const entityToolSpecs = [
-    {
-        name: "wyrm_entity_add",
-        description: "Add an entity to the knowledge graph (person, concept, tool, etc.)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project to add entity to" },
-                name: { type: "string", description: "Entity name" },
-                type: { type: "string", description: "Entity type (e.g., person, concept, tool, framework, service)" },
-                metadata: { type: "string", description: "JSON metadata about the entity" },
-                aliases: { type: "array", items: { type: "string" }, description: "Alternative names for the entity" },
-            },
-            required: ["projectPath", "name", "type"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_add"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, graph } = ctx;
-            const { projectPath: ePath, name: eName, type: eType, metadata: eMeta, aliases: eAliases } = args;
-            const eProject = db.getProject(ePath);
-            if (!eProject)
-                return { content: [{ type: "text", text: `Project not found: ${ePath}` }], isError: true };
-            const existingEntity = graph.findEntity(eProject.id, eName, eType);
-            if (existingEntity) {
-                return { content: [{ type: "text", text: `󱅝 Entity already exists: **${eName}** (${eType}) — id ${existingEntity.id}` }] };
-            }
-            const entity = graph.addEntity(eProject.id, eName, eType, eMeta);
-            if (eAliases?.length) {
-                for (const alias of eAliases)
-                    graph.addAlias(entity.id, alias);
-            }
-            cache.invalidate('wyrm_entity_search');
-            cache.invalidate('wyrm_entity_graph');
-            cache.invalidate('wyrm_stats');
-            let text = `󱅝 **Entity Added**\n\n- **${entity.name}** _(${entity.type})_\n- ID: ${entity.id}\n`;
-            if (eAliases?.length)
-                text += `- Aliases: ${eAliases.join(', ')}\n`;
-            return { content: [{ type: "text", text }] };
-        },
-    },
-    {
-        name: "wyrm_entity_link",
-        description: "Create a relationship between two entities in the knowledge graph",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project containing the entities" },
-                source: { type: "string", description: "Source entity name" },
-                target: { type: "string", description: "Target entity name" },
-                relationship: { type: "string", description: "Relationship type (e.g., uses, depends_on, created_by, extends)" },
-                weight: { type: "number", description: "Relationship weight 0-1 (default: 1.0)" },
-                confidence: { type: "number", description: "Confidence score 0-1 (default: 1.0)" },
-                sourceMemory: { type: "string", description: "Source of this knowledge (e.g., session:42, quest:7)" },
-            },
-            required: ["projectPath", "source", "target", "relationship"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_link"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, graph } = ctx;
-            const { projectPath: lPath, source, target, relationship, weight, confidence, sourceMemory } = args;
-            const lProject = db.getProject(lPath);
-            if (!lProject)
-                return { content: [{ type: "text", text: `Project not found: ${lPath}` }], isError: true };
-            const srcEntity = graph.findEntity(lProject.id, source) ?? graph.findByAlias(lProject.id, source);
-            const tgtEntity = graph.findEntity(lProject.id, target) ?? graph.findByAlias(lProject.id, target);
-            if (!srcEntity)
-                return { content: [{ type: "text", text: `Entity not found: "${source}". Use wyrm_entity_add first.` }], isError: true };
-            if (!tgtEntity)
-                return { content: [{ type: "text", text: `Entity not found: "${target}". Use wyrm_entity_add first.` }], isError: true };
-            const rel = graph.addRelationship(lProject.id, srcEntity.id, tgtEntity.id, relationship, {
-                weight: weight ?? 1.0,
-                confidence: confidence ?? 1.0,
-                sourceMemory,
-            });
-            cache.invalidate('wyrm_entity_search');
-            cache.invalidate('wyrm_entity_graph');
-            cache.invalidate('wyrm_stats');
-            return { content: [{ type: "text", text: `󱅝 **Relationship Created**\n\n**${source}** —[${relationship}]→ **${target}**\n- ID: ${rel.id}${sourceMemory ? `\n- Source: ${sourceMemory}` : ''}` }] };
-        },
-    },
-    {
-        name: "wyrm_entity_search",
-        description: "Search for entities in the knowledge graph",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project to search in" },
-                query: { type: "string", description: "Search query for entity names" },
-                type: { type: "string", description: "Filter by entity type" },
-                limit: { type: "number", description: "Max results (default: 20)" },
-            },
-            required: ["projectPath", "query"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_search"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db, graph } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { projectPath: sePath, query: seQuery, type: seType, limit: seLimit } = args;
-            const seProject = db.getProject(sePath);
-            if (!seProject)
-                return { content: [{ type: "text", text: `Project not found: ${sePath}` }], isError: true };
-            const entities = graph.searchEntities(seProject.id, seQuery, seLimit ?? 20);
-            const filtered = seType ? entities.filter(e => e.type === seType) : entities;
-            if (filtered.length === 0) {
-                return { content: [{ type: "text", text: `󱅝 No entities found matching "${seQuery}"` }] };
-            }
-            let text = `󱅝 **Entities matching "${seQuery}"** (${filtered.length})\n\n`;
-            for (const e of filtered) {
-                const rels = graph.getRelationships(e.id, 'both');
-                const aliases = graph.getAliases(e.id);
-                text += `- **${e.name}** _(${e.type})_ — ${rels.length} connection${rels.length !== 1 ? 's' : ''}`;
-                if (aliases.length)
-                    text += ` | also: ${aliases.join(', ')}`;
-                text += '\n';
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 15000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_entity_graph",
-        description: "Get the neighborhood graph around an entity — all connected nodes within N hops",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project containing the entity" },
-                entity: { type: "string", description: "Entity name to center on" },
-                depth: { type: "number", description: "Max hops from center (1-5, default: 2)" },
-            },
-            required: ["projectPath", "entity"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_graph"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db, graph } = ctx;
-            const a = args || {};
-            const cacheKey = currentReadCacheKey();
-            const { projectPath: gPath, entity: gEntity, depth: gDepth } = args;
-            const gProject = db.getProject(gPath);
-            if (!gProject)
-                return { content: [{ type: "text", text: `Project not found: ${gPath}` }], isError: true };
-            const centerEntity = graph.findEntity(gProject.id, gEntity) ?? graph.findByAlias(gProject.id, gEntity);
-            if (!centerEntity)
-                return { content: [{ type: "text", text: `Entity not found: "${gEntity}". Use wyrm_entity_search to find entities.` }], isError: true };
-            const hood = graph.getNeighborhood(centerEntity.id, Math.min(gDepth ?? 2, 5));
-            let text = `󱅝 **Graph: ${centerEntity.name}** _(depth: ${gDepth ?? 2})_\n\n`;
-            text += `**${hood.nodes.length} nodes, ${hood.edges.length} edges**\n\n`;
-            // Group nodes by depth
-            const byDepth = {};
-            for (const n of hood.nodes) {
-                if (!byDepth[n.depth])
-                    byDepth[n.depth] = [];
-                byDepth[n.depth].push(n);
-            }
-            for (const [depth, nodes] of Object.entries(byDepth).sort((a, b) => Number(a[0]) - Number(b[0]))) {
-                const label = depth === '0' ? '🎯 Center' : `Hop ${depth}`;
-                text += `**${label}:** ${nodes.map(n => `${n.name} (${n.type})`).join(', ')}\n`;
-            }
-            if (hood.edges.length > 0) {
-                text += '\n**Connections:**\n';
-                for (const e of hood.edges.slice(0, 20)) {
-                    text += `- ${e.source_name} —[${e.relationship_type}]→ ${e.target_name}\n`;
-                }
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 15000);
-            return response;
-        },
-    },
-    {
-        name: "wyrm_entity_path",
-        description: "Find the shortest path between two entities in the knowledge graph",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project containing the entities" },
-                source: { type: "string", description: "Source entity name" },
-                target: { type: "string", description: "Target entity name" },
-                maxDepth: { type: "number", description: "Max path length (1-5, default: 5)" },
-            },
-            required: ["projectPath", "source", "target"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_path"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, graph } = ctx;
-            const { projectPath: pPath, source: pSource, target: pTarget, maxDepth: pDepth } = args;
-            const pProject = db.getProject(pPath);
-            if (!pProject)
-                return { content: [{ type: "text", text: `Project not found: ${pPath}` }], isError: true };
-            const pSrc = graph.findEntity(pProject.id, pSource) ?? graph.findByAlias(pProject.id, pSource);
-            const pTgt = graph.findEntity(pProject.id, pTarget) ?? graph.findByAlias(pProject.id, pTarget);
-            if (!pSrc)
-                return { content: [{ type: "text", text: `Entity not found: "${pSource}"` }], isError: true };
-            if (!pTgt)
-                return { content: [{ type: "text", text: `Entity not found: "${pTarget}"` }], isError: true };
-            const path = graph.findPath(pSrc.id, pTgt.id, Math.min(pDepth ?? 5, 5));
-            if (!path) {
-                return { content: [{ type: "text", text: `󱅝 No path found between **${pSource}** and **${pTarget}** within ${pDepth ?? 5} hops.` }] };
-            }
-            // Resolve entity names for path display
-            const pathEntities = path.map(id => graph.getEntity(id)).filter(Boolean);
-            const pathStr = pathEntities.map(e => e.name).join(' → ');
-            return { content: [{ type: "text", text: `󱅝 **Path Found** (${path.length - 1} hops)\n\n${pathStr}` }] };
-        },
-    },
-    {
-        name: "wyrm_entity_merge",
-        description: "Merge two entities — combines aliases, redirects relationships, deletes the source",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project containing the entities" },
-                source: { type: "string", description: "Entity name to merge FROM (will be deleted)" },
-                target: { type: "string", description: "Entity name to merge INTO (will be kept)" },
-            },
-            required: ["projectPath", "source", "target"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_entity_merge"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db, graph } = ctx;
-            const { projectPath: mPath, source: mSource, target: mTarget } = args;
-            const mProject = db.getProject(mPath);
-            if (!mProject)
-                return { content: [{ type: "text", text: `Project not found: ${mPath}` }], isError: true };
-            const mSrc = graph.findEntity(mProject.id, mSource) ?? graph.findByAlias(mProject.id, mSource);
-            const mTgt = graph.findEntity(mProject.id, mTarget) ?? graph.findByAlias(mProject.id, mTarget);
-            if (!mSrc)
-                return { content: [{ type: "text", text: `Entity not found: "${mSource}"` }], isError: true };
-            if (!mTgt)
-                return { content: [{ type: "text", text: `Entity not found: "${mTarget}"` }], isError: true };
-            if (mSrc.id === mTgt.id)
-                return { content: [{ type: "text", text: `Cannot merge entity with itself.` }], isError: true };
-            graph.mergeEntities(mSrc.id, mTgt.id);
-            cache.invalidate('wyrm_entity_search');
-            cache.invalidate('wyrm_entity_graph');
-            cache.invalidate('wyrm_stats');
-            return { content: [{ type: "text", text: `󱅝 **Merged** "${mSource}" → "${mTarget}"\n\n"${mSource}" is now an alias of "${mTarget}". All relationships redirected.` }] };
-        },
-    },
-];
-//# sourceMappingURL=entity.js.map
+import{TOOL_ANNOTATIONS as _}from"../tool-annotations.js";import{currentReadCacheKey as P}from"./boundary.js";import{cache as m}from"../performance.js";const S=[{name:"wyrm_entity_add",description:"Add an entity to the knowledge graph (person, concept, tool, etc.)",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project to add entity to"},name:{type:"string",description:"Entity name"},type:{type:"string",description:"Entity type (e.g., person, concept, tool, framework, service)"},metadata:{type:"string",description:"JSON metadata about the entity"},aliases:{type:"array",items:{type:"string"},description:"Alternative names for the entity"}},required:["projectPath","name","type"]},annotations:_.wyrm_entity_add,aliases:[],handler:async(g,l)=>{const{db:u,graph:t}=l,{projectPath:s,name:n,type:e,metadata:o,aliases:i}=g,a=u.getProject(s);if(!a)return{content:[{type:"text",text:`Project not found: ${s}`}],isError:!0};const p=t.findEntity(a.id,n,e);if(p)return{content:[{type:"text",text:`\u{F115D} Entity already exists: **${n}** (${e}) \u2014 id ${p.id}`}]};const r=t.addEntity(a.id,n,e,o);if(i?.length)for(const c of i)t.addAlias(r.id,c);m.invalidate("wyrm_entity_search"),m.invalidate("wyrm_entity_graph"),m.invalidate("wyrm_stats");let d=`\u{F115D} **Entity Added**
+
+- **${r.name}** _(${r.type})_
+- ID: ${r.id}
+`;return i?.length&&(d+=`- Aliases: ${i.join(", ")}
+`),{content:[{type:"text",text:d}]}}},{name:"wyrm_entity_link",description:"Create a relationship between two entities in the knowledge graph",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project containing the entities"},source:{type:"string",description:"Source entity name"},target:{type:"string",description:"Target entity name"},relationship:{type:"string",description:"Relationship type (e.g., uses, depends_on, created_by, extends)"},weight:{type:"number",description:"Relationship weight 0-1 (default: 1.0)"},confidence:{type:"number",description:"Confidence score 0-1 (default: 1.0)"},sourceMemory:{type:"string",description:"Source of this knowledge (e.g., session:42, quest:7)"}},required:["projectPath","source","target","relationship"]},annotations:_.wyrm_entity_link,aliases:[],handler:async(g,l)=>{const{db:u,graph:t}=l,{projectPath:s,source:n,target:e,relationship:o,weight:i,confidence:a,sourceMemory:p}=g,r=u.getProject(s);if(!r)return{content:[{type:"text",text:`Project not found: ${s}`}],isError:!0};const d=t.findEntity(r.id,n)??t.findByAlias(r.id,n),c=t.findEntity(r.id,e)??t.findByAlias(r.id,e);if(!d)return{content:[{type:"text",text:`Entity not found: "${n}". Use wyrm_entity_add first.`}],isError:!0};if(!c)return{content:[{type:"text",text:`Entity not found: "${e}". Use wyrm_entity_add first.`}],isError:!0};const h=t.addRelationship(r.id,d.id,c.id,o,{weight:i??1,confidence:a??1,sourceMemory:p});return m.invalidate("wyrm_entity_search"),m.invalidate("wyrm_entity_graph"),m.invalidate("wyrm_stats"),{content:[{type:"text",text:`\u{F115D} **Relationship Created**
+
+**${n}** \u2014[${o}]\u2192 **${e}**
+- ID: ${h.id}${p?`
+- Source: ${p}`:""}`}]}}},{name:"wyrm_entity_search",description:"Search for entities in the knowledge graph",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project to search in"},query:{type:"string",description:"Search query for entity names"},type:{type:"string",description:"Filter by entity type"},limit:{type:"number",description:"Max results (default: 20)"}},required:["projectPath","query"]},annotations:_.wyrm_entity_search,aliases:[],handler:async(g,l)=>{const{cachedResponse:u,db:t,graph:s}=l,n=P(),{projectPath:e,query:o,type:i,limit:a}=g,p=t.getProject(e);if(!p)return{content:[{type:"text",text:`Project not found: ${e}`}],isError:!0};const r=s.searchEntities(p.id,o,a??20),d=i?r.filter(f=>f.type===i):r;if(d.length===0)return{content:[{type:"text",text:`\u{F115D} No entities found matching "${o}"`}]};let c=`\u{F115D} **Entities matching "${o}"** (${d.length})
+
+`;for(const f of d){const y=s.getRelationships(f.id,"both"),$=s.getAliases(f.id);c+=`- **${f.name}** _(${f.type})_ \u2014 ${y.length} connection${y.length!==1?"s":""}`,$.length&&(c+=` | also: ${$.join(", ")}`),c+=`
+`}const h=u(c);return n&&m.set(n,h,15e3),h}},{name:"wyrm_entity_graph",description:"Get the neighborhood graph around an entity \u2014 all connected nodes within N hops",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project containing the entity"},entity:{type:"string",description:"Entity name to center on"},depth:{type:"number",description:"Max hops from center (1-5, default: 2)"}},required:["projectPath","entity"]},annotations:_.wyrm_entity_graph,aliases:[],handler:async(g,l)=>{const{cachedResponse:u,db:t,graph:s}=l,n=g||{},e=P(),{projectPath:o,entity:i,depth:a}=g,p=t.getProject(o);if(!p)return{content:[{type:"text",text:`Project not found: ${o}`}],isError:!0};const r=s.findEntity(p.id,i)??s.findByAlias(p.id,i);if(!r)return{content:[{type:"text",text:`Entity not found: "${i}". Use wyrm_entity_search to find entities.`}],isError:!0};const d=s.getNeighborhood(r.id,Math.min(a??2,5));let c=`\u{F115D} **Graph: ${r.name}** _(depth: ${a??2})_
+
+`;c+=`**${d.nodes.length} nodes, ${d.edges.length} edges**
+
+`;const h={};for(const y of d.nodes)h[y.depth]||(h[y.depth]=[]),h[y.depth].push(y);for(const[y,$]of Object.entries(h).sort((x,j)=>Number(x[0])-Number(j[0]))){const x=y==="0"?"\u{1F3AF} Center":`Hop ${y}`;c+=`**${x}:** ${$.map(j=>`${j.name} (${j.type})`).join(", ")}
+`}if(d.edges.length>0){c+=`
+**Connections:**
+`;for(const y of d.edges.slice(0,20))c+=`- ${y.source_name} \u2014[${y.relationship_type}]\u2192 ${y.target_name}
+`}const f=u(c);return e&&m.set(e,f,15e3),f}},{name:"wyrm_entity_path",description:"Find the shortest path between two entities in the knowledge graph",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project containing the entities"},source:{type:"string",description:"Source entity name"},target:{type:"string",description:"Target entity name"},maxDepth:{type:"number",description:"Max path length (1-5, default: 5)"}},required:["projectPath","source","target"]},annotations:_.wyrm_entity_path,aliases:[],handler:async(g,l)=>{const{db:u,graph:t}=l,{projectPath:s,source:n,target:e,maxDepth:o}=g,i=u.getProject(s);if(!i)return{content:[{type:"text",text:`Project not found: ${s}`}],isError:!0};const a=t.findEntity(i.id,n)??t.findByAlias(i.id,n),p=t.findEntity(i.id,e)??t.findByAlias(i.id,e);if(!a)return{content:[{type:"text",text:`Entity not found: "${n}"`}],isError:!0};if(!p)return{content:[{type:"text",text:`Entity not found: "${e}"`}],isError:!0};const r=t.findPath(a.id,p.id,Math.min(o??5,5));if(!r)return{content:[{type:"text",text:`\u{F115D} No path found between **${n}** and **${e}** within ${o??5} hops.`}]};const c=r.map(h=>t.getEntity(h)).filter(Boolean).map(h=>h.name).join(" \u2192 ");return{content:[{type:"text",text:`\u{F115D} **Path Found** (${r.length-1} hops)
+
+${c}`}]}}},{name:"wyrm_entity_merge",description:"Merge two entities \u2014 combines aliases, redirects relationships, deletes the source",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project containing the entities"},source:{type:"string",description:"Entity name to merge FROM (will be deleted)"},target:{type:"string",description:"Entity name to merge INTO (will be kept)"}},required:["projectPath","source","target"]},annotations:_.wyrm_entity_merge,aliases:[],handler:async(g,l)=>{const{db:u,graph:t}=l,{projectPath:s,source:n,target:e}=g,o=u.getProject(s);if(!o)return{content:[{type:"text",text:`Project not found: ${s}`}],isError:!0};const i=t.findEntity(o.id,n)??t.findByAlias(o.id,n),a=t.findEntity(o.id,e)??t.findByAlias(o.id,e);return i?a?i.id===a.id?{content:[{type:"text",text:"Cannot merge entity with itself."}],isError:!0}:(t.mergeEntities(i.id,a.id),m.invalidate("wyrm_entity_search"),m.invalidate("wyrm_entity_graph"),m.invalidate("wyrm_stats"),{content:[{type:"text",text:`\u{F115D} **Merged** "${n}" \u2192 "${e}"
+
+"${n}" is now an alias of "${e}". All relationships redirected.`}]}):{content:[{type:"text",text:`Entity not found: "${e}"`}],isError:!0}:{content:[{type:"text",text:`Entity not found: "${n}"`}],isError:!0}}}];export{S as entityToolSpecs};