@zds-ai/cli 0.1.0

package/dist/ui/utils/markdown-renderer.js

@@ -0,0 +1,40 @@
+import React from 'react';
+import { Text } from 'ink';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+export function MarkdownRenderer({ content }) {
+    try {
+        // List of common abbreviations that should NOT get two spaces after them
+        const abbreviations = ['Mr', 'Mrs', 'Ms', 'Dr', 'St', 'Jr', 'Sr', 'Prof', 'Rev'];
+        // Pre-process: Convert one or two spaces after hard stops to nbsp + space (to prevent reflow collapse)
+        // Pattern: word(2+ chars) + optional quotes/markdown + hard stop + optional quotes/markdown + 1-2 spaces + optional quotes/markdown + capital
+        // Supports: " ' " " ' ' " " (quotes) and * ** (markdown emphasis)
+        // Note: nbsp comes FIRST so it stays with the hard stop, not at start of new line
+        let processed = content.replace(/\b(\w{2,})(["'""''""\u201C\u201D*]*?)([.!?])(["'""''""\u201C\u201D*]*?) {1,2}(["'""''""\u201C\u201D*]*?)([A-Z])/g, (match, word, markupBefore, punct, markupAfter, markupBeforeCap, cap) => {
+            // Don't convert if word is an abbreviation
+            if (abbreviations.includes(word))
+                return match;
+            // Convert to: non-breaking space + regular space (preserving all markup)
+            return `${word}${markupBefore}${punct}${markupAfter}\u00A0 ${markupBeforeCap}${cap}`;
+        });
+        // Create a new renderer with width reduced by 3 columns for each render
+        // to account for bullet points and spacing that would cause wrapping
+        const terminalWidth = (process.stdout.columns || 80) - 3;
+        const renderer = new TerminalRenderer({
+            width: terminalWidth,
+            reflowText: true
+        });
+        marked.setOptions({ renderer });
+        // Use marked.parse for synchronous parsing
+        const result = marked.parse(processed);
+        // Handle both sync and async results
+        const rendered = typeof result === 'string' ? result : content;
+        return React.createElement(Text, null, rendered);
+    }
+    catch (error) {
+        // Fallback to plain text if markdown parsing fails
+        console.error('Markdown rendering error:', error);
+        return React.createElement(Text, null, content);
+    }
+}
+//# sourceMappingURL=markdown-renderer.js.map

package/dist/ui/utils/markdown-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-renderer.js","sourceRoot":"","sources":["../../../src/ui/utils/markdown-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC;AAC3B,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,gBAAgB,MAAM,iBAAiB,CAAC;AAE/C,MAAM,UAAU,gBAAgB,CAAC,EAAE,OAAO,EAAuB;IAC/D,IAAI,CAAC;QACH,yEAAyE;QACzE,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAEjF,uGAAuG;QACvG,8IAA8I;QAC9I,kEAAkE;QAClE,kFAAkF;QAClF,IAAI,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,kHAAkH,EAChJ,CAAC,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,GAAG,EAAE,EAAE;YACtE,2CAA2C;YAC3C,IAAI,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC/C,yEAAyE;YACzE,OAAO,GAAG,IAAI,GAAG,YAAY,GAAG,KAAK,GAAG,WAAW,UAAU,eAAe,GAAG,GAAG,EAAE,CAAC;QACvF,CAAC,CACF,CAAC;QAEF,wEAAwE;QACxE,qEAAqE;QACrE,MAAM,aAAa,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;QAEzD,MAAM,QAAQ,GAAG,IAAK,gBAAwB,CAAC;YAC7C,KAAK,EAAE,aAAa;YACpB,UAAU,EAAE,IAAI;SACjB,CAAC,CAAC;QAEH,MAAM,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEhC,2CAA2C;QAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACvC,qCAAqC;QACrC,MAAM,QAAQ,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;QAC/D,OAAO,oBAAC,IAAI,QAAE,QAAQ,CAAQ,CAAC;IACjC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,mDAAmD;QACnD,OAAO,CAAC,KAAK,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;QAClD,OAAO,oBAAC,IAAI,QAAE,OAAO,CAAQ,CAAC;IAChC,CAAC;AACH,CAAC"}

