@ebowwa/coder 0.7.63 → 0.7.64

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

@@ -0,0 +1,309 @@
+/**
+ * Session Metadata - Manage session metadata and summaries
+ */
+
+import type {
+  SessionMetadata,
+  SessionSummary,
+  SessionEntry,
+  SessionMessage,
+  SessionMetrics,
+  SessionFilter,
+} from "./types.js";
+import type { ContentBlock, Message } from "../../types/index.js";
+import { SessionPersistence } from "./persistence.js";
+
+export class SessionMetadataManager {
+  private persistence: SessionPersistence;
+
+  constructor(persistence: SessionPersistence) {
+    this.persistence = persistence;
+  }
+
+  /**
+   * Generate a new session ID
+   */
+  generateId(): string {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${timestamp}-${random}`;
+  }
+
+  /**
+   * Create metadata for a new session
+   */
+  createMetadata(options: {
+    id?: string;
+    model: string;
+    workingDirectory: string;
+    agentName?: string;
+    agentColor?: string;
+    teamName?: string;
+  }): SessionMetadata {
+    return {
+      type: "metadata",
+      id: options.id ?? this.generateId(),
+      created: Date.now(),
+      updated: Date.now(),
+      model: options.model,
+      workingDirectory: options.workingDirectory,
+      agentName: options.agentName,
+      agentColor: options.agentColor,
+      teamName: options.teamName,
+      totalCost: 0,
+      totalTokens: { input: 0, output: 0 },
+    };
+  }
+
+  /**
+   * Update metadata timestamps
+   */
+  touch(metadata: SessionMetadata): SessionMetadata {
+    return {
+      ...metadata,
+      updated: Date.now(),
+    };
+  }
+
+  /**
+   * Merge updated fields into metadata
+   */
+  merge(
+    metadata: SessionMetadata,
+    updates: Partial<SessionMetadata>
+  ): SessionMetadata {
+    return {
+      ...metadata,
+      ...updates,
+      updated: Date.now(),
+    };
+  }
+
+  /**
+   * Get summary from session entries
+   */
+  async getSummary(sessionId: string): Promise<SessionSummary | null> {
+    const entries = await this.persistence.read(sessionId);
+    return this.entriesToSummary(sessionId, entries);
+  }
+
+  /**
+   * Convert entries to summary
+   */
+  entriesToSummary(
+    sessionId: string,
+    entries: SessionEntry[]
+  ): SessionSummary | null {
+    let metadata: SessionMetadata | null = null;
+    let messageCount = 0;
+    let totalCost = 0;
+    let totalInput = 0;
+    let totalOutput = 0;
+    let firstMessage: string | undefined;
+    let lastActivity: number | undefined;
+
+    for (const entry of entries) {
+      // All entries have a type field now
+      if ("type" in entry) {
+        switch (entry.type) {
+          case "metadata":
+            metadata = entry as SessionMetadata;
+            break;
+          case "message":
+            messageCount++;
+            lastActivity = entry.timestamp;
+            const msg = (entry as SessionMessage).data as Message;
+            if (!firstMessage && msg.role === "user") {
+              const textBlock = msg.content.find(
+                (b: ContentBlock) => b.type === "text"
+              );
+              if (textBlock && "text" in textBlock) {
+                firstMessage = textBlock.text.slice(0, 100);
+                if (textBlock.text.length > 100) {
+                  firstMessage += "...";
+                }
+              }
+            }
+            break;
+
+          case "metrics":
+            const metrics = (entry as SessionMetrics).data;
+            totalCost += metrics.costUSD;
+            totalInput += metrics.usage.input_tokens;
+            totalOutput += metrics.usage.output_tokens;
+            lastActivity = entry.timestamp;
+            break;
+
+          case "tool_use":
+          case "context":
+          case "checkpoint":
+            lastActivity = entry.timestamp;
+            break;
+        }
+      }
+    }
+
+    if (!metadata) {
+      return null;
+    }
+
+    return {
+      id: sessionId,
+      created: metadata.created,
+      updated: metadata.updated,
+      lastActivity,
+      model: metadata.model,
+      messageCount,
+      totalCost,
+      totalTokens: { input: totalInput, output: totalOutput },
+      firstMessage,
+      workingDirectory: metadata.workingDirectory,
+      metadata: {
+        agentName: metadata.agentName,
+        agentColor: metadata.agentColor,
+        teamName: metadata.teamName,
+      },
+    };
+  }
+
+  /**
+   * Filter sessions based on criteria
+   */
+  filterSessions(
+    sessions: SessionSummary[],
+    filter: SessionFilter
+  ): SessionSummary[] {
+    return sessions.filter((session) => {
+      // Filter by model
+      if (filter.model && session.model !== filter.model) {
+        return false;
+      }
+
+      // Filter by working directory
+      if (
+        filter.workingDirectory &&
+        session.workingDirectory !== filter.workingDirectory
+      ) {
+        return false;
+      }
+
+      // Filter by minimum messages
+      if (filter.minMessages && session.messageCount < filter.minMessages) {
+        return false;
+      }
+
+      // Filter by age (maxAge = maximum age in ms)
+      if (filter.maxAge) {
+        const age = Date.now() - session.created;
+        if (age > filter.maxAge) {
+          return false;
+        }
+      }
+
+      // Filter by timestamp (since = minimum created timestamp)
+      if (filter.since && session.created < filter.since) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Sort sessions by various criteria
+   */
+  sortSessions(
+    sessions: SessionSummary[],
+    sortBy: "created" | "updated" | "lastActivity" | "messageCount" | "cost" = "lastActivity",
+    order: "asc" | "desc" = "desc"
+  ): SessionSummary[] {
+    return [...sessions].sort((a, b) => {
+      let comparison = 0;
+
+      switch (sortBy) {
+        case "created":
+          comparison = a.created - b.created;
+          break;
+        case "updated":
+          comparison = a.updated - b.updated;
+          break;
+        case "lastActivity":
+          comparison = (a.lastActivity ?? a.updated) - (b.lastActivity ?? b.updated);
+          break;
+        case "messageCount":
+          comparison = a.messageCount - b.messageCount;
+          break;
+        case "cost":
+          comparison = a.totalCost - b.totalCost;
+          break;
+      }
+
+      return order === "desc" ? -comparison : comparison;
+    });
+  }
+
+  /**
+   * Find empty sessions (no messages)
+   */
+  findEmptySessions(sessions: SessionSummary[]): SessionSummary[] {
+    return sessions.filter((s) => s.messageCount === 0);
+  }
+
+  /**
+   * Find sessions by partial ID match
+   */
+  findById(sessions: SessionSummary[], partialId: string): SessionSummary | undefined {
+    return sessions.find((s) => s.id.startsWith(partialId) || s.id.includes(partialId));
+  }
+
+  /**
+   * Get unique models from sessions
+   */
+  getUniqueModels(sessions: SessionSummary[]): string[] {
+    const models = new Set(sessions.map((s) => s.model));
+    return [...models].sort();
+  }
+
+  /**
+   * Get unique working directories from sessions
+   */
+  getUniqueDirectories(sessions: SessionSummary[]): string[] {
+    const dirs = new Set(sessions.map((s) => s.workingDirectory));
+    return [...dirs].sort();
+  }
+
+  /**
+   * Calculate aggregate statistics
+   */
+  calculateStats(sessions: SessionSummary[]): {
+    totalSessions: number;
+    totalMessages: number;
+    totalCost: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    averageMessagesPerSession: number;
+    averageCostPerSession: number;
+  } {
+    const totalSessions = sessions.length;
+    const totalMessages = sessions.reduce((sum, s) => sum + s.messageCount, 0);
+    const totalCost = sessions.reduce((sum, s) => sum + s.totalCost, 0);
+    const totalInputTokens = sessions.reduce(
+      (sum, s) => sum + s.totalTokens.input,
+      0
+    );
+    const totalOutputTokens = sessions.reduce(
+      (sum, s) => sum + s.totalTokens.output,
+      0
+    );
+
+    return {
+      totalSessions,
+      totalMessages,
+      totalCost,
+      totalInputTokens,
+      totalOutputTokens,
+      averageMessagesPerSession: totalSessions > 0 ? totalMessages / totalSessions : 0,
+      averageCostPerSession: totalSessions > 0 ? totalCost / totalSessions : 0,
+    };
+  }
+}

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

@@ -0,0 +1,244 @@
+/**
+ * Session Persistence - File operations for session storage
+ * Handles JSONL file I/O with atomic writes and queue management
+ */
+
+import { homedir } from "os";
+import { join } from "path";
+import type {
+  SessionEntry,
+  SessionMetadata,
+  ISessionPersistence,
+} from "./types.js";
+
+export class SessionPersistence implements ISessionPersistence {
+  private sessionsDir: string;
+  private writeQueues: Map<string, Promise<void>> = new Map();
+
+  constructor(sessionsDir?: string) {
+    this.sessionsDir = sessionsDir ?? join(homedir(), ".claude", "sessions");
+  }
+
+  /**
+   * Get the sessions directory path
+   */
+  getSessionsDir(): string {
+    return this.sessionsDir;
+  }
+
+  /**
+   * Get the file path for a session
+   */
+  getSessionPath(sessionId: string): string {
+    return join(this.sessionsDir, `${sessionId}.jsonl`);
+  }
+
+  /**
+   * Initialize the sessions directory
+   */
+  async init(): Promise<void> {
+    try {
+      await Bun.write(join(this.sessionsDir, ".gitkeep"), "");
+    } catch {
+      // Directory might already exist
+    }
+  }
+
+  /**
+   * Check if a session file exists
+   */
+  async exists(sessionId: string): Promise<boolean> {
+    const file = Bun.file(this.getSessionPath(sessionId));
+    return file.exists();
+  }
+
+  /**
+   * Read all entries from a session file
+   */
+  async read(sessionId: string): Promise<SessionEntry[]> {
+    const sessionFile = this.getSessionPath(sessionId);
+
+    try {
+      const content = await Bun.file(sessionFile).text();
+      if (!content) {
+        return [];
+      }
+
+      const entries: SessionEntry[] = [];
+      const lines = content.trim().split("\n");
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          entries.push(JSON.parse(line) as SessionEntry);
+        } catch {
+          // Skip malformed lines
+        }
+      }
+
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Append an entry to a session file (queued for atomic writes)
+   */
+  async append(
+    sessionId: string,
+    entry: SessionEntry | SessionMetadata
+  ): Promise<void> {
+    const sessionFile = this.getSessionPath(sessionId);
+
+    // Queue writes per session to ensure order
+    const existingQueue = this.writeQueues.get(sessionId) || Promise.resolve();
+
+    const newQueue = existingQueue.then(async () => {
+      const line = JSON.stringify(entry) + "\n";
+      const file = Bun.file(sessionFile);
+      const existing = (await file.exists()) ? await file.text() : "";
+      await Bun.write(sessionFile, existing + line);
+    });
+
+    this.writeQueues.set(sessionId, newQueue);
+
+    try {
+      await newQueue;
+    } finally {
+      // Clean up completed queue
+      if (this.writeQueues.get(sessionId) === newQueue) {
+        this.writeQueues.delete(sessionId);
+      }
+    }
+  }
+
+  /**
+   * Write all entries to a session file (replaces existing)
+   */
+  async writeAll(sessionId: string, entries: SessionEntry[]): Promise<void> {
+    const sessionFile = this.getSessionPath(sessionId);
+    const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await Bun.write(sessionFile, content);
+  }
+
+  /**
+   * Delete a session file
+   */
+  async delete(sessionId: string): Promise<boolean> {
+    const sessionFile = this.getSessionPath(sessionId);
+
+    try {
+      const file = Bun.file(sessionFile);
+      if (await file.exists()) {
+        const { unlink } = await import("fs/promises");
+        await unlink(sessionFile);
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * List all session files in the directory
+   */
+  async listFiles(): Promise<string[]> {
+    await this.init();
+
+    try {
+      const glob = new Bun.Glob("*.jsonl");
+      const files = [...glob.scanSync(this.sessionsDir)];
+      return files.map((f) => f.replace(".jsonl", ""));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get file stats for a session
+   */
+  async getStats(sessionId: string): Promise<{
+    exists: boolean;
+    size: number;
+    mtime: Date | null;
+  }> {
+    const sessionFile = this.getSessionPath(sessionId);
+
+    try {
+      const file = Bun.file(sessionFile);
+      const stat = await file.stat();
+
+      return {
+        exists: true,
+        size: stat?.size ?? 0,
+        mtime: stat?.mtime ?? null,
+      };
+    } catch {
+      return { exists: false, size: 0, mtime: null };
+    }
+  }
+
+  /**
+   * Get modification times for multiple sessions
+   */
+  async getModificationTimes(sessionIds: string[]): Promise<Map<string, Date>> {
+    const times = new Map<string, Date>();
+
+    await Promise.all(
+      sessionIds.map(async (id) => {
+        const stats = await this.getStats(id);
+        if (stats.exists && stats.mtime) {
+          times.set(id, stats.mtime);
+        }
+      })
+    );
+
+    return times;
+  }
+
+  /**
+   * Read the first line (metadata) of a session file
+   */
+  async readMetadata(sessionId: string): Promise<SessionMetadata | null> {
+    const entries = await this.read(sessionId);
+
+    for (const entry of entries) {
+      // Metadata has explicit type field now
+      if ("type" in entry && entry.type === "metadata") {
+        return entry as SessionMetadata;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Read the last N entries from a session file
+   */
+  async readLast(sessionId: string, count: number): Promise<SessionEntry[]> {
+    const entries = await this.read(sessionId);
+    return entries.slice(-count);
+  }
+
+  /**
+   * Count entries in a session file
+   */
+  async countEntries(sessionId: string): Promise<number> {
+    const entries = await this.read(sessionId);
+    return entries.length;
+  }
+}
+
+// Singleton instance for convenience
+let defaultPersistence: SessionPersistence | null = null;
+
+export function getSessionPersistence(
+  sessionsDir?: string
+): SessionPersistence {
+  if (!defaultPersistence) {
+    defaultPersistence = new SessionPersistence(sessionsDir);
+  }
+  return defaultPersistence;
+}

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

@@ -0,0 +1,169 @@
+/**
+ * Session Types - All type definitions for session handling
+ */
+
+import type { Message, QueryMetrics } from "../../types/index.js";
+
+// ============================================
+// SESSION METADATA
+// ============================================
+
+export interface SessionMetadata {
+  type: "metadata";
+  id: string;
+  created: number;
+  updated: number;
+  model: string;
+  workingDirectory: string;
+  agentName?: string;
+  agentColor?: string;
+  teamName?: string;
+  totalCost?: number;
+  totalTokens?: { input: number; output: number };
+}
+
+// ============================================
+// SESSION ENTRIES (JSONL lines)
+// ============================================
+
+export interface SessionMessage {
+  type: "message";
+  timestamp: number;
+  data: Message;
+}
+
+export interface SessionToolUse {
+  type: "tool_use";
+  timestamp: number;
+  toolId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+}
+
+export interface SessionMetrics {
+  type: "metrics";
+  timestamp: number;
+  data: QueryMetrics;
+}
+
+export interface SessionContext {
+  type: "context";
+  timestamp: number;
+  workingDirectory: string;
+  gitBranch?: string;
+  systemPrompt?: string;
+}
+
+export interface SessionCheckpoint {
+  type: "checkpoint";
+  timestamp: number;
+  checkpointId: string;
+  label?: string;
+  messageCount: number;
+}
+
+export type SessionEntry =
+  | SessionMetadata
+  | SessionMessage
+  | SessionToolUse
+  | SessionMetrics
+  | SessionContext
+  | SessionCheckpoint;
+
+// ============================================
+// LOADED SESSION
+// ============================================
+
+export interface LoadedSession {
+  metadata: SessionMetadata;
+  messages: Message[];
+  tools: SessionToolUse[];
+  metrics: QueryMetrics[];
+  context: SessionContext | null;
+  checkpoints: SessionCheckpoint[];
+}
+
+// ============================================
+// SESSION SUMMARY (for listing)
+// ============================================
+
+export interface SessionSummary {
+  id: string;
+  created: number;
+  updated: number;
+  lastActivity?: number;
+  model: string;
+  messageCount: number;
+  totalCost: number;
+  totalTokens: { input: number; output: number };
+  firstMessage?: string;
+  workingDirectory: string;
+  metadata?: Record<string, unknown>;
+  // Additional fields for TUI compatibility
+  agentName?: string;
+  agentColor?: string;
+  teamName?: string;
+}
+
+// ============================================
+// SESSION FILTERS
+// ============================================
+
+export interface SessionFilter {
+  model?: string;
+  workingDirectory?: string;
+  minMessages?: number;
+  maxAge?: number; // milliseconds
+  since?: number; // timestamp
+}
+
+// ============================================
+// SESSION EVENTS
+// ============================================
+
+export type SessionEventType =
+  | "created"
+  | "resumed"
+  | "message_saved"
+  | "metrics_saved"
+  | "checkpoint_created"
+  | "deleted";
+
+export interface SessionEvent {
+  type: SessionEventType;
+  sessionId: string;
+  timestamp: number;
+  data?: unknown;
+}
+
+export type SessionEventHandler = (event: SessionEvent) => void | Promise<void>;
+
+// ============================================
+// PERSISTENCE INTERFACE
+// ============================================
+
+export interface ISessionPersistence {
+  init(): Promise<void>;
+  read(sessionId: string): Promise<SessionEntry[]>;
+  append(sessionId: string, entry: SessionEntry | SessionMetadata): Promise<void>;
+  delete(sessionId: string): Promise<boolean>;
+  exists(sessionId: string): Promise<boolean>;
+  listFiles(): Promise<string[]>;
+}
+
+// ============================================
+// EXPORT INTERFACE
+// ============================================
+
+export type ExportFormat = "jsonl" | "json" | "markdown";
+
+export interface ISessionExporter {
+  export(session: LoadedSession, format: ExportFormat): string;
+  exportToFile(
+    sessionId: string,
+    format: ExportFormat,
+    outputPath?: string
+  ): Promise<string>;
+}