yapout 0.3.1 → 0.4.0

package/dist/index.js

@@ -291,6 +291,29 @@ def main():
             prompt += f" about {topic}"
         if persona and persona != "tech lead":
             prompt += f" \u2014 be a {persona}"
+    elif action == "compact":
+    elif action == "enrich-bundle":
+        bundle_id = ticket_id
+        prompt = (
+            f'Use yapout to enrich a bundle as a single cohesive unit.\\n'
+            f'\\n'
+            f'1. Call yapout_enrich_bundle with bundleId "{bundle_id}" to claim it and get all findings\\n'
+            f'2. Read the codebase to understand the full scope of the bundle\\n'
+            f'3. Ask me any clarifying questions about the bundle as a whole (not individual findings)\\n'
+            f'4. For each finding, formulate:\\n'
+            f'   - A refined title\\n'
+            f'   - A specific description\\n'
+            f'   - Concrete acceptance criteria\\n'
+            f'   - An implementation brief\\n'
+            f'5. Also formulate bundle-level:\\n'
+            f'   - An overall description of what the bundle delivers\\n'
+            f'   - Combined acceptance criteria\\n'
+            f'   - An architecture/approach brief that covers the full scope\\n'
+            f'6. Call yapout_save_bundle_enrichment with ALL enrichment data at once\\n'
+            f'\\n'
+            f'Treat this as ONE problem, not separate findings. Understand how they relate,\\n'
+            f'identify dependencies, and write briefs that reference each other.'
+        )
     elif action == "compact":
         prompt = "Run yapout_compact to update the project context summary."
     else:
@@ -2055,7 +2078,7 @@ This tool saves the enrichment, then automatically creates the Linear issue with
 - Clarification Q&A as a branded comment (if any)
 - Implementation brief as attachment metadata
 
-The finding transitions: enriching \u2192 enriched \u2192 synced.`,
+The finding transitions: enriching \u2192 enriched \u2192 ready.`,
     {
       findingId: z11.string().describe("The finding ID to enrich (from yapout_get_unenriched_finding)"),
       title: z11.string().describe("Refined finding title \u2014 improve it if the original was vague"),
@@ -2115,7 +2138,7 @@ The finding transitions: enriching \u2192 enriched \u2192 synced.`,
           linearIssueId: finding?.linearIssueId ?? null,
           linearIssueUrl: finding?.linearIssueUrl ?? null,
           compactionHint,
-          message: finding?.linearIssueUrl ? `Finding enriched and synced to Linear: ${finding.linearIssueUrl}` : "Finding enriched and synced to Linear."
+          message: finding?.linearIssueUrl ? `Finding enriched and ready in Linear: ${finding.linearIssueUrl}` : "Finding enriched and ready in Linear."
         };
         if (args.isOversized && args.suggestedSplit?.length) {
           response.warning = `This finding is oversized. Suggested split: ${args.suggestedSplit.join(", ")}`;
@@ -2996,6 +3019,121 @@ When done=true, all findings have been processed.`,
   );
 }
 
