@contextstream/mcp-server 0.4.43 → 0.4.44

package/dist/index.js

@@ -7691,7 +7691,8 @@ var ContextStreamClient = class {
         ...Array.isArray(data?.errors) ? { errors: data.errors } : {},
         ...Array.isArray(data?.warnings) && data.warnings.length > 0 ? { warnings: data.warnings } : {},
         ...this.indexRefreshInProgress ? { index_status: "refreshing" } : {},
-        ...data?.context_pressure ? { context_pressure: data.context_pressure } : {}
+        ...data?.context_pressure ? { context_pressure: data.context_pressure } : {},
+        ...data?.semantic_intent ? { semantic_intent: data.semantic_intent } : {}
       };
     } catch (err) {
       const message2 = err instanceof Error ? err.message : String(err);
@@ -8831,6 +8832,145 @@ W:${wsHint}
     uuidSchema.parse(params.task_id);
     return request(this.config, `/tasks/${params.task_id}`, { method: "DELETE" });
   }
+  // ============================================================================
+  // Media/Content Methods (for video, audio, image indexing)
+  // ============================================================================
+  /**
+   * Initialize a media upload and get a presigned URL.
+   * After calling this, upload the file to the returned upload_url with the specified headers.
+   */
+  async mediaInitUpload(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for media upload");
+    }
+    const body = {
+      filename: params.filename,
+      size_bytes: params.size_bytes,
+      content_type: params.content_type.toLowerCase(),
+      // Backend uses snake_case (lowercase)
+      mime_type: params.mime_type,
+      title: params.title,
+      tags: params.tags || []
+    };
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/uploads/init`,
+      { method: "POST", body }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * Complete a media upload and trigger indexing.
+   * Call this after successfully uploading the file to the presigned URL.
+   */
+  async mediaCompleteUpload(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required to complete upload");
+    }
+    uuidSchema.parse(params.content_id);
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/${params.content_id}/complete-upload`,
+      { method: "POST" }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * Get the status of a content item (for checking indexing progress).
+   */
+  async mediaGetContent(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for getting content");
+    }
+    uuidSchema.parse(params.content_id);
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/${params.content_id}`,
+      { method: "GET" }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * List content items in a workspace.
+   */
+  async mediaListContent(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for listing content");
+    }
+    const query = new URLSearchParams();
+    if (params?.content_type) query.set("content_type", params.content_type);
+    if (params?.status) query.set("status", params.status);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content${suffix}`,
+      { method: "GET" }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * Search content by semantic query (transcripts, descriptions, etc.).
+   */
+  async mediaSearchContent(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for searching content");
+    }
+    const query = new URLSearchParams();
+    query.set("q", params.query);
+    if (params.content_type) query.set("content_type", params.content_type);
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/search?${query.toString()}`,
+      { method: "GET" }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * Get a specific clip/segment from indexed content.
+   */
+  async mediaGetClip(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for getting clips");
+    }
+    uuidSchema.parse(params.content_id);
+    const query = new URLSearchParams();
+    if (params.start_time !== void 0) query.set("start_time", String(params.start_time));
+    if (params.end_time !== void 0) query.set("end_time", String(params.end_time));
+    if (params.format) query.set("format", params.format);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/${params.content_id}/clip${suffix}`,
+      { method: "GET" }
+    );
+    return unwrapApiResponse(result);
+  }
+  /**
+   * Delete a content item.
+   */
+  async mediaDeleteContent(params) {
+    const withDefaults = this.withDefaults(params);
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for deleting content");
+    }
+    uuidSchema.parse(params.content_id);
+    const result = await request(
+      this.config,
+      `/workspaces/${withDefaults.workspace_id}/content/${params.content_id}`,
+      { method: "DELETE" }
+    );
+    return unwrapApiResponse(result);
+  }
 };
 
 // src/tools.ts
@@ -8872,6 +9012,38 @@ function applyMcpToolPrefix(markdown, toolPrefix) {
   const toolRegex = new RegExp(`(?<!__)\\b(${toolPattern})\\b(?=\\s*\\()`, "g");
   return markdown.replace(toolRegex, `${toolPrefix}$1`);
 }
