byterover-cli 1.6.0 → 1.7.0

package/dist/infra/cipher/file-system/pdf-extractor.js

@@ -1,226 +0,0 @@
-import { getDocumentProxy, getMeta } from 'unpdf';
-import { PdfExtractionError } from '../../../core/domain/cipher/errors/file-system-error.js';
-/**
- * PDF magic bytes: %PDF-
- */
-const PDF_MAGIC_BYTES = [0x25, 0x50, 0x44, 0x46, 0x2d];
-/**
- * Default number of pages to extract when no limit specified.
- */
-const DEFAULT_PAGE_LIMIT = 100;
-/**
- * Maximum number of pages allowed per extraction.
- */
-const MAX_PAGE_LIMIT = 200;
-/**
- * PDF text extraction and metadata extraction utility.
- * Provides page-by-page extraction with pagination support.
- *
- * Features:
- * - Magic byte validation
- * - Fast metadata-only extraction
- * - Page-by-page text extraction with offset/limit
- * - Default: 100 pages, max: 200 pages per extraction
- */
-export class PdfExtractor {
-    /**
-     * Extracts metadata from a PDF buffer without extracting text.
-     * This is a fast path when you only need page count, title, author, etc.
-     *
-     * @param buffer - PDF file buffer
-     * @param filePath - Path to the PDF file (for error messages)
-     * @returns PDF metadata
-     */
-    static async extractMetadata(buffer, filePath) {
-        try {
-            const pdf = await getDocumentProxy(new Uint8Array(buffer));
-            const meta = await getMeta(pdf);
-            return PdfExtractor.buildMetadataFromInfo(pdf.numPages, meta.info);
-        }
-        catch (error) {
-            throw PdfExtractor.wrapExtractionError(error, filePath);
-        }
-    }
-    /**
-     * Extracts text from a PDF buffer with pagination support.
-     *
-     * @param buffer - PDF file buffer
-     * @param filePath - Path to the PDF file (for error messages)
-     * @param options - Extraction options (offset, limit)
-     * @returns Extraction result with pages, metadata, and continuation info
-     */
-    static async extractText(buffer, filePath, options = {}) {
-        // Validate PDF magic bytes
-        if (!PdfExtractor.isValidPdf(buffer)) {
-            throw new PdfExtractionError(filePath, 'Invalid PDF file format (missing PDF header)');
-        }
-        try {
-            const pdf = await getDocumentProxy(new Uint8Array(buffer));
-            const meta = await getMeta(pdf);
-            const totalPages = pdf.numPages;
-            const metaInfo = meta.info;
-            // Calculate pagination
-            const offset = Math.max(1, options.offset ?? 1);
-            const limit = Math.min(options.limit ?? DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT);
-            // Return empty result if offset is beyond total pages
-            if (offset > totalPages) {
-                return {
-                    hasMore: false,
-                    metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
-                    pages: [],
-                };
-            }
-            // Calculate page range
-            const endPage = Math.min(offset + limit - 1, totalPages);
-            // Extract text only from requested pages using PDF.js page-level API
-            const pages = await PdfExtractor.extractPagesFromDocument(pdf, offset, endPage);
-            return {
-                hasMore: endPage < totalPages,
-                metadata: PdfExtractor.buildMetadataFromInfo(totalPages, metaInfo),
-                pages,
-            };
-        }
-        catch (error) {
-            throw PdfExtractor.wrapExtractionError(error, filePath);
-        }
-    }
-    /**
-     * Checks if a buffer contains valid PDF magic bytes.
-     * @param buffer - Buffer to check
-     * @returns true if buffer starts with %PDF-
-     */
-    static isValidPdf(buffer) {
-        if (buffer.length < PDF_MAGIC_BYTES.length) {
-            return false;
-        }
-        for (const [index, byte] of PDF_MAGIC_BYTES.entries()) {
-            if (buffer[index] !== byte) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Builds PdfMetadata from unpdf meta info object.
-     * @param pageCount - Total number of pages
-     * @param info - Optional info object from unpdf getMeta
-     * @returns PdfMetadata object
-     */
-    static buildMetadataFromInfo(pageCount, info) {
-        const metadata = { pageCount };
-        if (!info) {
-            return metadata;
-        }
-        if (typeof info.Title === 'string' && info.Title.trim()) {
-            metadata.title = info.Title.trim();
-        }
-        if (typeof info.Author === 'string' && info.Author.trim()) {
-            metadata.author = info.Author.trim();
-        }
-        if (info.CreationDate) {
-            const parsed = PdfExtractor.parsePdfDate(info.CreationDate);
-            if (parsed) {
-                metadata.creationDate = parsed;
-            }
-        }
-        return metadata;
-    }
-    /**
-     * Extracts text from specific pages of a PDF document.
-     * Uses PDF.js page-level API for efficient extraction of page ranges.
-     *
-     * @param pdf - PDF document proxy from unpdf
-     * @param startPage - Starting page number (1-based)
-     * @param endPage - Ending page number (1-based, inclusive)
-     * @returns Array of PdfPageContent with extracted text
-     */
-    static async extractPagesFromDocument(pdf, startPage, endPage) {
-        // Build array of page numbers to extract
-        const pageNumbers = [];
-        for (let pageNum = startPage; pageNum <= endPage; pageNum++) {
-            pageNumbers.push(pageNum);
-        }
-        // Extract all requested pages in parallel
-        const pages = await Promise.all(pageNumbers.map(async (pageNum) => {
-            const page = await pdf.getPage(pageNum);
-            const textContent = await page.getTextContent();
-            // Extract text from text items, handling EOL markers
-            // TextContent.items contains TextItem and TextMarkedContent - we only want TextItem (has 'str')
-            const text = textContent.items
-                .filter((item) => typeof item === 'object' && item !== null && 'str' in item)
-                .map((item) => item.str + (item.hasEOL ? '\n' : ''))
-                .join('');
-            return {
-                pageNumber: pageNum,
-                text: text.trim(),
-            };
-        }));
-        return pages;
-    }
-    /**
-     * Extracts a meaningful error message from an unknown error.
-     */
-    static getExtractionErrorMessage(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === 'string') {
-            return error;
-        }
-        return 'Unknown PDF extraction error';
-    }
-    /**
-     * Parses PDF date string format (D:YYYYMMDDHHmmSS) to Date object.
-     * @param dateStr - PDF date string
-     * @returns Parsed Date or undefined if invalid
-     */
-    static parsePdfDate(dateStr) {
-        if (!dateStr) {
-            return undefined;
-        }
-        // PDF date format: D:YYYYMMDDHHmmSS+HH'mm' or variations
-        const match = dateStr.match(/D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?/);
-        if (!match) {
-            return undefined;
-        }
-        const year = Number.parseInt(match[1], 10);
-        const month = match[2] ? Number.parseInt(match[2], 10) - 1 : 0;
-        const day = match[3] ? Number.parseInt(match[3], 10) : 1;
-        const hour = match[4] ? Number.parseInt(match[4], 10) : 0;
-        const minute = match[5] ? Number.parseInt(match[5], 10) : 0;
-        const second = match[6] ? Number.parseInt(match[6], 10) : 0;
-        return new Date(year, month, day, hour, minute, second);
-    }
-    /**
-     * Wraps extraction errors with appropriate PdfExtractionError.
-     * @param error - The caught error
-     * @param filePath - Path to the PDF file
-     * @returns PdfExtractionError with appropriate message
-     */
-    static wrapExtractionError(error, filePath) {
-        const errorMessage = PdfExtractor.getExtractionErrorMessage(error);
-        const lowerMessage = errorMessage.toLowerCase();
-        if (lowerMessage.includes('password') || lowerMessage.includes('encrypted')) {
-            return new PdfExtractionError(filePath, 'PDF is password-protected or encrypted');
-        }
-        return new PdfExtractionError(filePath, errorMessage);
-    }
-}
-/**
- * Formats extracted PDF pages into a readable string with page separators.
- * @param pages - Array of extracted page contents
- * @param metadata - PDF metadata
- * @param hasMore - Whether there are more pages
- * @param nextOffset - Next offset for continuation (if hasMore is true)
- * @returns Formatted string with page separators
- */
-export function formatPdfContent(pages, metadata, hasMore, nextOffset) {
-    if (pages.length === 0) {
-        return '';
-    }
-    const formattedPages = pages.map((page) => `--- Page ${page.pageNumber} ---\n${page.text}`).join('\n\n');
-    const truncationNote = hasMore
-        ? `\n\n(PDF has more pages. Use offset=${nextOffset} to continue)`
-        : `\n\n(End of PDF - ${metadata.pageCount} pages)`;
-    return formattedPages + truncationNote;
-}

package/dist/infra/cipher/http/internal-llm-http-service.d.ts

@@ -1,133 +0,0 @@
-import type { RequestOptions } from '@anthropic-ai/sdk/internal/request-options';
-import type { MessageCreateParamsNonStreaming } from '@anthropic-ai/sdk/resources/messages.js';
-import type { Content, GenerateContentConfig, GenerateContentResponse } from '@google/genai';
-import type { GenerateContentChunk } from '../../../core/interfaces/cipher/i-content-generator.js';
-/**
- * ByteRover HTTP LLM provider configuration.
- */
-export interface ByteRoverHttpConfig {
-    apiBaseUrl: string;
-    projectId?: string;
-    region?: string;
-    sessionKey: string;
-    spaceId: string;
-    teamId: string;
-    timeout?: number;
-}
-/**
- * ByteRover HTTP LLM API client.
- *
- * Simple wrapper around ByteRover REST LLM service.
- * Delegates prompt building and formatting to service layer.
- *
- * Responsibilities:
- * - Call the remote REST API
- * - Handle HTTP responses
- * - Convert to GenerateContentResponse format
- *
- * Does NOT:
- * - Build prompts or format inputs
- * - Parse or manipulate response content
- * - Handle tool call parsing from text
- */
-export declare class ByteRoverLlmHttpService {
-    private readonly config;
-    /**
-     * Initialize a new ByteRover HTTP LLM service client.
-     *
-     * Sets up configuration with sensible defaults:
-     * - projectId defaults to 'byterover'
-     * - region defaults to 'us-east1' (can be overridden per request)
-     * - timeout defaults to 60 seconds
-     *
-     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
-     */
-    constructor(config: ByteRoverHttpConfig);
-    /**
-     * Call ByteRover REST LLM service to generate content.
-     *
-     * Simple forward to remote REST API - delegates all formatting to backend.
-     * Supports both Gemini and Claude formats - the correct format is determined
-     * automatically based on the model name.
-     *
-     * Parameter structure differs by provider:
-     * - Gemini: contents = Content[], config = GenerateContentConfig
-     * - Claude: contents = MessageCreateParamsNonStreaming (complete body), config = RequestOptions (HTTP options)
-     *
-     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
-     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
-     * @param model - Model to use (detects provider from model name)
-     * @param executionMetadata - Optional execution metadata (mode, executionContext)
-     * @returns Response in GenerateContentResponse format
-     */
-    generateContent(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): Promise<GenerateContentResponse>;
-    /**
-     * Call ByteRover REST LLM service to generate content with streaming.
-     *
-     * Currently falls back to non-streaming endpoint since /api/llm/generate/stream
-     * doesn't exist on the backend yet. Extracts thinking/reasoning from the complete
-     * response and yields them as separate chunks.
-     *
-     * When backend streaming is available, this will use SSE for true streaming.
-     *
-     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
-     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
-     * @param model - Model to use (detects provider from model name)
-     * @param executionMetadata - Optional execution metadata (mode, executionContext)
-     * @yields GenerateContentChunk objects as they are generated
-     */
-    generateContentStream(contents: Content[] | MessageCreateParamsNonStreaming, config: GenerateContentConfig | RequestOptions, model: string, executionMetadata?: Record<string, unknown>): AsyncGenerator<GenerateContentChunk>;
-    /**
-     * Call the ByteRover REST Generate endpoint.
-     *
-     * Handles authentication headers and error handling.
-     *
-     * @param request - The REST generate request with model, provider, region, and params
-     * @returns Promise resolving to the complete LLM response
-     * @throws Error if the request fails
-     */
-    private callHttpGenerate;
-    /**
-     * Detect LLM provider from model identifier.
-     *
-     * Determines which provider (Claude or Gemini) to use based on the model name.
-     * Defaults to Gemini if the model doesn't match Claude patterns.
-     *
-     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
-     * @returns Provider name: 'claude' or 'gemini'
-     */
-    private detectProviderFromModel;
-    /**
-     * Detect appropriate GCP region from model identifier.
-     *
-     * Routes Claude models to us-east5 and Gemini models to global.
-     * This ensures compatibility with the provider's available regions on Vertex AI.
-     *
-     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
-     * @returns GCP region identifier ('us-east5' or 'global')
-     */
-    private detectRegionFromModel;
-    /**
-     * Extract content chunks from a complete response.
-     *
-     * Looks for text parts (excluding thinking) and function calls,
-     * yields them as final chunks.
-     *
-     * @param response - Complete GenerateContentResponse
-     * @yields GenerateContentChunk for content and tool calls
-     */
-    private extractContentFromResponse;
-    /**
-     * Extract thinking/reasoning chunks from a complete response.
-     *
-     * Looks for parts with `thought: true` and yields them as THINKING chunks.
-     *
-     * @param response - Complete GenerateContentResponse
-     * @yields GenerateContentChunk for each thinking part
-     */
-    private extractThinkingFromResponse;
-    /**
-     * Map provider finish reason to standard format.
-     */
-    private mapFinishReason;
-}

package/dist/infra/cipher/http/internal-llm-http-service.js

@@ -1,265 +0,0 @@
-import { StreamChunkType } from '../../../core/interfaces/cipher/i-content-generator.js';
-import { AuthenticatedHttpClient } from '../../http/authenticated-http-client.js';
-import { ThoughtParser } from '../llm/thought-parser.js';
-/**
- * ByteRover HTTP LLM API client.
- *
- * Simple wrapper around ByteRover REST LLM service.
- * Delegates prompt building and formatting to service layer.
- *
- * Responsibilities:
- * - Call the remote REST API
- * - Handle HTTP responses
- * - Convert to GenerateContentResponse format
- *
- * Does NOT:
- * - Build prompts or format inputs
- * - Parse or manipulate response content
- * - Handle tool call parsing from text
- */
-export class ByteRoverLlmHttpService {
-    config;
-    /**
-     * Initialize a new ByteRover HTTP LLM service client.
-     *
-     * Sets up configuration with sensible defaults:
-     * - projectId defaults to 'byterover'
-     * - region defaults to 'us-east1' (can be overridden per request)
-     * - timeout defaults to 60 seconds
-     *
-     * @param config - HTTP client configuration (accessToken, apiBaseUrl, sessionKey, optional: projectId, region, timeout)
-     */
-    constructor(config) {
-        this.config = {
-            apiBaseUrl: config.apiBaseUrl,
-            projectId: config.projectId ?? 'byterover',
-            region: config.region ?? 'us-east1',
-            sessionKey: config.sessionKey,
-            spaceId: config.spaceId,
-            teamId: config.teamId,
-            timeout: config.timeout ?? 60_000,
-        };
-    }
-    /**
-     * Call ByteRover REST LLM service to generate content.
-     *
-     * Simple forward to remote REST API - delegates all formatting to backend.
-     * Supports both Gemini and Claude formats - the correct format is determined
-     * automatically based on the model name.
-     *
-     * Parameter structure differs by provider:
-     * - Gemini: contents = Content[], config = GenerateContentConfig
-     * - Claude: contents = MessageCreateParamsNonStreaming (complete body), config = RequestOptions (HTTP options)
-     *
-     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
-     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
-     * @param model - Model to use (detects provider from model name)
-     * @param executionMetadata - Optional execution metadata (mode, executionContext)
-     * @returns Response in GenerateContentResponse format
-     */
-    async generateContent(contents, config, model, executionMetadata) {
-        const request = {
-            executionMetadata: JSON.stringify(executionMetadata ?? {}),
-            params: {
-                config,
-                contents,
-                model,
-            },
-            project_id: this.config.projectId,
-            provider: this.detectProviderFromModel(model),
-            region: this.detectRegionFromModel(model),
-            spaceId: this.config.spaceId,
-            teamId: this.config.teamId,
-        };
-        return this.callHttpGenerate(request);
-    }
-    /**
-     * Call ByteRover REST LLM service to generate content with streaming.
-     *
-     * Currently falls back to non-streaming endpoint since /api/llm/generate/stream
-     * doesn't exist on the backend yet. Extracts thinking/reasoning from the complete
-     * response and yields them as separate chunks.
-     *
-     * When backend streaming is available, this will use SSE for true streaming.
-     *
-     * @param contents - For Gemini: Content[]. For Claude: MessageCreateParamsNonStreaming (complete body)
-     * @param config - For Gemini: GenerateContentConfig. For Claude: RequestOptions (optional HTTP options)
-     * @param model - Model to use (detects provider from model name)
-     * @param executionMetadata - Optional execution metadata (mode, executionContext)
-     * @yields GenerateContentChunk objects as they are generated
-     */
-    async *generateContentStream(contents, config, model, executionMetadata) {
-        // Fall back to non-streaming endpoint and simulate streaming
-        // by extracting thinking from the complete response
-        const response = await this.generateContent(contents, config, model, executionMetadata);
-        // Extract and yield thinking/reasoning chunks first
-        yield* this.extractThinkingFromResponse(response);
-        // Then yield the final content
-        yield* this.extractContentFromResponse(response);
-    }
-    /**
-     * Call the ByteRover REST Generate endpoint.
-     *
-     * Handles authentication headers and error handling.
-     *
-     * @param request - The REST generate request with model, provider, region, and params
-     * @returns Promise resolving to the complete LLM response
-     * @throws Error if the request fails
-     */
-    async callHttpGenerate(request) {
-        const url = `${this.config.apiBaseUrl}/api/llm/generate`;
-        const httpClient = new AuthenticatedHttpClient(this.config.sessionKey);
-        const httpResponse = await httpClient.post(url, request, {
-            timeout: this.config.timeout,
-        });
-        return httpResponse.data;
-    }
-    /**
-     * Detect LLM provider from model identifier.
-     *
-     * Determines which provider (Claude or Gemini) to use based on the model name.
-     * Defaults to Gemini if the model doesn't match Claude patterns.
-     *
-     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
-     * @returns Provider name: 'claude' or 'gemini'
-     */
-    detectProviderFromModel(model) {
-        return model.toLowerCase().startsWith('claude') ? 'claude' : 'gemini';
-    }
-    /**
-     * Detect appropriate GCP region from model identifier.
-     *
-     * Routes Claude models to us-east5 and Gemini models to global.
-     * This ensures compatibility with the provider's available regions on Vertex AI.
-     *
-     * @param model - Model identifier (e.g., 'claude-3-5-sonnet', 'gemini-2.5-flash')
-     * @returns GCP region identifier ('us-east5' or 'global')
-     */
-    detectRegionFromModel(model) {
-        return model.toLowerCase().startsWith('claude') ? 'us-east5' : 'global';
-    }
-    /**
-     * Extract content chunks from a complete response.
-     *
-     * Looks for text parts (excluding thinking) and function calls,
-     * yields them as final chunks.
-     *
-     * @param response - Complete GenerateContentResponse
-     * @yields GenerateContentChunk for content and tool calls
-     */
-    *extractContentFromResponse(response) {
-        const { candidates } = response;
-        if (!candidates || candidates.length === 0) {
-            yield {
-                content: '',
-                finishReason: 'stop',
-                isComplete: true,
-            };
-            return;
-        }
-        const candidate = candidates[0];
-        const parts = candidate?.content?.parts;
-        const finishReason = this.mapFinishReason(candidate?.finishReason ?? 'STOP');
-        if (!parts || parts.length === 0) {
-            yield {
-                content: '',
-                finishReason,
-                isComplete: true,
-            };
-            return;
-        }
-        // Collect text content (excluding thinking parts)
-        const textParts = [];
-        const functionCalls = [];
-        for (const part of parts) {
-            const partRecord = part;
-            // Skip thinking parts
-            if (partRecord.thought === true)
-                continue;
-            // Collect text
-            if (partRecord.text && typeof partRecord.text === 'string') {
-                textParts.push(partRecord.text);
-            }
-            // Collect function calls
-            if (partRecord.functionCall) {
-                functionCalls.push(partRecord.functionCall);
-            }
-        }
-        // Yield final content chunk
-        yield {
-            content: textParts.join('').trimEnd(),
-            finishReason,
-            isComplete: true,
-            toolCalls: functionCalls.length > 0
-                ? functionCalls.map((fc, index) => ({
-                    function: {
-                        arguments: JSON.stringify(fc.args ?? {}),
-                        name: fc.name ?? '',
-                    },
-                    id: `call_${Date.now()}_${index}`,
-                    type: 'function',
-                }))
-                : undefined,
-        };
-    }
-    /**
-     * Extract thinking/reasoning chunks from a complete response.
-     *
-     * Looks for parts with `thought: true` and yields them as THINKING chunks.
-     *
-     * @param response - Complete GenerateContentResponse
-     * @yields GenerateContentChunk for each thinking part
-     */
-    *extractThinkingFromResponse(response) {
-        const { candidates } = response;
-        if (!candidates || candidates.length === 0)
-            return;
-        const parts = candidates[0]?.content?.parts;
-        if (!parts)
-            return;
-        let thinkingSubject;
-        for (const part of parts) {
-            const partRecord = part;
-            // Check for thinking part (thought: true)
-            if (partRecord.thought === true && partRecord.text && typeof partRecord.text === 'string') {
-                const delta = partRecord.text;
-                // Extract subject from **Subject** markdown if not already found
-                if (!thinkingSubject && delta) {
-                    const parsed = ThoughtParser.parse(delta);
-                    if (parsed.subject) {
-                        thinkingSubject = parsed.subject;
-                    }
-                }
-                yield {
-                    isComplete: false,
-                    providerMetadata: {
-                        subject: thinkingSubject,
-                    },
-                    reasoning: delta.trimEnd(),
-                    type: StreamChunkType.THINKING,
-                };
-            }
-        }
-    }
-    /**
-     * Map provider finish reason to standard format.
-     */
-    mapFinishReason(reason) {
-        switch (reason.toUpperCase()) {
-            case 'FUNCTION_CALL':
-            case 'TOOL_CALLS': {
-                return 'tool_calls';
-            }
-            case 'LENGTH':
-            case 'MAX_TOKENS': {
-                return 'max_tokens';
-            }
-            case 'STOP': {
-                return 'stop';
-            }
-            default: {
-                return 'stop';
-            }
-        }
-    }
-}

package/dist/infra/cipher/interactive-commands.d.ts

@@ -1,16 +0,0 @@
-import type { ICipherAgent } from '../../core/interfaces/cipher/i-cipher-agent.js';
-/**
- * Get all available command names (including aliases) for autocomplete
- *
- * @returns Array of command names with '/' prefix
- */
-export declare function getCommandNames(): string[];
-/**
- * Execute an interactive command
- *
- * @param command - Command name
- * @param args - Command arguments
- * @param agent - CipherAgent instance
- * @returns Promise<boolean> - true to continue loop, false to exit
- */
-export declare function executeCommand(command: string, args: string[], agent: ICipherAgent): Promise<boolean>;

package/dist/infra/cipher/interactive-loop.d.ts

@@ -1,24 +0,0 @@
-import type { ICipherAgent } from '../../core/interfaces/cipher/i-cipher-agent.js';
-import type { AgentEventBus } from './events/event-emitter.js';
-/**
- * Display system information message on the same line using carriage return
- * This allows messages to overwrite each other for cleaner output
- *
- * @param message - Info message to display
- * @param clear - If true, clear the line after displaying (for completed actions)
- */
-export declare function displayInfo(message: string, clear?: boolean): void;
-/**
- * Start interactive loop for CipherAgent
- *
- * @param agent - CipherAgent instance
- * @param options - Optional configuration
- * @param options.model - LLM model name
- * @param options.sessionId - Session identifier
- * @param options.eventBus - Optional event bus for listening to agent events
- */
-export declare function startInteractiveLoop(agent: ICipherAgent, options?: {
-    eventBus?: AgentEventBus;
-    model?: string;
-    sessionId?: string;
-}): Promise<void>;