@hienlh/ppm 0.17.14 → 0.17.16

package/spike-group-channel.mjs

@@ -1,156 +0,0 @@
-// Feasibility spike v2 — shared-channel group DISCUSSION (member<->member).
-// Throwaway diagnostic. Mirrors test-tool.mjs (direct provider, no DB/UI).
-//
-// Implements the agreed model:
-//   - shared broadcast channel (in-memory bus) — all agents see it
-//   - windowed context injection (last K messages) per turn
-//   - speaker selection: @mention-driven, leader as fallback facilitator
-//   - talk = sequential turns; termination = leader "DONE:" OR max-turns cap OR budget-ish (turn cap)
-//   - prints the full GROUP CHAT HISTORY at the end (what the user asked to see)
-//
-// Usage:  bun spike-group-channel.mjs [projectPath] [--turns N] [--keep]
-
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { readdir, mkdir, copyFile, rm, stat } from "node:fs/promises";
-import { ClaudeAgentSdkProvider } from "./src/providers/claude-agent-sdk.ts";
-import { configService } from "./src/services/config.service.ts";
-
-configService.load();
-delete process.env.CLAUDECODE;
-
-const projectPath = process.argv.find((a, i) => i >= 2 && !a.startsWith("--")) || process.cwd();
-const KEEP = process.argv.includes("--keep");
-const turnsArg = process.argv.indexOf("--turns");
-const MAX_TURNS = turnsArg > -1 ? Number(process.argv[turnsArg + 1]) : 8;
-const WINDOW = 8; // inject last N channel messages
-const TIMEOUT_MS = 120_000;
-const CLAUDE_PROJECTS = join(homedir(), ".claude", "projects");
-const ARCHIVE_DIR = join(homedir(), ".ppm", "teams", "spike", "transcripts");
-
-const provider = new ClaudeAgentSdkProvider();
-const opts = { permissionMode: "bypassPermissions" };
-
-// The group. Leader is a normal participant that also facilitates + finalizes.
-const TEAM = [
-  { name: "lead", role: "the team LEAD. You kick off, keep discussion on track, and are the ONLY one who may finalize." },
-  { name: "alice", role: "a backend engineer who favors simple, minimal schemas (YAGNI)." },
-  { name: "bob", role: "a backend engineer who worries about query flexibility and future needs." },
-];
-
-const TASK =
-  "Agree on how to store the group-chat message bus in PPM: ONE single SQLite table, " +
-  "or SEPARATE tables per concern. Discuss briefly, then lead finalizes with the decision + 1 reason.";
-
-const sessions = {}; // name -> session
-const channel = []; // { from, to, text }
-
-function log(...a) { console.log(...a); }
-function hr(t) { log("\n" + "=".repeat(64) + "\n" + t + "\n" + "=".repeat(64)); }
-
-async function run(sessionId, prompt) {
-  const abort = new AbortController();
-  const timer = setTimeout(() => abort.abort(), TIMEOUT_MS);
-  let full = "", error = null;
-  try {
-    for await (const ev of provider.sendMessage(sessionId, prompt, { ...opts, signal: abort.signal })) {
-      if (abort.signal.aborted) break;
-      if (ev.type === "text") full += ev.content ?? "";
-      else if (ev.type === "error") error = ev.message;
-      else if (ev.type === "done") break;
-    }
-  } catch (e) { error = e instanceof Error ? e.message : String(e); }
-  clearTimeout(timer);
-  return { text: full.trim(), error };
-}
-
-function windowed() {
-  return channel.slice(-WINDOW)
-    .map((m) => `${m.from} -> ${m.to}: ${m.text}`)
-    .join("\n") || "(channel empty)";
-}
-
-function turnPrompt(member, isFinalForced) {
-  const others = TEAM.filter((t) => t.name !== member.name).map((t) => t.name).join(", ");
-  return (
-    `You are "${member.name}", ${member.role}\n` +
-    `Team task: ${TASK}\n\n` +
-    `TEAM CHANNEL (recent, others: ${others}):\n${windowed()}\n\n` +
-    `Reply as ${member.name} in MAX 2 sentences. Address a teammate with @name (e.g. @bob).\n` +
-    (member.name === "lead"
-      ? (isFinalForced
-          ? `You MUST finalize now: start your message with "DONE:" then the decision + 1 reason.`
-          : `If the team has converged, start with "DONE:" then the decision + 1 reason. Otherwise steer the discussion and @ someone.`)
-      : `Do NOT write "DONE:" — only lead finalizes.`)
-  );
-}
-
-// pick next speaker from an @mention in text; else fall back to lead.
-function nextSpeaker(text, current) {
-  const names = TEAM.map((t) => t.name);
-  const m = text.toLowerCase().match(/@(\w+)/);
-  if (m && names.includes(m[1]) && m[1] !== current) return m[1];
-  return current === "lead" ? "alice" : "lead"; // fallback keeps it moving
-}
-
-async function findJsonl(id) {
-  let dirs = [];
-  try { dirs = await readdir(CLAUDE_PROJECTS); } catch { return null; }
-  for (const d of dirs) {
-    const p = join(CLAUDE_PROJECTS, d, `${id}.jsonl`);
-    try { await stat(p); return p; } catch {}
-  }
-  return null;
-}
-async function archiveAndDelete(id) {
-  const src = await findJsonl(id);
-  if (!src) return;
-  await mkdir(ARCHIVE_DIR, { recursive: true });
-  await copyFile(src, join(ARCHIVE_DIR, `${id}.jsonl`));
-  await rm(src, { force: true });
-}
-
-// ---------------------------------------------------------------------------
-hr(`SPIKE v2: shared-channel group discussion | project=${projectPath} | maxTurns=${MAX_TURNS}`);
-
-for (const m of TEAM) {
-  sessions[m.name] = await provider.createSession({ title: `spike-${m.name}`, projectPath });
-  log(`  ${m.name} session: ${sessions[m.name].id}`);
-}
-
-let speaker = "lead";
-let done = false;
-for (let turn = 1; turn <= MAX_TURNS && !done; turn++) {
-  const member = TEAM.find((t) => t.name === speaker);
-  const forceFinal = turn === MAX_TURNS && speaker === "lead";
-  const { text, error } = await run(sessions[speaker].id, turnPrompt(member, forceFinal));
-  if (error) { log(`\n[turn ${turn}] ${speaker} ERROR: ${error}`); break; }
-
-  const isDone = speaker === "lead" && /^\s*DONE:/i.test(text);
-  const to = (text.match(/@(\w+)/) || [])[1] || "all";
-  channel.push({ from: speaker, to: isDone ? "all" : to, text });
-  log(`\n[turn ${turn}] ${speaker} -> ${isDone ? "all" : to}:\n  ${text.replace(/\n/g, "\n  ")}`);
-
-  if (isDone) { done = true; break; }
-
-  // If max-turns is about to hit and lead hasn't spoken, force lead next to finalize.
-  speaker = (turn === MAX_TURNS - 1) ? "lead" : nextSpeaker(text, speaker);
-}
-
-if (!done) log("\n(!) discussion hit turn cap without explicit DONE — see last lead message");
-
-// ---- what the user asked to see: the group chat history ----
-hr("GROUP CHAT HISTORY (channel transcript)");
-for (const m of channel) {
-  log(`[${m.from} -> ${m.to}] ${m.text}`);
-  log("");
-}
-
-// ---- Option A+ cleanup (proves clean-up path again) ----
-if (!KEEP) {
-  hr("Option A+ archive-and-delete");
-  for (const m of TEAM) { await archiveAndDelete(sessions[m.name].id); }
-  log(`archived to ${ARCHIVE_DIR}, raw JSONL removed from ~/.claude/projects`);
-}
-
-hr(`RESULT: ${done ? "CONVERGED with leader DONE" : "capped"} | ${channel.length} messages | member<->member exchange demonstrated`);