+var CONTEXTSTREAM_RULES_DYNAMIC = `
+## ContextStream Dynamic Rules (Powered by our SmartRouter)
+
+All rules are served dynamically via \`context_smart\`. This file is minimal by design.
+
+### Every Message Protocol
+
+| Message | What to Call |
+|---------|--------------|
+| **1st message** | \`session_init(folder_path="<cwd>", context_hint="<msg>")\` then \`context_smart(user_message="<msg>")\` |
+| **2nd+ messages** | \`context_smart(user_message="<msg>")\` |
+
+### Follow the Instructions Field
+
+The \`context_smart\` response includes an \`instructions\` field with context-aware guidance.
+**Follow these instructions.** They are dynamically matched to your query and include:
+- Search guidance (when/how to search)
+- Git workflow rules (commit, PR, safety)
+- Planning rules (use ContextStream plans, not file-based)
+- Media/code analysis guidance
+- Lessons from past mistakes
+- And more...
+
+### Notices
+
+Handle notices from \`context_smart\` response:
+- **[VERSION_NOTICE]**: Tell user to update MCP
+- **[RULES_NOTICE]**: Run \`generate_rules()\`
+- **[LESSONS_WARNING]**: Apply lessons immediately
+
+Rules Version: ${RULES_VERSION}
+`.trim();
 var CONTEXTSTREAM_RULES_FULL = `
 ## ContextStream Rules
 
@@ -9528,8 +9700,8 @@ function getTemplate(editor) {
 function generateRuleContent(editor, options) {
   const template = getTemplate(editor);
   if (!template) return null;
-  const mode = options?.mode || "minimal";
-  const rules = mode === "full" ? CONTEXTSTREAM_RULES_FULL : CONTEXTSTREAM_RULES_MINIMAL;
+  const mode = options?.mode || "dynamic";
+  const rules = mode === "full" ? CONTEXTSTREAM_RULES_FULL : mode === "minimal" ? CONTEXTSTREAM_RULES_MINIMAL : CONTEXTSTREAM_RULES_DYNAMIC;
   let content = template.build(rules);
   if (options?.workspaceName || options?.projectName) {
     const header = `
@@ -9636,6 +9808,17 @@ var TOOL_CATALOG = [
       { name: "contradictions", hint: "conflicts" }
     ]
   },
