@chamba/mcp 0.1.0 → 0.2.0

package/dist/main.js

@@ -147,17 +147,73 @@ function registerGeneratePlan(server, logger, services) {
   );
 }
 
+// src/tools/get-agent-config.ts
+import {
+  AGENT_ROLES,
+  buildHint,
+  getModel,
+  joinPath,
+  loadConfig,
+  resolveRole,
+  WORKSPACE_DIR
+} 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`;
+function registerGetAgentConfig(server, logger, services) {
+  server.registerTool(
+    TOOL_NAME4,
+    {
+      title: "Get agent config",
+      description: DESCRIPTION4,
+      inputSchema: {
+        role: z4.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 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 },
+        "get-agent-config"
+      );
+      const structured = {
+        role,
+        model: agent.model,
+        effort: agent.effort,
+        reasoning_priority: agent.reasoning_priority,
+        provider: model?.provider ?? "unknown",
+        hint,
+        ...warning ? { warning } : {}
+      };
+      return {
+        content: [{ type: "text", text: warning ? `${hint}
+
+\u26A0\uFE0F ${warning}` : hint }],
+        structuredContent: structured
+      };
+    }
+  );
+}
+
 // 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).";
+var TOOL_NAME5 = "chamba_list_worktrees";
+var DESCRIPTION5 = "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: {} },
+    TOOL_NAME5,
+    { title: "List worktrees", description: DESCRIPTION5, inputSchema: {} },
     async () => {
       const worktrees = await new WorktreeManager3(services.process).list(services.cwd);
-      logger.info({ tool: TOOL_NAME4, count: worktrees.length }, "listed worktrees");
+      logger.info({ tool: TOOL_NAME5, 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 }],
@@ -169,18 +225,18 @@ function registerListWorktrees(server, logger, services) {
 
 // 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.";
+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.";
 function registerLoadContext(server, logger, services) {
   server.registerTool(
-    TOOL_NAME5,
+    TOOL_NAME6,
     {
       title: "Load context",
-      description: DESCRIPTION5,
+      description: DESCRIPTION6,
       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).")
+        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).")
       }
     },
     async ({ task, includeObsidian }) => {
@@ -195,7 +251,7 @@ function registerLoadContext(server, logger, services) {
       }
       const built = await new ContextBuilder(services.fs).build({ workspace, task, vaultPath });
       logger.info(
-        { tool: TOOL_NAME5, vault: vaultPath ?? null, notes: built.relevantNotes.length },
+        { tool: TOOL_NAME6, vault: vaultPath ?? null, notes: built.relevantNotes.length },
         "context built"
       );
       return { content: [{ type: "text", text: built.context }] };
@@ -205,23 +261,23 @@ function registerLoadContext(server, logger, services) {
 
 // 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.";
+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.";
 function registerRecall(server, logger, services) {
   server.registerTool(
-    TOOL_NAME6,
+    TOOL_NAME7,
     {
       title: "Recall",
-      description: DESCRIPTION6,
+      description: DESCRIPTION7,
       inputSchema: {
-        query: z5.string().describe("Keywords to search for.")
+        query: z6.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");
+      logger.info({ tool: TOOL_NAME7, 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 {
@@ -241,25 +297,25 @@ ${m.content}`).join("\n\n");
 
 // 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.";
