@ebowwa/coder 0.2.1 → 0.7.64

package/dist/core/sessions/metadata.js

@@ -0,0 +1,233 @@
+/**
+ * Session Metadata - Manage session metadata and summaries
+ */
+import { SessionPersistence } from "./persistence.js";
+export class SessionMetadataManager {
+    persistence;
+    constructor(persistence) {
+        this.persistence = persistence;
+    }
+    /**
+     * Generate a new session ID
+     */
+    generateId() {
+        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) {
+        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) {
+        return {
+            ...metadata,
+            updated: Date.now(),
+        };
+    }
+    /**
+     * Merge updated fields into metadata
+     */
+    merge(metadata, updates) {
+        return {
+            ...metadata,
+            ...updates,
+            updated: Date.now(),
+        };
+    }
+    /**
+     * Get summary from session entries
+     */
+    async getSummary(sessionId) {
+        const entries = await this.persistence.read(sessionId);
+        return this.entriesToSummary(sessionId, entries);
+    }
+    /**
+     * Convert entries to summary
+     */
+    entriesToSummary(sessionId, entries) {
+        let metadata = null;
+        let messageCount = 0;
+        let totalCost = 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let firstMessage;
+        let lastActivity;
+        for (const entry of entries) {
+            // All entries have a type field now
+            if ("type" in entry) {
+                switch (entry.type) {
+                    case "metadata":
+                        metadata = entry;
+                        break;
+                    case "message":
+                        messageCount++;
+                        lastActivity = entry.timestamp;
+                        const msg = entry.data;
+                        if (!firstMessage && msg.role === "user") {
+                            const textBlock = msg.content.find((b) => 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.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, filter) {
+        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, sortBy = "lastActivity", order = "desc") {
+        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) {
+        return sessions.filter((s) => s.messageCount === 0);
+    }
+    /**
+     * Find sessions by partial ID match
+     */
+    findById(sessions, partialId) {
+        return sessions.find((s) => s.id.startsWith(partialId) || s.id.includes(partialId));
+    }
+    /**
+     * Get unique models from sessions
+     */
+    getUniqueModels(sessions) {
+        const models = new Set(sessions.map((s) => s.model));
+        return [...models].sort();
+    }
+    /**
+     * Get unique working directories from sessions
+     */
+    getUniqueDirectories(sessions) {
+        const dirs = new Set(sessions.map((s) => s.workingDirectory));
+        return [...dirs].sort();
+    }
+    /**
+     * Calculate aggregate statistics
+     */
+    calculateStats(sessions) {
+        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/dist/core/sessions/persistence.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Session Persistence - File operations for session storage
+ * Handles JSONL file I/O with atomic writes and queue management
+ */
+import type { SessionEntry, SessionMetadata, ISessionPersistence } from "./types.js";
+export declare class SessionPersistence implements ISessionPersistence {
+    private sessionsDir;
+    private writeQueues;
+    constructor(sessionsDir?: string);
+    /**
+     * Get the sessions directory path
+     */
+    getSessionsDir(): string;
+    /**
+     * Get the file path for a session
+     */
+    getSessionPath(sessionId: string): string;
+    /**
+     * Initialize the sessions directory
+     */
+    init(): Promise<void>;
+    /**
+     * Check if a session file exists
+     */
+    exists(sessionId: string): Promise<boolean>;
+    /**
+     * Read all entries from a session file
+     */
+    read(sessionId: string): Promise<SessionEntry[]>;
+    /**
+     * Append an entry to a session file (queued for atomic writes)
+     */
+    append(sessionId: string, entry: SessionEntry | SessionMetadata): Promise<void>;
+    /**
+     * Write all entries to a session file (replaces existing)
+     */
+    writeAll(sessionId: string, entries: SessionEntry[]): Promise<void>;
+    /**
+     * Delete a session file
+     */
+    delete(sessionId: string): Promise<boolean>;
+    /**
+     * List all session files in the directory
+     */
+    listFiles(): Promise<string[]>;
+    /**
+     * Get file stats for a session
+     */
+    getStats(sessionId: string): Promise<{
+        exists: boolean;
+        size: number;
+        mtime: Date | null;
+    }>;
+    /**
+     * Get modification times for multiple sessions
+     */
+    getModificationTimes(sessionIds: string[]): Promise<Map<string, Date>>;
+    /**
+     * Read the first line (metadata) of a session file
+     */
+    readMetadata(sessionId: string): Promise<SessionMetadata | null>;
+    /**
+     * Read the last N entries from a session file
+     */
+    readLast(sessionId: string, count: number): Promise<SessionEntry[]>;
+    /**
+     * Count entries in a session file
+     */
+    countEntries(sessionId: string): Promise<number>;
+}
+export declare function getSessionPersistence(sessionsDir?: string): SessionPersistence;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/core/sessions/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../packages/src/core/sessions/persistence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB,qBAAa,kBAAmB,YAAW,mBAAmB;IAC5D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAAyC;gBAEhD,WAAW,CAAC,EAAE,MAAM;IAIhC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIzC;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKjD;;OAEG;IACG,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IA2BtD;;OAEG;IACG,MAAM,CACV,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,GAAG,eAAe,GACpC,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzE;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBjD;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAYpC;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QACzC,MAAM,EAAE,OAAO,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,IAAI,GAAG,IAAI,CAAC;KACpB,CAAC;IAiBF;;OAEG;IACG,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAe5E;;OAEG;IACG,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAatE;;OAEG;IACG,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAKzE;;OAEG;IACG,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAIvD;AAKD,wBAAgB,qBAAqB,CACnC,WAAW,CAAC,EAAE,MAAM,GACnB,kBAAkB,CAKpB"}

package/dist/core/sessions/persistence.js

@@ -0,0 +1,201 @@
+/**
+ * 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";
+export class SessionPersistence {
+    sessionsDir;
+    writeQueues = new Map();
+    constructor(sessionsDir) {
+        this.sessionsDir = sessionsDir ?? join(homedir(), ".claude", "sessions");
+    }
+    /**
+     * Get the sessions directory path
+     */
+    getSessionsDir() {
+        return this.sessionsDir;
+    }
+    /**
+     * Get the file path for a session
+     */
+    getSessionPath(sessionId) {
+        return join(this.sessionsDir, `${sessionId}.jsonl`);
+    }
+    /**
+     * Initialize the sessions directory
+     */
+    async init() {
+        try {
+            await Bun.write(join(this.sessionsDir, ".gitkeep"), "");
+        }
+        catch {
+            // Directory might already exist
+        }
+    }
+    /**
+     * Check if a session file exists
+     */
+    async exists(sessionId) {
+        const file = Bun.file(this.getSessionPath(sessionId));
+        return file.exists();
+    }
+    /**
+     * Read all entries from a session file
+     */
+    async read(sessionId) {
+        const sessionFile = this.getSessionPath(sessionId);
+        try {
+            const content = await Bun.file(sessionFile).text();
+            if (!content) {
+                return [];
+            }
+            const entries = [];
+            const lines = content.trim().split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Append an entry to a session file (queued for atomic writes)
+     */
+    async append(sessionId, entry) {
+        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, entries) {
+        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) {
+        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() {
+        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) {
+        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) {
+        const times = new Map();
+        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) {
+        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;
+            }
+        }
+        return null;
+    }
+    /**
+     * Read the last N entries from a session file
+     */
+    async readLast(sessionId, count) {
+        const entries = await this.read(sessionId);
+        return entries.slice(-count);
+    }
+    /**
+     * Count entries in a session file
+     */
+    async countEntries(sessionId) {
+        const entries = await this.read(sessionId);
+        return entries.length;
+    }
+}
+// Singleton instance for convenience
+let defaultPersistence = null;
+export function getSessionPersistence(sessionsDir) {
+    if (!defaultPersistence) {
+        defaultPersistence = new SessionPersistence(sessionsDir);
+    }
+    return defaultPersistence;
+}

package/dist/core/sessions/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Session Types - All type definitions for session handling
+ */
+import type { Message, QueryMetrics } from "../../types/index.js";
+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;
+    };
+}
+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;
+export interface LoadedSession {
+    metadata: SessionMetadata;
+    messages: Message[];
+    tools: SessionToolUse[];
+    metrics: QueryMetrics[];
+    context: SessionContext | null;
+    checkpoints: SessionCheckpoint[];
+}
+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>;
+    agentName?: string;
+    agentColor?: string;
+    teamName?: string;
+}
+export interface SessionFilter {
+    model?: string;
+    workingDirectory?: string;
+    minMessages?: number;
+    maxAge?: number;
+    since?: number;
+}
+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>;
+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 type ExportFormat = "jsonl" | "json" | "markdown";
+export interface ISessionExporter {
+    export(session: LoadedSession, format: ExportFormat): string;
+    exportToFile(sessionId: string, format: ExportFormat, outputPath?: string): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/sessions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../packages/src/core/sessions/types.ts"],"names":[],"mappings":"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"}

package/dist/core/sessions/types.js

@@ -0,0 +1,4 @@
+/**
+ * Session Types - All type definitions for session handling
+ */
+export {};

package/dist/core/stream-highlighter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Streaming text highlighter for code blocks and diffs
+ * Buffers text and highlights as content completes during streaming output
+ */
+/**
+ * Creates a streaming highlighter that detects and highlights code blocks
+ * and diffs as they complete during streaming output.
+ */
+export declare function createStreamHighlighter(): {
+    process: (text: string) => string;
+    flush: () => string;
+};
+/**
+ * Highlight complete text with code blocks
+ * Used for non-streaming contexts or final output
+ */
+export declare function highlightTextWithCodeBlocks(text: string): string;
+//# sourceMappingURL=stream-highlighter.d.ts.map

package/dist/core/stream-highlighter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-highlighter.d.ts","sourceRoot":"","sources":["../../packages/src/core/stream-highlighter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA02BH;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,KAAK,EAAE,MAAM,MAAM,CAAC;CACrB,CAiLA;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAuDhE"}