mrvn-cli 0.2.0 → 0.2.1

package/dist/marvin.js

@@ -18458,6 +18458,213 @@ function createSkillActionTools(skills, context) {
   return tools;
 }
 
+// src/mcp/persona-context.ts
+var PersonaContextManager = class {
+  activePersona = null;
+  setPersona(idOrShortName) {
+    const persona = getPersona(idOrShortName);
+    if (persona) {
+      this.activePersona = persona;
+    }
+    return persona;
+  }
+  getActivePersona() {
+    return this.activePersona;
+  }
+  clearPersona() {
+    this.activePersona = null;
+  }
+  isDocumentTypeAllowed(docType) {
+    if (!this.activePersona) return true;
+    return this.activePersona.documentTypes.includes(docType);
+  }
+};
+function buildMcpGuidance(persona, marvinDir) {
+  const parts = [];
+  parts.push(`# Active Persona: ${persona.name} (${persona.shortName})`);
+  parts.push(`
+${persona.description}`);
+  parts.push(`
+## Focus Areas`);
+  for (const area of persona.focusAreas) {
+    parts.push(`- ${area}`);
+  }
+  parts.push(`
+## Allowed Document Types`);
+  parts.push(persona.documentTypes.join(", "));
+  parts.push(`
+## Behavioral Instructions`);
+  parts.push(persona.systemPrompt);
+  try {
+    const config2 = loadProjectConfig(marvinDir);
+    const plugin = resolvePlugin(config2.methodology);
+    if (plugin) {
+      const fragment = getPluginPromptFragment(plugin, persona.id);
+      if (fragment) {
+        parts.push(`
+## Plugin Rules`);
+        parts.push(fragment);
+      }
+    }
+    const allSkills = loadAllSkills(marvinDir);
+    const skillIds = resolveSkillsForPersona(
+      persona.id,
+      config2.skills,
+      allSkills
+    );
+    if (skillIds.length > 0) {
+      const fragment = getSkillPromptFragment(skillIds, allSkills, persona.id);
+      if (fragment) {
+        parts.push(`
+## Skill Rules`);
+        parts.push(fragment);
+      }
+    }
+  } catch {
+  }
+  return parts.join("\n");
+}
+function buildPersonaSummaries() {
+  const personas = listPersonas();
+  const lines = personas.map(
+    (p) => `- **${p.name}** (${p.shortName}): ${p.description}
+  Document types: ${p.documentTypes.join(", ")}`
+  );
+  return `# Available Personas
+
+${lines.join("\n\n")}`;
+}
+
+// src/mcp/persona-tools.ts
+import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
+function createPersonaTools(ctx, marvinDir) {
+  return [
+    tool17(
+      "set_persona",
+      "Set the active persona for this session. Returns full guidance for the selected persona including behavioral rules, allowed document types, and scope. Call this before working to ensure persona-appropriate behavior.",
+      {
+        persona: external_exports.string().describe(
+          'Persona ID or short name (e.g. "po", "product-owner", "dm", "delivery-manager", "tl", "tech-lead")'
+        )
+      },
+      async (args) => {
+        const resolved = ctx.setPersona(args.persona);
+        if (!resolved) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown persona "${args.persona}".
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const guidance = buildMcpGuidance(resolved, marvinDir);
+        return {
+          content: [{ type: "text", text: guidance }]
+        };
+      }
+    ),
+    tool17(
+      "get_persona_guidance",
+      "Get guidance for a persona without changing the active persona. If no persona is specified, lists all available personas with summaries.",
+      {
+        persona: external_exports.string().optional().describe(
+          "Optional persona ID or short name. Omit to list all personas."
+        )
+      },
+      async (args) => {
+        if (!args.persona) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [{ type: "text", text: summaries }]
+          };
+        }
+        const resolved = getPersona(args.persona);
+        if (!resolved) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Unknown persona "${args.persona}".
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const guidance = buildMcpGuidance(resolved, marvinDir);
+        return {
+          content: [{ type: "text", text: guidance }]
+        };
+      },
+      { annotations: { readOnly: true } }
+    )
+  ];
+}
+
+// src/mcp/tool-wrapper.ts
+function extractDocType(toolName) {
+  if (toolName === "save_report") return "report";
+  const match = toolName.match(/^(?:create|update)_(\w+)$/);
+  return match ? match[1] : void 0;
+}
+function wrapToolsWithPersonaValidation(tools, ctx) {
+  return tools.map((t) => {
+    const docType = extractDocType(t.name);
+    if (!docType) return t;
+    return {
+      ...t,
+      handler: async (args, extra) => {
+        const persona = ctx.getActivePersona();
+        if (!persona) {
+          const summaries = buildPersonaSummaries();
+          return {
+            content: [
+              {
+                type: "text",
+                text: `[PERSONA REQUIRED] You must set an active persona before creating or updating documents. Call the set_persona tool first.
+
+${summaries}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await t.handler(args, extra);
+        if (ctx.isDocumentTypeAllowed(docType)) {
+          return result;
+        }
+        const warning = [
+          `[PERSONA WARNING] You are acting as ${persona.name} (${persona.shortName}). Creating/updating "${docType}" documents is outside your typical scope.`,
+          "",
+          `Your allowed document types: ${persona.documentTypes.join(", ")}`,
+          "",
+          "Consider whether this is the right persona for this task, or switch with set_persona.",
+          "",
+          "---"
+        ].join("\n");
+        const content = Array.isArray(result.content) ? result.content.map(
+          (block, index) => {
+            if (index === 0 && block.type === "text" && block.text) {
+              return { ...block, text: `${warning}
+${block.text}` };
+            }
+            return block;
+          }
+        ) : result.content;
+        return { ...result, content };
+      }
+    };
+  });
+}
+
 // src/mcp/stdio-server.ts
 function collectTools(marvinDir) {
   const config2 = loadProjectConfig(marvinDir);
@@ -18520,8 +18727,11 @@ async function startStdioServer(options) {
     { name: "marvin-governance", version: "0.1.0" },
     { capabilities: { tools: {} } }
   );
-  const tools = collectTools(options.marvinDir);
-  registerSdkTools(server, tools);
+  const contextManager = new PersonaContextManager();
+  const governanceTools = collectTools(options.marvinDir);
+  const personaTools = createPersonaTools(contextManager, options.marvinDir);
+  const wrappedTools = wrapToolsWithPersonaValidation(governanceTools, contextManager);
+  registerSdkTools(server, [...personaTools, ...wrappedTools]);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }