arisa 2.3.16 → 2.3.18

package/src/core/media.ts

@@ -0,0 +1,144 @@
+/**
+ * @module core/media
+ * @role Handle voice transcription (Whisper), image analysis (Vision), and speech synthesis (ElevenLabs).
+ * @responsibilities
+ *   - Transcribe audio buffers via OpenAI Whisper API
+ *   - Describe images via OpenAI Vision API
+ *   - Generate speech from text via ElevenLabs API
+ *   - Manage temp files for audio processing
+ * @dependencies shared/config
+ * @effects Network calls to OpenAI API and ElevenLabs API, temp file I/O in runtime voice_temp/
+ * @contract transcribeAudio(base64, filename) => Promise<string>
+ * @contract describeImage(base64, caption?) => Promise<string>
+ * @contract generateSpeech(text, voice?) => Promise<string>
+ */
+
+import { writeFileSync, unlinkSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import OpenAI from "openai";
+import { ElevenLabsClient } from "elevenlabs";
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+
+const log = createLogger("core");
+
+let openai: OpenAI | null = null;
+let elevenlabs: ElevenLabsClient | null = null;
+
+function getClient(): OpenAI {
+  if (!openai) {
+    if (!config.openaiApiKey) {
+      throw new Error("OPENAI_API_KEY not configured");
+    }
+    openai = new OpenAI({ apiKey: config.openaiApiKey });
+  }
+  return openai;
+}
+
+function getElevenLabsClient(): ElevenLabsClient {
+  if (!elevenlabs) {
+    if (!config.elevenlabsApiKey) {
+      throw new Error("ELEVENLABS_API_KEY not configured");
+    }
+    elevenlabs = new ElevenLabsClient({ apiKey: config.elevenlabsApiKey });
+  }
+  return elevenlabs;
+}
+
+export async function transcribeAudio(base64: string, filename: string): Promise<string> {
+  const client = getClient();
+
+  if (!existsSync(config.voiceTempDir)) {
+    mkdirSync(config.voiceTempDir, { recursive: true });
+  }
+
+  const tempPath = join(config.voiceTempDir, filename);
+  const buffer = Buffer.from(base64, "base64");
+  writeFileSync(tempPath, buffer);
+
+  try {
+    const file = Bun.file(tempPath);
+    const transcription = await client.audio.transcriptions.create({
+      file: file,
+      model: "gpt-4o-mini-transcribe",
+    });
+    log.info(`Transcribed audio: "${transcription.text.substring(0, 80)}..."`);
+    return transcription.text;
+  } finally {
+    try { unlinkSync(tempPath); } catch { /* ignore */ }
+  }
+}
+
+export async function describeImage(base64: string, caption?: string): Promise<string> {
+  const client = getClient();
+
+  const prompt = caption
+    ? `The user sent this image with the text: "${caption}". Describe in detail what you see and respond considering the attached text.`
+    : "Describe in detail what you see in this image.";
+
+  const response = await client.chat.completions.create({
+    model: "gpt-5.2",
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "image_url", image_url: { url: `data:image/jpeg;base64,${base64}` } },
+          { type: "text", text: prompt },
+        ],
+      },
+    ],
+    response_format: { type: "text" },
+    verbosity: "low",
+    reasoning_effort: "none",
+    store: false,
+  });
+
+  const description = response.choices[0]?.message?.content || "";
+  log.info(`Image described (gpt-5.2): "${description.substring(0, 80)}..."`);
+  return description;
+}
+
+export async function generateSpeech(text: string, voiceId: string = config.elevenlabsVoiceId): Promise<string> {
+  const client = getElevenLabsClient();
+
+  if (!existsSync(config.voiceTempDir)) {
+    mkdirSync(config.voiceTempDir, { recursive: true });
+  }
+
+  const outputPath = join(config.voiceTempDir, `speech_${Date.now()}.mp3`);
+
+  try {
+    const audio = await client.textToSpeech.convert(voiceId, {
+      text,
+      model_id: "eleven_turbo_v2_5",
+    });
+
+    const chunks: Uint8Array[] = [];
+    for await (const chunk of audio) {
+      chunks.push(chunk);
+    }
+
+    const buffer = Buffer.concat(chunks);
+    writeFileSync(outputPath, buffer);
+
+    log.info(`Generated speech: ${text.substring(0, 80)}... (voice: ${voiceId})`);
+    return outputPath;
+  } catch (error) {
+    // Invalidate cached client on auth errors so a new key takes effect without restart
+    const errStr = String(error);
+    if (errStr.includes("401") || errStr.includes("403") || errStr.includes("Unauthorized")) {
+      elevenlabs = null;
+      log.warn("ElevenLabs client invalidated due to auth error — update ELEVENLABS_API_KEY in .env");
+    }
+    log.error(`Failed to generate speech: ${error}`);
+    throw error;
+  }
+}
+
+export function isMediaConfigured(): boolean {
+  return !!config.openaiApiKey;
+}
+
+export function isSpeechConfigured(): boolean {
+  return !!config.elevenlabsApiKey;
+}