+// src/mcp/tools/enrich-bundle.ts
+import { z as z20 } from "zod";
+function registerEnrichBundleTool(server, ctx) {
+  server.tool(
+    "yapout_enrich_bundle",
+    `Claim an entire bundle for enrichment. Returns ALL findings in the bundle at once
+with their relationships, source quotes, and project context.
+
+This is for enriching a bundle as a single cohesive unit \u2014 NOT individual findings.
+The agent should understand the full scope, ask questions about the bundle as a whole,
+then call yapout_save_bundle_enrichment with enrichment data for every finding.
+
+The bundle and all its findings transition to "enriching" status.`,
+    {
+      bundleId: z20.string().describe("The bundle ID to enrich")
+    },
+    async (args) => {
+      try {
+        const result = await ctx.client.mutation(
+          anyApi2.functions.bundles.claimBundleForEnrichment,
+          { bundleId: args.bundleId }
+        );
+        if (!result) {
+          return {
+            content: [{ type: "text", text: "Failed to claim bundle for enrichment." }],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error claiming bundle: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/save-bundle-enrichment.ts
+import { z as z21 } from "zod";
+function registerSaveBundleEnrichmentTool(server, ctx) {
+  server.tool(
+    "yapout_save_bundle_enrichment",
+    `Save enrichment for an entire bundle at once. Call this after you've analyzed all
+findings in the bundle as a cohesive unit, read the codebase, and asked any questions.
+
+Provide:
+- Bundle-level: overall description, combined acceptance criteria, implementation brief
+- Per-finding: each finding gets its own refined title, description, acceptance criteria, and brief
+
+The bundle and all findings transition from "enriching" to "enriched".
+Call yapout_sync_bundle_to_linear afterwards to create the Linear project.`,
+    {
+      bundleId: z21.string().describe("The bundle ID"),
+      title: z21.string().optional().describe("Refined bundle title (optional, keeps existing if omitted)"),
+      enrichedDescription: z21.string().describe("Bundle-level description \u2014 the cohesive story of what this bundle delivers"),
+      acceptanceCriteria: z21.array(z21.string()).describe("Bundle-level acceptance criteria"),
+      implementationBrief: z21.string().describe("Bundle-level implementation brief \u2014 overall approach, architecture decisions, key files"),
+      findings: z21.array(z21.object({
+        findingId: z21.string().describe("Finding ID"),
+        title: z21.string().describe("Refined finding title"),
+        enrichedDescription: z21.string().describe("Finding-specific description"),
+        acceptanceCriteria: z21.array(z21.string()).describe("Finding-specific acceptance criteria"),
+        implementationBrief: z21.string().describe("Finding-specific implementation brief")
+      })).describe("Per-finding enrichment data \u2014 one entry per finding in the bundle")
+    },
+    async (args) => {
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.bundles.saveBundleEnrichment,
+          {
+            bundleId: args.bundleId,
+            title: args.title,
+            enrichedDescription: args.enrichedDescription,
+            acceptanceCriteria: args.acceptanceCriteria,
+            implementationBrief: args.implementationBrief,
+            findings: args.findings.map((f) => ({
+              findingId: f.findingId,
+              title: f.title,
+              enrichedDescription: f.enrichedDescription,
+              acceptanceCriteria: f.acceptanceCriteria,
+              implementationBrief: f.implementationBrief
+            }))
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                bundleId: args.bundleId,
+                findingsEnriched: args.findings.length,
+                message: `Bundle enriched successfully (${args.findings.length} findings). Call yapout_sync_bundle_to_linear to create the Linear project.`
+              }, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error saving bundle enrichment: ${err.message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/mcp/server.ts
 async function startMcpServer() {
   const cwd = process.cwd();
@@ -3050,6 +3188,8 @@ async function startMcpServer() {
   registerGetLinearProjectsTool(server, ctx);
   registerStartEnrichmentTool(server, ctx);
   registerEnrichNextTool(server, ctx);
+  registerEnrichBundleTool(server, ctx);
+  registerSaveBundleEnrichmentTool(server, ctx);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
@@ -4141,7 +4281,7 @@ import { Command as Command15 } from "commander";
 import { spawn as spawn2 } from "child_process";
 import { platform as platform2 } from "os";
 import chalk16 from "chalk";
-var VALID_ACTIONS = ["claim", "enrich", "enrich-bulk", "yap", "compact"];
+var VALID_ACTIONS = ["claim", "enrich", "enrich-bulk", "enrich-bundle", "yap", "compact"];
 function parseYapoutUri(raw) {
   const url = new URL(raw);
   const action = url.hostname;
@@ -4151,8 +4291,8 @@ function parseYapoutUri(raw) {
     );
   }
   const ticketId = url.pathname.replace(/^\//, "") || void 0;
-  if ((action === "claim" || action === "enrich") && !ticketId) {
-    throw new Error(`Missing finding ID in URI: ${raw}`);
+  if ((action === "claim" || action === "enrich" || action === "enrich-bundle") && !ticketId) {
+    throw new Error(`Missing ID in URI: ${raw}`);
   }
   return {
     action,
@@ -4209,6 +4349,27 @@ function buildPrompt(parsed) {
       }
       return lines.join("\n");
     }
+    case "enrich-bundle":
+      return [
+        `Use yapout to enrich a bundle as a single cohesive unit.`,
+        ``,
+        `1. Call yapout_enrich_bundle with bundleId "${parsed.ticketId}" to claim it and get all findings`,
+        `2. Read the codebase to understand the full scope of the bundle`,
+        `3. Ask me any clarifying questions about the bundle as a whole (not individual findings)`,
+        `4. For each finding, formulate:`,
+        `   - A refined title`,
+        `   - A specific description`,
+        `   - Concrete acceptance criteria`,
+        `   - An implementation brief`,
+        `5. Also formulate bundle-level:`,
+        `   - An overall description of what the bundle delivers`,
+        `   - Combined acceptance criteria`,
+        `   - An architecture/approach brief that covers the full scope`,
+        `6. Call yapout_save_bundle_enrichment with ALL enrichment data at once`,
+        ``,
+        `Treat this as ONE problem, not separate findings. Understand how they relate,`,
+        `identify dependencies, and write briefs that reference each other.`
+      ].join("\n");
     case "yap": {
       const parts = ["Let's have a yap session"];
       if (parsed.topic) parts[0] += ` about ${parsed.topic}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yapout",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "yapout CLI — link local repos, authenticate, and manage projects",
   "type": "module",
   "bin": {