@ebowwa/coder 0.7.63 → 0.7.65

package/packages/src/core/retry.ts

@@ -0,0 +1,180 @@
+/**
+ * Retry Logic - Exponential backoff with jitter for API failures
+ * Handles rate limits, network errors, and transient failures
+ */
+
+export interface RetryOptions {
+  maxRetries?: number;
+  baseDelayMs?: number;
+  maxDelayMs?: number;
+  jitterFactor?: number;
+  retryableStatusCodes?: number[];
+  onRetry?: (attempt: number, error: Error, delayMs: number) => void;
+}
+
+const DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 30000,
+  jitterFactor: 0.2,
+  retryableStatusCodes: [429, 500, 502, 503, 504, 529],
+  onRetry: undefined as ((attempt: number, error: Error, delayMs: number) => void) | undefined,
+};
+
+/**
+ * Calculate delay with exponential backoff and jitter
+ */
+function calculateDelay(
+  attempt: number,
+  baseDelayMs: number,
+  maxDelayMs: number,
+  jitterFactor: number
+): number {
+  // Exponential backoff: baseDelay * 2^attempt
+  const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+
+  // Add jitter to prevent thundering herd
+  const jitter = exponentialDelay * jitterFactor * (Math.random() * 2 - 1);
+
+  // Cap at max delay
+  return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+
+/**
+ * Check if an error is retryable
+ */
+function isRetryableError(
+  error: Error,
+  retryableStatusCodes: number[]
+): boolean {
+  // Check for rate limit errors
+  if (error.message.includes("429") || error.message.includes("rate limit")) {
+    return true;
+  }
+
+  // Check for server errors
+  if (error.message.includes("500") ||
+      error.message.includes("502") ||
+      error.message.includes("503") ||
+      error.message.includes("504")) {
+    return true;
+  }
+
+  // Check for network errors
+  if (error.message.includes("ECONNREFUSED") ||
+      error.message.includes("ENOTFOUND") ||
+      error.message.includes("ETIMEDOUT") ||
+      error.message.includes("network") ||
+      error.message.includes("fetch failed")) {
+    return true;
+  }
+
+  // Check for transient API errors (empty/malformed responses)
+  if (error.message.includes("No message received") ||
+      error.message.includes("empty response") ||
+      error.message.includes("invalid response") ||
+      error.message.includes("unexpected EOF") ||
+      error.message.includes("connection reset") ||
+      error.message.includes("aborted")) {
+    return true;
+  }
+
+  // Check for specific status codes in error message
+  for (const code of retryableStatusCodes) {
+    if (error.message.includes(String(code))) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Execute a function with retry logic
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+): Promise<T> {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  let lastError: Error | null = null;
+
+  for (let attempt = 0; attempt <= opts.maxRetries!; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      // Check if we should retry
+      if (attempt < opts.maxRetries! && isRetryableError(lastError, opts.retryableStatusCodes!)) {
+        const delayMs = calculateDelay(
+          attempt,
+          opts.baseDelayMs!,
+          opts.maxDelayMs!,
+          opts.jitterFactor!
+        );
+
+        // Log retry attempt
+        if (opts.onRetry) {
+          opts.onRetry(attempt + 1, lastError, delayMs);
+        } else {
+          console.warn(
+            `\x1b[33mRetry ${attempt + 1}/${opts.maxRetries} after ${delayMs}ms: ${lastError.message}\x1b[0m`
+          );
+        }
+
+        await sleep(delayMs);
+      } else {
+        // Non-retryable error or max retries reached
+        throw lastError;
+      }
+    }
+  }
+
+  throw lastError || new Error("Max retries exceeded");
+}
+
+/**
+ * Create a retry wrapper for fetch
+ */
+export function createFetchWithRetry(
+  options: RetryOptions = {}
+): (url: string, init?: RequestInit) => Promise<Response> {
+  return async (url: string, init?: RequestInit): Promise<Response> => {
+    return withRetry(
+      async () => {
+        const response = await fetch(url, init);
+
+        // Check for retryable status codes
+        if (options.retryableStatusCodes?.includes(response.status)) {
+          const text = await response.text();
+          throw new Error(`API error: ${response.status} - ${text}`);
+        }
+
+        return response;
+      },
+      options
+    );
+  };
+}
+
+/**
+ * Parse retry-after header from rate limit response
+ */
+export function parseRetryAfter(response: Response): number | null {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      return seconds * 1000; // Convert to milliseconds
+    }
+  }
+  return null;
+}

package/packages/src/core/session-store.ts