package/spike-group-chat.mjs

@@ -1,181 +0,0 @@
-// Feasibility spike for the native PPM group-chat engine.
-// Throwaway diagnostic — NOT production code. Mirrors test-tool.mjs (direct provider, no DB/UI).
-//
-// Proves, headless & real (no mocks):
-//   1. Parallel multi-agent: 1 leader + N member sessions on the SAME project cwd.
-//   2. Leader-driven task split -> dispatch to members -> collect (the orchestration loop).
-//   3. Summary-vs-full (#2): capture short summary for the feed + full text kept aside.
-//   4. Option A+ (#3): archive each member JSONL to ~/.ppm/teams/<group>/transcripts/,
-//      then delete the raw JSONL from ~/.claude/projects so CLI/VSCode stay clean.
-//   5. Synthesis: feed member summaries back to the leader for a final group answer.
-//
-// Usage:  bun spike-group-chat.mjs [projectPath] [--keep]
-//   --keep : skip the archive+delete step (leave raw JSONLs in place)
-
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-import { readdir, mkdir, copyFile, rm, stat } from "node:fs/promises";
-import { ClaudeAgentSdkProvider } from "./src/providers/claude-agent-sdk.ts";
-import { configService } from "./src/services/config.service.ts";
-
-configService.load();
-delete process.env.CLAUDECODE; // avoid nested-session error
-
-const projectPath = process.argv.find((a, i) => i >= 2 && !a.startsWith("--")) || process.cwd();
-const KEEP = process.argv.includes("--keep");
-const GROUP = "spike";
-const CLAUDE_PROJECTS = join(homedir(), ".claude", "projects");
-const ARCHIVE_DIR = join(homedir(), ".ppm", "teams", GROUP, "transcripts");
-const TIMEOUT_MS = 180_000;
-
-const provider = new ClaudeAgentSdkProvider();
-const opts = { permissionMode: "bypassPermissions" };
-const results = {}; // criterion -> boolean
-
-// The user's "task" given to the group.
-const TASK =
-  "Working from the CLAUDE.md in this project, report two facts: (a) the runtime used, " +
-  "(b) the command to run tests.";
-
-function log(...a) { console.log(...a); }
-function hr(t) { log("\n" + "=".repeat(64) + "\n" + t + "\n" + "=".repeat(64)); }
-
-// Run one prompt on a session, capture summary (last assistant text) + full text.
-async function run(sessionId, prompt) {
-  const abort = new AbortController();
-  const timer = setTimeout(() => abort.abort(), TIMEOUT_MS);
-  let full = "", last = "", error = null;
-  try {
-    for await (const ev of provider.sendMessage(sessionId, prompt, { ...opts, signal: abort.signal })) {
-      if (abort.signal.aborted) break;
-      if (ev.type === "text") { last = ev.content ?? ""; full += ev.content ?? ""; }
-      else if (ev.type === "error") { error = ev.message; }
-      else if (ev.type === "done") break;
-    }
-  } catch (e) { error = e instanceof Error ? e.message : String(e); }
-  clearTimeout(timer);
-  return { summary: (last || full).trim().slice(0, 400), full: full.trim(), error };
-}
-
-// Locate <sessionId>.jsonl anywhere under ~/.claude/projects (avoids slug guessing).
-async function findJsonl(sessionId) {
-  let dirs = [];
-  try { dirs = await readdir(CLAUDE_PROJECTS); } catch { return null; }
-  for (const d of dirs) {
-    const p = join(CLAUDE_PROJECTS, d, `${sessionId}.jsonl`);
-    try { await stat(p); return p; } catch { /* keep looking */ }
-  }
-  return null;
-}
-
-// Option A+: archive JSONL to PPM store, then delete the raw file.
-async function archiveAndDelete(sessionId) {
-  const src = await findJsonl(sessionId);
-  if (!src) return { archived: false, deleted: false, reason: "raw JSONL not found" };
-  await mkdir(ARCHIVE_DIR, { recursive: true });
-  const dest = join(ARCHIVE_DIR, `${sessionId}.jsonl`);
-  await copyFile(src, dest);
-  const archived = await stat(dest).then(() => true).catch(() => false);
-  await rm(src, { force: true });
-  const stillThere = await stat(src).then(() => true).catch(() => false);
-  return { archived, deleted: !stillThere, dest };
-}
-
-// ---------------------------------------------------------------------------
-hr(`SPIKE: native group-chat engine  |  project=${projectPath}  |  keep=${KEEP}`);
-
-// --- Criterion 1 + 2: leader session decides the work split -----------------
-hr("STEP 1 — Leader splits the task");
-const leader = await provider.createSession({ title: "spike-leader", projectPath });
-log(`leader session: ${leader.id}`);
-
-const splitPrompt =
-  `You are the LEADER of an agent team on this project. User task:\n"${TASK}"\n\n` +
-  `Split it into EXACTLY 2 independent subtasks. Reply with ONLY two lines, no preamble:\n` +
-  `M1: <subtask one>\nM2: <subtask two>`;
-const split = await run(leader.id, splitPrompt);
-log("leader raw:\n" + split.full);
-
-let subtasks = split.full
-  .split("\n")
-  .map((l) => l.replace(/^M\d+:\s*/i, "").trim())
-  .filter((l) => l && /subtask|report|find|read|runtime|test|command|CLAUDE/i.test(l))
-  .slice(0, 2);
-if (subtasks.length < 2) {
-  log("!! parse fallback — leader output not in expected format, using default split");
-  subtasks = [
-    "Read CLAUDE.md and report ONLY the runtime used. One sentence.",
-    "Read CLAUDE.md and report ONLY the command to run tests. One sentence.",
-  ];
-}
-results["1_leader_split"] = subtasks.length === 2;
-log("subtasks:", subtasks);
-
-// --- Criterion 1 (parallel) + 3 (summary/full): members work concurrently ---
-hr("STEP 2 — Members work in parallel (own sessions)");
-const members = await Promise.all(
-  subtasks.map((_, i) => provider.createSession({ title: `spike-m${i + 1}`, projectPath })),
-);
-members.forEach((m, i) => log(`member${i + 1} session: ${m.id}`));
-
-const memberRuns = await Promise.all(
-  subtasks.map((st, i) =>
-    run(members[i].id, `${st}\n\nReply with a 1-2 sentence summary only.`),
-  ),
-);
-
-results["2_parallel_members"] = memberRuns.every((r) => !r.error);
-results["3_summary_vs_full"] = memberRuns.every((r) => r.summary.length > 0 && r.full.length >= r.summary.length);
-memberRuns.forEach((r, i) => {
-  log(`\n--- member${i + 1} ---`);
-  if (r.error) log(`  ERROR: ${r.error}`);
-  log(`  FEED (summary): ${r.summary}`);
-  log(`  FULL kept aside: ${r.full.length} chars (hidden from feed)`);
-});
-
-// --- Criterion 4: Option A+ archive-and-delete ------------------------------
-hr("STEP 3 — Option A+ archive-and-delete member transcripts");
-let aPlusOk = true;
-if (KEEP) {
-  log("(--keep) skipping archive/delete");
-  aPlusOk = false;
-} else {
-  for (const m of members) {
-    const res = await archiveAndDelete(m.id);
-    log(`member ${m.id}: archived=${res.archived} deleted=${res.deleted}` + (res.reason ? ` (${res.reason})` : ""));
-    if (!res.archived || !res.deleted) aPlusOk = false;
-  }
-  log(`archive dir: ${ARCHIVE_DIR}`);
-}
-results["4_archive_delete"] = aPlusOk;
-
-// --- Criterion 5: leader synthesizes member summaries -----------------------
-hr("STEP 4 — Leader synthesizes final group answer");
-const synthPrompt =
-  `Your members reported:\n` +
-  memberRuns.map((r, i) => `- member${i + 1}: ${r.summary}`).join("\n") +
-  `\n\nSynthesize a short final answer to the user's task.`;
-const synth = await run(leader.id, synthPrompt);
-log("FINAL group answer:\n" + synth.summary);
-results["5_synthesis"] = !synth.error && synth.summary.length > 0;
-
-// Clean up leader too (it created a JSONL).
-if (!KEEP) { await archiveAndDelete(leader.id).catch(() => {}); }
-
-// --- Verdict ----------------------------------------------------------------
-hr("VERDICT");
-const labels = {
-  "1_leader_split": "Leader splits task into subtasks",
-  "2_parallel_members": "Members run in parallel (own sessions)",
-  "3_summary_vs_full": "Summary (feed) vs full (hidden) captured",
-  "4_archive_delete": "Option A+ archive-and-delete works",
-  "5_synthesis": "Leader synthesizes final answer",
-};
-let allPass = true;
-for (const [k, label] of Object.entries(labels)) {
-  const ok = results[k];
-  if (!ok && !(k === "4_archive_delete" && KEEP)) allPass = false;
-  log(`  ${ok ? "PASS" : (k === "4_archive_delete" && KEEP ? "SKIP" : "FAIL")}  ${label}`);
-}
-hr(allPass ? "FEASIBLE — core engine works end-to-end" : "NEEDS ATTENTION — see failures above");
-process.exit(allPass ? 0 : 1);