package/dist/utils/auth-helper.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Authentication helper utilities
+ * Handles API key retrieval from multiple sources with proper fallback logic
+ */
+/**
+ * Get API key with proper fallback logic:
+ * 1. Environment variable (GROK_API_KEY)
+ * 2. User settings file (~/.grok/user-settings.json)
+ * 3. Command-line argument (passed explicitly)
+ *
+ * @param explicitApiKey - API key passed via command-line argument (highest priority)
+ * @returns API key or undefined if not found
+ */
+export declare function getApiKey(explicitApiKey?: string): string | undefined;
+/**
+ * Get base URL with proper fallback logic:
+ * 1. Explicit base URL from command-line argument
+ * 2. Environment variable (GROK_BASE_URL)
+ * 3. User settings file (~/.grok/user-settings.json)
+ * 4. Default value
+ *
+ * @param explicitBaseURL - Base URL passed via command-line argument (highest priority)
+ * @param defaultBaseURL - Default base URL to use if none found (default: https://api.x.ai/v1)
+ * @returns Base URL
+ */
+export declare function getBaseURL(explicitBaseURL?: string, defaultBaseURL?: string): string;
+/**
+ * Get model with proper fallback logic:
+ * 1. Explicit model from command-line argument
+ * 2. Environment variable (GROK_MODEL)
+ * 3. Project-specific model setting
+ * 4. User's default model
+ * 5. Default value
+ *
+ * @param explicitModel - Model passed via command-line argument (highest priority)
+ * @param defaultModel - Default model to use if none found (default: grok-code-fast-1)
+ * @returns Model name
+ */
+export declare function getModel(explicitModel?: string, defaultModel?: string): string;
+/**
+ * Validate that required authentication is present
+ * Throws an error with helpful message if API key is missing
+ *
+ * @param apiKey - API key to validate
+ * @throws Error if API key is undefined or empty
+ */
+export declare function validateApiKey(apiKey: string | undefined): asserts apiKey is string;
+/**
+ * Get all authentication configuration with proper fallbacks
+ * Convenience function that combines all auth-related getters
+ *
+ * @param options - Optional explicit values from command-line arguments
+ * @returns Complete authentication configuration
+ */
+export declare function getAuthConfig(options?: {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+}): {
+    apiKey: string | undefined;
+    baseURL: string;
+    model: string;
+};

package/dist/utils/auth-helper.js

@@ -0,0 +1,129 @@
+/**
+ * Authentication helper utilities
+ * Handles API key retrieval from multiple sources with proper fallback logic
+ */
+import { getSettingsManager } from "./settings-manager.js";
+/**
+ * Get API key with proper fallback logic:
+ * 1. Environment variable (GROK_API_KEY)
+ * 2. User settings file (~/.grok/user-settings.json)
+ * 3. Command-line argument (passed explicitly)
+ *
+ * @param explicitApiKey - API key passed via command-line argument (highest priority)
+ * @returns API key or undefined if not found
+ */
+export function getApiKey(explicitApiKey) {
+    // Priority 1: Explicit API key from command-line argument
+    if (explicitApiKey) {
+        return explicitApiKey;
+    }
+    // Priority 2: Environment variable
+    const envApiKey = process.env.GROK_API_KEY;
+    if (envApiKey) {
+        return envApiKey;
+    }
+    // Priority 3: User settings file
+    try {
+        const manager = getSettingsManager();
+        return manager.getUserSetting("apiKey");
+    }
+    catch (error) {
+        // Silently ignore errors loading from settings
+        return undefined;
+    }
+}
+/**
+ * Get base URL with proper fallback logic:
+ * 1. Explicit base URL from command-line argument
+ * 2. Environment variable (GROK_BASE_URL)
+ * 3. User settings file (~/.grok/user-settings.json)
+ * 4. Default value
+ *
+ * @param explicitBaseURL - Base URL passed via command-line argument (highest priority)
+ * @param defaultBaseURL - Default base URL to use if none found (default: https://api.x.ai/v1)
+ * @returns Base URL
+ */
+export function getBaseURL(explicitBaseURL, defaultBaseURL = "https://api.x.ai/v1") {
+    // Priority 1: Explicit base URL from command-line argument
+    if (explicitBaseURL) {
+        return explicitBaseURL;
+    }
+    // Priority 2: Environment variable
+    const envBaseURL = process.env.GROK_BASE_URL;
+    if (envBaseURL) {
+        return envBaseURL;
+    }
+    // Priority 3: User settings file
+    try {
+        const manager = getSettingsManager();
+        const userBaseURL = manager.getUserSetting("baseURL");
+        if (userBaseURL) {
+            return userBaseURL;
+        }
+    }
+    catch (error) {
+        // Silently ignore errors loading from settings
+    }
+    // Priority 4: Default value
+    return defaultBaseURL;
+}
+/**
+ * Get model with proper fallback logic:
+ * 1. Explicit model from command-line argument
+ * 2. Environment variable (GROK_MODEL)
+ * 3. Project-specific model setting
+ * 4. User's default model
+ * 5. Default value
+ *
+ * @param explicitModel - Model passed via command-line argument (highest priority)
+ * @param defaultModel - Default model to use if none found (default: grok-code-fast-1)
+ * @returns Model name
+ */
+export function getModel(explicitModel, defaultModel = "grok-code-fast-1") {
+    // Priority 1: Explicit model from command-line argument
+    if (explicitModel) {
+        return explicitModel;
+    }
+    // Priority 2: Environment variable
+    const envModel = process.env.GROK_MODEL;
+    if (envModel) {
+        return envModel;
+    }
+    // Priority 3-4: Project-specific or user's default model
+    try {
+        const manager = getSettingsManager();
+        return manager.getCurrentModel();
+    }
+    catch (error) {
+        // Silently ignore errors loading from settings
+    }
+    // Priority 5: Default value
+    return defaultModel;
+}
+/**
+ * Validate that required authentication is present
+ * Throws an error with helpful message if API key is missing
+ *
+ * @param apiKey - API key to validate
+ * @throws Error if API key is undefined or empty
+ */
+export function validateApiKey(apiKey) {
+    if (!apiKey || apiKey.trim() === "") {
+        throw new Error("API key required. Set GROK_API_KEY environment variable, use --api-key flag, or save to ~/.grok/user-settings.json");
+    }
+}
+/**
+ * Get all authentication configuration with proper fallbacks
+ * Convenience function that combines all auth-related getters
+ *
+ * @param options - Optional explicit values from command-line arguments
+ * @returns Complete authentication configuration
+ */
+export function getAuthConfig(options = {}) {
+    return {
+        apiKey: getApiKey(options.apiKey),
+        baseURL: getBaseURL(options.baseURL),
+        model: getModel(options.model),
+    };
+}
+//# sourceMappingURL=auth-helper.js.map