+  {
+    name: "Media",
+    tools: [
+      { name: "index", hint: "add-media" },
+      { name: "status", hint: "progress" },
+      { name: "search", hint: "find-clip" },
+      { name: "get_clip", hint: "get-segment" },
+      { name: "list", hint: "browse" },
+      { name: "delete", hint: "remove" }
+    ]
+  },
   {
     name: "Workspace",
     tools: [
@@ -9900,6 +10083,78 @@ def main():
     print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": REMINDER}}))
     sys.exit(0)
 
+if __name__ == "__main__":
+    main()
+`;
+var MEDIA_AWARE_HOOK_SCRIPT = `#!/usr/bin/env python3
+"""
+ContextStream Media-Aware Hook for Claude Code
+
+Detects media-related prompts and injects context about the media tool.
+"""
+
+import json
+import sys
+import os
+import re
+
+ENABLED = os.environ.get("CONTEXTSTREAM_MEDIA_HOOK_ENABLED", "true").lower() == "true"
+
+# Media patterns (case-insensitive)
+PATTERNS = [
+    r"\\b(video|videos|clip|clips|footage|keyframe)s?\\b",
+    r"\\b(remotion|timeline|video\\s*edit)\\b",
+    r"\\b(image|images|photo|photos|picture|thumbnail)s?\\b",
+    r"\\b(audio|podcast|transcript|transcription|voice)\\b",
+    r"\\b(media|asset|assets|creative|b-roll)\\b",
+    r"\\b(find|search|show).*(clip|video|image|audio|footage|media)\\b",
+]
+
+COMPILED = [re.compile(p, re.IGNORECASE) for p in PATTERNS]
+
+MEDIA_CONTEXT = """[MEDIA TOOLS AVAILABLE]
+Your workspace may have indexed media. Use ContextStream media tools:
+
+- **Search**: \`mcp__contextstream__media(action="search", query="description")\`
+- **Get clip**: \`mcp__contextstream__media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion|ffmpeg|raw")\`
+- **List assets**: \`mcp__contextstream__media(action="list")\`
+- **Index**: \`mcp__contextstream__media(action="index", file_path="...", content_type="video|audio|image|document")\`
+
+For Remotion: use \`output_format="remotion"\` to get frame-based props.
+[END MEDIA TOOLS]"""
+
+def matches(text):
+    return any(p.search(text) for p in COMPILED)
+
+def main():
+    if not ENABLED:
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    prompt = data.get("prompt", "")
+    if not prompt:
+        session = data.get("session", {})
+        for msg in reversed(session.get("messages", [])):
+            if msg.get("role") == "user":
+                content = msg.get("content", "")
+                prompt = content if isinstance(content, str) else ""
+                if isinstance(content, list):
+                    for b in content:
+                        if isinstance(b, dict) and b.get("type") == "text":
+                            prompt = b.get("text", "")
+                            break
+                break
+
+    if not prompt or not matches(prompt):
+        sys.exit(0)
+
+    print(json.dumps({"hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": MEDIA_CONTEXT}}))
+    sys.exit(0)
+
 if __name__ == "__main__":
     main()
 `;
@@ -10148,6 +10403,31 @@ function buildHooksConfig(options) {
   const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
   const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
   const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
+  const mediaAwarePath = path5.join(hooksDir, "contextstream-media-aware.py");
+  const userPromptHooks = [
+    {
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: `python3 "${userPromptPath}"`,
+          timeout: 5
+        }
+      ]
+    }
+  ];
+  if (options?.includeMediaAware !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: `python3 "${mediaAwarePath}"`,
+          timeout: 5
+        }
+      ]
+    });
+  }
   const config = {
     PreToolUse: [
       {
@@ -10161,18 +10441,7 @@ function buildHooksConfig(options) {
         ]
       }
     ],
-    UserPromptSubmit: [
-      {
-        matcher: "*",
-        hooks: [
-          {
-            type: "command",
-            command: `python3 "${userPromptPath}"`,
-            timeout: 5
-          }
-        ]
-      }
-    ]
+    UserPromptSubmit: userPromptHooks
   };
   if (options?.includePreCompact) {
     config.PreCompact = [
@@ -10197,6 +10466,7 @@ async function installHookScripts(options) {
   const preToolUsePath = path5.join(hooksDir, "contextstream-redirect.py");
   const userPromptPath = path5.join(hooksDir, "contextstream-reminder.py");
   const preCompactPath = path5.join(hooksDir, "contextstream-precompact.py");
+  const mediaAwarePath = path5.join(hooksDir, "contextstream-media-aware.py");
   await fs4.writeFile(preToolUsePath, PRETOOLUSE_HOOK_SCRIPT, { mode: 493 });
   await fs4.writeFile(userPromptPath, USER_PROMPT_HOOK_SCRIPT, { mode: 493 });
   const result = {
@@ -10207,6 +10477,10 @@ async function installHookScripts(options) {
     await fs4.writeFile(preCompactPath, PRECOMPACT_HOOK_SCRIPT, { mode: 493 });
     result.preCompact = preCompactPath;
   }
+  if (options?.includeMediaAware !== false) {
+    await fs4.writeFile(mediaAwarePath, MEDIA_AWARE_HOOK_SCRIPT, { mode: 493 });
+    result.mediaAware = mediaAwarePath;
+  }
   return result;
 }
 async function readClaudeSettings(scope, projectPath) {
@@ -10882,6 +11156,7 @@ var TOOL_DISPLAY_NAMES = {
   search: "search",
   memory: "memory",
   graph: "graph",
+  media: "media",
   ai: "ai",
   generate_rules: "rules",
   generate_editor_rules: "rules",
@@ -12265,6 +12540,8 @@ var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
   // Consolidates reminders_list, reminders_create, etc.
   "integration",
   // Consolidates slack_*, github_*, notion_*, integrations_*
+  "media",
+  // Consolidates media indexing, search, and clip retrieval for Remotion/FFmpeg
   "help"
   // Consolidates session_tools, auth_me, mcp_server_version, etc.
 ]);
@@ -19663,6 +19940,430 @@ Last edited: ${updatedPage.last_edited_time}`
         }
       }
     );
