mrvn-cli 0.2.0 → 0.2.2

package/dist/marvin-serve.js

@@ -208,7 +208,7 @@ var DocumentStore = class {
       updated: now,
       ...cleaned
     };
-    const fileName = type === "meeting" ? `${now.slice(0, 10)}-${slugify(fullFrontmatter.title)}.md` : `${id}.md`;
+    const fileName = type === "meeting" ? `${cleaned.date?.slice(0, 10) ?? now.slice(0, 10)}-${slugify(fullFrontmatter.title)}.md` : `${id}.md`;
     const filePath = path3.join(dir, fileName);
     const doc = {
       frontmatter: fullFrontmatter,
@@ -232,7 +232,7 @@ var DocumentStore = class {
     }
     const dir = path3.join(this.docsDir, dirName);
     fs3.mkdirSync(dir, { recursive: true });
-    const fileName = type === "meeting" ? `${frontmatter.created.slice(0, 10)}-${slugify(frontmatter.title)}.md` : `${frontmatter.id}.md`;
+    const fileName = type === "meeting" ? `${frontmatter.date?.slice(0, 10) ?? frontmatter.created.slice(0, 10)}-${slugify(frontmatter.title)}.md` : `${frontmatter.id}.md`;
     const filePath = path3.join(dir, fileName);
     const doc = { frontmatter, content, filePath };
     fs3.writeFileSync(filePath, serializeDocument(doc), "utf-8");
@@ -14851,7 +14851,7 @@ function createMeetingTools(store) {
         owner: external_exports.string().optional().describe("Meeting organizer"),
         tags: external_exports.array(external_exports.string()).optional().describe("Tags for categorization"),
         attendees: external_exports.array(external_exports.string()).optional().describe("List of attendees"),
-        date: external_exports.string().optional().describe("Meeting date (ISO format)")
+        date: external_exports.string().describe("Date the meeting took place (ISO format, e.g. '2025-01-15'). Extract from the meeting content. If not found, ask the user before calling this tool.")
       },
       async (args) => {
         const frontmatter = {
@@ -14861,7 +14861,7 @@ function createMeetingTools(store) {
         if (args.owner) frontmatter.owner = args.owner;
         if (args.tags) frontmatter.tags = args.tags;
         if (args.attendees) frontmatter.attendees = args.attendees;
-        if (args.date) frontmatter.date = args.date;
+        frontmatter.date = args.date;
         const doc = store.create(
           "meeting",
           frontmatter,
@@ -15561,7 +15561,7 @@ var genericAgilePlugin = {
 
 **Meeting Tools:**
 - **list_meetings** / **get_meeting**: Browse and read meeting records.
-- **create_meeting**: Record new meetings with attendees, date, and agenda.
+- **create_meeting**: Record new meetings with attendees, date, and agenda. The meeting date is required \u2014 extract it from the meeting content or ask the user if not found.
 - **update_meeting**: Update meeting status or notes after completion.
 - **analyze_meeting**: Analyze a meeting to review its outcomes and extract artifacts.
 
@@ -15582,7 +15582,7 @@ var genericAgilePlugin = {
 
 **Meeting Tools:**
 - **list_meetings** / **get_meeting**: Browse and read meeting records.
-- **create_meeting**: Record new meetings with attendees, date, and agenda.
+- **create_meeting**: Record new meetings with attendees, date, and agenda. The meeting date is required \u2014 extract it from the meeting content or ask the user if not found.
 - **update_meeting**: Update meeting status or notes after completion.
 - **analyze_meeting**: Analyze a meeting to review its outcomes and extract artifacts.
 
@@ -15610,7 +15610,7 @@ var genericAgilePlugin = {
 
 **Meeting Tools:**
 - **list_meetings** / **get_meeting**: Browse and read meeting records.
-- **create_meeting**: Record new meetings with attendees, date, and agenda.
+- **create_meeting**: Record new meetings with attendees, date, and agenda. The meeting date is required \u2014 extract it from the meeting content or ask the user if not found.
 - **update_meeting**: Update meeting status or notes after completion.
 - **analyze_meeting**: Analyze a completed meeting to extract decisions, actions, and questions. Use this to ensure meeting outcomes are properly tracked as governance artifacts.
 
@@ -15628,7 +15628,7 @@ var genericAgilePlugin = {
 **Key workflow rule:** Epics must link to approved features \u2014 the system enforces this. The Product Owner defines and approves features, the Tech Lead breaks them into epics, and the Delivery Manager tracks dates and progress.
 
 - **list_meetings** / **get_meeting**: Browse and read meeting records.
-- **create_meeting**: Record meetings with attendees, date, and agenda.
+- **create_meeting**: Record meetings with attendees, date, and agenda. The meeting date is required \u2014 extract it from the meeting content or ask the user if not found.
 - **update_meeting**: Update meeting status or notes.
 - **analyze_meeting**: Analyze a meeting to extract decisions, actions, and questions as governance artifacts.`
   }
@@ -16530,6 +16530,10 @@ function resolvePlugin(methodologyId) {
 function getPluginTools(plugin, store, marvinDir) {
   return plugin.tools ? plugin.tools(store, marvinDir) : [];
 }
+function getPluginPromptFragment(plugin, personaId) {
+  if (!plugin.promptFragments) return void 0;
+  return plugin.promptFragments[personaId] ?? plugin.promptFragments["*"];
+}
 
 // src/skills/registry.ts
 import * as fs7 from "fs";
@@ -16697,6 +16701,18 @@ function loadAllSkills(marvinDir) {
   }
   return skills;
 }
+function resolveSkillsForPersona(personaId, skillsConfig, allSkills) {
+  if (skillsConfig?.[personaId]) {
+    return skillsConfig[personaId].filter((id) => allSkills.has(id));
+  }
+  const result = [];
+  for (const [id, skill] of allSkills) {
+    if (skill.personas?.includes(personaId)) {
+      result.push(id);
+    }
+  }
+  return result;
+}
 function getSkillTools(skillIds, allSkills, store) {
   const tools = [];
   for (const id of skillIds) {
@@ -16707,6 +16723,19 @@ function getSkillTools(skillIds, allSkills, store) {
   }
   return tools;
 }
+function getSkillPromptFragment(skillIds, allSkills, personaId) {
+  const fragments = [];
+  for (const id of skillIds) {
+    const skill = allSkills.get(id);
+    if (!skill?.promptFragments) continue;
+    const fragment = skill.promptFragments[personaId] ?? skill.promptFragments["*"];
+    if (fragment) {
+      fragments.push(`### ${skill.name}
+${fragment}`);
+    }
+  }
+  return fragments.length > 0 ? fragments.join("\n\n") : void 0;
+}
 
 // src/skills/action-tools.ts
 import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
@@ -16813,6 +16842,343 @@ function createSkillActionTools(skills, context) {
   return tools;
 }
 
+// src/personas/builtin/product-owner.ts
+var productOwner = {
+  id: "product-owner",
+  name: "Product Owner",
+  shortName: "po",
+  description: "Focuses on product vision, stakeholder needs, backlog prioritization, and value delivery.",
+  systemPrompt: `You are Marvin, acting as a **Product Owner**. Your role is to help the team maximize the value delivered by the product.
+
+## Core Responsibilities
+- Define and communicate the product vision and strategy
+- Manage and prioritize the product backlog
+- Ensure stakeholder needs are understood and addressed
+- Make decisions about scope, priority, and trade-offs
+- Accept or reject work results based on acceptance criteria
+
+## How You Work
+- Ask clarifying questions to understand business value and user needs
+- Create and refine decisions (D-xxx) for important product choices
+- Track questions (Q-xxx) that need stakeholder input
+- Define acceptance criteria for features and deliverables
+- Prioritize actions (A-xxx) based on business value
+
+## Communication Style
+- Business-oriented language, avoid unnecessary technical jargon
+- Focus on outcomes and value, not implementation details
+- Be decisive but transparent about trade-offs
+- Challenge assumptions that don't align with product goals`,
+  focusAreas: [
+    "Product vision and strategy",
+    "Backlog management",
+    "Stakeholder communication",
+    "Value delivery",
+    "Acceptance criteria",
+    "Feature definition and prioritization"
+  ],
+  documentTypes: ["decision", "question", "action", "feature"]
+};
+
+// src/personas/builtin/delivery-manager.ts
+var deliveryManager = {
+  id: "delivery-manager",
+  name: "Delivery Manager",
+  shortName: "dm",
+  description: "Focuses on project delivery, risk management, team coordination, and process governance.",
+  systemPrompt: `You are Marvin, acting as a **Delivery Manager**. Your role is to ensure the project is delivered on time, within scope, and with managed risks.
+
+## Core Responsibilities
+- Track project progress and identify blockers
+- Manage risks, issues, and dependencies
+- Coordinate between team members and stakeholders
+- Ensure governance processes are followed (decisions logged, actions tracked)
+- Facilitate meetings and ensure outcomes are captured
+
+## How You Work
+- Review open actions (A-xxx) and follow up on overdue items
+- Ensure decisions (D-xxx) are properly documented with rationale
+- Track questions (Q-xxx) and ensure they get answered
+- Monitor project health and flag risks early
+- Create meeting notes and ensure action items are assigned
+
+## Communication Style
+- Process-oriented but pragmatic
+- Focus on status, risks, and blockers
+- Be proactive about follow-ups and deadlines
+- Keep stakeholders informed with concise updates`,
+  focusAreas: [
+    "Project delivery",
+    "Risk management",
+    "Team coordination",
+    "Process governance",
+    "Status tracking",
+    "Epic scheduling and tracking"
+  ],
+  documentTypes: ["action", "decision", "meeting", "question", "feature", "epic"]
+};
+
+// src/personas/builtin/tech-lead.ts
+var techLead = {
+  id: "tech-lead",
+  name: "Technical Lead",
+  shortName: "tl",
+  description: "Focuses on technical architecture, code quality, technical decisions, and implementation guidance.",
+  systemPrompt: `You are Marvin, acting as a **Technical Lead**. Your role is to guide the team on technical decisions and ensure high-quality implementation.
+
+## Core Responsibilities
+- Define and maintain technical architecture
+- Make and document technical decisions with clear rationale
+- Review technical approaches and identify potential issues
+- Guide the team on best practices and patterns
+- Evaluate technical risks and propose mitigations
+
+## How You Work
+- Create decisions (D-xxx) for significant technical choices (framework, architecture, patterns)
+- Document technical questions (Q-xxx) that need investigation or proof-of-concept
+- Define technical actions (A-xxx) for implementation tasks
+- Consider non-functional requirements (performance, security, maintainability)
+- Provide clear technical guidance with examples when helpful
+
+## Communication Style
+- Technical but accessible \u2014 explain complex concepts clearly
+- Evidence-based decision making with documented trade-offs
+- Pragmatic about technical debt vs. delivery speed
+- Focus on maintainability and long-term sustainability`,
+  focusAreas: [
+    "Technical architecture",
+    "Code quality",
+    "Technical decisions",
+    "Implementation guidance",
+    "Non-functional requirements",
+    "Epic creation and scoping"
+  ],
+  documentTypes: ["decision", "action", "question", "epic"]
+};
+
+// src/personas/registry.ts
+var BUILTIN_PERSONAS = [
+  productOwner,
+  deliveryManager,
+  techLead
+];
+function getPersona(idOrShortName) {
+  const key = idOrShortName.toLowerCase();
+  return BUILTIN_PERSONAS.find(
+    (p) => p.id === key || p.shortName === key
+  );
+}
+function listPersonas() {
+  return [...BUILTIN_PERSONAS];
+}
+
+// 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);
@@ -16875,8 +17241,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);
 }