@chamba/mcp 0.2.1 → 0.3.0

package/dist/main.js

@@ -74,28 +74,86 @@ function registerCleanupWorktree(server, logger, services) {
   );
 }
 
+// src/tools/cleanup-worktrees.ts
+import {
+  detectGitRepos,
+  joinPath,
+  loadConfig,
+  MultiRepoWorktreeManager,
+  planWorktrees,
+  WORKSPACE_DIR
+} from "@chamba/core";
+import { z as z2 } from "zod";
+var TOOL_NAME2 = "chamba_cleanup_worktrees";
+var DESCRIPTION2 = "Remove a ticket's git worktrees across its repos. Removes only the worktree directories (no --force), KEEPS every branch for you to review and merge by hand. Returns the suggested `git merge --no-ff` command per repo.";
+var CONFIG_FILE = `${WORKSPACE_DIR}/config.json`;
+async function resolveRepos(config, services, explicit) {
+  if (explicit && explicit.length > 0) return explicit;
+  if (config.repos && config.repos.length > 0) return config.repos;
+  return detectGitRepos(services.fs, services.cwd);
+}
+function registerCleanupWorktrees(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME2,
+    {
+      title: "Cleanup worktrees (multi-repo)",
+      description: DESCRIPTION2,
+      inputSchema: {
+        ticket: z2.string().describe("Ticket id whose worktrees to remove."),
+        repos: z2.array(z2.string()).optional().describe("Repos to clean; defaults like create.")
+      }
+    },
+    async ({ ticket, repos }) => {
+      const globalPath = joinPath(services.homedir, CONFIG_FILE);
+      const projectPath = joinPath(services.cwd, CONFIG_FILE);
+      const { worktrees } = await loadConfig(services.fs, { globalPath, projectPath });
+      const repoList = await resolveRepos(worktrees, services, repos);
+      const items = planWorktrees({
+        workspaceRoot: services.cwd,
+        ticket,
+        repos: repoList,
+        config: worktrees
+      });
+      const results = await new MultiRepoWorktreeManager(services.process, services.fs).cleanup(
+        items
+      );
+      logger.info({ tool: TOOL_NAME2, ticket, repos: results.length }, "cleanup-worktrees");
+      const removed = results.filter((r) => r.removed);
+      const lines = results.map(
+        (r) => `- ${r.repo}: ${r.removed ? "removed" : "not found"} \u2014 merge: ${r.mergeSuggestion}`
+      );
+      const text = `Cleaned ${removed.length}/${results.length} worktree(s) for ${ticket}. Branches kept.
+${lines.join("\n")}`;
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: { ticket, worktrees: results }
+      };
+    }
+  );
+}
+
 // 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";
+import { z as z3 } from "zod";
+var TOOL_NAME3 = "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.";
+var DESCRIPTION3 = "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,
+    TOOL_NAME3,
     {
       title: "Create worktree",
-      description: DESCRIPTION2,
+      description: DESCRIPTION3,
       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.")
+        taskSlug: z3.string().describe("Short task identifier (slugified for git)."),
+        workerId: z3.string().describe('Worker identifier, e.g. "implementer".'),
+        baseBranch: z3.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");
+        logger.info({ tool: TOOL_NAME3 }, "not a git repo");
         return { isError: true, content: [{ type: "text", text: NOT_GIT }] };
       }
       try {
@@ -106,7 +164,7 @@ function registerCreateWorktree(server, logger, services) {
           date: services.clock.today(),
           baseBranch
         });
-        logger.info({ tool: TOOL_NAME2, branch: handle.branch }, "worktree created");
+        logger.info({ tool: TOOL_NAME3, branch: handle.branch }, "worktree created");
         return {
           content: [
             { type: "text", text: `Created worktree at ${handle.path} on branch ${handle.branch}` }
@@ -115,33 +173,140 @@ function registerCreateWorktree(server, logger, services) {
         };
       } catch (err) {
         const message = err instanceof WorktreeError2 ? err.message : String(err);
-        logger.info({ tool: TOOL_NAME2, err: message }, "worktree create failed");
+        logger.info({ tool: TOOL_NAME3, err: message }, "worktree create failed");
         return { isError: true, content: [{ type: "text", text: message }] };
       }
     }
   );
 }
 
+// src/tools/create-worktrees.ts
+import {
+  buildTicketBranch,
+  detectGitRepos as detectGitRepos2,
+  editorWorkspaceDir,
+  joinPath as joinPath2,
+  loadConfig as loadConfig2,
+  MultiRepoWorktreeManager as MultiRepoWorktreeManager2,
+  planWorktrees as planWorktrees2,
+  WORKSPACE_DIR as WORKSPACE_DIR2,
+  writeEditorWorkspace
+} from "@chamba/core";
+import { z as z4 } from "zod";
+var TOOL_NAME4 = "chamba_create_worktrees";
+var DESCRIPTION4 = "Create git worktrees for a ticket across the repos it touches, driven by the `worktrees` block of .chamba/config.json (layout, branch prefix, base branch, env copy, editor workspace). Reuses an existing local/remote branch or forks a new one from the base. If `worktrees.command` is set, runs that command instead. Never merges, never pushes \u2014 branches are left open for you.";
+var CONFIG_FILE2 = `${WORKSPACE_DIR2}/config.json`;
+async function resolveRepos2(config, services, explicit) {
+  if (explicit && explicit.length > 0) return explicit;
+  if (config.repos && config.repos.length > 0) return config.repos;
+  return detectGitRepos2(services.fs, services.cwd);
+}
+function registerCreateWorktrees(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME4,
+    {
+      title: "Create worktrees (multi-repo)",
+      description: DESCRIPTION4,
+      inputSchema: {
+        ticket: z4.string().describe("Ticket id, e.g. TICKET-123."),
+        repos: z4.array(z4.string()).optional().describe(
+          "Repos to act on; defaults to config.worktrees.repos or autodetected git repos."
+        )
+      }
+    },
+    async ({ ticket, repos }) => {
+      const globalPath = joinPath2(services.homedir, CONFIG_FILE2);
+      const projectPath = joinPath2(services.cwd, CONFIG_FILE2);
+      const { worktrees } = await loadConfig2(services.fs, { globalPath, projectPath });
+      if (worktrees.command) {
+        const cmd = worktrees.command.replaceAll("{ticket}", ticket).replaceAll("{repos}", (repos ?? []).join(" "));
+        const result = await services.process.exec("sh", ["-c", cmd], { cwd: services.cwd });
+        logger.info(
+          { tool: TOOL_NAME4, usedCommand: true, exitCode: result.exitCode },
+          "create-worktrees (command)"
+        );
+        const text2 = `Ran worktree command (exit ${result.exitCode}).
+${result.stdout || result.stderr}`;
+        return {
+          content: [{ type: "text", text: text2 }],
+          structuredContent: {
+            ticket,
+            usedCommand: true,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr
+          }
+        };
+      }
+      const repoList = await resolveRepos2(worktrees, services, repos);
+      const branch = buildTicketBranch(worktrees.branchPrefix, ticket);
+      if (repoList.length === 0) {
+        const text2 = `No git repos found in ${services.cwd}. Set worktrees.repos in .chamba/config.json or pass repos.`;
+        return {
+          content: [{ type: "text", text: text2 }],
+          structuredContent: { ticket, branch, worktrees: [] }
+        };
+      }
+      const items = planWorktrees2({
+        workspaceRoot: services.cwd,
+        ticket,
+        repos: repoList,
+        config: worktrees
+      });
+      const results = await new MultiRepoWorktreeManager2(services.process, services.fs).create({
+        items,
+        baseBranch: worktrees.baseBranch,
+        copyEnvFiles: worktrees.copyEnvFiles,
+        envPruneDirs: worktrees.envPruneDirs
+      });
+      let workspaceFile;
+      if (worktrees.editorWorkspace) {
+        const dir = editorWorkspaceDir(worktrees, services.cwd, ticket);
+        workspaceFile = await writeEditorWorkspace(services.fs, dir, ticket, items);
+      }
+      logger.info({ tool: TOOL_NAME4, ticket, repos: results.length }, "create-worktrees");
+      const lines = results.map(
+        (r) => `- ${r.repo}: ${r.status} \u2192 ${r.worktreePath}${r.envCopied > 0 ? ` (${r.envCopied} env)` : ""}`
+      );
+      const text = `Worktrees for ${ticket} on branch ${branch} (${worktrees.layout} layout):
+${lines.join("\n")}${workspaceFile ? `
+Editor workspace: ${workspaceFile}` : ""}
+
+Branches are left open \u2014 review, commit and merge by hand.`;
+      return {
+        content: [{ type: "text", text }],
+        structuredContent: {
+          ticket,
+          branch,
+          layout: worktrees.layout,
+          workspaceFile,
+          worktrees: results
+        }
+      };
+    }
+  );
+}
+
 // 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.";
