@chamba/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chamba contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,40 @@
+# @chamba/mcp
+
+The **chamba MCP server** — adds orchestration, workspace context, git worktrees and
+Obsidian memory to any MCP-capable editor (Cursor, Claude Code, VS Code/Copilot,
+Windsurf, Cline, OpenCode).
+
+**No API key.** chamba never calls an LLM — your editor's model does the reasoning
+and calls these tools.
+
+## Install (in your editor)
+
+**Cursor** — `.cursor/mcp.json`:
+
+```json
+{ "mcpServers": { "chamba": { "command": "npx", "args": ["-y", "@chamba/mcp"] } } }
+```
+
+**Claude Code**: `claude mcp add chamba -- npx -y @chamba/mcp`
+
+**VS Code** — `.vscode/mcp.json` (note: VS Code uses `"servers"`, not `"mcpServers"`):
+
+```json
+{ "servers": { "chamba": { "type": "stdio", "command": "npx", "args": ["-y", "@chamba/mcp"] } } }
+```
+
+Point at an Obsidian vault with `"env": { "CHAMBA_OBSIDIAN_VAULT_PATH": "/path/to/vault" }`.
+
+## Tools
+
+`chamba_workspace_init` · `chamba_workspace_show` · `chamba_workspace_reload` ·
+`chamba_load_context` · `chamba_summarize_to_vault` · `chamba_generate_plan` ·
+`chamba_review_plan` · `chamba_create_worktree` · `chamba_list_worktrees` ·
+`chamba_cleanup_worktree` · `chamba_remember` · `chamba_recall`
+
+Full docs, per-editor guides and examples:
+**https://github.com/thelord07/chamba**
+
+## License
+
+MIT

package/bin/chamba-mcp

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/main.js';

package/dist/main.js

