@indexnetwork/cli 0.7.0

package/dist/index.js

@@ -0,0 +1,2040 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { execFile } from "node:child_process";
+
+// src/args.parser.ts
+var KNOWN_COMMANDS = new Set(["login", "logout", "profile", "intent", "opportunity", "network", "conversation", "help", "version"]);
+var OPPORTUNITY_SUBCOMMANDS = new Set(["list", "show", "accept", "reject"]);
+var NETWORK_SUBCOMMANDS = new Set(["list", "create", "show", "join", "leave", "invite"]);
+var CONVERSATION_SUBCOMMANDS = new Set(["list", "with", "show", "send", "stream", "sessions", "help"]);
+function parseArgs(args) {
+  const result = {
+    command: "help",
+    list: false
+  };
+  if (args.length === 0) {
+    return result;
+  }
+  const first = args[0];
+  if (first === "--help" || first === "-h") {
+    result.command = "help";
+    return result;
+  }
+  if (first === "--version" || first === "-v") {
+    result.command = "version";
+    return result;
+  }
+  if (!KNOWN_COMMANDS.has(first)) {
+    result.command = "unknown";
+    result.unknown = first;
+    return result;
+  }
+  result.command = first;
+  let i = 1;
+  const positionals = [];
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--list" || arg === "-l") {
+      result.list = true;
+      i++;
+    } else if (arg === "--session" || arg === "-s") {
+      result.sessionId = args[i + 1];
+      i += 2;
+    } else if (arg === "--api-url") {
+      result.apiUrl = args[i + 1];
+      i += 2;
+    } else if (arg === "--app-url") {
+      result.appUrl = args[i + 1];
+      i += 2;
+    } else if (arg === "--token" || arg === "-t") {
+      result.token = args[i + 1];
+      i += 2;
+    } else if (arg === "--archived") {
+      result.archived = true;
+      i++;
+    } else if (arg === "--status") {
+      result.status = args[i + 1];
+      i += 2;
+    } else if (arg === "--limit") {
+      result.limit = parseInt(args[i + 1], 10);
+      i += 2;
+    } else if (arg === "--prompt" || arg === "-p") {
+      result.prompt = args[i + 1];
+      i += 2;
+    } else if (arg.startsWith("--")) {
+      i++;
+    } else {
+      positionals.push(arg);
+      i++;
+    }
+  }
+  if (result.command === "opportunity") {
+    const sub = positionals[0];
+    if (sub && OPPORTUNITY_SUBCOMMANDS.has(sub)) {
+      result.subcommand = sub;
+      if (positionals[1]) {
+        result.targetId = positionals[1];
+      }
+    }
+    return result;
+  }
+  if (result.command === "profile" && positionals.length > 0) {
+    const sub = positionals[0];
+    if (sub === "show") {
+      result.subcommand = "show";
+      if (positionals[1]) {
+        result.userId = positionals[1];
+      }
+    } else if (sub === "sync") {
+      result.subcommand = "sync";
+    }
+  }
+  if (result.command === "intent") {
+    parseIntentArgs(positionals, result);
+  }
+  if (result.command === "network") {
+    if (positionals.length > 0 && NETWORK_SUBCOMMANDS.has(positionals[0])) {
+      result.subcommand = positionals[0];
+      result.positionals = positionals.slice(1);
+    } else if (positionals.length > 0) {
+      result.positionals = positionals;
+    }
+  }
+  if (result.command === "conversation") {
+    if (positionals.length > 0 && CONVERSATION_SUBCOMMANDS.has(positionals[0])) {
+      result.subcommand = positionals[0];
+      result.positionals = positionals.slice(1);
+    } else if (positionals.length > 0) {
+      result.message = positionals.join(" ");
+    }
+  }
+  return result;
+}
+var INTENT_SUBCOMMANDS = new Set(["list", "show", "create", "archive"]);
+function parseIntentArgs(positionals, result) {
+  if (positionals.length === 0)
+    return;
+  const sub = positionals[0];
+  if (!INTENT_SUBCOMMANDS.has(sub))
+    return;
+  result.subcommand = sub;
+  const rest = positionals.slice(1);
+  switch (result.subcommand) {
+    case "show":
+    case "archive":
+      result.intentId = rest[0];
+      break;
+    case "create":
+      if (rest.length > 0) {
+        result.intentContent = rest.join(" ");
+      }
+      break;
+  }
+}
+
+// src/auth.store.ts
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { mkdir, readFile, writeFile, unlink } from "node:fs/promises";
+var CREDENTIALS_FILE = "credentials.json";
+
+class CredentialStore {
+  dir;
+  filePath;
+  constructor(dir) {
+    this.dir = dir ?? join(homedir(), ".index");
+    this.filePath = join(this.dir, CREDENTIALS_FILE);
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed.token && parsed.apiUrl) {
+        return parsed;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async save(credentials) {
+    await mkdir(this.dir, { recursive: true });
+    await writeFile(this.filePath, JSON.stringify(credentials, null, 2), {
+      mode: 384
+    });
+  }
+  async clear() {
+    try {
+      await unlink(this.filePath);
+    } catch {}
+  }
+}
+
+// src/api.client.ts
+class ApiClient {
+  baseUrl;
+  token;
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = token;
+  }
+  async listSessions() {
+    const res = await this.get("/api/chat/sessions");
+    const body = await res.json();
+    return body.sessions;
+  }
+  async getMe() {
+    const res = await this.get("/api/auth/me");
+    const body = await res.json();
+    return body.user;
+  }
+  async getUser(userId) {
+    const res = await this.get(`/api/users/${userId}`);
+    const body = await res.json();
+    return body.user;
+  }
+  async syncProfile() {
+    const res = await this.post("/api/profiles/sync");
+    const body = await res.json();
+    return body;
+  }
+  async listOpportunities(opts) {
+    const params = new URLSearchParams;
+    if (opts?.status)
+      params.set("status", opts.status);
+    if (opts?.limit)
+      params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    const path = qs ? `/api/opportunities?${qs}` : "/api/opportunities";
+    const res = await this.get(path);
+    const body = await res.json();
+    return body.opportunities;
+  }
+  async getOpportunity(id) {
+    const res = await this.get(`/api/opportunities/${id}`);
+    return await res.json();
+  }
+  async updateOpportunityStatus(id, status) {
+    const res = await this.patch(`/api/opportunities/${id}/status`, { status });
+    return await res.json();
+  }
+  async streamChat(params) {
+    const res = await fetch(`${this.baseUrl}/api/chat/stream`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      body: JSON.stringify({
+        message: params.message,
+        ...params.sessionId ? { sessionId: params.sessionId } : {}
+      })
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async listIntents(options = {}) {
+    const body = {};
+    if (options.limit !== undefined)
+      body.limit = options.limit;
+    if (options.archived !== undefined)
+      body.archived = options.archived;
+    if (options.sourceType !== undefined)
+      body.sourceType = options.sourceType;
+    if (options.page !== undefined)
+      body.page = options.page;
+    const res = await this.post("/api/intents/list", body);
+    return await res.json();
+  }
+  async getIntent(id) {
+    const res = await this.get(`/api/intents/${id}`);
+    const body = await res.json();
+    return body.intent;
+  }
+  async processIntent(content) {
+    const res = await this.post("/api/intents/process", { content });
+    return await res.json();
+  }
+  async archiveIntent(id) {
+    const res = await this.patch(`/api/intents/${id}/archive`);
+    return await res.json();
+  }
+  async listNetworks() {
+    const res = await this.get("/api/indexes");
+    const body = await res.json();
+    return body.indexes;
+  }
+  async createNetwork(title, prompt) {
+    const res = await this.post("/api/indexes", {
+      title,
+      ...prompt ? { prompt } : {}
+    });
+    const body = await res.json();
+    return body.index;
+  }
+  async getNetwork(id) {
+    const res = await this.get(`/api/indexes/${id}`);
+    const body = await res.json();
+    return body.index;
+  }
+  async getNetworkMembers(id) {
+    const res = await this.get(`/api/indexes/${id}/members`);
+    const body = await res.json();
+    return body.members;
+  }
+  async joinNetwork(id) {
+    const res = await this.post(`/api/indexes/${id}/join`, {});
+    const body = await res.json();
+    return body.index;
+  }
+  async leaveNetwork(id) {
+    await this.post(`/api/indexes/${id}/leave`, {});
+  }
+  async searchUsers(query, indexId) {
+    const params = new URLSearchParams({ q: query });
+    if (indexId)
+      params.set("indexId", indexId);
+    const res = await this.get(`/api/indexes/search-users?${params.toString()}`);
+    const body = await res.json();
+    return body.users;
+  }
+  async addNetworkMember(networkId, userId) {
+    const res = await this.post(`/api/indexes/${networkId}/members`, { userId });
+    const body = await res.json();
+    return body;
+  }
+  async listConversations() {
+    const res = await this.get("/api/conversations");
+    const body = await res.json();
+    return body.conversations;
+  }
+  async getOrCreateDM(peerUserId) {
+    const res = await this.post("/api/conversations/dm", { peerUserId });
+    const body = await res.json();
+    return body.conversation;
+  }
+  async getMessages(conversationId, opts) {
+    const params = new URLSearchParams;
+    if (opts?.limit)
+      params.set("limit", String(opts.limit));
+    if (opts?.before)
+      params.set("before", opts.before);
+    const qs = params.toString();
+    const path = qs ? `/api/conversations/${conversationId}/messages?${qs}` : `/api/conversations/${conversationId}/messages`;
+    const res = await this.get(path);
+    const body = await res.json();
+    return body.messages;
+  }
+  async sendMessage(conversationId, text) {
+    const res = await this.post(`/api/conversations/${conversationId}/messages`, {
+      parts: [{ type: "text", text }]
+    });
+    const body = await res.json();
+    return body.message;
+  }
+  async hideConversation(conversationId) {
+    await this.del(`/api/conversations/${conversationId}`);
+  }
+  async streamConversationEvents() {
+    const res = await fetch(`${this.baseUrl}/api/conversations/stream`, {
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "text/event-stream"
+      }
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async get(path) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async post(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      ...body !== undefined ? { body: JSON.stringify(body) } : {}
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async patch(path, body) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.token}`
+      },
+      ...body !== undefined ? { body: JSON.stringify(body) } : {}
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async del(path) {
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+    if (!res.ok) {
+      await this.handleError(res);
+    }
+    return res;
+  }
+  async handleError(res) {
+    if (res.status === 401) {
+      throw new Error("Session expired or invalid. Run `index login` to re-authenticate.");
+    }
+    let message = `HTTP ${res.status}`;
+    try {
+      const body = await res.json();
+      if (body.error)
+        message = body.error;
+    } catch {}
+    throw new Error(message);
+  }
+}
+
+// src/login.command.ts
+import { createServer } from "node:http";
+function closeServer(server) {
+  return new Promise((resolve) => {
+    server.close(() => resolve());
+    server.closeAllConnections();
+  });
+}
+async function handleLogin(apiUrl, appUrl, store, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 120000;
+  const baseUrl = apiUrl.replace(/\/$/, "");
+  const baseAppUrl = appUrl.replace(/\/$/, "");
+  let resolveCallback;
+  const callbackPromise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost`);
+    if (url.pathname === "/callback") {
+      const sessionToken = url.searchParams.get("session_token");
+      if (sessionToken) {
+        await store.save({ token: sessionToken, apiUrl: baseUrl });
+        resolveCallback({ success: true });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(callbackHtml("CLI authorized", "You can close this window and return to the terminal."));
+        return;
+      }
+      resolveCallback({
+        success: false,
+        error: "No session token received in callback."
+      });
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(callbackHtml("Authorization failed", "No session token received. Please try again."));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+  });
+  await new Promise((resolve) => {
+    server.listen(0, () => resolve());
+  });
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : 0;
+  const callbackUrl = `http://localhost:${port}/callback`;
+  const authUrl = `${baseAppUrl}/cli-auth?callback=${encodeURIComponent(callbackUrl)}`;
+  const timeout = setTimeout(() => {
+    resolveCallback({
+      success: false,
+      error: "Login timed out. No callback received."
+    });
+    closeServer(server);
+  }, timeoutMs);
+  if (options.signal) {
+    options.signal.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      closeServer(server);
+      resolveCallback({
+        success: false,
+        error: "Login cancelled."
+      });
+    });
+  }
+  const wrappedPromise = callbackPromise.then(async (result) => {
+    clearTimeout(timeout);
+    await new Promise((r) => setTimeout(r, 100));
+    await closeServer(server);
+    return result;
+  });
+  return {
+    authUrl,
+    port,
+    callbackPromise: wrappedPromise
+  };
+}
+function callbackHtml(title, message) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title} — Index</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Public+Sans:wght@400;500;600&display=swap" rel="stylesheet" />
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: 'Public Sans', -apple-system, BlinkMacSystemFont, sans-serif;
+      background: #FDFDFD;
+      color: #111;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .card {
+      text-align: center;
+      max-width: 400px;
+      padding: 2rem;
+    }
+    h1 {
+      font-size: 1.25rem;
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+    }
+    p {
+      font-size: 0.875rem;
+      color: #666;
+      line-height: 1.5;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>${title}</h1>
+    <p>${message}</p>
+  </div>
+</body>
+</html>`;
+}
+
+// src/output/base.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var ITALIC = "\x1B[3m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var MAGENTA = "\x1B[35m";
+var CYAN = "\x1B[36m";
+var WHITE = "\x1B[37m";
+var GRAY = "\x1B[90m";
+var ORANGE = "\x1B[38;5;208m";
+var AGENT_TEXT = "\x1B[38;5;252m";
+var USER_PROMPT = CYAN;
+function error(message, exitCode) {
+  console.error(`${RED}${BOLD}error${RESET}${RED}: ${message}${RESET}`);
+  if (exitCode !== undefined) {
+    process.exit(exitCode);
+  }
+}
+function success(message) {
+  console.log(`${GREEN}${BOLD}+${RESET} ${message}`);
+}
+function info(message) {
+  console.log(`${CYAN}${message}${RESET}`);
+}
+function dim(message) {
+  console.log(`${GRAY}${message}${RESET}`);
+}
+function heading(message) {
+  console.log(`
+${BOLD}${message}${RESET}`);
+}
+function chatHeader() {
+  console.log();
+  console.log(`  ${BOLD}${CYAN}I N D E X${RESET}  ${GRAY}chat${RESET}`);
+  console.log(`  ${GRAY}─────────────────────────────────────${RESET}`);
+  console.log(`  ${GRAY}Type your message. "exit" or Ctrl+C to quit.${RESET}`);
+  console.log();
+}
+var PROMPT_STR = `${USER_PROMPT}${BOLD}> ${RESET}`;
+function status(message) {
+  process.stderr.write(`\r  ${GRAY}${message}${RESET}\x1B[K`);
+}
+function clearStatus() {
+  process.stderr.write("\r\x1B[K");
+}
+function toolActivity(description) {
+  process.stderr.write(`\r\x1B[K${ORANGE}> ${description}${RESET}
+`);
+}
+var TOOL_DESCRIPTIONS = {
+  read_user_profiles: "Reading your profile...",
+  create_user_profile: "Creating your profile...",
+  update_user_profile: "Updating your profile...",
+  read_intents: "Fetching your active signals...",
+  create_intent: "Creating a new signal...",
+  update_intent: "Updating signal...",
+  delete_intent: "Removing signal...",
+  create_intent_index: "Saving signal to index...",
+  read_intent_indexes: "Fetching signals in index...",
+  delete_intent_index: "Removing signal from index...",
+  read_indexes: "Checking your indexes...",
+  create_index: "Creating a new index...",
+  update_index: "Updating index...",
+  delete_index: "Deleting index...",
+  create_index_membership: "Adding member to index...",
+  read_index_memberships: "Fetching index memberships...",
+  create_opportunities: "Searching for relevant connections...",
+  list_my_opportunities: "Listing your opportunities...",
+  update_opportunity: "Updating opportunity status...",
+  scrape_url: "Reading content from URL...",
+  read_docs: "Looking up documentation...",
+  import_gmail_contacts: "Importing Gmail contacts...",
+  import_contacts: "Importing contacts...",
+  list_contacts: "Listing your contacts...",
+  add_contact: "Adding contact...",
+  remove_contact: "Removing contact...",
+  send_opportunity: "Sending opportunity..."
+};
+function humanizeToolName(name) {
+  return TOOL_DESCRIPTIONS[name] ?? name.replace(/_/g, " ") + "...";
+}
+function wordWrap(text, maxWidth) {
+  const lines = [];
+  const words = text.split(/\s+/);
+  let current = "";
+  for (const word of words) {
+    if (current.length + word.length + 1 > maxWidth && current.length > 0) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current ? `${current} ${word}` : word;
+    }
+  }
+  if (current)
+    lines.push(current);
+  return lines;
+}
+function confidenceBar(confidence) {
+  const pct = Math.round(confidence);
+  const filled = Math.round(pct / 10);
+  const empty = 10 - filled;
+  return `${GREEN}${"#".repeat(filled)}${GRAY}${"-".repeat(empty)}${RESET} ${GRAY}${pct}%`;
+}
+function padTo(cellWidth, plainText) {
+  const remaining = Math.max(0, cellWidth - plainText.length);
+  return " ".repeat(remaining);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+// src/output/markdown.ts
+class MarkdownRenderer {
+  buffer = "";
+  inCodeBlock = false;
+  codeBlockLang = "";
+  codeBlockContent = "";
+  pristine = true;
+  write(text) {
+    this.buffer += text;
+    this.flush();
+  }
+  flush() {
+    while (this.buffer.length > 0) {
+      if (this.inCodeBlock) {
+        const endIdx = this.buffer.indexOf("```");
+        if (endIdx !== -1) {
+          this.codeBlockContent += this.buffer.slice(0, endIdx);
+          this.buffer = this.buffer.slice(endIdx + 3);
+          if (this.buffer.startsWith(`
+`)) {
+            this.buffer = this.buffer.slice(1);
+          }
+          this.renderCodeBlock();
+          this.inCodeBlock = false;
+          this.codeBlockLang = "";
+          this.codeBlockContent = "";
+          continue;
+        }
+        this.codeBlockContent += this.buffer;
+        this.buffer = "";
+        return;
+      }
+      const codeBlockMatch = this.buffer.match(/^```([^\n]*)\n/);
+      if (codeBlockMatch) {
+        this.codeBlockLang = codeBlockMatch[1].trim();
+        this.buffer = this.buffer.slice(codeBlockMatch[0].length);
+        this.inCodeBlock = true;
+        this.codeBlockContent = "";
+        continue;
+      }
+      if (this.buffer.startsWith("```")) {
+        return;
+      }
+      const nlIdx = this.buffer.indexOf(`
+`);
+      if (nlIdx === -1) {
+        return;
+      }
+      const line = this.buffer.slice(0, nlIdx);
+      this.buffer = this.buffer.slice(nlIdx + 1);
+      this.emitLine(line);
+    }
+  }
+  emitLine(line) {
+    if (this.pristine) {
+      process.stdout.write(`
+`);
+      this.pristine = false;
+    }
+    const rendered = this.renderLine(line);
+    process.stdout.write(rendered + `
+`);
+  }
+  renderLine(line) {
+    const bulletMatch = line.match(/^(\s*)([-*])\s+(.*)$/);
+    if (bulletMatch) {
+      const [, indent, , content] = bulletMatch;
+      return `${indent}  ${CYAN}*${RESET} ${this.renderInline(content)}`;
+    }
+    const numMatch = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
+    if (numMatch) {
+      const [, indent, num, content] = numMatch;
+      return `${indent}  ${CYAN}${num}.${RESET} ${this.renderInline(content)}`;
+    }
+    if (line.startsWith("### ")) {
+      return `${BOLD}${WHITE}${line.slice(4)}${RESET}`;
+    }
+    if (line.startsWith("## ")) {
+      return `${BOLD}${WHITE}${line.slice(3)}${RESET}`;
+    }
+    if (line.startsWith("# ")) {
+      return `${BOLD}${WHITE}${line.slice(2)}${RESET}`;
+    }
+    return this.renderInline(line);
+  }
+  renderInline(text) {
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${BOLD}${ITALIC}${WHITE}$1${RESET}${AGENT_TEXT}`);
+    text = text.replace(/\*\*(.+?)\*\*/g, `${BOLD}${WHITE}$1${RESET}${AGENT_TEXT}`);
+    text = text.replace(/(?<!\*)\*([^*]+?)\*(?!\*)/g, `${ITALIC}$1${RESET}${AGENT_TEXT}`);
+    text = text.replace(/`([^`]+)`/g, `${CYAN}$1${RESET}${AGENT_TEXT}`);
+    return `${AGENT_TEXT}${text}${RESET}`;
+  }
+  renderCodeBlock() {
+    const lang = this.codeBlockLang;
+    const content = this.codeBlockContent.trimEnd();
+    if (!this.pristine) {
+      process.stdout.write(`
+`);
+    }
+    this.pristine = false;
+    if (lang === "intent_proposal") {
+      this.renderIntentProposal(content);
+      return;
+    }
+    if (lang === "opportunity") {
+      this.renderOpportunity(content);
+      return;
+    }
+    const border = `${GRAY}|${RESET}`;
+    if (lang) {
+      process.stdout.write(`  ${GRAY}--- ${lang} ${"─".repeat(Math.max(0, 40 - lang.length))}${RESET}
+`);
+    } else {
+      process.stdout.write(`  ${GRAY}${"─".repeat(46)}${RESET}
+`);
+    }
+    for (const line of content.split(`
+`)) {
+      process.stdout.write(`  ${border} ${CYAN}${line}${RESET}
+`);
+    }
+    process.stdout.write(`  ${GRAY}${"─".repeat(46)}${RESET}
+
+`);
+  }
+  renderIntentProposal(content) {
+    try {
+      const data = JSON.parse(content);
+      const desc = data.description ?? content;
+      const confidence = data.confidence;
+      process.stdout.write(`  ${MAGENTA}+${"─".repeat(56)}+${RESET}
+`);
+      process.stdout.write(`  ${MAGENTA}|${RESET} ${BOLD}${MAGENTA}Signal Proposal${RESET}${" ".repeat(40)}${MAGENTA}|${RESET}
+`);
+      process.stdout.write(`  ${MAGENTA}|${RESET}${" ".repeat(56)}${MAGENTA}|${RESET}
+`);
+      const wrapped = wordWrap(desc, 52);
+      for (const line of wrapped) {
+        const pad = Math.max(0, 54 - line.length);
+        process.stdout.write(`  ${MAGENTA}|${RESET}  ${AGENT_TEXT}${line}${RESET}${" ".repeat(pad)}${MAGENTA}|${RESET}
+`);
+      }
+      if (confidence !== undefined) {
+        process.stdout.write(`  ${MAGENTA}|${RESET}${" ".repeat(56)}${MAGENTA}|${RESET}
+`);
+        const bar = confidenceBar(confidence);
+        process.stdout.write(`  ${MAGENTA}|${RESET}  ${GRAY}Confidence: ${bar}${RESET}${" ".repeat(24)}${MAGENTA}|${RESET}
+`);
+      }
+      process.stdout.write(`  ${MAGENTA}+${"─".repeat(56)}+${RESET}
+
+`);
+    } catch {
+      process.stdout.write(`  ${GRAY}${content}${RESET}
+
+`);
+    }
+  }
+  renderOpportunity(content) {
+    try {
+      const data = JSON.parse(content);
+      process.stdout.write(`  ${BLUE}+${"─".repeat(56)}+${RESET}
+`);
+      process.stdout.write(`  ${BLUE}|${RESET} ${BOLD}${BLUE}Opportunity${RESET}${" ".repeat(44)}${BLUE}|${RESET}
+`);
+      if (data.title) {
+        const pad = Math.max(0, 54 - data.title.length);
+        process.stdout.write(`  ${BLUE}|${RESET}  ${BOLD}${data.title}${RESET}${" ".repeat(pad)}${BLUE}|${RESET}
+`);
+      }
+      if (data.description) {
+        process.stdout.write(`  ${BLUE}|${RESET}${" ".repeat(56)}${BLUE}|${RESET}
+`);
+        const wrapped = wordWrap(data.description, 52);
+        for (const line of wrapped) {
+          const pad = Math.max(0, 54 - line.length);
+          process.stdout.write(`  ${BLUE}|${RESET}  ${AGENT_TEXT}${line}${RESET}${" ".repeat(pad)}${BLUE}|${RESET}
+`);
+        }
+      }
+      process.stdout.write(`  ${BLUE}+${"─".repeat(56)}+${RESET}
+
+`);
+    } catch {
+      process.stdout.write(`  ${GRAY}${content}${RESET}
+
+`);
+    }
+  }
+  reset(reason) {
+    if (this.buffer.length > 0 || this.inCodeBlock) {
+      this.buffer = "";
+      this.inCodeBlock = false;
+      this.codeBlockContent = "";
+      this.codeBlockLang = "";
+    }
+    if (!this.pristine) {
+      process.stdout.write(`
+${GRAY}--- retrying${reason ? `: ${reason}` : ""} ---${RESET}
+`);
+    }
+    this.pristine = true;
+  }
+  finalize() {
+    if (this.inCodeBlock) {
+      this.renderCodeBlock();
+      this.inCodeBlock = false;
+    }
+    if (this.buffer.length > 0) {
+      this.emitLine(this.buffer);
+      this.buffer = "";
+    }
+  }
+}
+// src/output/formatters.ts
+function profileCard(data) {
+  const lines = [];
+  const W = 56;
+  const border = (ch) => `${CYAN}${ch}${RESET}`;
+  const hline = `  ${border("+")}${CYAN}${"─".repeat(W)}${RESET}${border("+")}`;
+  lines.push("");
+  lines.push(hline);
+  const displayName = data.name ?? "(unnamed)";
+  const ghostTag = data.isGhost ? `  ${YELLOW}[ghost]${RESET}` : "";
+  const nameContent = `${BOLD}${WHITE}${displayName}${RESET}${ghostTag}`;
+  lines.push(`  ${border("|")} ${nameContent}${padTo(W - 2, stripAnsi(displayName + (data.isGhost ? "  [ghost]" : "")))}${border("|")}`);
+  if (data.intro) {
+    lines.push(`  ${border("|")}${" ".repeat(W)}${border("|")}`);
+    const wrapped = wordWrap(data.intro, W - 4);
+    for (const line of wrapped) {
+      lines.push(`  ${border("|")}  ${AGENT_TEXT}${line}${RESET}${padTo(W - 2, line)}${border("|")}`);
+    }
+  }
+  if (data.location) {
+    lines.push(`  ${border("|")}${" ".repeat(W)}${border("|")}`);
+    const locLine = `Location: ${data.location}`;
+    lines.push(`  ${border("|")}  ${GRAY}${locLine}${RESET}${padTo(W - 2, locLine)}${border("|")}`);
+  }
+  if (data.socials && Object.keys(data.socials).length > 0) {
+    lines.push(`  ${border("|")}${" ".repeat(W)}${border("|")}`);
+    for (const [platform, url] of Object.entries(data.socials)) {
+      const socialLine = `${platform}: ${url}`;
+      lines.push(`  ${border("|")}  ${BLUE}${socialLine}${RESET}${padTo(W - 2, socialLine)}${border("|")}`);
+    }
+  }
+  const since = new Date(data.createdAt).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+  const sinceLine = `Member since ${since}`;
+  lines.push(`  ${border("|")}${" ".repeat(W)}${border("|")}`);
+  lines.push(`  ${border("|")}  ${DIM}${sinceLine}${RESET}${padTo(W - 2, sinceLine)}${border("|")}`);
+  lines.push(hline);
+  lines.push("");
+  const output = lines.join(`
+`);
+  console.log(output);
+  return output;
+}
+function sessionTable(sessions) {
+  if (sessions.length === 0) {
+    dim("  No chat sessions found.");
+    return;
+  }
+  const idWidth = 36;
+  const titleWidth = 40;
+  const dateWidth = 20;
+  console.log(`  ${BOLD}${"ID".padEnd(idWidth)}  ${"Title".padEnd(titleWidth)}  ${"Created".padEnd(dateWidth)}${RESET}`);
+  console.log(`  ${GRAY}${"-".repeat(idWidth)}  ${"-".repeat(titleWidth)}  ${"-".repeat(dateWidth)}${RESET}`);
+  for (const s of sessions) {
+    const title = (s.title ?? "(untitled)").slice(0, titleWidth);
+    const date = new Date(s.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    console.log(`  ${GRAY}${s.id.padEnd(idWidth)}${RESET}  ${title.padEnd(titleWidth)}  ${GRAY}${date}${RESET}`);
+  }
+}
+function intentTable(intents) {
+  if (intents.length === 0) {
+    dim("  No signals found.");
+    return;
+  }
+  const descWidth = 50;
+  const statusWidth = 10;
+  const sourceWidth = 16;
+  const dateWidth = 20;
+  console.log(`  ${BOLD}${"Signal".padEnd(descWidth)}  ${"Status".padEnd(statusWidth)}  ${"Source".padEnd(sourceWidth)}  ${"Created".padEnd(dateWidth)}${RESET}`);
+  console.log(`  ${GRAY}${"-".repeat(descWidth)}  ${"-".repeat(statusWidth)}  ${"-".repeat(sourceWidth)}  ${"-".repeat(dateWidth)}${RESET}`);
+  for (const intent of intents) {
+    const desc = (intent.summary ?? intent.payload).slice(0, descWidth);
+    const status2 = (intent.status ?? "").padEnd(statusWidth);
+    const source = (intent.sourceType ?? "-").padEnd(sourceWidth);
+    const date = new Date(intent.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+    const sColor = intent.status === "ACTIVE" ? GREEN : GRAY;
+    console.log(`  ${desc.padEnd(descWidth)}  ${sColor}${status2}${RESET}  ${GRAY}${source}${RESET}  ${GRAY}${date}${RESET}`);
+  }
+}
+function intentCard(intent) {
+  console.log();
+  console.log(`  ${BOLD}${CYAN}Signal Details${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(50)}${RESET}`);
+  console.log(`  ${BOLD}ID${RESET}            ${GRAY}${intent.id}${RESET}`);
+  console.log(`  ${BOLD}Status${RESET}        ${intent.status === "ACTIVE" ? GREEN : GRAY}${intent.status}${RESET}`);
+  if (intent.summary) {
+    console.log(`  ${BOLD}Summary${RESET}       ${intent.summary}`);
+  }
+  console.log();
+  console.log(`  ${BOLD}Description${RESET}`);
+  console.log(`  ${intent.payload}`);
+  if (intent.speechActType) {
+    console.log();
+    console.log(`  ${BOLD}Speech Act${RESET}    ${intent.speechActType}`);
+  }
+  if (intent.intentMode) {
+    console.log(`  ${BOLD}Mode${RESET}          ${intent.intentMode}`);
+  }
+  if (intent.sourceType) {
+    console.log(`  ${BOLD}Source${RESET}        ${intent.sourceType}`);
+  }
+  if (intent.confidence !== undefined) {
+    console.log(`  ${BOLD}Confidence${RESET}    ${confidenceBar(intent.confidence)}`);
+  }
+  if (intent.semanticEntropy !== undefined) {
+    console.log(`  ${BOLD}Entropy${RESET}       ${intent.semanticEntropy.toFixed(2)}`);
+  }
+  if (intent.isIncognito) {
+    console.log(`  ${BOLD}Incognito${RESET}     ${YELLOW}Yes${RESET}`);
+  }
+  console.log();
+  console.log(`  ${BOLD}Created${RESET}       ${GRAY}${new Date(intent.createdAt).toLocaleString()}${RESET}`);
+  console.log(`  ${BOLD}Updated${RESET}       ${GRAY}${new Date(intent.updatedAt).toLocaleString()}${RESET}`);
+  if (intent.archivedAt) {
+    console.log(`  ${BOLD}Archived${RESET}      ${GRAY}${new Date(intent.archivedAt).toLocaleString()}${RESET}`);
+  }
+  if (intent.indexes && intent.indexes.length > 0) {
+    console.log();
+    console.log(`  ${BOLD}Index Assignments${RESET}`);
+    for (const idx of intent.indexes) {
+      const score = idx.relevancyScore !== undefined ? ` (${idx.relevancyScore.toFixed(2)})` : "";
+      console.log(`  ${CYAN}*${RESET} ${idx.title}${GRAY}${score}${RESET}`);
+    }
+  }
+  console.log(`  ${GRAY}${"─".repeat(50)}${RESET}`);
+  console.log();
+}
+var ROLE_LABELS = {
+  agent: { label: "Helper", color: GREEN },
+  patient: { label: "Seeker", color: YELLOW },
+  peer: { label: "Peer", color: CYAN }
+};
+function roleLabel(role) {
+  const entry = role ? ROLE_LABELS[role] : undefined;
+  if (!entry)
+    return `${GRAY}Unknown${RESET}`;
+  return `${entry.color}${entry.label}${RESET}`;
+}
+function opportunityTable(opportunities) {
+  if (opportunities.length === 0) {
+    dim("  No opportunities found.");
+    return;
+  }
+  const nameW = 24;
+  const catW = 20;
+  const statusW = 10;
+  const confW = 8;
+  const dateW = 20;
+  process.stdout.write(`  ${BOLD}${"Counterparty".padEnd(nameW)}  ${"Category".padEnd(catW)}  ${"Status".padEnd(statusW)}  ${"Conf".padEnd(confW)}  ${"Created".padEnd(dateW)}${RESET}
+`);
+  process.stdout.write(`  ${GRAY}${"-".repeat(nameW)}  ${"-".repeat(catW)}  ${"-".repeat(statusW)}  ${"-".repeat(confW)}  ${"-".repeat(dateW)}${RESET}
+`);
+  for (const opp of opportunities) {
+    const name = (opp.counterpartName ?? "Unknown").slice(0, nameW);
+    const category = (opp.interpretation?.category ?? "-").slice(0, catW);
+    const st = opp.status.slice(0, statusW);
+    const conf = opp.interpretation?.confidence != null ? `${opp.interpretation.confidence}%` : "-";
+    const date = opp.createdAt ? new Date(opp.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }) : "-";
+    process.stdout.write(`  ${name.padEnd(nameW)}  ${GRAY}${category.padEnd(catW)}${RESET}  ${statusColor(st)}${st.padEnd(statusW)}${RESET}  ${GRAY}${conf.padEnd(confW)}${RESET}  ${GRAY}${date.padEnd(dateW)}${RESET}
+`);
+  }
+}
+function opportunityCard(opp) {
+  const width = 58;
+  const innerWidth = width - 2;
+  process.stdout.write(`
+  ${BLUE}+${"─".repeat(width)}+${RESET}
+`);
+  process.stdout.write(`  ${BLUE}|${RESET} ${BOLD}${BLUE}Opportunity${RESET}${" ".repeat(innerWidth - 12)}${BLUE}|${RESET}
+`);
+  process.stdout.write(`  ${BLUE}+${"─".repeat(width)}+${RESET}
+`);
+  const st = opp.status ?? "unknown";
+  const category = opp.interpretation?.category ?? "Uncategorized";
+  cardLine(`${BOLD}Status:${RESET}  ${statusColor(st)}${st}${RESET}`, innerWidth);
+  cardLine(`${BOLD}Category:${RESET}  ${category}`, innerWidth);
+  if (opp.interpretation?.confidence != null) {
+    const bar = confidenceBar(opp.interpretation.confidence);
+    cardLine(`${BOLD}Confidence:${RESET}  ${bar}`, innerWidth);
+  }
+  if (opp.actors && opp.actors.length > 0) {
+    process.stdout.write(`  ${BLUE}|${RESET}${" ".repeat(innerWidth)}${BLUE}|${RESET}
+`);
+    cardLine(`${BOLD}Parties:${RESET}`, innerWidth);
+    for (const actor of opp.actors) {
+      const name = actor.name ?? actor.userId;
+      const role = roleLabel(actor.role);
+      cardLine(`  ${name}  ${role}`, innerWidth);
+    }
+  }
+  if (opp.interpretation?.reasoning) {
+    process.stdout.write(`  ${BLUE}|${RESET}${" ".repeat(innerWidth)}${BLUE}|${RESET}
+`);
+    cardLine(`${BOLD}Reasoning:${RESET}`, innerWidth);
+    const wrapped = wordWrap(opp.interpretation.reasoning, innerWidth - 4);
+    for (const line of wrapped) {
+      cardLine(`  ${AGENT_TEXT}${line}${RESET}`, innerWidth);
+    }
+  }
+  if (opp.presentation) {
+    process.stdout.write(`  ${BLUE}|${RESET}${" ".repeat(innerWidth)}${BLUE}|${RESET}
+`);
+    cardLine(`${BOLD}Presentation:${RESET}`, innerWidth);
+    const wrapped = wordWrap(opp.presentation, innerWidth - 4);
+    for (const line of wrapped) {
+      cardLine(`  ${AGENT_TEXT}${line}${RESET}`, innerWidth);
+    }
+  }
+  if (opp.createdAt) {
+    process.stdout.write(`  ${BLUE}|${RESET}${" ".repeat(innerWidth)}${BLUE}|${RESET}
+`);
+    const created = new Date(opp.createdAt).toLocaleString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    cardLine(`${GRAY}Created: ${created}${RESET}`, innerWidth);
+  }
+  process.stdout.write(`  ${BLUE}+${"─".repeat(width)}+${RESET}
+
+`);
+}
+function cardLine(content, _innerWidth) {
+  process.stdout.write(`  ${BLUE}|${RESET} ${content}
+`);
+}
+function statusColor(st) {
+  switch (st) {
+    case "accepted":
+      return GREEN;
+    case "rejected":
+      return RED;
+    case "pending":
+      return YELLOW;
+    case "expired":
+      return GRAY;
+    default:
+      return "";
+  }
+}
+function networkTable(networks) {
+  if (networks.length === 0) {
+    dim("  No networks found.");
+    return;
+  }
+  const titleW = 30;
+  const membersW = 8;
+  const roleW = 10;
+  const policyW = 12;
+  const dateW = 18;
+  console.log(`  ${BOLD}${"Title".padEnd(titleW)}  ${"Members".padEnd(membersW)}  ${"Role".padEnd(roleW)}  ${"Join Policy".padEnd(policyW)}  ${"Created".padEnd(dateW)}${RESET}`);
+  console.log(`  ${GRAY}${"-".repeat(titleW)}  ${"-".repeat(membersW)}  ${"-".repeat(roleW)}  ${"-".repeat(policyW)}  ${"-".repeat(dateW)}${RESET}`);
+  for (const n of networks) {
+    const title = n.title.slice(0, titleW);
+    const members = String(n.memberCount ?? "-");
+    const role = n.role ?? "member";
+    const policy = (n.joinPolicy ?? "invite_only").replace("_", " ");
+    const date = n.createdAt ? new Date(n.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }) : "-";
+    console.log(`  ${title.padEnd(titleW)}  ${members.padEnd(membersW)}  ${role.padEnd(roleW)}  ${policy.padEnd(policyW)}  ${GRAY}${date}${RESET}`);
+  }
+}
+function networkCard(network) {
+  console.log();
+  console.log(`  ${BOLD}${network.title}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(40)}${RESET}`);
+  console.log(`  ${GRAY}ID:${RESET}          ${network.id}`);
+  if (network.prompt) {
+    console.log(`  ${GRAY}Prompt:${RESET}      ${network.prompt}`);
+  }
+  console.log(`  ${GRAY}Join Policy:${RESET} ${(network.joinPolicy ?? "invite_only").replace("_", " ")}`);
+  console.log(`  ${GRAY}Members:${RESET}     ${network.memberCount ?? "-"}`);
+  if (network.owner) {
+    console.log(`  ${GRAY}Owner:${RESET}       ${network.owner.name} (${network.owner.email})`);
+  }
+  console.log();
+}
+function memberTable(members) {
+  if (members.length === 0) {
+    dim("  No members found.");
+    return;
+  }
+  const nameW = 24;
+  const emailW = 30;
+  const roleW = 10;
+  const dateW = 18;
+  console.log(`  ${BOLD}${"Name".padEnd(nameW)}  ${"Email".padEnd(emailW)}  ${"Role".padEnd(roleW)}  ${"Joined".padEnd(dateW)}${RESET}`);
+  console.log(`  ${GRAY}${"-".repeat(nameW)}  ${"-".repeat(emailW)}  ${"-".repeat(roleW)}  ${"-".repeat(dateW)}${RESET}`);
+  for (const m of members) {
+    const name = m.user.name.slice(0, nameW);
+    const email = m.user.email.slice(0, emailW);
+    const role = m.permissions.includes("owner") ? "owner" : m.permissions.includes("admin") ? "admin" : "member";
+    const date = m.createdAt ? new Date(m.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    }) : "-";
+    console.log(`  ${name.padEnd(nameW)}  ${email.padEnd(emailW)}  ${role.padEnd(roleW)}  ${GRAY}${date}${RESET}`);
+  }
+}
+function conversationTable(conversations) {
+  if (conversations.length === 0) {
+    dim("  No conversations found.");
+    return;
+  }
+  const idWidth = 36;
+  const participantsWidth = 40;
+  const dateWidth = 20;
+  console.log(`  ${BOLD}${"ID".padEnd(idWidth)}  ${"Participants".padEnd(participantsWidth)}  ${"Created".padEnd(dateWidth)}${RESET}`);
+  console.log(`  ${GRAY}${"-".repeat(idWidth)}  ${"-".repeat(participantsWidth)}  ${"-".repeat(dateWidth)}${RESET}`);
+  for (const c of conversations) {
+    const names = c.participants.map((p) => p.user?.name ?? p.participantId).join(", ").slice(0, participantsWidth);
+    const date = new Date(c.createdAt).toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+    console.log(`  ${GRAY}${c.id.padEnd(idWidth)}${RESET}  ${names.padEnd(participantsWidth)}  ${GRAY}${date}${RESET}`);
+  }
+}
+function conversationCard(conversation) {
+  console.log();
+  console.log(`  ${BOLD}${CYAN}Conversation${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(40)}${RESET}`);
+  console.log(`  ${BOLD}ID${RESET}            ${GRAY}${conversation.id}${RESET}`);
+  if (conversation.participants.length > 0) {
+    const names = conversation.participants.map((p) => p.user?.name ?? p.participantId).join(", ");
+    console.log(`  ${BOLD}Participants${RESET}  ${names}`);
+  }
+  const date = new Date(conversation.createdAt).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+  console.log(`  ${BOLD}Created${RESET}       ${GRAY}${date}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(40)}${RESET}`);
+  console.log();
+}
+function messageList(messages) {
+  if (messages.length === 0) {
+    dim("  No messages found.");
+    return;
+  }
+  for (const msg of messages) {
+    const sender = msg.senderId ?? msg.role;
+    const time = new Date(msg.createdAt).toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+    const date = new Date(msg.createdAt).toLocaleDateString("en-US", {
+      month: "short",
+      day: "numeric"
+    });
+    const textParts = msg.parts.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("");
+    console.log(`  ${CYAN}${sender}${RESET}  ${GRAY}${date} ${time}${RESET}`);
+    console.log(`  ${textParts}`);
+    console.log();
+  }
+}
+// src/profile.command.ts
+async function handleProfile(client, subcommand, positionals) {
+  if (subcommand === "sync") {
+    await profileSync(client);
+    return;
+  }
+  if (subcommand === "show") {
+    const userId = positionals[0];
+    if (!userId) {
+      error("Usage: index profile show <user-id>", 1);
+      return;
+    }
+    await profileShow(client, userId);
+    return;
+  }
+  await profileMe(client);
+}
+async function profileMe(client) {
+  info("Loading your profile...");
+  const me = await client.getMe();
+  const user = await client.getUser(me.id);
+  profileCard(user);
+}
+async function profileShow(client, userId) {
+  info("Loading profile...");
+  const user = await client.getUser(userId);
+  profileCard(user);
+}
+async function profileSync(client) {
+  info("Regenerating profile...");
+  await client.syncProfile();
+  success("Profile regeneration triggered. It may take a moment to complete.");
+}
+
+// src/intent.command.ts
+var INTENT_HELP = `
+Usage:
+  index intent list [--archived] [--limit <n>]  List your signals
+  index intent show <id>                        Show signal details
+  index intent create <content>                 Create a signal from text
+  index intent archive <id>                     Archive a signal
+`;
+async function handleIntent(client, subcommand, options) {
+  if (!subcommand) {
+    console.log(INTENT_HELP);
+    return;
+  }
+  switch (subcommand) {
+    case "list": {
+      const result = await client.listIntents({
+        archived: options.archived,
+        limit: options.limit
+      });
+      heading("Signals");
+      intentTable(result.intents);
+      if (result.pagination.total > 0) {
+        dim(`
+  Page ${result.pagination.page} of ${result.pagination.totalPages} (${result.pagination.total} total)`);
+      }
+      console.log();
+      return;
+    }
+    case "show": {
+      if (!options.intentId) {
+        error("Missing signal ID. Usage: index intent show <id>", 1);
+        return;
+      }
+      const intent = await client.getIntent(options.intentId);
+      intentCard(intent);
+      return;
+    }
+    case "create": {
+      if (!options.intentContent) {
+        error("Missing content. Usage: index intent create <content>", 1);
+        return;
+      }
+      info("Processing signal...");
+      const result = await client.processIntent(options.intentContent);
+      success("Signal processed successfully.");
+      if (result.message) {
+        dim(`  ${result.message}`);
+      }
+      return;
+    }
+    case "archive": {
+      if (!options.intentId) {
+        error("Missing signal ID. Usage: index intent archive <id>", 1);
+        return;
+      }
+      await client.archiveIntent(options.intentId);
+      success(`Signal ${options.intentId} archived.`);
+      return;
+    }
+  }
+}
+
+// src/opportunity.command.ts
+var OPPORTUNITY_HELP = `
+Usage:
+  index opportunity list                List your opportunities
+  index opportunity list --status <s>   Filter by status (pending|accepted|rejected|expired)
+  index opportunity list --limit <n>    Limit results
+  index opportunity show <id>           Show full opportunity details
+  index opportunity accept <id>         Accept an opportunity
+  index opportunity reject <id>         Reject an opportunity
+`;
+async function handleOpportunity(client, subcommand, options) {
+  if (!subcommand) {
+    console.log(OPPORTUNITY_HELP);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      await opportunityList(client, options.status, options.limit);
+      return;
+    case "show":
+      if (!options.targetId) {
+        error("Missing opportunity ID. Usage: index opportunity show <id>", 1);
+        return;
+      }
+      await opportunityShow(client, options.targetId);
+      return;
+    case "accept":
+      if (!options.targetId) {
+        error("Missing opportunity ID. Usage: index opportunity accept <id>", 1);
+        return;
+      }
+      await opportunityStatusUpdate(client, options.targetId, "accepted");
+      return;
+    case "reject":
+      if (!options.targetId) {
+        error("Missing opportunity ID. Usage: index opportunity reject <id>", 1);
+        return;
+      }
+      await opportunityStatusUpdate(client, options.targetId, "rejected");
+      return;
+    default:
+      error(`Unknown subcommand: ${subcommand}`, 1);
+      return;
+  }
+}
+async function opportunityList(client, status2, limit) {
+  const opportunities = await client.listOpportunities({ status: status2, limit });
+  heading("Opportunities");
+  opportunityTable(opportunities);
+  console.log();
+}
+async function opportunityShow(client, id) {
+  const opportunity = await client.getOpportunity(id);
+  opportunityCard(opportunity);
+}
+async function opportunityStatusUpdate(client, id, status2) {
+  await client.updateOpportunityStatus(id, status2);
+  const label = status2 === "accepted" ? "accepted" : "rejected";
+  success(`Opportunity ${label}.`);
+}
+
+// src/network.command.ts
+var NETWORK_HELP = `
+Network Commands:
+  index network list                     List your networks
+  index network create <name>            Create a new network
+  index network create <name> --prompt   Create with a description
+  index network show <id>                Show network details and members
+  index network join <id>                Join a public network
+  index network leave <id>               Leave a network
+  index network invite <id> <email>      Invite a user by email
+`;
+async function handleNetwork(client, subcommand, positionals, options) {
+  if (!subcommand) {
+    console.log(NETWORK_HELP);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      await networkList(client);
+      return;
+    case "create":
+      await networkCreate(client, positionals[0], options.prompt);
+      return;
+    case "show":
+      await networkShow(client, positionals[0]);
+      return;
+    case "join":
+      await networkJoin(client, positionals[0]);
+      return;
+    case "leave":
+      await networkLeave(client, positionals[0]);
+      return;
+    case "invite":
+      await networkInvite(client, positionals[0], positionals[1]);
+      return;
+    default:
+      error(`Unknown network subcommand: ${subcommand}`, 1);
+  }
+}
+async function networkList(client) {
+  const networks = await client.listNetworks();
+  const filtered = networks.filter((n) => !n.isPersonal);
+  heading("Networks");
+  networkTable(filtered);
+  console.log();
+}
+async function networkCreate(client, name, prompt) {
+  if (!name) {
+    error("Usage: index network create <name>", 1);
+    return;
+  }
+  const network = await client.createNetwork(name, prompt);
+  success(`Network created: ${network.title}`);
+  dim(`  ID: ${network.id}`);
+  dim(`  Join Policy: ${(network.joinPolicy ?? "invite_only").replace("_", " ")}`);
+}
+async function networkShow(client, id) {
+  if (!id) {
+    error("Usage: index network show <id>", 1);
+    return;
+  }
+  const network = await client.getNetwork(id);
+  networkCard(network);
+  const members = await client.getNetworkMembers(id);
+  heading("Members");
+  memberTable(members);
+  console.log();
+}
+async function networkJoin(client, id) {
+  if (!id) {
+    error("Usage: index network join <id>", 1);
+    return;
+  }
+  const network = await client.joinNetwork(id);
+  success(`Joined network: ${network.title}`);
+}
+async function networkLeave(client, id) {
+  if (!id) {
+    error("Usage: index network leave <id>", 1);
+    return;
+  }
+  await client.leaveNetwork(id);
+  success("Left network.");
+}
+async function networkInvite(client, id, email) {
+  if (!id || !email) {
+    error("Usage: index network invite <id> <email>", 1);
+    return;
+  }
+  const users = await client.searchUsers(email, id);
+  if (users.length === 0) {
+    error("User not found.");
+    return;
+  }
+  const user = users[0];
+  const result = await client.addNetworkMember(id, user.id);
+  success(`Invited ${user.name} (${user.email}) to the network.`);
+  if (result.message) {
+    dim(`  ${result.message}`);
+  }
+}
+
+// src/conversation.command.ts
+import { createInterface } from "node:readline/promises";
+async function renderSSEStream(response, callbacks) {
+  const { onToken, onStatus, onToolActivity, onResponseReset } = callbacks;
+  const result = {};
+  if (!response.body) {
+    result.error = "No response body";
+    return result;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let insideToolCall = false;
+  const toolDescriptions = new Map;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      while (buffer.includes(`
+
+`)) {
+        const idx = buffer.indexOf(`
+
+`);
+        const raw2 = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        for (const line of raw2.split(`
+`)) {
+          if (!line.startsWith("data:"))
+            continue;
+          const jsonStr = line.slice("data:".length).trim();
+          if (!jsonStr)
+            continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            const type = event.type;
+            switch (type) {
+              case "token": {
+                if (typeof event.content !== "string")
+                  break;
+                if (insideToolCall)
+                  break;
+                onToken(event.content);
+                break;
+              }
+              case "status":
+                if (onStatus && typeof event.message === "string") {
+                  onStatus(event.message);
+                }
+                break;
+              case "tool_activity": {
+                const phase = event.phase;
+                const toolName = typeof event.toolName === "string" ? event.toolName : "";
+                const desc = typeof event.description === "string" ? event.description : undefined;
+                if (phase === "start") {
+                  insideToolCall = true;
+                  if (desc && toolName) {
+                    toolDescriptions.set(toolName, desc);
+                  }
+                  if (onToolActivity && desc) {
+                    onToolActivity(desc, "start");
+                  }
+                } else if (phase === "end") {
+                  insideToolCall = false;
+                  const startDesc = toolName ? toolDescriptions.get(toolName) : undefined;
+                  if (onToolActivity) {
+                    onToolActivity(startDesc ?? desc ?? toolName, "end", event.success !== false);
+                  }
+                  if (toolName)
+                    toolDescriptions.delete(toolName);
+                }
+                break;
+              }
+              case "tool_start":
+                insideToolCall = true;
+                break;
+              case "tool_end":
+                insideToolCall = false;
+                break;
+              case "llm_start":
+                insideToolCall = false;
+                break;
+              case "response_reset":
+                result.response = undefined;
+                if (onResponseReset) {
+                  onResponseReset(typeof event.reason === "string" ? event.reason : undefined);
+                }
+                break;
+              case "done":
+                result.sessionId = typeof event.sessionId === "string" ? event.sessionId : undefined;
+                result.response = typeof event.response === "string" ? event.response : undefined;
+                result.title = typeof event.title === "string" ? event.title : undefined;
+                break;
+              case "error":
+                result.error = typeof event.message === "string" ? event.message : "Unknown stream error";
+                break;
+              default:
+                break;
+            }
+          } catch {}
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return result;
+}
+var CONVERSATION_HELP = `
+Conversation Commands:
+  index conversation                       Start an interactive AI chat (REPL)
+  index conversation "message"             One-shot message to the AI agent
+  index conversation --session <id>        Resume a specific chat session
+  index conversation sessions              List AI chat sessions
+  index conversation list                  List all conversations (H2A + H2H)
+  index conversation with <user-id>        Open or resume a DM with a user
+  index conversation show <id>             Show messages in a conversation
+  index conversation show <id> --limit <n> Limit number of messages
+  index conversation send <id> <message>   Send a message
+  index conversation stream                Listen for real-time events (SSE)
+`;
+async function handleConversation(client, subcommand, positionals, options) {
+  if (!subcommand) {
+    if (options?.message) {
+      await chatOneShot(client, options.message, options.sessionId);
+    } else {
+      await chatRepl(client, options?.sessionId);
+    }
+    return;
+  }
+  switch (subcommand) {
+    case "sessions":
+      await chatSessionsList(client);
+      return;
+    case "list":
+      await conversationList(client);
+      return;
+    case "with":
+      await conversationWith(client, positionals[0]);
+      return;
+    case "show":
+      await conversationShow(client, positionals[0], options?.limit);
+      return;
+    case "send":
+      await conversationSend(client, positionals[0], positionals.slice(1));
+      return;
+    case "stream":
+      await conversationStream(client);
+      return;
+    case "help":
+      console.log(CONVERSATION_HELP);
+      return;
+    default:
+      error(`Unknown conversation subcommand: ${subcommand}`, 1);
+  }
+}
+async function conversationList(client) {
+  const conversations = await client.listConversations();
+  heading("Conversations");
+  conversationTable(conversations);
+  console.log();
+}
+async function conversationWith(client, userId) {
+  if (!userId) {
+    error("Usage: index conversation with <user-id>", 1);
+    return;
+  }
+  const conversation = await client.getOrCreateDM(userId);
+  conversationCard(conversation);
+}
+async function conversationShow(client, id, limit) {
+  if (!id) {
+    error("Usage: index conversation show <id>", 1);
+    return;
+  }
+  const messages = await client.getMessages(id, { limit: limit ?? 20 });
+  heading("Messages");
+  messageList(messages);
+}
+async function conversationSend(client, id, messageParts) {
+  if (!id) {
+    error("Usage: index conversation send <id> <message>", 1);
+    return;
+  }
+  if (messageParts.length === 0) {
+    error("Missing message. Usage: index conversation send <id> <message>", 1);
+    return;
+  }
+  const text = messageParts.join(" ");
+  const msg = await client.sendMessage(id, text);
+  success(`Message sent (${msg.id})`);
+}
+async function conversationStream(client) {
+  info("Connecting to conversation stream...");
+  dim(`Press Ctrl+C to stop.
+`);
+  const response = await client.streamConversationEvents();
+  if (!response.body) {
+    error("No response body from stream endpoint.", 1);
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      while (buffer.includes(`
+
+`)) {
+        const idx = buffer.indexOf(`
+
+`);
+        const raw2 = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        for (const line of raw2.split(`
+`)) {
+          if (line.startsWith(":"))
+            continue;
+          if (!line.startsWith("data:"))
+            continue;
+          const jsonStr = line.slice("data:".length).trim();
+          if (!jsonStr)
+            continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            const type = event.type;
+            if (type === "connected") {
+              success("Connected to conversation stream.");
+            } else {
+              dim(`[${type}] ${JSON.stringify(event)}`);
+            }
+          } catch {}
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function chatSessionsList(client) {
+  const sessions = await client.listSessions();
+  heading("Chat Sessions");
+  sessionTable(sessions);
+  console.log();
+}
+async function chatOneShot(client, message, sessionId) {
+  const response = await client.streamChat({ message, sessionId });
+  if (!response.ok) {
+    handleStreamError(response);
+    return;
+  }
+  const result = await streamToTerminal(response);
+  if (result.error) {
+    error(result.error, 1);
+    return;
+  }
+  if (result.sessionId) {
+    dim(`
+Session: ${result.sessionId}`);
+  }
+}
+async function chatRepl(client, sessionId) {
+  let currentSessionId = sessionId;
+  chatHeader();
+  const PROMPT_STR2 = PROMPT_STR;
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: true
+  });
+  rl.setPrompt(PROMPT_STR2);
+  rl.prompt();
+  try {
+    for await (const line of rl) {
+      const input = line.trim();
+      if (!input) {
+        rl.prompt();
+        continue;
+      }
+      if (input === "exit" || input === "quit")
+        break;
+      const response = await client.streamChat({
+        message: input,
+        sessionId: currentSessionId
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          error("Session expired. Run `index login` to re-authenticate.", 1);
+          return;
+        }
+        const body = await response.json().catch(() => ({}));
+        error(body.error ?? `HTTP ${response.status}`);
+        rl.prompt();
+        continue;
+      }
+      const result = await streamToTerminal(response);
+      if (result.error) {
+        error(result.error);
+      }
+      if (result.sessionId) {
+        currentSessionId = result.sessionId;
+      }
+      process.stderr.write(`
+`);
+      rl.prompt();
+    }
+  } finally {
+    rl.close();
+  }
+  process.stderr.write(`
+`);
+  dim("Goodbye!");
+}
+async function streamToTerminal(response) {
+  let hasTokens = false;
+  const md = new MarkdownRenderer;
+  let lastToolDesc = "";
+  const result = await renderSSEStream(response, {
+    onToken(text) {
+      if (!hasTokens) {
+        clearStatus();
+        hasTokens = true;
+      }
+      md.write(text);
+      lastToolDesc = "";
+    },
+    onStatus(msg) {
+      if (!hasTokens) {
+        status(msg);
+      }
+    },
+    onToolActivity(description, phase) {
+      if (phase === "start") {
+        const friendly = humanizeToolName(description);
+        if (friendly === lastToolDesc)
+          return;
+        lastToolDesc = friendly;
+        md.finalize();
+        hasTokens = false;
+        toolActivity(friendly);
+      }
+    },
+    onResponseReset(reason) {
+      md.reset(reason);
+      hasTokens = false;
+    }
+  });
+  md.finalize();
+  clearStatus();
+  if (hasTokens) {
+    console.log();
+  }
+  return result;
+}
+async function handleStreamError(response) {
+  if (response.status === 401) {
+    error("Session expired or invalid. Run `index login` to re-authenticate.", 1);
+  }
+  const body = await response.json().catch(() => ({}));
+  error(body.error ?? `HTTP ${response.status}`, 1);
+}
+
+// src/main.ts
+var DEFAULT_API_URL = "https://protocol.index.network";
+var DEFAULT_APP_URL = "https://index.network";
+var VERSION = "0.7.0";
+var HELP_TEXT = `
+Index CLI v${VERSION}
+
+Usage:
+  index login                           Authenticate via browser (uses existing session or OAuth)
+  index login --token <token>           Authenticate with a manually provided token
+  index logout                          Clear stored session
+  index conversation                    Chat with the AI agent (interactive REPL)
+  index conversation "message"          One-shot message to the AI agent
+  index conversation --session <id>     Resume a specific chat session
+  index conversation sessions           List AI chat sessions
+  index conversation list               List all conversations (H2A + H2H)
+  index conversation with <user-id>     Open or resume a DM with a user
+  index conversation show <id>          Show messages in a conversation
+  index conversation send <id> <msg>    Send a message
+  index conversation stream             Listen for real-time events (SSE)
+  index profile                         Show your profile
+  index profile show <user-id>          Show another user's profile
+  index profile sync                    Regenerate your profile
+  index intent list [--archived] [--limit <n>]  List your signals
+  index intent show <id>               Show signal details
+  index intent create <content>        Create a signal from natural language
+  index intent archive <id>            Archive a signal
+  index opportunity list                List your opportunities
+  index opportunity list --status <s>   Filter by status (pending|accepted|rejected|expired)
+  index opportunity list --limit <n>    Limit results
+  index opportunity show <id>           Show full opportunity details
+  index opportunity accept <id>         Accept an opportunity
+  index opportunity reject <id>         Reject an opportunity
+  index network list                    List your networks
+  index network create <name>           Create a new network
+  index network show <id>               Show network details and members
+  index network join <id>               Join a public network
+  index network leave <id>              Leave a network
+  index network invite <id> <email>     Invite a user by email
+  index --help                          Show this help message
+  index --version                       Show version
+
+Options:
+  --api-url <url>     Override the API server URL (default: ${DEFAULT_API_URL})
+  --app-url <url>     Override the app URL for login (default: ${DEFAULT_APP_URL})
+  --token <token>, -t Provide a bearer token directly (skips browser flow)
+  --session <id>, -s  Resume a specific chat session
+  --archived          Include archived signals (intent list)
+  --status <status>   Filter opportunities by status
+  --limit <n>         Limit number of results
+`;
+async function requireAuth(apiUrlOverride) {
+  const store = new CredentialStore;
+  const creds = await store.load();
+  if (!creds) {
+    error("Not logged in. Run `index login` first.", 1);
+    process.exit(1);
+  }
+  const apiUrl = apiUrlOverride ?? creds.apiUrl;
+  return new ApiClient(apiUrl, creds.token);
+}
+async function runLogin(apiUrlOverride, appUrlOverride, manualToken) {
+  const store = new CredentialStore;
+  const apiUrl = apiUrlOverride ?? DEFAULT_API_URL;
+  const appUrl = appUrlOverride ?? DEFAULT_APP_URL;
+  if (manualToken) {
+    await store.save({ token: manualToken, apiUrl });
+    try {
+      const client = new ApiClient(apiUrl, manualToken);
+      const user = await client.getMe();
+      success(`Logged in as ${user.name} (${user.email})`);
+    } catch {
+      success("Token stored. Could not verify — check with `index conversation`.");
+    }
+    return;
+  }
+  info(`Authenticating with ${apiUrl}...`);
+  const { authUrl, callbackPromise } = await handleLogin(apiUrl, appUrl, store);
+  info("Opening browser for authentication...");
+  dim(`If the browser does not open, visit:
+  ${authUrl}
+`);
+  try {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : null;
+    if (opener) {
+      execFile(opener, [authUrl], { stdio: "ignore" });
+    }
+  } catch {}
+  dim("Waiting for authentication callback...");
+  const result = await callbackPromise;
+  if (result.success) {
+    try {
+      const creds = await store.load();
+      if (creds) {
+        const client = new ApiClient(creds.apiUrl, creds.token);
+        const user = await client.getMe();
+        success(`Logged in as ${user.name} (${user.email})`);
+      }
+    } catch {
+      success("Login successful! Token stored.");
+    }
+  } else {
+    error(result.error ?? "Login failed.", 1);
+  }
+}
+async function runLogout() {
+  const store = new CredentialStore;
+  await store.clear();
+  success("Logged out. Session cleared.");
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  switch (args.command) {
+    case "help":
+      console.log(HELP_TEXT);
+      return;
+    case "version":
+      console.log(VERSION);
+      return;
+    case "unknown":
+      error(`Unknown command: ${args.unknown}`, 1);
+      return;
+    case "login":
+      await runLogin(args.apiUrl, args.appUrl, args.token);
+      return;
+    case "logout":
+      await runLogout();
+      return;
+  }
+  const client = await requireAuth(args.apiUrl);
+  switch (args.command) {
+    case "profile":
+      await handleProfile(client, args.subcommand, args.userId ? [args.userId] : []);
+      return;
+    case "intent":
+      await handleIntent(client, args.subcommand, {
+        intentId: args.intentId,
+        intentContent: args.intentContent,
+        archived: args.archived,
+        limit: args.limit
+      });
+      return;
+    case "opportunity":
+      await handleOpportunity(client, args.subcommand, {
+        targetId: args.targetId,
+        status: args.status,
+        limit: args.limit
+      });
+      return;
+    case "network":
+      await handleNetwork(client, args.subcommand, args.positionals ?? [], {
+        prompt: args.prompt
+      });
+      return;
+    case "conversation":
+      await handleConversation(client, args.subcommand, args.positionals ?? [], {
+        limit: args.limit,
+        sessionId: args.sessionId,
+        message: args.message
+      });
+      return;
+  }
+}
+main().catch((err) => {
+  error(err instanceof Error ? err.message : String(err), 1);
+});