arisa 2.3.55 → 3.0.0

package/src/core/attachments.ts

@@ -1,104 +0,0 @@
-/**
- * @module core/attachments
- * @role Persist media attachments so the model can access them later.
- * @responsibilities
- *   - Save base64 attachments to runtime attachments/{chatId}/
- *   - Track metadata in deepbase (collection: "attachments")
- *   - Clean up files older than configured max age
- * @dependencies shared/config, shared/db
- * @effects Disk I/O in runtime attachments dir, deepbase writes
- */
-
-import { mkdirSync, existsSync, unlinkSync, rmdirSync, readdirSync } from "fs";
-import { join, dirname, relative } from "path";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-import { addAttachment, getExpiredAttachments, deleteAttachment, cleanupOldMessages } from "../shared/db";
-import type { AttachmentRecord } from "../shared/types";
-
-const log = createLogger("core");
-
-const EXT_MAP: Record<string, string> = {
-  image: "jpg",
-  audio: "ogg",
-  document: "bin",
-};
-
-export async function initAttachments(): Promise<void> {
-  if (!existsSync(config.attachmentsDir)) {
-    mkdirSync(config.attachmentsDir, { recursive: true });
-  }
-  await cleanupOldAttachments();
-  const msgsCleaned = await cleanupOldMessages(config.attachmentMaxAgeDays);
-  if (msgsCleaned > 0) {
-    log.info(`Cleaned up ${msgsCleaned} expired message record(s)`);
-  }
-}
-
-export async function saveAttachment(
-  chatId: string,
-  type: "image" | "audio" | "document",
-  base64: string,
-  filename?: string,
-  mimeType?: string,
-): Promise<string> {
-  const chatDir = join(config.attachmentsDir, chatId);
-  if (!existsSync(chatDir)) {
-    mkdirSync(chatDir, { recursive: true });
-  }
-
-  const ext = filename ? filename.split(".").pop() || EXT_MAP[type] : EXT_MAP[type];
-  const hex = Math.random().toString(16).slice(2, 6);
-  const prefix = type === "image" ? "img" : type === "audio" ? "aud" : "doc";
-  const outName = `${prefix}_${Date.now()}_${hex}.${ext}`;
-  const outPath = join(chatDir, outName);
-
-  const buffer = Buffer.from(base64, "base64");
-  await Bun.write(outPath, buffer);
-
-  let relPath = relative(config.projectDir, outPath).replace(/\\/g, "/");
-  if (relPath.startsWith("..")) {
-    relPath = outPath;
-  }
-
-  const record: AttachmentRecord = {
-    id: `${chatId}_${outName}`,
-    chatId,
-    type,
-    filename: filename || outName,
-    relPath,
-    mimeType,
-    sizeBytes: buffer.length,
-    createdAt: Date.now(),
-  };
-  await addAttachment(record);
-
-  log.info(`Saved ${type} attachment: ${relPath} (${buffer.length} bytes)`);
-  return relPath;
-}
-
-async function cleanupOldAttachments(): Promise<void> {
-  const expired = await getExpiredAttachments(config.attachmentMaxAgeDays);
-  if (expired.length === 0) return;
-
-  let cleaned = 0;
-  for (const record of expired) {
-    const absPath = join(config.projectDir, record.relPath);
-    try {
-      if (existsSync(absPath)) {
-        unlinkSync(absPath);
-      }
-      // Remove empty chat dir
-      const dir = dirname(absPath);
-      if (existsSync(dir) && readdirSync(dir).length === 0) {
-        rmdirSync(dir);
-      }
-    } catch {
-      // File already gone — just clean the record
-    }
-    await deleteAttachment(record.id);
-    cleaned++;
-  }
-
-  log.info(`Cleaned up ${cleaned} expired attachment(s)`);
-}

package/src/core/auth.ts

@@ -1,58 +0,0 @@
-/**
- * @module core/auth
- * @role Gate access to the bot via a one-time token shown in the console.
- * @responsibilities
- *   - Generate and persist an auth token via deepbase (settings.auth_token)
- *   - Track authorized chat IDs via deepbase (authorized collection)
- *   - Validate tokens from new chats
- * @dependencies shared/db
- * @effects deepbase writes, console output
- */
-
-import { createLogger } from "../shared/logger";
-import { getAuthorizedUsers, addAuthorized, getSetting, setSetting } from "../shared/db";
-
-const log = createLogger("auth");
-
-let authToken = "";
-let authorizedChats: Set<string> = new Set();
-
-async function loadToken(): Promise<string> {
-  const existing = await getSetting("auth_token");
-  if (existing) return existing;
-
-  const token = crypto.randomUUID().split("-")[0];
-  await setSetting("auth_token", token);
-  return token;
-}
-
-async function loadAuthorized(): Promise<Set<string>> {
-  try {
-    const users = await getAuthorizedUsers();
-    return new Set(users);
-  } catch (error) {
-    log.error(`Failed to load authorized users: ${error}`);
-    return new Set();
-  }
-}
-
-export async function initAuth() {
-  authToken = await loadToken();
-  authorizedChats = await loadAuthorized();
-  log.info(`Auth token: ${authToken}`);
-  console.log(`\n🔑 Auth token: ${authToken}\n   Send this token to the bot on Telegram to authorize a chat.\n`);
-}
-
-export function isAuthorized(chatId: string): boolean {
-  return authorizedChats.has(chatId);
-}
-
-export async function tryAuthorize(chatId: string, message: string): Promise<boolean> {
-  if (message.trim() === authToken) {
-    authorizedChats.add(chatId);
-    await addAuthorized(chatId);
-    log.info(`Chat ${chatId} authorized`);
-    return true;
-  }
-  return false;
-}

