feat: document summarization recipe redesign for journalism use (#88)

* feat: add conditional block syntax to interpolateTemplate

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test: add same-key block test; docs: note nesting unsupported

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat: update document-summarization recipe for journalism use

* test: integration tests for recipe template rendering

* docs: add design and implementation plan for document summarization recipe redesign

* feat: remove redundant User Prompt column from document-summarization recipe

* feat: apply field-label styling and (optional) markers to recipe inputs

* feat: use field-group wrapper for recipe inputs to get section dividers

* feat: add intro field to RecipeDefinition for panel-level description

* fix: remove redundant optional field guidance from recipe intro

* tweaking helper text

* fix: remove BLUF label prefix from system prompt structure guideline

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: aaronbrezel

__tests__/panels/recipe.test.ts

@@ -65,16 +65,16 @@ async function flush() {
 describe("rendering", () => {
   it("renders one input field per RecipeInput", () => {
     const { container } = mount();
-    expect(container.querySelectorAll(".recipe-input-field")).toHaveLength(2);
+    expect(container.querySelectorAll(".field-group")).toHaveLength(2);
   });
 
   it("renders the label for each input", () => {
     const { container } = mount();
-    const labels = Array.from(container.querySelectorAll(".recipe-input-label")).map(
+    const labels = Array.from(container.querySelectorAll(".field-label")).map(
       (el) => el.textContent,
     );
-    expect(labels).toContain("Drive Folder");
-    expect(labels).toContain("What are you looking for?");
+    expect(labels).toContain("Drive Folder *");
+    expect(labels).toContain("What are you looking for? (optional)");
   });
 
   it("renders placeholder on the input element", () => {

__tests__/recipes.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Integration tests for src/client/recipes.ts
+ *
+ * Exercises each recipe's template strings through interpolateTemplate to catch
+ * typos in placeholder/block syntax (e.g. mismatched closing tags) that would
+ * silently pass unit tests on either module in isolation.
+ */
+
+import { RECIPES } from "../src/client/recipes";
+import { interpolateTemplate } from "../src/server/utils";
+import type { RecipeColumn } from "../src/client/types";
+
+function getTemplateCol(cols: RecipeColumn[], role: RecipeColumn["role"]): string | null {
+  const col = cols.find((c) => c.role === role);
+  if (!col || col.fillStrategy.kind !== "template") return null;
+  return col.fillStrategy.template;
+}
+
+describe("document-summarization recipe", () => {
+  const recipe = RECIPES.find((r) => r.id === "document-summarization");
+
+  it("is registered in RECIPES", () => {
+    expect(recipe).toBeDefined();
+  });
+
+  describe("system-prompt template", () => {
+    const template = recipe ? getTemplateCol(recipe.prepTemplate, "system-prompt") : null;
+
+    it("uses a template fill strategy", () => {
+      expect(template).not.toBeNull();
+    });
+
+    it("renders cleanly with no optional inputs", () => {
+      const result = interpolateTemplate(template!, { folder: "", docType: "", focus: "" });
+      expect(result).not.toContain("{{");
+      expect(result).toContain("Briefing Assistant");
+      expect(result).not.toContain("Document type");
+      expect(result).not.toContain("Area of interest");
+    });
+
+    it("renders docType when provided", () => {
+      const result = interpolateTemplate(template!, {
+        folder: "",
+        docType: "court filing",
+        focus: "",
+      });
+      expect(result).toContain("Document type: court filing");
+      expect(result).not.toContain("Area of interest");
+      expect(result).not.toContain("{{");
+    });
+
+    it("renders focus when provided", () => {
+      const result = interpolateTemplate(template!, {
+        folder: "",
+        docType: "",
+        focus: "financial fraud",
+      });
+      expect(result).not.toContain("Document type");
+      expect(result).toContain("Area of interest: financial fraud");
+      expect(result).not.toContain("{{");
+    });
+
+    it("renders both optional inputs when provided", () => {
+      const result = interpolateTemplate(template!, {
+        folder: "",
+        docType: "FOIA response",
+        focus: "conflicts of interest",
+      });
+      expect(result).toContain("Document type: FOIA response");
+      expect(result).toContain("Area of interest: conflicts of interest");
+      expect(result).not.toContain("{{");
+    });
+  });
+});

__tests__/utils.test.ts

@@ -437,9 +437,7 @@ describe("interpolateTemplate", () => {
   });
 
   it("replaces multiple placeholders in one string", () => {
-    expect(
-      interpolateTemplate("{{a}} and {{b}}", { a: "foo", b: "bar" }),
-    ).toBe("foo and bar");
+    expect(interpolateTemplate("{{a}} and {{b}}", { a: "foo", b: "bar" })).toBe("foo and bar");
   });
 
   it("replaces the same placeholder multiple times", () => {
@@ -453,4 +451,50 @@ describe("interpolateTemplate", () => {
   it("returns the string unchanged when no placeholders present", () => {
     expect(interpolateTemplate("no placeholders", { x: "y" })).toBe("no placeholders");
   });
+
+  it("includes block content when the key has a non-empty value", () => {
+    expect(interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", { focus: "fraud" })).toBe(
+      "Focus: fraud",
+    );
+  });
+
+  it("omits block content when the key is empty string", () => {
+    expect(interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", { focus: "" })).toBe("");
+  });
+
+  it("omits block content when the key is missing from inputValues", () => {
+    expect(interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", {})).toBe("");
+  });
+
+  it("handles multiple conditional blocks independently", () => {
+    expect(
+      interpolateTemplate(
+        "{{#docType}}Type: {{docType}}{{/docType}}\n{{#focus}}Focus: {{focus}}{{/focus}}",
+        { docType: "filing", focus: "" },
+      ),
+    ).toBe("Type: filing\n");
+  });
+
+  it("handles conditional blocks alongside simple placeholders", () => {
+    expect(
+      interpolateTemplate("Hello {{name}}{{#extra}} ({{extra}}){{/extra}}", {
+        name: "world",
+        extra: "detail",
+      }),
+    ).toBe("Hello world (detail)");
+  });
+
+  it("handles conditional blocks with multiline content", () => {
+    expect(interpolateTemplate("before\n{{#key}}line1\nline2\n{{/key}}after", { key: "yes" })).toBe(
+      "before\nline1\nline2\nafter",
+    );
+  });
+
+  it("handles two conditional blocks with the same key", () => {
+    expect(interpolateTemplate("{{#x}}first{{/x}}{{#x}}second{{/x}}", { x: "yes" })).toBe(
+      "firstsecond",
+    );
+
+    expect(interpolateTemplate("{{#x}}first{{/x}}{{#x}}second{{/x}}", { x: "" })).toBe("");
+  });
 });

docs/plans/2026-04-15-document-summarization-recipe-implementation.md

@@ -0,0 +1,223 @@
+# Document Summarization Recipe Redesign — Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Update the document-summarization recipe for journalism use — two new optional inputs (document type, area of interest), a journalist-oriented BLUF system prompt using conditional template blocks, and the infrastructure to support those blocks.
+
+**Architecture:** Add a two-pass conditional block syntax (`{{#key}}...{{/key}}`) to `interpolateTemplate`, then update the recipe definition to use the new inputs and template. No new files; three existing files modified.
+
+**Tech Stack:** TypeScript, Jest, Rollup (no new dependencies)
+
+---
+
+### Task 1: Extend `interpolateTemplate` with conditional block support
+
+**Files:**
+- Modify: `src/server/utils.ts:145-151`
+- Test: `__tests__/utils.test.ts:434-456`
+
+**Step 1: Write the failing tests**
+
+Add the following cases to the `describe("interpolateTemplate", ...)` block in `__tests__/utils.test.ts`, just before the closing `});` on line 456:
+
+```typescript
+  it("includes block content when the key has a non-empty value", () => {
+    expect(
+      interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", { focus: "fraud" }),
+    ).toBe("Focus: fraud");
+  });
+
+  it("omits block content when the key is empty string", () => {
+    expect(
+      interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", { focus: "" }),
+    ).toBe("");
+  });
+
+  it("omits block content when the key is missing from inputValues", () => {
+    expect(
+      interpolateTemplate("{{#focus}}Focus: {{focus}}{{/focus}}", {}),
+    ).toBe("");
+  });
+
+  it("handles multiple conditional blocks independently", () => {
+    expect(
+      interpolateTemplate(
+        "{{#docType}}Type: {{docType}}{{/docType}}\n{{#focus}}Focus: {{focus}}{{/focus}}",
+        { docType: "filing", focus: "" },
+      ),
+    ).toBe("Type: filing\n");
+  });
+
+  it("handles conditional blocks alongside simple placeholders", () => {
+    expect(
+      interpolateTemplate("Hello {{name}}{{#extra}} ({{extra}}){{/extra}}", {
+        name: "world",
+        extra: "detail",
+      }),
+    ).toBe("Hello world (detail)");
+  });
+
+  it("handles conditional blocks with multiline content", () => {
+    expect(
+      interpolateTemplate("before\n{{#key}}line1\nline2\n{{/key}}after", { key: "yes" }),
+    ).toBe("before\nline1\nline2\nafter");
+  });
+```
+
+**Step 2: Run tests to verify they fail**
+
+```bash
+npx jest __tests__/utils.test.ts -t "interpolateTemplate" --no-coverage
+```
+
+Expected: 6 new tests FAIL with errors like `"Focus: fraud" !== ""`
+
+**Step 3: Implement two-pass interpolation**
+
+Replace the body of `interpolateTemplate` in `src/server/utils.ts` (lines 145–151):
+
+```typescript
+/**
+ * Replace {{inputId}} placeholders and {{#key}}...{{/key}} conditional blocks
+ * in a template string with values from a map.
+ *
+ * Conditional blocks: content is included only when the named key has a non-empty value.
+ * Simple placeholders: unknown keys are replaced with an empty string.
+ */
+export function interpolateTemplate(template: string, inputValues: Record<string, string>): string {
+  // Pass 1: conditional blocks — include content only if value is non-empty
+  const withBlocks = template.replace(
+    /\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g,
+    (_, id: string, content: string) => ((inputValues[id] ?? "") ? content : ""),
+  );
+  // Pass 2: simple interpolations
+  return withBlocks.replace(/\{\{(\w+)\}\}/g, (_, id: string) => inputValues[id] ?? "");
+}
+```
+
+**Step 4: Run tests to verify they pass**
+
+```bash
+npx jest __tests__/utils.test.ts -t "interpolateTemplate" --no-coverage
+```
+
+Expected: all 11 tests PASS (5 existing + 6 new)
+
+**Step 5: Run the full test suite**
+
+```bash
+npm test
+```
+
+Expected: all tests PASS
+
+**Step 6: Commit**
+
+```bash
+git add src/server/utils.ts __tests__/utils.test.ts
+git commit -m "feat: add conditional block syntax to interpolateTemplate"
+```
+
+---
+
+### Task 2: Update the document-summarization recipe
+
+**Files:**
+- Modify: `src/client/recipes.ts`
+
+**Step 1: Replace the recipe definition**
+
+Replace the entire contents of `src/client/recipes.ts` with:
+
+```typescript
+import type { RecipeDefinition } from "./types";
+
+export const RECIPES: RecipeDefinition[] = [
+  {
+    id: "document-summarization",
+    name: "Document Summarization",
+    icon: "📄",
+    description: "Summarize files in a Google Drive folder",
+    inputs: [
+      {
+        id: "folder",
+        label: "Drive Folder",
+        required: true,
+        helperText: "Make sure you have access to this folder",
+        placeholder: "Paste Google Drive folder URL",
+      },
+      {
+        id: "docType",
+        label: "Document Type",
+        required: false,
+        placeholder: "e.g. court filing, FOIA response, annual report",
+      },
+      {
+        id: "focus",
+        label: "Area of Interest",
+        required: false,
+        placeholder: "e.g. financial fraud, conflicts of interest",
+      },
+    ],
+    prepTemplate: [
+      {
+        colTitle: "Drive Link",
+        fillStrategy: { kind: "list-drive-folder", inputId: "folder" },
+        role: "file-prompt",
+      },
+      {
+        colTitle: "System Prompt",
+        fillStrategy: {
+          kind: "template",
+          template:
+            "Role: You are a specialized Briefing Assistant. Your goal is to distill complex documents into ultra-concise, scannable summaries.\n\n" +
+            "Tone: Objective, professional, and dense with information but sparse with \"fluff\" words.\n\n" +
+            "Guidelines:\n" +
+            "  - Prioritize Utility: Focus on information that helps a user decide: \"Do I need to open the full file?\"\n" +
+            "  - Structure: Always start with a 1-sentence \"Bottom Line Up Front\" (BLUF). Follow with 3-5 high-impact bullet points.\n" +
+            "  - Constraint: Keep the entire output under 150 words.\n" +
+            "{{#docType}}  - Document type: {{docType}}\n{{/docType}}" +
+            "{{#focus}}  - Area of interest: {{focus}} — prioritize this above all else.\n{{/focus}}",
+        },
+        role: "system-prompt",
+      },
+      {
+        colTitle: "User Prompt",
+        fillStrategy: {
+          kind: "fill-value",
+          value: "Summarize the attached document.",
+        },
+        role: "text-prompt",
+      },
+      {
+        colTitle: "AI_Summarization",
+        fillStrategy: { kind: "create-empty" },
+        role: "output",
+      },
+    ],
+  },
+];
+```
+
+**Step 2: Type-check**
+
+```bash
+npm run typecheck
+```
+
+Expected: no errors
+
+**Step 3: Build**
+
+```bash
+npm run build
+```
+
+Expected: clean build, no errors
+
+**Step 4: Commit**
+
+```bash
+git add src/client/recipes.ts
+git commit -m "feat: update document-summarization recipe for journalism use"
+```