tarsk 0.3.43 → 0.4.4

package/dist/features/conversations/conversations.manager.js

@@ -0,0 +1,162 @@
+/**
+ * ConversationManager handles conversation history storage and retrieval
+ *
+ * This manager is responsible for:
+ * - Storing request/response pairs in SQLite database
+ * - Retrieving conversation history for a thread
+ * - Managing conversation persistence
+ */
+import { getDatabase } from '../../database/database.js';
+import * as dbConversations from './conversations.database.js';
+/**
+ * ConversationManagerImpl provides the implementation for conversation operations
+ */
+export class ConversationManagerImpl {
+    db;
+    /**
+     * Create a new ConversationManagerImpl
+     * @param _dataDir - Directory where metadata files are stored (unused, kept for interface compatibility)
+     */
+    constructor(_dataDir) {
+        // Database will be initialized in initialize() method
+        this.db = null;
+    }
+    /**
+     * Initialize the conversation manager
+     */
+    async initialize() {
+        this.db = await getDatabase();
+    }
+    /**
+     * Starts a new conversation message
+     */
+    async startMessage(threadId, _threadPath, conversationId, message, model, attachments, planMode) {
+        try {
+            // Ensure database is initialized
+            if (!this.db) {
+                await this.initialize();
+            }
+            return await dbConversations.insertMessage(this.db, threadId, conversationId, message, model, attachments, planMode);
+        }
+        catch (error) {
+            console.error("Failed to start conversation message:", error);
+            throw error;
+        }
+    }
+    /**
+     * Completes a conversation message
+     */
+    async completeMessage(messageId, content, events) {
+        try {
+            // Ensure database is initialized
+            if (!this.db) {
+                await this.initialize();
+            }
+            // Update the conversation message
+            await dbConversations.updateMessage(this.db, messageId, content, events);
+        }
+        catch (error) {
+            console.error("Failed to complete conversation message:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the conversation history for a thread (all conversations)
+     */
+    async getConversationHistory(threadPath) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getConversationHistory(this.db, threadId);
+        }
+        catch (error) {
+            console.error("Failed to get conversation history:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the conversation history for a specific conversation
+     */
+    async getConversationHistoryByConversationId(threadPath, conversationId) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getConversationHistoryByConversationId(this.db, threadId, conversationId);
+        }
+        catch (error) {
+            console.error("Failed to get conversation history by conversation ID:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the last N messages from conversation history for a specific conversation
+     */
+    async getLastMessages(threadPath, conversationId, count = 1) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getLastMessages(this.db, threadId, conversationId, count);
+        }
+        catch (error) {
+            console.error("Failed to get last messages:", error);
+            throw error;
+        }
+    }
+    /**
+     * Clears conversation history for a specific conversation
+     */
+    async clearChatHistory(threadPath, conversationId) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            await dbConversations.clearConversationHistory(this.db, threadId, conversationId);
+        }
+        catch (error) {
+            console.error("Failed to clear conversation history:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets all conversation IDs for a thread
+     */
+    async getConversationIds(threadPath) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getConversationIds(this.db, threadId);
+        }
+        catch (error) {
+            console.error("Failed to get conversation IDs:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets deleted conversation history for a thread
+     */
+    async getDeletedConversationHistory(threadPath) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getDeletedConversationHistory(this.db, threadId);
+        }
+        catch (error) {
+            console.error("Failed to get deleted conversation history:", error);
+            throw error;
+        }
+    }
+    /**
+     * Gets deleted conversation IDs for a thread
+     */
+    async getDeletedConversationIds(threadPath) {
+        try {
+            // Extract thread ID from path (last part of the path)
+            const threadId = threadPath.split(/[\\/]/).pop() ?? "unknown";
+            return await dbConversations.getDeletedConversationIds(this.db, threadId);
+        }
+        catch (error) {
+            console.error("Failed to get deleted conversation IDs:", error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=conversations.manager.js.map

package/dist/features/conversations/conversations.routes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Conversation History routes for the REST API
+ *
+ * Handles conversation history access:
+ * - GET /api/conversations/:threadId - Get all conversation history for a thread
+ * - GET /api/conversations/:threadId/:conversationId - Get specific conversation history
+ * - GET /api/conversations/:threadId/:conversationId/messages/:count - Get last N messages
+ * - GET /api/conversations/:threadId/deleted - Get deleted conversation history
+ * - DELETE /api/conversations/:threadId/:conversationId - Clear conversation history
+ */
+import { Hono } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+/**
+ * Creates conversation history routes
+ * @param conversationManager - The ConversationManager instance
+ * @param threadManager - The ThreadManager instance
+ * @returns Hono router with conversation history routes
+ */
+export declare function createConversationRoutes(conversationManager: ConversationManager, threadManager: ThreadManager): Hono;
+//# sourceMappingURL=conversations.routes.d.ts.map

package/dist/features/conversations/conversations.routes.js

@@ -0,0 +1,38 @@
+/**
+ * Conversation History routes for the REST API
+ *
+ * Handles conversation history access:
+ * - GET /api/conversations/:threadId - Get all conversation history for a thread
+ * - GET /api/conversations/:threadId/:conversationId - Get specific conversation history
+ * - GET /api/conversations/:threadId/:conversationId/messages/:count - Get last N messages
+ * - GET /api/conversations/:threadId/deleted - Get deleted conversation history
+ * - DELETE /api/conversations/:threadId/:conversationId - Clear conversation history
+ */
+import { Hono } from "hono";
+import { getAllConversations } from "./conversations-get-all.route.js";
+import { getConversationById } from "./conversations-get-by-id.route.js";
+import { getConversationMessages } from "./conversations-get-messages.route.js";
+import { getDeletedConversations } from "./conversations-get-deleted.route.js";
+import { deleteConversation } from "./conversations-delete.route.js";
+import { handleGetConversationUsage, handleGetThreadUsage, handleGetThreadUsageSummary, } from "./token-usage.route.js";
+/**
+ * Creates conversation history routes
+ * @param conversationManager - The ConversationManager instance
+ * @param threadManager - The ThreadManager instance
+ * @returns Hono router with conversation history routes
+ */
+export function createConversationRoutes(conversationManager, threadManager) {
+    const router = new Hono();
+    router.get("/:threadId", (c) => getAllConversations(c, conversationManager, threadManager));
+    router.get("/:threadId/deleted", (c) => getDeletedConversations(c, conversationManager));
+    // Token usage routes (must come before :threadId/:conversationId)
+    router.get("/:threadId/usage", (c) => handleGetThreadUsage(c, conversationManager, threadManager));
+    router.get("/:threadId/usage-summary", (c) => handleGetThreadUsageSummary(c, conversationManager, threadManager));
+    router.get("/:threadId/:conversationId/usage", (c) => handleGetConversationUsage(c, conversationManager, threadManager));
+    // Generic conversation routes (must come after specific routes)
+    router.get("/:threadId/:conversationId", (c) => getConversationById(c, conversationManager, threadManager));
+    router.get("/:threadId/:conversationId/messages/:count", (c) => getConversationMessages(c, conversationManager, threadManager));
+    router.delete("/:threadId/:conversationId", (c) => deleteConversation(c, conversationManager, threadManager));
+    return router;
+}
+//# sourceMappingURL=conversations.routes.js.map

package/dist/features/conversations/token-usage.route.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Token usage API route
+ * Provides detailed token and cost information for conversations
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+/**
+ * Get detailed token usage for a specific conversation
+ */
+export declare function handleGetConversationUsage(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+/**
+ * Get aggregated token usage for an entire thread
+ */
+export declare function handleGetThreadUsage(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+/**
+ * Get simple usage summary for a thread (for UI display)
+ */
+export declare function handleGetThreadUsageSummary(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=token-usage.route.d.ts.map