package/src/core/context.ts

@@ -1,30 +0,0 @@
-/**
- * @module core/context
- * @role Manage Claude conversation continuity via the -c flag and reset_flag.
- * @responsibilities
- *   - Check if reset_flag exists (user sent /reset)
- *   - Return whether to use -c (continue) flag
- *   - Clear reset_flag after consuming it
- * @dependencies shared/config
- * @effects Reads/deletes reset_flag from runtime data dir
- * @contract shouldContinue() => boolean
- */
-
-import { existsSync, unlinkSync } from "fs";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-
-const log = createLogger("core");
-
-export function shouldContinue(): boolean {
-  if (existsSync(config.resetFlagPath)) {
-    log.info("Reset flag found — starting fresh conversation");
-    try {
-      unlinkSync(config.resetFlagPath);
-    } catch {
-      // Already deleted, race condition
-    }
-    return false;
-  }
-  return true;
-}

package/src/core/file-detector.ts

@@ -1,39 +0,0 @@
-/**
- * @module core/file-detector
- * @role Detect file paths mentioned in Claude responses that exist on disk.
- * @responsibilities
- *   - Scan response text for absolute file paths
- *   - Verify they exist and are sendable (< 50MB, not directories)
- *   - Return list of unique valid file paths
- * @dependencies None
- * @effects Reads file system to check existence/size
- * @contract detectFiles(text) => string[]
- */
-
-import { statSync } from "fs";
-
-const FILE_PATH_REGEX = /(\/[\w./-]+\.\w{1,10})/gm;
-const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
-
-export function detectFiles(text: string): string[] {
-  const matches = [...text.matchAll(FILE_PATH_REGEX)];
-  const seen = new Set<string>();
-  const files: string[] = [];
-
-  for (const match of matches) {
-    const filePath = match[1];
-    if (seen.has(filePath)) continue;
-    seen.add(filePath);
-
-    try {
-      const stat = statSync(filePath);
-      if (stat.isFile() && stat.size < MAX_FILE_SIZE) {
-        files.push(filePath);
-      }
-    } catch {
-      // File doesn't exist or can't be read
-    }
-  }
-
-  return files;
-}

package/src/core/format.ts

