tarsk 0.2.5 → 0.3.0

package/dist/routes/models.js

@@ -0,0 +1,128 @@
+/**
+ * Model routes for the REST API
+ *
+ * Handles all model-related operations:
+ * - GET /api/models - Get available models for a provider
+ * - POST /api/models/:provider/:modelId/enable - Enable a model
+ * - POST /api/models/:provider/:modelId/disable - Disable a model
+ * - GET /api/models/enabled - Get all enabled models
+ */
+import { Hono } from 'hono';
+import { ModelManager } from '../managers/model-manager.js';
+/**
+ * Creates model routes
+ * @param metadataManager - Manager for metadata persistence
+ * @returns Hono router with model routes
+ */
+export function createModelRoutes(metadataManager) {
+    const router = new Hono();
+    const modelManager = new ModelManager(metadataManager);
+    /**
+     * GET /api/models?provider=openrouter&supportedTools=true
+     * Get available models for a provider
+     *
+     * Query parameters:
+     * - provider: Required. Provider name (e.g., "openrouter", "openai")
+     * - supportedTools: Optional. If "true", only return models with tools support
+     */
+    router.get('/', async (c) => {
+        try {
+            const provider = c.req.query('provider');
+            const supportedTools = c.req.query('supportedTools');
+            if (!provider) {
+                return c.json({ error: 'provider query parameter is required' }, 400);
+            }
+            let models = await modelManager.getAvailableModels(provider);
+            // Filter by supported tools if requested
+            if (supportedTools === 'true' && provider.toLowerCase() === 'openrouter') {
+                models = models.filter((m) => m.supportedParameters?.tools === true);
+            }
+            // Sort models to put enabled ones at the top
+            const enabledModels = await modelManager.getEnabledModels(provider);
+            const enabledModelIds = new Set(enabledModels.map((m) => m.id));
+            models.sort((a, b) => {
+                const aEnabled = enabledModelIds.has(a.id) ? 0 : 1;
+                const bEnabled = enabledModelIds.has(b.id) ? 0 : 1;
+                return aEnabled - bEnabled;
+            });
+            return c.json({ provider, models });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return c.json({ error: message }, 500);
+        }
+    });
+    /**
+     * GET /api/models/enabled
+     * Get all enabled models across all providers
+     */
+    router.get('/enabled', async (c) => {
+        try {
+            const enabledModels = await modelManager.getAllEnabledModels();
+            return c.json({ enabledModels });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return c.json({ error: message }, 500);
+        }
+    });
+    /**
+     * POST /api/models/:provider/:modelId/enable
+     * Enable a model for a provider
+     */
+    router.post('/:provider/:modelId/enable', async (c) => {
+        try {
+            const provider = c.req.param('provider');
+            const modelId = c.req.param('modelId');
+            if (!provider || !modelId) {
+                return c.json({ error: 'provider and modelId are required' }, 400);
+            }
+            await modelManager.enableModel(provider, modelId);
+            return c.json({ success: true, message: `Model ${modelId} enabled for ${provider}` });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return c.json({ error: message }, 400);
+        }
+    });
+    /**
+     * POST /api/models/:provider/:modelId/disable
+     * Disable a model for a provider
+     */
+    router.post('/:provider/:modelId/disable', async (c) => {
+        try {
+            const provider = c.req.param('provider');
+            const modelId = c.req.param('modelId');
+            if (!provider || !modelId) {
+                return c.json({ error: 'provider and modelId are required' }, 400);
+            }
+            await modelManager.disableModel(provider, modelId);
+            return c.json({ success: true, message: `Model ${modelId} disabled for ${provider}` });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return c.json({ error: message }, 500);
+        }
+    });
+    /**
+     * POST /api/models/:provider/refresh
+     * Refresh the available models for a provider
+     * Note: With provider-data.ts, this is a no-op but kept for backward compatibility
+     */
+    router.post('/:provider/refresh', async (c) => {
+        try {
+            const provider = c.req.param('provider');
+            if (!provider) {
+                return c.json({ error: 'provider is required' }, 400);
+            }
+            const models = await modelManager.getAvailableModels(provider);
+            return c.json({ success: true, provider, modelCount: models.length });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return c.json({ error: message }, 500);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=models.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,297 @@
+/**
+ * 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/projects.d.ts

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