package/src/core/onboarding.ts

@@ -0,0 +1,102 @@
+/**
+ * @module core/onboarding
+ * @role First-message onboarding: check CLIs and API keys, guide the user.
+ * @responsibilities
+ *   - Detect installed CLIs (claude, codex) via Bun.which
+ *   - Check OPENAI_API_KEY config
+ *   - Track onboarded chats in runtime storage
+ *   - Build platform-specific install instructions
+ * @dependencies shared/config
+ * @effects Reads/writes onboarded state in deepbase
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getOnboardedUsers, addOnboarded as dbAddOnboarded, isOnboarded as dbIsOnboarded } from "../shared/db";
+import { isAgentCliInstalled } from "../shared/ai-cli";
+
+const log = createLogger("core");
+
+let onboardedChats: Set<string> = new Set();
+
+async function loadOnboarded() {
+  try {
+    const users = await getOnboardedUsers();
+    onboardedChats = new Set(users);
+  } catch (error) {
+    log.warn(`Failed to load onboarded state: ${error}`);
+  }
+}
+
+// Load immediately
+loadOnboarded();
+
+export interface DepsStatus {
+  claude: boolean;
+  codex: boolean;
+  openaiKey: boolean;
+  os: string;
+}
+
+export function checkDeps(): DepsStatus {
+  const os =
+    process.platform === "darwin"
+      ? "macOS"
+      : process.platform === "win32"
+        ? "Windows"
+        : "Linux";
+
+  return {
+    claude: isAgentCliInstalled("claude"),
+    codex: isAgentCliInstalled("codex"),
+    openaiKey: !!config.openaiApiKey,
+    os,
+  };
+}
+
+export function isOnboarded(chatId: string): boolean {
+  return onboardedChats.has(chatId);
+}
+
+export async function markOnboarded(chatId: string) {
+  onboardedChats.add(chatId);
+  await dbAddOnboarded(chatId);
+}
+
+/**
+ * Returns onboarding message for first-time users, or null if everything is set up.
+ * Only blocks if NO CLI is available at all.
+ */
+export async function getOnboarding(chatId: string): Promise<{ message: string; blocking: boolean } | null> {
+  if (isOnboarded(chatId)) return null;
+
+  const deps = checkDeps();
+
+  // No CLI at all — block
+  if (!deps.claude && !deps.codex) {
+    const lines = [
+      "<b>Welcome to Arisa!</b>\n",
+      "Neither Claude CLI nor Codex CLI found. You need at least one.\n",
+    ];
+    if (deps.os === "macOS") {
+      lines.push("Claude: <code>brew install claude-code</code>");
+    } else {
+      lines.push("Claude: <code>bun add -g @anthropic-ai/claude-code</code>");
+    }
+    lines.push("Codex: <code>bun add -g @openai/codex</code>\n");
+    lines.push("Install one and message me again.");
+    return { message: lines.join("\n"), blocking: true };
+  }
+
+  // At least one CLI — minimal greeting and continue
+  await markOnboarded(chatId);
+
+  const using = deps.claude ? "Claude" : "Codex";
+  const lines = [`<b>Arisa</b> — using <b>${using}</b>`];
+
+  if (deps.claude && deps.codex) {
+    lines.push("Use /codex or /claude to switch backend.");
+  }
+
+  return { message: lines.join("\n"), blocking: false };
+}

package/src/core/processor.ts

