@contextstream/mcp-server 0.4.65 → 0.4.66

package/dist/index.js

@@ -12919,6 +12919,37 @@ function normalizeTags(tags) {
   );
   return normalized.length > 0 ? normalized : void 0;
 }
+function extractEventTags(item) {
+  const tags = [];
+  if (Array.isArray(item.tags)) {
+    tags.push(...item.tags.filter((t) => typeof t === "string"));
+  }
+  const metaTags = item.metadata?.tags;
+  if (Array.isArray(metaTags)) {
+    tags.push(...metaTags.filter((t) => typeof t === "string"));
+  }
+  return tags;
+}
+function extractEffectiveEventType(item) {
+  for (const field of ["event_type", "node_type", "type"]) {
+    const val = item[field];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  for (const field of ["original_type", "node_type", "event_type", "type"]) {
+    const val = item.metadata?.[field];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  return "unknown";
+}
+function isLessonResult(item) {
+  const effectiveType = extractEffectiveEventType(item);
+  if (effectiveType === "lesson") return true;
+  const tags = extractEventTags(item);
+  if (tags.some((t) => t === "lesson" || t === "lesson_system")) return true;
+  const content = typeof item.content === "string" ? item.content : "";
+  if (content.includes("### Prevention") && content.includes("### Trigger")) return true;
+  return false;
+}
 function pickString(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -13472,6 +13503,8 @@ var ContextStreamClient = class _ContextStreamClient {
     const query = new URLSearchParams();
     if (params?.limit) query.set("limit", String(params.limit));
     if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.event_type) query.set("event_type", params.event_type);
+    if (params?.tags && params.tags.length > 0) query.set("tags", params.tags.join(","));
     const suffix = query.toString() ? `?${query.toString()}` : "";
     return request(this.config, `/memory/events/workspace/${withDefaults.workspace_id}${suffix}`, {
       method: "GET"
@@ -15835,14 +15868,13 @@ ${context}`;
       });
       if (!searchResult?.results) return [];
       const lessons = searchResult.results.filter((item) => {
-        const tags = item.metadata?.tags || [];
-        const isLesson = tags.includes("lesson") || tags.includes("lesson_system");
-        if (!isLesson) return false;
+        if (!isLessonResult(item)) return false;
+        const tags = extractEventTags(item);
         const severityTag = tags.find((t) => t.startsWith("severity:"));
         const severity = severityTag?.split(":")[1] || item.metadata?.importance || "medium";
         return severity === "critical" || severity === "high";
       }).slice(0, limit).map((item) => {
-        const tags = item.metadata?.tags || [];
+        const tags = extractEventTags(item);
         const severityTag = tags.find((t) => t.startsWith("severity:"));
         const severity = severityTag?.split(":")[1] || item.metadata?.importance || "medium";
         const category = tags.find(
@@ -15856,7 +15888,7 @@ ${context}`;
         ) || "unknown";
         const content = item.content || "";
         const preventionMatch = content.match(/### Prevention\n([\s\S]*?)(?:\n\n|\n\*\*|$)/);
-        const prevention = preventionMatch?.[1]?.trim() || content.slice(0, 200);
+        const prevention = preventionMatch?.[1]?.trim() || content.slice(0, 1e3);
         return {
           title: item.title || "Lesson",
           severity,
@@ -17111,6 +17143,55 @@ ${context}`;
     return request(this.config, `/docs/${params.doc_id}`, { method: "DELETE" });
   }
   // -------------------------------------------------------------------------
+  // Skill methods (portable instruction + action bundles)
+  // -------------------------------------------------------------------------
+  async listSkills(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (params?.project_id) query.set("project_id", params.project_id);
+    if (params?.scope) query.set("scope", params.scope);
+    if (params?.status) query.set("status", params.status);
+    if (params?.category) query.set("category", params.category);
+    if (params?.query) query.set("query", params.query);
+    if (params?.is_personal !== void 0) query.set("is_personal", String(params.is_personal));
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/skills${suffix}`, { method: "GET" });
+  }
+  async getSkill(skillId) {
+    return request(this.config, `/skills/${skillId}`, { method: "GET" });
+  }
+  async createSkill(params) {
+    return request(this.config, "/skills", { body: this.withDefaults(params) });
+  }
+  async updateSkill(skillId, params) {
+    return request(this.config, `/skills/${skillId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  async runSkill(skillId, params) {
+    return request(this.config, `/skills/${skillId}/run`, {
+      body: params || {}
+    });
+  }
+  async deleteSkill(skillId) {
+    return request(this.config, `/skills/${skillId}`, { method: "DELETE" });
+  }
+  async importSkills(params) {
+    return request(this.config, "/skills/import", { body: this.withDefaults(params) });
+  }
+  async exportSkills(params) {
+    const withDefaults = this.withDefaults(params || {});
+    return request(this.config, "/skills/export", { body: withDefaults });
+  }
+  async shareSkill(skillId, scope) {
+    return request(this.config, `/skills/${skillId}/share`, {
+      body: { scope }
+    });
+  }
+  // -------------------------------------------------------------------------
   // Transcript methods (conversation session storage)
   // -------------------------------------------------------------------------
   /**
@@ -17202,14 +17283,14 @@ ${context}`;
 };
 
 // src/tools.ts
-init_files();
-init_rules_templates();
-init_version();
 import * as fs5 from "node:fs";
 import * as path6 from "node:path";
 import { execFile } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 import { promisify as promisify2 } from "node:util";
+init_files();
+init_rules_templates();
+init_version();
 
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
@@ -19313,6 +19394,8 @@ var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
   // Consolidates slack_*, github_*, notion_*, integrations_*
   "media",
   // Consolidates media indexing, search, and clip retrieval for Remotion/FFmpeg
+  "skill",
+  // Skill management: list, get, create, update, run, delete, import, export, share
   "help"
   // Consolidates session_tools, auth_me, mcp_server_version, etc.
 ]);
@@ -19332,6 +19415,7 @@ function mapToolToConsolidatedDomain(toolName) {
     return "integration";
   }
   if (toolName.startsWith("media_")) return "media";
+  if (toolName.startsWith("skill_")) return "skill";
   if (toolName === "session_tools" || toolName === "auth_me" || toolName === "mcp_server_version" || toolName === "tools_enable_bundle") {
     return "help";
   }
@@ -19427,6 +19511,31 @@ function toStructured(data) {
   }
   return void 0;
 }
+function formatSkillDetail(skill) {
+  const lines = [
+    `**${skill.title || skill.name || "?"}** (${skill.name || "?"})`,
+    `- ID: ${skill.id || "?"}`,
+    `- Scope: ${skill.scope || "personal"} | Status: ${skill.status || "active"}`
+  ];
+  if (skill.description) lines.push(`- Description: ${skill.description}`);
+  if (skill.trigger_patterns?.length) lines.push(`- Triggers: ${skill.trigger_patterns.join(", ")}`);
+  if (skill.categories?.length) lines.push(`- Categories: ${skill.categories.join(", ")}`);
+  if (skill.priority != null) lines.push(`- Priority: ${skill.priority}`);
+  if (skill.version) lines.push(`- Version: ${skill.version}`);
+  if (skill.instruction_body) {
+    const body = String(skill.instruction_body);
+    lines.push(`
+### Instruction
+${body.length > 2e3 ? body.slice(0, 2e3) + "\u2026" : body}`);
+  }
+  return lines.join("\n");
+}
+function formatRunResult(result) {
+  if (result.instruction) return result.instruction;
+  if (result.output) return `Skill output:
+${result.output}`;
+  return JSON.stringify(result, null, 2);
+}
 function readStatNumber(payload, key) {
   if (!payload || typeof payload !== "object") return void 0;
   const direct = payload[key];
@@ -21750,6 +21859,201 @@ Access: Free`,
       };
     }
   );
+  registerTool(
+    "skill",
+    {
+      title: "Manage reusable skills",
+      description: `Manage and execute reusable skills (instruction + action bundles). Skills are portable across projects, sessions, and tools.
+
+Actions:
+- list: Browse skills (filter by scope, status, category)
+- get: Get skill details by ID or name
+- create: Define a new skill with name, instruction, and triggers
+- update: Modify an existing skill
+- run: Execute a skill (by ID or name)
+- delete: Remove a skill
+- import: Import skills from file or content (supports markdown, JSON, cursorrules, claude_md)
+- export: Export skills in various formats
+- share: Change skill visibility scope`,
+      inputSchema: external_exports.object({
+        action: external_exports.enum(["list", "get", "create", "update", "run", "delete", "import", "export", "share"]).describe("The action to perform"),
+        skill_id: external_exports.string().optional().describe("Skill ID (UUID)"),
+        name: external_exports.string().optional().describe("Skill name (slug, e.g. 'deploy-checker')"),
+        title: external_exports.string().optional().describe("Skill display title"),
+        description: external_exports.string().optional().describe("Skill description"),
+        instruction_body: external_exports.string().optional().describe("Markdown instruction text (the prompt)"),
+        trigger_patterns: external_exports.array(external_exports.string()).optional().describe("Keywords/phrases for auto-activation"),
+        trigger_regex: external_exports.string().optional().describe("Optional regex for advanced trigger matching"),
+        categories: external_exports.array(external_exports.string()).optional().describe("Tags for discovery/filtering"),
+        actions: external_exports.any().optional().describe("Action steps array [{type, tool, params, ...}]"),
+        params: external_exports.any().optional().describe("Parameters passed to skill execution"),
+        dry_run: external_exports.boolean().optional().describe("Preview execution without running"),
+        scope: external_exports.enum(["personal", "team", "public", "all"]).optional().describe("Visibility scope"),
+        status: external_exports.enum(["active", "draft", "archived"]).optional().describe("Skill status"),
+        is_personal: external_exports.boolean().optional().describe("Whether skill is personal"),
+        priority: external_exports.number().optional().describe("Skill priority 0-100 (higher = matched first)"),
+        content: external_exports.string().optional().describe("Content string for import"),
+        file_path: external_exports.string().optional().describe("Local file path for import"),
+        format: external_exports.enum(["auto", "json", "markdown", "skills_md", "cursorrules", "claude_md", "aider", "zip"]).optional().describe("Import/export format"),
+        source_tool: external_exports.string().optional().describe("Source tool name (for import provenance)"),
+        source_file: external_exports.string().optional().describe("Source filename (for import provenance)"),
+        skill_ids: external_exports.array(external_exports.string()).optional().describe("Skill IDs for export"),
+        change_summary: external_exports.string().optional().describe("Summary of changes (for version history)"),
+        workspace_id: external_exports.string().optional().describe("Workspace ID (UUID)"),
+        project_id: external_exports.string().optional().describe("Project ID (UUID)"),
+        query: external_exports.string().optional().describe("Search query"),
+        category: external_exports.string().optional().describe("Filter by category tag"),
+        limit: external_exports.number().optional().describe("Max results to return")
+      })
+    },
+    async (input) => {
+      const action = input.action;
+      switch (action) {
+        case "list": {
+          const result = await client.listSkills({
+            workspace_id: input.workspace_id,
+            project_id: input.project_id,
+            scope: input.scope,
+            status: input.status,
+            category: input.category,
+            query: input.query,
+            is_personal: input.is_personal,
+            limit: input.limit
+          });
+          const items = result.items || [];
+          let text = `Found ${items.length} skill(s).
+`;
+          for (const item of items) {
+            const name = item.name || "?";
+            const title = item.title || "?";
+            const scope = item.scope || "?";
+            const status = item.status || "?";
+            const id = item.id || "?";
+            text += `- ${title} (${name}) [${scope}|${status}] id=${id}
+`;
+          }
+          return { content: [{ type: "text", text }] };
+        }
+        case "get": {
+          let skillData;
+          if (input.skill_id) {
+            skillData = await client.getSkill(input.skill_id);
+          } else if (input.name) {
+            const result = await client.listSkills({
+              workspace_id: input.workspace_id,
+              query: input.name,
+              limit: 1
+            });
+            skillData = result.items?.find((s) => s.name === input.name) || result.items?.[0];
+            if (!skillData) throw new Error(`Skill '${input.name}' not found`);
+          } else {
+            throw new Error("Either skill_id or name is required for 'get'");
+          }
+          const detail = formatSkillDetail(skillData);
+          return { content: [{ type: "text", text: detail }] };
+        }
+        case "create": {
+          if (!input.name) throw new Error("'name' is required for create");
+          if (!input.instruction_body) throw new Error("'instruction_body' is required for create");
+          const result = await client.createSkill({
+            name: input.name,
+            title: input.title || input.name,
+            instruction_body: input.instruction_body,
+            description: input.description,
+            trigger_patterns: input.trigger_patterns,
+            trigger_regex: input.trigger_regex,
+            categories: input.categories,
+            actions: input.actions,
+            scope: input.scope,
+            is_personal: input.is_personal,
+            priority: input.priority,
+            workspace_id: input.scope === "team" ? input.workspace_id : void 0,
+            project_id: void 0,
+            // Skills are account-level by default
+            source_tool: input.source_tool,
+            source_file: input.source_file
+          });
+          return { content: [{ type: "text", text: `Skill '${input.name}' created (id=${result.id || "?"}).` }] };
+        }
+        case "update": {
+          if (!input.skill_id) throw new Error("'skill_id' is required for update");
+          const result = await client.updateSkill(input.skill_id, {
+            title: input.title,
+            description: input.description,
+            instruction_body: input.instruction_body,
+            trigger_patterns: input.trigger_patterns,
+            trigger_regex: input.trigger_regex,
+            categories: input.categories,
+            actions: input.actions,
+            scope: input.scope,
+            status: input.status,
+            is_personal: input.is_personal,
+            priority: input.priority,
+            change_summary: input.change_summary
+          });
+          return { content: [{ type: "text", text: `Skill ${input.skill_id} updated (version=${result.version || 0}).` }] };
+        }
+        case "run": {
+          let resolvedId = input.skill_id;
+          if (!resolvedId && input.name) {
+            const result2 = await client.listSkills({
+              workspace_id: input.workspace_id,
+              query: input.name,
+              limit: 1
+            });
+            const found = result2.items?.find((s) => s.name === input.name) || result2.items?.[0];
+            if (!found?.id) throw new Error(`Skill '${input.name}' not found`);
+            resolvedId = found.id;
+          }
+          if (!resolvedId) throw new Error("Either skill_id or name is required for 'run'");
+          const result = await client.runSkill(resolvedId, {
+            params: input.params,
+            dry_run: input.dry_run
+          });
+          return { content: [{ type: "text", text: formatRunResult(result) }] };
+        }
+        case "delete": {
+          if (!input.skill_id) throw new Error("'skill_id' is required for delete");
+          await client.deleteSkill(input.skill_id);
+          return { content: [{ type: "text", text: `Skill ${input.skill_id} deleted.` }] };
+        }
+        case "import": {
+          let importContent = input.content;
+          if (!importContent && input.file_path) {
+            const { readFile: readFile4 } = await import("fs/promises");
+            importContent = await readFile4(input.file_path, "utf-8");
+          }
+          if (!importContent) throw new Error("Either 'content' or 'file_path' is required for import");
+          const result = await client.importSkills({
+            content: importContent,
+            format: input.format,
+            source_tool: input.source_tool,
+            source_file: input.source_file || input.file_path,
+            scope: input.scope,
+            workspace_id: input.workspace_id
+          });
+          return { content: [{ type: "text", text: `Import complete: ${result.imported || 0} imported, ${result.skipped || 0} skipped (duplicates).` }] };
+        }
+        case "export": {
+          const result = await client.exportSkills({
+            skill_ids: input.skill_ids,
+            format: input.format,
+            scope: input.scope,
+            workspace_id: input.workspace_id
+          });
+          return { content: [{ type: "text", text: result.content || JSON.stringify(result, null, 2) }] };
+        }
+        case "share": {
+          if (!input.skill_id) throw new Error("'skill_id' is required for share");
+          if (!input.scope) throw new Error("'scope' is required for share");
+          const result = await client.shareSkill(input.skill_id, input.scope);
+          return { content: [{ type: "text", text: `Skill ${input.skill_id} shared with scope=${result.scope || input.scope}.` }] };
+        }
+        default:
+          throw new Error(`Invalid skill action: '${action}'. Valid: list, get, create, update, run, delete, import, export, share`);
+      }
+    }
+  );
   registerTool(
     "memory_bulk_ingest",
     {
@@ -21772,15 +22076,24 @@ Access: Free`,
     "memory_list_events",
     {
       title: "List memory events",
-      description: "List memory events (optionally scoped)",
+      description: "List memory events (optionally scoped). Supports tag-based and event_type filtering for precise provenance tracking.",
       inputSchema: external_exports.object({
         workspace_id: external_exports.string().uuid().optional(),
         project_id: external_exports.string().uuid().optional(),
-        limit: external_exports.number().optional()
+        limit: external_exports.number().optional(),
+        tags: external_exports.array(external_exports.string()).optional().describe("Filter events that contain ALL of these tags"),
+        event_type: external_exports.string().optional().describe("Filter by event type (e.g. decision, lesson, manual_note)")
       })
     },
     async (input) => {
       const result = await client.listMemoryEvents(input);
+      if (input.tags && input.tags.length > 0 && result.items) {
+        const requiredTags = input.tags;
+        result.items = result.items.filter((item) => {
+          const itemTags = extractEventTags(item);
+          return requiredTags.every((tag) => itemTags.includes(tag));
+        });
+      }
       return {
         content: [{ type: "text", text: formatContent(result) }]
       };
@@ -21834,16 +22147,24 @@ Access: Free`,
     "memory_search",
     {
       title: "Memory-aware search",
-      description: "Search memory events/notes",
+      description: "Search memory events/notes. Supports optional tag-based pre-filtering.",
       inputSchema: external_exports.object({
         query: external_exports.string(),
         workspace_id: external_exports.string().uuid().optional(),
         project_id: external_exports.string().uuid().optional(),
-        limit: external_exports.number().optional()
+        limit: external_exports.number().optional(),
+        tags: external_exports.array(external_exports.string()).optional().describe("Filter results that contain ALL of these tags")
       })
     },
     async (input) => {
       const result = await client.memorySearch(input);
+      if (input.tags && input.tags.length > 0 && result.results) {
+        const requiredTags = input.tags;
+        result.results = result.results.filter((item) => {
+          const itemTags = extractEventTags(item);
+          return requiredTags.every((tag) => itemTags.includes(tag));
+        });
+      }
       return {
         content: [{ type: "text", text: formatContent(result) }]
       };
@@ -23631,9 +23952,8 @@ Returns lessons filtered by:
         // Fetch more to filter
       });
       const lessons = (searchResult.results || []).filter((item) => {
-        const tags = item.metadata?.tags || [];
-        const isLesson = tags.includes("lesson");
-        if (!isLesson) return false;
+        if (!isLessonResult(item)) return false;
+        const tags = extractEventTags(item);
         if (input.category && !tags.includes(input.category)) {
           return false;
         }
@@ -23652,7 +23972,7 @@ Returns lessons filtered by:
         };
       }
       const formattedLessons = lessons.map((lesson, i) => {
-        const tags = lesson.metadata?.tags || [];
+        const tags = extractEventTags(lesson);
         const severity = tags.find((t) => t.startsWith("severity:"))?.split(":")[1] || "medium";
         const category = tags.find(
           (t) => [
@@ -23671,7 +23991,7 @@ Returns lessons filtered by:
         }[severity] || "\u26AA";
         return `${i + 1}. ${severityEmoji} **${lesson.title}**
    Category: ${category} | Severity: ${severity}
-   ${lesson.content?.slice(0, 200)}...`;
+   ${lesson.content?.slice(0, 500)}...`;
       }).join("\n\n");
       return {
         content: [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.65",
+  "version": "0.4.66",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",