@adaptic/maestro 1.0.0

package/scripts/daemon/prompt-builder.mjs

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+// Prompt Builder — constructs focused prompts for claude --print sessions
+// Each inbox item or backlog queue item gets a tailored prompt with identity,
+// rules, context, and action instructions.
+
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { compileContext } from "./context-compiler.mjs";
+
+const SOPHIE_AI_DIR = join(new URL(".", import.meta.url).pathname, "../..");
+
+// Legacy: Maximum lines of conversation history (used when DAEMON_CONTEXT_COMPILER is off)
+const MAX_HISTORY_LINES = 30;
+
+// Cached identity preamble — extracted from CLAUDE.md on first call
+let cachedPreamble = null;
+
+function loadPreamble() {
+  if (cachedPreamble) return cachedPreamble;
+
+  try {
+    const raw = readFileSync(join(SOPHIE_AI_DIR, "CLAUDE.md"), "utf-8");
+    cachedPreamble = extractPreamble(raw);
+  } catch (err) {
+    console.error(`[prompt-builder] Failed to read CLAUDE.md: ${err.message}`);
+    cachedPreamble = FALLBACK_PREAMBLE;
+  }
+  return cachedPreamble;
+}
+
+/**
+ * Extract the Identity, Operating Principles, Communication Rules,
+ * and Document Sharing sections from CLAUDE.md — keep it concise.
+ */
+function extractPreamble(raw) {
+  const sections = [];
+  const lines = raw.split("\n");
+  const targetHeaders = [
+    "## Identity",
+    "## Company Context",
+    "## Operating Principles",
+    "## Communication Rules",
+  ];
+
+  let capturing = false;
+  let depth = 0;
+
+  for (const line of lines) {
+    // Start capturing when we hit a target header
+    if (targetHeaders.some((h) => line.startsWith(h))) {
+      capturing = true;
+      depth = 2; // ## level
+      sections.push(line);
+      continue;
+    }
+
+    // Stop capturing when we hit another ## header that is NOT a sub-section of what we want
+    if (capturing && /^## [A-Z]/.test(line) && !targetHeaders.some((h) => line.startsWith(h))) {
+      capturing = false;
+      sections.push(""); // blank line separator
+      continue;
+    }
+
+    // Also stop at ### Document Sharing end — capture it but stop at next ##
+    if (capturing) {
+      sections.push(line);
+    }
+  }
+
+  const extracted = sections.join("\n").trim();
+
+  // If extraction got something reasonable, use it; otherwise fall back
+  if (extracted.length > 200) return extracted;
+  return FALLBACK_PREAMBLE;
+}
+
+const FALLBACK_PREAMBLE = `You are Sophie Nguyen, Chief of Staff to Mehran Granfar, CEO of Adaptic.ai.
+You operate as the autonomous executive command layer for the company.
+
+Adaptic Group — a global AI-native institutional asset management group.
+UBOs: Mehran Granfar (50%) + Bronwyn Leong (50%) via Arrowsphere Holdings Limited.
+
+Operating Principles:
+1. Follow-through over brilliance — track every commitment until it closes
+2. Concise over comprehensive — sharp recommendations, not exhaustive reports
+3. Evidence over opinion — cite sources
+4. Bias to action — act decisively on operational matters; escalate only strategic commitments
+5. Audit everything — every action is logged
+6. Full autonomy, full accountability
+
+Autonomy Model:
+- Sophie sends autonomously: all internal messages, external operational messages, candidate comms, follow-ups, calendar coordination
+- Sophie escalates only: binding legal/financial obligations, regulatory submissions, acquisition deal terms, public statements
+
+Document Sharing (CRITICAL):
+- NEVER reference local file paths in outbound communications
+- Upload to Google Drive or generate branded PDF for sharing
+- Inline short content directly in messages
+- Never attach raw .md or .yaml files`;
+
+const ACTION_INSTRUCTIONS = {
+  respond: `ACTION: Respond to this message.
+- Read the message carefully and understand the request
+- Check for any relevant context in thread history
+- Draft and send a response using the appropriate MCP tool (Slack or Gmail)
+- Match the tone and urgency of the sender
+- If the sender is CEO, prioritise speed and directness
+- If you need to share documents, upload to Google Drive or send as PDF — NEVER reference local file paths`,
+
+  draft: `ACTION: Draft a response or document — do NOT send it yet.
+- Read the message and understand what is being requested
+- Draft the response or document
+- Save the draft to outputs/ with a descriptive filename
+- If it is a document (memo, brief, letter), use the appropriate format
+- Log that a draft has been created and is awaiting review`,
+
+  research: `ACTION: Research this topic and write findings.
+- Investigate the topic thoroughly using available tools and knowledge
+- Check relevant files in knowledge/, docs/, and memory/
+- Write concise findings to outputs/research/ with today's date prefix
+- Include sources and evidence for all claims
+- Highlight actionable recommendations`,
+
+  queue: `ACTION: Create a queue item for later processing.
+- This item needs tracking but not immediate action
+- Create or update a queue item in the appropriate state/queues/ file
+- Set appropriate priority, owner, SLA deadline, and next_action
+- Log the queuing decision`,
+
+  archive: `ACTION: Archive — no action needed.
+- Mark this item as processed
+- Log that it was reviewed and archived with a brief reason
+- No response required`,
+
+  ignore: `ACTION: Ignore — skip entirely.
+- This item requires no processing
+- Log only that it was classified as ignore`,
+};
+
+function today() {
+  return new Date().toISOString().split("T")[0];
+}
+
+/**
+ * Load recent conversation history for a sender/channel from interaction logs.
+ * Searches memory/interactions/slack/{channel-or-sender}/ for recent JSONL entries.
+ * Returns the most recent entries as formatted context text.
+ */
+function loadConversationHistory(item) {
+  if (!item) return null;
+  const date = today();
+
+  // Try multiple paths where interaction logs may live
+  const channelId = extractChannelId(item);
+  const senderSlug = item.sender ? item.sender.replace(/\s+/g, "-").toLowerCase() : null;
+
+  const candidateDirs = [];
+  if (channelId) candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", channelId));
+  if (senderSlug) {
+    candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", `dm-${senderSlug}`));
+    candidateDirs.push(join(SOPHIE_AI_DIR, "memory", "interactions", "slack", senderSlug));
+  }
+
+  const entries = [];
+
+  for (const dir of candidateDirs) {
+    try {
+      // Read today's and yesterday's logs
+      const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort()
+        .reverse()
+        .slice(0, 2); // Today + yesterday at most
+
+      for (const file of files) {
+        try {
+          const content = readFileSync(join(dir, file), "utf-8").trim();
+          if (!content) continue;
+          const lines = content.split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              entries.push(JSON.parse(line));
+            } catch { /* skip malformed lines */ }
+          }
+        } catch { /* skip unreadable files */ }
+      }
+    } catch { /* dir doesn't exist — try next */ }
+  }
+
+  if (entries.length === 0) return null;
+
+  // Sort by timestamp and take recent entries
+  entries.sort((a, b) => {
+    const tsA = a.ts || a.received_at || "";
+    const tsB = b.ts || b.received_at || "";
+    return tsA.localeCompare(tsB);
+  });
+
+  const recent = entries.slice(-MAX_HISTORY_LINES);
+
+  // Format into readable context
+  const lines = ["## Recent conversation history with this sender"];
+  for (const entry of recent) {
+    const from = entry.from || entry.user_name || entry.sender || "unknown";
+    const text = entry.content || entry.text || "(no text)";
+    const ts = entry.received_at || entry.processed_at || entry.ts || "";
+    const actions = entry.actions_taken
+      ? ` [Actions: ${Array.isArray(entry.actions_taken) ? entry.actions_taken.join(", ") : entry.actions_taken}]`
+      : entry.action_taken
+        ? ` [Action: ${entry.action_taken}]`
+        : "";
+    const responded = entry.response_sent ? " [Responded]" : "";
+    lines.push(`[${ts}] ${from}: ${text.substring(0, 300)}${actions}${responded}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Extract Slack channel ID from item metadata.
+ */
+function extractChannelId(item) {
+  if (!item) return null;
+  // Direct channel ID field
+  if (item.channel_id) return item.channel_id;
+  // From raw_ref format: "slack:D099N1JGKRQ:1775331885.690669"
+  if (item.raw_ref) {
+    const match = item.raw_ref.match(/slack:([DC][A-Z0-9]+):/);
+    if (match) return match[1];
+  }
+  // Channel field if it looks like an ID
+  if (item.channel && /^[DC][A-Z0-9]{8,}$/.test(item.channel)) return item.channel;
+  return null;
+}
+
+/**
+ * Build a sender identifier string for the prompt
+ */
+function formatSender(item) {
+  const parts = [];
+  if (item.sender) parts.push(item.sender);
+  if (item.sender_privilege && item.sender_privilege !== "unknown") {
+    parts.push(`(${item.sender_privilege})`);
+  }
+  return parts.join(" ") || "unknown sender";
+}
+
+/**
+ * Build the item context block for inbox items
+ */
+function buildInboxContext(item) {
+  const lines = [];
+  lines.push("--- INCOMING MESSAGE ---");
+  lines.push(`From: ${formatSender(item)}`);
+  lines.push(`Service: ${item.service || "unknown"}`);
+  lines.push(`Channel: ${item.channel || "unknown"}`);
+  if (item.subject) lines.push(`Subject: ${item.subject}`);
+  lines.push(`Timestamp: ${item.timestamp || new Date().toISOString()}`);
+  if (item.is_reply) lines.push(`Is reply: yes`);
+  if (item.thread_id) lines.push(`Thread ID: ${item.thread_id}`);
+  if (item.raw_ref) lines.push(`Reference: ${item.raw_ref}`);
+  lines.push("");
+
+  if (item.thread_context) {
+    lines.push("Thread context:");
+    lines.push(item.thread_context);
+    lines.push("");
+  }
+
+  lines.push("Message content:");
+  lines.push(item.content || "(empty)");
+  lines.push("--- END MESSAGE ---");
+
+  return lines.join("\n");
+}
+
+/**
+ * Build the item context block for backlog queue items
+ */
+function buildBacklogContext(queueItem) {
+  const lines = [];
+  lines.push("--- QUEUE ITEM ---");
+  lines.push(`ID: ${queueItem.id || "unknown"}`);
+  lines.push(`Title: ${queueItem.title || "untitled"}`);
+  lines.push(`Status: ${queueItem.status || "open"}`);
+  lines.push(`Priority: ${queueItem.priority || "normal"}`);
+  lines.push(`Owner: ${queueItem.owner || "sophie"}`);
+  if (queueItem.source) lines.push(`Source: ${queueItem.source}`);
+  if (queueItem.source_ref) lines.push(`Source ref: ${queueItem.source_ref}`);
+  if (queueItem.due) lines.push(`Due: ${queueItem.due}`);
+  if (queueItem.sla_deadline) lines.push(`SLA deadline: ${queueItem.sla_deadline}`);
+  lines.push("");
+
+  if (queueItem.context) {
+    lines.push("Context:");
+    lines.push(queueItem.context);
+    lines.push("");
+  }
+
+  if (queueItem.next_action) {
+    lines.push("Next action required:");
+    lines.push(queueItem.next_action);
+    lines.push("");
+  }
+
+  if (queueItem.blocked_by) {
+    lines.push(`Blocked by: ${queueItem.blocked_by}`);
+    lines.push("");
+  }
+
+  if (queueItem.success_criteria) {
+    lines.push("Success criteria:");
+    if (Array.isArray(queueItem.success_criteria)) {
+      for (const c of queueItem.success_criteria) lines.push(`- ${c}`);
+    } else {
+      lines.push(queueItem.success_criteria);
+    }
+    lines.push("");
+  }
+
+  // Include recent history for context
+  if (queueItem.history && Array.isArray(queueItem.history) && queueItem.history.length > 0) {
+    const recent = queueItem.history.slice(-3);
+    lines.push("Recent history:");
+    for (const h of recent) {
+      lines.push(`  [${h.timestamp}] ${h.action} (by ${h.by || "unknown"})`);
+    }
+    lines.push("");
+  }
+
+  lines.push("--- END QUEUE ITEM ---");
+  return lines.join("\n");
+}
+
+/**
+ * Build a focused prompt for a claude --print session.
+ *
+ * @param {object} item - The inbox item (sender, content, channel, service, subject, thread_context, etc.)
+ * @param {object} classResult - Classifier output (priority, action, model, summary, category)
+ * @param {object} options - { type: "inbox" | "backlog", queueItem?: object }
+ * @returns {string} Prompt string ready for claude --print
+ */
+export async function buildPrompt(item, classResult, options = {}) {
+  const { type = "inbox", queueItem, holdingMessage } = options;
+  const preamble = loadPreamble();
+  const action = classResult.action || "respond";
+  const actionBlock = ACTION_INSTRUCTIONS[action] || ACTION_INSTRUCTIONS.respond;
+  const date = today();
+
+  const parts = [];
+
+  // 1. Identity preamble (cached)
+  parts.push(preamble);
+  parts.push("");
+
+  // 2. Session context
+  parts.push(`Date: ${date}`);
+  parts.push(`Classification: priority=${classResult.priority}, action=${action}, category=${classResult.category || "unclassified"}`);
+  parts.push(`Summary: ${classResult.summary || "No summary"}`);
+  parts.push("");
+
+  // 3. Item context — inbox or backlog
+  if (type === "backlog" && queueItem) {
+    parts.push(buildBacklogContext(queueItem));
+  } else {
+    parts.push(buildInboxContext(item));
+  }
+  parts.push("");
+
+  // 4. Compiled context (profile + history + disclosure boundaries + active sessions + sent messages)
+  if (process.env.DAEMON_CONTEXT_COMPILER === "1" && (type === "inbox" ? item : true)) {
+    try {
+      const { contextBlock } = await compileContext(
+        item || {},
+        classResult,
+        { type }
+      );
+      parts.push(contextBlock);
+      parts.push("");
+    } catch (err) {
+      console.error(`[prompt-builder] Context compilation failed: ${err.message}`);
+      // Fall through to legacy behaviour
+      if (type === "inbox" && item) {
+        const history = loadConversationHistory(item);
+        if (history) { parts.push(history); parts.push(""); }
+      }
+    }
+  } else if (type === "inbox" && item) {
+    // Legacy path (feature flag off)
+    const history = loadConversationHistory(item);
+    if (history) { parts.push(history); parts.push(""); }
+  }
+
+  // 5. Action instructions
+  parts.push(actionBlock);
+  parts.push("");
+
+  // 6. User profile lookup — legacy only (when feature flag is off, profile is in compiled context)
+  if (process.env.DAEMON_CONTEXT_COMPILER !== "1" && type === "inbox" && item && item.sender) {
+    const profileName = item.sender.replace(/\s+/g, "-").toLowerCase();
+    parts.push(`Before responding, read memory/profiles/users/${profileName}.yaml for sender preferences, standing instructions, and relationship context. If the file does not exist, proceed without it.`);
+    parts.push("");
+  }
+
+  // 7. Backlog-specific: queue update instructions
+  if (type === "backlog" && queueItem) {
+    parts.push(`When this task is complete:
+- Update the queue item status to "resolved" in the appropriate state/queues/ file
+- Add a history entry with timestamp, action taken, and by: sophie-daemon
+- If the task cannot be completed, set status to "blocked" and record what is blocking it`);
+    parts.push("");
+  }
+
+  // 8. Holding message context (if one was already sent)
+  if (holdingMessage) {
+    parts.push(`IMPORTANT: A holding message has ALREADY been sent to the sender. Do NOT send another acknowledgment. The message sent was:`);
+    parts.push(`"${holdingMessage}"`);
+    parts.push(`Now deliver the actual substantive response or complete the requested work. The sender is expecting the real answer, not another "I'm looking into it."`);
+    parts.push("");
+  }
+
+  // 9. Audit instruction
+  parts.push(`Log all actions taken to logs/audit/${date}-actions.jsonl as a JSON line with: timestamp, action_type, target, result, session context.`);
+
+  return parts.join("\n");
+}