arisa 2.0.0

package/src/core/onboarding.ts

@@ -0,0 +1,115 @@
+/**
+ * @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";
+
+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: Bun.which("claude") !== null,
+    codex: Bun.which("codex") !== null,
+    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();
+
+  // Everything set up — skip onboarding
+  if (deps.claude && deps.codex && deps.openaiKey) {
+    await markOnboarded(chatId);
+    return null;
+  }
+
+  // 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>npm install -g @anthropic-ai/claude-code</code>");
+    }
+    lines.push("Codex: <code>npm install -g @openai/codex</code>\n");
+    lines.push("Install one and message me again.");
+    return { message: lines.join("\n"), blocking: true };
+  }
+
+  // At least one CLI — inform and continue
+  await markOnboarded(chatId);
+
+  const using = deps.claude ? "Claude" : "Codex";
+  const lines = [`<b>Arisa</b> — using <b>${using}</b>`];
+
+  if (!deps.claude) {
+    lines.push("Claude CLI not installed. Add it with <code>npm install -g @anthropic-ai/claude-code</code>");
+  } else if (!deps.codex) {
+    lines.push("Codex CLI not installed. Add it with <code>npm install -g @openai/codex</code>");
+  } else {
+    lines.push("Use /codex or /claude to switch backend.");
+  }
+
+  if (!deps.openaiKey) {
+    lines.push("No OpenAI API key — voice and image processing disabled. Add <code>OPENAI_API_KEY</code> to <code>~/.arisa/.env</code> to enable.");
+  }
+
+  return { message: lines.join("\n"), blocking: false };
+}

package/src/core/processor.ts

@@ -0,0 +1,268 @@
+/**
+ * @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 { 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.";
+
+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"];
+
+  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(["claude", ...args], {
+    cwd: config.projectDir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  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(["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) {
+    log.error(`Codex exited with code ${exitCode}: ${stderr.substring(0, 200)}`);
+    logActivity("codex", null, duration, `error:${exitCode}`);
+    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;
+}
+
+function summarizeError(raw: string): string {
+  const clean = raw.replace(/\s+/g, " ").trim();
+  if (!clean) return "process ended without details.";
+  // Cap at 200 chars for Telegram readability
+  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);
+}

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;
+}

package/src/core/scheduler.ts

@@ -0,0 +1,192 @@
+/**
+ * @module core/scheduler
+ * @role Manage cron and one-time scheduled tasks using croner.
+ * @responsibilities
+ *   - Persist tasks to tasks.json, restore on startup
+ *   - Execute tasks by processing through Claude, then sending result via Daemon
+ *   - Schedule one-time (setTimeout) and recurring (croner) tasks
+ * @dependencies croner, shared/config, shared/types
+ * @effects Disk I/O (tasks.json), network (POST to Daemon), timers
+ */
+
+import { Cron } from "croner";
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getTasks, updateTask, deleteTask, addTask as dbAddTask } from "../shared/db";
+import { processWithClaude, flushChatQueue } from "./processor";
+import type { ScheduledTask } from "../shared/types";
+
+const log = createLogger("scheduler");
+
+let tasks: ScheduledTask[] = [];
+const activeJobs = new Map<string, Cron | ReturnType<typeof setTimeout>>();
+const inFlight = new Set<string>(); // task IDs currently executing
+
+async function loadTasks(): Promise<ScheduledTask[]> {
+  try {
+    return await getTasks();
+  } catch (error) {
+    log.error(`Failed to load tasks from db: ${error}`);
+    return [];
+  }
+}
+
+async function saveTask(task: ScheduledTask) {
+  try {
+    await updateTask(task.id, task);
+  } catch (error) {
+    log.error(`Failed to save task ${task.id}: ${error}`);
+  }
+}
+
+async function executeTask(task: ScheduledTask) {
+  // Skip if previous execution is still in-flight (prevents queue buildup)
+  if (inFlight.has(task.id)) {
+    log.info(`Skipping task ${task.id}: previous execution still in-flight`);
+    return;
+  }
+
+  // Check task is still active (may have been cancelled)
+  if (!tasks.includes(task)) return;
+
+  log.info(`Executing task ${task.id}: ${task.message.substring(0, 60)}`);
+  inFlight.add(task.id);
+  try {
+    // Process through Claude to get a real response (source:"task" = low priority)
+    const result = await processWithClaude(task.message, task.chatId, "task");
+
+    // Re-check: task may have been cancelled while Claude was processing
+    if (!tasks.includes(task) || !result) return;
+
+    // Send the processed result to Telegram via Daemon
+    const response = await fetch(`http://localhost:${config.daemonPort}/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chatId: task.chatId,
+        text: result,
+      }),
+    });
+    if (!response.ok) {
+      log.error(`Daemon returned ${response.status} for task ${task.id}`);
+    }
+  } catch (error) {
+    log.error(`Failed to execute task ${task.id}: ${error}`);
+  } finally {
+    inFlight.delete(task.id);
+  }
+}
+
+function scheduleTask(task: ScheduledTask) {
+  if (task.type === "once") {
+    if (task.status === "done") return;
+    const delay = (task.runAt || 0) - Date.now();
+    if (delay <= 0) {
+      executeTask(task).then(async () => {
+        task.status = "done";
+        task.lastRunAt = Date.now();
+        await saveTask(task);
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      executeTask(task).then(async () => {
+        task.status = "done";
+        task.lastRunAt = Date.now();
+        activeJobs.delete(task.id);
+        await saveTask(task);
+      });
+    }, delay);
+    activeJobs.set(task.id, timer);
+    log.info(`Scheduled one-time task ${task.id} in ${Math.round(delay / 1000)}s`);
+  } else if (task.type === "cron" && task.cron) {
+    const job = new Cron(task.cron, async () => {
+      task.lastRunAt = Date.now();
+      await saveTask(task);
+      executeTask(task);
+    });
+    activeJobs.set(task.id, job);
+    log.info(`Scheduled cron task ${task.id}: ${task.cron}`);
+  }
+}
+
+export async function initScheduler() {
+  tasks = await loadTasks();
+  log.info(`Loaded ${tasks.length} tasks`);
+
+  // Clean old completed one-time tasks (> 7 days)
+  const retentionMs = 7 * 24 * 60 * 60 * 1000;
+  const now = Date.now();
+
+  const tasksToDelete: string[] = [];
+  tasks = tasks.filter((t) => {
+    if (t.type === "once" && t.status === "done") {
+      const shouldKeep = now - (t.lastRunAt || t.runAt || now) < retentionMs;
+      if (!shouldKeep) {
+        tasksToDelete.push(t.id);
+      }
+      return shouldKeep;
+    }
+    return true;
+  });
+
+  // Delete old completed tasks from db
+  for (const id of tasksToDelete) {
+    await deleteTask(id);
+  }
+
+  const activeCron = tasks.filter((t) => t.type === "cron");
+  if (activeCron.length > 0) {
+    log.info(`Restoring ${activeCron.length} cron tasks: ${activeCron.map((t) => `"${t.message}" (${t.cron})`).join(", ")} — send /cancel to stop`);
+  }
+
+  for (const task of tasks) {
+    scheduleTask(task);
+  }
+}
+
+export async function addTask(task: ScheduledTask) {
+  // Deduplicate: if a cron with the same message already exists for this chat, skip
+  if (task.type === "cron") {
+    const duplicate = tasks.find(
+      (t) => t.chatId === task.chatId && t.type === "cron" && t.message === task.message,
+    );
+    if (duplicate) {
+      log.info(`Skipping duplicate cron task for chat ${task.chatId}: "${task.message}"`);
+      return;
+    }
+  }
+
+  tasks.push(task);
+  scheduleTask(task);
+  await dbAddTask(task);
+  log.info(`Added task ${task.id} (${task.type})`);
+}
+
+export async function cancelAllChatTasks(chatId: string): Promise<number> {
+  let removed = 0;
+  for (let i = tasks.length - 1; i >= 0; i -= 1) {
+    const task = tasks[i];
+    if (task.chatId !== chatId) continue;
+    // Skip already-completed one-time tasks
+    if (task.type === "once" && task.status === "done") continue;
+
+    const job = activeJobs.get(task.id);
+    if (job && "stop" in job && typeof job.stop === "function") {
+      job.stop();
+    } else if (job) {
+      clearTimeout(job as ReturnType<typeof setTimeout>);
+    }
+    activeJobs.delete(task.id);
+    inFlight.delete(task.id);
+    await deleteTask(task.id);
+    tasks.splice(i, 1);
+    removed += 1;
+  }
+
+  // Flush any queued processWithClaude calls for this chat
+  flushChatQueue(chatId);
+
+  log.info(`Cancelled ${removed} tasks for chat ${chatId}`);
+  return removed;
+}