tarsk 0.2.5 → 0.3.0

package/dist/routes/threads-old.js

@@ -0,0 +1,393 @@
+/**
+ * Thread routes for the REST API
+ *
+ * Handles all thread-related operations:
+ * - POST /api/threads - Create a new thread
+ * - GET /api/threads?projectId=xxx - List threads for a project
+ * - DELETE /api/threads/:id - Delete a thread
+ */
+import { Hono } from 'hono';
+import { validateThreadName } from '../utils/validation.js';
+import { streamAsyncGenerator } from '../lib/stream-helper.js';
+const extractTextBlocksFromContent = (content) => {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .filter((block) => block && typeof block === 'object' && block.type === 'text')
+                .map((block) => (typeof block.text === 'string' ? block.text : ''))
+                .filter((text) => text.length > 0);
+        }
+        if (parsed && typeof parsed === 'object' && typeof parsed.text === 'string') {
+            return [parsed.text];
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+};
+const extractAssistantContent = (events, fallback) => {
+    if (!events || events.length === 0) {
+        return fallback;
+    }
+    const resultEvent = [...events].reverse().find((event) => event.type === 'result');
+    if (resultEvent && typeof resultEvent.content === 'string' && resultEvent.content.trim().length > 0) {
+        return resultEvent.content;
+    }
+    const assistantMessages = events.filter((event) => event.type === 'message' && event.role === 'assistant');
+    let lastTextBlock = null;
+    const assistantChunks = [];
+    for (const event of assistantMessages) {
+        if (typeof event.content !== 'string') {
+            continue;
+        }
+        assistantChunks.push(event.content);
+        const textBlocks = extractTextBlocksFromContent(event.content);
+        if (textBlocks.length > 0) {
+            lastTextBlock = textBlocks[textBlocks.length - 1];
+        }
+    }
+    if (lastTextBlock) {
+        return lastTextBlock;
+    }
+    if (assistantChunks.length === 0) {
+        return fallback;
+    }
+    const combined = assistantChunks.join('');
+    return combined.trim().length > 0 ? combined : fallback;
+};
+export function createThreadRoutes(threadManager, gitManager, conversationManager) {
+    const router = new Hono();
+    /**
+     * POST /api/threads
+     * Create a new thread for a project
+     *
+     * Request body:
+     * {
+     *   "projectId": "uuid",
+     *   "title": "Optional thread title"
+     * }
+     *
+     * Response: Newline-delimited JSON stream of ThreadEvent objects
+     *
+     * Requirements:
+     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
+     * - 8.3 - WHEN creating a Thread, THE App SHALL send a POST request with the Project identifier to the CLI
+     * - 8.4 - THE CLI SHALL support streaming responses to the client
+     */
+    router.post('/', async (c) => {
+        try {
+            const body = await c.req.json();
+            const { projectId, title } = body;
+            // Validate projectId is provided
+            if (!projectId || typeof projectId !== 'string') {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'projectId is required and must be a string',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            // Validate title if provided
+            if (title !== undefined && typeof title !== 'string') {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'title must be a string if provided',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            // Validate thread name (empty/whitespace is allowed, will auto-generate)
+            if (title && title.trim() !== '') {
+                const nameError = validateThreadName(title);
+                if (nameError) {
+                    const errorResponse = {
+                        error: {
+                            code: 'INVALID_REQUEST',
+                            message: nameError,
+                            timestamp: new Date().toISOString()
+                        }
+                    };
+                    return c.json(errorResponse, 400);
+                }
+                // Check for duplicate branch names
+                const existingThreads = await threadManager.listThreads(projectId);
+                const sanitizedNewName = gitManager.sanitizeBranchName(title);
+                const existingSanitized = existingThreads.map(t => gitManager.sanitizeBranchName(t.title));
+                if (existingSanitized.includes(sanitizedNewName)) {
+                    const errorResponse = {
+                        error: {
+                            code: 'DUPLICATE_BRANCH',
+                            message: `A thread with branch name "${sanitizedNewName}" already exists`,
+                            timestamp: new Date().toISOString()
+                        }
+                    };
+                    return c.json(errorResponse, 409);
+                }
+            }
+            // Stream the thread creation events
+            return streamAsyncGenerator(c, threadManager.createThread(projectId, title));
+        }
+        catch (error) {
+            const errorResponse = {
+                error: {
+                    code: 'REQUEST_PARSE_ERROR',
+                    message: 'Failed to parse request body',
+                    details: error instanceof Error ? error.message : String(error),
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return c.json(errorResponse, 400);
+        }
+    });
+    /**
+     * GET /api/threads?projectId=xxx
+     * List all threads for a specific project
+     *
+     * Query parameters:
+     * - projectId (required): The project ID to filter threads
+     *
+     * Response:
+     * [
+     *   {
+     *     "id": "uuid",
+     *     "projectId": "uuid",
+     *     "title": "Thread title",
+     *     "path": "/path/to/thread",
+     *     "currentBranch": "branch-name",
+     *     "createdAt": "2024-01-01T00:00:00Z"
+     *   }
+     * ]
+     *
+     * Requirements:
+     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
+     */
+    router.get('/', async (c) => {
+        try {
+            const projectId = c.req.query('projectId');
+            // Validate projectId is provided
+            if (!projectId) {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'projectId query parameter is required',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            const threads = await threadManager.listThreads(projectId);
+            return c.json(threads);
+        }
+        catch (error) {
+            const errorResponse = {
+                error: {
+                    code: 'LIST_THREADS_ERROR',
+                    message: 'Failed to list threads',
+                    details: error instanceof Error ? error.message : String(error),
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return c.json(errorResponse, 500);
+        }
+    });
+    /**
+     * DELETE /api/threads/:id
+     * Delete a thread
+     *
+     * Response:
+     * {
+     *   "success": true,
+     *   "message": "Thread deleted successfully"
+     * }
+     *
+     * Requirements:
+     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
+     * - 8.4 - WHEN deleting a Thread, THE App SHALL send a DELETE request with the Thread identifier to the CLI
+     */
+    router.delete('/:id', async (c) => {
+        try {
+            const threadId = c.req.param('id');
+            if (!threadId) {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'Thread ID is required',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            await threadManager.deleteThread(threadId);
+            return c.json({
+                success: true,
+                message: 'Thread deleted successfully'
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if it's a "not found" error
+            if (errorMessage.includes('not found')) {
+                const errorResponse = {
+                    error: {
+                        code: 'THREAD_NOT_FOUND',
+                        message: errorMessage,
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 404);
+            }
+            const errorResponse = {
+                error: {
+                    code: 'DELETE_THREAD_ERROR',
+                    message: 'Failed to delete thread',
+                    details: errorMessage,
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return c.json(errorResponse, 500);
+        }
+    });
+    /**
+     * POST /api/threads/:id/select
+     * Select a thread as the active thread
+     *
+     * Response:
+     * {
+     *   "success": true,
+     *   "message": "Thread selected successfully",
+     *   "threadId": "uuid"
+     * }
+     *
+     * Requirements:
+     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
+     */
+    router.post('/:id/select', async (c) => {
+        try {
+            const threadId = c.req.param('id');
+            if (!threadId) {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'Thread ID is required',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            // Verify thread exists
+            const thread = await threadManager.getThread(threadId);
+            if (!thread) {
+                const errorResponse = {
+                    error: {
+                        code: 'THREAD_NOT_FOUND',
+                        message: `Thread not found: ${threadId}`,
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 404);
+            }
+            await threadManager.selectThread(threadId);
+            return c.json({
+                success: true,
+                message: 'Thread selected successfully',
+                threadId
+            });
+        }
+        catch (error) {
+            const errorResponse = {
+                error: {
+                    code: 'SELECT_THREAD_ERROR',
+                    message: 'Failed to select thread',
+                    details: error instanceof Error ? error.message : String(error),
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return c.json(errorResponse, 500);
+        }
+    });
+    /**
+     * GET /api/threads/:id/messages
+     * Get chat history for a thread
+     */
+    router.get('/:id/messages', async (c) => {
+        try {
+            const threadId = c.req.param('id');
+            if (!threadId) {
+                const errorResponse = {
+                    error: {
+                        code: 'INVALID_REQUEST',
+                        message: 'Thread ID is required',
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 400);
+            }
+            const thread = await threadManager.getThread(threadId);
+            if (!thread) {
+                const errorResponse = {
+                    error: {
+                        code: 'THREAD_NOT_FOUND',
+                        message: `Thread not found: ${threadId}`,
+                        timestamp: new Date().toISOString()
+                    }
+                };
+                return c.json(errorResponse, 404);
+            }
+            const history = await conversationManager.getConversationHistory(thread.path);
+            if (!history || history.messages.length === 0) {
+                return c.json([]);
+            }
+            const messages = history.messages.flatMap((message) => {
+                const userMessage = {
+                    messageId: `user-${message.id}`,
+                    sender: 'user',
+                    content: message.request.message,
+                    contentType: 'text',
+                    timestamp: message.timestamp,
+                    model: message.request.model,
+                    attachments: message.request.attachments?.map((attachment) => ({
+                        fileName: attachment.name,
+                        content: attachment.content,
+                        size: attachment.size,
+                    }))
+                };
+                if (!message.response) {
+                    return [userMessage];
+                }
+                const agentMessage = {
+                    messageId: `agent-${message.id}`,
+                    sender: 'agent',
+                    content: extractAssistantContent(message.response.events, message.response.content),
+                    contentType: 'markdown',
+                    timestamp: message.response.completedAt,
+                    model: message.request.model,
+                };
+                return [userMessage, agentMessage];
+            });
+            return c.json(messages);
+        }
+        catch (error) {
+            const errorResponse = {
+                error: {
+                    code: 'GET_THREAD_MESSAGES_ERROR',
+                    message: 'Failed to load thread messages',
+                    details: error instanceof Error ? error.message : String(error),
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return c.json(errorResponse, 500);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=threads-old.js.map

package/dist/routes/threads.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Thread routes for the REST API
+ *
+ * Handles all thread-related operations:
+ * - POST /api/threads - Create a new thread
+ * - GET /api/threads?projectId=xxx - List threads for a project
+ * - DELETE /api/threads/:id - Delete a thread
+ */
+import { Hono } from 'hono';
+import type { ThreadManager } from '../managers/thread-manager.js';
+import type { ConversationManager } from '../managers/conversation-manager.js';
+import type { GitManager } from '../managers/git-manager.js';
+export declare function createThreadRoutes(threadManager: ThreadManager, gitManager: GitManager, conversationManager: ConversationManager): Hono;
+//# sourceMappingURL=threads.d.ts.map