tarsk 0.3.43 → 0.4.4

package/dist/features/threads/threads.routes.js

@@ -0,0 +1,230 @@
+/**
+ * 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 { handleCreateThread } from "./threads-create.route.js";
+import { handleListThreads } from "./threads-list.route.js";
+import { handleDeleteThread } from "./threads-delete.route.js";
+import { handleSelectThread } from "./threads-select.route.js";
+import { handleGetThread } from "./threads-get.route.js";
+import { handleGetThreadMessages } from "./threads-messages.route.js";
+import { handleListThreadFiles } from "./threads-files.route.js";
+import { handleUpdateThread } from "./threads-update.route.js";
+import { handleOpenThread } from "./threads-open.route.js";
+import { handleGetConversationFolderPath } from "./threads-conversation-folder-path.route.js";
+import { handleFixComments } from "./threads-fix-comments.route.js";
+import { handleGetThreadAIFiles, handleGetThreadAIFile, handleSaveThreadAIFile, handleDeleteThreadAIFile, handleCreateThreadSkill, handleCreateThreadAgent, } from "./threads-ai-files.route.js";
+/**
+ * Creates thread routes
+ * @param threadManager - The ThreadManager instance
+ * @param gitManager - The GitManager instance
+ * @returns Hono router with thread routes
+ */
+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) => {
+        return handleCreateThread(c, threadManager, gitManager);
+    });
+    /**
+     * 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) => {
+        const { getDatabase } = await import("../../database/database.js");
+        const db = await getDatabase();
+        return handleListThreads(c, threadManager, db);
+    });
+    /**
+     * 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) => {
+        return handleDeleteThread(c, threadManager);
+    });
+    /**
+     * 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) => {
+        return handleSelectThread(c, threadManager);
+    });
+    /**
+     * GET /api/threads/:id
+     * Get details of a specific thread
+     *
+     * Response:
+     * {
+     *   "id": "uuid",
+     *   "projectId": "uuid",
+     *   "title": "Thread title",
+     *   "path": "/path/to/thread",
+     *   "currentBranch": "branch-name",
+     *   "createdAt": "2024-01-01T00:00:00Z",
+     *   "currentConversationId": "uuid",
+     *   "status": "active"
+     * }
+     *
+     * Requirements:
+     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
+     */
+    router.get("/:id", async (c) => {
+        return handleGetThread(c, threadManager);
+    });
+    /**
+     * GET /api/threads/:id/messages
+     * Get chat history for a thread
+     */
+    router.get("/:id/messages", async (c) => {
+        return handleGetThreadMessages(c, threadManager, conversationManager);
+    });
+    /**
+     * GET /api/threads/:id/files
+     * List all files in a thread's directory
+     */
+    router.get("/:id/files", async (c) => {
+        return handleListThreadFiles(c, threadManager);
+    });
+    /**
+     * PATCH /api/threads/:id
+     * Update thread metadata
+     */
+    router.patch("/:id", async (c) => {
+        return handleUpdateThread(c, threadManager);
+    });
+    /**
+     * POST /api/threads/:id/open
+     * Open a thread in the specified program
+     *
+     * Request body:
+     * {
+     *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
+     * }
+     *
+     * Response:
+     * {
+     *   "success": true,
+     *   "message": "Thread opened in VS Code"
+     * }
+     */
+    router.post("/:id/open", async (c) => {
+        return handleOpenThread(c, threadManager);
+    });
+    /**
+     * GET /api/threads/:id/conversation-folder-path
+     * Return the absolute path to the folder containing the conversation history JSON for this thread.
+     */
+    router.get("/:id/conversation-folder-path", async (c) => {
+        return handleGetConversationFolderPath(c);
+    });
+    /**
+     * POST /api/threads/:id/fix-comments
+     * Convert diff review comments into todos and return the prompt to send to the agent.
+     */
+    router.post("/:id/fix-comments", async (c) => {
+        return handleFixComments(c, threadManager);
+    });
+    /**
+     * GET /api/threads/:id/ai-files
+     * List AI-related files (skills, rules, commands, markdown files) from the thread's path
+     */
+    router.get("/:id/ai-files", async (c) => {
+        return handleGetThreadAIFiles(c, threadManager);
+    });
+    /**
+     * GET /api/threads/:id/ai-file?path=...
+     * Read the content of an AI-related file from the thread's path
+     */
+    router.get("/:id/ai-file", async (c) => {
+        return handleGetThreadAIFile(c, threadManager);
+    });
+    /**
+     * PUT /api/threads/:id/ai-file
+     * Save the content of an AI-related file in the thread's path
+     */
+    router.put("/:id/ai-file", async (c) => {
+        return handleSaveThreadAIFile(c, threadManager);
+    });
+    /**
+     * DELETE /api/threads/:id/ai-file?path=...
+     * Delete a file or folder in the thread's path
+     */
+    router.delete("/:id/ai-file", async (c) => {
+        return handleDeleteThreadAIFile(c, threadManager);
+    });
+    /**
+     * POST /api/threads/:id/ai-files/skill
+     * Create a new skill in the thread's path
+     */
+    router.post("/:id/ai-files/skill", async (c) => {
+        return handleCreateThreadSkill(c, threadManager);
+    });
+    /**
+     * POST /api/threads/:id/ai-files/agent
+     * Create a new agent in the thread's path
+     */
+    router.post("/:id/ai-files/agent", async (c) => {
+        return handleCreateThreadAgent(c, threadManager);
+    });
+    return router;
+}
+//# sourceMappingURL=threads.routes.js.map

