@adaptic/maestro 1.0.0

package/scripts/parse-voice-transcript.mjs

@@ -0,0 +1,486 @@
+#!/usr/bin/env node
+/**
+ * Voice Call Transcript Parser
+ *
+ * Parses voice call transcript summaries posted to Slack by the voice-ai
+ * post-call routing (voice-ai/lib/logger.js → postCallSummaryToSlack).
+ *
+ * Input format (Slack message text):
+ *   *Phone call completed* — +971585291799 (243s, 38 turns)
+ *
+ *   *Caller said:*
+ *   > First thing caller said
+ *   > Second thing caller said
+ *   > ...
+ *
+ *   _Action items from this call should be processed immediately._
+ *
+ * Output: structured object with caller identity, duration, topics,
+ *         and extracted action items suitable for queue routing.
+ *
+ * Usage:
+ *   import { isVoiceTranscript, parseVoiceTranscript } from './parse-voice-transcript.mjs';
+ *
+ *   if (isVoiceTranscript(messageText)) {
+ *     const parsed = parseVoiceTranscript(messageText);
+ *     // parsed.actionItems → array of { title, context, priority, source }
+ *   }
+ *
+ * Can also run standalone for testing:
+ *   node scripts/parse-voice-transcript.mjs < message.txt
+ */
+
+// ---------------------------------------------------------------------------
+// Known callers — maps phone numbers to identities
+// Keep in sync with voice-ai/server.js CALLER_GREETINGS
+// ---------------------------------------------------------------------------
+
+const KNOWN_CALLERS = {
+  "+971585291799": {
+    name: "mehran-granfar",
+    role: "ceo",
+    privilege: "ceo",
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Action item detection patterns
+// ---------------------------------------------------------------------------
+
+// Phrases that signal a request, ask, or action item
+const ACTION_PATTERNS = [
+  // Direct requests
+  /\b(?:can you|could you|please|I need you to|I want you to|go ahead and|make sure|set up|look into|find out|search for|book|schedule|send|draft|prepare|create|build|update|check|review|look at|investigate|fix|handle|take care of|arrange|organize|coordinate|follow up|chase|email|call|message|write)\b/i,
+  // Imperative verbs — direct commands without polite framing
+  /\b(?:time.?box|block out|clear my|reschedule|prioriti[sz]e|research|compile|summarize|summarise|analyze|analyse|escalate|ping|nudge|chase up|circle back|loop in|pull together|put together|get me|grab|download|upload|share|forward|transfer|assign|delegate|sort out|figure out|work on|finish|complete|deliver|ship|deploy|launch|submit|file|register|sign up|enroll|enrol)\b/i,
+  // Questions that imply action needed
+  /\b(?:what(?:'s| is) the status|where are we|have you|did you|when (?:can|will)|how (?:do|can)|is there)\b/i,
+  // Decisions and directives
+  /\b(?:let's|we should|we need to|I've decided|go with|use|switch to|stop|start|change|move|cancel|approve|reject)\b/i,
+  // Time-sensitive signals
+  /\b(?:today|tomorrow|this week|by (?:end of|monday|tuesday|wednesday|thursday|friday|saturday|sunday)|asap|urgent|immediately|right now|priority)\b/i,
+  // Follow-up triggers
+  /\b(?:remind me|don't forget|make a note|keep track|follow up|circle back|loop back)\b/i,
+  // Also/additionally — signals a new action item being added
+  /\b(?:also|additionally|one more thing|and also|plus)\b/i,
+];
+
+// Priority signal patterns
+const PRIORITY_SIGNALS = {
+  critical:
+    /\b(?:urgent|emergency|asap|critical|immediately|right now|drop everything)\b/i,
+  high: /\b(?:today|priority|important|need this|by end of day|eod)\b/i,
+  medium: /\b(?:this week|soon|when you can|follow up)\b/i,
+};
+
+// Topic classification patterns
+const TOPIC_PATTERNS = {
+  travel:
+    /\b(?:flight|flights|travel|book|booking|trip|australia|sydney|brisbane|airport|airline|hotel)\b/i,
+  calendar:
+    /\b(?:calendar|schedule|time.?box|block|meeting|appointment|slot|availability)\b/i,
+  hiring:
+    /\b(?:hiring|candidate|interview|role|position|recruit|applicant|offer|resume|cv)\b/i,
+  legal:
+    /\b(?:legal|contract|agreement|nda|compliance|regulatory|dfsa|licence|filing)\b/i,
+  engineering:
+    /\b(?:engineering|code|deploy|build|bug|fix|feature|platform|api|infrastructure)\b/i,
+  finance:
+    /\b(?:finance|budget|cost|expense|invoice|payment|funding|capital|runway)\b/i,
+  communication:
+    /\b(?:email|slack|message|send|reply|respond|follow.?up|chase)\b/i,
+  strategy:
+    /\b(?:strategy|roadmap|plan|initiative|priority|milestone|target|goal|objective)\b/i,
+  voice_ai: /\b(?:voice|phone|call|twilio|speech|conversation)\b/i,
+};
+
+// ---------------------------------------------------------------------------
+// Detection
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if a Slack message text is a voice call transcript summary.
+ * Uses the exact format produced by voice-ai/lib/logger.js postCallSummaryToSlack.
+ *
+ * @param {string} text - Slack message text
+ * @returns {boolean}
+ */
+export function isVoiceTranscript(text) {
+  if (!text || typeof text !== "string") return false;
+  // Must contain the post-call header AND caller-said block
+  return text.includes("Phone call completed") && text.includes("Caller said:");
+}
+
+// ---------------------------------------------------------------------------
+// Parsing
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse a voice call transcript summary from Slack into structured data.
+ *
+ * @param {string} text - Slack message text containing the transcript
+ * @param {object} [meta] - Optional metadata from the Slack message
+ * @param {string} [meta.ts] - Slack message timestamp
+ * @param {string} [meta.channel] - Slack channel ID
+ * @returns {object} Parsed transcript with caller info, duration, topics, action items
+ */
+export function parseVoiceTranscript(text, meta = {}) {
+  const result = {
+    type: "voice_call_transcript",
+    caller: null,
+    callerPhone: null,
+    callerIdentity: null,
+    duration: null,
+    durationSeconds: null,
+    turns: null,
+    callerStatements: [],
+    topics: [],
+    actionItems: [],
+    rawText: text,
+    slackTs: meta.ts || null,
+    slackChannel: meta.channel || null,
+  };
+
+  // --- Parse header line ---
+  // Format: *Phone call completed* — +971585291799 (243s, 38 turns)
+  const headerMatch = text.match(
+    /Phone call completed\*?\s*[-—]\s*(\+?[\d]+)\s*\((\d+)s,\s*(\d+)\s*turns?\)/,
+  );
+  if (headerMatch) {
+    result.callerPhone = headerMatch[1];
+    result.durationSeconds = parseInt(headerMatch[2], 10);
+    result.duration = formatDuration(result.durationSeconds);
+    result.turns = parseInt(headerMatch[3], 10);
+
+    // Resolve caller identity from phone number
+    const known = KNOWN_CALLERS[result.callerPhone];
+    if (known) {
+      result.caller = known.name;
+      result.callerIdentity = known;
+    } else {
+      result.caller = result.callerPhone;
+      result.callerIdentity = {
+        name: result.callerPhone,
+        role: "unknown",
+        privilege: "unknown",
+      };
+    }
+  }
+
+  // --- Extract caller statements ---
+  // Format: lines starting with > after "Caller said:"
+  const callerSaidMatch = text.match(
+    /Caller said:\*?\s*\n([\s\S]*?)(?:\n\n|_Action items|$)/,
+  );
+  if (callerSaidMatch) {
+    const callerBlock = callerSaidMatch[1];
+    result.callerStatements = callerBlock
+      .split("\n")
+      .map((line) => line.replace(/^>\s*/, "").trim())
+      .filter((line) => line.length > 0);
+  }
+
+  // --- Classify topics ---
+  const allCallerText = result.callerStatements.join(" ");
+  for (const [topic, pattern] of Object.entries(TOPIC_PATTERNS)) {
+    if (pattern.test(allCallerText)) {
+      result.topics.push(topic);
+    }
+  }
+
+  // --- Extract action items ---
+  result.actionItems = extractActionItems(result);
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Action Item Extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract action items from parsed caller statements.
+ * Groups related consecutive statements and identifies actionable requests.
+ *
+ * @param {object} parsed - Parsed transcript result
+ * @returns {Array<object>} Action items
+ */
+function extractActionItems(parsed) {
+  const items = [];
+  const statements = parsed.callerStatements;
+
+  if (!statements || statements.length === 0) return items;
+
+  // Group consecutive statements into logical segments.
+  // A segment break occurs when there's a topic shift or a clear pause indicator.
+  const segments = segmentStatements(statements);
+
+  for (const segment of segments) {
+    const segmentText = segment.join(" ");
+
+    // Check if this segment contains action-worthy content
+    const isActionable = ACTION_PATTERNS.some((p) => p.test(segmentText));
+    if (!isActionable) continue;
+
+    // Determine priority
+    let priority = "medium";
+    if (PRIORITY_SIGNALS.critical.test(segmentText)) priority = "critical";
+    else if (PRIORITY_SIGNALS.high.test(segmentText)) priority = "high";
+
+    // Determine topic
+    const topics = [];
+    for (const [topic, pattern] of Object.entries(TOPIC_PATTERNS)) {
+      if (pattern.test(segmentText)) topics.push(topic);
+    }
+
+    // Build a concise title from the segment
+    const title = buildActionTitle(segmentText, topics);
+
+    // Check if caller is CEO for priority boost
+    if (parsed.callerIdentity?.privilege === "ceo" && priority === "medium") {
+      priority = "high";
+    }
+
+    items.push({
+      title,
+      context: segmentText,
+      priority,
+      topics,
+      source: "voice-call",
+      source_ref: parsed.slackTs
+        ? `slack:${parsed.slackChannel || "unknown"}:${parsed.slackTs}`
+        : "voice-call",
+      caller: parsed.caller,
+      caller_privilege: parsed.callerIdentity?.privilege || "unknown",
+    });
+  }
+
+  return items;
+}
+
+/**
+ * Segment caller statements into logical groups.
+ * Statements about the same topic are grouped together.
+ */
+function segmentStatements(statements) {
+  if (statements.length === 0) return [];
+
+  const segments = [];
+  let current = [statements[0]];
+
+  for (let i = 1; i < statements.length; i++) {
+    const prev = statements[i - 1];
+    const curr = statements[i];
+
+    // Detect topic shift: if current statement matches different topic patterns
+    // than previous, or if there's a transitional phrase
+    const isTopicShift =
+      /\b(?:also|another thing|by the way|oh and|next|separately|on a different|switching to)\b/i.test(
+        curr,
+      ) || hasTopicShift(prev, curr);
+
+    if (isTopicShift) {
+      segments.push(current);
+      current = [curr];
+    } else {
+      current.push(curr);
+    }
+  }
+
+  if (current.length > 0) {
+    segments.push(current);
+  }
+
+  return segments;
+}
+
+/**
+ * Detect if two consecutive statements are about different topics.
+ */
+function hasTopicShift(prev, curr) {
+  const prevTopics = new Set();
+  const currTopics = new Set();
+
+  for (const [topic, pattern] of Object.entries(TOPIC_PATTERNS)) {
+    if (pattern.test(prev)) prevTopics.add(topic);
+    if (pattern.test(curr)) currTopics.add(topic);
+  }
+
+  // If both have topics and they don't overlap, it's a shift
+  if (prevTopics.size > 0 && currTopics.size > 0) {
+    const overlap = [...prevTopics].some((t) => currTopics.has(t));
+    return !overlap;
+  }
+
+  return false;
+}
+
+/**
+ * Build a concise action item title from segment text.
+ */
+function buildActionTitle(text, topics) {
+  // Truncate to a reasonable title length
+  const maxLen = 100;
+
+  // Try to extract the core request
+  const requestMatch = text.match(
+    /(?:can you|could you|please|I need you to|I want you to)\s+(.{10,80}?)(?:\.|,|$)/i,
+  );
+  if (requestMatch) {
+    return `CEO voice request: ${capitalize(requestMatch[1].trim())}`;
+  }
+
+  // Try to use the topic and first actionable phrase
+  const topicLabel = topics.length > 0 ? topics[0] : "general";
+  const shortened =
+    text.length > maxLen ? text.substring(0, maxLen) + "..." : text;
+
+  return `CEO voice directive (${topicLabel}): ${shortened}`;
+}
+
+// ---------------------------------------------------------------------------
+// Inbox Item Generation
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert parsed voice transcript into inbox queue items compatible
+ * with the poller's writeInboxItem format.
+ *
+ * @param {object} parsed - Output from parseVoiceTranscript
+ * @returns {Array<object>} Inbox items ready for writeInboxItem
+ */
+export function toInboxItems(parsed) {
+  if (!parsed.actionItems || parsed.actionItems.length === 0) {
+    // Even if no specific action items detected, create one catch-all item
+    // for voice calls from the CEO so nothing is missed
+    if (parsed.callerIdentity?.privilege === "ceo") {
+      return [
+        {
+          id: `voice-${parsed.slackTs || Date.now()}`.replace(/\./g, "-"),
+          service: "slack",
+          channel: `dm/${parsed.caller || "unknown"}`,
+          sender: parsed.caller || "unknown",
+          sender_privilege: parsed.callerIdentity?.privilege || "unknown",
+          timestamp: new Date().toISOString(),
+          subject: `Voice call from ${parsed.caller || "unknown caller"} (${parsed.duration || "unknown"})`,
+          content: parsed.rawText,
+          thread_id: "",
+          is_reply: false,
+          is_voice_transcript: true,
+          voice_meta: {
+            caller_phone: parsed.callerPhone,
+            duration_seconds: parsed.durationSeconds,
+            turns: parsed.turns,
+            topics: parsed.topics,
+            caller_statements_count: parsed.callerStatements.length,
+          },
+          priority_signals: {
+            from_ceo: true,
+            tagged_urgent: false,
+            contains_deadline: false,
+            mentions_sophie: true,
+          },
+          raw_ref: parsed.slackTs
+            ? `slack:${parsed.slackChannel || "unknown"}:${parsed.slackTs}`
+            : "",
+        },
+      ];
+    }
+    return [];
+  }
+
+  return parsed.actionItems.map((action, idx) => ({
+    id: `voice-${parsed.slackTs || Date.now()}-${idx}`.replace(/\./g, "-"),
+    service: "slack",
+    channel: `dm/${parsed.caller || "unknown"}`,
+    sender: parsed.caller || "unknown",
+    sender_privilege: action.caller_privilege || "unknown",
+    timestamp: new Date().toISOString(),
+    subject: action.title,
+    content: `[Voice Call Action Item]\n\nCaller: ${parsed.caller || "unknown"} (${parsed.callerPhone || "unknown"})\nDuration: ${parsed.duration || "unknown"}\nTopics: ${action.topics.join(", ") || "general"}\n\nCaller statement:\n${action.context}\n\nFull transcript summary:\n${parsed.rawText}`,
+    thread_id: "",
+    is_reply: false,
+    is_voice_transcript: true,
+    voice_meta: {
+      caller_phone: parsed.callerPhone,
+      duration_seconds: parsed.durationSeconds,
+      turns: parsed.turns,
+      topics: action.topics,
+      action_priority: action.priority,
+    },
+    priority_signals: {
+      from_ceo: action.caller_privilege === "ceo",
+      tagged_urgent: action.priority === "critical",
+      contains_deadline: PRIORITY_SIGNALS.high.test(action.context),
+      mentions_sophie: true,
+    },
+    raw_ref: action.source_ref || "",
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function formatDuration(seconds) {
+  if (!seconds || seconds < 0) return "unknown";
+  const min = Math.floor(seconds / 60);
+  const sec = seconds % 60;
+  if (min === 0) return `${sec}s`;
+  return `${min}m ${sec}s`;
+}
+
+function capitalize(str) {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// ---------------------------------------------------------------------------
+// CLI mode — for testing
+// ---------------------------------------------------------------------------
+
+if (process.argv[1] && process.argv[1].includes("parse-voice-transcript")) {
+  // Read from stdin or from file argument
+  const input = process.argv[2];
+
+  if (input) {
+    // File argument
+    const { readFileSync } = await import("fs");
+    const text = readFileSync(input, "utf-8");
+    processInput(text);
+  } else {
+    // Stdin
+    let text = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => (text += chunk));
+    process.stdin.on("end", () => processInput(text));
+
+    // If no input after 100ms, show usage
+    setTimeout(() => {
+      if (!text) {
+        console.log("Usage: node parse-voice-transcript.mjs [file]");
+        console.log(
+          "       echo 'message text' | node parse-voice-transcript.mjs",
+        );
+        console.log("");
+        console.log("Parses voice call transcript summaries posted to Slack.");
+        process.exit(0);
+      }
+    }, 100);
+  }
+}
+
+function processInput(text) {
+  if (!isVoiceTranscript(text)) {
+    console.log("Not a voice call transcript.");
+    process.exit(1);
+  }
+
+  const parsed = parseVoiceTranscript(text, { ts: "test", channel: "test" });
+  console.log("\n=== Parsed Voice Transcript ===");
+  console.log(JSON.stringify(parsed, null, 2));
+
+  const inboxItems = toInboxItems(parsed);
+  console.log("\n=== Generated Inbox Items ===");
+  console.log(JSON.stringify(inboxItems, null, 2));
+}

package/scripts/pdf-generation/README.md

@@ -0,0 +1,61 @@
+# PDF Generation Pipeline
+
+Generates professional PDF documents from Markdown using Pandoc + XeLaTeX.
+Ported from the `~/ai-born` book generation pipeline, adapted for corporate documents.
+
+## Prerequisites
+
+```bash
+# Install Pandoc
+brew install pandoc
+
+# Install MacTeX (for XeLaTeX)
+brew install --cask mactex-no-gui
+
+# Install Node.js dependencies
+cd ~/sophie-ai && npm install
+```
+
+## Usage
+
+```bash
+# Generate a single document
+node scripts/pdf-generation/build-document.mjs --input outputs/briefs/daily/2026-04-02/morning-brief.md --template corporate-letter
+
+# Generate a board pack
+node scripts/pdf-generation/build-document.mjs --input outputs/board/2026-Q2-board-pack.md --template board-pack
+
+# Generate an investor letter
+node scripts/pdf-generation/build-document.mjs --input outputs/memos/investor-update-2026-Q1.md --template investor-letter
+
+# Available templates
+#   corporate-letter   — Standard A4/Letter corporate document
+#   board-pack         — Board materials with cover page and TOC
+#   investor-letter    — Investor communications on branded letterhead
+#   memo               — Internal memos and briefs
+```
+
+## Templates
+
+LaTeX templates live in `scripts/pdf-generation/templates/`:
+
+| Template                 | Page Size      | Margins | Use Case                                             |
+| ------------------------ | -------------- | ------- | ---------------------------------------------------- |
+| `corporate-letter.latex` | A4 (210x297mm) | 25mm    | Standard correspondence, regulatory submissions      |
+| `board-pack.latex`       | A4             | 20mm    | Board packs with TOC, branded cover, section headers |
+| `investor-letter.latex`  | A4             | 30mm    | Investor letters, LP updates                         |
+| `memo.latex`             | A4             | 20mm    | Internal briefs, memos, decision documents           |
+
+## How It Works
+
+1. Markdown content is authored (by agents or manually)
+2. `build-document.mjs` reads the Markdown and selects the appropriate LaTeX template
+3. Pandoc converts Markdown → PDF via XeLaTeX with brand fonts and logo placement
+4. Output PDF is saved alongside the source Markdown or to a specified output path
+
+## Brand Integration
+
+- Templates reference brand assets from `public/assets/` for logos and icons
+- Typography uses Georgia (main) and Helvetica Neue (sans) per brand guidelines
+- Colour values sourced from `config/brand-assets.yaml`
+- See `config/brand-assets.yaml → typography.pdf` for font configuration