arisa 2.3.51 → 2.3.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "2.3.51",
+  "version": "2.3.52",
   "description": "Arisa - dynamic agent runtime with daemon/core architecture that evolves through user interaction",
   "keywords": [
     "tinyclaw",

package/src/core/index.ts

@@ -27,7 +27,6 @@ import {
 import { transcribeAudio, describeImage, generateSpeech, isMediaConfigured, isSpeechConfigured } from "./media";
 import { detectFiles } from "./file-detector";
 
-import { addExchange, getForeignContext, clearHistory, getLastBackend } from "./history";
 import { getOnboarding, checkDeps } from "./onboarding";
 import { initScheduler, addTask, cancelAllChatTasks } from "./scheduler";
 import { detectScheduleIntent } from "./intent";
@@ -60,13 +59,6 @@ function getBackend(chatId: string): "claude" | "codex" {
   const current = backendState.get(chatId);
   if (current) return preferInstalled(current);
 
-  const fromHistory = getLastBackend(chatId);
-  if (fromHistory) {
-    const resolved = preferInstalled(fromHistory);
-    backendState.set(chatId, resolved);
-    return resolved;
-  }
-
   return preferInstalled(defaultBackend());
 }
 
@@ -164,7 +156,6 @@ ${messageText}`;
         if (msg.command === "/reset") {
           const { writeFileSync } = await import("fs");
           writeFileSync(config.resetFlagPath, "reset");
-          clearHistory(msg.chatId);
           const { resetRouterState } = await import("./router");
           resetRouterState();
           const response: CoreResponse = { text: "Conversation reset! Next message will start a fresh conversation." };
@@ -361,27 +352,22 @@ ${messageText}`;
         const backend = getBackend(msg.chatId);
         const canFallback = backend === "codex" ? deps.claude : deps.codex;
         let agentResponse: string;
-        let historyResponse: string | null = null;
         let usedBackend: "claude" | "codex" = backend;
 
-        // Inject cross-backend context if switching
-        const foreignCtx = getForeignContext(msg.chatId, backend);
-        const enrichedMessage = foreignCtx ? foreignCtx + messageText : messageText;
-
-        log.info(`Routing | backend: ${backend} | foreignCtx: ${!!foreignCtx} | enrichedChars: ${enrichedMessage.length}`);
+        log.info(`Routing | backend: ${backend} | messageChars: ${messageText.length}`);
 
         if (backend === "codex") {
           try {
-            agentResponse = await processWithCodex(enrichedMessage);
+            agentResponse = await processWithCodex(messageText);
             if (agentResponse.startsWith("Error processing with Codex") && canFallback) {
               log.warn("Codex failed, falling back to Claude");
-              agentResponse = await processWithClaude(enrichedMessage, msg.chatId);
+              agentResponse = await processWithClaude(messageText, msg.chatId);
               usedBackend = "claude";
             }
           } catch (error) {
             if (canFallback) {
               log.warn(`Codex threw, falling back to Claude: ${error}`);
-              agentResponse = await processWithClaude(enrichedMessage, msg.chatId);
+              agentResponse = await processWithClaude(messageText, msg.chatId);
               usedBackend = "claude";
             } else {
               agentResponse = "Error processing with Codex. Please try again.";
@@ -389,23 +375,20 @@ ${messageText}`;
           }
         } else {
           try {
-            agentResponse = await processWithClaude(enrichedMessage, msg.chatId);
+            agentResponse = await processWithClaude(messageText, msg.chatId);
             if (agentResponse.startsWith("Error:") && canFallback) {
               log.warn("Claude failed, falling back to Codex");
-              agentResponse = await processWithCodex(enrichedMessage);
+              agentResponse = await processWithCodex(messageText);
               usedBackend = "codex";
             }
             if (isClaudeRateLimitResponse(agentResponse) && canFallback) {
               log.warn("Claude credits exhausted, falling back to Codex");
-              const codexResponse = await processWithCodex(enrichedMessage);
+              const codexResponse = await processWithCodex(messageText);
               if (isCodexAuthRequiredResponse(codexResponse)) {
                 agentResponse = `${agentResponse}\n---CHUNK---\n${codexResponse}`;
               } else {
                 agentResponse = `Claude is out of credits right now, so I switched this reply to Codex.\n---CHUNK---\n${codexResponse}`;
-                historyResponse = codexResponse;
                 usedBackend = "codex";
-                // Persist the switch so subsequent messages don't keep re-injecting
-                // cross-backend context while Claude has no credits.
                 backendState.set(msg.chatId, "codex");
               }
             }
@@ -413,7 +396,7 @@ ${messageText}`;
             const errMsg = error instanceof Error ? error.message : String(error);
             if (canFallback) {
               log.warn(`Claude threw, falling back to Codex: ${errMsg}`);
-              agentResponse = await processWithCodex(enrichedMessage);
+              agentResponse = await processWithCodex(messageText);
               usedBackend = "codex";
             } else {
               agentResponse = `Claude error: ${errMsg.slice(0, 200)}`;
@@ -421,9 +404,6 @@ ${messageText}`;
           }
         }
 
-        // Log exchange for shared history
-        addExchange(msg.chatId, messageText, historyResponse ?? agentResponse, usedBackend);
-
         log.info(`Response | backend: ${usedBackend} | responseChars: ${agentResponse.length}`);
         log.debug(`Response raw >>>>\n${agentResponse}\n<<<<`);
 

package/src/core/processor.ts

@@ -12,7 +12,6 @@
  */
 
 import { selectModel } from "./router";
-import { getRecentHistory } from "./history";
 import { shouldContinue } from "./context";
 import { config } from "../shared/config";
 import { createLogger } from "../shared/logger";
@@ -127,12 +126,10 @@ async function processNext() {
 
 async function runClaude(message: string, chatId: string): Promise<string> {
   const model = selectModel(message);
-  const historyContext = getRecentHistory(chatId);
   const start = Date.now();
-  const prompt = withSoul(historyContext + message);
+  const prompt = withSoul(message);
 
-  const historyCount = historyContext ? historyContext.split("\nUser: ").length - 1 : 0;
-  log.info(`Model: ${model.model} (${model.reason}) | History: ${historyCount} exchanges`);
+  log.info(`Model: ${model.model} (${model.reason})`);
 
   const args = ["--dangerously-skip-permissions", "--output-format", "text"];
 

package/src/core/history.ts

@@ -1,193 +0,0 @@
-/**
- * @module core/history
- * @role Shared conversation history across backends (Claude/Codex).
- * @responsibilities
- *   - Log each user↔backend exchange with backend tag
- *   - Provide "foreign" context: exchanges from the OTHER backend
- *     that the current backend hasn't seen
- *   - Persist to disk, load on startup
- * @dependencies shared/config
- * @effects Reads/writes runtime history.jsonl
- */
-
-import { existsSync, readFileSync, appendFileSync, writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-
-const log = createLogger("core");
-
-const HISTORY_PATH = join(config.arisaDir, "history.jsonl");
-const MAX_ENTRIES_PER_CHAT = 50;
-const FOREIGN_CONTEXT_MAX_AGE_MS = 30 * 60 * 1000;
-const CODEX_SWITCH_NOTICE = "Claude is out of credits right now, so I switched this reply to Codex.";
-
-interface Exchange {
-  ts: number;
-  chatId: string;
-  user: string;
-  response: string;
-  backend: "claude" | "codex";
-}
-
-let history: Exchange[] = [];
-
-// Load persisted history on import
-try {
-  if (existsSync(HISTORY_PATH)) {
-    const lines = readFileSync(HISTORY_PATH, "utf8").split("\n").filter(Boolean);
-    history = lines.map((l) => {
-      const entry = JSON.parse(l) as Exchange;
-      return { ...entry, response: normalizeResponse(entry.response) };
-    });
-    log.info(`Loaded ${history.length} history entries`);
-  }
-} catch (e) {
-  log.warn(`Failed to load history: ${e}`);
-}
-
-export function addExchange(
-  chatId: string,
-  user: string,
-  response: string,
-  backend: "claude" | "codex",
-) {
-  const normalizedResponse = normalizeResponse(response);
-  const entry: Exchange = { ts: Date.now(), chatId, user, response: normalizedResponse, backend };
-  history.push(entry);
-
-  // Prune old entries per chat
-  const chatEntries = history.filter((e) => e.chatId === chatId);
-  if (chatEntries.length > MAX_ENTRIES_PER_CHAT) {
-    const toRemove = chatEntries.length - MAX_ENTRIES_PER_CHAT;
-    let removed = 0;
-    history = history.filter((e) => {
-      if (e.chatId === chatId && removed < toRemove) {
-        removed++;
-        return false;
-      }
-      return true;
-    });
-  }
-
-  // Persist
-  try {
-    const dir = dirname(HISTORY_PATH);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    // Rewrite full file after prune to keep it clean
-    writeFileSync(HISTORY_PATH, history.map((e) => JSON.stringify(e)).join("\n") + "\n");
-  } catch (e) {
-    log.warn(`Failed to persist history: ${e}`);
-  }
-}
-
-/**
- * Returns context string with exchanges from the OTHER backend
- * that happened since the current backend was last used.
- * Returns empty string if there's nothing to inject.
- */
-export function getForeignContext(
-  chatId: string,
-  currentBackend: "claude" | "codex",
-  limit = 10,
-): string {
-  const chatHistory = history.filter((e) => e.chatId === chatId);
-  if (chatHistory.length === 0) return "";
-
-  // Find last exchange handled by current backend
-  let lastOwnIdx = -1;
-  for (let i = chatHistory.length - 1; i >= 0; i--) {
-    if (chatHistory[i].backend === currentBackend) {
-      lastOwnIdx = i;
-      break;
-    }
-  }
-
-  const cutoff = Date.now() - FOREIGN_CONTEXT_MAX_AGE_MS;
-
-  // Get foreign exchanges since then
-  const foreign = chatHistory
-    .slice(lastOwnIdx + 1)
-    .filter((e) => e.backend !== currentBackend && e.ts >= cutoff);
-
-  if (foreign.length === 0) return "";
-
-  const otherName = currentBackend === "claude" ? "Codex" : "Claude";
-  const lines = foreign
-    .slice(-limit)
-    .map((e) => `User: ${e.user}\n${otherName}: ${normalizeResponse(e.response)}`)
-    .join("\n\n");
-
-  return `[Contexto previo con ${otherName}]\n${lines}\n[Fin del contexto previo]\n\n`;
-}
-
-/**
- * Returns recent conversation history for this chat, formatted as User/Assistant pairs.
- * Trims oldest entries first if total exceeds maxChars.
- * Returns "" for new conversations.
- */
-export function getRecentHistory(
-  chatId: string,
-  limit = 10,
-  maxChars = 8000,
-): string {
-  const chatHistory = history.filter((e) => e.chatId === chatId);
-  if (chatHistory.length === 0) return "";
-
-  const recent = chatHistory.slice(-limit);
-
-  // Format exchanges
-  const formatted = recent.map(
-    (e) => `User: ${e.user}\nAssistant: ${normalizeResponse(e.response)}`,
-  );
-
-  // Trim oldest entries if total exceeds maxChars
-  let total = formatted.join("\n\n").length;
-  while (formatted.length > 1 && total > maxChars) {
-    formatted.shift();
-    total = formatted.join("\n\n").length;
-  }
-
-  if (formatted.length === 0) return "";
-
-  return `[Conversation history]\n${formatted.join("\n\n")}\n[End of conversation history]\n\n`;
-}
-
-/**
- * Removes all history entries for this chat from memory and disk.
- */
-export function clearHistory(chatId: string): void {
-  const before = history.length;
-  history = history.filter((e) => e.chatId !== chatId);
-  const removed = before - history.length;
-
-  if (removed > 0) {
-    log.info(`Cleared ${removed} history entries for chat ${chatId}`);
-    try {
-      writeFileSync(HISTORY_PATH, history.map((e) => JSON.stringify(e)).join("\n") + "\n");
-    } catch (e) {
-      log.warn(`Failed to persist history after clear: ${e}`);
-    }
-  }
-}
-
-export function getLastBackend(chatId: string): "claude" | "codex" | null {
-  for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i].chatId === chatId) {
-      return history[i].backend;
-    }
-  }
-  return null;
-}
-
-function normalizeResponse(response: string): string {
-  const cleaned = response
-    .replace(/\n---CHUNK---\n/g, "\n")
-    .replace(new RegExp(`^${escapeRegExp(CODEX_SWITCH_NOTICE)}\\s*`, "m"), "")
-    .trim();
-  return cleaned;
-}
-
-function escapeRegExp(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}