@@ -1,159 +0,0 @@
-/**
- * @module core/format
- * @role Format responses for Telegram (HTML) and chunk long messages.
- * @responsibilities
- *   - Split text into chunks respecting Telegram's 4096 char limit
- *   - Safe HTML sending with plain-text fallback marker
- * @dependencies None
- * @effects None (pure functions)
- * @contract chunkMessage(text) => string[]
- */
-
-const MAX_TELEGRAM_LENGTH = 4096;
-
-function escapeHtml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-/** Decode HTML entities so we don't double-encode them when escapeHtml runs. */
-function unescapeHtml(s: string): string {
-  return s
-    .replace(/&amp;/g, "&")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'");
-}
-
-function protectTelegramHtmlTags(text: string): { text: string; tags: string[] } {
-  const tags: string[] = [];
-  const tagPattern = /<\/?(?:b|i|u|s|code|pre|blockquote)>|<a\s+href="[^"]+">|<\/a>/gi;
-  const protectedText = text.replace(tagPattern, (tag) => {
-    tags.push(tag);
-    return `\x00HTMLTAG${tags.length - 1}\x00`;
-  });
-  return { text: protectedText, tags };
-}
-
-/**
- * Convert Markdown (from Claude CLI) to Telegram-safe HTML.
- * Telegram supports: <b>, <i>, <code>, <pre>, <a>, <s>, <u>, <blockquote>
- * Must also escape HTML entities in non-tag content.
- */
-export function markdownToTelegramHtml(text: string): string {
-  // Step 0: Decode any pre-escaped HTML entities to avoid double-encoding
-  // (e.g. &lt;code&gt; → <code> so protectTelegramHtmlTags can detect them)
-  text = unescapeHtml(text);
-
-  // Step 1: Extract code blocks and links before escaping to protect them
-  const codeBlocks: string[] = [];
-  const inlineCodes: string[] = [];
-  const links: string[] = [];
-
-  // Preserve already-valid Telegram HTML tags instead of escaping them.
-  const protectedHtml = protectTelegramHtmlTags(text);
-
-  // Protect fenced code blocks: ```lang\n...\n``` or ```...```
-  let result = protectedHtml.text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, _lang, code) => {
-    codeBlocks.push(code.trimEnd());
-    return `\x00CODEBLOCK${codeBlocks.length - 1}\x00`;
-  });
-
-  // Protect inline code: `...`
-  result = result.replace(/`([^`\n]+)`/g, (_match, code) => {
-    inlineCodes.push(code);
-    return `\x00INLINE${inlineCodes.length - 1}\x00`;
-  });
-
-  // Protect links: [text](url)
-  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, linkText, url) => {
-    links.push(`<a href="${url}">${escapeHtml(linkText)}</a>`);
-    return `\x00LINK${links.length - 1}\x00`;
-  });
-
-  // Step 2: Now escape HTML entities in the remaining text
-  result = escapeHtml(result);
-
-  // Step 3: Convert markdown patterns to HTML tags
-
-  // Bold+Italic: ***text*** or ___text___
-  result = result.replace(/\*{3}(.+?)\*{3}/g, "<b><i>$1</i></b>");
-  result = result.replace(/_{3}(.+?)_{3}/g, "<b><i>$1</i></b>");
-
-  // Bold: **text** or __text__
-  result = result.replace(/\*{2}(.+?)\*{2}/g, "<b>$1</b>");
-  result = result.replace(/_{2}(.+?)_{2}/g, "<b>$1</b>");
-
-  // Italic: *text* or _text_ (not inside words for underscore)
-  result = result.replace(/(?<!\w)\*([^*\n]+)\*(?!\w)/g, "<i>$1</i>");
-  result = result.replace(/(?<!\w)_([^_\n]+)_(?!\w)/g, "<i>$1</i>");
-
-  // Strikethrough: ~~text~~
-  result = result.replace(/~~(.+?)~~/g, "<s>$1</s>");
-
-  // Step 4: Restore protected elements
-  result = result.replace(/\x00CODEBLOCK(\d+)\x00/g, (_m, i) => `<pre>${escapeHtml(codeBlocks[+i])}</pre>`);
-  result = result.replace(/\x00INLINE(\d+)\x00/g, (_m, i) => `<code>${escapeHtml(inlineCodes[+i])}</code>`);
-  result = result.replace(/\x00LINK(\d+)\x00/g, (_m, i) => links[+i]);
-  result = result.replace(/\x00HTMLTAG(\d+)\x00/g, (_m, i) => protectedHtml.tags[+i]);
-
-  return result;
-}
-
-export function chunkMessage(text: string): string[] {
-  if (text.length <= MAX_TELEGRAM_LENGTH) {
-    return [text];
-  }
-
-  const chunks: string[] = [];
-  let remaining = text;
-
-  // Tags that Telegram supports and we use
-  const tagNames = ["pre", "code", "b", "i", "s", "a"];
-
-  while (remaining.length > 0) {
-    if (remaining.length <= MAX_TELEGRAM_LENGTH) {
-      chunks.push(remaining);
-      break;
-    }
-
-    let splitAt = remaining.lastIndexOf("\n", MAX_TELEGRAM_LENGTH);
-    if (splitAt === -1 || splitAt < MAX_TELEGRAM_LENGTH * 0.5) {
-      splitAt = MAX_TELEGRAM_LENGTH;
-    }
-
-    // Check if splitting here would break an HTML tag
-    let candidate = remaining.substring(0, splitAt);
-
-    // Find unclosed tags in the candidate chunk
-    const openTags: string[] = [];
-    const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?\/?>/gi;
-    let match: RegExpExecArray | null;
-    while ((match = tagRegex.exec(candidate)) !== null) {
-      const fullTag = match[0];
-      const tagName = match[1].toLowerCase();
-      if (!tagNames.includes(tagName)) continue;
-      if (fullTag.startsWith("</")) {
-        // Closing tag - pop if matching
-        const idx = openTags.lastIndexOf(tagName);
-        if (idx !== -1) openTags.splice(idx, 1);
-      } else if (!fullTag.endsWith("/>")) {
-        openTags.push(tagName);
-      }
-    }
-
-    // If there are unclosed tags, close them at end of this chunk and reopen in next
-    if (openTags.length > 0) {
-      const closingTags = [...openTags].reverse().map(t => `</${t}>`).join("");
-      const openingTags = openTags.map(t => `<${t}>`).join("");
-      candidate = candidate + closingTags;
-      remaining = openingTags + remaining.substring(splitAt).trimStart();
-    } else {
-      remaining = remaining.substring(splitAt).trimStart();
-    }
-
-    chunks.push(candidate);
-  }
-
-  return chunks;
-}