@@ -0,0 +1,309 @@
+/**
+ * @module core/processor
+ * @role Execute Claude CLI with model routing and conversation context.
+ * @responsibilities
+ *   - Build claude CLI command with appropriate flags
+ *   - Execute via async Bun.spawn (non-blocking)
+ *   - Serialize calls through a queue (only one Claude at a time)
+ *   - Handle errors and truncate responses
+ * @dependencies core/router, core/context, shared/config
+ * @effects Spawns claude CLI process, reads/writes conversation state
+ * @contract (message: string) => Promise<string>
+ */
+
+import { selectModel } from "./router";
+import { getRecentHistory } from "./history";
+import { shouldContinue } from "./context";
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { buildBunWrappedAgentCliCommand } from "../shared/ai-cli";
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from "fs";
+import { join } from "path";
+
+const log = createLogger("core");
+const ACTIVITY_LOG = join(config.logsDir, "activity.log");
+const PROMPT_PREVIEW_MAX = 220;
+export const CLAUDE_RATE_LIMIT_MESSAGE = "Claude is out of credits right now. Please try again in a few minutes.";
+export const CODEX_AUTH_REQUIRED_MESSAGE = [
+  "Codex login is required.",
+  "Check the Arisa daemon logs now and complete the device-auth steps shown there."
+].join("\n");
+
+function logActivity(backend: string, model: string | null, durationMs: number, status: string) {
+  try {
+    if (!existsSync(config.logsDir)) mkdirSync(config.logsDir, { recursive: true });
+    const ts = new Date().toISOString();
+    const entry = { ts, backend, model, durationMs, status };
+    appendFileSync(ACTIVITY_LOG, JSON.stringify(entry) + "\n");
+  } catch {}
+}
+const SOUL_PATH = join(config.projectDir, "SOUL.md");
+
+// Load SOUL.md once at startup — shared personality for all backends
+let soulPrompt = "";
+try {
+  if (existsSync(SOUL_PATH)) {
+    soulPrompt = readFileSync(SOUL_PATH, "utf8").trim();
+    log.info("SOUL.md loaded");
+  }
+} catch (e) {
+  log.warn(`Failed to load SOUL.md: ${e}`);
+}
+
+function withSoul(message: string): string {
+  if (!soulPrompt) return message;
+  return `[System instructions]\n${soulPrompt}\n[End system instructions]\n\n${message}`;
+}
+
+function previewPrompt(input: string): string {
+  const compact = input.replace(/\s+/g, " ").trim();
+  if (!compact) return "(empty)";
+  return compact.length > PROMPT_PREVIEW_MAX
+    ? `${compact.slice(0, PROMPT_PREVIEW_MAX)}...`
+    : compact;
+}
+
+// Serialize Claude calls — only one at a time
+// User messages have priority over task messages
+type QueueSource = "user" | "task";
+let processing = false;
+const queue: Array<{
+  message: string;
+  chatId: string;
+  source: QueueSource;
+  resolve: (result: string) => void;
+}> = [];
+
+export async function processWithClaude(
+  message: string,
+  chatId: string,
+  source: QueueSource = "user",
+): Promise<string> {
+  return new Promise((resolve) => {
+    queue.push({ message, chatId, source, resolve });
+    processNext();
+  });
+}
+
+/**
+ * Flush pending TASK queue items for a chat (resolve with empty string).
+ * Only flushes source:"task" items — never discards user messages.
+ */
+export function flushChatQueue(chatId: string): number {
+  let flushed = 0;
+  for (let i = queue.length - 1; i >= 0; i--) {
+    if (queue[i].chatId === chatId && queue[i].source === "task") {
+      queue[i].resolve("");
+      queue.splice(i, 1);
+      flushed++;
+    }
+  }
+  if (flushed > 0) log.info(`Flushed ${flushed} task queue items for chat ${chatId}`);
+  return flushed;
+}
+
+async function processNext() {
+  if (processing || queue.length === 0) return;
+  processing = true;
+
+  // Pick user messages first, then task messages
+  const userIdx = queue.findIndex((q) => q.source === "user");
+  const idx = userIdx >= 0 ? userIdx : 0;
+  const [item] = queue.splice(idx, 1);
+  const { message, chatId, resolve } = item;
+
+  try {
+    const result = await runClaude(message, chatId);
+    resolve(result);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log.error(`Claude execution error: ${msg}`);
+    resolve(`Error: ${summarizeError(msg)}`);
+  } finally {
+    processing = false;
+    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 historyCount = historyContext ? historyContext.split("\nUser: ").length - 1 : 0;
+  log.info(`Model: ${model.model} (${model.reason}) | History: ${historyCount} exchanges`);
+
+  const args = ["--dangerously-skip-permissions", "--output-format", "text"];
+
+  args.push("--model", model.model);
+  args.push("-p", prompt);
+
+  log.info(
+    `Claude send | promptChars: ${prompt.length} | preview: ${previewPrompt(prompt)}`
+  );
+  log.info(`Claude spawn | cmd: claude --dangerously-skip-permissions --model ${model.model} -p <prompt>`);
+  log.debug(`Claude prompt >>>>\n${prompt}\n<<<<`);
+
+  const proc = Bun.spawn(buildBunWrappedAgentCliCommand("claude", args), {
+    cwd: config.projectDir,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+  proc.stdin.end();
+
+  const timeout = setTimeout(() => {
+    log.warn(`Claude timed out after ${model.timeout}ms, killing process`);
+    proc.kill();
+  }, model.timeout);
+
+  const exitCode = await proc.exited;
+  clearTimeout(timeout);
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const duration = Date.now() - start;
+
+  if (exitCode !== 0) {
+    const combined = stdout + stderr;
+    log.error(`Claude exited with code ${exitCode}: ${stderr.substring(0, 200)}`);
+    logActivity("claude", model.model, duration, `error:${exitCode}`);
+    if (isRateLimit(combined)) {
+      return CLAUDE_RATE_LIMIT_MESSAGE;
+    }
+    return `Error (exit ${exitCode}): ${summarizeError(stderr || stdout)}`;
+  }
+
+  const response = stdout.trim();
+  logActivity("claude", model.model, duration, response ? "ok" : "empty");
+  log.info(`Claude recv | ${duration}ms | responseChars: ${response.length} | preview: ${previewPrompt(response)}`);
+  log.debug(`Claude response >>>>\n${response}\n<<<<`);
+
+  if (!response) {
+    log.warn("Claude returned empty response");
+    return "Claude returned an empty response.";
+  }
+
+  if (response.length > config.maxResponseLength) {
+    return response.substring(0, config.maxResponseLength - 100) + "\n\n[Response truncated...]";
+  }
+
+  return response;
+}
+
+export async function processWithCodex(message: string): Promise<string> {
+  const continueFlag = shouldContinue();
+  const start = Date.now();
+
+  log.info(`Codex | Continue: ${continueFlag}`);
+
+  const args: string[] = [];
+
+  if (continueFlag) {
+    args.push("exec", "resume", "--last", "--dangerously-bypass-approvals-and-sandbox");
+  } else {
+    args.push("exec", "--dangerously-bypass-approvals-and-sandbox", "-C", config.projectDir);
+  }
+
+  args.push(message);
+
+  log.info(
+    `Codex send | promptChars: ${message.length} | preview: ${previewPrompt(message)}`
+  );
+  log.info(
+    `Codex spawn | cmd: codex ${continueFlag
+      ? "exec resume --last --dangerously-bypass-approvals-and-sandbox <prompt>"
+      : `exec --dangerously-bypass-approvals-and-sandbox -C ${config.projectDir} <prompt>`}`
+  );
+  log.debug(`Codex prompt >>>>\n${message}\n<<<<`);
+
+  const proc = Bun.spawn(buildBunWrappedAgentCliCommand("codex", args), {
+    cwd: config.projectDir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const timeout = setTimeout(() => {
+    log.warn("Codex timed out after 180s, killing process");
+    proc.kill();
+  }, 180_000);
+
+  const exitCode = await proc.exited;
+  clearTimeout(timeout);
+
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const duration = Date.now() - start;
+
+  if (exitCode !== 0) {
+    const combined = `${stdout}\n${stderr}`;
+    log.error(`Codex exited with code ${exitCode}: ${stderr.substring(0, 200)}`);
+    logActivity("codex", null, duration, `error:${exitCode}`);
+    if (isCodexAuthError(combined)) {
+      return CODEX_AUTH_REQUIRED_MESSAGE;
+    }
+    return "Error processing with Codex. Please try again.";
+  }
+
+  const response = stdout.trim();
+  logActivity("codex", null, duration, response ? "ok" : "empty");
+  log.info(`Codex recv | ${duration}ms | responseChars: ${response.length} | preview: ${previewPrompt(response)}`);
+  log.debug(`Codex response >>>>\n${response}\n<<<<`);
+
+  if (!response) {
+    log.warn("Codex returned empty response");
+    return "Codex returned an empty response.";
+  }
+
+  if (response.length > config.maxResponseLength) {
+    return response.substring(0, config.maxResponseLength - 100) + "\n\n[Response truncated...]";
+  }
+
+  return response;
+}
+
+export function isClaudeRateLimitResponse(text: string): boolean {
+  return text.trim() === CLAUDE_RATE_LIMIT_MESSAGE;
+}
+
+export function isCodexAuthRequiredResponse(text: string): boolean {
+  return text.trim() === CODEX_AUTH_REQUIRED_MESSAGE;
+}
+
+function summarizeError(raw: string): string {
+  if (!raw.trim()) return "process ended without details.";
+
+  const lines = raw.split("\n");
+
+  // Filter out Bun stack-trace source code lines (e.g. "3 | import{createRequire...")
+  // and caret pointer lines (e.g. "      ^")
+  const meaningful = lines.filter(
+    (l) => !/^\s*\d+\s*\|/.test(l) && !/^\s*\^+\s*$/.test(l)
+  );
+
+  // Look for explicit error lines first (e.g. "error: ...", "TypeError: ...")
+  const errorLine = meaningful.find((l) =>
+    /^\s*(error|Error|TypeError|ReferenceError|SyntaxError|RangeError|ENOENT|EACCES|fatal)[:]/i.test(l.trim())
+  );
+
+  const summary = errorLine?.trim()
+    || meaningful.filter((l) => l.trim()).join(" ").trim()
+    || "process ended without details.";
+
+  const clean = summary.replace(/\s+/g, " ");
+  return clean.length > 200 ? clean.slice(0, 200) + "..." : clean;
+}
+
+function isRateLimit(output: string): boolean {
+  return /you'?ve hit your limit|rate limit|quota|credits.*(exceeded|exhausted)/i.test(output);
+}
+
+function isCodexAuthError(output: string): boolean {
+  return (
+    /missing bearer authentication in header/i.test(output)
+    || (/401\s+Unauthorized/i.test(output) && /bearer/i.test(output))
+    || (/failed to refresh available models/i.test(output) && /unauthorized/i.test(output))
+  );
+}

package/src/core/router.ts

@@ -0,0 +1,64 @@
+/**
+ * @module core/router
+ * @role Decide which Claude model to use based on message complexity.
+ * @responsibilities
+ *   - Analyze incoming message text for complexity patterns
+ *   - Return model ID, timeout, and reason for logging
+ * @dependencies shared/types
+ * @effects None (pure function)
+ * @contract (message: string) => ModelConfig
+ */
+
+import type { ModelConfig } from "../shared/types";
+
+const HAIKU_PATTERNS = [
+  /^\s*\/reset\s*$/i,
+  /^\s*\S{1,12}\s*[.!]?\s*$/i, // Single short word replies (ok, yes, thanks, dale, etc.)
+];
+
+const OPUS_PATTERNS = [
+  /\b(debug|fix|bug|error|refactor|deploy|architect|migration)\b/i,
+  /\b(code|file|function|class|module|component|endpoint|api)\b/i,
+  /```[\s\S]*```/,
+];
+
+// Recency-aware state: prevent haiku downgrade during active conversations
+const RECENCY_WINDOW = 5 * 60 * 1000; // 5 minutes
+let lastModel: string | null = null;
+let lastCallAt = 0;
+
+export function resetRouterState(): void {
+  lastModel = null;
+  lastCallAt = 0;
+}
+
+export function selectModel(message: string): ModelConfig {
+  const stripped = message.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+
+  let candidate: ModelConfig;
+
+  const isHaiku = HAIKU_PATTERNS.some((p) => p.test(stripped));
+  const isOpus = OPUS_PATTERNS.some((p) => p.test(stripped) || p.test(message));
+
+  if (isHaiku) {
+    candidate = { model: "haiku", timeout: 30_000, reason: "simple/acknowledgment" };
+  } else if (isOpus) {
+    candidate = { model: "opus", timeout: 180_000, reason: "code/complex task" };
+  } else {
+    candidate = { model: "sonnet", timeout: 120_000, reason: "general conversation" };
+  }
+
+  // Don't downgrade to haiku if there's a recent conversation on a higher model
+  if (
+    candidate.model === "haiku" &&
+    lastModel &&
+    lastModel !== "haiku" &&
+    Date.now() - lastCallAt < RECENCY_WINDOW
+  ) {
+    candidate = { model: lastModel, timeout: lastModel === "opus" ? 180_000 : 120_000, reason: "keeping context (was: simple/acknowledgment)" };
+  }
+
+  lastModel = candidate.model;
+  lastCallAt = Date.now();
+  return candidate;
+}