repoburg 1.3.201 → 1.3.204

package/agent-pane/backend/src/repoburg/repoburg-provider.ts

@@ -1,422 +0,0 @@
-/**
- * Repoburg provider — drives the repoburg backend's full agent engine
- * through TWO channels:
- *
- *  - CONTROL (HTTP): session create/patch, input, cancel, models — via
- *    RepoburgHttpClient (repoburg-client.ts).
- *  - MESSAGES (SSE): the agent-runtime stream (agent-runtime-client.ts) —
- *    Claude-Code-style ordered messages projected onto agent-pane items by
- *    TurnProjector (turn-projector.ts). The terminal `result` message ends
- *    the turn; ordering is guaranteed by the backend's emission points.
- *
- * The repoburg session UUID is persisted in `sessions.external_thread_id`.
- * Backend lifecycle: the backend instance per workspace is resolved via the
- * platform daemon (backend-resolver.ts) — started/restarted on demand; the
- * user never starts a repoburg backend manually.
- */
-
-import type Database from 'better-sqlite3';
-import type { ModelInfo } from '@agentpane/shared';
-import { getDb } from '../db/index.ts';
-import { broadcast } from '../ws/index.ts';
-import { RepoburgHttpClient } from './repoburg-client.ts';
-import type { RepoburgRuntimeClient } from './repoburg-client.ts';
-import { resolveBackendUrl, invalidateBackend } from './backend-resolver.ts';
-import { setSessionStatus } from './action-mapping.ts';
-import { TurnProjector } from './turn-projector.ts';
-import { streamAgentRuntimeMessages } from './agent-runtime-client.ts';
-import type { Session, Turn } from '../db/schema.ts';
-import type { RuntimeProvider } from '../providers/runtime-provider.ts';
-
-// ---------------------------------------------------------------------------
-// Reasoning-effort mapping (root enum ↔ Ollama think levels)
-// ---------------------------------------------------------------------------
-
-/** Reasoning levels offered for non-Ollama runtime models (full root enum). */
-const REASONING_LEVELS: { effort: string; label: string }[] = [
-  { effort: 'low', label: 'Low' },
-  { effort: 'medium', label: 'Medium' },
-  { effort: 'high', label: 'High' },
-  { effort: 'xhigh', label: 'Extra High' },
-];
-
-/** Ollama `think` accepts only low|medium|high|max|bool — xhigh/minimal/none
- *  are rejected with 400. Offer only the expressible levels. */
-const OLLAMA_REASONING_LEVELS = REASONING_LEVELS.filter((l) => l.effort !== 'xhigh');
-
-/** Map an agent-pane reasoning level onto a root-backend ReasoningEffort the
- *  runtime's LLM accepts. The root backend forwards reasoning_effort verbatim
- *  into the provider call (Ollama `think`), so unsafe levels are clamped or
- *  omitted: ollama xhigh→high, minimal/none→omit; other providers verbatim. */
-export function mapReasoningEffort(
-  modelId: string | null | undefined,
-  effort: string | null | undefined,
-): string | undefined {
-  if (!effort) return undefined;
-  if (!['xhigh', 'high', 'medium', 'low', 'minimal', 'none'].includes(effort)) return undefined;
-  if (modelId?.startsWith('ollama/')) {
-    if (effort === 'xhigh') return 'high';
-    if (effort === 'low' || effort === 'medium' || effort === 'high') return effort;
-    return undefined; // minimal/none are not expressible via Ollama `think`
-  }
-  return effort;
-}
-
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-
-/** One running agent-pane turn on a repoburg session. */
-interface ActiveTurn {
-  turnId: string;
-  projector: TurnProjector;
-  /** Aborts the current SSE connection (stall watchdog / interrupt). */
-  sseAbort: AbortController;
-  /** true once the user interrupted — stream loop stops reconnecting. */
-  cancelled: boolean;
-}
-
-/** Per-agent-pane-session runtime state. */
-interface SessionEntry {
-  agentPaneSessionId: string;
-  repoburgSessionId: string;
-  client: RepoburgRuntimeClient;
-  baseUrl: string;
-  /** Last model id pushed to the runtime session (mid-session change detection). */
-  modelId: string | null;
-  /** Last mapped reasoning effort pushed to the runtime session. */
-  reasoningEffort: string | undefined;
-  activeTurn: ActiveTurn | null;
-}
-
-const sessionMap = new Map<string, SessionEntry>();
-
-/** Bytes-level stream watchdog: no bytes (message OR heartbeat) within this
- *  window → abort the SSE connection and reconnect. */
-const STALLED_STREAM_MS = 60_000;
-
-/** Connection-level failures that mean the backend URL must be re-resolved. */
-function isConnectionError(err: unknown): boolean {
-  const message = String((err as Error)?.message ?? '');
-  return /fetch failed|ECONNREFUSED|ENOTFOUND|ECONNRESET|ETIMEDOUT|EHOSTUNREACH|socket hang up/i.test(
-    message,
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Session management
-// ---------------------------------------------------------------------------
-
-/** Create or reuse the runtime session for an agent-pane session. */
-async function ensureSession(
-  session: Session,
-  client: RepoburgRuntimeClient,
-  baseUrl: string,
-): Promise<SessionEntry> {
-  const existing = sessionMap.get(session.id);
-  if (existing) return existing;
-
-  if (session.external_thread_id) {
-    const entry: SessionEntry = {
-      agentPaneSessionId: session.id,
-      repoburgSessionId: session.external_thread_id,
-      client,
-      baseUrl,
-      modelId: session.model ?? null,
-      // undefined forces a re-push on the next turn — heals sessions created
-      // before unsafe effort values (e.g. ollama xhigh) were clamped.
-      reasoningEffort: undefined,
-      activeTurn: null,
-    };
-    sessionMap.set(session.id, entry);
-    return entry;
-  }
-
-  // First turn — create a runtime session carrying model + reasoning config.
-  const mappedEffort = mapReasoningEffort(session.model, session.model_reasoning_effort);
-  const created = await client.createSession({
-    session_title: session.title ?? undefined,
-    model_id: session.model ?? undefined,
-    reasoning_effort: mappedEffort,
-  });
-
-  const db = getDb();
-  const now = new Date().toISOString();
-  db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
-    created.id,
-    now,
-    session.id,
-  );
-
-  const entry: SessionEntry = {
-    agentPaneSessionId: session.id,
-    repoburgSessionId: created.id,
-    client,
-    baseUrl,
-    modelId: session.model ?? null,
-    reasoningEffort: mappedEffort,
-    activeTurn: null,
-  };
-  sessionMap.set(session.id, entry);
-  return entry;
-}
-
-// ---------------------------------------------------------------------------
-// Turn lifecycle
-// ---------------------------------------------------------------------------
-
-/** Mark a turn failed and reset the session — used before a projector exists. */
-function failTurnBeforeStart(db: Database.Database, sessionId: string, turnId: string, error: string): void {
-  const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-    'failed',
-    error,
-    now,
-    turnId,
-  );
-  setSessionStatus(db, sessionId, 0, 'failed', now);
-  broadcast('turn:failed', { sessionId, turnId, error });
-}
-
-/** Fail the active turn — projector closed, stream stopped, state dropped. */
-function failTurn(entry: SessionEntry, error: string): void {
-  const active = entry.activeTurn;
-  if (!active) return;
-  entry.activeTurn = null;
-  active.projector.close();
-  active.sseAbort.abort();
-
-  const db = getDb();
-  const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?').run(
-    'failed',
-    error,
-    now,
-    active.turnId,
-  );
-  db.prepare('UPDATE items SET status = ?, updated_at = ? WHERE turn_id = ? AND status = ?').run(
-    'failed',
-    now,
-    active.turnId,
-    'in_progress',
-  );
-  setSessionStatus(db, entry.agentPaneSessionId, 0, 'failed', now);
-  broadcast('turn:failed', { sessionId: entry.agentPaneSessionId, turnId: active.turnId, error });
-}
-
-/**
- * SSE loop — consume the agent-runtime message stream until the projector
- * finalizes the turn. Handles reconnects (connection drops) and the
- * bytes-level stall watchdog (silent connection → abort + reconnect).
- */
-async function runStreamLoop(entry: SessionEntry, projector: TurnProjector): Promise<void> {
-  while (entry.activeTurn?.projector === projector && !projector.isDone) {
-    const active = entry.activeTurn;
-    const controller = new AbortController();
-    active.sseAbort = controller;
-
-    // Bytes watchdog — heartbeats count as activity (server alive).
-    let stallTimer: ReturnType<typeof setTimeout> | null = null;
-    const resetStall = (): void => {
-      if (stallTimer) clearTimeout(stallTimer);
-      stallTimer = setTimeout(() => controller.abort(), STALLED_STREAM_MS);
-    };
-    resetStall();
-
-    const reason = await streamAgentRuntimeMessages(
-      entry.baseUrl,
-      entry.repoburgSessionId,
-      (message) => projector.handle(message),
-      { signal: controller.signal, onActivity: resetStall },
-    );
-
-    if (stallTimer) clearTimeout(stallTimer);
-
-    if (projector.isDone || entry.activeTurn?.projector !== projector) return;
-    if (reason === 'session-not-found') {
-      failTurn(entry, 'Repoburg session no longer exists on the backend.');
-      return;
-    }
-    if (reason === 'aborted') {
-      if (active.cancelled) return; // user interrupt — already finalized.
-      continue; // stall-forced abort → reconnect with a fresh signal.
-    }
-    // reason === 'result' implies projector.isDone (handled above).
-  }
-}
-
-/** Start a repoburg turn. Fire-and-forget — messages stream via SSE. */
-export async function startTurn(session: Session, turn: Turn): Promise<void> {
-  const db = getDb();
-
-  // Phase 0: resolve the workspace's backend instance (daemon-managed).
-  let client: RepoburgRuntimeClient;
-  let baseUrl: string;
-  try {
-    const resolved = await resolveBackendUrl(session.cwd ?? process.cwd());
-    if (!resolved) throw new Error('No repoburg backend resolved.');
-    baseUrl = resolved.baseUrl;
-    client = new RepoburgHttpClient(baseUrl);
-  } catch (err) {
-    failTurnBeforeStart(db, session.id, turn.id, `Failed to resolve repoburg backend: ${(err as Error).message}`);
-    return;
-  }
-
-  // Phase 1: ensure the runtime session exists.
-  let entry: SessionEntry;
-  try {
-    entry = await ensureSession(session, client, baseUrl);
-  } catch (err) {
-    if (isConnectionError(err)) invalidateBackend(baseUrl);
-    failTurnBeforeStart(db, session.id, turn.id, `Failed to create repoburg session: ${(err as Error).message}`);
-    return;
-  }
-
-  // Phase 2: push model/reasoning changes (mid-session switches in agent-pane).
-  const wantedModel = session.model ?? null;
-  const wantedEffort = mapReasoningEffort(session.model, session.model_reasoning_effort);
-  if (wantedModel !== entry.modelId || wantedEffort !== entry.reasoningEffort) {
-    try {
-      await entry.client.patchSession(entry.repoburgSessionId, {
-        model_id: wantedModel ?? undefined,
-        reasoning_effort: wantedEffort,
-      });
-      entry.modelId = wantedModel;
-      entry.reasoningEffort = wantedEffort;
-    } catch (err) {
-      console.error(`[repoburg] patchSession failed for ${entry.repoburgSessionId}:`, err);
-    }
-  }
-
-  // Phase 3: mark running + open the message stream.
-  const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('running', now, turn.id);
-  setSessionStatus(db, session.id, 1, 'running', now);
-  broadcast('turn:started', { sessionId: session.id, turnId: turn.id });
-
-  const projector = new TurnProjector({
-    agentPaneSessionId: session.id,
-    turnId: turn.id,
-    repoburgSessionId: entry.repoburgSessionId,
-    client: entry.client,
-  });
-  entry.activeTurn = { turnId: turn.id, projector, sseAbort: new AbortController(), cancelled: false };
-
-  // Phase 4: consume the SSE message stream (reconnects internally).
-  runStreamLoop(entry, projector).catch((err) => {
-    console.error('[repoburg] stream loop crashed:', err);
-    failTurn(entry, `Stream loop failed: ${(err as Error).message}`);
-  });
-
-  // Phase 5: start the agent turn on the backend.
-  try {
-    // `auto_apply` keeps actions autonomous (agent-like). It is per-input, so
-    // the backend's global execution-strategy setting stays untouched.
-    await entry.client.createInput(entry.repoburgSessionId, {
-      user_prompt: turn.user_prompt,
-      execution_strategy: 'auto_apply',
-    });
-  } catch (err) {
-    if (isConnectionError(err)) invalidateBackend(entry.baseUrl);
-    failTurn(entry, (err as Error).message);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Provider interface
-// ---------------------------------------------------------------------------
-
-/** Cancel a running turn by agent-pane session id. Returns true if a turn was cancelled. */
-export async function interruptTurn(sessionId: string): Promise<boolean> {
-  const entry = sessionMap.get(sessionId);
-  const active = entry?.activeTurn;
-  if (!entry || !active) return false;
-
-  // Finalize locally at once — the backend's result{aborted} may follow on a
-  // stream we no longer consume.
-  active.cancelled = true;
-  entry.activeTurn = null;
-  active.projector.close();
-  active.sseAbort.abort();
-
-  // Best-effort abort of the in-flight LLM round. Note: this cannot stop
-  // mid-action execution on the runtime side.
-  entry.client
-    .cancel(entry.repoburgSessionId)
-    .catch((err) => console.error('[repoburg] cancel failed:', err));
-
-  const db = getDb();
-  const now = new Date().toISOString();
-  db.prepare('UPDATE turns SET status = ?, updated_at = ? WHERE id = ?').run('aborted', now, active.turnId);
-  db.prepare('UPDATE items SET status = ?, updated_at = ? WHERE turn_id = ? AND status = ?').run(
-    'completed',
-    now,
-    active.turnId,
-    'in_progress',
-  );
-  setSessionStatus(db, sessionId, 0, 'active', now);
-  broadcast('turn:cancelled', { sessionId, turnId: active.turnId });
-
-  return true;
-}
-
-/** Drop a session's active stream (rewind/provider switch) and in-memory state. */
-export function clearThread(sessionId: string): void {
-  const entry = sessionMap.get(sessionId);
-  if (entry?.activeTurn) {
-    const active = entry.activeTurn;
-    entry.activeTurn = null;
-    active.projector.close();
-    active.sseAbort.abort();
-  }
-  sessionMap.delete(sessionId);
-}
-
-/** Clear all session state. Used in test cleanup. */
-export function clearAllThreads(): void {
-  for (const entry of sessionMap.values()) {
-    if (entry.activeTurn) {
-      const active = entry.activeTurn;
-      entry.activeTurn = null;
-      active.projector.close();
-      active.sseAbort.abort();
-    }
-  }
-  sessionMap.clear();
-}
-
-/** Fetch available models from the runtime and map to ModelInfo[].
- *  Never starts a backend (autoStart=false) — empty list until the first turn
- *  brings a workspace backend up. */
-async function getModels(): Promise<ModelInfo[]> {
-  try {
-    const resolved = await resolveBackendUrl(process.cwd(), { autoStart: false });
-    if (!resolved) return [];
-    const models = await new RepoburgHttpClient(resolved.baseUrl).getModels();
-    return models.map((m) => ({
-      slug: m.id,
-      displayName: m.name,
-      description: 'Repoburg backend',
-      defaultReasoning: 'medium',
-      // Ollama rejects xhigh/minimal/none as `think` — offer only valid levels.
-      reasoningLevels: m.id.startsWith('ollama/') ? OLLAMA_REASONING_LEVELS : REASONING_LEVELS,
-    }));
-  } catch {
-    return [];
-  }
-}
-
-/** Graceful shutdown — abort active streams and clear state. */
-async function shutdown(): Promise<void> {
-  clearAllThreads();
-}
-
-/** Repoburg provider — implements RuntimeProvider. */
-export const repoburgProvider: RuntimeProvider = {
-  startTurn,
-  interruptTurn,
-  clearThread,
-  clearAllThreads,
-  getModels,
-  shutdown,
-};