@olivaresai/alma-mcp 1.3.1 → 1.3.2

package/dist/index.js

@@ -328,6 +328,87 @@ var AlmaClient = class _AlmaClient {
   async createProcedure(params) {
     return this.request("POST", "/procedures", params);
   }
+  // ─── Cowork (Collaborative Workspaces) ─────────────
+  async listWorkspaces() {
+    return this.request("GET", "/cowork/workspaces");
+  }
+  async createWorkspace(params) {
+    return this.request("POST", "/cowork/workspaces", params);
+  }
+  async listWorkspaceFiles(workspaceId) {
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files`
+    );
+  }
+  async readWorkspaceFile(workspaceId, filePath) {
+    const qs = new URLSearchParams({ path: filePath });
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files/read?${qs}`
+    );
+  }
+  async writeWorkspaceFile(workspaceId, filePath, content) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files/write`,
+      { path: filePath, content }
+    );
+  }
+  async searchWorkspace(workspaceId, query) {
+    const qs = new URLSearchParams({ q: query });
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/search?${qs}`
+    );
+  }
+  async executeSkill(workspaceId, params) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/skills`,
+      params
+    );
+  }
+  async applyDiff(workspaceId, operationId) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/apply`,
+      { operationId }
+    );
+  }
+  // ─── Video ────────────────────────────────────────
+  async generateVideo(params) {
+    return this.request("POST", "/video/generate", params);
+  }
+  async checkVideoJob(jobId) {
+    return this.request(
+      "GET",
+      `/video/jobs/${encodeURIComponent(jobId)}`
+    );
+  }
+  async listVideoProjects() {
+    return this.request("GET", "/video/projects");
+  }
+  async createVideoProject(params) {
+    return this.request("POST", "/video/projects", params);
+  }
+  async planVideoScenes(projectId, params) {
+    return this.request(
+      "POST",
+      `/video/projects/${encodeURIComponent(projectId)}/plan`,
+      params
+    );
+  }
+  async stitchVideo(projectId, jobIds) {
+    return this.request(
+      "POST",
+      `/video/projects/${encodeURIComponent(projectId)}/stitch`,
+      { jobIds }
+    );
+  }
+  async getVideoBudget() {
+    return this.request("GET", "/video/budget");
+  }
 };
 
 // src/tools/assemble.ts
