byterover-cli 0.4.1 → 1.0.0

package/dist/infra/cipher/session/session-status.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Session Status Manager
+ *
+ * Manages ephemeral session lifecycle states following the OpenCode pattern.
+ * Tracks whether sessions are idle, busy, retrying, or waiting for permission.
+ *
+ * This is in-memory state only - does not persist across restarts.
+ * Status changes are published via the event bus for UI consumption.
+ */
+import type { SessionStatusType } from '../../../core/domain/cipher/agent-events/types.js';
+import type { SessionEventBus } from '../events/event-emitter.js';
+/**
+ * Session Status Manager.
+ *
+ * Provides centralized tracking of session lifecycle states.
+ * Each session can be in one of four states:
+ * - idle: Ready to accept new messages
+ * - busy: Currently executing a request
+ * - retry: Waiting to retry after a transient error
+ * - waiting_permission: Waiting for user permission (e.g., tool confirmation)
+ *
+ * @example
+ * ```typescript
+ * const statusManager = new SessionStatusManager()
+ *
+ * // Get current status
+ * const status = statusManager.get('session-123')
+ * if (status.type === 'idle') {
+ *   // Session is ready
+ * }
+ *
+ * // Update status
+ * statusManager.set('session-123', { type: 'busy' }, eventBus)
+ *
+ * // Clear status when session is disposed
+ * statusManager.remove('session-123')
+ * ```
+ */
+export declare class SessionStatusManager {
+    private readonly status;
+    /**
+     * Get the current status of a session.
+     * Returns 'idle' if no status has been set.
+     *
+     * @param sessionId - The session ID to get status for
+     * @returns Current session status
+     */
+    get(sessionId: string): SessionStatusType;
+    /**
+     * Get all session statuses.
+     * Useful for debugging or admin interfaces.
+     *
+     * @returns Map of session IDs to their statuses
+     */
+    getAll(): ReadonlyMap<string, SessionStatusType>;
+    /**
+     * Check if a session is busy (executing or retrying).
+     *
+     * @param sessionId - The session ID to check
+     * @returns True if the session is busy or retrying
+     */
+    isBusy(sessionId: string): boolean;
+    /**
+     * Check if a session is idle and ready for new messages.
+     *
+     * @param sessionId - The session ID to check
+     * @returns True if the session is idle
+     */
+    isIdle(sessionId: string): boolean;
+    /**
+     * Remove a session's status.
+     * Call this when a session is disposed.
+     *
+     * @param sessionId - The session ID to remove
+     */
+    remove(sessionId: string): void;
+    /**
+     * Set the status of a session and emit a status change event.
+     *
+     * @param sessionId - The session ID to update
+     * @param newStatus - The new status to set
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    set(sessionId: string, newStatus: SessionStatusType, eventBus?: SessionEventBus): void;
+    /**
+     * Transition a session to busy state.
+     * Convenience method for the common case.
+     *
+     * @param sessionId - The session ID to update
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setBusy(sessionId: string, eventBus?: SessionEventBus): void;
+    /**
+     * Transition a session to idle state.
+     * Convenience method for the common case.
+     *
+     * @param sessionId - The session ID to update
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setIdle(sessionId: string, eventBus?: SessionEventBus): void;
+    /**
+     * Transition a session to retry state.
+     *
+     * @param sessionId - The session ID to update
+     * @param options - Retry options
+     * @param options.attempt - Current retry attempt number
+     * @param options.message - Human-readable retry message
+     * @param options.nextRetryAt - Timestamp when next retry will occur
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setRetry(sessionId: string, options: {
+        attempt: number;
+        message: string;
+        nextRetryAt: number;
+    }, eventBus?: SessionEventBus): void;
+    /**
+     * Transition a session to waiting_permission state.
+     *
+     * @param sessionId - The session ID to update
+     * @param toolName - Name of the tool waiting for permission
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setWaitingPermission(sessionId: string, toolName: string, eventBus?: SessionEventBus): void;
+    /**
+     * Compare two session statuses for equality.
+     *
+     * @param a - First status (may be undefined)
+     * @param b - Second status
+     * @returns True if statuses are equal
+     */
+    private statusEquals;
+}
+/**
+ * Singleton instance of the session status manager.
+ * Use this for global session status tracking.
+ */
+export declare const sessionStatusManager: SessionStatusManager;