@@ -0,0 +1,564 @@
+// src/main.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/logging.ts
+import { mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { destination, pino } from "pino";
+function createLogger() {
+  const logDir = join(homedir(), ".chamba", "logs");
+  mkdirSync(logDir, { recursive: true });
+  const logPath = join(logDir, `mcp-${process.pid}.log`);
+  return pino(
+    { level: process.env.CHAMBA_LOG_LEVEL ?? "info" },
+    destination({ dest: logPath, sync: false })
+  );
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/services.ts
+import { homedir as homedir2 } from "os";
+import { NodeFilesystem, NodeProcess, SystemClock } from "@chamba/adapters";
+function createNodeServices() {
+  return {
+    fs: new NodeFilesystem(),
+    process: new NodeProcess(),
+    clock: new SystemClock(),
+    cwd: process.cwd(),
+    homedir: homedir2(),
+    obsidianVaultPath: process.env.CHAMBA_OBSIDIAN_VAULT_PATH
+  };
+}
+function obsidianSearchRoots(services) {
+  const { homedir: home, cwd } = services;
+  return [cwd, `${home}/Documents`, `${home}/Notes`, `${home}/Obsidian`, `${home}/obsidian`, home];
+}
+
+// src/tools/cleanup-worktree.ts
+import { WorktreeError, WorktreeManager } from "@chamba/core";
+import { z } from "zod";
+var TOOL_NAME = "chamba_cleanup_worktree";
+var DESCRIPTION = "Remove a worktree directory while KEEPING its branch. Never deletes the branch and never merges \u2014 the branch stays for you to review and merge by hand. Runs `git worktree remove` without --force, so a dirty worktree fails loudly.";
+function registerCleanupWorktree(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME,
+    {
+      title: "Cleanup worktree",
+      description: DESCRIPTION,
+      inputSchema: {
+        branch: z.string().describe("Branch whose worktree directory should be removed.")
+      }
+    },
+    async ({ branch }) => {
+      try {
+        const result = await new WorktreeManager(services.process).cleanup(services.cwd, branch);
+        logger.info({ tool: TOOL_NAME, branch }, "worktree removed, branch kept");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Removed worktree for ${branch}. Branch kept. To merge: ${result.mergeSuggestion}`
+            }
+          ],
+          structuredContent: { ...result }
+        };
+      } catch (err) {
+        const message = err instanceof WorktreeError ? err.message : String(err);
+        logger.info({ tool: TOOL_NAME, branch, err: message }, "worktree cleanup failed");
+        return { isError: true, content: [{ type: "text", text: message }] };
+      }
+    }
+  );
+}
+
+// src/tools/create-worktree.ts
+import { GitDetector, WorktreeError as WorktreeError2, WorktreeManager as WorktreeManager2 } from "@chamba/core";
+import { z as z2 } from "zod";
+var TOOL_NAME2 = "chamba_create_worktree";
+var NOT_GIT = "Not a git repo, worktree skipped. Worker should use main cwd.";
+var DESCRIPTION2 = "Create an isolated git worktree for a task/worker under `.chamba/worktrees/<task>/<worker>/` on branch `chamba/<date>-<task>/<worker>`. If the directory is not a git repo, returns an error and the worker should use the main cwd instead.";
+function registerCreateWorktree(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME2,
+    {
+      title: "Create worktree",
+      description: DESCRIPTION2,
+      inputSchema: {
+        taskSlug: z2.string().describe("Short task identifier (slugified for git)."),
+        workerId: z2.string().describe('Worker identifier, e.g. "implementer".'),
+        baseBranch: z2.string().optional().describe("Branch to base the worktree on.")
+      }
+    },
+    async ({ taskSlug, workerId, baseBranch }) => {
+      const isGit = await new GitDetector(services.process).isGitRepo(services.cwd);
+      if (!isGit) {
+        logger.info({ tool: TOOL_NAME2 }, "not a git repo");
+        return { isError: true, content: [{ type: "text", text: NOT_GIT }] };
+      }
+      try {
+        const handle = await new WorktreeManager2(services.process).create({
+          root: services.cwd,
+          taskSlug,
+          workerId,
+          date: services.clock.today(),
+          baseBranch
+        });
+        logger.info({ tool: TOOL_NAME2, branch: handle.branch }, "worktree created");
+        return {
+          content: [
+            { type: "text", text: `Created worktree at ${handle.path} on branch ${handle.branch}` }
+          ],
+          structuredContent: { ...handle }
+        };
+      } catch (err) {
+        const message = err instanceof WorktreeError2 ? err.message : String(err);
+        logger.info({ tool: TOOL_NAME2, err: message }, "worktree create failed");
+        return { isError: true, content: [{ type: "text", text: message }] };
+      }
+    }
+  );
+}
+
+// src/tools/generate-plan.ts
+import { generatePlanTemplate, WorkspaceScanner } from "@chamba/core";
+import { z as z3 } from "zod";
+var TOOL_NAME3 = "chamba_generate_plan";
+var DESCRIPTION3 = "Generate a structured plan TEMPLATE (not a finished plan) for a task: goal, acceptance criteria, subtasks with suggested workers, risks, and files likely touched. The editor model fills the placeholders, then calls chamba_review_plan. No LLM is used here.";
+function registerGeneratePlan(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME3,
+    {
+      title: "Generate plan",
+      description: DESCRIPTION3,
+      inputSchema: {
+        task: z3.string().describe("What the plan should accomplish."),
+        context: z3.string().optional().describe("Context from chamba_load_context, if any.")
+      }
+    },
+    async ({ task, context }) => {
+      const workspace = await new WorkspaceScanner(services.fs).scan(services.cwd);
+      const template = generatePlanTemplate({ task, context, workspace });
+      logger.info({ tool: TOOL_NAME3 }, "plan template generated");
+      return { content: [{ type: "text", text: template }] };
+    }
+  );
+}
+
+// src/tools/list-worktrees.ts
+import { WorktreeManager as WorktreeManager3 } from "@chamba/core";
+var TOOL_NAME4 = "chamba_list_worktrees";
+var DESCRIPTION4 = "List the git worktrees in the current repo (path, HEAD, branch).";
+function registerListWorktrees(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME4,
+    { title: "List worktrees", description: DESCRIPTION4, inputSchema: {} },
+    async () => {
+      const worktrees = await new WorktreeManager3(services.process).list(services.cwd);
+      logger.info({ tool: TOOL_NAME4, count: worktrees.length }, "listed worktrees");
+      const text = worktrees.length === 0 ? "No worktrees found (or not a git repo)." : worktrees.map((w) => `- ${w.path}${w.branch ? ` [${w.branch}]` : ""}`).join("\n");
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: { worktrees }
+      };
+    }
+  );
+}
+
+// src/tools/load-context.ts
+import { ContextBuilder, ObsidianDetector, WorkspaceScanner as WorkspaceScanner2 } from "@chamba/core";
+import { z as z4 } from "zod";
+var TOOL_NAME5 = "chamba_load_context";
+var DESCRIPTION5 = "Load context for a task: a summary of the workspace plus, when an Obsidian vault is available, the notes most relevant to the task (keyword search). Returns a markdown block the model can reason over before planning.";
+function registerLoadContext(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME5,
+    {
+      title: "Load context",
+      description: DESCRIPTION5,
+      inputSchema: {
+        task: z4.string().describe("The task you are about to work on."),
+        includeObsidian: z4.boolean().optional().describe("Search the Obsidian vault for relevant notes (default true).")
+      }
+    },
+    async ({ task, includeObsidian }) => {
+      const workspace = await new WorkspaceScanner2(services.fs).scan(services.cwd);
+      let vaultPath;
+      if (includeObsidian !== false) {
+        const detection = await new ObsidianDetector(services.fs).detect({
+          explicitPath: services.obsidianVaultPath,
+          searchRoots: obsidianSearchRoots(services)
+        });
+        if (detection.found) vaultPath = detection.path;
+      }
+      const built = await new ContextBuilder(services.fs).build({ workspace, task, vaultPath });
+      logger.info(
+        { tool: TOOL_NAME5, vault: vaultPath ?? null, notes: built.relevantNotes.length },
+        "context built"
+      );
+      return { content: [{ type: "text", text: built.context }] };
+    }
+  );
+}
+
+// src/tools/recall.ts
+import { FilesystemMemoryStore } from "@chamba/core";
+import { z as z5 } from "zod";
+var TOOL_NAME6 = "chamba_recall";
+var DESCRIPTION6 = "Search persisted memories (case-insensitive substring over key, tags and content) and return the matches with their paths and content.";
+function registerRecall(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME6,
+    {
+      title: "Recall",
+      description: DESCRIPTION6,
+      inputSchema: {
+        query: z5.string().describe("Keywords to search for.")
+      }
+    },
+    async ({ query }) => {
+      const store = new FilesystemMemoryStore(services.fs, services.clock, services.cwd);
+      const matches = await store.recall(query);
+      logger.info({ tool: TOOL_NAME6, query, matches: matches.length }, "recall");
+      const text = matches.length === 0 ? `No memories matched "${query}".` : matches.map((m) => `### ${m.key} (\`${m.path}\`)
+${m.content}`).join("\n\n");
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: {
+          matches: matches.map((m) => ({
+            key: m.key,
+            path: m.path,
+            tags: m.tags,
+            content: m.content
+          }))
+        }
+      };
+    }
+  );
+}
+
+// src/tools/remember.ts
+import { FilesystemMemoryStore as FilesystemMemoryStore2 } from "@chamba/core";
+import { z as z6 } from "zod";
+var TOOL_NAME7 = "chamba_remember";
+var DESCRIPTION7 = "Persist a piece of knowledge across sessions as an editable markdown file under `.chamba/memory/<key>.md`. Re-remembering an existing key appends a timestamped section instead of overwriting.";
+function registerRemember(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME7,
+    {
+      title: "Remember",
+      description: DESCRIPTION7,
+      inputSchema: {
+        key: z6.string().describe('Short identifier, e.g. "auth-decisions".'),
+        content: z6.string().describe("What to remember (markdown)."),
+        tags: z6.array(z6.string()).optional().describe("Optional tags for search.")
+      }
+    },
+    async ({ key, content, tags }) => {
+      const store = new FilesystemMemoryStore2(services.fs, services.clock, services.cwd);
+      const memory = await store.remember({ key, content, tags });
+      logger.info({ tool: TOOL_NAME7, key, path: memory.path }, "memory saved");
+      return {
+        content: [{ type: "text", text: `Saved memory '${key}' to ${memory.path}` }],
+        structuredContent: { saved: true, path: memory.path }
+      };
+    }
+  );
+}
+
+// src/tools/review-plan.ts
+import { Reviewer, WorkspaceScanner as WorkspaceScanner3 } from "@chamba/core";
+import { z as z7 } from "zod";
+var TOOL_NAME8 = "chamba_review_plan";
+var DESCRIPTION8 = "Review a plan with programmatic heuristics (NO LLM): checks for acceptance criteria, tests, subtasks with assigned workers, concrete descriptions, files outside the workspace, and risk assessment for sensitive areas. Returns { approved, issues, suggestions, riskFlags }.";
+function registerReviewPlan(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME8,
+    {
+      title: "Review plan",
+      description: DESCRIPTION8,
+      inputSchema: {
+        plan: z7.string().describe("The plan markdown to review."),
+        task: z7.string().describe("The task the plan is for."),
+        context: z7.string().optional().describe("Context from chamba_load_context, if any.")
+      },
+      outputSchema: {
+        approved: z7.boolean(),
+        issues: z7.array(
+          z7.object({
+            code: z7.string(),
+            severity: z7.enum(["error", "warning"]),
+            message: z7.string()
+          })
+        ),
+        suggestions: z7.array(z7.string()),
+        riskFlags: z7.array(z7.string())
+      }
+    },
+    async ({ plan, task, context }) => {
+      const workspace = await new WorkspaceScanner3(services.fs).scan(services.cwd);
+      const review = new Reviewer().review({ plan, task, context, workspace });
+      logger.info(
+        { tool: TOOL_NAME8, approved: review.approved, issues: review.issues.length },
+        "plan reviewed"
+      );
+      const verdict = review.approved ? "\u2705 approved" : "\u274C changes requested";
+      const errorLines = review.issues.map((i) => `- [${i.severity}] ${i.code}: ${i.message}`);
+      const summary = [
+        `Plan review: ${verdict}`,
+        review.issues.length > 0 ? `
+Issues:
+${errorLines.join("\n")}` : "",
+        review.riskFlags.length > 0 ? `
+Risk flags:
+${review.riskFlags.map((r) => `- ${r}`).join("\n")}` : "",
+        review.suggestions.length > 0 ? `
+Suggestions:
+${review.suggestions.map((s) => `- ${s}`).join("\n")}` : ""
+      ].filter((s) => s.length > 0).join("\n");
+      const structuredContent = review;
+      return { content: [{ type: "text", text: summary }], structuredContent };
+    }
+  );
+}
+
+// src/tools/summarize-to-vault.ts
+import { ObsidianDetector as ObsidianDetector2, VaultWriter } from "@chamba/core";
+import { z as z8 } from "zod";
+var TOOL_NAME9 = "chamba_summarize_to_vault";
+var NO_VAULT_ERROR = "No Obsidian vault configured. Set CHAMBA_OBSIDIAN_VAULT_PATH or use the obsidian-mcp server";
+var DESCRIPTION9 = "Write a structured summary note to the Obsidian vault under `proyectos/<date>-<slug>.md` with valid YAML frontmatter. Fails clearly if no vault is configured.";
+function registerSummarizeToVault(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME9,
+    {
+      title: "Summarize to vault",
+      description: DESCRIPTION9,
+      inputSchema: {
+        title: z8.string().describe("Note title."),
+        content: z8.string().describe("Markdown body (summary, plan, decisions, next steps)."),
+        projectSlug: z8.string().optional().describe("Optional slug for the filename.")
+      }
+    },
+    async ({ title, content, projectSlug }) => {
+      const detection = await new ObsidianDetector2(services.fs).detect({
+        explicitPath: services.obsidianVaultPath,
+        searchRoots: obsidianSearchRoots(services)
+      });
+      if (!detection.found || !detection.path) {
+        logger.info({ tool: TOOL_NAME9 }, "no vault configured");
+        return { isError: true, content: [{ type: "text", text: NO_VAULT_ERROR }] };
+      }
+      const writer = new VaultWriter(services.fs, services.clock);
+      const { notePath } = await writer.write({
+        vaultPath: detection.path,
+        title,
+        content,
+        projectSlug
+      });
+      logger.info({ tool: TOOL_NAME9, notePath }, "note written to vault");
+      return { content: [{ type: "text", text: `Wrote note to ${notePath}` }] };
+    }
+  );
+}
+
+// src/tools/workspace-init.ts
+import {
+  joinPath,
+  renderWorkspaceMarkdown,
+  WORKSPACE_DIR,
+  WORKSPACE_RELATIVE_PATH,
+  WorkspaceScanner as WorkspaceScanner4
+} from "@chamba/core";
+import { z as z9 } from "zod";
+var TOOL_NAME10 = "chamba_workspace_init";
+var DESCRIPTION10 = "Scan the workspace and generate `.chamba/workspace.md` (description, languages, framework, conventions, active projects, folder map). Respects .gitignore/.dockerignore and never reads node_modules or binaries. If the file already exists it is NOT overwritten \u2014 its current contents are returned so the model/user decides what to do.";
+function registerWorkspaceInit(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME10,
+    {
+      title: "Init workspace",
+      description: DESCRIPTION10,
+      inputSchema: {
+        root: z9.string().optional().describe("Workspace root to scan. Defaults to the directory chamba runs in.")
+      }
+    },
+    async ({ root }) => {
+      const workspaceRoot = root ?? services.cwd;
+      const wsPath = joinPath(workspaceRoot, WORKSPACE_RELATIVE_PATH);
+      if (await services.fs.exists(wsPath)) {
+        const currentContents = await services.fs.readFile(wsPath);
+        logger.info({ tool: TOOL_NAME10, wsPath }, "workspace.md already exists, not overwriting");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\`${WORKSPACE_RELATIVE_PATH}\` already exists at ${wsPath}; not overwriting.
+
+Current contents:
+
+${currentContents}`
+            }
+          ]
+        };
+      }
+      const scanner = new WorkspaceScanner4(services.fs);
+      const workspace = await scanner.scan(workspaceRoot);
+      const markdown = renderWorkspaceMarkdown(workspace);
+      await services.fs.mkdir(joinPath(workspaceRoot, WORKSPACE_DIR));
+      await services.fs.writeFile(wsPath, markdown);
+      logger.info(
+        { tool: TOOL_NAME10, wsPath, projects: workspace.projects.length },
+        "workspace.md created"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Created \`${WORKSPACE_RELATIVE_PATH}\` at ${wsPath}.
+
+${markdown}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/workspace-reload.ts
+import {
+  diffLines,
+  joinPath as joinPath2,
+  renderWorkspaceMarkdown as renderWorkspaceMarkdown2,
+  textsEqual,
+  WORKSPACE_RELATIVE_PATH as WORKSPACE_RELATIVE_PATH2,
+  WorkspaceScanner as WorkspaceScanner5
+} from "@chamba/core";
+var TOOL_NAME11 = "chamba_workspace_reload";
+var DESCRIPTION11 = "Re-scan the workspace and return a diff against the current `.chamba/workspace.md`. NEVER overwrites the file \u2014 the user may have hand-edited it. The model decides whether to apply changes.";
+function registerWorkspaceReload(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME11,
+    {
+      title: "Reload workspace",
+      description: DESCRIPTION11,
+      inputSchema: {}
+    },
+    async () => {
+      const wsPath = joinPath2(services.cwd, WORKSPACE_RELATIVE_PATH2);
+      if (!await services.fs.exists(wsPath)) {
+        logger.info({ tool: TOOL_NAME11, wsPath }, "no workspace.md to reload");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No \`${WORKSPACE_RELATIVE_PATH2}\` found at ${wsPath}. Run chamba_workspace_init first.`
+            }
+          ]
+        };
+      }
+      const current = await services.fs.readFile(wsPath);
+      const scanner = new WorkspaceScanner5(services.fs);
+      const rescanned = renderWorkspaceMarkdown2(await scanner.scan(services.cwd));
+      if (textsEqual(current, rescanned)) {
+        logger.info({ tool: TOOL_NAME11, wsPath }, "workspace.md up to date");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\`${WORKSPACE_RELATIVE_PATH2}\` is up to date \u2014 no changes from a re-scan.`
+            }
+          ]
+        };
+      }
+      logger.info({ tool: TOOL_NAME11, wsPath }, "workspace.md differs from re-scan");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Re-scan differs from \`${WORKSPACE_RELATIVE_PATH2}\` (NOT applied \u2014 your edits are kept). Diff (\`-\` current, \`+\` re-scan):
+
+\`\`\`diff
+${diffLines(current, rescanned)}
+\`\`\``
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/workspace-show.ts
+import { joinPath as joinPath3, WORKSPACE_RELATIVE_PATH as WORKSPACE_RELATIVE_PATH3 } from "@chamba/core";
+var TOOL_NAME12 = "chamba_workspace_show";
+var DESCRIPTION12 = "Show the current workspace map. Reads `.chamba/workspace.md` from the workspace root and returns its contents. If no workspace file exists yet, says so \u2014 the model can then run chamba_workspace_init to create one.";
+function registerWorkspaceShow(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME12,
+    {
+      title: "Show workspace",
+      description: DESCRIPTION12,
+      inputSchema: {}
+    },
+    async () => {
+      const path = joinPath3(services.cwd, WORKSPACE_RELATIVE_PATH3);
+      try {
+        const contents = await services.fs.readFile(path);
+        logger.info({ tool: TOOL_NAME12, path }, "workspace.md read");
+        return { content: [{ type: "text", text: contents }] };
+      } catch {
+        logger.info({ tool: TOOL_NAME12, path }, "no workspace.md found");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No \`${WORKSPACE_RELATIVE_PATH3}\` found at ${path}. Run chamba_workspace_init to create one.`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/server.ts
+var SERVER_NAME = "chamba";
+var SERVER_VERSION = "0.0.0";
+function createServer(logger, services = createNodeServices()) {
+  const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION });
+  registerWorkspaceShow(server, logger, services);
+  registerWorkspaceInit(server, logger, services);
+  registerWorkspaceReload(server, logger, services);
+  registerLoadContext(server, logger, services);
+  registerSummarizeToVault(server, logger, services);
+  registerGeneratePlan(server, logger, services);
+  registerReviewPlan(server, logger, services);
+  registerCreateWorktree(server, logger, services);
+  registerListWorktrees(server, logger, services);
+  registerCleanupWorktree(server, logger, services);
+  registerRemember(server, logger, services);
+  registerRecall(server, logger, services);
+  return server;
+}
+
+// src/main.ts
+async function main() {
+  const logger = createLogger();
+  const server = createServer(logger);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("chamba MCP server connected over stdio");
+  const shutdown = (signal) => {
+    logger.info({ signal }, "shutting down");
+    void server.close().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+main().catch((err) => {
+  process.stderr.write(`chamba-mcp fatal: ${err.message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@chamba/mcp",
+  "version": "0.1.0",
+  "description": "chamba MCP server — orchestration, workspace, worktree and Obsidian tools for any MCP-capable editor",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/main.js",
+  "bin": {
+    "chamba-mcp": "./bin/chamba-mcp"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thelord07/chamba.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/thelord07/chamba#readme",
+  "bugs": {
+    "url": "https://github.com/thelord07/chamba/issues"
+  },
+  "keywords": [
+    "chamba",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "cursor",
+    "claude-code",
+    "obsidian",
+    "git-worktree",
+    "orchestrator"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "pino": "^9.0.0",
+    "zod": "^3.23.0",
+    "@chamba/core": "0.1.0",
+    "@chamba/adapters": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/main.ts --format esm --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}