@@ -0,0 +1,36 @@
+/**
+ * Session Store - Backward compatibility layer
+ * Re-exports from composable sessions module
+ *
+ * @deprecated Import from "./sessions/index.js" instead for composable access
+ */
+
+// Re-export everything from the new composable module
+export {
+  SessionStore,
+  SessionPersistence,
+  SessionMetadataManager,
+  SessionExporter,
+  formatSessionSummary,
+  printSessionsList,
+  // Types
+  type SessionMetadata,
+  type SessionMessage,
+  type SessionToolUse,
+  type SessionMetrics,
+  type SessionContext,
+  type SessionCheckpoint,
+  type SessionEntry,
+  type LoadedSession,
+  type SessionSummary,
+  type SessionFilter,
+  type SessionEvent,
+  type SessionEventType,
+  type SessionEventHandler,
+  type ExportFormat,
+  type ISessionPersistence,
+  type ISessionExporter,
+} from "./sessions/index.js";
+
+// Default export
+export { SessionStore as default } from "./sessions/index.js";

package/packages/src/core/sessions/export.ts

@@ -0,0 +1,329 @@
+/**
+ * Session Export - Export sessions to various formats
+ * Supports JSONL, JSON, and Markdown
+ */
+
+import { join } from "path";
+import type {
+  LoadedSession,
+  SessionSummary,
+  ExportFormat,
+  ISessionExporter,
+  SessionToolUse,
+} from "./types.js";
+import type { ContentBlock, ToolUseBlock, ToolResultBlock } from "../../types/index.js";
+import { SessionPersistence } from "./persistence.js";
+
+export class SessionExporter implements ISessionExporter {
+  private persistence: SessionPersistence;
+
+  constructor(persistence: SessionPersistence) {
+    this.persistence = persistence;
+  }
+
+  /**
+   * Export a loaded session to the specified format
+   */
+  export(session: LoadedSession, format: ExportFormat): string {
+    switch (format) {
+      case "jsonl":
+        return this.toJsonl(session);
+      case "json":
+        return this.toJson(session);
+      case "markdown":
+        return this.toMarkdown(session);
+      default:
+        throw new Error(`Unsupported export format: ${format}`);
+    }
+  }
+
+  /**
+   * Export a session to a file
+   */
+  async exportToFile(
+    sessionId: string,
+    format: ExportFormat,
+    outputPath?: string
+  ): Promise<string> {
+    const sessionFile = this.persistence.getSessionPath(sessionId);
+
+    // For JSONL, just return the original file
+    if (format === "jsonl") {
+      const content = await Bun.file(sessionFile).text();
+      const finalPath = outputPath ?? join(process.cwd(), `session-${sessionId}.jsonl`);
+      await Bun.write(finalPath, content);
+      return finalPath;
+    }
+
+    // For other formats, we'd need to load and convert
+    // This is handled by the SessionStore which has access to the full session
+    throw new Error("Use SessionStore.exportSession for full export functionality");
+  }
+
+  /**
+   * Export to JSONL format (raw session file)
+   */
+  private toJsonl(session: LoadedSession): string {
+    const lines: string[] = [];
+
+    // Metadata first (with explicit type)
+    lines.push(JSON.stringify({ ...session.metadata, type: "metadata" }));
+
+    // Context
+    if (session.context) {
+      lines.push(JSON.stringify(session.context));
+    }
+
+    // Messages
+    for (const msg of session.messages) {
+      lines.push(JSON.stringify({ type: "message", timestamp: Date.now(), data: msg }));
+    }
+
+    // Tools
+    for (const tool of session.tools) {
+      lines.push(JSON.stringify(tool));
+    }
+
+    // Metrics
+    for (const metric of session.metrics) {
+      lines.push(JSON.stringify({ type: "metrics", timestamp: Date.now(), data: metric }));
+    }
+
+    // Checkpoints
+    for (const checkpoint of session.checkpoints) {
+      lines.push(JSON.stringify(checkpoint));
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Export to JSON format (pretty-printed)
+   */
+  private toJson(session: LoadedSession): string {
+    return JSON.stringify(session, null, 2);
+  }
+
+  /**
+   * Export to Markdown format
+   */
+  private toMarkdown(session: LoadedSession): string {
+    const lines: string[] = [];
+
+    // Header
+    lines.push(`# Session: ${session.metadata.id}`);
+    lines.push("");
+    lines.push(`**Created:** ${new Date(session.metadata.created).toISOString()}`);
+    lines.push(`**Model:** ${session.metadata.model}`);
+    lines.push(`**Working Directory:** ${session.metadata.workingDirectory}`);
+
+    if (session.metadata.agentName) {
+      lines.push(`**Agent:** ${session.metadata.agentName}`);
+    }
+
+    if (session.metadata.teamName) {
+      lines.push(`**Team:** ${session.metadata.teamName}`);
+    }
+
+    lines.push("");
+
+    // Messages
+    lines.push("## Conversation");
+    lines.push("");
+
+    for (const message of session.messages) {
+      const role = message.role === "user" ? "**User**" : "**Claude**";
+      lines.push(`### ${role}`);
+      lines.push("");
+
+      for (const block of message.content) {
+        this.formatBlock(block, lines);
+      }
+    }
+
+    // Tools
+    if (session.tools.length > 0) {
+      lines.push("## Tool Calls");
+      lines.push("");
+
+      for (const tool of session.tools) {
+        lines.push(`### ${tool.toolName}`);
+        lines.push("");
+        lines.push("**Input:**");
+        lines.push("```json");
+        lines.push(JSON.stringify(tool.input, null, 2));
+        lines.push("```");
+
+        if (tool.result) {
+          lines.push("");
+          lines.push(`**Result:**${tool.isError ? " (error)" : ""}`);
+          lines.push("```");
+          lines.push(tool.result);
+          lines.push("```");
+        }
+        lines.push("");
+      }
+    }
+
+    // Metrics
+    if (session.metrics.length > 0) {
+      lines.push("## Metrics");
+      lines.push("");
+
+      const totalCost = session.metrics.reduce((sum, m) => sum + m.costUSD, 0);
+      const totalInput = session.metrics.reduce(
+        (sum, m) => sum + m.usage.input_tokens,
+        0
+      );
+      const totalOutput = session.metrics.reduce(
+        (sum, m) => sum + m.usage.output_tokens,
+        0
+      );
+
+      lines.push(`- **Total Cost:** $${totalCost.toFixed(4)}`);
+      lines.push(`- **Total Input Tokens:** ${totalInput.toLocaleString()}`);
+      lines.push(`- **Total Output Tokens:** ${totalOutput.toLocaleString()}`);
+      lines.push(`- **API Calls:** ${session.metrics.length}`);
+    }
+
+    // Checkpoints
+    if (session.checkpoints.length > 0) {
+      lines.push("");
+      lines.push("## Checkpoints");
+      lines.push("");
+
+      for (const cp of session.checkpoints) {
+        const date = new Date(cp.timestamp).toISOString();
+        lines.push(`- ${cp.label ?? cp.checkpointId} (${date}) - ${cp.messageCount} messages`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Format a content block for markdown
+   */
+  private formatBlock(block: ContentBlock, lines: string[]): void {
+    switch (block.type) {
+      case "text":
+        lines.push(block.text);
+        lines.push("");
+        break;
+
+      case "tool_use": {
+        const tool = block as ToolUseBlock;
+        lines.push(`\`\`\`tool:${tool.name}`);
+        lines.push(JSON.stringify(tool.input, null, 2));
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+
+      case "tool_result": {
+        const result = block as ToolResultBlock;
+        lines.push(`**Result**${result.is_error ? " (error)" : ""}:`);
+        lines.push("```");
+        lines.push(
+          typeof result.content === "string"
+            ? result.content
+            : JSON.stringify(result.content, null, 2)
+        );
+        lines.push("```");
+        lines.push("");
+        break;
+      }
+
+      case "thinking":
+        lines.push("> **Thinking**");
+        lines.push(`> ${block.thinking.replace(/\n/g, "\n> ")}`);
+        lines.push("");
+        break;
+
+      case "image":
+        lines.push("*(Image)*");
+        lines.push("");
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Format a session summary for display
+   */
+  static formatSummary(session: SessionSummary): string {
+    const created = new Date(session.created);
+    const updated = session.lastActivity
+      ? new Date(session.lastActivity)
+      : new Date(session.updated);
+    const age = this.formatRelativeTime(updated);
+
+    const lines: string[] = [];
+
+    // Session ID and age
+    lines.push(`\x1b[1m${session.id}\x1b[0m (${age})`);
+
+    // Model and message count
+    lines.push(`  Model: ${session.model} | Messages: ${session.messageCount}`);
+
+    // Cost and tokens
+    const cost =
+      session.totalCost < 0.01
+        ? `$${session.totalCost.toFixed(4)}`
+        : `$${session.totalCost.toFixed(2)}`;
+    lines.push(
+      `  Cost: ${cost} | Tokens: ${session.totalTokens.input.toLocaleString()} in, ${session.totalTokens.output.toLocaleString()} out`
+    );
+
+    // First message preview
+    if (session.firstMessage) {
+      lines.push(`  Preview: ${session.firstMessage}`);
+    }
+
+    // Working directory
+    lines.push(`  Directory: ${session.workingDirectory}`);
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Format relative time
+   */
+  static formatRelativeTime(date: Date): string {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return "just now";
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+
+    return date.toLocaleDateString();
+  }
+
+  /**
+   * Print sessions list for CLI
+   */
+  static printList(sessions: SessionSummary[]): void {
+    if (sessions.length === 0) {
+      console.log("No sessions found.");
+      console.log("\nStart a new conversation to create a session.");
+      return;
+    }
+
+    console.log(`\x1b[1mRecent Sessions (${sessions.length})\x1b[0m\n`);
+
+    for (const session of sessions) {
+      console.log(this.formatSummary(session));
+      console.log("");
+    }
+
+    console.log("To resume a session:");
+    console.log("  coder --resume <session-id>");
+  }
+}