tarsk 0.3.43 → 0.4.4

package/dist/features/threads/threads-ai-files.route.js

@@ -0,0 +1,287 @@
+/**
+ * AI Files routes for threads REST API
+ *
+ * Handles listing and editing AI-related files in a thread's path:
+ * - GET /api/threads/:id/ai-files - List AI file tree (skills, rules, commands, markdown files)
+ * - GET /api/threads/:id/ai-file?path=... - Read file content
+ * - PUT /api/threads/:id/ai-file - Write file content
+ * - DELETE /api/threads/:id/ai-file?path=... - Delete file or folder
+ * - POST /api/threads/:id/ai-files/skill - Create a new skill
+ */
+import { readFile, writeFile, mkdir, access, rm } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+import { buildAIFileTree, validateFilePath } from "../projects/projects-ai-files.route.js";
+/**
+ * GET /api/threads/:id/ai-files
+ */
+export async function handleGetThreadAIFiles(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const nodes = await buildAIFileTree(thread.path);
+        return c.json({ nodes });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to list AI files", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * GET /api/threads/:id/ai-file?path=...
+ */
+export async function handleGetThreadAIFile(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        const filePath = c.req.query("path");
+        if (!filePath) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "path query parameter is required" } }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const absPath = validateFilePath(thread.path, filePath);
+        if (!absPath) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
+        }
+        // Special handling for AGENTS.md - return default content if it doesn't exist
+        if (filePath === "AGENTS.md") {
+            try {
+                await access(absPath);
+            }
+            catch {
+                const defaultContent = `# AGENTS.md
+
+This file contains configuration and instructions for AI agents working on this repository.
+
+## Overview
+Add information about your project that would be helpful for AI agents to understand:
+
+- Project purpose and goals
+- Architecture and technology stack
+- Development workflows and conventions
+- Testing strategies
+- Deployment processes
+
+## Guidelines
+Provide specific guidelines for AI agents:
+
+- Code style preferences
+- File organization patterns
+- Review processes
+- Communication protocols
+
+## Resources
+Links to important documentation, tools, or references.
+
+---
+
+*This file was automatically created. Edit it to provide context for AI agents.*
+`;
+                return c.json({ content: defaultContent, path: filePath });
+            }
+        }
+        try {
+            await access(absPath);
+        }
+        catch {
+            return c.json({ error: { code: "NOT_FOUND", message: `File not found: ${filePath}` } }, 404);
+        }
+        const content = await readFile(absPath, "utf-8");
+        return c.json({ content, path: filePath });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to read file", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * PUT /api/threads/:id/ai-file
+ * Body: { path: string, content: string }
+ */
+export async function handleSaveThreadAIFile(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+        }
+        const { path: filePath, content } = body;
+        if (!filePath || content === undefined) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "path and content are required" } }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const absPath = validateFilePath(thread.path, filePath);
+        if (!absPath) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
+        }
+        const parentDir = join(absPath, "..");
+        await mkdir(parentDir, { recursive: true });
+        await writeFile(absPath, content, "utf-8");
+        return c.json({ success: true, path: filePath });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to save file", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * DELETE /api/threads/:id/ai-file?path=...
+ */
+export async function handleDeleteThreadAIFile(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        const filePath = c.req.query("path");
+        if (!filePath) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "path query parameter is required" } }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const absPath = validateFilePath(thread.path, filePath);
+        if (!absPath) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid file path" } }, 400);
+        }
+        try {
+            await access(absPath);
+        }
+        catch {
+            return c.json({ error: { code: "NOT_FOUND", message: `File or folder not found: ${filePath}` } }, 404);
+        }
+        await rm(absPath, { recursive: true, force: true });
+        return c.json({ success: true, path: filePath });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to delete file", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * POST /api/threads/:id/ai-files/agent
+ * Body: { name: string, description: string, tools?: string }
+ */
+export async function handleCreateThreadAgent(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+        }
+        const { name, description, tools } = body;
+        if (!name || !description) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "name and description are required" } }, 400);
+        }
+        if (!/^[a-z0-9-]+$/.test(name) ||
+            name.startsWith("-") ||
+            name.endsWith("-") ||
+            name.includes("--")) {
+            return c.json({
+                error: {
+                    code: "BAD_REQUEST",
+                    message: "Agent name must be lowercase alphanumeric with hyphens (no leading/trailing/consecutive hyphens)",
+                },
+            }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const agentRelPath = join(".agents", "agents", name);
+        const agentAbsPath = join(thread.path, agentRelPath);
+        const agentFileRelPath = join(agentRelPath, "AGENT.md");
+        const agentFileAbsPath = join(agentAbsPath, "AGENT.md");
+        if (existsSync(agentAbsPath)) {
+            return c.json({ error: { code: "CONFLICT", message: `Agent '${name}' already exists` } }, 409);
+        }
+        await mkdir(agentAbsPath, { recursive: true });
+        const toolsLine = tools ? `\ntools: ${tools}` : "";
+        const agentContent = `---
+name: ${name}
+description: ${description}${toolsLine}
+---
+
+Place your agent system prompt here as markdown. This will be used as the system prompt when this agent is invoked as a subagent.
+`;
+        await writeFile(agentFileAbsPath, agentContent, "utf-8");
+        return c.json({
+            success: true,
+            path: agentFileRelPath,
+            content: agentContent,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to create agent", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * POST /api/threads/:id/ai-files/skill
+ * Body: { name: string, description: string }
+ */
+export async function handleCreateThreadSkill(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
+        }
+        const { name, description } = body;
+        if (!name || !description) {
+            return c.json({ error: { code: "BAD_REQUEST", message: "name and description are required" } }, 400);
+        }
+        if (!/^[a-z0-9-]+$/.test(name) ||
+            name.startsWith("-") ||
+            name.endsWith("-") ||
+            name.includes("--")) {
+            return c.json({
+                error: {
+                    code: "BAD_REQUEST",
+                    message: "Skill name must be lowercase alphanumeric with hyphens (no leading/trailing/consecutive hyphens)",
+                },
+            }, 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const skillRelPath = join(".agents", "skills", name);
+        const skillAbsPath = join(thread.path, skillRelPath);
+        const skillFileRelPath = join(skillRelPath, "SKILL.md");
+        const skillFileAbsPath = join(skillAbsPath, "SKILL.md");
+        if (existsSync(skillAbsPath)) {
+            return c.json({ error: { code: "CONFLICT", message: `Skill '${name}' already exists` } }, 409);
+        }
+        await mkdir(skillAbsPath, { recursive: true });
+        const skillContent = `---
+name: ${name}
+description: ${description}
+---
+
+Place your skill instructions here as markdown. This will be used when Tarsk is prompted with a request related to the description of this skill.
+`;
+        await writeFile(skillFileAbsPath, skillContent, "utf-8");
+        return c.json({
+            success: true,
+            path: skillFileRelPath,
+            content: skillContent,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to create skill", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=threads-ai-files.route.js.map

package/dist/features/threads/threads-conversation-folder-path.route.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GET /api/threads/:id/conversation-folder-path
+ * Return the absolute path to the folder containing the conversation history JSON for this thread.
+ */
+import { Context } from "hono";
+export declare function handleGetConversationFolderPath(c: Context): 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=threads-conversation-folder-path.route.d.ts.map

package/dist/features/threads/threads-conversation-folder-path.route.js

@@ -0,0 +1,23 @@
+/**
+ * GET /api/threads/:id/conversation-folder-path
+ * Return the absolute path to the folder containing the conversation history JSON for this thread.
+ */
+import { join } from "path";
+import { getDataDir } from "../../core/paths.js";
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleGetConversationFolderPath(c) {
+    try {
+        const threadId = c.req.param("id");
+        if (!threadId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+        }
+        const path = join(getDataDir(), threadId);
+        return successResponse(c, { path });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return errorResponse(c, ErrorCodes.PATH_ERROR, "Failed to get conversation folder path", 500, errorMessage);
+    }
+}
+//# sourceMappingURL=threads-conversation-folder-path.route.js.map

package/dist/features/threads/threads-create.route.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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
+ */
+import { Context } from "hono";
+import type { ThreadManager } from "../threads/threads.manager.js";
+import type { GitManager } from "../git/git.manager.js";
+export declare function handleCreateThread(c: Context, threadManager: ThreadManager, gitManager: GitManager): Promise<Response>;
+//# sourceMappingURL=threads-create.route.d.ts.map

package/dist/features/threads/threads-create.route.js

@@ -0,0 +1,60 @@
+/**
+ * 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
+ */
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+import { validateThreadName } from "../../core/validation.js";
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+import { generateRandomThreadName } from "../../core/random-words.js";
+export async function handleCreateThread(c, threadManager, gitManager) {
+    try {
+        const body = await c.req.json();
+        const { projectId, title } = body;
+        // Validate projectId is provided
+        if (!projectId || typeof projectId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "projectId is required and must be a string", 400);
+        }
+        // Validate title if provided
+        if (title !== undefined && typeof title !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "title must be a string if provided", 400);
+        }
+        // Validate thread name (empty/whitespace is allowed, will auto-generate)
+        if (title && title.trim() !== "") {
+            const nameError = validateThreadName(title);
+            if (nameError) {
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, nameError, 400);
+            }
+            // Check for duplicate branch names — if duplicate, fall back to a random name
+            const existingThreads = await threadManager.listThreads(projectId);
+            const sanitizedNewName = gitManager.sanitizeBranchName(title);
+            const existingSanitized = existingThreads.map((t) => gitManager.sanitizeBranchName(t.title));
+            if (existingSanitized.includes(sanitizedNewName)) {
+                let fallbackTitle = generateRandomThreadName();
+                while (existingSanitized.includes(gitManager.sanitizeBranchName(fallbackTitle))) {
+                    fallbackTitle = generateRandomThreadName();
+                }
+                return streamAsyncGenerator(c, threadManager.createThread(projectId, fallbackTitle));
+            }
+        }
+        // Stream the thread creation events
+        return streamAsyncGenerator(c, threadManager.createThread(projectId, title));
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.REQUEST_PARSE_ERROR, "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=threads-create.route.js.map

package/dist/features/threads/threads-delete.route.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+import { Context } from "hono";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function handleDeleteThread(c: Context, 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=threads-delete.route.d.ts.map

package/dist/features/threads/threads-delete.route.js

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleDeleteThread(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        if (!threadId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+        }
+        await threadManager.deleteThread(threadId);
+        return successResponse(c, { 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")) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, errorMessage, 404);
+        }
+        return errorResponse(c, ErrorCodes.DELETE_THREAD_ERROR, "Failed to delete thread", 500, errorMessage);
+    }
+}
+//# sourceMappingURL=threads-delete.route.js.map

package/dist/features/threads/threads-files.route.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GET /api/threads/:id/files
+ * List all files in a thread's directory
+ */
+import { Context } from "hono";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function handleListThreadFiles(c: Context, 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<string[], import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+//# sourceMappingURL=threads-files.route.d.ts.map

package/dist/features/threads/threads-files.route.js

@@ -0,0 +1,20 @@
+/**
+ * GET /api/threads/:id/files
+ * List all files in a thread's directory
+ */
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleListThreadFiles(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        if (!threadId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+        }
+        const files = await threadManager.listFiles(threadId);
+        return c.json(files);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.LIST_THREAD_FILES_ERROR, "Failed to list thread files", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=threads-files.route.js.map

package/dist/features/threads/threads-fix-comments.route.d.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /api/threads/:id/fix-comments
+ * Converts diff review comments into todos in the database.
+ *
+ * Request body:
+ * {
+ *   "comments": DiffCommentRecord[]
+ * }
+ *
+ * Response:
+ * {
+ *   "prompt": string,
+ *   "todos": TodoRecord[]
+ * }
+ */
+import type { Context } from "hono";
+import type { ThreadManager } from "./threads.manager.js";
+export declare function handleFixComments(c: Context, 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=threads-fix-comments.route.d.ts.map

package/dist/features/threads/threads-fix-comments.route.js

@@ -0,0 +1,45 @@
+/**
+ * POST /api/threads/:id/fix-comments
+ * Converts diff review comments into todos in the database.
+ *
+ * Request body:
+ * {
+ *   "comments": DiffCommentRecord[]
+ * }
+ *
+ * Response:
+ * {
+ *   "prompt": string,
+ *   "todos": TodoRecord[]
+ * }
+ */
+import { addTodos, clearTodos } from "../todos/todos.database.js";
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleFixComments(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        if (!threadId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        const body = await c.req.json();
+        const { comments } = body;
+        if (!Array.isArray(comments) || comments.length === 0) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "comments must be a non-empty array", 400);
+        }
+        // Clear existing todos and insert one per comment
+        await clearTodos(threadId);
+        const descriptions = comments.map((c, i) => `${i + 1}. ${c.filePath} line ${c.lineNumber}: \`${c.lineContent.trim()}\` — ${c.comment}`);
+        const todos = await addTodos(threadId, descriptions);
+        const prompt = `${comments.length} code review comment${comments.length === 1 ? " has" : "s have"} been added as todos. First, call the todo list tool to display the tasks. Then work through each todo and implement the required changes.`;
+        return successResponse(c, { prompt, todos });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.REQUEST_PARSE_ERROR, "Failed to process fix-comments request", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=threads-fix-comments.route.js.map

package/dist/features/threads/threads-get.route.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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
+ */
+import { Context } from "hono";
+import type { ThreadManager } from "./threads.manager.js";
+export declare function handleGetThread(c: Context, 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=threads-get.route.d.ts.map

package/dist/features/threads/threads-get.route.js

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleGetThread(c, threadManager) {
+    try {
+        const threadId = c.req.param("id");
+        if (!threadId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
+        }
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        return successResponse(c, thread);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, "Failed to get thread", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=threads-get.route.js.map