@@ -1232,12 +1313,470 @@ ${JSON.stringify(result.memory, null, 2)}`
   );
 }
 
+// src/tools/cowork.ts
+import { z as z18 } from "zod";
+function registerCoworkTools(server2, client2) {
+  server2.registerTool(
+    "cowork_list_workspaces",
+    {
+      title: "List Workspaces",
+      description: "List all collaborative workspaces available to the user. Returns workspace IDs, names, and metadata.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await client2.listWorkspaces();
+        if (result.workspaces.length === 0) {
+          return {
+            content: [{ type: "text", text: "No workspaces found." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_create_workspace",
+    {
+      title: "Create Workspace",
+      description: "Create a new collaborative workspace. Workspaces hold files that Alma can read, write, and operate on.",
+      inputSchema: {
+        name: z18.string().min(1).max(200).describe("Name for the workspace"),
+        description: z18.string().max(1e3).optional().describe("Optional description of the workspace purpose"),
+        sourceType: z18.string().optional().describe('Source type for the workspace (e.g. "blank", "template", "import")')
+      }
+    },
+    async ({ name, description, sourceType }) => {
+      try {
+        const result = await client2.createWorkspace({ name, description, sourceType });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Workspace created successfully.
+${JSON.stringify(result.workspace, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_list_files",
+    {
+      title: "List Workspace Files",
+      description: "List all files in a collaborative workspace. Returns file paths, sizes, and metadata.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to list files from")
+      }
+    },
+    async ({ workspaceId }) => {
+      try {
+        const result = await client2.listWorkspaceFiles(workspaceId);
+        if (result.files.length === 0) {
+          return {
+            content: [{ type: "text", text: "No files found in this workspace." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_read_file",
+    {
+      title: "Read Workspace File",
+      description: "Read the content of a file in a collaborative workspace. Returns the file content and metadata.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID containing the file"),
+        filePath: z18.string().min(1).describe("Path of the file within the workspace")
+      }
+    },
+    async ({ workspaceId, filePath }) => {
+      try {
+        const result = await client2.readWorkspaceFile(workspaceId, filePath);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result.file, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_write_file",
+    {
+      title: "Write Workspace File",
+      description: "Write or update a file in a collaborative workspace. Creates the file if it does not exist.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to write the file in"),
+        filePath: z18.string().min(1).describe("Path of the file within the workspace"),
+        content: z18.string().describe("The content to write to the file")
+      }
+    },
+    async ({ workspaceId, filePath, content }) => {
+      try {
+        const result = await client2.writeWorkspaceFile(workspaceId, filePath, content);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File written successfully.
+${JSON.stringify(result.file, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_search",
+    {
+      title: "Search Workspace",
+      description: "Search across all files in a collaborative workspace. Returns matching files and content snippets.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to search in"),
+        query: z18.string().min(1).describe("Search query string")
+      }
+    },
+    async ({ workspaceId, query }) => {
+      try {
+        const result = await client2.searchWorkspace(workspaceId, query);
+        if (result.results.length === 0) {
+          return {
+            content: [{ type: "text", text: `No results found for: ${query}` }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_execute_skill",
+    {
+      title: "Execute Skill",
+      description: "Run an AI skill on a file or input within a collaborative workspace. Available skills: explain, refactor, review, test, fix, document, search, commit.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to execute the skill in"),
+        skill: z18.enum(["explain", "refactor", "review", "test", "fix", "document", "search", "commit"]).describe("The skill to execute"),
+        targetPath: z18.string().optional().describe("Optional file path to target with the skill"),
+        input: z18.string().min(1).describe("Input or instructions for the skill execution")
+      }
+    },
+    async ({ workspaceId, skill, targetPath, input }) => {
+      try {
+        const result = await client2.executeSkill(workspaceId, { skill, targetPath, input });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Skill "${skill}" executed successfully.
+${JSON.stringify(result.result, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_apply_diff",
+    {
+      title: "Apply Operation Diff",
+      description: "Apply a pending operation diff to a workspace file. Use after executing a skill that produces changes.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID containing the operation"),
+        operationId: z18.string().min(1).describe("The operation ID whose diff should be applied")
+      }
+    },
+    async ({ workspaceId, operationId }) => {
+      try {
+        const result = await client2.applyDiff(workspaceId, operationId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.applied ? `Diff applied successfully.
+${JSON.stringify(result.result, null, 2)}` : "Diff could not be applied. The operation may have already been applied or expired."
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/video.ts
+import { z as z19 } from "zod";
+function registerVideoTools(server2, client2) {
+  server2.registerTool(
+    "video_generate",
+    {
+      title: "Generate Video",
+      description: "Start an AI video generation job. Returns a job ID to track progress. Requires a paid plan with video credits.",
+      inputSchema: {
+        prompt: z19.string().min(1).max(2e3).describe("Text description of the video to generate"),
+        model: z19.string().min(1).describe('Video generation model to use (e.g. "runway-gen3", "kling-v1", "pika-v2")'),
+        durationSeconds: z19.number().int().min(1).max(60).describe("Duration of the video in seconds (1-60)"),
+        aspectRatio: z19.enum(["16:9", "9:16", "1:1", "4:3", "3:4"]).optional().describe("Aspect ratio of the video (default: 16:9)"),
+        style: z19.string().max(200).optional().describe('Optional style modifier (e.g. "cinematic", "anime", "documentary")')
+      }
+    },
+    async ({ prompt, model, durationSeconds, aspectRatio, style }) => {
+      try {
+        const result = await client2.generateVideo({ prompt, model, durationSeconds, aspectRatio, style });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video generation started.
+${JSON.stringify(result.job, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_check_job",
+    {
+      title: "Check Video Job",
+      description: "Check the status of a video generation job. Returns status, progress percentage, and result URL when complete.",
+      inputSchema: {
+        jobId: z19.string().min(1).describe("The video generation job ID to check")
+      }
+    },
+    async ({ jobId }) => {
+      try {
+        const result = await client2.checkVideoJob(jobId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result.job, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_list_projects",
+    {
+      title: "List Video Projects",
+      description: "List all video projects for the user. Projects organize multiple video scenes into a cohesive production.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await client2.listVideoProjects();
+        if (result.projects.length === 0) {
+          return {
+            content: [{ type: "text", text: "No video projects found." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_create_project",
+    {
+      title: "Create Video Project",
+      description: "Create a new video project. Projects let you plan scenes, generate clips, and stitch them into a final video.",
+      inputSchema: {
+        name: z19.string().min(1).max(200).describe("Name for the video project"),
+        description: z19.string().max(1e3).optional().describe("Optional description of the video project")
+      }
+    },
+    async ({ name, description }) => {
+      try {
+        const result = await client2.createVideoProject({ name, description });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video project created successfully.
+${JSON.stringify(result.project, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_plan_scenes",
+    {
+      title: "Plan Video Scenes",
+      description: "Use AI to plan scenes for a video project. Breaks a description into individual scene prompts with timing and transitions.",
+      inputSchema: {
+        projectId: z19.string().min(1).describe("The video project ID to plan scenes for"),
+        description: z19.string().min(1).max(5e3).describe("Description of the video to plan (story, concept, or script)"),
+        sceneCount: z19.number().int().min(1).max(20).optional().describe("Number of scenes to plan (default: auto-determined by AI)")
+      }
+    },
+    async ({ projectId, description, sceneCount }) => {
+      try {
+        const result = await client2.planVideoScenes(projectId, { description, sceneCount });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Scene plan created (${result.scenes.length} scenes).
+${JSON.stringify(result.scenes, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_stitch",
+    {
+      title: "Stitch Video",
+      description: "Stitch multiple generated video scenes into a single final video. All referenced jobs must be complete.",
+      inputSchema: {
+        projectId: z19.string().min(1).describe("The video project ID"),
+        jobIds: z19.array(z19.string().min(1)).min(1).max(20).describe("Ordered list of completed video job IDs to stitch together")
+      }
+    },
+    async ({ projectId, jobIds }) => {
+      try {
+        const result = await client2.stitchVideo(projectId, jobIds);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video stitch job started.
+${JSON.stringify(result.job, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/index.ts
 var config = loadConfig();
 var client = new AlmaClient(config);
 var server = new McpServer({
   name: "alma-mcp",
-  version: "1.3.0"
+  version: "1.3.2"
 });
 registerAssembleTool(server, client);
 registerRememberTool(server, client);
@@ -1260,6 +1799,8 @@ registerListProceduresTool(server, client);
 registerCreateProcedureTool(server, client);
 registerPreviewContextTool(server, client);
 registerUpdateMemoryTool(server, client);
+registerCoworkTools(server, client);
+registerVideoTools(server, client);
 server.registerResource(
   "soul",
   "alma://soul",
@@ -1400,6 +1941,34 @@ server.registerResource(
     }
   }
 );
+server.registerResource(
+  "video-budget",
+  "alma://video-budget",
+  {
+    title: "Video Budget",
+    description: "Current video generation credits, usage, and remaining quota",
+    mimeType: "application/json"
+  },
+  async (uri) => {
+    try {
+      const result = await client.getVideoBudget();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/plain", text: `Error loading resource: ${message}` }]
+      };
+    }
+  }
+);
 server.registerResource(
   "memories-by-category",
   new ResourceTemplate("alma://memories/{category}", {
@@ -1523,10 +2092,76 @@ server.registerResource(
     }
   }
 );
+server.prompt(
+  "alma-context",
+  "Assemble Alma's full context: soul identity, relevant memories, recent episodes, and procedures. Use this to give the AI persistent memory about the user.",
+  {},
+  async () => {
+    try {
+      const result = await client.assembleContext({ message: "general conversation" });
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `The following is your persistent memory and identity context from Alma. Use it to personalize your responses:
+
+${result.system_prompt}`
+            }
+          }
+        ]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `[Alma context unavailable: ${message}]`
+            }
+          }
+        ]
+      };
+    }
+  }
+);
+server.prompt(
+  "alma-recall",
+  "Search Alma's memory for information about a specific topic.",
+  { topic: { description: "The topic to recall memories about", required: true } },
+  async (args) => {
+    try {
+      const result = await client.searchMemories({ q: args.topic ?? "", limit: 10 });
+      const memoryText = result.memories.length > 0 ? result.memories.map((m) => `- ${m.content} (${m.category}, importance: ${m.importance})`).join("\n") : "No memories found for this topic.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Here is what Alma remembers about "${args.topic}":
+
+${memoryText}`
+            }
+          }
+        ]
+      };
+    } catch {
+      return {
+        messages: [
+          { role: "user", content: { type: "text", text: `[Could not recall memories for "${args.topic}"]` } }
+        ]
+      };
+    }
+  }
+);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("[alma-mcp] Server started on stdio (v1.3.0, 21 tools, 9 resources)");
+  console.error("[alma-mcp] Server started on stdio (v1.3.2, 35 tools, 10 resources, 2 prompts)");
   if (process.env.ALMA_DEBUG) {
     console.error(`[alma-mcp] API: ${config.baseUrl}`);
     if (config.environmentId) {

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "@olivaresai/alma-mcp",
-  "version": "1.3.1",
-  "description": "MCP Server for Alma — persistent memory for AI agents",
+  "version": "1.3.2",
+  "description": "MCP Server for Alma by OlivaresAI — persistent memory for AI agents",
   "type": "module",
   "bin": {
     "alma-mcp": "./dist/index.js"
   },
   "main": "dist/index.js",
-  "files": ["dist", "README.md", "LICENSE"],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": ["mcp", "alma", "ai", "memory", "persistent-memory", "ai-agent", "model-context-protocol", "claude", "cursor", "windsurf", "llm"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "alma",
+    "ai",
+    "memory",
+    "persistent-memory",
+    "ai-agent",
+    "model-context-protocol",
+    "claude",
+    "cursor",
+    "windsurf",
+    "llm"
+  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0",
     "zod": "^3.24.0"
@@ -35,5 +45,9 @@
   },
   "author": "OlivaresAI",
   "license": "SEE LICENSE IN LICENSE",
-  "pnpm": {}
-}
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}