@a-company/paradigm 5.11.0 → 5.21.0

package/dist/chunk-S2HO5MLR.js

@@ -1,621 +0,0 @@
-#!/usr/bin/env node
-
-// ../paradigm-mcp/src/utils/symphony-loader.ts
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import * as crypto from "crypto";
-var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
-var LEGACY_MAIL_DIR = path.join(os.homedir(), ".paradigm", "mail");
-var AGENTS_DIR = path.join(SCORE_DIR, "agents");
-var THREADS_DIR = path.join(SCORE_DIR, "threads");
-var FILE_REQUESTS_DIR = path.join(SCORE_DIR, "file-requests");
-var TRUST_CONFIG_PATH = path.join(SCORE_DIR, "trust.yaml");
-var FILE_REQUEST_TTL_MS = 60 * 60 * 1e3;
-var DEFAULT_TRUST = {
-  users: {},
-  defaults: {
-    level: "restricted",
-    autoApprove: [],
-    neverApprove: [
-      ".env*",
-      "**/*.key",
-      "**/*.pem",
-      "**/credentials*",
-      "**/secrets/**"
-    ]
-  }
-};
-function migrateFromLegacyMail() {
-  if (fs.existsSync(LEGACY_MAIL_DIR) && !fs.existsSync(SCORE_DIR)) {
-    try {
-      fs.renameSync(LEGACY_MAIL_DIR, SCORE_DIR);
-    } catch {
-    }
-  }
-}
-function ensureScoreDirs() {
-  migrateFromLegacyMail();
-  for (const dir of [AGENTS_DIR, THREADS_DIR, FILE_REQUESTS_DIR]) {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-function getAgentDir(agentId) {
-  return path.join(AGENTS_DIR, agentId);
-}
-function ensureAgentDir(agentId) {
-  const dir = getAgentDir(agentId);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function readJsonlFile(filePath) {
-  if (!fs.existsSync(filePath)) return [];
-  const content = fs.readFileSync(filePath, "utf-8");
-  const lines = content.split("\n").filter((line) => line.trim().length > 0);
-  const items = [];
-  for (const line of lines) {
-    try {
-      items.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return items;
-}
-function appendJsonlLine(filePath, item) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
-}
-function sanitizeId(name) {
-  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "unknown";
-}
-function resolveProjectName(projectDir) {
-  try {
-    const configPath = path.join(projectDir, ".paradigm", "config.yaml");
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, "utf-8");
-      const match = content.match(/^project:\s*(.+)$/m);
-      if (match) return sanitizeId(match[1].trim().replace(/["']/g, ""));
-    }
-  } catch {
-  }
-  return sanitizeId(path.basename(projectDir));
-}
-function resolveAgentIdentity(projectDir, role) {
-  const project = resolveProjectName(projectDir);
-  const agentRole = role || "core";
-  return `${project}/${agentRole}`;
-}
-function registerAgent(projectDir, role, label) {
-  ensureScoreDirs();
-  const agentId = resolveAgentIdentity(projectDir, role);
-  const agentDir = ensureAgentDir(agentId);
-  const project = resolveProjectName(projectDir);
-  const identity = {
-    id: agentId,
-    name: label || `${project} (${role || "core"})`,
-    type: "agent",
-    project,
-    role: role || "core",
-    pid: process.pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    label
-  };
-  fs.writeFileSync(
-    path.join(agentDir, "identity.json"),
-    JSON.stringify(identity, null, 2),
-    "utf-8"
-  );
-  return identity;
-}
-function unregisterAgent(agentId) {
-  const agentDir = getAgentDir(agentId);
-  if (!fs.existsSync(agentDir)) return false;
-  try {
-    fs.rmSync(agentDir, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function listAgents() {
-  ensureScoreDirs();
-  if (!fs.existsSync(AGENTS_DIR)) return [];
-  const agents = [];
-  const projectDirs = fs.readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
-  for (const projectDir of projectDirs) {
-    const projectPath = path.join(AGENTS_DIR, projectDir.name);
-    const roleDirs = fs.readdirSync(projectPath, { withFileTypes: true }).filter((d) => d.isDirectory());
-    for (const roleDir of roleDirs) {
-      const identityPath = path.join(projectPath, roleDir.name, "identity.json");
-      if (!fs.existsSync(identityPath)) continue;
-      try {
-        const content = fs.readFileSync(identityPath, "utf-8");
-        const identity = JSON.parse(content);
-        agents.push(identity);
-      } catch {
-      }
-    }
-  }
-  return agents;
-}
-function cleanStaleAgents() {
-  const agents = listAgents();
-  let cleaned = 0;
-  for (const agent of agents) {
-    if (!isProcessAlive(agent.pid)) {
-      unregisterAgent(agent.id);
-      cleaned++;
-    }
-  }
-  return cleaned;
-}
-function getMyIdentity(projectDir) {
-  const agentId = resolveAgentIdentity(projectDir);
-  const identityPath = path.join(getAgentDir(agentId), "identity.json");
-  if (!fs.existsSync(identityPath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(identityPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function markAgentPollTime(agentId, statusBlurb) {
-  const identityPath = path.join(getAgentDir(agentId), "identity.json");
-  if (!fs.existsSync(identityPath)) return;
-  try {
-    const identity = JSON.parse(fs.readFileSync(identityPath, "utf-8"));
-    identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
-    if (statusBlurb !== void 0) {
-      identity.statusBlurb = statusBlurb || void 0;
-    }
-    fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
-  } catch {
-  }
-}
-function isAgentAsleep(identity, thresholdMs = 6e4) {
-  if (!identity.lastPoll) return true;
-  const lastPoll = new Date(identity.lastPoll).getTime();
-  return Date.now() - lastPoll > thresholdMs;
-}
-function discoverClaudeCodeSessions() {
-  const agents = listAgents();
-  const alive = agents.filter((a) => isProcessAlive(a.pid));
-  try {
-    const conductorSessionsDir = path.join(os.homedir(), ".conductor", "sessions");
-    if (fs.existsSync(conductorSessionsDir)) {
-      const files = fs.readdirSync(conductorSessionsDir).filter((f) => f.endsWith(".json"));
-      for (const file of files) {
-        try {
-          const content = fs.readFileSync(path.join(conductorSessionsDir, file), "utf-8");
-          const session = JSON.parse(content);
-          const pid = parseInt(path.basename(file, ".json"), 10);
-          if (!alive.some((a) => a.pid === pid) && isProcessAlive(pid)) {
-            alive.push({
-              id: `conductor/${pid}`,
-              name: session.label || `Session ${pid}`,
-              type: "agent",
-              project: session.projectDir ? path.basename(session.projectDir) : "unknown",
-              role: "conductor",
-              pid,
-              startedAt: session.registeredAt || (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-  return alive;
-}
-function inboxPath(agentId) {
-  return path.join(getAgentDir(agentId), "inbox.jsonl");
-}
-function outboxPath(agentId) {
-  return path.join(getAgentDir(agentId), "outbox.jsonl");
-}
-function ackPath(agentId) {
-  return path.join(getAgentDir(agentId), "ack.json");
-}
-function appendToInbox(agentId, message) {
-  ensureAgentDir(agentId);
-  appendJsonlLine(inboxPath(agentId), message);
-}
-function readInbox(agentId, afterAck) {
-  const messages = readJsonlFile(inboxPath(agentId));
-  if (!afterAck) {
-    const ack = readAck(agentId);
-    if (ack) {
-      const ackIndex2 = messages.findIndex((m) => m.id === ack);
-      if (ackIndex2 >= 0) return messages.slice(ackIndex2 + 1);
-    }
-    return messages;
-  }
-  const ackIndex = messages.findIndex((m) => m.id === afterAck);
-  if (ackIndex >= 0) return messages.slice(ackIndex + 1);
-  return messages;
-}
-function appendToOutbox(agentId, message) {
-  ensureAgentDir(agentId);
-  appendJsonlLine(outboxPath(agentId), message);
-}
-function readOutbox(agentId) {
-  return readJsonlFile(outboxPath(agentId));
-}
-function acknowledgeMessages(agentId, lastMessageId) {
-  const filePath = ackPath(agentId);
-  ensureAgentDir(agentId);
-  fs.writeFileSync(filePath, JSON.stringify({ lastAck: lastMessageId }), "utf-8");
-}
-function readAck(agentId) {
-  const filePath = ackPath(agentId);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return content.lastAck || null;
-  } catch {
-    return null;
-  }
-}
-function garbageCollect(agentId) {
-  const ack = readAck(agentId);
-  if (!ack) return 0;
-  const filePath = inboxPath(agentId);
-  const messages = readJsonlFile(filePath);
-  const ackIndex = messages.findIndex((m) => m.id === ack);
-  if (ackIndex < 0) return 0;
-  const kept = messages.slice(ackIndex + 1);
-  const removed = messages.length - kept.length;
-  if (kept.length === 0) {
-    if (fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf-8");
-  } else {
-    fs.writeFileSync(filePath, kept.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
-  }
-  return removed;
-}
-function threadPath(threadId) {
-  return path.join(THREADS_DIR, `${threadId}.json`);
-}
-function createThread(topic, initiator) {
-  ensureScoreDirs();
-  const id = "thr-" + crypto.randomBytes(4).toString("hex");
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const thread = {
-    id,
-    topic,
-    initiator,
-    participants: [initiator],
-    status: "active",
-    createdAt: now,
-    lastActivity: now,
-    messageCount: 0
-  };
-  fs.writeFileSync(threadPath(id), JSON.stringify(thread, null, 2), "utf-8");
-  return thread;
-}
-function loadThread(threadId) {
-  const filePath = threadPath(threadId);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function listThreads(status) {
-  ensureScoreDirs();
-  if (!fs.existsSync(THREADS_DIR)) return [];
-  const files = fs.readdirSync(THREADS_DIR).filter((f) => f.endsWith(".json"));
-  const threads = [];
-  for (const file of files) {
-    try {
-      const content = fs.readFileSync(path.join(THREADS_DIR, file), "utf-8");
-      const thread = JSON.parse(content);
-      if (!status || thread.status === status) {
-        threads.push(thread);
-      }
-    } catch {
-    }
-  }
-  return threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
-}
-function updateThread(threadId, partial) {
-  const thread = loadThread(threadId);
-  if (!thread) return false;
-  const updated = { ...thread, ...partial };
-  fs.writeFileSync(threadPath(threadId), JSON.stringify(updated, null, 2), "utf-8");
-  return true;
-}
-function resolveThread(threadId, decision) {
-  return updateThread(threadId, {
-    status: "resolved",
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    decision
-  });
-}
-function getThreadMessages(threadId) {
-  const agents = listAgents();
-  const messages = [];
-  for (const agent of agents) {
-    const inbox = readJsonlFile(inboxPath(agent.id));
-    const outbox = readJsonlFile(outboxPath(agent.id));
-    for (const msg of [...inbox, ...outbox]) {
-      if (msg.threadRoot === threadId || msg.id === threadId) {
-        if (!messages.some((m) => m.id === msg.id)) {
-          messages.push(msg);
-        }
-      }
-    }
-  }
-  return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-}
-function buildMessage(params) {
-  return {
-    id: crypto.randomUUID(),
-    parentId: params.parentId,
-    threadRoot: params.threadRoot,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    sender: params.sender,
-    recipients: params.recipients,
-    intent: params.intent,
-    content: {
-      text: params.text,
-      diff: params.diff,
-      decision: params.decision
-    },
-    symbols: params.symbols || [],
-    attachments: params.attachments,
-    metadata: params.metadata
-  };
-}
-function routeMessage(message) {
-  ensureScoreDirs();
-  appendToOutbox(message.sender.id, message);
-  let deliveryCount = 0;
-  if (message.recipients && message.recipients.length > 0) {
-    for (const recipient of message.recipients) {
-      appendToInbox(recipient.id, message);
-      deliveryCount++;
-    }
-  } else {
-    const agents = listAgents();
-    for (const agent of agents) {
-      if (agent.id !== message.sender.id) {
-        appendToInbox(agent.id, message);
-        deliveryCount++;
-      }
-    }
-  }
-  if (message.threadRoot) {
-    const thread = loadThread(message.threadRoot);
-    if (thread) {
-      const isParticipant = thread.participants.some((p) => p.id === message.sender.id);
-      const updatedParticipants = isParticipant ? thread.participants : [...thread.participants, message.sender];
-      updateThread(message.threadRoot, {
-        participants: updatedParticipants,
-        lastActivity: message.timestamp,
-        messageCount: thread.messageCount + 1
-      });
-    }
-  }
-  return deliveryCount;
-}
-function fileRequestPath(requestId) {
-  return path.join(FILE_REQUESTS_DIR, `${requestId}.json`);
-}
-function loadTrustConfig() {
-  if (!fs.existsSync(TRUST_CONFIG_PATH)) return DEFAULT_TRUST;
-  try {
-    const content = fs.readFileSync(TRUST_CONFIG_PATH, "utf-8");
-    try {
-      return JSON.parse(content);
-    } catch {
-      return DEFAULT_TRUST;
-    }
-  } catch {
-    return DEFAULT_TRUST;
-  }
-}
-function createFileRequest(params) {
-  ensureScoreDirs();
-  const requestId = "freq-" + crypto.randomBytes(4).toString("hex");
-  const record = {
-    request: {
-      requestId,
-      filePath: params.filePath,
-      reason: params.reason,
-      requester: params.requester,
-      urgency: params.urgency || "normal",
-      snippet: params.snippet,
-      threadRoot: params.threadRoot
-    },
-    status: "pending",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-  return record;
-}
-function loadFileRequest(requestId) {
-  const filePath = fileRequestPath(requestId);
-  if (!fs.existsSync(filePath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function listFileRequests(status) {
-  ensureScoreDirs();
-  if (!fs.existsSync(FILE_REQUESTS_DIR)) return [];
-  const files = fs.readdirSync(FILE_REQUESTS_DIR).filter((f) => f.endsWith(".json"));
-  const requests = [];
-  for (const file of files) {
-    try {
-      const content = fs.readFileSync(path.join(FILE_REQUESTS_DIR, file), "utf-8");
-      const record = JSON.parse(content);
-      if (!status || record.status === status) {
-        requests.push(record);
-      }
-    } catch {
-    }
-  }
-  return requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-}
-function approveFileRequest(requestId, projectDir, redact) {
-  const record = loadFileRequest(requestId);
-  if (!record) return { success: false, error: `File request not found: ${requestId}` };
-  if (record.status !== "pending") return { success: false, error: `Request already ${record.status}` };
-  const absolutePath = path.resolve(projectDir, record.request.filePath);
-  if (!absolutePath.startsWith(path.resolve(projectDir))) {
-    return { success: false, error: "File path escapes project directory" };
-  }
-  if (!fs.existsSync(absolutePath)) {
-    return { success: false, error: `File not found: ${record.request.filePath}` };
-  }
-  try {
-    let content = fs.readFileSync(absolutePath, "utf-8");
-    let encoding = "utf8";
-    if (redact) {
-      const secretPatterns = [
-        /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]/i,
-        /(?:^|\s)(?:export\s+)?[A-Z_]+(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=/,
-        /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
-      ];
-      content = content.split("\n").map((line) => {
-        for (const pattern of secretPatterns) {
-          if (pattern.test(line)) return "[REDACTED]";
-        }
-        return line;
-      }).join("\n");
-    }
-    const hash = crypto.createHash("sha256").update(content).digest("hex");
-    const delivery = {
-      requestId,
-      filePath: record.request.filePath,
-      content,
-      encoding,
-      size: Buffer.byteLength(content),
-      hash
-    };
-    record.status = "approved";
-    record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-    record.delivery = delivery;
-    fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-    const deliveryMessage = buildMessage({
-      sender: { id: "system", name: "File Transfer", type: "human" },
-      recipients: [record.request.requester],
-      intent: "fileDelivery",
-      text: `File delivered: ${record.request.filePath} (${delivery.size} bytes, SHA-256: ${hash.slice(0, 12)}...)`,
-      threadRoot: record.request.threadRoot,
-      symbols: []
-    });
-    deliveryMessage.attachments = [{
-      name: path.basename(record.request.filePath),
-      type: "file",
-      content: delivery.content,
-      encoding: delivery.encoding
-    }];
-    routeMessage(deliveryMessage);
-    return { success: true, delivery };
-  } catch (err) {
-    return { success: false, error: `Failed to read file: ${err.message}` };
-  }
-}
-function denyFileRequest(requestId, reason) {
-  const record = loadFileRequest(requestId);
-  if (!record || record.status !== "pending") return false;
-  record.status = "denied";
-  record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-  record.denyReason = reason;
-  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
-  const denialMessage = buildMessage({
-    sender: { id: "system", name: "File Transfer", type: "human" },
-    recipients: [record.request.requester],
-    intent: "fileDenied",
-    text: `File request denied: ${record.request.filePath}${reason ? ` \u2014 ${reason}` : ""}`,
-    threadRoot: record.request.threadRoot,
-    symbols: []
-  });
-  routeMessage(denialMessage);
-  return true;
-}
-function matchesGlob(filePath, pattern) {
-  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
-  return new RegExp(`^${regex}$`).test(filePath);
-}
-function isPathDenied(filePath, config, user) {
-  const trust = config || loadTrustConfig();
-  if (user && trust.users[user]) {
-    for (const pattern of trust.users[user].neverApprove) {
-      if (matchesGlob(filePath, pattern)) return true;
-    }
-  }
-  for (const pattern of trust.defaults.neverApprove) {
-    if (matchesGlob(filePath, pattern)) return true;
-  }
-  return false;
-}
-function expireOldRequests() {
-  const requests = listFileRequests("pending");
-  let expired = 0;
-  for (const record of requests) {
-    const age = Date.now() - new Date(record.createdAt).getTime();
-    if (age > FILE_REQUEST_TTL_MS) {
-      record.status = "expired";
-      record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-      fs.writeFileSync(
-        fileRequestPath(record.request.requestId),
-        JSON.stringify(record, null, 2),
-        "utf-8"
-      );
-      expired++;
-    }
-  }
-  return expired;
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export {
-  resolveAgentIdentity,
-  registerAgent,
-  unregisterAgent,
-  listAgents,
-  cleanStaleAgents,
-  getMyIdentity,
-  markAgentPollTime,
-  isAgentAsleep,
-  discoverClaudeCodeSessions,
-  appendToInbox,
-  readInbox,
-  readOutbox,
-  acknowledgeMessages,
-  garbageCollect,
-  createThread,
-  loadThread,
-  listThreads,
-  resolveThread,
-  getThreadMessages,
-  buildMessage,
-  routeMessage,
-  loadTrustConfig,
-  createFileRequest,
-  listFileRequests,
-  approveFileRequest,
-  denyFileRequest,
-  isPathDenied,
-  expireOldRequests
-};