@contextstream/mcp-server 0.3.42 → 0.3.44

package/dist/index.js

@@ -7443,11 +7443,155 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
   };
 }
 
+// src/tool-catalog.ts
+var TOOL_CATALOG = [
+  {
+    name: "Session",
+    tools: [
+      { name: "init", hint: "start-conv" },
+      { name: "smart", hint: "each-msg" },
+      { name: "capture", hint: "save" },
+      { name: "recall", hint: "find" },
+      { name: "remember", hint: "quick" },
+      { name: "compress", hint: "end" },
+      { name: "summary", hint: "brief" },
+      { name: "delta", hint: "changes" },
+      { name: "get_lessons", hint: "learn" },
+      { name: "capture_lesson", hint: "mistake" },
+      { name: "get_user_context", hint: "prefs" },
+      { name: "smart_search", hint: "deep-find" }
+    ]
+  },
+  {
+    name: "Search",
+    tools: [
+      { name: "semantic", hint: "meaning" },
+      { name: "hybrid", hint: "combo" },
+      { name: "keyword", hint: "exact" },
+      { name: "pattern", hint: "code" }
+    ]
+  },
+  {
+    name: "Memory",
+    tools: [
+      { name: "create_event", hint: "new" },
+      { name: "list_events", hint: "list" },
+      { name: "get_event", hint: "get" },
+      { name: "update_event", hint: "edit" },
+      { name: "delete_event", hint: "rm" },
+      { name: "search", hint: "find" },
+      { name: "decisions", hint: "choices" },
+      { name: "timeline", hint: "history" },
+      { name: "distill_event", hint: "extract" }
+    ]
+  },
+  {
+    name: "Knowledge",
+    tools: [
+      { name: "create_node", hint: "new" },
+      { name: "list_nodes", hint: "list" },
+      { name: "get_node", hint: "get" },
+      { name: "update_node", hint: "edit" },
+      { name: "delete_node", hint: "rm" },
+      { name: "supersede_node", hint: "replace" }
+    ]
+  },
+  {
+    name: "Graph",
+    tools: [
+      { name: "related", hint: "links" },
+      { name: "path", hint: "trace" },
+      { name: "decisions", hint: "choices" },
+      { name: "dependencies", hint: "deps" },
+      { name: "impact", hint: "changes" },
+      { name: "contradictions", hint: "conflicts" }
+    ]
+  },
+  {
+    name: "Workspace",
+    tools: [
+      { name: "list", hint: "" },
+      { name: "get", hint: "" },
+      { name: "create", hint: "" },
+      { name: "associate", hint: "link-folder" },
+      { name: "bootstrap", hint: "new-ws" }
+    ]
+  },
+  {
+    name: "Project",
+    tools: [
+      { name: "list", hint: "" },
+      { name: "get", hint: "" },
+      { name: "create", hint: "" },
+      { name: "index", hint: "scan-code" },
+      { name: "files", hint: "list-files" },
+      { name: "overview", hint: "summary" }
+    ]
+  },
+  {
+    name: "AI",
+    tools: [
+      { name: "context", hint: "smart-ctx" },
+      { name: "plan", hint: "generate" },
+      { name: "tasks", hint: "breakdown" },
+      { name: "embeddings", hint: "vectors" }
+    ]
+  }
+];
+function generateToolCatalog(format = "grouped", category) {
+  let categories = TOOL_CATALOG;
+  if (category) {
+    const filtered = TOOL_CATALOG.filter(
+      (c) => c.name.toLowerCase() === category.toLowerCase()
+    );
+    if (filtered.length > 0) {
+      categories = filtered;
+    }
+  }
+  switch (format) {
+    case "minimal":
+      return generateMinimal(categories);
+    case "full":
+      return generateFull(categories);
+    case "grouped":
+    default:
+      return generateGrouped(categories);
+  }
+}
+function generateGrouped(categories) {
+  return categories.map((cat) => {
+    const tools = cat.tools.map((t) => t.hint ? `${t.name}(${t.hint})` : t.name).join(" ");
+    return `${cat.name}: ${tools}`;
+  }).join("\n");
+}
+function generateMinimal(categories) {
+  return categories.map((cat) => {
+    const tools = cat.tools.map((t) => t.name).join("|");
+    return `${cat.name}:${tools}`;
+  }).join("\n");
+}
+function generateFull(categories) {
+  const lines = [];
+  for (const cat of categories) {
+    lines.push(`## ${cat.name}`);
+    for (const tool of cat.tools) {
+      const prefix = cat.name.toLowerCase().replace(/\s+/g, "_");
+      const fullName = `${prefix}_${tool.name}`;
+      lines.push(`- ${fullName}: ${tool.hint || "standard CRUD"}`);
+    }
+  }
+  return lines.join("\n");
+}
+function getCoreToolsHint() {
+  return `Session: init(start) smart(each-msg) capture(save) recall(find) remember(quick)`;
+}
+
 // src/tools.ts
 var LESSON_DEDUP_WINDOW_MS = 2 * 60 * 1e3;
 var recentLessonCaptures = /* @__PURE__ */ new Map();
 var CORE_TOOLSET = /* @__PURE__ */ new Set([
   "session_init",
+  "session_tools",
   "context_smart",
   "session_summary",
   "session_capture",
@@ -7462,6 +7606,8 @@ var CORE_TOOLSET = /* @__PURE__ */ new Set([
   "generate_editor_rules",
   "workspace_associate",
   "workspace_bootstrap",
+  "projects_create",
+  "projects_list",
   "auth_me",
   "mcp_server_version"
 ]);
@@ -7812,16 +7958,82 @@ Upgrade: ${upgradeUrl}` : "";
     "projects_create",
     {
       title: "Create project",
-      description: "Create a project within a workspace (returns ApiResponse with created project in data).",
+      description: `Create a new project within a workspace.
+Use this when you need to create a project for a specific folder/codebase.
+If workspace_id is not provided, uses the current session's workspace.
+Optionally associates a local folder and generates AI editor rules.
+
+Access: Free`,
       inputSchema: external_exports.object({
-        name: external_exports.string(),
-        description: external_exports.string().optional(),
-        workspace_id: external_exports.string().uuid().optional()
+        name: external_exports.string().describe("Project name"),
+        description: external_exports.string().optional().describe("Project description"),
+        workspace_id: external_exports.string().uuid().optional().describe("Workspace ID (uses current session workspace if not provided)"),
+        folder_path: external_exports.string().optional().describe("Optional: Local folder path to associate with this project"),
+        generate_editor_rules: external_exports.boolean().optional().describe("Generate AI editor rules in folder_path (requires folder_path)")
       })
     },
     async (input) => {
-      const result = await client.createProject(input);
-      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.createProject({
+        name: input.name,
+        description: input.description,
+        workspace_id: workspaceId
+      });
+      const projectData = result;
+      let rulesGenerated = [];
+      if (input.folder_path && projectData.id) {
+        try {
+          const configDir = path4.join(input.folder_path, ".contextstream");
+          const configPath = path4.join(configDir, "config.json");
+          if (!fs3.existsSync(configDir)) {
+            fs3.mkdirSync(configDir, { recursive: true });
+          }
+          const config = {
+            workspace_id: workspaceId,
+            project_id: projectData.id,
+            project_name: input.name
+          };
+          fs3.writeFileSync(configPath, JSON.stringify(config, null, 2));
+          if (input.generate_editor_rules) {
+            for (const editor of getAvailableEditors()) {
+              const rule = generateRuleContent(editor, {
+                workspaceId,
+                projectName: input.name
+              });
+              if (rule) {
+                const filePath = path4.join(input.folder_path, rule.filename);
+                try {
+                  let existingContent = "";
+                  try {
+                    existingContent = fs3.readFileSync(filePath, "utf-8");
+                  } catch {
+                  }
+                  if (!existingContent) {
+                    fs3.writeFileSync(filePath, rule.content);
+                    rulesGenerated.push(rule.filename);
+                  } else if (!existingContent.includes("ContextStream")) {
+                    fs3.writeFileSync(filePath, existingContent + "\n\n" + rule.content);
+                    rulesGenerated.push(rule.filename + " (appended)");
+                  }
+                } catch {
+                }
+              }
+            }
+          }
+        } catch (err) {
+          console.error("[ContextStream] Failed to write project config:", err);
+        }
+      }
+      const response = {
+        ...result,
+        folder_path: input.folder_path,
+        config_written: input.folder_path ? true : void 0,
+        editor_rules_generated: rulesGenerated.length > 0 ? rulesGenerated : void 0
+      };
+      return { content: [{ type: "text", text: formatContent(response) }], structuredContent: toStructured(response) };
     }
   );
   registerTool(
@@ -8688,6 +8900,7 @@ This does semantic search on the first message. You only need context_smart on s
         ideRoots = [input.folder_path];
       }
       const result = await client.initSession(input, ideRoots);
+      result.tools_hint = getCoreToolsHint();
       if (sessionManager) {
         sessionManager.markInitialized(result);
       }
@@ -8743,6 +8956,38 @@ This does semantic search on the first message. You only need context_smart on s
       return { content: [{ type: "text", text }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "session_tools",
+    {
+      title: "Get available ContextStream tools",
+      description: `Get an ultra-compact list of all available ContextStream MCP tools.
+Use this when you need to know what tools are available without reading full descriptions.
+
+Returns a token-efficient tool catalog (~120 tokens) organized by category.
+
+Format options:
+- 'grouped' (default): Category: tool(hint) tool(hint) - best for quick reference
+- 'minimal': Category:tool|tool|tool - most compact
+- 'full': Detailed list with descriptions
+
+Example output (grouped):
+Session: init(start-conv) smart(each-msg) capture(save) recall(find) remember(quick)
+Search: semantic(meaning) hybrid(combo) keyword(exact)
+Memory: events(crud) nodes(knowledge) search(find) decisions(choices)`,
+      inputSchema: external_exports.object({
+        format: external_exports.enum(["grouped", "minimal", "full"]).optional().default("grouped").describe("Output format: grouped (default, ~120 tokens), minimal (~80 tokens), or full (~200 tokens)"),
+        category: external_exports.string().optional().describe("Filter to specific category: Session, Search, Memory, Knowledge, Graph, Workspace, Project, AI")
+      })
+    },
+    async (input) => {
+      const format = input.format || "grouped";
+      const catalog = generateToolCatalog(format, input.category);
+      return {
+        content: [{ type: "text", text: catalog }],
+        structuredContent: { format, catalog }
+      };
+    }
+  );
   registerTool(
     "session_get_user_context",
     {
@@ -10520,9 +10765,9 @@ var SessionManager = class {
 };
 
 // src/index.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/setup.ts
 import * as fs5 from "node:fs/promises";
@@ -11366,14 +11611,14 @@ Applying to ${projects.length} project(s)...`);
 
 // src/index.ts
 function showFirstRunMessage() {
-  const configDir = join6(homedir3(), ".contextstream");
-  const starShownFile = join6(configDir, ".star-shown");
-  if (existsSync2(starShownFile)) {
+  const configDir = join7(homedir3(), ".contextstream");
+  const starShownFile = join7(configDir, ".star-shown");
+  if (existsSync3(starShownFile)) {
     return;
   }
-  if (!existsSync2(configDir)) {
+  if (!existsSync3(configDir)) {
     try {
-      mkdirSync2(configDir, { recursive: true });
+      mkdirSync3(configDir, { recursive: true });
     } catch {
       return;
     }
@@ -11386,7 +11631,7 @@ function showFirstRunMessage() {
   console.error("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
   console.error("");
   try {
-    writeFileSync2(starShownFile, (/* @__PURE__ */ new Date()).toISOString());
+    writeFileSync3(starShownFile, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextstream/mcp-server",
-  "version": "0.3.42",
+  "version": "0.3.44",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",