package/dist/utils/auth-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-helper.js","sourceRoot":"","sources":["../../src/utils/auth-helper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;GAQG;AACH,MAAM,UAAU,SAAS,CAAC,cAAuB;IAC/C,0DAA0D;IAC1D,IAAI,cAAc,EAAE,CAAC;QACnB,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,mCAAmC;IACnC,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;IAC3C,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,iCAAiC;IACjC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACrC,OAAO,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,+CAA+C;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,UAAU,CACxB,eAAwB,EACxB,iBAAyB,qBAAqB;IAE9C,2DAA2D;IAC3D,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,mCAAmC;IACnC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC;IAC7C,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,iCAAiC;IACjC,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACrC,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACtD,IAAI,WAAW,EAAE,CAAC;YAChB,OAAO,WAAW,CAAC;QACrB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,+CAA+C;IACjD,CAAC;IAED,4BAA4B;IAC5B,OAAO,cAAc,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ,CACtB,aAAsB,EACtB,eAAuB,kBAAkB;IAEzC,wDAAwD;IACxD,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,mCAAmC;IACnC,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;IACxC,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,yDAAyD;IACzD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACrC,OAAO,OAAO,CAAC,eAAe,EAAE,CAAC;IACnC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,+CAA+C;IACjD,CAAC;IAED,4BAA4B;IAC5B,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,MAA0B;IACvD,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,oHAAoH,CACrH,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,UAI1B,EAAE;IAKJ,OAAO;QACL,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC;QACjC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC;QACpC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC;KAC/B,CAAC;AACJ,CAAC"}

package/dist/utils/chat-history-manager-sqlite.d.ts

