tarsk 0.3.3 → 0.3.16

package/dist/routes/chat-old.d.ts

@@ -1,21 +0,0 @@
-/**
- * Chat routes for the REST API
- *
- * Handles chat message processing:
- * - POST /api/chat - Send a message to the agent
- */
-import { Hono } from 'hono';
-import { ThreadManager } from '../managers/thread-manager.js';
-import { NeovateExecutor } from '../managers/neovate-executor.js';
-import { ConversationManager } from '../managers/conversation-manager.js';
-import { ProcessingStateManager } from '../managers/processing-state-manager.js';
-/**
- * Creates chat routes
- * @param threadManager - The ThreadManager instance
- * @param neovateExecutor - The NeovateExecutor instance
- * @param conversationManager - The ConversationManager instance
- * @param processingStateManager - The ProcessingStateManager instance
- * @returns Hono router with chat routes
- */
-export declare function createChatRoutes(threadManager: ThreadManager, neovateExecutor: NeovateExecutor, conversationManager: ConversationManager, processingStateManager: ProcessingStateManager): Hono;
-//# sourceMappingURL=chat-old.d.ts.map

package/dist/routes/chat-old.js

@@ -1,251 +0,0 @@
-/**
- * Chat routes for the REST API
- *
- * Handles chat message processing:
- * - POST /api/chat - Send a message to the agent
- */
-import { Hono } from 'hono';
-import { delay } from '../utils.js';
-import { streamAsyncGenerator } from '../lib/stream-helper.js';
-/**
- * Creates chat routes
- * @param threadManager - The ThreadManager instance
- * @param neovateExecutor - The NeovateExecutor instance
- * @param conversationManager - The ConversationManager instance
- * @param processingStateManager - The ProcessingStateManager instance
- * @returns Hono router with chat routes
- */
-export function createChatRoutes(threadManager, neovateExecutor, conversationManager, processingStateManager) {
-    const router = new Hono();
-    /**
-     * POST /api/chat
-     * Send a message to the agent
-     *
-     * Request body:
-     * {
-     *   "threadId": "uuid",
-     *   "message": "User message content",
-     *   "model": "model-name",
-     *   "attachments": [
-     *     {
-     *       "name": "file.txt",
-     *       "content": "base64-encoded-content",
-     *       "size": 1024,
-     *       "mimeType": "text/plain"
-     *     }
-     *   ]
-     * }
-     *
-     * Response: Newline-delimited JSON stream of NeovateEvent objects
-     *
-     * Requirements:
-     * - 6.4 - THE CLI SHALL expose REST API endpoints for chat message processing
-     * - 8.5 - WHEN sending a chat message, THE App SHALL send a POST request with the message content and Selected_Thread context to the CLI
-     * - 5.4 - WHEN the Neovate command executes, THE CLI SHALL stream the output back to the App
-     */
-    router.post('/', async (c) => {
-        try {
-            const body = await c.req.json();
-            const { threadId, content, model: baseModel, provider, attachments, planMode } = body;
-            // Prepend provider name (lowercased) to the model if provider is provided
-            let model = baseModel;
-            if (provider && typeof provider === 'string') {
-                const providerPrefix = provider.toLowerCase();
-                // Only prepend if the model doesn't already start with this provider prefix
-                if (!model.startsWith(providerPrefix + '/')) {
-                    model = `${providerPrefix}/${model}`;
-                }
-            }
-            // Validate required fields
-            if (!threadId || typeof threadId !== 'string') {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'threadId is required and must be a string',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            if (!content || typeof content !== 'string') {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'content is required and must be a string',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            if (!model || typeof model !== 'string') {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'model is required and must be a string',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            // Get thread metadata to build execution context
-            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);
-            }
-            // Capture thread path for use in generators
-            const threadPath = thread.path;
-            // Check if this is a replay request
-            if (content.trim().toLowerCase() === 'replay') {
-                console.log('[ChatRoute] Replay request detected');
-                // Get the last message from conversation history
-                const lastMessages = await conversationManager.getLastMessages(threadPath, 1);
-                if (lastMessages.length === 0) {
-                    const errorResponse = {
-                        error: {
-                            code: 'NO_HISTORY',
-                            message: 'No previous conversation found to replay',
-                            timestamp: new Date().toISOString()
-                        }
-                    };
-                    return c.json(errorResponse, 404);
-                }
-                const lastMessage = lastMessages[0];
-                // Check if message has a completed response
-                if (!lastMessage.response) {
-                    const errorResponse = {
-                        data: null,
-                        error: {
-                            code: 'NO_RESPONSE',
-                            message: 'Previous message has no completed response to replay',
-                            timestamp: new Date().toISOString()
-                        }
-                    };
-                    return c.json(errorResponse, 404);
-                }
-                console.log('[ChatRoute] Replaying message:', {
-                    messageId: lastMessage.id,
-                    timestamp: lastMessage.timestamp,
-                    eventCount: lastMessage.response.events.length,
-                });
-                // Extract response to ensure TypeScript narrowing
-                const response = lastMessage.response;
-                // Create a generator for replay events
-                async function* replayGenerator() {
-                    // First, send a replay indicator event
-                    const replayEvent = {
-                        type: 'message',
-                        role: 'system',
-                        content: `🔄 Replaying previous conversation from ${lastMessage.timestamp}`
-                    };
-                    await delay(1000);
-                    yield replayEvent;
-                    // Then stream all the captured events
-                    for (const event of response.events) {
-                        console.log('[ChatRoute] Replaying event:', event);
-                        await delay(1000);
-                        yield event;
-                    }
-                    // Finally, send a completion indicator
-                    const completeEvent = {
-                        type: 'message',
-                        role: 'system',
-                        content: '✅ Replay complete'
-                    };
-                    await delay(1000);
-                    yield completeEvent;
-                }
-                return streamAsyncGenerator(c, replayGenerator());
-            }
-            // Normal chat flow - capture and execute
-            // Build execution context
-            const context = {
-                threadId,
-                threadPath,
-                model,
-                provider,
-                attachments,
-                planMode,
-            };
-            console.log('[ChatRoute] Execution context:', {
-                threadId,
-                threadPath,
-                model,
-                planMode,
-                attachmentCount: attachments?.length || 0,
-            });
-            // Start capturing the conversation
-            const messageId = await conversationManager.startMessage(threadId, threadPath, content, model, attachments, planMode);
-            // Mark thread as processing
-            processingStateManager.setProcessing(threadId);
-            // Create a generator for chat execution events
-            async function* chatExecutionGenerator() {
-                const capturedEvents = [];
-                let fullContent = '';
-                try {
-                    for await (const event of neovateExecutor.execute(content, context)) {
-                        // Capture the event
-                        capturedEvents.push(event);
-                        // Accumulate content from message events
-                        if (event.type === 'message' && event.content) {
-                            fullContent += event.content;
-                        }
-                        // Yield the event for streaming
-                        yield event;
-                    }
-                    // Complete the conversation message with captured data
-                    await conversationManager.completeMessage(threadPath, messageId, fullContent, capturedEvents);
-                    console.log('[ChatRoute] Conversation captured:', {
-                        messageId,
-                        eventCount: capturedEvents.length,
-                        contentLength: fullContent.length,
-                    });
-                }
-                catch (error) {
-                    const errorEvent = {
-                        type: 'error',
-                        error: {
-                            code: 'STREAM_ERROR',
-                            message: error instanceof Error ? error.message : String(error),
-                            details: error instanceof Error ? { stack: error.stack } : undefined
-                        }
-                    };
-                    // Capture the error event too
-                    capturedEvents.push(errorEvent);
-                    yield errorEvent;
-                    // Try to save the partial conversation even on error
-                    try {
-                        await conversationManager.completeMessage(threadPath, messageId, fullContent, capturedEvents);
-                    }
-                    catch (saveError) {
-                        console.error('[ChatRoute] Failed to save partial conversation:', saveError);
-                    }
-                }
-                finally {
-                    // Clear processing state when done
-                    processingStateManager.clearProcessing(threadId);
-                }
-            }
-            return streamAsyncGenerator(c, chatExecutionGenerator());
-        }
-        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);
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=chat-old.js.map

package/dist/routes/projects-old.d.ts

@@ -1,20 +0,0 @@
-/**
- * Project routes for the REST API
- *
- * Handles all project-related operations:
- * - POST /api/projects - Create a new project
- * - GET /api/projects - List all projects
- * - GET /api/projects/:id - Get project details
- * - DELETE /api/projects/:id - Delete a project
- */
-import { Hono } from 'hono';
-import { ProjectManager } from '../managers/project-manager.js';
-import { ThreadManager } from '../managers/thread-manager.js';
-/**
- * Creates project routes
- * @param projectManager - The ProjectManager instance
- * @param threadManager - The ThreadManager instance
- * @returns Hono router with project routes
- */
-export declare function createProjectRoutes(projectManager: ProjectManager, threadManager: ThreadManager): Hono;
-//# sourceMappingURL=projects-old.d.ts.map

package/dist/routes/projects-old.js

@@ -1,297 +0,0 @@
-/**
- * Project routes for the REST API
- *
- * Handles all project-related operations:
- * - POST /api/projects - Create a new project
- * - GET /api/projects - List all projects
- * - GET /api/projects/:id - Get project details
- * - DELETE /api/projects/:id - Delete a project
- */
-import { Hono } from 'hono';
-import { AVAILABLE_PROGRAMS } from '../types/models.js';
-import { streamAsyncGenerator } from '../lib/stream-helper.js';
-import { ResponseBuilder } from '../lib/response-builder.js';
-/**
- * Creates project routes
- * @param projectManager - The ProjectManager instance
- * @param threadManager - The ThreadManager instance
- * @returns Hono router with project routes
- */
-export function createProjectRoutes(projectManager, threadManager) {
-    const router = new Hono();
-    /**
-     * POST /api/projects
-     * Create a new project from a git URL
-     *
-     * Request body:
-     * {
-     *   "gitUrl": "https://github.com/user/repo.git"
-     * }
-     *
-     * Response: Newline-delimited JSON stream of ProjectEvent objects
-     *
-     * Requirements:
-     * - 6.2 - THE App SHALL send a POST request with the git URL to the CLI
-     * - 8.2 - THE CLI SHALL support streaming responses to the client
-     */
-    router.post('/', async (c) => {
-        try {
-            const body = await c.req.json();
-            const { gitUrl } = body;
-            // Validate gitUrl is provided
-            if (!gitUrl || typeof gitUrl !== 'string') {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'gitUrl is required and must be a string', 400);
-                return c.json(response, statusCode);
-            }
-            // Stream the project creation events
-            return streamAsyncGenerator(c, projectManager.createProject(gitUrl));
-        }
-        catch (error) {
-            const { response, statusCode } = ResponseBuilder.error('REQUEST_PARSE_ERROR', 'Failed to parse request body', 400, error instanceof Error ? error.message : String(error));
-            return c.json(response, statusCode);
-        }
-    });
-    /**
-     * GET /api/projects
-     * List all projects with expanded threads
-     *
-     * Response:
-     * [
-     *   {
-     *     "projectId": "uuid",
-     *     "gitUrl": "https://github.com/user/repo.git",
-     *     "projectPath": "/path/to/project",
-     *     "threads": [
-     *       {
-     *         "threadId": "uuid",
-     *         "title": "thread-title",
-     *         "path": "/path/to/thread",
-     *         "isSelected": false
-     *       }
-     *     ]
-     *   }
-     * ]
-     *
-     * Requirements:
-     * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
-     */
-    router.get('/', async (c) => {
-        try {
-            const projects = await projectManager.listProjects();
-            // Get the currently selected thread
-            const selectedThreadId = await threadManager.getSelectedThreadId();
-            // Expand threads for each project
-            const expandedProjects = await Promise.all(projects.map(async (project) => {
-                const threads = await threadManager.listThreads(project.id);
-                return {
-                    projectId: project.id,
-                    gitUrl: project.gitUrl,
-                    projectPath: project.path,
-                    openWith: project.openWith,
-                    threads: threads.map(thread => ({
-                        threadId: thread.id,
-                        title: thread.title,
-                        path: thread.path,
-                        isSelected: thread.id === selectedThreadId
-                    }))
-                };
-            }));
-            return c.json(expandedProjects);
-        }
-        catch (error) {
-            const { response, statusCode } = ResponseBuilder.error('LIST_PROJECTS_ERROR', 'Failed to list projects', 500, error instanceof Error ? error.message : String(error));
-            return c.json(response, statusCode);
-        }
-    });
-    /**
-     * GET /api/projects/:id
-     * Get project details by ID
-     *
-     * Response:
-     * {
-     *   "id": "uuid",
-     *   "name": "project-name",
-     *   "gitUrl": "https://github.com/user/repo.git",
-     *   "path": "/path/to/project",
-     *   "createdAt": "2024-01-01T00:00:00Z",
-     *   "threads": ["thread-id-1", "thread-id-2"]
-     * }
-     *
-     * Requirements:
-     * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
-     */
-    router.get('/:id', async (c) => {
-        try {
-            const projectId = c.req.param('id');
-            if (!projectId) {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
-                return c.json(response, statusCode);
-            }
-            const project = await projectManager.getProject(projectId);
-            if (!project) {
-                const { response, statusCode } = ResponseBuilder.error('PROJECT_NOT_FOUND', `Project not found: ${projectId}`, 404);
-                return c.json(response, statusCode);
-            }
-            return c.json(project);
-        }
-        catch (error) {
-            const { response, statusCode } = ResponseBuilder.error('GET_PROJECT_ERROR', 'Failed to get project', 500, error instanceof Error ? error.message : String(error));
-            return c.json(response, statusCode);
-        }
-    });
-    /**
-     * DELETE /api/projects/:id
-     * Delete a project and all its threads
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Project deleted successfully"
-     * }
-     *
-     * Requirements:
-     * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
-     */
-    router.delete('/:id', async (c) => {
-        try {
-            const projectId = c.req.param('id');
-            if (!projectId) {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
-                return c.json(response, statusCode);
-            }
-            await projectManager.deleteProject(projectId);
-            const { response, statusCode } = ResponseBuilder.success({ success: true, message: 'Project deleted successfully' });
-            return c.json(response, statusCode);
-        }
-        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 { response, statusCode } = ResponseBuilder.error('PROJECT_NOT_FOUND', errorMessage, 404);
-                return c.json(response, statusCode);
-            }
-            const { response, statusCode } = ResponseBuilder.error('DELETE_PROJECT_ERROR', 'Failed to delete project', 500, errorMessage);
-            return c.json(response, statusCode);
-        }
-    });
-    /**
-     * POST /api/projects/:id/open
-     * Open a project in the specified program
-     *
-     * Request body:
-     * {
-     *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
-     * }
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Project opened in VS Code"
-     * }
-     */
-    router.post('/:id/open', async (c) => {
-        try {
-            const projectId = c.req.param('id');
-            const body = await c.req.json();
-            const { program } = body;
-            if (!projectId) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'Project ID is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            if (!program) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'Program is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            if (!AVAILABLE_PROGRAMS.includes(program)) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(', ')}`,
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            const project = await projectManager.getProject(projectId);
-            if (!project) {
-                const errorResponse = {
-                    error: {
-                        code: 'PROJECT_NOT_FOUND',
-                        message: `Project not found: ${projectId}`,
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 404);
-            }
-            await projectManager.openWith(projectId, program);
-            const { response, statusCode } = ResponseBuilder.success({ success: true, message: `Project opened in ${program}` });
-            return c.json(response, statusCode);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const { response, statusCode } = ResponseBuilder.error('OPEN_PROGRAM_ERROR', 'Failed to open project', 500, errorMessage);
-            return c.json(response, statusCode);
-        }
-    });
-    /**
-     * PUT /api/projects/:id/open-with
-     * Update the project's open-with program preference
-     *
-     * Request body:
-     * {
-     *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
-     * }
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Open-with program updated"
-     * }
-     */
-    router.put('/:id/open-with', async (c) => {
-        try {
-            const projectId = c.req.param('id');
-            const body = await c.req.json();
-            const { program } = body;
-            if (!projectId) {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
-                return c.json(response, statusCode);
-            }
-            if (!program) {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Program is required', 400);
-                return c.json(response, statusCode);
-            }
-            if (!AVAILABLE_PROGRAMS.includes(program)) {
-                const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(', ')}`, 400);
-                return c.json(response, statusCode);
-            }
-            const project = await projectManager.getProject(projectId);
-            if (!project) {
-                const { response, statusCode } = ResponseBuilder.error('PROJECT_NOT_FOUND', `Project not found: ${projectId}`, 404);
-                return c.json(response, statusCode);
-            }
-            await projectManager.updateOpenWith(projectId, program);
-            const { response, statusCode } = ResponseBuilder.success({ success: true, message: 'Open-with program updated' });
-            return c.json(response, statusCode);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const { response, statusCode } = ResponseBuilder.error('UPDATE_PROGRAM_ERROR', 'Failed to update open-with program', 500, errorMessage);
-            return c.json(response, statusCode);
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=projects-old.js.map

package/dist/routes/threads-old.d.ts

@@ -1,14 +0,0 @@
-/**
- * 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-old.d.ts.map