@loreai/gateway 0.14.0 → 0.14.1

package/src/compaction.ts

@@ -1,195 +0,0 @@
-/**
- * Compaction request detection and interception for the Lore gateway.
- *
- * Claude Code (and other clients using the same pattern) sends compaction
- * requests with a distinct system prompt and message structure. The gateway
- * detects these and runs Lore's own distillation instead of forwarding to
- * the upstream API.
- *
- * Detection mirrors the patterns documented in the upstream
- * `packages/opencode/src/agent/prompt/compaction.txt` and the
- * `experimental.session.compacting` hook.
- *
- * This module has zero dependencies on `@loreai/core` — pure detection logic.
- */
-import type { GatewayRequest, GatewayResponse } from "./translate/types";
-
-// ---------------------------------------------------------------------------
-// Detection patterns — exported so tests can reference them
-// ---------------------------------------------------------------------------
-
-/** System prompt substrings that identify a compaction agent. */
-export const COMPACTION_SYSTEM_PATTERNS = [
-  "anchored context summarization assistant",
-] as const;
-
-/** Last user message substrings that indicate a compaction request. */
-export const COMPACTION_USER_PATTERNS = [
-  "anchored summary from the conversation history above",
-  "Update the anchored summary below",
-  "<previous-summary>",
-] as const;
-
-/**
- * Template section headers found in the `<template>` block of a compaction
- * request. A request matching ≥4 of these (with a `<template>` tag) is
- * considered a compaction request.
- */
-export const COMPACTION_TEMPLATE_SECTIONS = [
-  "## Goal",
-  "## Progress",
-  "## Key Decisions",
-  "## Next Steps",
-  "## Critical Context",
-  "## Relevant Files",
-] as const;
-
-/** Minimum number of template sections that must match (with `<template>` tag). */
-const MIN_TEMPLATE_SECTION_MATCHES = 4;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Extract the concatenated text content from the last user message.
- * Returns an empty string if there are no user messages or no text blocks.
- */
-function lastUserText(req: GatewayRequest): string {
-  for (let i = req.messages.length - 1; i >= 0; i--) {
-    const msg = req.messages[i];
-    if (msg.role === "user") {
-      return msg.content
-        .filter((b) => b.type === "text")
-        .map((b) => (b as { type: "text"; text: string }).text)
-        .join("\n");
-    }
-  }
-  return "";
-}
-
-/** Rough token estimate: ~4 characters per token. */
-function estimateTokens(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-// ---------------------------------------------------------------------------
-// isCompactionRequest
-// ---------------------------------------------------------------------------
-
-/**
- * Returns `true` if the request looks like a compaction request.
- *
- * Checks in order:
- *  1. System prompt contains any `COMPACTION_SYSTEM_PATTERNS` → true
- *  2. Tools empty AND last user message contains any `COMPACTION_USER_PATTERNS` → true
- *  3. Last user message has `<template>` tag AND ≥4 template sections → true
- *  4. Otherwise → false
- */
-export function isCompactionRequest(req: GatewayRequest): boolean {
-  // 1. System prompt check — strongest signal, sufficient alone
-  const systemLower = req.system.toLowerCase();
-  for (const pattern of COMPACTION_SYSTEM_PATTERNS) {
-    if (systemLower.includes(pattern.toLowerCase())) return true;
-  }
-
-  const userText = lastUserText(req);
-
-  // 2. No tools + user message contains compaction keywords
-  if (req.tools.length === 0 && userText) {
-    for (const pattern of COMPACTION_USER_PATTERNS) {
-      if (userText.includes(pattern)) return true;
-    }
-  }
-
-  // 3. <template> tag + ≥4 section headers
-  if (userText.includes("<template>")) {
-    let matches = 0;
-    for (const section of COMPACTION_TEMPLATE_SECTIONS) {
-      if (userText.includes(section)) matches++;
-    }
-    if (matches >= MIN_TEMPLATE_SECTION_MATCHES) return true;
-  }
-
-  return false;
-}
-
-// ---------------------------------------------------------------------------
-// extractPreviousSummary
-// ---------------------------------------------------------------------------
-
-/** Regex to extract content from `<previous-summary>` block (dotAll). */
-const PREVIOUS_SUMMARY_RE =
-  /<previous-summary>\n(.*?)\n<\/previous-summary>/s;
-
-/**
- * Extract the content of a `<previous-summary>` block from the last user
- * message, or `undefined` if no such block exists.
- */
-export function extractPreviousSummary(
-  req: GatewayRequest,
-): string | undefined {
-  const userText = lastUserText(req);
-  const match = PREVIOUS_SUMMARY_RE.exec(userText);
-  return match?.[1] ?? undefined;
-}
-
-// ---------------------------------------------------------------------------
-// isTitleOrSummaryRequest
-// ---------------------------------------------------------------------------
-
-/** Max system prompt length for title/summary agents (chars). */
-const TITLE_SUMMARY_MAX_SYSTEM_LENGTH = 500;
-
-/** Max number of tools for a title/summary agent (0 or very few). */
-const TITLE_SUMMARY_MAX_TOOLS = 2;
-
-/** Max message count for a title/summary agent (system extracted, so 1–2). */
-const TITLE_SUMMARY_MAX_MESSAGES = 2;
-
-/**
- * Detect non-conversation requests that should be forwarded without Lore
- * pipeline processing (title generation, summary agents, etc.).
- *
- * These have:
- *  - Empty or very few tools (≤2)
- *  - Only 1–2 messages (system already extracted to `req.system`)
- *  - Short system prompt (< 500 chars)
- *  - NOT a compaction request (handled separately)
- */
-export function isTitleOrSummaryRequest(req: GatewayRequest): boolean {
-  // Compaction requests are handled separately — don't classify as title/summary
-  if (isCompactionRequest(req)) return false;
-
-  return (
-    req.tools.length <= TITLE_SUMMARY_MAX_TOOLS &&
-    req.messages.length <= TITLE_SUMMARY_MAX_MESSAGES &&
-    req.system.length < TITLE_SUMMARY_MAX_SYSTEM_LENGTH
-  );
-}
-
-// ---------------------------------------------------------------------------
-// buildCompactionResponse
-// ---------------------------------------------------------------------------
-
-/**
- * Build a `GatewayResponse` wrapping a compaction summary as if it were a
- * normal assistant response. The gateway translates this back to the
- * client's protocol (Anthropic/OpenAI) before sending.
- */
-export function buildCompactionResponse(
-  _sessionID: string,
-  summary: string,
-  model: string,
-): GatewayResponse {
-  return {
-    id: `msg_lore_compact_${crypto.randomUUID().slice(0, 8)}`,
-    model,
-    content: [{ type: "text", text: summary }],
-    stopReason: "end_turn",
-    usage: {
-      inputTokens: 0,
-      outputTokens: estimateTokens(summary),
-    },
-  };
-}

package/src/config.ts

@@ -1,199 +0,0 @@
-/**
- * Gateway configuration — loaded from environment variables with sensible
- * defaults. No Zod, no file-based config, no @loreai/core dependency.
- */
-
-// ---------------------------------------------------------------------------
-// Config shape
-// ---------------------------------------------------------------------------
-
-export interface GatewayConfig {
-  /** Port to listen on. Default: 6969. Env: LORE_LISTEN_PORT */
-  port: number;
-  /** Host to bind to. Default: "127.0.0.1". Env: LORE_LISTEN_HOST */
-  host: string;
-  /** Upstream Anthropic API URL. Default: "https://api.anthropic.com". Env: LORE_UPSTREAM_ANTHROPIC */
-  upstreamAnthropic: string;
-  /** Upstream OpenAI API URL. Default: "https://api.openai.com". Env: LORE_UPSTREAM_OPENAI */
-  upstreamOpenAI: string;
-  /** Idle timeout in seconds before triggering background work. Default: 60 */
-  idleTimeoutSeconds: number;
-  /** Whether to log requests. Default: false. Env: LORE_DEBUG */
-  debug: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// loadConfig
-// ---------------------------------------------------------------------------
-
-/** Load gateway configuration from environment variables with defaults. */
-export function loadConfig(): GatewayConfig {
-  const env = process.env;
-  return {
-    port: parsePort(env.LORE_LISTEN_PORT, 6969),
-    host: env.LORE_LISTEN_HOST || "127.0.0.1",
-    upstreamAnthropic: trimTrailingSlash(
-      env.LORE_UPSTREAM_ANTHROPIC || "https://api.anthropic.com",
-    ),
-    upstreamOpenAI: trimTrailingSlash(
-      env.LORE_UPSTREAM_OPENAI || "https://api.openai.com",
-    ),
-    idleTimeoutSeconds: parsePositiveInt(env.LORE_IDLE_TIMEOUT, 60),
-    debug: isTruthy(env.LORE_DEBUG),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Upstream routing — model name → provider URL + protocol
-// ---------------------------------------------------------------------------
-
-export type UpstreamRoute = {
-  url: string;
-  protocol: "anthropic" | "openai";
-};
-
-/**
- * Model prefix → upstream provider routing table.
- *
- * Ordered from most-specific to most-general so that e.g. `claude-3-5-haiku`
- * matches `claude-` before any catch-all. Unknown models fall back to the
- * env-var-configured defaults.
- */
-const UPSTREAM_ROUTES: Array<{ prefix: string; url: string; protocol: "anthropic" | "openai" }> = [
-  // Anthropic
-  { prefix: "claude-",        url: "https://api.anthropic.com",          protocol: "anthropic" },
-  // Nvidia NIM
-  { prefix: "nvidia/",        url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  { prefix: "meta/",          url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  { prefix: "mistralai/",     url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  { prefix: "google/",        url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  { prefix: "qwen/",          url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  { prefix: "deepseek/",      url: "https://integrate.api.nvidia.com",   protocol: "openai" },
-  // OpenAI
-  { prefix: "gpt-",           url: "https://api.openai.com",             protocol: "openai" },
-  { prefix: "o1-",            url: "https://api.openai.com",             protocol: "openai" },
-  { prefix: "o3-",            url: "https://api.openai.com",             protocol: "openai" },
-  { prefix: "o4-",            url: "https://api.openai.com",             protocol: "openai" },
-  // xAI
-  { prefix: "grok-",          url: "https://api.x.ai",                   protocol: "openai" },
-  // Mistral (direct)
-  { prefix: "mistral-",       url: "https://api.mistral.ai",             protocol: "openai" },
-  { prefix: "codestral-",     url: "https://api.mistral.ai",             protocol: "openai" },
-  // Google (direct)
-  { prefix: "gemini-",        url: "https://generativelanguage.googleapis.com", protocol: "openai" },
-];
-
-/**
- * Resolve which upstream to use for a given model name.
- *
- * Returns the inferred route, or null if the model doesn't match any known
- * prefix (caller should fall back to env-var-configured defaults).
- */
-export function resolveUpstreamRoute(model: string): UpstreamRoute | null {
-  for (const route of UPSTREAM_ROUTES) {
-    if (model.startsWith(route.prefix)) {
-      return { url: route.url, protocol: route.protocol };
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Project path inference
-// ---------------------------------------------------------------------------
-
-/**
- * Regex patterns to extract an absolute project path from a system prompt.
- *
- * Claude Code embeds absolute paths in several places:
- *  - CLAUDE.md content references (`/home/user/project/CLAUDE.md`)
- *  - Tool definitions mention cwd (`"cwd": "/home/user/project"`)
- *  - Working directory lines (`Working directory: /Users/…/project`)
- *
- * Each pattern captures the directory portion (no trailing filename when
- * possible). Ordered from most-specific to most-general.
- */
-const PROJECT_PATH_PATTERNS: RegExp[] = [
-  // "cwd": "/home/…/project" or "cwd":"/Users/…/project" (JSON-style)
-  /["']?cwd["']?\s*[:=]\s*["']?(\/(?:home|Users)\/[^\s"',}]+)/,
-  // Working directory: /home/user/project
-  /[Ww]orking\s+directory[:=]\s*(\/(?:home|Users)\/[^\s"',]+)/,
-  // CLAUDE.md / AGENTS.md / .lore.md file path → take the directory
-  /(\/(?:home|Users)\/[^\s"',]+)\/(?:CLAUDE|AGENTS|\.lore)\.md/,
-  // Generic absolute path starting with /home/ or /Users/ — first occurrence
-  // Captures until whitespace, quote, comma, or bracket.
-  /(\/(?:home|Users)\/[\w./-]+)/,
-];
-
-/**
- * Try to extract a project path from the system prompt content.
- *
- * Claude Code includes absolute paths in its system prompt (CLAUDE.md
- * content, tool definitions, working directory references). Returns the
- * extracted path or `null` if nothing looks like a project directory.
- */
-export function inferProjectPath(systemPrompt: string): string | null {
-  for (const pattern of PROJECT_PATH_PATTERNS) {
-    const match = pattern.exec(systemPrompt);
-    if (match?.[1]) {
-      // Strip trailing slashes for consistency
-      return match[1].replace(/\/+$/, "") || null;
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// getProjectPath
-// ---------------------------------------------------------------------------
-
-/**
- * Resolve the project path for a request. Checks in order:
- *  1. `X-Lore-Project` header (explicit override)
- *  2. `inferProjectPath(systemPrompt)` (zero-config extraction)
- *  3. `process.cwd()` (last resort fallback)
- */
-export function getProjectPath(
-  systemPrompt: string,
-  headers: Record<string, string>,
-): string {
-  // 1. Explicit header override
-  const headerPath = headers["x-lore-project"];
-  if (headerPath) return headerPath;
-
-  // 2. Infer from system prompt content
-  const inferred = inferProjectPath(systemPrompt);
-  if (inferred) return inferred;
-
-  // 3. Fall back to gateway's own cwd
-  return process.cwd();
-}
-
-// ---------------------------------------------------------------------------
-// Helpers (not exported — internal only)
-// ---------------------------------------------------------------------------
-
-function parsePort(value: string | undefined, fallback: number): number {
-  if (!value) return fallback;
-  const n = Number.parseInt(value, 10);
-  if (Number.isNaN(n) || n < 0 || n > 65535) return fallback;
-  return n;
-}
-
-function parsePositiveInt(
-  value: string | undefined,
-  fallback: number,
-): number {
-  if (!value) return fallback;
-  const n = Number.parseInt(value, 10);
-  if (Number.isNaN(n) || n <= 0) return fallback;
-  return n;
-}
-
-function isTruthy(value: string | undefined): boolean {
-  return value === "1" || value?.toLowerCase() === "true";
-}
-
-function trimTrailingSlash(url: string): string {
-  return url.replace(/\/+$/, "");
-}

package/src/idle.ts

@@ -1,240 +0,0 @@
-/**
- * Idle detection and background work scheduling for the Lore gateway.
- *
- * Since the gateway doesn't have host lifecycle hooks (like OpenCode's
- * `session.idle` event), it uses a timer-based approach to detect when
- * sessions go idle and trigger background work (distillation, curation,
- * pruning, AGENTS.md export, etc.).
- */
-
-import { join } from "node:path";
-import {
-  temporal,
-  distillation,
-  curator,
-  ltm,
-  latReader,
-  log,
-  config as loreConfig,
-  getLastTurnAt,
-  exportToFile,
-  exportLoreFile,
-} from "@loreai/core";
-import type { LLMClient } from "@loreai/core";
-import type { GatewayConfig } from "./config";
-import type { SessionState } from "./translate/types";
-import type { AuthCredential } from "./auth";
-import { maybeValidateWorkerModel, getWorkerModel } from "./worker-model";
-
-const POLL_INTERVAL_MS = 30_000;
-
-// ---------------------------------------------------------------------------
-// startIdleScheduler
-// ---------------------------------------------------------------------------
-
-/**
- * Start a periodic timer that checks each active session for idle timeout.
- *
- * Every 30 seconds, walks the sessions map and fires `doIdleWork` for any
- * session whose `lastRequestTime` is older than `config.idleTimeoutSeconds`.
- * Tracks in-progress sessions to avoid double-triggering.
- *
- * @returns A cleanup function that clears the interval timer.
- */
-export function startIdleScheduler(
-  config: GatewayConfig,
-  sessions: Map<string, SessionState>,
-  doIdleWork: (sessionID: string, state: SessionState) => Promise<void>,
-): () => void {
-  const inProgress = new Set<string>();
-
-  const timer = setInterval(() => {
-    const now = Date.now();
-    const timeoutMs = config.idleTimeoutSeconds * 1000;
-
-    for (const [sessionID, state] of sessions) {
-      if (inProgress.has(sessionID)) continue;
-      if (now - state.lastRequestTime < timeoutMs) continue;
-
-      inProgress.add(sessionID);
-      doIdleWork(sessionID, state)
-        .catch((e) => log.error(`idle work failed for session ${sessionID}:`, e))
-        .finally(() => inProgress.delete(sessionID));
-    }
-  }, POLL_INTERVAL_MS);
-
-  return () => clearInterval(timer);
-}
-
-// ---------------------------------------------------------------------------
-// touchSession
-// ---------------------------------------------------------------------------
-
-/**
- * Update a session's `lastRequestTime` to now. Called on every request.
- */
-export function touchSession(
-  sessions: Map<string, SessionState>,
-  sessionID: string,
-): void {
-  const state = sessions.get(sessionID);
-  if (state) {
-    state.lastRequestTime = Date.now();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// buildIdleWorkHandler
-// ---------------------------------------------------------------------------
-
-/**
- * Build the idle work handler that runs the same background tasks as
- * OpenCode/Pi adapters on session idle:
- *
- *  1. Distillation (if enough undistilled messages)
- *  2. Curation (if enough turns since last curation)
- *  3. Consolidation (if entries exceed max)
- *  4. Temporal pruning
- *  5. AGENTS.md export
- *  6. Dead reference cleanup
- *  7. lat.md refresh
- *
- * Each step is independently try/catch'd — one failure won't block the rest.
- *
- * @param projectPath - Resolved project directory path
- * @param llm - LLM client for worker calls (distillation, curation)
- * @param upstreamUrl - Anthropic API base URL (for model discovery)
- * @param getAuth - Callback to resolve auth credentials
- * @param sessionModel - Model ID used for conversation (frontier model)
- */
-export function buildIdleWorkHandler(
-  projectPath: string,
-  llm: LLMClient,
-  upstreamUrl: string,
-  getAuth: () => AuthCredential | null,
-  sessionModel: string,
-): (sessionID: string, state: SessionState) => Promise<void> {
-  return async (sessionID: string, state: SessionState) => {
-    const cfg = loreConfig();
-
-    // 0. Worker model validation — discover cheaper models for background work.
-    // Runs before distillation/curation so the resolved model is up-to-date.
-    try {
-      const cred = getAuth();
-      if (cred) {
-        await maybeValidateWorkerModel(
-          sessionModel,
-          upstreamUrl,
-          cred,
-          llm,
-          projectPath,
-          sessionID,
-        );
-      }
-    } catch (e) {
-      log.error("idle worker model validation error:", e);
-    }
-
-    const model = getWorkerModel();
-
-    // 1. Distillation — force-distill ALL pending messages on idle, even
-    // below minMessages. The cache is going cold; aggressive distillation
-    // now means a smaller context on the next turn via post-idle compact.
-    // Meta-distillation is always allowed on idle (cache is cold anyway).
-    try {
-      const pending = temporal.undistilledCount(projectPath, sessionID);
-      if (pending > 0) {
-        await distillation.run({ llm, projectPath, sessionID, model, force: true });
-      }
-    } catch (e) {
-      log.error("idle distillation error:", e);
-    }
-
-    // 2. Curation
-    if (cfg.knowledge.enabled && cfg.curator.onIdle) {
-      try {
-        if (state.turnsSinceCuration >= cfg.curator.afterTurns) {
-          await curator.run({ llm, projectPath, sessionID, model });
-          state.turnsSinceCuration = 0;
-        }
-      } catch (e) {
-        log.error("idle curation error:", e);
-      }
-    }
-
-    // 3. Consolidation — runs after curation so new entries are counted
-    if (cfg.knowledge.enabled) {
-      try {
-        const entries = ltm.forProject(projectPath, false);
-        if (entries.length > cfg.curator.maxEntries) {
-          log.info(
-            `entry count ${entries.length} exceeds maxEntries ${cfg.curator.maxEntries} — running consolidation`,
-          );
-          const { updated, deleted } = await curator.consolidate({
-            llm,
-            projectPath,
-            sessionID,
-            model,
-          });
-          if (updated > 0 || deleted > 0) {
-            log.info(`consolidation: ${updated} updated, ${deleted} deleted`);
-          }
-        }
-      } catch (e) {
-        log.error("idle consolidation error:", e);
-      }
-    }
-
-    // 4. Temporal pruning
-    try {
-      const { ttlDeleted, capDeleted } = temporal.prune({
-        projectPath,
-        retentionDays: cfg.pruning.retention,
-        maxStorageMB: cfg.pruning.maxStorage,
-      });
-      if (ttlDeleted > 0 || capDeleted > 0) {
-        log.info(
-          `pruned temporal messages: ${ttlDeleted} by TTL, ${capDeleted} by size cap`,
-        );
-      }
-    } catch (e) {
-      log.error("idle pruning error:", e);
-    }
-
-    // 5. Knowledge export (.lore.md + optional agents file pointer)
-    if (cfg.knowledge.enabled) {
-      try {
-        const entries = ltm.forProject(projectPath, false);
-        if (entries.length > 0) {
-          if (cfg.agentsFile.enabled) {
-            const filePath = join(projectPath, cfg.agentsFile.path);
-            exportToFile({ projectPath, filePath });
-          } else {
-            exportLoreFile(projectPath);
-          }
-        }
-      } catch (e) {
-        log.error("idle knowledge export error:", e);
-      }
-    }
-
-    // 6. Dead reference cleanup
-    if (cfg.knowledge.enabled) {
-      try {
-        const cleaned = ltm.cleanDeadRefs();
-        if (cleaned > 0) {
-          log.info(`cleaned ${cleaned} dead knowledge cross-references`);
-        }
-      } catch (e) {
-        log.error("idle dead-ref cleanup error:", e);
-      }
-    }
-
-    // 7. lat.md refresh
-    try {
-      latReader.refresh(projectPath);
-    } catch (e) {
-      log.error("idle lat-reader refresh error:", e);
-    }
-  };
-}

package/src/index.ts

@@ -1,41 +0,0 @@
-/**
- * Lore Gateway — package entry point.
- *
- * Library exports for programmatic use, plus `_cli()` for the CLI binary.
- *
- * Library usage:
- *   import { startServer, loadConfig } from "@loreai/gateway";
- *
- * CLI usage (via bin wrapper):
- *   lore start
- *   lore run claude
- */
-import "../instrument";
-
-// ---------------------------------------------------------------------------
-// Library API
-// ---------------------------------------------------------------------------
-
-export { loadConfig } from "./config";
-export type { GatewayConfig } from "./config";
-export { startServer } from "./server";
-export { handleRequest, resetPipelineState } from "./pipeline";
-
-// ---------------------------------------------------------------------------
-// CLI entry — called by dist/bin.cjs or `bun run src/index.ts`
-// ---------------------------------------------------------------------------
-
-export { _cli } from "./cli/main";
-
-// ---------------------------------------------------------------------------
-// Direct execution — `bun run src/index.ts` still works as before
-// ---------------------------------------------------------------------------
-
-if (typeof Bun !== "undefined" && Bun.main === import.meta.path) {
-  // Direct execution (e.g. `bun run src/index.ts` from the OpenCode plugin)
-  // defaults to server-only mode (`start`), not `run` — there's no TTY and
-  // no reason to auto-detect agents when launched as an embedded server.
-  // esbuild CJS output drops import.meta to `{}` so the condition is
-  // always false in the npm bundle — the await is dead-code-eliminated.
-  import("./cli/start").then(({ commandStart }) => commandStart({}));
-}