@@ -0,0 +1,92 @@
+import { ChatEntry } from "../agent/grok-agent.js";
+export interface SessionState {
+    session: string;
+    persona: string;
+    personaColor: string;
+    mood: string;
+    moodColor: string;
+    activeTask: string;
+    activeTaskAction: string;
+    activeTaskColor: string;
+    cwd: string;
+    contextCurrent: number;
+    contextMax: number;
+}
+/**
+ * SQLite-based chat history manager with support for concurrent access
+ */
+export declare class ChatHistoryManager {
+    private static instance;
+    private static customHistoryPath;
+    private dbPath;
+    private db;
+    private constructor();
+    /**
+     * Set a custom database path (must be called before getInstance)
+     */
+    static setCustomHistoryPath(filePath: string): void;
+    static getInstance(): ChatHistoryManager;
+    /**
+     * Get the database file path
+     */
+    getContextFilePath(): string;
+    private ensureHistoryDirExists;
+    /**
+     * Migrate from JSON files to SQLite if JSON files exist and DB is empty
+     */
+    private migrateFromJSONIfNeeded;
+    /**
+     * Load chat history from database
+     */
+    loadHistory(): ChatEntry[];
+    /**
+     * Add a single message to the database (atomic operation)
+     */
+    addMessage(entry: ChatEntry): void;
+    /**
+     * Save chat history to database (replaces entire history)
+     * This maintains backward compatibility but is less efficient than addMessage
+     */
+    saveHistory(history: ChatEntry[]): void;
+    /**
+     * Save raw messages log (for backward compatibility)
+     * In SQLite version, this is stored alongside the messages
+     */
+    saveMessages(messages: any[]): void;
+    /**
+     * Create a backup of the database
+     */
+    backupHistory(): string | null;
+    /**
+     * Clear all data from database with automatic backup
+     */
+    clearHistory(): void;
+    /**
+     * Save session state to database
+     */
+    saveSessionState(state: SessionState): void;
+    /**
+     * Load session state from database
+     */
+    loadSessionState(): SessionState | null;
+    /**
+     * Get the debug log file path
+     */
+    getDebugLogPath(): string;
+    /**
+     * Static method to get debug log path
+     */
+    static getDebugLogPath(): string;
+    /**
+     * Get messages in a specific range (for pagination)
+     */
+    getMessagesRange(offset: number, limit: number): ChatEntry[];
+    /**
+     * Get the total number of messages
+     */
+    getMessageCount(): number;
+    /**
+     * Export current database to JSON format (for debugging/backup)
+     */
+    exportToJSON(): string;
+}

package/dist/utils/chat-history-manager-sqlite.js