+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.";
 function registerRemember(server, logger, services) {
   server.registerTool(
-    TOOL_NAME7,
+    TOOL_NAME8,
     {
       title: "Remember",
-      description: DESCRIPTION7,
+      description: DESCRIPTION8,
       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.")
+        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.")
       }
     },
     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");
+      logger.info({ tool: TOOL_NAME8, key, path: memory.path }, "memory saved");
       return {
         content: [{ type: "text", text: `Saved memory '${key}' to ${memory.path}` }],
         structuredContent: { saved: true, path: memory.path }
@@ -270,38 +326,38 @@ function registerRemember(server, logger, services) {
 
 // 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 }.";
+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 }.";
 function registerReviewPlan(server, logger, services) {
   server.registerTool(
-    TOOL_NAME8,
+    TOOL_NAME9,
     {
       title: "Review plan",
-      description: DESCRIPTION8,
+      description: DESCRIPTION9,
       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.")
+        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.")
       },
       outputSchema: {
-        approved: z7.boolean(),
-        issues: z7.array(
-          z7.object({
-            code: z7.string(),
-            severity: z7.enum(["error", "warning"]),
-            message: z7.string()
+        approved: z8.boolean(),
+        issues: z8.array(
+          z8.object({
+            code: z8.string(),
+            severity: z8.enum(["error", "warning"]),
+            message: z8.string()
           })
         ),
-        suggestions: z7.array(z7.string()),
-        riskFlags: z7.array(z7.string())
+        suggestions: z8.array(z8.string()),
+        riskFlags: z8.array(z8.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 },
+        { tool: TOOL_NAME9, approved: review.approved, issues: review.issues.length },
         "plan reviewed"
       );
       const verdict = review.approved ? "\u2705 approved" : "\u274C changes requested";
@@ -326,20 +382,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 z8 } from "zod";
-var TOOL_NAME9 = "chamba_summarize_to_vault";
+import { z as z9 } from "zod";
+var TOOL_NAME10 = "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.";
+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.";
 function registerSummarizeToVault(server, logger, services) {
   server.registerTool(
-    TOOL_NAME9,
+    TOOL_NAME10,
     {
       title: "Summarize to vault",
-      description: DESCRIPTION9,
+      description: DESCRIPTION10,
       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.")
+        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.")
       }
     },
     async ({ title, content, projectSlug }) => {
@@ -348,7 +404,7 @@ function registerSummarizeToVault(server, logger, services) {
         searchRoots: obsidianSearchRoots(services)
       });
       if (!detection.found || !detection.path) {
-        logger.info({ tool: TOOL_NAME9 }, "no vault configured");
+        logger.info({ tool: TOOL_NAME10 }, "no vault configured");
         return { isError: true, content: [{ type: "text", text: NO_VAULT_ERROR }] };
       }
       const writer = new VaultWriter(services.fs, services.clock);
@@ -358,7 +414,7 @@ function registerSummarizeToVault(server, logger, services) {
         content,
         projectSlug
       });
-      logger.info({ tool: TOOL_NAME9, notePath }, "note written to vault");
+      logger.info({ tool: TOOL_NAME10, notePath }, "note written to vault");
       return { content: [{ type: "text", text: `Wrote note to ${notePath}` }] };
     }
   );
@@ -366,31 +422,31 @@ function registerSummarizeToVault(server, logger, services) {
 
 // src/tools/workspace-init.ts
 import {
-  joinPath,
+  joinPath as joinPath2,
   renderWorkspaceMarkdown,
-  WORKSPACE_DIR,
+  WORKSPACE_DIR as WORKSPACE_DIR2,
   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.";
+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.";
 function registerWorkspaceInit(server, logger, services) {
   server.registerTool(
-    TOOL_NAME10,
+    TOOL_NAME11,
     {
       title: "Init workspace",
-      description: DESCRIPTION10,
+      description: DESCRIPTION11,
       inputSchema: {
-        root: z9.string().optional().describe("Workspace root to scan. Defaults to the directory chamba runs in.")
+        root: z10.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);
+      const wsPath = joinPath2(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");
+        logger.info({ tool: TOOL_NAME11, wsPath }, "workspace.md already exists, not overwriting");
         return {
           content: [
             {
@@ -407,10 +463,10 @@ ${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.mkdir(joinPath2(workspaceRoot, WORKSPACE_DIR2));
       await services.fs.writeFile(wsPath, markdown);
       logger.info(
-        { tool: TOOL_NAME10, wsPath, projects: workspace.projects.length },
+        { tool: TOOL_NAME11, wsPath, projects: workspace.projects.length },
         "workspace.md created"
       );
       return {
@@ -430,26 +486,26 @@ ${markdown}`
 // src/tools/workspace-reload.ts
 import {
   diffLines,
-  joinPath as joinPath2,
+  joinPath as joinPath3,
   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.";
+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.";
 function registerWorkspaceReload(server, logger, services) {
   server.registerTool(
-    TOOL_NAME11,
+    TOOL_NAME12,
     {
       title: "Reload workspace",
-      description: DESCRIPTION11,
+      description: DESCRIPTION12,
       inputSchema: {}
     },
     async () => {
-      const wsPath = joinPath2(services.cwd, WORKSPACE_RELATIVE_PATH2);
+      const wsPath = joinPath3(services.cwd, WORKSPACE_RELATIVE_PATH2);
       if (!await services.fs.exists(wsPath)) {
-        logger.info({ tool: TOOL_NAME11, wsPath }, "no workspace.md to reload");
+        logger.info({ tool: TOOL_NAME12, wsPath }, "no workspace.md to reload");
         return {
           content: [
             {
@@ -463,7 +519,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_NAME11, wsPath }, "workspace.md up to date");
+        logger.info({ tool: TOOL_NAME12, wsPath }, "workspace.md up to date");
         return {
           content: [
             {
@@ -473,7 +529,7 @@ function registerWorkspaceReload(server, logger, services) {
           ]
         };
       }
-      logger.info({ tool: TOOL_NAME11, wsPath }, "workspace.md differs from re-scan");
+      logger.info({ tool: TOOL_NAME12, wsPath }, "workspace.md differs from re-scan");
       return {
         content: [
           {
@@ -491,25 +547,25 @@ ${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.";
+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.";
 function registerWorkspaceShow(server, logger, services) {
   server.registerTool(
-    TOOL_NAME12,
+    TOOL_NAME13,
     {
       title: "Show workspace",
-      description: DESCRIPTION12,
+      description: DESCRIPTION13,
       inputSchema: {}
     },
     async () => {
-      const path = joinPath3(services.cwd, WORKSPACE_RELATIVE_PATH3);
+      const path = joinPath4(services.cwd, WORKSPACE_RELATIVE_PATH3);
       try {
         const contents = await services.fs.readFile(path);
-        logger.info({ tool: TOOL_NAME12, path }, "workspace.md read");
+        logger.info({ tool: TOOL_NAME13, path }, "workspace.md read");
         return { content: [{ type: "text", text: contents }] };
       } catch {
-        logger.info({ tool: TOOL_NAME12, path }, "no workspace.md found");
+        logger.info({ tool: TOOL_NAME13, path }, "no workspace.md found");
         return {
           content: [
             {
@@ -540,6 +596,7 @@ function createServer(logger, services = createNodeServices()) {
   registerCleanupWorktree(server, logger, services);
   registerRemember(server, logger, services);
   registerRecall(server, logger, services);
+  registerGetAgentConfig(server, logger, services);
   return server;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chamba/mcp",
-  "version": "0.1.0",
+  "version": "0.2.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/core": "0.1.0",
-    "@chamba/adapters": "0.1.0"
+    "@chamba/adapters": "0.2.0",
+    "@chamba/core": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",