+import { z as z5 } from "zod";
+var TOOL_NAME5 = "chamba_generate_plan";
+var DESCRIPTION5 = "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,
+    TOOL_NAME5,
     {
       title: "Generate plan",
-      description: DESCRIPTION3,
+      description: DESCRIPTION5,
       inputSchema: {
-        task: z3.string().describe("What the plan should accomplish."),
-        context: z3.string().optional().describe("Context from chamba_load_context, if any.")
+        task: z5.string().describe("What the plan should accomplish."),
+        context: z5.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");
+      logger.info({ tool: TOOL_NAME5 }, "plan template generated");
       return { content: [{ type: "text", text: template }] };
     }
   );
@@ -152,36 +317,36 @@ import {
   AGENT_ROLES,
   buildHint,
   getModel,
-  joinPath,
-  loadConfig,
+  joinPath as joinPath3,
+  loadConfig as loadConfig3,
   resolveRole,
-  WORKSPACE_DIR
+  WORKSPACE_DIR as WORKSPACE_DIR3
 } from "@chamba/core";
-import { z as z4 } from "zod";
-var TOOL_NAME4 = "chamba_get_agent_config";
-var DESCRIPTION4 = "Return the configured model + effort hint for a given agent role (orchestrator, planner, reviewer, implementer, tester, summarizer, researcher). chamba does not call any model \u2014 this is guidance the editor's own model can use to decide how to delegate. Reads ~/.chamba/config.json and ./.chamba/config.json (project overrides global); falls back to built-in defaults.";
-var CONFIG_FILE = `${WORKSPACE_DIR}/config.json`;
+import { z as z6 } from "zod";
+var TOOL_NAME6 = "chamba_get_agent_config";
+var DESCRIPTION6 = "Return the configured model + effort hint for a given agent role (orchestrator, planner, reviewer, implementer, tester, summarizer, researcher). chamba does not call any model \u2014 this is guidance the editor's own model can use to decide how to delegate. Reads ~/.chamba/config.json and ./.chamba/config.json (project overrides global); falls back to built-in defaults.";
+var CONFIG_FILE3 = `${WORKSPACE_DIR3}/config.json`;
 function registerGetAgentConfig(server, logger, services) {
   server.registerTool(
-    TOOL_NAME4,
+    TOOL_NAME6,
     {
       title: "Get agent config",
-      description: DESCRIPTION4,
+      description: DESCRIPTION6,
       inputSchema: {
-        role: z4.enum([...AGENT_ROLES]).describe("The agent role to get a model + effort hint for.")
+        role: z6.enum([...AGENT_ROLES]).describe("The agent role to get a model + effort hint for.")
       }
     },
     async ({ role }) => {
-      const globalPath = joinPath(services.homedir, CONFIG_FILE);
-      const projectPath = joinPath(services.cwd, CONFIG_FILE);
-      const { config, sources } = await loadConfig(services.fs, { globalPath, projectPath });
+      const globalPath = joinPath3(services.homedir, CONFIG_FILE3);
+      const projectPath = joinPath3(services.cwd, CONFIG_FILE3);
+      const { config, sources } = await loadConfig3(services.fs, { globalPath, projectPath });
       const agent = resolveRole(config, role);
       const model = getModel(agent.model);
       const hint = buildHint(role, agent);
       const invalid = sources.find((s) => s.status === "invalid");
       const warning = invalid ? `Ignored invalid config at ${invalid.path}: ${invalid.error}. Using defaults.` : void 0;
       logger.info(
-        { tool: TOOL_NAME4, role, model: agent.model, effort: agent.effort },
+        { tool: TOOL_NAME6, role, model: agent.model, effort: agent.effort },
         "get-agent-config"
       );
       const structured = {
@@ -205,15 +370,15 @@ function registerGetAgentConfig(server, logger, services) {
 
 // src/tools/list-worktrees.ts
 import { WorktreeManager as WorktreeManager3 } from "@chamba/core";
-var TOOL_NAME5 = "chamba_list_worktrees";
-var DESCRIPTION5 = "List the git worktrees in the current repo (path, HEAD, branch).";
+var TOOL_NAME7 = "chamba_list_worktrees";
+var DESCRIPTION7 = "List the git worktrees in the current repo (path, HEAD, branch).";
 function registerListWorktrees(server, logger, services) {
   server.registerTool(
-    TOOL_NAME5,
-    { title: "List worktrees", description: DESCRIPTION5, inputSchema: {} },
+    TOOL_NAME7,
+    { title: "List worktrees", description: DESCRIPTION7, inputSchema: {} },
     async () => {
       const worktrees = await new WorktreeManager3(services.process).list(services.cwd);
-      logger.info({ tool: TOOL_NAME5, count: worktrees.length }, "listed worktrees");
+      logger.info({ tool: TOOL_NAME7, 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 }],
@@ -225,18 +390,18 @@ function registerListWorktrees(server, logger, services) {
 
 // src/tools/load-context.ts
 import { ContextBuilder, ObsidianDetector, WorkspaceScanner as WorkspaceScanner2 } from "@chamba/core";
-import { z as z5 } from "zod";
-var TOOL_NAME6 = "chamba_load_context";
-var DESCRIPTION6 = "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.";
+import { z as z7 } from "zod";
+var TOOL_NAME8 = "chamba_load_context";
+var DESCRIPTION8 = "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_NAME6,
+    TOOL_NAME8,
     {
       title: "Load context",
-      description: DESCRIPTION6,
+      description: DESCRIPTION8,
       inputSchema: {
-        task: z5.string().describe("The task you are about to work on."),
-        includeObsidian: z5.boolean().optional().describe("Search the Obsidian vault for relevant notes (default true).")
+        task: z7.string().describe("The task you are about to work on."),
+        includeObsidian: z7.boolean().optional().describe("Search the Obsidian vault for relevant notes (default true).")
       }
     },
     async ({ task, includeObsidian }) => {
@@ -251,7 +416,7 @@ function registerLoadContext(server, logger, services) {
       }
       const built = await new ContextBuilder(services.fs).build({ workspace, task, vaultPath });
       logger.info(
-        { tool: TOOL_NAME6, vault: vaultPath ?? null, notes: built.relevantNotes.length },
+        { tool: TOOL_NAME8, vault: vaultPath ?? null, notes: built.relevantNotes.length },
         "context built"
       );
       return { content: [{ type: "text", text: built.context }] };
@@ -261,23 +426,23 @@ function registerLoadContext(server, logger, services) {
 
 // src/tools/recall.ts
 import { FilesystemMemoryStore } from "@chamba/core";
-import { z as z6 } from "zod";
-var TOOL_NAME7 = "chamba_recall";
-var DESCRIPTION7 = "Search persisted memories (case-insensitive substring over key, tags and content) and return the matches with their paths and content.";
+import { z as z8 } from "zod";
+var TOOL_NAME9 = "chamba_recall";
+var DESCRIPTION9 = "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_NAME7,
+    TOOL_NAME9,
     {
       title: "Recall",
-      description: DESCRIPTION7,
+      description: DESCRIPTION9,
       inputSchema: {
-        query: z6.string().describe("Keywords to search for.")
+        query: z8.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_NAME7, query, matches: matches.length }, "recall");
+      logger.info({ tool: TOOL_NAME9, 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 {
@@ -297,25 +462,25 @@ ${m.content}`).join("\n\n");
 
 // src/tools/remember.ts
 import { FilesystemMemoryStore as FilesystemMemoryStore2 } from "@chamba/core";
-import { z as z7 } from "zod";
-var TOOL_NAME8 = "chamba_remember";
-var DESCRIPTION8 = "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.";
+import { z as z9 } from "zod";
+var TOOL_NAME10 = "chamba_remember";
+var DESCRIPTION10 = "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_NAME8,
+    TOOL_NAME10,
     {
       title: "Remember",
-      description: DESCRIPTION8,
+      description: DESCRIPTION10,
       inputSchema: {
-        key: z7.string().describe('Short identifier, e.g. "auth-decisions".'),
-        content: z7.string().describe("What to remember (markdown)."),
-        tags: z7.array(z7.string()).optional().describe("Optional tags for search.")
+        key: z9.string().describe('Short identifier, e.g. "auth-decisions".'),
+        content: z9.string().describe("What to remember (markdown)."),
+        tags: z9.array(z9.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_NAME8, key, path: memory.path }, "memory saved");
+      logger.info({ tool: TOOL_NAME10, key, path: memory.path }, "memory saved");
       return {
         content: [{ type: "text", text: `Saved memory '${key}' to ${memory.path}` }],
         structuredContent: { saved: true, path: memory.path }
@@ -326,38 +491,38 @@ function registerRemember(server, logger, services) {
 
 // src/tools/review-plan.ts
 import { Reviewer, WorkspaceScanner as WorkspaceScanner3 } from "@chamba/core";
-import { z as z8 } from "zod";
-var TOOL_NAME9 = "chamba_review_plan";
-var DESCRIPTION9 = "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 }.";
+import { z as z10 } from "zod";
+var TOOL_NAME11 = "chamba_review_plan";
+var DESCRIPTION11 = "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_NAME9,
+    TOOL_NAME11,
     {
       title: "Review plan",
-      description: DESCRIPTION9,
+      description: DESCRIPTION11,
       inputSchema: {
-        plan: z8.string().describe("The plan markdown to review."),
-        task: z8.string().describe("The task the plan is for."),
-        context: z8.string().optional().describe("Context from chamba_load_context, if any.")
+        plan: z10.string().describe("The plan markdown to review."),
+        task: z10.string().describe("The task the plan is for."),
+        context: z10.string().optional().describe("Context from chamba_load_context, if any.")
       },
       outputSchema: {
-        approved: z8.boolean(),
-        issues: z8.array(
-          z8.object({
-            code: z8.string(),
-            severity: z8.enum(["error", "warning"]),
-            message: z8.string()
+        approved: z10.boolean(),
+        issues: z10.array(
+          z10.object({
+            code: z10.string(),
+            severity: z10.enum(["error", "warning"]),
+            message: z10.string()
           })
         ),
-        suggestions: z8.array(z8.string()),
-        riskFlags: z8.array(z8.string())
+        suggestions: z10.array(z10.string()),
+        riskFlags: z10.array(z10.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_NAME9, approved: review.approved, issues: review.issues.length },
+        { tool: TOOL_NAME11, approved: review.approved, issues: review.issues.length },
         "plan reviewed"
       );
       const verdict = review.approved ? "\u2705 approved" : "\u274C changes requested";
@@ -382,20 +547,20 @@ ${review.suggestions.map((s) => `- ${s}`).join("\n")}` : ""
 
 // src/tools/summarize-to-vault.ts
 import { ObsidianDetector as ObsidianDetector2, VaultWriter } from "@chamba/core";
-import { z as z9 } from "zod";
-var TOOL_NAME10 = "chamba_summarize_to_vault";
+import { z as z11 } from "zod";
+var TOOL_NAME12 = "chamba_summarize_to_vault";
 var NO_VAULT_ERROR = "No Obsidian vault configured. Set CHAMBA_OBSIDIAN_VAULT_PATH or use the obsidian-mcp server";
-var DESCRIPTION10 = "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.";
+var DESCRIPTION12 = "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_NAME10,
+    TOOL_NAME12,
     {
       title: "Summarize to vault",
-      description: DESCRIPTION10,
+      description: DESCRIPTION12,
       inputSchema: {
-        title: z9.string().describe("Note title."),
-        content: z9.string().describe("Markdown body (summary, plan, decisions, next steps)."),
-        projectSlug: z9.string().optional().describe("Optional slug for the filename.")
+        title: z11.string().describe("Note title."),
+        content: z11.string().describe("Markdown body (summary, plan, decisions, next steps)."),
+        projectSlug: z11.string().optional().describe("Optional slug for the filename.")
       }
     },
     async ({ title, content, projectSlug }) => {
@@ -404,7 +569,7 @@ function registerSummarizeToVault(server, logger, services) {
         searchRoots: obsidianSearchRoots(services)
       });
       if (!detection.found || !detection.path) {
-        logger.info({ tool: TOOL_NAME10 }, "no vault configured");
+        logger.info({ tool: TOOL_NAME12 }, "no vault configured");
         return { isError: true, content: [{ type: "text", text: NO_VAULT_ERROR }] };
       }
       const writer = new VaultWriter(services.fs, services.clock);
@@ -414,7 +579,7 @@ function registerSummarizeToVault(server, logger, services) {
         content,
         projectSlug
       });
-      logger.info({ tool: TOOL_NAME10, notePath }, "note written to vault");
+      logger.info({ tool: TOOL_NAME12, notePath }, "note written to vault");
       return { content: [{ type: "text", text: `Wrote note to ${notePath}` }] };
     }
   );
@@ -422,31 +587,31 @@ function registerSummarizeToVault(server, logger, services) {
 
 // src/tools/workspace-init.ts
 import {
-  joinPath as joinPath2,
+  joinPath as joinPath4,
   renderWorkspaceMarkdown,
-  WORKSPACE_DIR as WORKSPACE_DIR2,
+  WORKSPACE_DIR as WORKSPACE_DIR4,
   WORKSPACE_RELATIVE_PATH,
   WorkspaceScanner as WorkspaceScanner4
 } from "@chamba/core";
-import { z as z10 } from "zod";
-var TOOL_NAME11 = "chamba_workspace_init";
-var DESCRIPTION11 = "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.";
+import { z as z12 } from "zod";
+var TOOL_NAME13 = "chamba_workspace_init";
+var DESCRIPTION13 = "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_NAME11,
+    TOOL_NAME13,
     {
       title: "Init workspace",
-      description: DESCRIPTION11,
+      description: DESCRIPTION13,
       inputSchema: {
-        root: z10.string().optional().describe("Workspace root to scan. Defaults to the directory chamba runs in.")
+        root: z12.string().optional().describe("Workspace root to scan. Defaults to the directory chamba runs in.")
       }
     },
     async ({ root }) => {
       const workspaceRoot = root ?? services.cwd;
-      const wsPath = joinPath2(workspaceRoot, WORKSPACE_RELATIVE_PATH);
+      const wsPath = joinPath4(workspaceRoot, WORKSPACE_RELATIVE_PATH);
       if (await services.fs.exists(wsPath)) {
         const currentContents = await services.fs.readFile(wsPath);
-        logger.info({ tool: TOOL_NAME11, wsPath }, "workspace.md already exists, not overwriting");
+        logger.info({ tool: TOOL_NAME13, wsPath }, "workspace.md already exists, not overwriting");
         return {
           content: [
             {
@@ -463,10 +628,10 @@ ${currentContents}`
       const scanner = new WorkspaceScanner4(services.fs);
       const workspace = await scanner.scan(workspaceRoot);
       const markdown = renderWorkspaceMarkdown(workspace);
-      await services.fs.mkdir(joinPath2(workspaceRoot, WORKSPACE_DIR2));
+      await services.fs.mkdir(joinPath4(workspaceRoot, WORKSPACE_DIR4));
       await services.fs.writeFile(wsPath, markdown);
       logger.info(
-        { tool: TOOL_NAME11, wsPath, projects: workspace.projects.length },
+        { tool: TOOL_NAME13, wsPath, projects: workspace.projects.length },
         "workspace.md created"
       );
       return {
@@ -486,26 +651,26 @@ ${markdown}`
 // src/tools/workspace-reload.ts
 import {
   diffLines,
-  joinPath as joinPath3,
+  joinPath as joinPath5,
   renderWorkspaceMarkdown as renderWorkspaceMarkdown2,
   textsEqual,
   WORKSPACE_RELATIVE_PATH as WORKSPACE_RELATIVE_PATH2,
   WorkspaceScanner as WorkspaceScanner5
 } from "@chamba/core";
-var TOOL_NAME12 = "chamba_workspace_reload";
-var DESCRIPTION12 = "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.";
+var TOOL_NAME14 = "chamba_workspace_reload";
+var DESCRIPTION14 = "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_NAME12,
+    TOOL_NAME14,
     {
       title: "Reload workspace",
-      description: DESCRIPTION12,
+      description: DESCRIPTION14,
       inputSchema: {}
     },
     async () => {
-      const wsPath = joinPath3(services.cwd, WORKSPACE_RELATIVE_PATH2);
+      const wsPath = joinPath5(services.cwd, WORKSPACE_RELATIVE_PATH2);
       if (!await services.fs.exists(wsPath)) {
-        logger.info({ tool: TOOL_NAME12, wsPath }, "no workspace.md to reload");
+        logger.info({ tool: TOOL_NAME14, wsPath }, "no workspace.md to reload");
         return {
           content: [
             {
@@ -519,7 +684,7 @@ function registerWorkspaceReload(server, logger, services) {
       const scanner = new WorkspaceScanner5(services.fs);
       const rescanned = renderWorkspaceMarkdown2(await scanner.scan(services.cwd));
       if (textsEqual(current, rescanned)) {
-        logger.info({ tool: TOOL_NAME12, wsPath }, "workspace.md up to date");
+        logger.info({ tool: TOOL_NAME14, wsPath }, "workspace.md up to date");
         return {
           content: [
             {
@@ -529,7 +694,7 @@ function registerWorkspaceReload(server, logger, services) {
           ]
         };
       }
-      logger.info({ tool: TOOL_NAME12, wsPath }, "workspace.md differs from re-scan");
+      logger.info({ tool: TOOL_NAME14, wsPath }, "workspace.md differs from re-scan");
       return {
         content: [
           {
@@ -547,25 +712,25 @@ ${diffLines(current, rescanned)}
 }
 
 // src/tools/workspace-show.ts
-import { joinPath as joinPath4, WORKSPACE_RELATIVE_PATH as WORKSPACE_RELATIVE_PATH3 } from "@chamba/core";
-var TOOL_NAME13 = "chamba_workspace_show";
-var DESCRIPTION13 = "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.";
+import { joinPath as joinPath6, WORKSPACE_RELATIVE_PATH as WORKSPACE_RELATIVE_PATH3 } from "@chamba/core";
+var TOOL_NAME15 = "chamba_workspace_show";
+var DESCRIPTION15 = "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_NAME13,
+    TOOL_NAME15,
     {
       title: "Show workspace",
-      description: DESCRIPTION13,
+      description: DESCRIPTION15,
       inputSchema: {}
     },
     async () => {
-      const path = joinPath4(services.cwd, WORKSPACE_RELATIVE_PATH3);
+      const path = joinPath6(services.cwd, WORKSPACE_RELATIVE_PATH3);
       try {
         const contents = await services.fs.readFile(path);
-        logger.info({ tool: TOOL_NAME13, path }, "workspace.md read");
+        logger.info({ tool: TOOL_NAME15, path }, "workspace.md read");
         return { content: [{ type: "text", text: contents }] };
       } catch {
-        logger.info({ tool: TOOL_NAME13, path }, "no workspace.md found");
+        logger.info({ tool: TOOL_NAME15, path }, "no workspace.md found");
         return {
           content: [
             {
@@ -594,6 +759,8 @@ function createServer(logger, services = createNodeServices()) {
   registerCreateWorktree(server, logger, services);
   registerListWorktrees(server, logger, services);
   registerCleanupWorktree(server, logger, services);
+  registerCreateWorktrees(server, logger, services);
+  registerCleanupWorktrees(server, logger, services);
   registerRemember(server, logger, services);
   registerRecall(server, logger, services);
   registerGetAgentConfig(server, logger, services);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chamba/mcp",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "chamba MCP server — orchestration, workspace, worktree and Obsidian tools for any MCP-capable editor",
   "license": "MIT",
   "type": "module",
@@ -36,8 +36,8 @@
     "@modelcontextprotocol/sdk": "^1.12.0",
     "pino": "^9.0.0",
     "zod": "^3.23.0",
-    "@chamba/adapters": "0.2.1",
-    "@chamba/core": "0.2.1"
+    "@chamba/adapters": "0.3.0",
+    "@chamba/core": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",