@cohortapp/agent-sdk 2.3.0

package/scripts/huddle/test-pipeline.mjs

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+/**
+ * Maestro Huddle — Pipeline Test
+ *
+ * Verifies each component of the huddle pipeline:
+ *   1. CDP connection to Slack
+ *   2. DOM selector verification
+ *   3. Keyboard navigation
+ *   4. Audio device availability
+ *   5. Deepgram API connectivity
+ *   6. ElevenLabs API connectivity
+ *   7. Claude API connectivity
+ */
+
+import dotenv from "dotenv";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __test_dir = dirname(fileURLToPath(import.meta.url));
+dotenv.config({ path: join(__test_dir, "../..", ".env") });
+dotenv.config({ path: join(__test_dir, ".env"), override: true });
+import { HuddleController } from "./huddle-controller.mjs";
+import { AudioBridge } from "./audio-bridge.mjs";
+
+const results = [];
+function pass(name, detail = "") {
+  results.push({ name, status: "PASS", detail });
+  console.log(`  ✓ ${name}${detail ? ` — ${detail}` : ""}`);
+}
+function fail(name, detail = "") {
+  results.push({ name, status: "FAIL", detail });
+  console.log(`  ✗ ${name}${detail ? ` — ${detail}` : ""}`);
+}
+function skip(name, detail = "") {
+  results.push({ name, status: "SKIP", detail });
+  console.log(`  ○ ${name}${detail ? ` — ${detail}` : ""}`);
+}
+
+async function main() {
+  console.log("\n==========================================");
+  console.log("  Maestro Huddle — Pipeline Test");
+  console.log("  " + new Date().toISOString());
+  console.log("==========================================\n");
+
+  // ── 1. CDP Connection ──────────────────────────────────────────────────
+  console.log("1. CDP Connection");
+  const controller = new HuddleController();
+  let cdpConnected = false;
+
+  try {
+    const resp = await fetch("http://localhost:9222/json/version");
+    if (resp.ok) {
+      const version = await resp.json();
+      pass("CDP endpoint reachable", `Browser: ${version.Browser}`);
+    } else {
+      fail("CDP endpoint", `Status: ${resp.status}`);
+    }
+  } catch (err) {
+    fail("CDP endpoint", err.message);
+  }
+
+  try {
+    cdpConnected = await controller.connect();
+    if (cdpConnected) {
+      pass("CDP WebSocket connected");
+    } else {
+      fail("CDP WebSocket connection");
+    }
+  } catch (err) {
+    fail("CDP WebSocket", err.message);
+  }
+
+  // ── 2. DOM Selector Verification ───────────────────────────────────────
+  console.log("\n2. DOM Selectors");
+
+  if (cdpConnected) {
+    try {
+      const hasHuddleBtn = await controller._evaluate(`
+        !!document.querySelector('[data-qa="huddle_channel_header_button__start_button"]')
+      `);
+      if (hasHuddleBtn) {
+        pass("Huddle start button found", "data-qa='huddle_channel_header_button__start_button'");
+      } else {
+        skip("Huddle start button", "Not in channel view — navigate to a channel first");
+      }
+    } catch (err) {
+      fail("Huddle start button check", err.message);
+    }
+
+    try {
+      const workspace = await controller._evaluate(`
+        (() => {
+          const ws = document.querySelector('div.p-huddle_workspace[role="dialog"]');
+          return ws ? { found: true, children: ws.children.length } : { found: false };
+        })()
+      `);
+      if (workspace?.found) {
+        pass("Huddle workspace element", `children: ${workspace.children} (0 = no active huddle)`);
+      } else {
+        fail("Huddle workspace element not found");
+      }
+    } catch (err) {
+      fail("Huddle workspace check", err.message);
+    }
+
+    try {
+      const audioEl = await controller._evaluate(`
+        !!document.querySelector('audio[data-qa="p-huddle_audio"]')
+      `);
+      if (audioEl) {
+        pass("Huddle audio element found", "audio[data-qa='p-huddle_audio']");
+      } else {
+        fail("Huddle audio element");
+      }
+    } catch (err) {
+      fail("Huddle audio element check", err.message);
+    }
+
+    // Check huddle active state
+    try {
+      const isActive = await controller.isInHuddle();
+      pass("Huddle state check", `Currently in huddle: ${isActive}`);
+    } catch (err) {
+      fail("Huddle state check", err.message);
+    }
+  } else {
+    skip("DOM selectors", "CDP not connected");
+  }
+
+  // ── 3. Keyboard Navigation ─────────────────────────────────────────────
+  console.log("\n3. Keyboard Navigation");
+
+  if (cdpConnected) {
+    try {
+      // Test Cmd+K quick switcher
+      await controller._sendKeyCombo("k", ["Meta"]);
+      await new Promise(r => setTimeout(r, 600));
+
+      // Check if quick switcher opened
+      const switcherOpen = await controller._evaluate(`
+        !!document.querySelector('[data-qa="channel_browser_modal"], [class*="quick_switcher"], [class*="QuickSwitcher"]')
+      `);
+
+      // Close it with Escape
+      await controller._sendKey("Escape");
+      await new Promise(r => setTimeout(r, 300));
+
+      if (switcherOpen) {
+        pass("Cmd+K quick switcher", "Opens and closes correctly");
+      } else {
+        // Switcher may have a different selector — test by checking if focus changed
+        pass("Cmd+K dispatched", "Key event sent (switcher selector may differ)");
+      }
+    } catch (err) {
+      fail("Cmd+K test", err.message);
+    }
+  } else {
+    skip("Keyboard navigation", "CDP not connected");
+  }
+
+  // ── 4. Audio Devices ──────────────────────────────────────────────────
+  console.log("\n4. Audio Devices");
+
+  const bridge = new AudioBridge();
+  const devices = await bridge.checkDevices();
+
+  if (devices.capture) {
+    pass("Capture device (BlackHole 2ch)");
+  } else {
+    fail("Capture device (BlackHole 2ch)", "Not found — run: sudo brew install --cask blackhole-2ch");
+  }
+
+  if (devices.playback) {
+    pass("Playback device (BlackHole 16ch)");
+  } else {
+    fail("Playback device (BlackHole 16ch)", "Not found — run: sudo brew install --cask blackhole-16ch");
+  }
+
+  // ── 5. Deepgram API ────────────────────────────────────────────────────
+  console.log("\n5. Deepgram API");
+
+  if (process.env.DEEPGRAM_API_KEY) {
+    try {
+      const resp = await fetch("https://api.deepgram.com/v1/projects", {
+        headers: { Authorization: `Token ${process.env.DEEPGRAM_API_KEY}` },
+      });
+      if (resp.ok) {
+        pass("Deepgram API key valid");
+      } else {
+        fail("Deepgram API", `Status: ${resp.status}`);
+      }
+    } catch (err) {
+      fail("Deepgram API", err.message);
+    }
+  } else {
+    fail("Deepgram API key", "DEEPGRAM_API_KEY not set in .env");
+  }
+
+  // ── 6. ElevenLabs API ──────────────────────────────────────────────────
+  console.log("\n6. ElevenLabs API");
+
+  if (process.env.ELEVENLABS_API_KEY) {
+    try {
+      const resp = await fetch("https://api.elevenlabs.io/v1/user", {
+        headers: { "xi-api-key": process.env.ELEVENLABS_API_KEY },
+      });
+      if (resp.ok) {
+        const user = await resp.json();
+        pass("ElevenLabs API key valid", `Plan: ${user.subscription?.tier || "unknown"}`);
+      } else {
+        fail("ElevenLabs API", `Status: ${resp.status}`);
+      }
+    } catch (err) {
+      fail("ElevenLabs API", err.message);
+    }
+  } else {
+    fail("ElevenLabs API key", "ELEVENLABS_API_KEY not set in .env");
+  }
+
+  // ── 7. Claude API ─────────────────────────────────────────────────────
+  console.log("\n7. Claude API");
+
+  if (process.env.ANTHROPIC_API_KEY) {
+    try {
+      const { default: Anthropic } = await import("@anthropic-ai/sdk");
+      const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+      const resp = await client.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 20,
+        messages: [{ role: "user", content: "Say 'huddle test ok' in exactly 3 words." }],
+      });
+      const text = resp.content[0]?.text || "";
+      pass("Claude API", `Response: "${text.trim()}"`);
+    } catch (err) {
+      fail("Claude API", err.message);
+    }
+  } else {
+    fail("Claude API key", "ANTHROPIC_API_KEY not set in .env");
+  }
+
+  // ── Summary ──────────────────────────────────────────────────────────
+  console.log("\n==========================================");
+  const passed = results.filter(r => r.status === "PASS").length;
+  const failed = results.filter(r => r.status === "FAIL").length;
+  const skipped = results.filter(r => r.status === "SKIP").length;
+  console.log(`  Results: ${passed} passed, ${failed} failed, ${skipped} skipped`);
+
+  if (failed === 0) {
+    console.log("  Status: GREEN — pipeline ready");
+  } else {
+    console.log("  Status: BLOCKED — fix failures above");
+  }
+  console.log("==========================================\n");
+
+  // Clean up
+  await controller.disconnect();
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch((err) => {
+  console.error(`Test error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/learning/consolidate-skills.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * scripts/learning/consolidate-skills.mjs — the detached LLM consolidation
+ * worker (WS3 phase 2). This is what the `skill-curator` cadence guard spawns as
+ * a DETACHED, unref'd child (mirroring the collective capture worker) when an
+ * umbrella-consolidation pass is DUE — it is NOT a nested sub-session.
+ *
+ * It resolves the agent root from env and calls
+ * lib/learning/curator.consolidateUmbrellas(), which merges narrowly-overlapping
+ * agent-authored skills into class-level umbrellas via one bounded `claude
+ * --print` call. Fully fail-open: any error → log + exit 0; never throws, never
+ * blocks the daemon (the guard already returned `inline` before this ran).
+ *
+ * Agent root: $MAESTRO_CONSOLIDATE_ROOT / $AGENT_ROOT / $AGENT_DIR / cwd.
+ *
+ * Usage (normally invoked by the guard, not by hand):
+ *   node scripts/learning/consolidate-skills.mjs
+ *
+ * @module scripts/learning/consolidate-skills
+ */
+
+"use strict";
+
+function agentRoot() {
+  return process.env.MAESTRO_CONSOLIDATE_ROOT || process.env.AGENT_ROOT || process.env.AGENT_DIR || process.cwd();
+}
+
+function log(msg) {
+  try { process.stdout.write(`[consolidate-skills] ${msg}\n`); } catch { /* */ }
+}
+
+async function main() {
+  const root = agentRoot();
+  try {
+    // Load the learning config so the consolidation knobs (minSkills, model,
+    // enabled) come from config/learning.yaml; fall back to curator defaults.
+    let minSkills, model, enabled = true;
+    try {
+      const cfgMod = await import("../../lib/learning/config.mjs");
+      const collMod = await import("../../lib/collective/config.mjs");
+      const coll = await collMod.loadConfig(root);
+      const cfg = await cfgMod.loadLearningConfig(root, coll);
+      const c = cfg && cfg.consolidation ? cfg.consolidation : {};
+      enabled = c.enabled !== false && cfg.enabled !== false;
+      if (Number.isFinite(c.minSkills)) minSkills = c.minSkills;
+      if (typeof c.model === "string" && c.model) model = c.model;
+    } catch { /* fall back to curator defaults */ }
+
+    if (!enabled) {
+      log("consolidation disabled — no-op");
+      return;
+    }
+
+    const { consolidateUmbrellas } = await import("../../lib/learning/curator.mjs");
+    const res = await consolidateUmbrellas({ agentRoot: root, minSkills, model });
+
+    if (res.error) {
+      log(`fail-open: ${res.error}`);
+    } else if (res.reason) {
+      log(`no consolidation (${res.reason})`);
+    } else {
+      const n = (res.umbrellas || []).length;
+      const absorbed = (res.umbrellas || []).reduce((s, u) => s + (u.absorbed ? u.absorbed.length : 0), 0);
+      log(`consolidated ${n} umbrella(s), absorbed ${absorbed} skill(s)`);
+    }
+  } catch (e) {
+    // Absolute fail-open at the process boundary.
+    log(`error: ${e && e.message ? e.message : String(e)}`);
+  }
+}
+
+main().then(() => process.exit(0)).catch(() => process.exit(0));

package/scripts/learning/session-search.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * scripts/learning/session-search.mjs — CLI over lib/learning/session-index.
+ *
+ * Verbatim recall of the agent's own past sessions (the on-demand complement to
+ * the budgeted SessionStart card digest). Four modes, ported from Hermes:
+ *
+ *   discovery (default) — bm25-ranked turns matching a query, each with a snippet
+ *                         and a per-session BOOKEND (first + last turn for
+ *                         orientation). This is how you FIND a past session.
+ *   scroll              — a window of ±N turns around a (session, seq) anchor.
+ *                         How you read AROUND a discovery hit.
+ *   read                — every turn of one session, in order. The full record.
+ *   browse              — the most-recent sessions (metadata), newest first.
+ *
+ * Also: `ingest` to (re)build the index from logs/sessions/*.jsonl.
+ *
+ * Usage:
+ *   node scripts/learning/session-search.mjs "duplicate charge anomaly"
+ *   node scripts/learning/session-search.mjs --mode=scroll --session=<id> --seq=42 --window=6
+ *   node scripts/learning/session-search.mjs --mode=read --session=<id>
+ *   node scripts/learning/session-search.mjs --mode=browse [--top=20]
+ *   node scripts/learning/session-search.mjs ingest
+ *
+ * Agent root: $AGENT_ROOT / $AGENT_DIR / cwd.
+ *
+ * @module scripts/learning/session-search
+ */
+
+"use strict";
+
+import { parseArgs } from "node:util";
+import { search, ingestAll } from "../../lib/learning/session-index.mjs";
+
+function agentRoot() {
+  return process.env.AGENT_ROOT || process.env.AGENT_DIR || process.cwd();
+}
+
+function clip(s, n = 220) {
+  const t = String(s || "").replace(/\s+/g, " ").trim();
+  return t.length <= n ? t : t.slice(0, n) + "…";
+}
+
+function printTurn(t, prefix = "  ") {
+  if (!t) return;
+  console.log(`${prefix}[${t.seq}] ${t.role}: ${clip(t.body)}`);
+}
+
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    strict: false,
+    options: {
+      mode: { type: "string" },
+      session: { type: "string" },
+      seq: { type: "string" },
+      window: { type: "string" },
+      top: { type: "string" },
+      json: { type: "boolean", default: false },
+    },
+  });
+
+  const verb = positionals[0];
+  if (verb === "ingest") {
+    const res = await ingestAll({ agentRoot: agentRoot(), force: !!values.force });
+    console.log(`[session-search] ingest: ${res.added} added, ${res.updated} updated, ${res.skipped} skipped (${res.files} files)`);
+    return 0;
+  }
+
+  const mode = values.mode || "discovery";
+  const query = positionals.join(" ").trim();
+  const opts = {
+    agentRoot: agentRoot(),
+    mode,
+    sessionId: values.session,
+    seq: values.seq != null ? parseInt(values.seq, 10) : undefined,
+    window: values.window != null ? parseInt(values.window, 10) : undefined,
+    topN: values.top != null ? parseInt(values.top, 10) : undefined,
+  };
+
+  const res = await search(query, opts);
+
+  if (values.json) { console.log(JSON.stringify(res, null, 2)); return 0; }
+
+  if (res.mode === "discovery") {
+    if (!res.hits.length) { console.log("(no matching sessions)"); return 0; }
+    let lastSession = null;
+    for (const h of res.hits) {
+      if (h.session_id !== lastSession) {
+        lastSession = h.session_id;
+        console.log(`\n● session ${h.session_id}`);
+        if (h.bookend) {
+          if (h.bookend.first) console.log(`  ┌ first ${clip(h.bookend.first.body, 120)}`);
+          if (h.bookend.last) console.log(`  └ last  ${clip(h.bookend.last.body, 120)}`);
+        }
+      }
+      console.log(`    ↳ turn ${h.seq} (${h.role}): ${clip(h.snippet, 200)}`);
+    }
+    return 0;
+  }
+
+  if (res.mode === "read" || res.mode === "scroll") {
+    if (!res.turns.length) { console.log("(no turns)"); return 0; }
+    console.log(`● ${res.mode} — session ${res.sessionId}${res.anchor != null ? ` around seq ${res.anchor} (±${res.window})` : ""}`);
+    for (const t of res.turns) printTurn(t);
+    return 0;
+  }
+
+  if (res.mode === "browse") {
+    if (!res.sessions.length) { console.log("(no sessions indexed — run `session-search ingest`)"); return 0; }
+    for (const s of res.sessions) {
+      console.log(`● ${s.session_id} — ${s.turn_count} turns, last ${s.last_ts || "?"}`);
+    }
+    return 0;
+  }
+
+  console.log(JSON.stringify(res, null, 2));
+  return 0;
+}
+
+main().then((c) => process.exit(c || 0)).catch((e) => {
+  console.error(`[session-search] ${e && e.message ? e.message : e}`);
+  process.exit(1);
+});