package/dist/features/todos/todos.database.d.ts

@@ -0,0 +1,14 @@
+import type { Database } from "../../database/database.types.js";
+export interface TodoRecord {
+    id: string;
+    threadId: string;
+    description: string;
+    status: string;
+    assignedTo: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function fetchAllTodos(db: Database, threadId: string): Promise<TodoRecord[]>;
+export declare function addTodos(threadId: string, descriptions: string[], assignedTo?: string): Promise<TodoRecord[]>;
+export declare function clearTodos(threadId: string): Promise<void>;
+//# sourceMappingURL=todos.database.d.ts.map

package/dist/features/todos/todos.database.js

@@ -0,0 +1,31 @@
+import { randomUUID } from "crypto";
+import { getDatabase } from "../../database/database.js";
+export async function fetchAllTodos(db, threadId) {
+    const result = await db.execute({
+        sql: `SELECT id, threadId, description, status, assignedTo, createdAt, updatedAt
+		      FROM todos WHERE threadId = ? ORDER BY createdAt ASC`,
+        args: [threadId],
+    });
+    return result.rows;
+}
+export async function addTodos(threadId, descriptions, assignedTo = "agent") {
+    const db = await getDatabase();
+    const now = new Date().toISOString();
+    for (const desc of descriptions) {
+        const id = randomUUID();
+        await db.execute({
+            sql: `INSERT INTO todos (id, threadId, description, status, assignedTo, createdAt, updatedAt)
+			      VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
+            args: [id, threadId, desc.trim(), assignedTo, now, now],
+        });
+    }
+    return fetchAllTodos(db, threadId);
+}
+export async function clearTodos(threadId) {
+    const db = await getDatabase();
+    await db.execute({
+        sql: "DELETE FROM todos WHERE threadId = ?",
+        args: [threadId],
+    });
+}
+//# sourceMappingURL=todos.database.js.map

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

@@ -0,0 +1,13 @@
+import { Hono } from "hono";
+export interface UpdateFunctions {
+    checkForUpdate: () => Promise<{
+        updateAvailable: boolean;
+    } | null>;
+    downloadUpdate: () => Promise<void>;
+    applyUpdate: () => Promise<void>;
+    getUpdateInfo: () => {
+        updateReady?: boolean;
+    } | null;
+}
+export declare function createUpdateRoutes(updater?: UpdateFunctions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=updates.routes.d.ts.map

package/dist/features/updates/updates.routes.js

@@ -0,0 +1,40 @@
+import { Hono } from "hono";
+export function createUpdateRoutes(updater) {
+    const app = new Hono();
+    app.get("/check", async (c) => {
+        if (!updater) {
+            return c.json({ updateAvailable: false, supported: false });
+        }
+        try {
+            const result = await updater.checkForUpdate();
+            return c.json({
+                updateAvailable: result?.updateAvailable ?? false,
+                supported: true,
+            });
+        }
+        catch (error) {
+            console.error("Failed to check for update:", error);
+            return c.json({ updateAvailable: false, supported: true, error: "Check failed" });
+        }
+    });
+    app.post("/apply", async (c) => {
+        if (!updater) {
+            return c.json({ error: "Updates not supported in this environment" }, 400);
+        }
+        try {
+            await updater.downloadUpdate();
+            const info = updater.getUpdateInfo();
+            if (info?.updateReady) {
+                await updater.applyUpdate();
+                return c.json({ success: true, message: "Update applied, restarting..." });
+            }
+            return c.json({ success: false, message: "Update downloaded but not ready to apply" });
+        }
+        catch (error) {
+            console.error("Failed to apply update:", error);
+            return c.json({ error: "Failed to apply update" }, 500);
+        }
+    });
+    return app;
+}
+//# sourceMappingURL=updates.routes.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map