arisa 2.0.0

package/src/daemon/agent-cli.ts

@@ -0,0 +1,119 @@
+/**
+ * @module daemon/agent-cli
+ * @role Run AI CLI commands directly from Daemon with local fallback order.
+ * @responsibilities
+ *   - Detect available CLIs (Claude, Codex)
+ *   - Execute prompt with timeout
+ *   - Fallback from Claude to Codex when needed
+ * @dependencies shared/config
+ * @effects Spawns external CLI processes
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+
+const log = createLogger("daemon");
+
+export type AgentCli = "claude" | "codex";
+
+export interface CliExecutionResult {
+  cli: AgentCli;
+  output: string;
+  stderr: string;
+  exitCode: number;
+  partial: boolean;
+}
+
+export interface CliFallbackOutcome {
+  result: CliExecutionResult | null;
+  attempted: AgentCli[];
+  failures: string[];
+}
+
+export function getAvailableAgentCli(): AgentCli[] {
+  const order: AgentCli[] = [];
+  if (Bun.which("claude") !== null) order.push("claude");
+  if (Bun.which("codex") !== null) order.push("codex");
+  return order;
+}
+
+export function getAgentCliLabel(cli: AgentCli): string {
+  return cli === "claude" ? "Claude" : "Codex";
+}
+
+function buildCommand(cli: AgentCli, prompt: string): string[] {
+  if (cli === "claude") {
+    return ["claude", "--dangerously-skip-permissions", "--model", "sonnet", "-p", prompt];
+  }
+  return ["codex", "exec", "--dangerously-bypass-approvals-and-sandbox", "-C", config.projectDir, prompt];
+}
+
+async function runSingleCli(
+  cli: AgentCli,
+  prompt: string,
+  timeoutMs: number,
+): Promise<Omit<CliExecutionResult, "partial">> {
+  const cmd = buildCommand(cli, prompt);
+  log.info(`Daemon AI: trying ${getAgentCliLabel(cli)} CLI`);
+
+  const proc = Bun.spawn(cmd, {
+    cwd: config.projectDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+
+  const timeout = setTimeout(() => proc.kill(), timeoutMs);
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  clearTimeout(timeout);
+
+  const [output, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+  return { cli, output, stderr, exitCode };
+}
+
+export async function runWithCliFallback(prompt: string, timeoutMs: number): Promise<CliFallbackOutcome> {
+  const candidates = getAvailableAgentCli();
+  const attempted: AgentCli[] = [];
+  const failures: string[] = [];
+  let partial: CliExecutionResult | null = null;
+
+  for (const cli of candidates) {
+    attempted.push(cli);
+
+    try {
+      const result = await runSingleCli(cli, prompt, timeoutMs);
+      const output = result.output.trim();
+
+      if (result.exitCode === 0 && output) {
+        return {
+          result: { ...result, output, partial: false },
+          attempted,
+          failures,
+        };
+      }
+
+      if (result.exitCode !== 0 && output && partial === null) {
+        partial = { ...result, output, partial: true };
+      }
+
+      const reason = result.exitCode === 0
+        ? "empty output"
+        : `exit=${result.exitCode}: ${summarizeError(result.stderr || result.output)}`;
+      failures.push(`${getAgentCliLabel(cli)} ${reason}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      failures.push(`${getAgentCliLabel(cli)} error: ${summarizeError(msg)}`);
+    }
+  }
+
+  return { result: partial, attempted, failures };
+}
+
+function summarizeError(raw: string): string {
+  const clean = raw.replace(/\s+/g, " ").trim();
+  if (!clean) return "no details";
+  return clean.length > 200 ? `${clean.slice(0, 200)}...` : clean;
+}
+

package/src/daemon/autofix.ts

@@ -0,0 +1,116 @@
+/**
+ * @module daemon/autofix
+ * @role Auto-diagnose and fix Core crashes using available AI CLI.
+ * @responsibilities
+ *   - Spawn Claude/Codex CLI to analyze crash errors and edit code
+ *   - Rate-limit attempts (cooldown + max attempts)
+ *   - Notify via callback (Telegram)
+ * @dependencies shared/config
+ * @effects Spawns AI CLI process which may edit project files
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getAgentCliLabel, runWithCliFallback } from "./agent-cli";
+
+const log = createLogger("daemon");
+
+let lastAttemptAt = 0;
+let attemptCount = 0;
+
+const COOLDOWN_MS = 120_000; // 2min between batches
+const MAX_ATTEMPTS = 3;
+const AUTOFIX_TIMEOUT = 180_000; // 3min for autofix
+
+type NotifyFn = (text: string) => Promise<void>;
+let notifyFn: NotifyFn | null = null;
+
+export function setAutoFixNotify(fn: NotifyFn) {
+  notifyFn = fn;
+}
+
+/**
+ * Attempt to auto-fix a Core crash. Returns true if any CLI produced a usable result.
+ */
+export async function attemptAutoFix(error: string): Promise<boolean> {
+  const now = Date.now();
+
+  // Reset attempts after cooldown
+  if (now - lastAttemptAt > COOLDOWN_MS) {
+    attemptCount = 0;
+  }
+
+  if (attemptCount >= MAX_ATTEMPTS) {
+    log.warn(`Auto-fix: max attempts (${MAX_ATTEMPTS}) reached, waiting for cooldown`);
+    return false;
+  }
+
+  attemptCount++;
+  lastAttemptAt = now;
+
+  log.info(`Auto-fix: attempt ${attemptCount}/${MAX_ATTEMPTS}`);
+  await notifyFn?.(`Auto-fix: intento ${attemptCount}/${MAX_ATTEMPTS}. Analizando error...`);
+
+  // Extract file paths from the error to help the fallback model focus
+  const projectPathPattern = new RegExp(`${escapeRegExp(config.projectDir)}[^\\s:)]+`, "g");
+  const fileRefs = error.match(projectPathPattern) || [];
+  const uniqueFiles = [...new Set(fileRefs)].slice(0, 5);
+  const fileHint = uniqueFiles.length > 0
+    ? `\nKey files from the stack trace: ${uniqueFiles.join(", ")}`
+    : "";
+
+  const prompt = `Arisa Core error on startup. Fix it.
+
+Error:
+\`\`\`
+${error.slice(-1500)}
+\`\`\`
+${fileHint}
+
+Rules:
+- If it's a corrupted JSON/data file: delete or recreate it
+- If it's a bad import: fix the import
+- If it's a code bug: fix the minimal code
+- Do NOT refactor, improve, or change anything beyond the fix
+- Be fast — read only the files mentioned in the error`;
+
+  try {
+    const outcome = await runWithCliFallback(prompt, AUTOFIX_TIMEOUT);
+    const result = outcome.result;
+
+    if (!result) {
+      if (outcome.attempted.length === 0) {
+        log.error("Auto-fix: no AI CLI available (claude/codex)");
+        await notifyFn?.("Auto-fix: no hay CLI disponible (Claude/Codex).");
+      } else {
+        const detail = outcome.failures.join(" | ").slice(0, 400);
+        log.error(`Auto-fix: all CLIs failed: ${detail}`);
+        await notifyFn?.("Auto-fix: Claude y Codex fallaron. Revisá los logs.");
+      }
+      return false;
+    }
+
+    const cli = getAgentCliLabel(result.cli);
+    const summary = result.output.slice(0, 300);
+    if (result.partial) {
+      log.warn(`Auto-fix: ${cli} produced output but exited with code ${result.exitCode}`);
+    } else {
+      log.info(`Auto-fix: ${cli} completed successfully`);
+    }
+
+    await notifyFn?.(`Auto-fix aplicado con ${cli}. Core reiniciando...\n<pre>${escapeHtml(summary)}</pre>`);
+    return true;
+  } catch (err) {
+    log.error(`Auto-fix: error: ${err}`);
+    await notifyFn?.("Auto-fix: error interno. Revisá los logs.");
+    return false;
+  }
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/daemon/bridge.ts

@@ -0,0 +1,162 @@
+/**
+ * @module daemon/bridge
+ * @role HTTP client from Daemon to Core with smart fallback to local AI CLI.
+ * @responsibilities
+ *   - POST messages to Core at :51777/message
+ *   - Respect Core lifecycle state (starting/up/down)
+ *   - Wait for Core during startup, fallback only when truly down
+ *   - Serialize fallback calls (one CLI process at a time)
+ * @dependencies shared/config, shared/types, daemon/fallback, daemon/lifecycle
+ * @effects Network (HTTP to Core), may spawn AI CLI process
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import type { IncomingMessage, CoreResponse } from "../shared/types";
+import { fallbackClaude } from "./fallback";
+import { getCoreState, getCoreError, waitForCoreReady } from "./lifecycle";
+
+const log = createLogger("daemon");
+
+const CORE_URL = `http://localhost:${config.corePort}`;
+const STARTUP_WAIT_MS = 15_000;
+const RETRY_DELAY = 3000;
+
+type StatusCallback = (text: string) => Promise<void>;
+
+// Serialize fallback calls — only one fallback CLI process at a time
+let fallbackQueue: Promise<string> = Promise.resolve("");
+
+export async function sendToCore(
+  message: IncomingMessage,
+  onStatus?: StatusCallback,
+): Promise<CoreResponse> {
+  const state = getCoreState();
+
+  if (state === "starting") {
+    return await handleStarting(message, onStatus);
+  }
+
+  if (state === "up") {
+    return await handleUp(message, onStatus);
+  }
+
+  // state === "down" — go straight to fallback
+  log.warn("Core is down, using fallback");
+  return await runFallback(message, onStatus);
+}
+
+/**
+ * Core is starting — wait for it, then send.
+ */
+async function handleStarting(
+  message: IncomingMessage,
+  onStatus?: StatusCallback,
+): Promise<CoreResponse> {
+  log.info("Core is starting, waiting for it to be ready...");
+  await onStatus?.("Core iniciando, esperando...");
+
+  const ready = await waitForCoreReady(STARTUP_WAIT_MS);
+
+  if (ready) {
+    try {
+      return await postToCore(message);
+    } catch {
+      log.warn("Core ready but request failed, retrying...");
+      await sleep(RETRY_DELAY);
+      try {
+        return await postToCore(message);
+      } catch {
+        // Fall through to fallback
+      }
+    }
+  }
+
+  log.warn("Core didn't start in time, using fallback");
+  return await runFallback(message, onStatus);
+}
+
+/**
+ * Core is up — normal path with one retry.
+ */
+async function handleUp(
+  message: IncomingMessage,
+  onStatus?: StatusCallback,
+): Promise<CoreResponse> {
+  try {
+    return await postToCore(message);
+  } catch {
+    // First failure
+  }
+
+  log.warn("Core unreachable, retrying in 3s...");
+  await onStatus?.("Core no responde, reintentando...");
+  await sleep(RETRY_DELAY);
+
+  try {
+    return await postToCore(message);
+  } catch {
+    // Still down
+  }
+
+  log.warn("Core still unreachable after retry, using fallback");
+  return await runFallback(message, onStatus);
+}
+
+/**
+ * Fallback: call local CLI directly (Claude -> Codex). Serialized so only one runs at a time.
+ */
+async function runFallback(
+  message: IncomingMessage,
+  onStatus?: StatusCallback,
+): Promise<CoreResponse> {
+  const coreError = getCoreError();
+
+  if (coreError) {
+    const preview = coreError.length > 300 ? coreError.slice(-300) : coreError;
+    await onStatus?.(`Core caido. Error:\n<pre>${escapeHtml(preview)}</pre>\nConsultando fallback directo (Claude/Codex)...`);
+  } else {
+    await onStatus?.("Core caido. Consultando fallback directo (Claude/Codex)...");
+  }
+
+  const text = message.text || "[non-text message — media not available in fallback mode]";
+
+  // Chain onto the queue so only one fallback CLI runs at a time
+  const result = fallbackQueue.then(() => fallbackClaude(text, coreError ?? undefined));
+  fallbackQueue = result.catch(() => "");
+
+  const response = await result;
+  return { text: response };
+}
+
+async function postToCore(message: IncomingMessage): Promise<CoreResponse> {
+  const response = await fetch(`${CORE_URL}/message`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ message }),
+    signal: AbortSignal.timeout(config.claudeTimeout + 5000),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Core returned ${response.status}`);
+  }
+
+  return (await response.json()) as CoreResponse;
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function isCoreHealthy(): Promise<boolean> {
+  try {
+    const response = await fetch(`${CORE_URL}/health`, { signal: AbortSignal.timeout(2000) });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/daemon/channels/base.ts

@@ -0,0 +1,10 @@
+/**
+ * @module daemon/channels/base
+ * @role Re-export the Channel interface from shared types.
+ * @responsibilities
+ *   - Provide the Channel contract that all adapters must implement
+ * @dependencies shared/types
+ * @effects None
+ */
+
+export type { Channel, IncomingMessage } from "../../shared/types";