+    registerTool(
+      "media",
+      {
+        title: "Media",
+        description: `Media operations for video/audio/image assets. Enables AI agents to index, search, and retrieve media with semantic understanding - solving the "LLM as video editor has no context" problem for tools like Remotion.
+
+Actions:
+- index: Index a local media file or external URL. Triggers ML processing (Whisper transcription, CLIP embeddings, keyframe extraction).
+- status: Check indexing progress for a content_id. Returns transcript_available, keyframe_count, duration.
+- search: Semantic search across indexed media. Returns timestamps, transcript excerpts, keyframe URLs.
+- get_clip: Get clip details for a time range. Supports output_format: remotion (frame-based props), ffmpeg (timecodes), raw.
+- list: List indexed media assets.
+- delete: Remove a media asset from the index.
+
+Example workflow:
+1. media(action="index", file_path="/path/to/video.mp4") \u2192 get content_id
+2. media(action="status", content_id="...") \u2192 wait for indexed
+3. media(action="search", query="where John explains authentication") \u2192 get timestamps
+4. media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion") \u2192 get Remotion props`,
+        inputSchema: external_exports.object({
+          action: external_exports.enum(["index", "status", "search", "get_clip", "list", "delete"]).describe("Action to perform"),
+          workspace_id: external_exports.string().uuid().optional(),
+          project_id: external_exports.string().uuid().optional(),
+          // Index params
+          file_path: external_exports.string().optional().describe("Local path to media file for indexing"),
+          external_url: external_exports.string().url().optional().describe("External URL to media file for indexing"),
+          content_type: external_exports.enum(["video", "audio", "image", "document"]).optional().describe("Type of media content (auto-detected if not provided)"),
+          // Status/get_clip/delete params
+          content_id: external_exports.string().uuid().optional().describe("Content ID from index operation"),
+          // Search params
+          query: external_exports.string().optional().describe("Semantic search query for media content"),
+          content_types: external_exports.array(external_exports.enum(["video", "audio", "image", "document"])).optional().describe("Filter search to specific content types"),
+          // Get clip params
+          start: external_exports.string().optional().describe('Start time for clip. Formats: "1:34", "94s", or seconds as string'),
+          end: external_exports.string().optional().describe('End time for clip. Formats: "2:15", "135s", or seconds as string'),
+          output_format: external_exports.enum(["remotion", "ffmpeg", "raw"]).optional().describe(
+            "Output format: remotion (frame-based props for Video component), ffmpeg (timecodes), raw (seconds)"
+          ),
+          fps: external_exports.number().optional().describe("Frames per second for remotion format (default: 30)"),
+          // Common params
+          tags: external_exports.array(external_exports.string()).optional().describe("Tags to associate with media"),
+          limit: external_exports.number().optional().describe("Maximum results to return")
+        })
+      },
+      async (input) => {
+        const workspaceId = resolveWorkspaceId(input.workspace_id);
+        const projectId = resolveProjectId(input.project_id);
+        switch (input.action) {
+          case "index": {
+            if (!input.file_path && !input.external_url) {
+              return errorResult("index requires: file_path or external_url");
+            }
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            if (input.file_path) {
+              const fs8 = await import("fs/promises");
+              const pathModule = await import("path");
+              const filePath = input.file_path.startsWith("~") ? input.file_path.replace("~", process.env.HOME || "") : input.file_path;
+              const resolvedPath = pathModule.resolve(filePath);
+              let fileStats;
+              try {
+                fileStats = await fs8.stat(resolvedPath);
+              } catch {
+                return errorResult(`File not found: ${resolvedPath}`);
+              }
+              if (!fileStats.isFile()) {
+                return errorResult(`Not a file: ${resolvedPath}`);
+              }
+              const ext = pathModule.extname(resolvedPath).toLowerCase();
+              const mimeTypes = {
+                ".mp4": "video/mp4",
+                ".webm": "video/webm",
+                ".mov": "video/quicktime",
+                ".avi": "video/x-msvideo",
+                ".mkv": "video/x-matroska",
+                ".mp3": "audio/mpeg",
+                ".wav": "audio/wav",
+                ".ogg": "audio/ogg",
+                ".flac": "audio/flac",
+                ".m4a": "audio/mp4",
+                ".png": "image/png",
+                ".jpg": "image/jpeg",
+                ".jpeg": "image/jpeg",
+                ".gif": "image/gif",
+                ".webp": "image/webp",
+                ".svg": "image/svg+xml"
+              };
+              const mimeType = mimeTypes[ext] || "application/octet-stream";
+              let contentType = "other";
+              if (input.content_type) {
+                contentType = input.content_type;
+              } else if (mimeType.startsWith("video/")) {
+                contentType = "video";
+              } else if (mimeType.startsWith("audio/")) {
+                contentType = "audio";
+              } else if (mimeType.startsWith("image/")) {
+                contentType = "image";
+              }
+              const filename = pathModule.basename(resolvedPath);
+              try {
+                const uploadInit = await client.mediaInitUpload({
+                  workspace_id: workspaceId,
+                  filename,
+                  size_bytes: fileStats.size,
+                  content_type: contentType,
+                  mime_type: mimeType,
+                  tags: input.tags
+                });
+                const fileBuffer = await fs8.readFile(resolvedPath);
+                const uploadResponse = await fetch(uploadInit.upload_url, {
+                  method: "PUT",
+                  headers: uploadInit.headers,
+                  body: fileBuffer
+                });
+                if (!uploadResponse.ok) {
+                  return errorResult(
+                    `Failed to upload file: ${uploadResponse.status} ${uploadResponse.statusText}`
+                  );
+                }
+                await client.mediaCompleteUpload({
+                  workspace_id: workspaceId,
+                  content_id: uploadInit.content_id
+                });
+                const result2 = {
+                  status: "uploaded",
+                  message: "Media file uploaded successfully. Indexing has been triggered.",
+                  content_id: uploadInit.content_id,
+                  filename,
+                  content_type: contentType,
+                  size_bytes: fileStats.size,
+                  mime_type: mimeType,
+                  note: "Use media(action='status', content_id='...') to check indexing progress."
+                };
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `\u2705 Media uploaded successfully!
+
+Content ID: ${uploadInit.content_id}
+Filename: ${filename}
+Type: ${contentType}
+Size: ${(fileStats.size / 1024 / 1024).toFixed(2)} MB
+
+Indexing has been triggered. Use media(action='status', content_id='${uploadInit.content_id}') to check progress.`
+                    }
+                  ],
+                  structuredContent: toStructured(result2)
+                };
+              } catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                return errorResult(`Failed to upload media: ${errMsg}`);
+              }
+            }
+            const result = {
+              status: "not_implemented",
+              message: "External URL indexing is not yet implemented. Please use file_path for local files instead.",
+              action: "index",
+              external_url: input.external_url,
+              content_type: input.content_type
+            };
+            return {
+              content: [{ type: "text", text: formatContent(result) }],
+              structuredContent: toStructured(result)
+            };
+          }
+          case "status": {
+            if (!input.content_id) {
+              return errorResult("status requires: content_id");
+            }
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            try {
+              const content = await client.mediaGetContent({
+                workspace_id: workspaceId,
+                content_id: input.content_id
+              });
+              let statusEmoji = "\u23F3";
+              let statusMessage = "Pending";
+              if (content.status === "indexed" || content.status === "ready") {
+                statusEmoji = "\u2705";
+                statusMessage = "Indexed and ready";
+              } else if (content.status === "processing" || content.status === "indexing") {
+                statusEmoji = "\u{1F504}";
+                statusMessage = `Processing${content.indexing_progress ? ` (${content.indexing_progress}%)` : ""}`;
+              } else if (content.status === "error" || content.status === "failed") {
+                statusEmoji = "\u274C";
+                statusMessage = content.indexing_error || "Indexing failed";
+              }
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `${statusEmoji} ${content.filename}
+
+Status: ${statusMessage}
+Content ID: ${content.id}
+Type: ${content.content_type}
+Size: ${(content.size_bytes / 1024 / 1024).toFixed(2)} MB
+Created: ${content.created_at}`
+                  }
+                ],
+                structuredContent: toStructured(content)
+              };
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              return errorResult(`Failed to get content status: ${errMsg}`);
+            }
+          }
+          case "search": {
+            if (!input.query) {
+              return errorResult("search requires: query");
+            }
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            try {
+              const searchResult = await client.mediaSearchContent({
+                workspace_id: workspaceId,
+                query: input.query,
+                content_type: input.content_types?.[0],
+                // API accepts single type for now
+                limit: input.limit
+              });
+              if (searchResult.results.length === 0) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `No results found for: "${input.query}"
+
+Try a different query or check that you have indexed media content.`
+                    }
+                  ],
+                  structuredContent: toStructured(searchResult)
+                };
+              }
+              const resultsText = searchResult.results.map((r, i) => {
+                let timeInfo = "";
+                if (r.timestamp_start !== void 0) {
+                  const startMin = Math.floor(r.timestamp_start / 60);
+                  const startSec = Math.floor(r.timestamp_start % 60);
+                  timeInfo = ` @ ${startMin}:${startSec.toString().padStart(2, "0")}`;
+                  if (r.timestamp_end !== void 0) {
+                    const endMin = Math.floor(r.timestamp_end / 60);
+                    const endSec = Math.floor(r.timestamp_end % 60);
+                    timeInfo += `-${endMin}:${endSec.toString().padStart(2, "0")}`;
+                  }
+                }
+                const matchText = r.match_text ? `
+   "${r.match_text}"` : "";
+                return `${i + 1}. ${r.filename} (${r.content_type})${timeInfo}${matchText}`;
+              }).join("\n\n");
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Found ${searchResult.total} result(s) for: "${input.query}"
+
+${resultsText}`
+                  }
+                ],
+                structuredContent: toStructured(searchResult)
+              };
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              return errorResult(`Failed to search media: ${errMsg}`);
+            }
+          }
+          case "get_clip": {
+            if (!input.content_id) {
+              return errorResult("get_clip requires: content_id");
+            }
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            const parseTime = (t) => {
+              if (!t) return void 0;
+              if (t.includes(":")) {
+                const parts = t.split(":").map(Number);
+                if (parts.length === 2) return parts[0] * 60 + parts[1];
+                if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+              }
+              if (t.endsWith("s")) return parseFloat(t.slice(0, -1));
+              return parseFloat(t);
+            };
+            const startTime = parseTime(input.start);
+            const endTime = parseTime(input.end);
+            try {
+              const clipResult = await client.mediaGetClip({
+                workspace_id: workspaceId,
+                content_id: input.content_id,
+                start_time: startTime,
+                end_time: endTime,
+                format: input.output_format === "remotion" ? "remotion" : input.output_format === "ffmpeg" ? "ffmpeg" : "json"
+              });
+              let outputText = `\u{1F4F9} Clip from: ${clipResult.filename}
+
+`;
+              outputText += `Time range: ${clipResult.clip.start_time}s - ${clipResult.clip.end_time}s
+`;
+              if (clipResult.clip.transcript) {
+                outputText += `
+Transcript:
+"${clipResult.clip.transcript}"
+`;
+              }
+              if (clipResult.remotion_props && input.output_format === "remotion") {
+                outputText += `
+### Remotion Props:
+\`\`\`json
+${JSON.stringify(clipResult.remotion_props, null, 2)}
+\`\`\``;
+              }
+              if (clipResult.ffmpeg_command && input.output_format === "ffmpeg") {
+                outputText += `
+### FFmpeg Command:
+\`\`\`bash
+${clipResult.ffmpeg_command}
+\`\`\``;
+              }
+              return {
+                content: [{ type: "text", text: outputText }],
+                structuredContent: toStructured(clipResult)
+              };
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              return errorResult(`Failed to get clip: ${errMsg}`);
+            }
+          }
+          case "list": {
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            try {
+              const listResult = await client.mediaListContent({
+                workspace_id: workspaceId,
+                content_type: input.content_types?.[0],
+                // API accepts single type for now
+                limit: input.limit
+              });
+              if (listResult.items.length === 0) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: "No media content found.\n\nUse media(action='index', file_path='...') to index media files."
+                    }
+                  ],
+                  structuredContent: toStructured(listResult)
+                };
+              }
+              const itemsText = listResult.items.map((item, i) => {
+                const statusEmoji = item.status === "indexed" || item.status === "ready" ? "\u2705" : item.status === "processing" ? "\u{1F504}" : item.status === "error" ? "\u274C" : "\u23F3";
+                const size = (item.size_bytes / 1024 / 1024).toFixed(2);
+                return `${i + 1}. ${statusEmoji} ${item.filename}
+   Type: ${item.content_type} | Size: ${size} MB | Status: ${item.status}
+   ID: ${item.id}`;
+              }).join("\n\n");
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u{1F4DA} Media Library (${listResult.total} items)
+
+${itemsText}`
+                  }
+                ],
+                structuredContent: toStructured(listResult)
+              };
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              return errorResult(`Failed to list media: ${errMsg}`);
+            }
+          }
+          case "delete": {
+            if (!input.content_id) {
+              return errorResult("delete requires: content_id");
+            }
+            if (!workspaceId) {
+              return errorResult(
+                "Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly."
+              );
+            }
+            try {
+              const deleteResult = await client.mediaDeleteContent({
+                workspace_id: workspaceId,
+                content_id: input.content_id
+              });
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: deleteResult.deleted ? `\u2705 Content deleted successfully.
+
+Content ID: ${input.content_id}` : `\u26A0\uFE0F Content may not have been deleted.
+
+Content ID: ${input.content_id}`
+                  }
+                ],
+                structuredContent: toStructured(deleteResult)
+              };
+            } catch (err) {
+              const errMsg = err instanceof Error ? err.message : String(err);
+              return errorResult(`Failed to delete content: ${errMsg}`);
+            }
+          }
+          default:
+            return errorResult(`Unknown action: ${input.action}`);
+        }
+      }
+    );
     registerTool(
       "help",
       {
@@ -22193,7 +22894,8 @@ function buildClientConfig(params) {
     defaultWorkspaceId: void 0,
     defaultProjectId: void 0,
     userAgent: `contextstream-mcp/setup/${VERSION}`,
-    contextPackEnabled: true
+    contextPackEnabled: true,
+    showTiming: false
   };
 }
 async function runSetupWizard(args) {
@@ -22440,7 +23142,15 @@ Code: ${device.user_code}`);
         }
       }
     }
-    const mode = "full";
+    console.log("\nRules mode (how rules are delivered to the AI):");
+    console.log("  1) Dynamic (recommended) \u2014 minimal rules file, context_smart delivers rules dynamically");
+    console.log("     Best for: efficiency, better results, rules always up-to-date");
+    console.log("     The rules file just tells the AI to call session_init + context_smart");
+    console.log("  2) Full \u2014 complete rules embedded in file");
+    console.log("     Best for: offline use, debugging, or if you prefer static rules");
+    console.log("");
+    const ruleModeChoice = normalizeInput(await rl.question("Choose [1/2] (default 1): ")) || "1";
+    const mode = ruleModeChoice === "2" ? "full" : "dynamic";
     const detectedPlanName = await client.getPlanName();
     const detectedGraphTier = await client.getGraphTier();
     const graphTierLabel = detectedGraphTier === "full" ? "full graph" : detectedGraphTier === "lite" ? "graph-lite" : "none";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.43",
+  "version": "0.4.44",
   "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",