@a-company/paradigm 3.43.0 → 3.44.0

package/dist/symphony-EYRGGVNE.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+import {
+  acknowledgeMessages,
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createFileRequest,
+  createThread,
+  denyFileRequest,
+  discoverClaudeCodeSessions,
+  garbageCollect,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  isPathDenied,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadThread,
+  loadTrustConfig,
+  markAgentPollTime,
+  readInbox,
+  registerAgent,
+  resolveAgentIdentity,
+  resolveThread,
+  routeMessage,
+  unregisterAgent
+} from "./chunk-SOBTKFSP.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/symphony/index.ts
+import chalk from "chalk";
+import * as net from "net";
+async function symphonyJoinCommand(options) {
+  const rootDir = process.cwd();
+  if (options.remote) {
+    console.log(chalk.yellow(`Remote linking to ${options.remote} \u2014 not yet implemented in Phase 0.`));
+    console.log(chalk.gray("Remote linking will be available in a future Symphony phase."));
+    return;
+  }
+  const identity = registerAgent(rootDir);
+  console.log(chalk.green(`\u2713 Joined as ${chalk.bold(identity.id)}`));
+  const sessions = discoverClaudeCodeSessions();
+  const others = sessions.filter((s) => s.id !== identity.id);
+  if (others.length > 0) {
+    console.log(chalk.cyan(`
+  Found ${others.length} other session${others.length !== 1 ? "s" : ""}:`));
+    for (const s of others) {
+      const status = isAgentAsleep(s) ? chalk.yellow("asleep") : chalk.green("awake");
+      console.log(`    ${chalk.white(s.id)} \u2014 ${s.name} [${status}]`);
+    }
+  } else {
+    console.log(chalk.gray('\n  No other sessions found. Open another terminal and run "paradigm symphony join".'));
+  }
+  console.log(chalk.gray(`
+  Tip: Set up polling with: /loop 10s paradigm_symphony_poll`));
+}
+async function symphonyLeaveCommand() {
+  const rootDir = process.cwd();
+  const agentId = resolveAgentIdentity(rootDir);
+  const success = unregisterAgent(agentId);
+  if (success) {
+    console.log(chalk.green(`\u2713 Left the score: ${agentId}`));
+  } else {
+    console.log(chalk.yellow(`No active part found for this project.`));
+  }
+}
+async function symphonyWhoamiCommand() {
+  const rootDir = process.cwd();
+  const identity = getMyIdentity(rootDir);
+  if (!identity) {
+    console.log(chalk.yellow('Not joined. Run "paradigm symphony join" first.'));
+    return;
+  }
+  const agents = listAgents();
+  const others = agents.filter((a) => a.id !== identity.id);
+  const threads = listThreads("active");
+  const unread = readInbox(identity.id);
+  console.log(chalk.cyan(`
+  ${chalk.bold(identity.id)}`));
+  console.log(chalk.gray(`  Project: ${identity.project}`));
+  console.log(chalk.gray(`  Role: ${identity.role}`));
+  console.log(chalk.gray(`  PID: ${identity.pid}`));
+  console.log(chalk.gray(`  Started: ${identity.startedAt}`));
+  if (identity.statusBlurb) {
+    console.log(chalk.white(`  Status: ${identity.statusBlurb}`));
+  }
+  console.log(`
+  ${chalk.white(`${others.length} linked peer${others.length !== 1 ? "s" : ""}`)} \u2014 ${chalk.white(`${threads.length} active thread${threads.length !== 1 ? "s" : ""}`)} \u2014 ${chalk.white(`${unread.length} unread`)}`);
+}
+async function symphonyListCommand(options) {
+  cleanStaleAgents();
+  const agents = listAgents();
+  if (options.json) {
+    console.log(JSON.stringify(agents, null, 2));
+    return;
+  }
+  if (agents.length === 0) {
+    console.log(chalk.yellow('No agents joined. Run "paradigm symphony join" in each terminal.'));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Symphony Agents (${agents.length})
+`));
+  console.log(chalk.gray(`  ${"AGENT ID".padEnd(30)} ${"PROJECT".padEnd(15)} ${"ROLE".padEnd(10)} STATUS`));
+  console.log(chalk.gray(`  ${"\u2500".repeat(30)} ${"\u2500".repeat(15)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)}`));
+  for (const agent of agents) {
+    const status = isAgentAsleep(agent) ? chalk.yellow("asleep") : chalk.green("awake");
+    console.log(`  ${chalk.white(agent.id.padEnd(30))} ${agent.project.padEnd(15)} ${agent.role.padEnd(10)} ${status}`);
+    if (agent.statusBlurb) {
+      console.log(`  ${chalk.gray(`  \u2514 ${agent.statusBlurb}`)}`);
+    }
+  }
+  console.log();
+}
+async function symphonySendCommand(messageText, options) {
+  const rootDir = process.cwd();
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+    console.log(chalk.gray(`Auto-joined as ${identity.id}`));
+  }
+  const sender = {
+    id: identity.id,
+    name: identity.name,
+    type: "human",
+    // CLI notes come from the human
+    project: identity.project,
+    role: identity.role
+  };
+  let recipients;
+  if (options.to) {
+    recipients = [{ id: options.to, name: options.to, type: "agent" }];
+  }
+  let threadRoot = options.thread;
+  if (!threadRoot) {
+    const topic = messageText.length > 60 ? messageText.slice(0, 60) + "..." : messageText;
+    const thread = createThread(topic, sender);
+    threadRoot = thread.id;
+  }
+  const message = buildMessage({
+    sender,
+    recipients,
+    intent: "context",
+    text: messageText,
+    threadRoot
+  });
+  const deliveryCount = routeMessage(message);
+  console.log(chalk.green(`\u2713 Sent to ${deliveryCount} agent${deliveryCount !== 1 ? "s" : ""}`));
+  console.log(chalk.gray(`  Thread: ${threadRoot}`));
+  console.log(chalk.gray(`  Note: ${message.id}`));
+}
+async function symphonyReadCommand() {
+  const rootDir = process.cwd();
+  const identity = getMyIdentity(rootDir);
+  if (!identity) {
+    console.log(chalk.yellow('Not joined. Run "paradigm symphony join" first.'));
+    return;
+  }
+  markAgentPollTime(identity.id);
+  const messages = readInbox(identity.id);
+  if (messages.length === 0) {
+    console.log(chalk.gray("\n  No unread notes.\n"));
+    return;
+  }
+  const byThread = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const tid = msg.threadRoot || "direct";
+    if (!byThread.has(tid)) byThread.set(tid, []);
+    byThread.get(tid).push(msg);
+  }
+  console.log(chalk.cyan(`
+  ${messages.length} unread note${messages.length !== 1 ? "s" : ""}
+`));
+  for (const [threadId, msgs] of byThread) {
+    let threadLabel = threadId;
+    if (threadId !== "direct") {
+      const thread = loadThread(threadId);
+      if (thread) threadLabel = `${thread.topic} (${threadId})`;
+    }
+    console.log(chalk.white(`  \u250C\u2500 ${threadLabel}`));
+    for (let i = 0; i < msgs.length; i++) {
+      const msg = msgs[i];
+      const isLast = i === msgs.length - 1;
+      const prefix = isLast ? "  \u2514\u2500" : "  \u251C\u2500";
+      const time = new Date(msg.timestamp).toLocaleTimeString(void 0, { hour: "numeric", minute: "2-digit" });
+      console.log(`${prefix} ${chalk.cyan(msg.sender.name)} ${chalk.gray(`[${msg.intent}]`)} ${chalk.gray(time)}`);
+      const textLines = msg.content.text.split("\n");
+      const indent = isLast ? "     " : "  \u2502  ";
+      for (const line of textLines) {
+        console.log(`${indent}${line}`);
+      }
+      if (msg.symbols.length > 0) {
+        console.log(`${indent}${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
+      }
+    }
+    console.log();
+  }
+  const lastId = messages[messages.length - 1].id;
+  acknowledgeMessages(identity.id, lastId);
+  garbageCollect(identity.id);
+}
+async function symphonyThreadsCommand(options) {
+  const threads = listThreads();
+  if (options.json) {
+    console.log(JSON.stringify(threads, null, 2));
+    return;
+  }
+  if (threads.length === 0) {
+    console.log(chalk.gray("\n  No threads.\n"));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Threads (${threads.length})
+`));
+  console.log(chalk.gray(`  ${"ID".padEnd(14)} ${"TOPIC".padEnd(35)} ${"MSGS".padEnd(6)} ${"STATUS".padEnd(10)} LAST ACTIVITY`));
+  console.log(chalk.gray(`  ${"\u2500".repeat(14)} ${"\u2500".repeat(35)} ${"\u2500".repeat(6)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`));
+  for (const thread of threads) {
+    const topic = thread.topic.length > 33 ? thread.topic.slice(0, 33) + ".." : thread.topic;
+    const status = thread.status === "active" ? chalk.green("active") : chalk.gray("resolved");
+    const lastAct = new Date(thread.lastActivity).toLocaleString(void 0, {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    });
+    console.log(`  ${chalk.white(thread.id.padEnd(14))} ${topic.padEnd(35)} ${String(thread.messageCount).padEnd(6)} ${status.padEnd(10)} ${chalk.gray(lastAct)}`);
+  }
+  console.log();
+}
+async function symphonyThreadCommand(threadId) {
+  const thread = loadThread(threadId);
+  if (!thread) {
+    console.log(chalk.red(`Thread not found: ${threadId}`));
+    return;
+  }
+  const messages = getThreadMessages(threadId);
+  console.log(chalk.cyan(`
+  Thread: ${thread.topic}`));
+  console.log(chalk.gray(`  ID: ${thread.id} | Status: ${thread.status} | Notes: ${thread.messageCount}`));
+  console.log(chalk.gray(`  Participants: ${thread.participants.map((p) => p.name).join(", ")}`));
+  if (thread.decision) {
+    console.log(chalk.green(`  Decision: ${thread.decision}`));
+  }
+  console.log(chalk.gray(`
+  ${"\u2500".repeat(60)}
+`));
+  for (const msg of messages) {
+    const time = new Date(msg.timestamp).toLocaleString(void 0, {
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    });
+    console.log(`  ${chalk.cyan(msg.sender.name)} ${chalk.gray(`[${msg.intent}]`)} ${chalk.gray(time)}`);
+    const textLines = msg.content.text.split("\n");
+    for (const line of textLines) {
+      console.log(`    ${line}`);
+    }
+    if (msg.symbols.length > 0) {
+      console.log(`    ${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
+    }
+    if (msg.content.decision) {
+      console.log(`    ${chalk.green(`Decision: ${msg.content.decision}`)}`);
+    }
+    console.log();
+  }
+}
+async function symphonyResolveCommand(threadId, options) {
+  const thread = loadThread(threadId);
+  if (!thread) {
+    console.log(chalk.red(`Thread not found: ${threadId}`));
+    return;
+  }
+  const success = resolveThread(threadId, options.decision);
+  if (success) {
+    console.log(chalk.green(`\u2713 Thread resolved: ${thread.topic}`));
+    if (options.decision) {
+      console.log(chalk.gray(`  Decision: ${options.decision}`));
+    }
+    console.log(chalk.gray(`  Tip: Record this as lore with "paradigm lore record --title 'Thread: ${thread.topic}'"`));
+  } else {
+    console.log(chalk.red("Failed to resolve thread."));
+  }
+}
+async function symphonyStatusCommand(options) {
+  cleanStaleAgents();
+  const rootDir = process.cwd();
+  const identity = getMyIdentity(rootDir);
+  const agents = listAgents();
+  const threads = listThreads("active");
+  const pendingRequests = listFileRequests("pending");
+  const unread = identity ? readInbox(identity.id) : [];
+  if (options.json) {
+    console.log(JSON.stringify({
+      identity: identity ? { id: identity.id, project: identity.project, role: identity.role } : null,
+      agents: agents.map((a) => ({ id: a.id, status: isAgentAsleep(a) ? "asleep" : "awake", statusBlurb: a.statusBlurb })),
+      activeThreads: threads.length,
+      unreadMessages: unread.length,
+      pendingFileRequests: pendingRequests.length
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.cyan("\n  Symphony Status\n"));
+  if (identity) {
+    console.log(`  ${chalk.white("Identity:")} ${identity.id}`);
+  } else {
+    console.log(`  ${chalk.yellow("Not joined.")} Run "paradigm symphony join" to join.`);
+  }
+  const awake = agents.filter((a) => !isAgentAsleep(a)).length;
+  console.log(`  ${chalk.white("Agents:")} ${agents.length} joined (${awake} awake)`);
+  for (const a of agents) {
+    const st = isAgentAsleep(a) ? chalk.yellow("asleep") : chalk.green("awake");
+    const blurb = a.statusBlurb ? chalk.gray(` \u2014 ${a.statusBlurb}`) : "";
+    console.log(`    ${chalk.white(a.id)} [${st}]${blurb}`);
+  }
+  console.log(`  ${chalk.white("Threads:")} ${threads.length} active`);
+  console.log(`  ${chalk.white("Unread:")} ${unread.length} note${unread.length !== 1 ? "s" : ""}`);
+  console.log(`  ${chalk.white("File Requests:")} ${pendingRequests.length} pending`);
+  console.log();
+}
+async function symphonyServeCommand(options) {
+  const port = parseInt(options.port || "3939", 10);
+  console.log(chalk.cyan(`
+  Starting Symphony TCP server on port ${port}...`));
+  console.log(chalk.gray("  Phase 0 stub \u2014 remote linking protocol not yet implemented.\n"));
+  const server = net.createServer((socket) => {
+    socket.write(JSON.stringify({ type: "hello", version: "0.1.0" }) + "\n");
+    socket.on("data", (data) => {
+      try {
+        const msg = JSON.parse(data.toString().trim());
+        socket.write(JSON.stringify({ type: "ack", received: msg.type }) + "\n");
+      } catch {
+        socket.write(JSON.stringify({ type: "error", message: "Invalid JSON" }) + "\n");
+      }
+    });
+    socket.on("error", () => {
+    });
+  });
+  server.listen(port, "0.0.0.0", () => {
+    console.log(chalk.green(`  \u2713 Symphony server listening on 0.0.0.0:${port}`));
+    console.log(chalk.gray(`  Connect from another machine: paradigm symphony join --remote <this-ip>:${port}`));
+  });
+  server.on("error", (err) => {
+    console.log(chalk.red(`  Failed to start server: ${err.message}`));
+  });
+  await new Promise(() => {
+  });
+}
+async function symphonyRequestCommand(file, options) {
+  const rootDir = process.cwd();
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+  }
+  const from = options.from;
+  const reason = options.reason || "Needed for current task";
+  if (!from) {
+    console.log(chalk.red("--from is required. Specify which agent to request from."));
+    const agents = listAgents().filter((a) => a.id !== identity.id);
+    if (agents.length > 0) {
+      console.log(chalk.gray("\nAvailable agents:"));
+      for (const a of agents) {
+        console.log(chalk.gray(`  ${a.id}`));
+      }
+    }
+    return;
+  }
+  const trust = loadTrustConfig();
+  if (isPathDenied(file, trust)) {
+    console.log(chalk.red(`\u2717 "${file}" is on the hard-deny list and cannot be requested.`));
+    return;
+  }
+  const record = createFileRequest({
+    filePath: file,
+    requester: {
+      id: identity.id,
+      name: identity.name,
+      type: "agent",
+      project: identity.project,
+      role: identity.role
+    },
+    reason
+  });
+  const msg = buildMessage({
+    sender: {
+      id: identity.id,
+      name: identity.name,
+      type: "agent",
+      project: identity.project,
+      role: identity.role
+    },
+    recipients: [{ id: from, name: from, type: "agent" }],
+    intent: "fileRequest",
+    text: `File request: ${file}
+Reason: ${reason}`,
+    symbols: []
+  });
+  routeMessage(msg);
+  console.log(chalk.green(`\u2713 File request created: ${record.request.requestId}`));
+  console.log(chalk.gray(`  File: ${file}`));
+  console.log(chalk.gray(`  From: ${from}`));
+  console.log(chalk.gray(`  Reason: ${reason}`));
+  console.log(chalk.gray(`
+  The owning agent's human must approve with:`));
+  console.log(chalk.white(`    paradigm symphony approve ${record.request.requestId}`));
+}
+async function symphonyRequestsCommand() {
+  const requests = listFileRequests("pending");
+  if (requests.length === 0) {
+    console.log(chalk.gray("\n  No pending file requests.\n"));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Pending File Requests (${requests.length})
+`));
+  for (const req of requests) {
+    const age = Date.now() - new Date(req.createdAt).getTime();
+    const ageMin = Math.round(age / 6e4);
+    console.log(`  ${chalk.white(req.request.requestId)}`);
+    console.log(`    File: ${req.request.filePath}`);
+    console.log(`    From: ${req.request.requester.name} (${req.request.requester.id})`);
+    console.log(`    Reason: ${req.request.reason}`);
+    console.log(chalk.gray(`    ${ageMin}m ago`));
+    console.log(chalk.gray(`    \u2192 paradigm symphony approve ${req.request.requestId}`));
+    console.log(chalk.gray(`    \u2192 paradigm symphony deny ${req.request.requestId}`));
+    console.log();
+  }
+}
+async function symphonyApproveCommand(requestId, options) {
+  const rootDir = process.cwd();
+  const result = approveFileRequest(requestId, rootDir, options.redact);
+  if (!result.success) {
+    console.log(chalk.red(`\u2717 ${result.error}`));
+    return;
+  }
+  const label = options.redact ? "approved (redacted)" : "approved";
+  console.log(chalk.green(`\u2713 File request ${label}`));
+  console.log(chalk.gray(`  File: ${result.delivery?.filePath}`));
+  console.log(chalk.gray(`  Size: ${result.delivery?.size} bytes`));
+  console.log(chalk.gray(`  SHA-256: ${result.delivery?.hash?.slice(0, 16)}...`));
+}
+async function symphonyDenyCommand(requestId, options) {
+  const success = denyFileRequest(requestId, options.reason);
+  if (success) {
+    console.log(chalk.green(`\u2713 File request denied: ${requestId}`));
+    if (options.reason) {
+      console.log(chalk.gray(`  Reason: ${options.reason}`));
+    }
+  } else {
+    console.log(chalk.red(`\u2717 File request not found or already resolved: ${requestId}`));
+  }
+}
+export {
+  symphonyApproveCommand,
+  symphonyDenyCommand,
+  symphonyJoinCommand,
+  symphonyLeaveCommand,
+  symphonyListCommand,
+  symphonyReadCommand,
+  symphonyRequestCommand,
+  symphonyRequestsCommand,
+  symphonyResolveCommand,
+  symphonySendCommand,
+  symphonyServeCommand,
+  symphonyStatusCommand,
+  symphonyThreadCommand,
+  symphonyThreadsCommand,
+  symphonyWhoamiCommand
+};