@@ -0,0 +1,334 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { DatabaseConnection } from "./database-connection.js";
+const HISTORY_DIR = path.join(os.homedir(), ".grok");
+const DB_FILE_NAME = "chat-history.db";
+/**
+ * SQLite-based chat history manager with support for concurrent access
+ */
+export class ChatHistoryManager {
+    static instance;
+    static customHistoryPath = null;
+    dbPath;
+    db;
+    constructor() {
+        this.dbPath = ChatHistoryManager.customHistoryPath || path.join(HISTORY_DIR, DB_FILE_NAME);
+        this.ensureHistoryDirExists();
+        this.db = DatabaseConnection.getConnection(this.dbPath);
+        // Attempt migration from JSON if this is first run
+        this.migrateFromJSONIfNeeded();
+    }
+    /**
+     * Set a custom database path (must be called before getInstance)
+     */
+    static setCustomHistoryPath(filePath) {
+        // Convert .json path to .db path
+        ChatHistoryManager.customHistoryPath = filePath.replace(/\.json$/, ".db");
+    }
+    static getInstance() {
+        if (!ChatHistoryManager.instance) {
+            ChatHistoryManager.instance = new ChatHistoryManager();
+        }
+        return ChatHistoryManager.instance;
+    }
+    /**
+     * Get the database file path
+     */
+    getContextFilePath() {
+        return this.dbPath;
+    }
+    ensureHistoryDirExists() {
+        const dir = path.dirname(this.dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    /**
+     * Migrate from JSON files to SQLite if JSON files exist and DB is empty
+     */
+    migrateFromJSONIfNeeded() {
+        try {
+            // Check if database is empty
+            const count = this.db.prepare("SELECT COUNT(*) as count FROM messages").get();
+            if (count.count > 0) {
+                // Database already has data, skip migration
+                return;
+            }
+            // Check for old JSON files
+            const jsonPath = this.dbPath.replace(".db", ".json");
+            const messagesJsonPath = jsonPath.replace(".json", ".messages.json");
+            const stateJsonPath = jsonPath.replace(".json", ".state.json");
+            if (!fs.existsSync(jsonPath) && !fs.existsSync(messagesJsonPath)) {
+                // No JSON files to migrate
+                return;
+            }
+            console.log("Migrating from JSON to SQLite...");
+            // Migrate chat history
+            if (fs.existsSync(jsonPath)) {
+                const data = fs.readFileSync(jsonPath, "utf-8");
+                const entries = JSON.parse(data);
+                for (const entry of entries) {
+                    this.addMessage({
+                        type: entry.type,
+                        content: entry.content,
+                        timestamp: new Date(entry.timestamp),
+                        tool_calls: entry.tool_calls,
+                        toolCall: entry.toolCall,
+                        toolResult: entry.toolResult,
+                        isStreaming: entry.isStreaming,
+                    });
+                }
+                // Rename JSON file to .migrated
+                fs.renameSync(jsonPath, `${jsonPath}.migrated`);
+            }
+            // Migrate messages log if exists
+            if (fs.existsSync(messagesJsonPath)) {
+                fs.renameSync(messagesJsonPath, `${messagesJsonPath}.migrated`);
+            }
+            // Migrate session state
+            if (fs.existsSync(stateJsonPath)) {
+                const stateData = fs.readFileSync(stateJsonPath, "utf-8");
+                const state = JSON.parse(stateData);
+                this.saveSessionState(state);
+                fs.renameSync(stateJsonPath, `${stateJsonPath}.migrated`);
+            }
+            console.log("Migration complete!");
+        }
+        catch (error) {
+            console.warn("Failed to migrate from JSON:", error);
+        }
+    }
+    /**
+     * Load chat history from database
+     */
+    loadHistory() {
+        try {
+            const stmt = this.db.prepare(`
+        SELECT type, content, tool_calls, tool_call, tool_result, is_streaming, timestamp
+        FROM messages
+        ORDER BY id ASC
+      `);
+            const rows = stmt.all();
+            return rows.map(row => ({
+                type: row.type,
+                content: row.content || undefined,
+                timestamp: new Date(row.timestamp),
+                tool_calls: row.tool_calls ? JSON.parse(row.tool_calls) : undefined,
+                toolCall: row.tool_call ? JSON.parse(row.tool_call) : undefined,
+                toolResult: row.tool_result ? JSON.parse(row.tool_result) : undefined,
+                isStreaming: row.is_streaming === 1,
+            }));
+        }
+        catch (error) {
+            console.warn("Failed to load chat history:", error);
+            return [];
+        }
+    }
+    /**
+     * Add a single message to the database (atomic operation)
+     */
+    addMessage(entry) {
+        try {
+            const stmt = this.db.prepare(`
+        INSERT INTO messages (message_id, type, content, tool_calls, tool_call, tool_result, is_streaming, timestamp)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            const messageId = `${entry.type}-${entry.timestamp.getTime()}-${Math.random().toString(36).substr(2, 9)}`;
+            stmt.run(messageId, entry.type, entry.content || null, entry.tool_calls ? JSON.stringify(entry.tool_calls) : null, entry.toolCall ? JSON.stringify(entry.toolCall) : null, entry.toolResult ? JSON.stringify(entry.toolResult) : null, entry.isStreaming ? 1 : 0, entry.timestamp.getTime());
+        }
+        catch (error) {
+            console.warn("Failed to add message:", error);
+        }
+    }
+    /**
+     * Save chat history to database (replaces entire history)
+     * This maintains backward compatibility but is less efficient than addMessage
+     */
+    saveHistory(history) {
+        try {
+            // Use transaction for atomicity
+            DatabaseConnection.transaction(this.db, () => {
+                // Clear existing messages
+                this.db.prepare("DELETE FROM messages").run();
+                // Insert all messages
+                const stmt = this.db.prepare(`
+          INSERT INTO messages (message_id, type, content, tool_calls, tool_call, tool_result, is_streaming, timestamp)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+                for (const entry of history) {
+                    const messageId = `${entry.type}-${entry.timestamp.getTime()}-${Math.random().toString(36).substr(2, 9)}`;
+                    stmt.run(messageId, entry.type, entry.content || null, entry.tool_calls ? JSON.stringify(entry.tool_calls) : null, entry.toolCall ? JSON.stringify(entry.toolCall) : null, entry.toolResult ? JSON.stringify(entry.toolResult) : null, entry.isStreaming ? 1 : 0, entry.timestamp.getTime());
+                }
+            });
+        }
+        catch (error) {
+            console.warn("Failed to save chat history:", error);
+        }
+    }
+    /**
+     * Save raw messages log (for backward compatibility)
+     * In SQLite version, this is stored alongside the messages
+     */
+    saveMessages(messages) {
+        // Messages are already saved in the main messages table
+        // This method is kept for backward compatibility but doesn't need to do anything
+        // The messages are retrievable via loadHistory()
+    }
+    /**
+     * Create a backup of the database
+     */
+    backupHistory() {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const backupPath = this.dbPath.replace(".db", `.backup-${timestamp}.db`);
+            DatabaseConnection.backup(this.dbPath, backupPath);
+            // Also backup debug log if it exists
+            const debugLogPath = this.dbPath.replace(".db", ".debug.log");
+            if (fs.existsSync(debugLogPath)) {
+                const debugBackupPath = debugLogPath.replace(".log", `.backup-${timestamp}.log`);
+                fs.copyFileSync(debugLogPath, debugBackupPath);
+            }
+            return backupPath;
+        }
+        catch (error) {
+            console.warn("Failed to backup database:", error);
+            return null;
+        }
+    }
+    /**
+     * Clear all data from database with automatic backup
+     */
+    clearHistory() {
+        try {
+            // Create backup first
+            this.backupHistory();
+            // Clear all tables
+            DatabaseConnection.transaction(this.db, () => {
+                this.db.prepare("DELETE FROM messages").run();
+                this.db.prepare("DELETE FROM session_state").run();
+                this.db.prepare("DELETE FROM session_metadata").run();
+            });
+            // Clear debug log
+            const debugLogPath = this.dbPath.replace(".db", ".debug.log");
+            if (fs.existsSync(debugLogPath)) {
+                fs.unlinkSync(debugLogPath);
+            }
+        }
+        catch (error) {
+            console.warn("Failed to clear history:", error);
+        }
+    }
+    /**
+     * Save session state to database
+     */
+    saveSessionState(state) {
+        try {
+            const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO session_state (key, value, updated_at)
+        VALUES (?, ?, ?)
+      `);
+            const now = Date.now();
+            for (const [key, value] of Object.entries(state)) {
+                stmt.run(key, JSON.stringify(value), now);
+            }
+        }
+        catch (error) {
+            console.warn("Failed to save session state:", error);
+        }
+    }
+    /**
+     * Load session state from database
+     */
+    loadSessionState() {
+        try {
+            const stmt = this.db.prepare("SELECT key, value FROM session_state");
+            const rows = stmt.all();
+            if (rows.length === 0) {
+                return null;
+            }
+            const state = {};
+            for (const row of rows) {
+                state[row.key] = JSON.parse(row.value);
+            }
+            return state;
+        }
+        catch (error) {
+            console.warn("Failed to load session state:", error);
+            return null;
+        }
+    }
+    /**
+     * Get the debug log file path
+     */
+    getDebugLogPath() {
+        return this.dbPath.replace(".db", ".debug.log");
+    }
+    /**
+     * Static method to get debug log path
+     */
+    static getDebugLogPath() {
+        const instance = ChatHistoryManager.getInstance();
+        return instance.getDebugLogPath();
+    }
+    /**
+     * Get messages in a specific range (for pagination)
+     */
+    getMessagesRange(offset, limit) {
+        try {
+            const stmt = this.db.prepare(`
+        SELECT type, content, tool_calls, tool_call, tool_result, is_streaming, timestamp
+        FROM messages
+        ORDER BY id ASC
+        LIMIT ? OFFSET ?
+      `);
+            const rows = stmt.all(limit, offset);
+            return rows.map(row => ({
+                type: row.type,
+                content: row.content || undefined,
+                timestamp: new Date(row.timestamp),
+                tool_calls: row.tool_calls ? JSON.parse(row.tool_calls) : undefined,
+                toolCall: row.tool_call ? JSON.parse(row.tool_call) : undefined,
+                toolResult: row.tool_result ? JSON.parse(row.tool_result) : undefined,
+                isStreaming: row.is_streaming === 1,
+            }));
+        }
+        catch (error) {
+            console.warn("Failed to get messages range:", error);
+            return [];
+        }
+    }
+    /**
+     * Get the total number of messages
+     */
+    getMessageCount() {
+        try {
+            const result = this.db.prepare("SELECT COUNT(*) as count FROM messages").get();
+            return result.count;
+        }
+        catch (error) {
+            console.warn("Failed to get message count:", error);
+            return 0;
+        }
+    }
+    /**
+     * Export current database to JSON format (for debugging/backup)
+     */
+    exportToJSON() {
+        try {
+            const history = this.loadHistory();
+            const serialized = history.map(entry => ({
+                ...entry,
+                timestamp: entry.timestamp.toISOString(),
+            }));
+            const exportPath = this.dbPath.replace(".db", ".export.json");
+            fs.writeFileSync(exportPath, JSON.stringify(serialized, null, 2));
+            return exportPath;
+        }
+        catch (error) {
+            console.warn("Failed to export to JSON:", error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=chat-history-manager-sqlite.js.map