package/dist/infra/cipher/session/session-status.js

@@ -0,0 +1,184 @@
+/**
+ * Session Status Manager
+ *
+ * Manages ephemeral session lifecycle states following the OpenCode pattern.
+ * Tracks whether sessions are idle, busy, retrying, or waiting for permission.
+ *
+ * This is in-memory state only - does not persist across restarts.
+ * Status changes are published via the event bus for UI consumption.
+ */
+/**
+ * Session Status Manager.
+ *
+ * Provides centralized tracking of session lifecycle states.
+ * Each session can be in one of four states:
+ * - idle: Ready to accept new messages
+ * - busy: Currently executing a request
+ * - retry: Waiting to retry after a transient error
+ * - waiting_permission: Waiting for user permission (e.g., tool confirmation)
+ *
+ * @example
+ * ```typescript
+ * const statusManager = new SessionStatusManager()
+ *
+ * // Get current status
+ * const status = statusManager.get('session-123')
+ * if (status.type === 'idle') {
+ *   // Session is ready
+ * }
+ *
+ * // Update status
+ * statusManager.set('session-123', { type: 'busy' }, eventBus)
+ *
+ * // Clear status when session is disposed
+ * statusManager.remove('session-123')
+ * ```
+ */
+export class SessionStatusManager {
+    status = new Map();
+    /**
+     * Get the current status of a session.
+     * Returns 'idle' if no status has been set.
+     *
+     * @param sessionId - The session ID to get status for
+     * @returns Current session status
+     */
+    get(sessionId) {
+        return this.status.get(sessionId) ?? { type: 'idle' };
+    }
+    /**
+     * Get all session statuses.
+     * Useful for debugging or admin interfaces.
+     *
+     * @returns Map of session IDs to their statuses
+     */
+    getAll() {
+        return this.status;
+    }
+    /**
+     * Check if a session is busy (executing or retrying).
+     *
+     * @param sessionId - The session ID to check
+     * @returns True if the session is busy or retrying
+     */
+    isBusy(sessionId) {
+        const status = this.get(sessionId);
+        return status.type === 'busy' || status.type === 'retry';
+    }
+    /**
+     * Check if a session is idle and ready for new messages.
+     *
+     * @param sessionId - The session ID to check
+     * @returns True if the session is idle
+     */
+    isIdle(sessionId) {
+        return this.get(sessionId).type === 'idle';
+    }
+    /**
+     * Remove a session's status.
+     * Call this when a session is disposed.
+     *
+     * @param sessionId - The session ID to remove
+     */
+    remove(sessionId) {
+        this.status.delete(sessionId);
+    }
+    /**
+     * Set the status of a session and emit a status change event.
+     *
+     * @param sessionId - The session ID to update
+     * @param newStatus - The new status to set
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    set(sessionId, newStatus, eventBus) {
+        const oldStatus = this.status.get(sessionId);
+        // Only update and emit if status actually changed
+        if (!this.statusEquals(oldStatus, newStatus)) {
+            this.status.set(sessionId, newStatus);
+            // Emit status change event if event bus provided
+            if (eventBus) {
+                eventBus.emit('session:statusChanged', {
+                    status: newStatus,
+                });
+            }
+        }
+    }
+    /**
+     * Transition a session to busy state.
+     * Convenience method for the common case.
+     *
+     * @param sessionId - The session ID to update
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setBusy(sessionId, eventBus) {
+        this.set(sessionId, { type: 'busy' }, eventBus);
+    }
+    /**
+     * Transition a session to idle state.
+     * Convenience method for the common case.
+     *
+     * @param sessionId - The session ID to update
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setIdle(sessionId, eventBus) {
+        this.set(sessionId, { type: 'idle' }, eventBus);
+    }
+    /**
+     * Transition a session to retry state.
+     *
+     * @param sessionId - The session ID to update
+     * @param options - Retry options
+     * @param options.attempt - Current retry attempt number
+     * @param options.message - Human-readable retry message
+     * @param options.nextRetryAt - Timestamp when next retry will occur
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setRetry(sessionId, options, eventBus) {
+        this.set(sessionId, { attempt: options.attempt, message: options.message, nextRetryAt: options.nextRetryAt, type: 'retry' }, eventBus);
+    }
+    /**
+     * Transition a session to waiting_permission state.
+     *
+     * @param sessionId - The session ID to update
+     * @param toolName - Name of the tool waiting for permission
+     * @param eventBus - Optional event bus to emit status change event
+     */
+    setWaitingPermission(sessionId, toolName, eventBus) {
+        this.set(sessionId, { toolName, type: 'waiting_permission' }, eventBus);
+    }
+    /**
+     * Compare two session statuses for equality.
+     *
+     * @param a - First status (may be undefined)
+     * @param b - Second status
+     * @returns True if statuses are equal
+     */
+    statusEquals(a, b) {
+        if (!a)
+            return false;
+        if (a.type !== b.type)
+            return false;
+        switch (a.type) {
+            case 'busy': {
+                return true;
+            }
+            case 'idle': {
+                return true;
+            }
+            case 'retry': {
+                return (b.type === 'retry' && a.attempt === b.attempt && a.message === b.message && a.nextRetryAt === b.nextRetryAt);
+            }
+            case 'waiting_permission': {
+                return b.type === 'waiting_permission' && a.toolName === b.toolName;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+}
+/**
+ * Singleton instance of the session status manager.
+ * Use this for global session status tracking.
+ */
+export const sessionStatusManager = new SessionStatusManager();

package/dist/infra/cipher/session/title-generator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate a session title from the first user message.
+ * Uses heuristic extraction (no LLM call to avoid latency).
+ *
+ * @param firstMessage - The first user message in the conversation
+ * @returns A concise title for the session
+ */
+export declare function generateSessionTitle(firstMessage: string): string;

package/dist/infra/cipher/session/title-generator.js

@@ -0,0 +1,31 @@
+/**
+ * Generate a session title from the first user message.
+ * Uses heuristic extraction (no LLM call to avoid latency).
+ *
+ * @param firstMessage - The first user message in the conversation
+ * @returns A concise title for the session
+ */
+export function generateSessionTitle(firstMessage) {
+    // Remove markdown, code blocks, etc.
+    const cleaned = firstMessage
+        .replaceAll(/```[\s\S]*?```/g, '') // Remove code blocks
+        .replaceAll(/`[^`]+`/g, '') // Remove inline code
+        .replaceAll(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Extract link text
+        .replaceAll(/[#*_~]/g, '') // Remove markdown formatting chars
+        .trim();
+    // If nothing left after cleaning, use a generic title
+    if (!cleaned) {
+        return 'New conversation';
+    }
+    // Extract first sentence or meaningful chunk
+    const firstSentence = cleaned.split(/[.!?\n]/)[0]?.trim() || cleaned;
+    // Truncate to reasonable length
+    const maxLength = 50;
+    if (firstSentence.length <= maxLength) {
+        return firstSentence;
+    }
+    // Truncate at word boundary
+    const truncated = firstSentence.slice(0, maxLength);
+    const lastSpace = truncated.lastIndexOf(' ');
+    return (lastSpace > 20 ? truncated.slice(0, lastSpace) : truncated) + '...';
+}

package/dist/infra/cipher/storage/message-storage-service.d.ts

@@ -1,6 +1,21 @@
-import type { CompactionResult, LoadMessagesResult, PruneToolOutputsOptions, SessionRecord, StoredMessage, StoredMessageWithParts, StreamMessagesOptions } from '../../../core/domain/cipher/storage/message-storage-types.js';
+import type { CompactionResult, LoadMessagesResult, PruneToolOutputsOptions, SessionRecord, StoredMessage, StoredMessageWithParts, StoredPart, StoredToolState, StreamMessagesOptions } from '../../../core/domain/cipher/storage/message-storage-types.js';
 import type { IKeyStorage } from '../../../core/interfaces/cipher/i-key-storage.js';
-import type { InternalMessage } from '../../../core/interfaces/cipher/message-types.js';
+import type { AttachmentPart, InternalMessage } from '../../../core/interfaces/cipher/message-types.js';
+/**
+ * Options for creating a tool part.
+ */
+export interface CreateToolPartOptions {
+    /** Unique identifier for this tool call */
+    callId: string;
+    /** Parsed input arguments */
+    input: Record<string, unknown>;
+    /** ID of the message to add the tool part to */
+    messageId: string;
+    /** Session ID for validation */
+    sessionId: string;
+    /** Name of the tool being called */
+    toolName: string;
+}
 /**
  * Service for granular message and part storage.
  *
@@ -18,6 +33,21 @@ import type { InternalMessage } from '../../../core/interfaces/cipher/message-ty
 export declare class MessageStorageService {
     private readonly keyStorage;
     constructor(keyStorage: IKeyStorage);
+    /**
+     * Add attachments to a completed tool part.
+     *
+     * @param messageId - ID of the message containing the part
+     * @param partId - ID of the tool part
+     * @param attachments - Attachments to add
+     */
+    addToolPartAttachments(messageId: string, partId: string, attachments: AttachmentPart[]): Promise<void>;
+    /**
+     * Create a tool part in pending state and add it to a message.
+     *
+     * @param options - Options for creating the tool part
+     * @returns The created StoredPart
+     */
+    createToolPart(options: CreateToolPartOptions): Promise<StoredPart>;
     /**
      * Delete a session and all its messages and parts.
      */
@@ -26,6 +56,14 @@ export declare class MessageStorageService {
      * Get the session record, if it exists.
      */
     getSession(sessionId: string): Promise<SessionRecord | undefined>;
+    /**
+     * Get a tool part by call ID from a message.
+     *
+     * @param messageId - ID of the message
+     * @param callId - Call ID of the tool part
+     * @returns The tool part if found
+     */
+    getToolPartByCallId(messageId: string, callId: string): Promise<StoredPart | undefined>;
     /**
      * Check if a session exists in granular format.
      */
@@ -49,6 +87,9 @@ export declare class MessageStorageService {
     /**
      * Prune old tool outputs by marking them as compacted.
      * Keeps the most recent tool outputs up to the specified token limit.
+     *
+     * Turn-based protection: Protects tool outputs in the most recent N user turns.
+     * Minimum threshold: Only executes if the minimum token threshold can be saved.
      */
     pruneToolOutputs(options: PruneToolOutputsOptions): Promise<CompactionResult>;
     /**
@@ -80,6 +121,20 @@ export declare class MessageStorageService {
      * Convert loaded messages back to InternalMessage format.
      */
     toInternalMessages(messages: StoredMessageWithParts[]): InternalMessage[];
+    /**
+     * Update a tool part's state.
+     * Used for transitioning through pending → running → completed/error.
+     *
+     * @param messageId - ID of the message containing the part
+     * @param partId - ID of the tool part to update
+     * @param update - Partial tool state update
+     */
+    updateToolPartState(messageId: string, partId: string, update: Partial<StoredToolState>): Promise<void>;
+    /**
+     * Convert a StoredPart to a MessagePart for reconstruction.
+     * Returns the converted part and optionally tool output content.
+     */
+    private convertStoredPartToMessagePart;
     /**
      * Extract parts from an InternalMessage.
      */
@@ -101,6 +156,14 @@ export declare class MessageStorageService {
      */
     private serializeImageContent;
     private sessionKey;
+    /**
+     * Convert a stored part with tool state to a ToolPart.
+     */
+    private storedPartToToolPart;
+    /**
+     * Convert a ToolPart to a StoredPart.
+     */
+    private toolPartToStoredPart;
 }
 /**
  * Factory function to create MessageStorageService.