tagteam 0.1.0

package/dist/index.js

@@ -0,0 +1,1326 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse, stringify } from "smol-toml";
+var DEFAULT_CONFIG = {
+  claude: {
+    model: "sonnet"
+  },
+  codex: {
+    model: "gpt-5.3-codex"
+  },
+  discussion: {
+    max_rounds: 10
+  }
+};
+function getConfigDir() {
+  return join(homedir(), ".tagteam");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.toml");
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = parse(raw);
+    return {
+      claude: { ...DEFAULT_CONFIG.claude, ...parsed.claude },
+      codex: { ...DEFAULT_CONFIG.codex, ...parsed.codex },
+      discussion: { ...DEFAULT_CONFIG.discussion, ...parsed.discussion }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  writeFileSync(configPath, stringify(config), "utf-8");
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    switch (parts[0]) {
+      case "claude_model":
+        config.claude.model = value;
+        break;
+      case "codex_model":
+        config.codex.model = value;
+        break;
+      case "discussion_max_rounds":
+        config.discussion.max_rounds = Number(value);
+        break;
+      default:
+        throw new Error(`Unknown config key: ${key}`);
+    }
+  } else if (parts.length === 2) {
+    const [section, field] = parts;
+    if (section === "claude" && field === "model") {
+      config.claude.model = value;
+    } else if (section === "codex" && field === "model") {
+      config.codex.model = value;
+    } else if (section === "discussion" && field === "max_rounds") {
+      config.discussion.max_rounds = Number(value);
+    } else {
+      throw new Error(`Unknown config key: ${key}`);
+    }
+  } else {
+    throw new Error(`Invalid config key format: ${key}`);
+  }
+  saveConfig(config);
+  return config;
+}
+
+// src/ui.tsx
+import { useState as useState2, useEffect, useCallback, useRef } from "react";
+import { render as render2, Box as Box2, Text as Text2, useApp as useApp2, useInput as useInput2 } from "ink";
+import TextInput2 from "ink-text-input";
+import Spinner from "ink-spinner";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { nanoid } from "nanoid";
+
+// src/agents/claude.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+async function* streamClaude(options) {
+  const args = [
+    "-p",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--no-session-persistence"
+  ];
+  if (options.systemPrompt) {
+    args.push("--system-prompt", options.systemPrompt);
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  args.push(options.prompt);
+  const proc = spawn("claude", args, {
+    cwd: options.cwd,
+    stdio: ["ignore", "pipe", "inherit"],
+    env: { ...process.env, CLAUDECODE: "" }
+  });
+  let spawnErrorMsg = "";
+  proc.on("error", (err) => {
+    spawnErrorMsg = err.message;
+  });
+  if (options.signal) {
+    if (options.signal.aborted) {
+      proc.kill();
+    } else {
+      options.signal.addEventListener("abort", () => proc.kill(), { once: true });
+    }
+  }
+  const rl = createInterface({ input: proc.stdout });
+  let gotResultText = false;
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let data;
+    try {
+      data = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (data.type === "assistant" && data.message?.content) {
+      for (const block of data.message.content) {
+        if (block.type === "text" && block.text) {
+          yield { type: "text", agent: "claude", content: block.text };
+          gotResultText = true;
+        } else if (block.type === "tool_use") {
+          yield {
+            type: "tool_call",
+            agent: "claude",
+            toolName: block.name,
+            toolInput: typeof block.input === "string" ? block.input : JSON.stringify(block.input)
+          };
+        }
+      }
+    } else if (data.type === "user" && data.message?.content) {
+      for (const block of data.message.content) {
+        if (block.type === "tool_result") {
+          const text = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.filter((c) => c.type === "text").map((c) => c.text).join("\n") : "";
+          if (text) {
+            yield {
+              type: "tool_result",
+              agent: "claude",
+              toolOutput: text
+            };
+          }
+        }
+      }
+    } else if (data.type === "result") {
+      if (data.is_error) {
+        yield {
+          type: "error",
+          agent: "claude",
+          content: data.error || data.result || "Unknown error"
+        };
+      } else if (data.result && !gotResultText) {
+        yield { type: "text", agent: "claude", content: data.result };
+      }
+    }
+  }
+  await new Promise((resolve) => {
+    proc.on("close", resolve);
+  });
+  if (spawnErrorMsg) {
+    yield {
+      type: "error",
+      agent: "claude",
+      content: `Failed to spawn claude: ${spawnErrorMsg}`
+    };
+  }
+  yield { type: "done", agent: "claude" };
+}
+async function runClaude(options) {
+  const start = Date.now();
+  const events = [];
+  const textParts = [];
+  const errors = [];
+  for await (const event of streamClaude(options)) {
+    events.push(event);
+    if (event.type === "text" && event.content) {
+      textParts.push(event.content);
+    } else if (event.type === "error" && event.content) {
+      errors.push(event.content);
+    }
+  }
+  return {
+    agent: "claude",
+    text: textParts.join(""),
+    events,
+    durationMs: Date.now() - start,
+    error: errors.length > 0 ? errors.join("\n") : void 0
+  };
+}
+
+// src/agents/codex.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+async function* streamCodex(options) {
+  const args = ["exec", "--json", "--full-auto", "--ephemeral"];
+  if (options.model) {
+    args.push("-m", options.model);
+  }
+  let fullPrompt = options.prompt;
+  if (options.systemPrompt) {
+    fullPrompt = `${options.systemPrompt}
+
+---
+
+${options.prompt}`;
+  }
+  args.push(fullPrompt);
+  const proc = spawn2("codex", args, {
+    cwd: options.cwd,
+    stdio: ["ignore", "pipe", "inherit"],
+    env: process.env
+  });
+  let spawnErrorMsg = "";
+  proc.on("error", (err) => {
+    spawnErrorMsg = err.message;
+  });
+  if (options.signal) {
+    if (options.signal.aborted) {
+      proc.kill();
+    } else {
+      options.signal.addEventListener("abort", () => proc.kill(), { once: true });
+    }
+  }
+  const rl = createInterface2({ input: proc.stdout });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    let data;
+    try {
+      data = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (data.type === "item.completed" && data.item) {
+      const item = data.item;
+      if (item.type === "agent_message" && item.text) {
+        yield { type: "text", agent: "codex", content: item.text };
+      } else if (item.type === "command_execution") {
+        yield {
+          type: "tool_call",
+          agent: "codex",
+          toolName: "command",
+          toolInput: item.command
+        };
+        if (item.aggregated_output) {
+          yield {
+            type: "tool_result",
+            agent: "codex",
+            toolOutput: item.aggregated_output
+          };
+        }
+      } else if (item.type === "file_change" && item.changes) {
+        const desc = item.changes.map((c) => `${c.kind}: ${c.path}`).join(", ");
+        yield {
+          type: "tool_result",
+          agent: "codex",
+          toolName: "file_change",
+          toolOutput: desc
+        };
+      } else if (item.type === "error") {
+        yield {
+          type: "error",
+          agent: "codex",
+          content: item.message || "Unknown error"
+        };
+      }
+    } else if (data.type === "turn.failed") {
+      yield {
+        type: "error",
+        agent: "codex",
+        content: data.error?.message || "Turn failed"
+      };
+    } else if (data.type === "error") {
+      yield {
+        type: "error",
+        agent: "codex",
+        content: data.message || "Stream error"
+      };
+    }
+  }
+  await new Promise((resolve) => {
+    proc.on("close", resolve);
+  });
+  if (spawnErrorMsg) {
+    yield {
+      type: "error",
+      agent: "codex",
+      content: `Failed to spawn codex: ${spawnErrorMsg}`
+    };
+  }
+  yield { type: "done", agent: "codex" };
+}
+async function runCodex(options) {
+  const start = Date.now();
+  const events = [];
+  const textParts = [];
+  const errors = [];
+  for await (const event of streamCodex(options)) {
+    events.push(event);
+    if (event.type === "text" && event.content) {
+      textParts.push(event.content);
+    } else if (event.type === "error" && event.content) {
+      errors.push(event.content);
+    }
+  }
+  return {
+    agent: "codex",
+    text: textParts.join(""),
+    events,
+    durationMs: Date.now() - start,
+    error: errors.length > 0 ? errors.join("\n") : void 0
+  };
+}
+
+// src/format.ts
+function formatAsMarkdown(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+    if (msg.role === "user") {
+      parts.push(`**You:** ${msg.content}`);
+    } else {
+      const name = msg.role === "claude" ? "Claude" : "Codex";
+      if (msg.error) {
+        parts.push(`**${name}:** *(error)*
+
+${msg.content}`);
+      } else {
+        parts.push(`**${name}:**
+
+${msg.content}`);
+      }
+    }
+  }
+  return parts.join("\n\n---\n\n") + "\n";
+}
+
+// src/clipboard.ts
+import { execSync } from "child_process";
+function copyToClipboard(text) {
+  const platform = process.platform;
+  let cmd;
+  if (platform === "darwin") {
+    cmd = "pbcopy";
+  } else if (platform === "win32") {
+    cmd = "clip";
+  } else {
+    try {
+      execSync("which xclip", { stdio: "ignore" });
+      cmd = "xclip -selection clipboard";
+    } catch {
+      cmd = "xsel --clipboard --input";
+    }
+  }
+  execSync(cmd, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+}
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { join as join2 } from "path";
+var db = null;
+function getDbPath() {
+  return join2(getConfigDir(), "tagteam.db");
+}
+function getDb() {
+  if (db) return db;
+  ensureConfigDir();
+  db = new Database(getDbPath());
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initSchema(db);
+  return db;
+}
+function initSchema(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id           TEXT PRIMARY KEY,
+      title        TEXT,
+      working_dir  TEXT NOT NULL,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at   TEXT NOT NULL DEFAULT (datetime('now')),
+      status       TEXT NOT NULL DEFAULT 'active'
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id   TEXT NOT NULL REFERENCES sessions(id),
+      role         TEXT NOT NULL,
+      content      TEXT NOT NULL,
+      round        INTEGER NOT NULL DEFAULT 0,
+      duration_ms  INTEGER,
+      metadata     TEXT,
+      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, id);
+  `);
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/db/sessions.ts
+function createSession(id, workingDir) {
+  const db2 = getDb();
+  db2.prepare(
+    `INSERT INTO sessions (id, working_dir) VALUES (?, ?)`
+  ).run(id, workingDir);
+  return getSession(id);
+}
+function getSession(id) {
+  const db2 = getDb();
+  return db2.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+}
+function getSessionByPrefix(prefix) {
+  const db2 = getDb();
+  return db2.prepare(`SELECT * FROM sessions WHERE id LIKE ? ORDER BY updated_at DESC LIMIT 1`).get(`${prefix}%`);
+}
+function getMostRecentSession() {
+  const db2 = getDb();
+  return db2.prepare(
+    `SELECT * FROM sessions WHERE status = 'active' ORDER BY updated_at DESC LIMIT 1`
+  ).get();
+}
+function listSessions(limit = 20) {
+  const db2 = getDb();
+  return db2.prepare(`SELECT * FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(limit);
+}
+function updateSessionTitle(id, title) {
+  const db2 = getDb();
+  db2.prepare(
+    `UPDATE sessions SET title = ?, updated_at = datetime('now') WHERE id = ?`
+  ).run(title, id);
+}
+function touchSession(id) {
+  const db2 = getDb();
+  db2.prepare(`UPDATE sessions SET updated_at = datetime('now') WHERE id = ?`).run(
+    id
+  );
+}
+
+// src/db/messages.ts
+function insertMessage(params) {
+  const db2 = getDb();
+  const result = db2.prepare(
+    `INSERT INTO messages (session_id, role, content, round, duration_ms, metadata)
+       VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    params.sessionId,
+    params.role,
+    params.content,
+    params.round,
+    params.durationMs ?? null,
+    params.metadata ? JSON.stringify(params.metadata) : null
+  );
+  return db2.prepare(`SELECT * FROM messages WHERE id = ?`).get(result.lastInsertRowid);
+}
+function getMessages(sessionId) {
+  const db2 = getDb();
+  return db2.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY id`).all(sessionId);
+}
+function deleteMessagesFromRound(sessionId, fromRound) {
+  const db2 = getDb();
+  db2.prepare(
+    `DELETE FROM messages WHERE session_id = ? AND round >= ?`
+  ).run(sessionId, fromRound);
+}
+
+// src/prompts.ts
+var OTHER = {
+  claude: "Codex (OpenAI)",
+  codex: "Claude (Anthropic)"
+};
+function collaborationPrompt(agent) {
+  return `You are in a collaborative session with ${OTHER[agent]}. You'll both respond to the user's prompt independently, then see each other's responses. In discussion rounds: highlight where you agree, constructively address disagreements, and build on each other's ideas. Be concise - avoid repeating what was already said.`;
+}
+function discussionPrompt(agent, conversationHistory) {
+  return `${collaborationPrompt(agent)}
+
+Here is the conversation so far:
+
+${conversationHistory}
+
+Now provide your response for this discussion round. Build on what was said, highlight agreements, and address any disagreements constructively. Be concise.`;
+}
+function debatePrompt(agent) {
+  return `You are in a structured debate with ${OTHER[agent]}. You'll both respond to the user's prompt, then see each other's responses and discuss.
+
+Your goal is to reach consensus through constructive discussion. In each round:
+- Address specific points of agreement and disagreement
+- Refine your position based on valid arguments from ${OTHER[agent]}
+- Be concise \u2014 don't repeat points already established
+
+When you believe you and ${OTHER[agent]} have reached substantial agreement on the key points, end your response with [CONSENSUS] on its own line. Only do this when you genuinely agree \u2014 don't force premature consensus.`;
+}
+function debateRoundPrompt(agent, conversationHistory) {
+  return `${debatePrompt(agent)}
+
+Here is the conversation so far:
+
+${conversationHistory}
+
+Respond to the latest round. If you agree with ${OTHER[agent]}'s position on all key points, end with [CONSENSUS]. Otherwise, continue the discussion.`;
+}
+var CONSENSUS_MARKER = "[CONSENSUS]";
+function formatConversationHistory(messages) {
+  return messages.map((m) => {
+    const label = m.role === "user" ? "User" : m.agent === "claude" ? "Claude" : "Codex";
+    return `[${label}]: ${m.content}`;
+  }).join("\n\n");
+}
+
+// src/config-editor.tsx
+import { useState } from "react";
+import { render, Box, Text, useApp, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { jsx, jsxs } from "react/jsx-runtime";
+var CONFIG_FIELDS = [
+  {
+    key: "claude.model",
+    label: "Claude model",
+    get: (c) => c.claude.model,
+    type: "string"
+  },
+  {
+    key: "codex.model",
+    label: "Codex model",
+    get: (c) => c.codex.model,
+    type: "string"
+  },
+  {
+    key: "discussion.max_rounds",
+    label: "Discussion max rounds",
+    get: (c) => String(c.discussion.max_rounds),
+    type: "number"
+  }
+];
+var LABEL_WIDTH = Math.max(...CONFIG_FIELDS.map((f) => f.label.length));
+function InlineConfigEditor({ isActive, onClose }) {
+  const [config, setConfig] = useState(() => loadConfig());
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [mode, setMode] = useState("select");
+  const [editValue, setEditValue] = useState("");
+  const [savedMessage, setSavedMessage] = useState(null);
+  useInput(
+    (input, key) => {
+      if (key.upArrow) {
+        setSavedMessage(null);
+        setSelectedIndex((i) => i > 0 ? i - 1 : CONFIG_FIELDS.length - 1);
+      } else if (key.downArrow) {
+        setSavedMessage(null);
+        setSelectedIndex((i) => i < CONFIG_FIELDS.length - 1 ? i + 1 : 0);
+      } else if (key.return) {
+        const field = CONFIG_FIELDS[selectedIndex];
+        setEditValue(field.get(config));
+        setSavedMessage(null);
+        setMode("edit");
+      } else if (key.escape || input === "q") {
+        onClose();
+      }
+    },
+    { isActive: isActive && mode === "select" }
+  );
+  useInput(
+    (_input, key) => {
+      if (key.escape) {
+        setMode("select");
+      }
+    },
+    { isActive: isActive && mode === "edit" }
+  );
+  const handleEditSubmit = (value) => {
+    const field = CONFIG_FIELDS[selectedIndex];
+    if (field.type === "number") {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 1) {
+        setSavedMessage("Error: must be a positive integer");
+        setMode("select");
+        return;
+      }
+    }
+    try {
+      const updated = setConfigValue(field.key, value);
+      setConfig(updated);
+      setSavedMessage(`Saved ${field.key} = ${value}`);
+    } catch (e) {
+      setSavedMessage(`Error: ${e.message}`);
+    }
+    setMode("select");
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Configuration" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2500\u2500 edit values inline" })
+    ] }),
+    CONFIG_FIELDS.map((field, i) => {
+      const selected = i === selectedIndex;
+      const pointer = selected ? "> " : "  ";
+      const currentValue = field.get(config);
+      return /* @__PURE__ */ jsxs(Box, { marginLeft: 1, children: [
+        /* @__PURE__ */ jsxs(Text, { color: selected ? "cyan" : void 0, bold: selected, children: [
+          pointer,
+          field.label.padEnd(LABEL_WIDTH)
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: " = " }),
+        mode === "edit" && selected ? /* @__PURE__ */ jsx(
+          TextInput,
+          {
+            value: editValue,
+            onChange: setEditValue,
+            onSubmit: handleEditSubmit,
+            showCursor: true
+          }
+        ) : /* @__PURE__ */ jsx(Text, { color: "white", children: currentValue })
+      ] }, field.key);
+    }),
+    savedMessage && /* @__PURE__ */ jsx(Box, { marginTop: 1, marginLeft: 1, children: /* @__PURE__ */ jsx(Text, { color: savedMessage.startsWith("Error") ? "red" : "green", children: savedMessage }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, marginLeft: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: mode === "edit" ? "Enter save  Esc cancel" : "\u2191\u2193 navigate  Enter edit  Esc/q quit" }) })
+  ] });
+}
+function StandaloneConfigEditor() {
+  const { exit } = useApp();
+  return /* @__PURE__ */ jsx(InlineConfigEditor, { isActive: true, onClose: exit });
+}
+function startConfigEditor() {
+  return render(/* @__PURE__ */ jsx(StandaloneConfigEditor, {}));
+}
+
+// src/ui.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+marked.use(markedTerminal());
+function parseInput(input) {
+  const lower = input.toLowerCase();
+  if (lower.startsWith("discuss ")) {
+    return { target: "both", prompt: input.slice(8).trim(), discuss: true };
+  }
+  if (lower.startsWith("claude ") || lower.startsWith("claude, ")) {
+    return { target: "claude", prompt: input.slice(input.indexOf(" ") + 1).trim(), discuss: false };
+  }
+  if (lower.startsWith("codex ") || lower.startsWith("codex, ")) {
+    return { target: "codex", prompt: input.slice(input.indexOf(" ") + 1).trim(), discuss: false };
+  }
+  return { target: "both", prompt: input, discuss: false };
+}
+function RenderedMarkdown({ text }) {
+  const rendered = marked.parse(text).trimEnd();
+  return /* @__PURE__ */ jsx2(Text2, { children: rendered });
+}
+function AgentResponseBlock({
+  agent,
+  content,
+  error
+}) {
+  const color = agent === "claude" ? "magenta" : "green";
+  if (error) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginLeft: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "red", bold: true, children: [
+        agent === "claude" ? "Claude" : "Codex",
+        " error:"
+      ] }),
+      /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "red", children: content }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginLeft: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { color, bold: true, children: [
+      agent === "claude" ? "Claude" : "Codex",
+      ":"
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, children: /* @__PURE__ */ jsx2(RenderedMarkdown, { text: content }) })
+  ] });
+}
+function Header({ sessionId }) {
+  return /* @__PURE__ */ jsxs2(Box2, { marginBottom: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2500\u2500 " }),
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Tag Team" }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " \u2500\u2500 session " }),
+    /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: sessionId.slice(0, 7) }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " " + "\u2500".repeat(35) })
+  ] });
+}
+function UserMessage({ content }) {
+  return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "white", children: [
+      "You:",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { children: content })
+  ] });
+}
+function ThinkingIndicator({ agent }) {
+  const color = agent === "claude" ? "magenta" : "green";
+  const label = agent === "claude" ? "Claude" : "Codex";
+  return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color, children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) }),
+    /* @__PURE__ */ jsxs2(Text2, { color, children: [
+      " ",
+      label,
+      " is thinking..."
+    ] })
+  ] });
+}
+function DiscussionStatus({ round, maxRounds }) {
+  return /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, marginBottom: 1, children: /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+    "Discussion round ",
+    round,
+    "/",
+    maxRounds
+  ] }) });
+}
+function ConsensusReached() {
+  return /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, marginBottom: 1, children: /* @__PURE__ */ jsx2(Text2, { color: "green", bold: true, children: "Consensus reached." }) });
+}
+function PromptInput({
+  onSubmit
+}) {
+  const [value, setValue] = useState2("");
+  const handleSubmit = useCallback(
+    (submitted) => {
+      if (submitted.trim()) {
+        onSubmit(submitted.trim());
+        setValue("");
+      }
+    },
+    [onSubmit]
+  );
+  return /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: "white", children: "> " }),
+    /* @__PURE__ */ jsx2(
+      TextInput2,
+      {
+        value,
+        onChange: setValue,
+        onSubmit: handleSubmit,
+        showCursor: true
+      }
+    )
+  ] });
+}
+function App({
+  initialPrompt,
+  sessionId: existingSessionId,
+  claudeModel,
+  codexModel,
+  config,
+  showTranscript: showTranscript2,
+  discuss: initialDiscuss
+}) {
+  const { exit } = useApp2();
+  const [sessionId, setSessionId] = useState2(() => existingSessionId ?? nanoid(12));
+  const [messages, setMessages] = useState2(showTranscript2 ?? []);
+  const [state, setState] = useState2(
+    initialPrompt ? "running" : "input"
+  );
+  const [thinkingAgents, setThinkingAgents] = useState2([]);
+  const [discussionRound, setDiscussionRound] = useState2(0);
+  const [consensusReached, setConsensusReached] = useState2(false);
+  const [statusMessage, setStatusMessage] = useState2(null);
+  const [roundNum, setRoundNum] = useState2(() => {
+    if (showTranscript2 && showTranscript2.length > 0) {
+      return Math.max(...showTranscript2.map((m) => m.round)) + 1;
+    }
+    return 0;
+  });
+  useEffect(() => {
+    if (!existingSessionId) {
+      createSession(sessionId, process.cwd());
+    }
+  }, []);
+  useEffect(() => {
+    if (initialPrompt && state === "running") {
+      if (initialDiscuss) {
+        runDiscussion(initialPrompt);
+      } else {
+        runRound(initialPrompt);
+      }
+    }
+  }, []);
+  const abortRef = useRef(null);
+  const runningRoundRef = useRef(null);
+  useInput2((input, key) => {
+    if (key.ctrl && input === "c") {
+      abortRef.current?.abort();
+      closeDb();
+      exit();
+    }
+    if (key.escape && state === "running") {
+      abortRef.current?.abort();
+      abortRef.current = null;
+      if (runningRoundRef.current !== null) {
+        deleteMessagesFromRound(sessionId, runningRoundRef.current);
+        const fromRound = runningRoundRef.current;
+        setMessages((prev) => prev.filter((m) => m.round < fromRound));
+        runningRoundRef.current = null;
+      }
+      setThinkingAgents([]);
+      setDiscussionRound(0);
+      setStatusMessage("Interrupted.");
+      setState("input");
+    }
+  });
+  const runAgents = async (currentMessages, round, target, promptOverride, isDebate = false) => {
+    const runCl = target === "both" || target === "claude";
+    const runCx = target === "both" || target === "codex";
+    const activeAgents = [];
+    if (runCl) activeAgents.push("claude");
+    if (runCx) activeAgents.push("codex");
+    setThinkingAgents(activeAgents);
+    const history = formatConversationHistory(
+      currentMessages.map((m) => ({
+        role: m.role,
+        agent: m.role === "claude" || m.role === "codex" ? m.role : void 0,
+        content: m.content
+      }))
+    );
+    const cwd = process.cwd();
+    const isFirstRound = round === 0 && !existingSessionId;
+    const agentPrompt = (agent) => {
+      if (promptOverride) return promptOverride;
+      if (isFirstRound && target === "both") {
+        return currentMessages[currentMessages.length - 1]?.content || "";
+      }
+      return "Provide your response for this round.";
+    };
+    const agentSystemPrompt = (agent) => {
+      if (isDebate) {
+        if (isFirstRound) return debatePrompt(agent);
+        return debateRoundPrompt(agent, history);
+      }
+      if (isFirstRound && target === "both") return collaborationPrompt(agent);
+      return discussionPrompt(agent, history);
+    };
+    const ac = new AbortController();
+    abortRef.current = ac;
+    const results = [];
+    const promises = [];
+    if (runCl) {
+      promises.push(
+        runClaude({
+          prompt: agentPrompt("claude"),
+          systemPrompt: agentSystemPrompt("claude"),
+          model: claudeModel,
+          cwd,
+          signal: ac.signal
+        }).then(
+          (value) => {
+            results.push({ agent: "claude", result: { status: "fulfilled", value } });
+          },
+          (reason) => {
+            results.push({ agent: "claude", result: { status: "rejected", reason } });
+          }
+        )
+      );
+    }
+    if (runCx) {
+      promises.push(
+        runCodex({
+          prompt: agentPrompt("codex"),
+          systemPrompt: agentSystemPrompt("codex"),
+          model: codexModel,
+          cwd,
+          signal: ac.signal
+        }).then(
+          (value) => {
+            results.push({ agent: "codex", result: { status: "fulfilled", value } });
+          },
+          (reason) => {
+            results.push({ agent: "codex", result: { status: "rejected", reason } });
+          }
+        )
+      );
+    }
+    await Promise.all(promises);
+    abortRef.current = null;
+    if (ac.signal.aborted) return [];
+    setThinkingAgents([]);
+    const newMessages = [];
+    for (const { agent, result } of results) {
+      if (result.status === "fulfilled") {
+        const resp = result.value;
+        const msg = {
+          role: agent,
+          content: resp.error || resp.text,
+          round,
+          error: !!resp.error
+        };
+        newMessages.push(msg);
+        insertMessage({
+          sessionId,
+          role: agent,
+          content: resp.error || resp.text,
+          round,
+          durationMs: resp.durationMs
+        });
+      } else {
+        const errorMsg = result.reason?.message || "Failed to run";
+        const msg = {
+          role: agent,
+          content: errorMsg,
+          round,
+          error: true
+        };
+        newMessages.push(msg);
+        insertMessage({
+          sessionId,
+          role: agent,
+          content: `[Error: ${errorMsg}]`,
+          round
+        });
+      }
+    }
+    return newMessages;
+  };
+  const runRound = async (rawInput) => {
+    const { target, prompt, discuss } = parseInput(rawInput);
+    if (discuss) {
+      return runDiscussion(prompt);
+    }
+    const currentRound = roundNum;
+    runningRoundRef.current = currentRound;
+    const userMsg = {
+      role: "user",
+      content: rawInput,
+      round: currentRound
+    };
+    setMessages((prev) => [...prev, userMsg]);
+    insertMessage({
+      sessionId,
+      role: "user",
+      content: rawInput,
+      round: currentRound
+    });
+    const allMessages = [...messages, userMsg];
+    const newMessages = await runAgents(allMessages, currentRound, target);
+    if (newMessages.length === 0) return;
+    setMessages((prev) => [...prev, ...newMessages]);
+    setRoundNum(currentRound + 1);
+    runningRoundRef.current = null;
+    if (currentRound === 0 && !existingSessionId) {
+      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
+      updateSessionTitle(sessionId, title);
+    }
+    touchSession(sessionId);
+    setState("input");
+  };
+  const runDiscussion = async (prompt) => {
+    setConsensusReached(false);
+    let currentRound = roundNum;
+    runningRoundRef.current = currentRound;
+    const userMsg = {
+      role: "user",
+      content: `discuss ${prompt}`,
+      round: currentRound
+    };
+    setMessages((prev) => [...prev, userMsg]);
+    insertMessage({
+      sessionId,
+      role: "user",
+      content: `discuss ${prompt}`,
+      round: currentRound
+    });
+    let allMessages = [...messages, userMsg];
+    if (currentRound === 0 && !existingSessionId) {
+      const title = prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt;
+      updateSessionTitle(sessionId, title);
+    }
+    for (let disc = 1; disc <= config.discussion.max_rounds; disc++) {
+      setDiscussionRound(disc);
+      const newMessages = await runAgents(
+        allMessages,
+        currentRound,
+        "both",
+        disc === 1 ? prompt : "Provide your response for this round.",
+        true
+      );
+      if (newMessages.length === 0) break;
+      setMessages((prev) => [...prev, ...newMessages]);
+      allMessages = [...allMessages, ...newMessages];
+      currentRound++;
+      const claudeMsg = newMessages.find((m) => m.role === "claude" && !m.error);
+      const codexMsg = newMessages.find((m) => m.role === "codex" && !m.error);
+      const claudeConsensus = claudeMsg?.content.includes(CONSENSUS_MARKER) ?? false;
+      const codexConsensus = codexMsg?.content.includes(CONSENSUS_MARKER) ?? false;
+      if (claudeConsensus && codexConsensus) {
+        setConsensusReached(true);
+        break;
+      }
+    }
+    setRoundNum(currentRound);
+    setDiscussionRound(0);
+    runningRoundRef.current = null;
+    touchSession(sessionId);
+    setState("input");
+  };
+  const handleSubmit = (value) => {
+    setStatusMessage(null);
+    if (value === "/exit") {
+      closeDb();
+      exit();
+      return;
+    }
+    if (value === "/help") {
+      setStatusMessage(
+        [
+          "/help    Show this help",
+          "/config  Edit configuration",
+          "/new     Start a new session",
+          "/copy    Copy conversation to clipboard",
+          "/exit    Exit the app",
+          "",
+          "Esc      Interrupt running agents"
+        ].join("\n")
+      );
+      return;
+    }
+    if (value === "/config") {
+      setState("config");
+      return;
+    }
+    if (value === "/new") {
+      const newId = nanoid(12);
+      createSession(newId, process.cwd());
+      setSessionId(newId);
+      setMessages([]);
+      setRoundNum(0);
+      setConsensusReached(false);
+      setDiscussionRound(0);
+      setStatusMessage("Started new session.");
+      return;
+    }
+    if (value === "/copy") {
+      try {
+        const md = formatAsMarkdown(messages);
+        copyToClipboard(md);
+        setStatusMessage("Copied conversation to clipboard.");
+      } catch {
+        setStatusMessage("Failed to copy to clipboard.");
+      }
+      return;
+    }
+    setConsensusReached(false);
+    setState("running");
+    runRound(value);
+  };
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Header, { sessionId }),
+    messages.map((msg, i) => {
+      if (msg.role === "user") {
+        return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, i);
+      }
+      if (msg.role === "claude" || msg.role === "codex") {
+        return /* @__PURE__ */ jsx2(
+          AgentResponseBlock,
+          {
+            agent: msg.role,
+            content: msg.content,
+            error: msg.error
+          },
+          i
+        );
+      }
+      return null;
+    }),
+    discussionRound > 0 && thinkingAgents.length > 0 && /* @__PURE__ */ jsx2(DiscussionStatus, { round: discussionRound, maxRounds: config.discussion.max_rounds }),
+    thinkingAgents.length > 0 && /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", marginBottom: 1, children: thinkingAgents.map((agent) => /* @__PURE__ */ jsx2(ThinkingIndicator, { agent }, agent)) }),
+    consensusReached && /* @__PURE__ */ jsx2(ConsensusReached, {}),
+    statusMessage && /* @__PURE__ */ jsx2(Box2, { marginLeft: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, italic: true, children: statusMessage }) }),
+    state === "config" && /* @__PURE__ */ jsx2(
+      InlineConfigEditor,
+      {
+        isActive: state === "config",
+        onClose: () => setState("input")
+      }
+    ),
+    state === "input" && /* @__PURE__ */ jsx2(PromptInput, { onSubmit: handleSubmit })
+  ] });
+}
+function startApp(props) {
+  return render2(/* @__PURE__ */ jsx2(App, { ...props }));
+}
+function showTranscriptMarkdown(sessionId) {
+  const dbMessages = getMessages(sessionId);
+  const messages = dbMessages.map((m) => ({
+    role: m.role,
+    content: m.content,
+    round: m.round
+  }));
+  return formatAsMarkdown(messages);
+}
+function showTranscript(sessionId) {
+  const dbMessages = getMessages(sessionId);
+  const messages = dbMessages.map((m) => ({
+    role: m.role,
+    content: m.content,
+    round: m.round
+  }));
+  const { unmount } = render2(
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Header, { sessionId }),
+      messages.map((msg, i) => {
+        if (msg.role === "user") {
+          return /* @__PURE__ */ jsx2(UserMessage, { content: msg.content }, i);
+        }
+        if (msg.role === "claude" || msg.role === "codex") {
+          return /* @__PURE__ */ jsx2(AgentResponseBlock, { agent: msg.role, content: msg.content }, i);
+        }
+        return null;
+      }),
+      /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2500".repeat(60) }) })
+    ] })
+  );
+  unmount();
+}
+function showSessionList(sessions) {
+  const { unmount } = render2(
+    /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: sessions.length === 0 ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " No sessions found." }) : sessions.map((s) => /* @__PURE__ */ jsxs2(Box2, { marginLeft: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: s.id.slice(0, 7) }),
+      /* @__PURE__ */ jsx2(Text2, { children: "  " }),
+      /* @__PURE__ */ jsx2(Text2, { children: s.title || "(untitled)" }),
+      /* @__PURE__ */ jsx2(Text2, { children: "  " }),
+      /* @__PURE__ */ jsx2(Text2, { color: s.status === "active" ? "green" : void 0, dimColor: s.status !== "active", children: s.status }),
+      /* @__PURE__ */ jsx2(Text2, { children: "  " }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: s.updated_at })
+    ] }, s.id)) })
+  );
+  unmount();
+}
+
+// src/index.ts
+var program = new Command();
+program.name("tagteam").description("Tag Team - Orchestrate Claude and Codex collaboratively").version("0.1.0").option("--claude-model <model>", "Claude model to use").option("--codex-model <model>", "Codex model to use").argument("[prompt...]", "Prompt to send to both agents").action(async (promptParts, opts) => {
+  const config = loadConfig();
+  const prompt = promptParts.join(" ") || void 0;
+  const instance = startApp({
+    initialPrompt: prompt,
+    claudeModel: opts.claudeModel ?? config.claude.model,
+    codexModel: opts.codexModel ?? config.codex.model,
+    config
+  });
+  await instance.waitUntilExit();
+});
+program.command("discuss").description("Have Claude and Codex discuss a topic until they reach consensus").argument("<prompt...>", "Topic to discuss").action(async (promptParts) => {
+  const config = loadConfig();
+  const prompt = promptParts.join(" ");
+  const instance = startApp({
+    initialPrompt: prompt,
+    claudeModel: config.claude.model,
+    codexModel: config.codex.model,
+    config,
+    discuss: true
+  });
+  await instance.waitUntilExit();
+});
+program.command("continue").description("Resume the most recent session").action(async () => {
+  const config = loadConfig();
+  const session = getMostRecentSession();
+  if (!session) {
+    console.log(chalk.red(" No active sessions found."));
+    process.exit(1);
+  }
+  const dbMessages = getMessages(session.id);
+  const transcript = dbMessages.map((m) => ({
+    role: m.role,
+    content: m.content,
+    round: m.round
+  }));
+  const instance = startApp({
+    sessionId: session.id,
+    claudeModel: config.claude.model,
+    codexModel: config.codex.model,
+    config,
+    showTranscript: transcript
+  });
+  await instance.waitUntilExit();
+});
+program.command("resume [id]").description("Resume a session by ID, or pick interactively").action(async (id) => {
+  const config = loadConfig();
+  if (!id) {
+    const sessions = listSessions(20);
+    if (sessions.length === 0) {
+      console.log(chalk.red(" No sessions found."));
+      process.exit(1);
+    }
+    console.log(chalk.bold("\n Recent sessions:\n"));
+    sessions.forEach((s, i) => {
+      const sid = chalk.cyan(s.id.slice(0, 7));
+      const title = s.title || chalk.dim("(untitled)");
+      const date = chalk.dim(s.updated_at);
+      console.log(` ${chalk.dim(`${i + 1}.`)} ${sid}  ${title}  ${date}`);
+    });
+    console.log();
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(" Select session number: ", async (input) => {
+        rl.close();
+        const num = parseInt(input.trim(), 10);
+        if (isNaN(num) || num < 1 || num > sessions.length) {
+          console.log(chalk.red(" Invalid selection."));
+          closeDb();
+          resolve();
+          return;
+        }
+        const session2 = sessions[num - 1];
+        const dbMessages2 = getMessages(session2.id);
+        const transcript2 = dbMessages2.map((m) => ({
+          role: m.role,
+          content: m.content,
+          round: m.round
+        }));
+        const instance2 = startApp({
+          sessionId: session2.id,
+          claudeModel: config.claude.model,
+          codexModel: config.codex.model,
+          config,
+          showTranscript: transcript2
+        });
+        await instance2.waitUntilExit();
+        resolve();
+      });
+    });
+  }
+  const session = getSession(id) || getSessionByPrefix(id);
+  if (!session) {
+    console.log(chalk.red(` Session not found: ${id}`));
+    process.exit(1);
+  }
+  const dbMessages = getMessages(session.id);
+  const transcript = dbMessages.map((m) => ({
+    role: m.role,
+    content: m.content,
+    round: m.round
+  }));
+  const instance = startApp({
+    sessionId: session.id,
+    claudeModel: config.claude.model,
+    codexModel: config.codex.model,
+    config,
+    showTranscript: transcript
+  });
+  await instance.waitUntilExit();
+});
+program.command("history").description("List recent sessions").option("-n, --limit <n>", "Number of sessions to show", parseInt, 20).action((opts) => {
+  const sessions = listSessions(opts.limit);
+  console.log(chalk.bold("\n Recent sessions:\n"));
+  showSessionList(sessions);
+  console.log();
+  closeDb();
+});
+program.command("show <id>").description("Print full transcript for a session").option("-m, --markdown", "Output as GitHub-compatible markdown").action((id, opts) => {
+  const session = getSession(id) || getSessionByPrefix(id);
+  if (!session) {
+    console.log(chalk.red(` Session not found: ${id}`));
+    process.exit(1);
+  }
+  if (opts.markdown) {
+    process.stdout.write(showTranscriptMarkdown(session.id));
+  } else {
+    showTranscript(session.id);
+  }
+  closeDb();
+});
+var configCmd = program.command("config").description("Manage configuration").action(async () => {
+  const instance = startConfigEditor();
+  await instance.waitUntilExit();
+});
+configCmd.command("edit").description("Interactively edit configuration").action(async () => {
+  const instance = startConfigEditor();
+  await instance.waitUntilExit();
+});
+configCmd.command("show").description("Show current configuration").action(() => {
+  const config = loadConfig();
+  console.log(chalk.bold("\n Configuration:\n"));
+  console.log(
+    chalk.dim(" claude.model = ") + chalk.white(config.claude.model)
+  );
+  console.log(
+    chalk.dim(" codex.model  = ") + chalk.white(config.codex.model)
+  );
+  console.log(
+    chalk.dim(" discussion.max_rounds = ") + chalk.white(String(config.discussion.max_rounds))
+  );
+  console.log();
+});
+configCmd.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+  try {
+    setConfigValue(key, value);
+    console.log(chalk.green(` Set ${key} = ${value}`));
+  } catch (e) {
+    console.log(chalk.red(` ${e.message}`));
+    process.exit(1);
+  }
+});
+program.parseAsync();
+//# sourceMappingURL=index.js.map