spora 0.3.2 → 0.3.4

package/dist/web-chat-N2AYUWT7.js

@@ -1,802 +0,0 @@
-import {
-  loadIdentity
-} from "./chunk-GJFBWIW3.js";
-import {
-  paths
-} from "./chunk-Q7YS3AIK.js";
-
-// src/web-chat/server.ts
-import http from "http";
-import { URL } from "url";
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var WebChatServer = class {
-  server = null;
-  port;
-  messages = [];
-  onUserMessage;
-  onHeartbeatChange;
-  identity;
-  sleepState = {
-    sleeping: false,
-    wakeAt: null,
-    intervalMs: 6e4
-  };
-  memoryStats = {
-    learnings: 0,
-    relationships: 0,
-    interactions: 0
-  };
-  constructor(port = 3737) {
-    this.port = port;
-  }
-  setIdentity(identity) {
-    this.identity = identity;
-  }
-  setMessageHandler(handler) {
-    this.onUserMessage = handler;
-  }
-  setHeartbeatChangeHandler(handler) {
-    this.onHeartbeatChange = handler;
-  }
-  setSleeping(wakeAt) {
-    this.sleepState.sleeping = true;
-    this.sleepState.wakeAt = wakeAt;
-  }
-  setAwake() {
-    this.sleepState.sleeping = false;
-    this.sleepState.wakeAt = null;
-  }
-  getSleepState() {
-    return { ...this.sleepState };
-  }
-  setHeartbeatInterval(intervalMs) {
-    this.sleepState.intervalMs = intervalMs;
-  }
-  getHeartbeatInterval() {
-    return this.sleepState.intervalMs;
-  }
-  setMemoryStats(stats) {
-    this.memoryStats = stats;
-  }
-  async start() {
-    return new Promise((resolve, reject) => {
-      this.server = http.createServer(async (req, res) => {
-        const url = new URL(req.url || "/", `http://${req.headers.host}`);
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-        if (req.method === "OPTIONS") {
-          res.writeHead(200);
-          res.end();
-          return;
-        }
-        if (url.pathname === "/" || url.pathname === "/index.html") {
-          try {
-            const possiblePaths = [
-              join(__dirname, "web-chat", "chat.html"),
-              join(__dirname, "chat.html"),
-              join(__dirname, "..", "web-chat", "chat.html"),
-              join(__dirname, "..", "src", "web-chat", "chat.html")
-            ];
-            let html = null;
-            for (const p of possiblePaths) {
-              try {
-                html = readFileSync(p, "utf-8");
-                break;
-              } catch {
-                continue;
-              }
-            }
-            if (html) {
-              res.writeHead(200, { "Content-Type": "text/html" });
-              res.end(html);
-            } else {
-              console.error("Could not find chat.html in any of:", possiblePaths);
-              res.writeHead(500);
-              res.end("Error: Could not find chat.html");
-            }
-          } catch (error) {
-            res.writeHead(500);
-            res.end("Error loading chat interface");
-          }
-          return;
-        }
-        if (url.pathname === "/logo.png") {
-          try {
-            const logoPaths = [
-              join(__dirname, "web-chat", "logo.png"),
-              join(__dirname, "logo.png"),
-              join(__dirname, "..", "web-chat", "logo.png"),
-              join(__dirname, "..", "src", "web-chat", "logo.png")
-            ];
-            let logoData = null;
-            for (const p of logoPaths) {
-              try {
-                logoData = readFileSync(p);
-                break;
-              } catch {
-                continue;
-              }
-            }
-            if (logoData) {
-              res.writeHead(200, { "Content-Type": "image/png", "Cache-Control": "public, max-age=86400" });
-              res.end(logoData);
-            } else {
-              res.writeHead(404);
-              res.end("Logo not found");
-            }
-          } catch {
-            res.writeHead(404);
-            res.end("Logo not found");
-          }
-          return;
-        }
-        if (url.pathname === "/api/identity" && req.method === "GET") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ identity: this.identity || null }));
-          return;
-        }
-        if (url.pathname === "/api/messages" && req.method === "GET") {
-          const since = url.searchParams.get("since");
-          if (since) {
-            const sinceTs = parseInt(since, 10);
-            const newMessages = this.messages.filter((m) => m.timestamp > sinceTs);
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ messages: newMessages }));
-          } else {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ messages: this.messages }));
-          }
-          return;
-        }
-        if (url.pathname === "/api/message" && req.method === "POST") {
-          let body = "";
-          req.on("data", (chunk) => {
-            body += chunk.toString();
-          });
-          req.on("end", async () => {
-            try {
-              const { message } = JSON.parse(body);
-              this.messages.push({
-                role: "user",
-                content: message,
-                timestamp: Date.now()
-              });
-              if (this.onUserMessage) {
-                const response = await this.onUserMessage(message);
-                this.messages.push({
-                  role: "assistant",
-                  content: response,
-                  timestamp: Date.now()
-                });
-                this.saveLastAssistantMessage(response);
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ success: true, response }));
-              } else {
-                res.writeHead(500, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "No message handler configured" }));
-              }
-            } catch (error) {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Invalid request" }));
-            }
-          });
-          return;
-        }
-        if (url.pathname === "/api/memory-stats" && req.method === "GET") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(this.memoryStats));
-          return;
-        }
-        if (url.pathname === "/api/last-message" && req.method === "GET") {
-          try {
-            if (existsSync(paths.lastChatMessage)) {
-              const data = readFileSync(paths.lastChatMessage, "utf-8");
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(data);
-            } else {
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ content: null }));
-            }
-          } catch {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ content: null }));
-          }
-          return;
-        }
-        if (url.pathname === "/api/sleep-state" && req.method === "GET") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(this.sleepState));
-          return;
-        }
-        if (url.pathname === "/api/config/heartbeat" && req.method === "POST") {
-          let body = "";
-          req.on("data", (chunk) => {
-            body += chunk.toString();
-          });
-          req.on("end", () => {
-            try {
-              const { intervalMs } = JSON.parse(body);
-              if (typeof intervalMs === "number" && intervalMs >= 6e4) {
-                this.sleepState.intervalMs = intervalMs;
-                if (this.onHeartbeatChange) {
-                  this.onHeartbeatChange(intervalMs);
-                }
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ success: true, intervalMs }));
-              } else {
-                res.writeHead(400, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "Invalid interval" }));
-              }
-            } catch {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Invalid request" }));
-            }
-          });
-          return;
-        }
-        res.writeHead(404);
-        res.end("Not found");
-      });
-      this.server.listen(this.port, () => {
-        const url = `http://localhost:${this.port}`;
-        resolve(url);
-      });
-      this.server.on("error", (error) => {
-        if (error.code === "EADDRINUSE") {
-          this.port++;
-          this.server?.close();
-          this.start().then(resolve).catch(reject);
-        } else {
-          reject(error);
-        }
-      });
-    });
-  }
-  /**
-   * Push a message into the chat from the server side (used by heartbeat narration)
-   */
-  pushMessage(role, content) {
-    this.messages.push({ role, content, timestamp: Date.now() });
-    if (role === "assistant") {
-      this.saveLastAssistantMessage(content);
-    }
-  }
-  /**
-   * Persist the last assistant message to disk so it survives restarts
-   */
-  saveLastAssistantMessage(content) {
-    try {
-      writeFileSync(paths.lastChatMessage, JSON.stringify({ content, timestamp: Date.now() }));
-    } catch {
-    }
-  }
-  getMessageCount() {
-    return this.messages.length;
-  }
-  stop() {
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-  }
-};
-
-// src/web-chat/index.ts
-import { execSync } from "child_process";
-import chalk from "chalk";
-async function extractAndSaveLearnings(responseText) {
-  const learnPattern = /<<LEARN:\s*(.+?)>>/g;
-  const matches = [...responseText.matchAll(learnPattern)];
-  if (matches.length > 0) {
-    const { addLearning } = await import("./memory-J6AYZ5Y2.js");
-    for (const match of matches) {
-      const learning = match[1].trim();
-      addLearning(learning, "web-chat", ["chat", "creator-interaction"]);
-      console.log(chalk.dim(`  [Memory] Saved learning: ${learning}`));
-    }
-  }
-  return responseText.replace(/<<LEARN:\s*.+?>>/g, "").trim();
-}
-async function extractAndApplyTraining(responseText) {
-  const trainingPattern = /<<TRAINING:([\s\S]*?)>>/g;
-  const matches = [...responseText.matchAll(trainingPattern)];
-  for (const match of matches) {
-    try {
-      const update = JSON.parse(match[1]);
-      if (update.identity) {
-        const { loadIdentity: loadIdentity2, saveIdentity, mutateIdentity } = await import("./identity-LN2R4KJU.js");
-        let identity = loadIdentity2();
-        if (update.identity.traits) {
-          for (const [trait, value] of Object.entries(update.identity.traits)) {
-            if (typeof value === "number" && value >= 0 && value <= 1) {
-              identity = mutateIdentity(identity, `traits.${trait}`, value, "training-chat");
-              console.log(chalk.dim(`  [Training] ${trait}: ${(value * 100).toFixed(0)}%`));
-            }
-          }
-        }
-        const arrayFields = ["coreValues", "catchphrases", "topics", "avoidTopics", "heroes", "goals", "boundaries"];
-        for (const field of arrayFields) {
-          if (update.identity[field] && Array.isArray(update.identity[field])) {
-            identity = mutateIdentity(identity, field, update.identity[field], "training-chat");
-            console.log(chalk.dim(`  [Training] ${field} updated`));
-          }
-        }
-        const stringFields = ["worldview", "tone", "bio", "originStory"];
-        for (const field of stringFields) {
-          if (typeof update.identity[field] === "string") {
-            identity = mutateIdentity(identity, field, update.identity[field], "training-chat");
-            console.log(chalk.dim(`  [Training] ${field} updated`));
-          }
-        }
-        const enumFields = ["vocabularyStyle", "emojiUsage", "tweetStyle", "conflictStyle"];
-        for (const field of enumFields) {
-          if (typeof update.identity[field] === "string") {
-            identity = mutateIdentity(identity, field, update.identity[field], "training-chat");
-            console.log(chalk.dim(`  [Training] ${field} \u2192 ${update.identity[field]}`));
-          }
-        }
-        if (update.identity.engagementStrategy) {
-          const es = update.identity.engagementStrategy;
-          if (es.replyStyle) identity = mutateIdentity(identity, "engagementStrategy.replyStyle", es.replyStyle, "training-chat");
-          if (es.followStrategy) identity = mutateIdentity(identity, "engagementStrategy.followStrategy", es.followStrategy, "training-chat");
-          if (es.contentMix) {
-            const merged = { ...identity.engagementStrategy.contentMix, ...es.contentMix };
-            identity = mutateIdentity(identity, "engagementStrategy.contentMix", merged, "training-chat");
-          }
-          console.log(chalk.dim(`  [Training] engagement strategy updated`));
-        }
-        try {
-          saveIdentity(identity);
-          console.log(chalk.green(`  [Training] Identity saved.`));
-        } catch (err) {
-          console.log(chalk.red(`  [Training] Identity save failed: ${err.message}`));
-        }
-      }
-      if (update.strategy) {
-        const { loadStrategy, saveStrategy } = await import("./strategy-TOVFBIZQ.js");
-        const strategy = loadStrategy();
-        if (update.strategy.currentFocus) strategy.currentFocus = update.strategy.currentFocus;
-        if (update.strategy.shortTermGoals) strategy.shortTermGoals = update.strategy.shortTermGoals;
-        if (update.strategy.currentMood) strategy.currentMood = update.strategy.currentMood;
-        if (update.strategy.contentInsights) strategy.contentInsights.push(...update.strategy.contentInsights);
-        if (update.strategy.experiments) strategy.experiments.push(...update.strategy.experiments);
-        if (update.strategy.peopleToEngage) strategy.peopleToEngage.push(...update.strategy.peopleToEngage);
-        strategy.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-        saveStrategy(strategy);
-        console.log(chalk.green(`  [Training] Strategy updated.`));
-      }
-      if (update.learning?.content) {
-        const { addLearning } = await import("./memory-J6AYZ5Y2.js");
-        addLearning(update.learning.content, "training-chat", update.learning.tags ?? ["training"]);
-        console.log(chalk.dim(`  [Training] Learning: "${update.learning.content.slice(0, 50)}..."`));
-      }
-      if (update.reflection) {
-        const { loadIdentity: loadId, saveIdentity: saveId } = await import("./identity-LN2R4KJU.js");
-        const id = loadId();
-        id.evolutionJournal.push({ date: (/* @__PURE__ */ new Date()).toISOString(), reflection: update.reflection });
-        saveId(id);
-        console.log(chalk.dim(`  [Training] Journal entry added.`));
-      }
-      if (update.goalUpdates?.length > 0) {
-        const { loadGoals, saveGoals } = await import("./goals-IM4AEHS4.js");
-        const tracker = loadGoals();
-        for (const gu of update.goalUpdates) {
-          const existing = tracker.goals.find((g) => g.goal === gu.goal);
-          if (existing) {
-            existing.progress = gu.progress;
-            existing.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-          } else {
-            tracker.goals.push({ goal: gu.goal, progress: gu.progress, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
-          }
-        }
-        tracker.lastReviewed = (/* @__PURE__ */ new Date()).toISOString();
-        saveGoals(tracker);
-        console.log(chalk.dim(`  [Training] Goals updated.`));
-      }
-    } catch (err) {
-      console.log(chalk.red(`  [Training] Failed to parse/apply training: ${err.message}`));
-    }
-  }
-  return responseText.replace(/<<TRAINING:[\s\S]*?>>/g, "").trim().replace(/\n{3,}/g, "\n\n");
-}
-async function logChatInteraction(userMessage, agentResponse) {
-  const { logInteraction } = await import("./memory-J6AYZ5Y2.js");
-  logInteraction({
-    id: `chat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: "reply",
-    content: agentResponse.slice(0, 200),
-    targetHandle: "creator",
-    creditsUsed: 0,
-    success: true
-  });
-}
-async function startWebChat() {
-  const identity = loadIdentity();
-  const server = new WebChatServer();
-  server.setIdentity({
-    name: identity.name,
-    handle: identity.handle,
-    bio: identity.bio,
-    profileImage: identity.profileImage,
-    createdAt: identity.createdAt
-  });
-  let realHandle;
-  try {
-    const { hasXCredentials } = await import("./paths-KXOWF2B2.js");
-    if (hasXCredentials()) {
-      const { getXClient } = await import("./x-client-HUXCQOAW.js");
-      const client = await getXClient();
-      if ("getAuthenticatedHandle" in client) {
-        realHandle = await client.getAuthenticatedHandle();
-        console.log(chalk.dim(`  [Auth] Real Twitter handle: @${realHandle}`));
-        server.setIdentity({
-          name: identity.name,
-          handle: realHandle,
-          bio: identity.bio,
-          profileImage: identity.profileImage,
-          createdAt: identity.createdAt
-        });
-      }
-    }
-  } catch (err) {
-    console.log(chalk.dim(`  [Auth] Could not resolve real handle: ${err.message}`));
-  }
-  const chatHistory = [];
-  let systemPrompt = null;
-  let messageCount = 0;
-  server.setMessageHandler(async (message) => {
-    try {
-      const sleepBefore = server.getSleepState();
-      const remainingMs = sleepBefore.sleeping && sleepBefore.wakeAt ? Math.max(0, sleepBefore.wakeAt - Date.now()) : 0;
-      server.setAwake();
-      if (!systemPrompt || messageCount % 10 === 0) {
-        const { buildTrainingChatPrompt } = await import("./prompt-builder-NSU4IFPB.js");
-        systemPrompt = buildTrainingChatPrompt(realHandle);
-      }
-      messageCount++;
-      const { hasLLMKey, chat: chatLLM } = await import("./llm-MHZG2VHU.js");
-      if (!hasLLMKey()) {
-        return "I can't respond right now - no API key configured. Run `spora set-llm-key` to set one up.";
-      }
-      chatHistory.push({ role: "user", content: message });
-      const response = await chatLLM(systemPrompt, chatHistory);
-      const trainedText = await extractAndApplyTraining(response.content);
-      const cleanResponse = await extractAndSaveLearnings(trainedText);
-      chatHistory.push({ role: "assistant", content: cleanResponse });
-      logChatInteraction(message, cleanResponse).catch(
-        (err) => console.error(chalk.dim("  [Memory] Failed to log interaction:"), err)
-      );
-      if (remainingMs > 1e4) {
-        server.setSleeping(Date.now() + remainingMs);
-      }
-      return cleanResponse;
-    } catch (error) {
-      console.error("Chat error:", error);
-      return `Sorry, I ran into an issue: ${error.message}`;
-    }
-  });
-  refreshMemoryStats(server).catch(() => {
-  });
-  const url = await server.start();
-  console.log(chalk.green(`
-\u2713 Chat interface started at ${chalk.bold(url)}
-`));
-  console.log(chalk.dim(`Press Ctrl+C to stop the server
-`));
-  openBrowser(url);
-  startNarratedHeartbeat(server).catch(
-    (err) => console.error(chalk.red("Heartbeat failed to start:"), err)
-  );
-  process.on("SIGINT", () => {
-    console.log(chalk.yellow("\n\nStopping chat server..."));
-    heartbeatRunning = false;
-    server.stop();
-    process.exit(0);
-  });
-  return server;
-}
-async function refreshMemoryStats(server) {
-  try {
-    const { loadLearnings, loadRelationships, getRecentInteractions } = await import("./memory-J6AYZ5Y2.js");
-    const learnings = loadLearnings().learnings.length;
-    const relationships = Object.keys(loadRelationships().accounts).length;
-    const interactions = getRecentInteractions(1e3).length;
-    server.setMemoryStats({ learnings, relationships, interactions });
-  } catch {
-  }
-}
-var heartbeatRunning = false;
-var lastMentionsSinceId;
-async function startNarratedHeartbeat(server) {
-  const { loadConfig } = await import("./config-QRBOL4NX.js");
-  const { hasLLMKey, generateResponse } = await import("./llm-MHZG2VHU.js");
-  const { hasXCredentials } = await import("./paths-KXOWF2B2.js");
-  if (!hasLLMKey()) {
-    console.log(chalk.dim("  [Heartbeat] No LLM key \u2014 heartbeat disabled."));
-    return;
-  }
-  if (!hasXCredentials()) {
-    console.log(chalk.dim("  [Heartbeat] No X credentials \u2014 heartbeat disabled."));
-    return;
-  }
-  const config = loadConfig();
-  let intervalMs = config.runtime?.heartbeatIntervalMs ?? 6e4;
-  const maxActions = config.runtime?.actionsPerHeartbeat ?? 10;
-  server.setHeartbeatInterval(intervalMs);
-  server.setHeartbeatChangeHandler((newIntervalMs) => {
-    intervalMs = newIntervalMs;
-    console.log(chalk.cyan(`  [Heartbeat] Interval changed to ${Math.round(newIntervalMs / 1e3)}s`));
-    import("./config-QRBOL4NX.js").then(({ loadConfig: reloadConfig, saveConfig }) => {
-      const cfg = reloadConfig();
-      if (!cfg.runtime) cfg.runtime = {};
-      cfg.runtime.heartbeatIntervalMs = newIntervalMs;
-      saveConfig(cfg);
-    }).catch(() => {
-    });
-  });
-  heartbeatRunning = true;
-  let heartbeatCount = 0;
-  console.log(chalk.cyan(`  [Heartbeat] Running every ${Math.round(intervalMs / 1e3)}s
-`));
-  while (heartbeatRunning) {
-    heartbeatCount++;
-    console.log(chalk.cyan(`  [Heartbeat] #${heartbeatCount} starting...`));
-    server.setAwake();
-    await refreshMemoryStats(server);
-    try {
-      await runNarratedHeartbeat(server, maxActions, intervalMs, heartbeatCount);
-    } catch (error) {
-      console.error(chalk.red(`  [Heartbeat] #${heartbeatCount} failed:`), error.message);
-    }
-    const jitter = Math.floor(Math.random() * intervalMs * 0.2);
-    const sleepMs = intervalMs + jitter;
-    console.log(chalk.dim(`  [Heartbeat] Sleeping ${Math.round(sleepMs / 1e3)}s...`));
-    server.setSleeping(Date.now() + sleepMs);
-    let slept = 0;
-    while (slept < sleepMs && heartbeatRunning) {
-      await new Promise((r) => setTimeout(r, Math.min(1e4, sleepMs - slept)));
-      slept += 1e4;
-      try {
-        const { flushQueue } = await import("./queue-MLRTMJRE.js");
-        const flushed = await flushQueue();
-        if (flushed.posted > 0) {
-          console.log(chalk.green(`  [Queue] Posted ${flushed.posted} scheduled tweet(s)`));
-        }
-      } catch {
-      }
-    }
-    server.setAwake();
-  }
-}
-async function runNarratedHeartbeat(server, maxActions, intervalMs, heartbeatCount = 1) {
-  const { getXClient } = await import("./x-client-HUXCQOAW.js");
-  const { buildSystemPrompt, buildNarratedHeartbeatMessage, buildReflectionPrompt, parseReflection } = await import("./prompt-builder-NSU4IFPB.js");
-  const { generateResponse } = await import("./llm-MHZG2VHU.js");
-  const { parseActions, executeActions } = await import("./decision-engine-WBD36PZI.js");
-  const { flushQueue } = await import("./queue-MLRTMJRE.js");
-  const { retireOldPosts, getActiveTrackedPosts, updatePostMetrics, updateSelfMetrics, getPerformanceSummary } = await import("./performance-7G6R6ELJ.js");
-  const { loadStrategy, saveStrategy } = await import("./strategy-TOVFBIZQ.js");
-  const { addLearning } = await import("./memory-J6AYZ5Y2.js");
-  const { loadIdentity: loadId } = await import("./identity-LN2R4KJU.js");
-  try {
-    const flushed = await flushQueue();
-    if (flushed.posted > 0) {
-      console.log(chalk.green(`  [Queue] Flushed ${flushed.posted} scheduled tweet(s)`));
-    }
-  } catch {
-  }
-  const client = await getXClient();
-  let ownHandle;
-  if ("getAuthenticatedHandle" in client) {
-    try {
-      ownHandle = await client.getAuthenticatedHandle();
-    } catch {
-    }
-  }
-  try {
-    retireOldPosts();
-    const activePosts = getActiveTrackedPosts();
-    for (const post of activePosts.slice(0, 5)) {
-      try {
-        const tweet = await client.getTweet(post.tweetId);
-        if (tweet) {
-          updatePostMetrics(post.tweetId, {
-            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            likes: tweet.likeCount ?? 0,
-            retweets: tweet.retweetCount ?? 0,
-            replies: tweet.replyCount ?? 0
-          });
-        }
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, 1e3));
-    }
-  } catch (error) {
-    console.log(chalk.dim(`  [Heartbeat] Performance check failed: ${error.message}`));
-  }
-  if (heartbeatCount % 6 === 1) {
-    try {
-      const handle = ownHandle ?? loadId().handle;
-      const profile = await client.getProfile(handle);
-      updateSelfMetrics({
-        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        followers: profile.followersCount,
-        following: profile.followingCount,
-        totalTweets: profile.tweetCount
-      });
-      console.log(chalk.dim(`  [Heartbeat] Self: ${profile.followersCount} followers`));
-    } catch (error) {
-      console.log(chalk.dim(`  [Heartbeat] Self-check failed: ${error.message}`));
-    }
-  }
-  let timeline = [];
-  let mentions = [];
-  try {
-    timeline = await client.getTimeline({ count: 20 });
-    if (ownHandle) {
-      timeline = timeline.filter((t) => t.authorHandle.toLowerCase() !== ownHandle.toLowerCase());
-    }
-  } catch (error) {
-    console.log(chalk.dim(`  [Heartbeat] Timeline read failed: ${error.message}`));
-  }
-  try {
-    mentions = await client.getMentions({ count: 10, sinceId: lastMentionsSinceId });
-    if (mentions.length > 0) {
-      lastMentionsSinceId = mentions[0].id;
-    }
-  } catch (error) {
-    console.log(chalk.dim(`  [Heartbeat] Mentions read failed: ${error.message}`));
-  }
-  let discoveryResults = [];
-  if (heartbeatCount % 4 === 0) {
-    try {
-      const identity = loadId();
-      const strategy = loadStrategy();
-      const allTopics = [...identity.topics, ...strategy.currentFocus ?? []];
-      if (allTopics.length > 0) {
-        const topic = allTopics[Math.floor(Math.random() * allTopics.length)];
-        discoveryResults = await client.searchTweets(topic, { count: 10 });
-        if (ownHandle) {
-          discoveryResults = discoveryResults.filter((t) => t.authorHandle.toLowerCase() !== ownHandle.toLowerCase());
-        }
-        console.log(chalk.dim(`  [Heartbeat] Discovery for "${topic}": ${discoveryResults.length} results`));
-      }
-    } catch (error) {
-      console.log(chalk.dim(`  [Heartbeat] Discovery failed: ${error.message}`));
-    }
-  }
-  const systemPrompt = buildSystemPrompt();
-  const userMessage = buildNarratedHeartbeatMessage(timeline, mentions, intervalMs, discoveryResults);
-  const response = await generateResponse(systemPrompt, userMessage, { temperature: 0.95 });
-  let narration = response.content.replace(/```json\s*[\s\S]*?```/g, "").replace(/\n{3,}/g, "\n\n").trim();
-  const actions = parseActions(response.content);
-  const validTweetIds = /* @__PURE__ */ new Set();
-  for (const t of timeline) validTweetIds.add(t.id);
-  for (const t of mentions) validTweetIds.add(t.id);
-  for (const t of discoveryResults) validTweetIds.add(t.id);
-  const validatedActions = actions.filter((a) => {
-    if (a.tweetId) {
-      const cleanId = a.tweetId.replace(/^tweet:/i, "").trim();
-      if (!validTweetIds.has(cleanId)) {
-        console.log(chalk.yellow(`  [Heartbeat] Rejected ${a.action}: tweet ID ${cleanId} not in timeline/mentions (likely hallucinated)`));
-        return false;
-      }
-    }
-    return true;
-  });
-  const limitedActions = validatedActions.slice(0, maxActions);
-  const tweetMap = /* @__PURE__ */ new Map();
-  for (const t of timeline) tweetMap.set(t.id, t);
-  for (const t of mentions) tweetMap.set(t.id, t);
-  for (const t of discoveryResults) tweetMap.set(t.id, t);
-  let results = [];
-  if (limitedActions.length > 0) {
-    results = await executeActions(limitedActions, tweetMap);
-    const visibleResults = [];
-    for (let i = 0; i < results.length; i++) {
-      const r = results[i];
-      const action = limitedActions[i];
-      const detail = r.detail ? ` (${r.detail})` : "";
-      if (r.action === "schedule") {
-        console.log(chalk.dim(`  [Heartbeat] ${r.action}: ${r.success ? "queued" : r.error}${detail}`));
-      } else if (r.success) {
-        if ((r.action === "post" || r.action === "reply") && r.content) {
-          const tweetData = JSON.stringify({ action: r.action, tweetId: r.detail ?? null, content: r.content });
-          visibleResults.push(`<<TWEET:${tweetData}>>`);
-          console.log(chalk.green(`  [Heartbeat] ${r.action}: success (tweet preview)`));
-        } else if (r.action === "like" && action?.tweetId) {
-          const tweet = tweetMap.get(action.tweetId.replace(/^tweet:/i, "").trim());
-          if (tweet) {
-            const likeData = JSON.stringify({ authorHandle: tweet.authorHandle, text: tweet.text });
-            visibleResults.push(`<<LIKE:${likeData}>>`);
-          }
-          console.log(chalk.green(`  [Heartbeat] like: @${tweet?.authorHandle ?? "unknown"}`));
-        } else if (r.action === "retweet" && action?.tweetId) {
-          const tweet = tweetMap.get(action.tweetId.replace(/^tweet:/i, "").trim());
-          if (tweet) {
-            const rtData = JSON.stringify({ authorHandle: tweet.authorHandle, text: tweet.text });
-            visibleResults.push(`<<RETWEET:${rtData}>>`);
-          }
-          console.log(chalk.green(`  [Heartbeat] retweet: @${tweet?.authorHandle ?? "unknown"}`));
-        } else if (r.action === "follow" && action?.handle) {
-          const followData = JSON.stringify({ handle: action.handle });
-          visibleResults.push(`<<FOLLOW:${followData}>>`);
-          console.log(chalk.green(`  [Heartbeat] follow: @${action.handle}`));
-        } else {
-          console.log(chalk.green(`  [Heartbeat] ${r.action}: success${detail}`));
-        }
-      } else {
-        console.log(chalk.red(`  [Heartbeat] ${r.action}: ${r.error}`));
-      }
-    }
-    let fullMessage = narration || "";
-    if (visibleResults.length > 0) {
-      fullMessage += (fullMessage ? "\n\n" : "") + visibleResults.join("\n");
-    }
-    if (fullMessage) {
-      server.pushMessage("assistant", fullMessage);
-    }
-  } else if (narration) {
-    server.pushMessage("assistant", narration);
-  }
-  try {
-    const perfSummary = getPerformanceSummary();
-    const currentStrategy = loadStrategy();
-    const reflectPrompt = buildReflectionPrompt(results, perfSummary, currentStrategy);
-    const reflection = await generateResponse(systemPrompt, reflectPrompt, { temperature: 0.7 });
-    const reflectionData = parseReflection(reflection.content);
-    if (reflectionData.learning) {
-      addLearning(reflectionData.learning, "reflection", ["auto-reflect"]);
-      console.log(chalk.dim(`  [Heartbeat] Reflection: "${reflectionData.learning.slice(0, 60)}..."`));
-    }
-    if (reflectionData.strategyUpdate) {
-      const updated = { ...currentStrategy, ...reflectionData.strategyUpdate, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
-      saveStrategy(updated);
-      console.log(chalk.dim(`  [Heartbeat] Strategy updated.`));
-    }
-  } catch (error) {
-    console.log(chalk.dim(`  [Heartbeat] Reflection failed: ${error.message}`));
-  }
-  console.log(chalk.cyan(`  [Heartbeat] Complete.`));
-}
-function openBrowser(url) {
-  const platform = process.platform;
-  try {
-    if (platform === "darwin") {
-      try {
-        execSync(`open -na "Google Chrome" --args --app="${url}" --window-size=420,620`, { stdio: "ignore" });
-      } catch {
-        try {
-          execSync(`open -na "Brave Browser" --args --app="${url}" --window-size=420,620`, { stdio: "ignore" });
-        } catch {
-          execSync(`open "${url}"`, { stdio: "ignore" });
-        }
-      }
-    } else if (platform === "win32") {
-      try {
-        execSync(`start chrome --app="${url}" --window-size=420,620`, { stdio: "ignore" });
-      } catch {
-        execSync(`start "" "${url}"`, { stdio: "ignore" });
-      }
-    } else {
-      try {
-        execSync(`google-chrome --app="${url}" --window-size=420,620`, { stdio: "ignore" });
-      } catch {
-        execSync(`xdg-open "${url}"`, { stdio: "ignore" });
-      }
-    }
-  } catch (error) {
-    console.log(chalk.dim(`(Couldn't open browser automatically - please visit ${url} manually)`));
-  }
-}
-export {
-  openBrowser,
-  startWebChat
-};
-//# sourceMappingURL=web-chat-N2AYUWT7.js.map