tarsk 0.4.4 → 0.4.6

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

@@ -1,56 +0,0 @@
-/**
- * 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
- */
-import { Context } from "hono";
-import type { ThreadManager } from "../threads/threads.manager.js";
-import type { Database } from "../../database/database.types.js";
-export declare function handleListThreads(c: Context, threadManager: ThreadManager, db?: Database): 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<{
-    id: string;
-    projectId: string;
-    title: string;
-    path: string;
-    currentBranch: string;
-    createdAt: string;
-    enabledSkills?: string[] | undefined;
-    disabledSkills?: string[] | undefined;
-    currentConversationId?: string | undefined;
-    status?: "active" | "deleted" | undefined;
-    diffComments?: {
-        id: string;
-        filePath: string;
-        fileIndex: number;
-        lineNumber: number;
-        lineContent: string;
-        comment: string;
-        side: "original" | "modified";
-    }[] | undefined;
-    model?: string | undefined;
-    modelProvider?: string | undefined;
-}[], import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-//# sourceMappingURL=threads-list.route.d.ts.map

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

@@ -1,58 +0,0 @@
-/**
- * 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
- */
-import { errorResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-import { getGitStatusCacheBulk } from "../git/git-status-cache.database.js";
-function computeGitStatusDot(status) {
-    if (status.hasChanges)
-        return true;
-    if (status.commitsAheadOfDefault && !status.prExists)
-        return true;
-    if (status.status === "Behind" || status.status === "Diverged")
-        return true;
-    return false;
-}
-export async function handleListThreads(c, threadManager, db) {
-    try {
-        const projectId = c.req.query("projectId");
-        // Validate projectId is provided
-        if (!projectId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "projectId query parameter is required", 400);
-        }
-        const threads = await threadManager.listThreads(projectId);
-        if (!db) {
-            return c.json(threads);
-        }
-        const statusCache = await getGitStatusCacheBulk(db, threads.map((t) => t.id));
-        const threadsWithStatus = threads.map((thread) => {
-            const cached = statusCache.get(thread.id);
-            const gitStatusDot = cached ? computeGitStatusDot(cached) : false;
-            return { ...thread, gitStatusDot };
-        });
-        return c.json(threadsWithStatus);
-    }
-    catch (error) {
-        return errorResponse(c, ErrorCodes.LIST_THREADS_ERROR, "Failed to list threads", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-//# sourceMappingURL=threads-list.route.js.map

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

@@ -1,28 +0,0 @@
-/**
- * GET /api/threads/:id/messages
- * Get chat history for a thread
- */
-import { Context } from "hono";
-import type { ThreadManager } from "../threads/threads.manager.js";
-import type { ConversationManager } from "../conversations/conversations.manager.js";
-export declare function handleGetThreadMessages(c: Context, threadManager: ThreadManager, conversationManager: ConversationManager): 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<{
-    messageId: string;
-    sender: "user" | "agent";
-    content: string;
-    contentType: "text" | "markdown";
-    timestamp: string;
-    model?: string | undefined;
-    attachments?: {
-        fileName: string;
-        content: string;
-        size?: number | undefined;
-    }[] | undefined;
-}[], import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-//# sourceMappingURL=threads-messages.route.d.ts.map

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

@@ -1,110 +0,0 @@
-/**
- * GET /api/threads/:id/messages
- * Get chat history for a thread
- */
-import { extractAssistantContent, parseAssistantContentBlocks, } from "../conversations/conversations.content.js";
-import { errorResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-/**
- * Builds content for the UI that includes reasoning, tool_use, tool results, and final answer.
- * Returns a JSON string of content blocks so the frontend can show reasoning, tool progress, and answer.
- */
-const buildStructuredContentFromEvents = (events, fallbackContent) => {
-    if (!events || events.length === 0) {
-        return fallbackContent;
-    }
-    // Prefer assistant message content when it is already a structured array (reasoning, text, tool_use)
-    for (const event of events) {
-        if (event.type === "message" &&
-            event.role === "assistant" &&
-            typeof event.content === "string") {
-            const assistantBlocks = parseAssistantContentBlocks(event.content);
-            if (assistantBlocks && assistantBlocks.length > 0) {
-                return JSON.stringify(assistantBlocks);
-            }
-        }
-    }
-    const blocks = [];
-    for (const event of events) {
-        if (event.type === "message" && event.role === "tool" && typeof event.content === "string") {
-            try {
-                const parsed = JSON.parse(event.content.trim());
-                if (Array.isArray(parsed)) {
-                    for (const item of parsed) {
-                        if (item && typeof item === "object" && "type" in item) {
-                            blocks.push(item);
-                        }
-                    }
-                }
-                else if (parsed && typeof parsed === "object" && "type" in parsed) {
-                    blocks.push(parsed);
-                }
-            }
-            catch {
-                blocks.push({ type: "text", text: event.content });
-            }
-        }
-    }
-    const finalText = extractAssistantContent(events, fallbackContent);
-    if (finalText.trim().length > 0) {
-        blocks.push({ type: "text", text: finalText });
-    }
-    if (blocks.length === 0) {
-        return fallbackContent;
-    }
-    if (blocks.length === 1 && blocks[0].type === "text" && "text" in blocks[0]) {
-        return typeof blocks[0].text === "string" ? blocks[0].text : fallbackContent;
-    }
-    return JSON.stringify(blocks);
-};
-export async function handleGetThreadMessages(c, threadManager, conversationManager) {
-    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);
-        }
-        // Load messages for the current conversation only
-        const history = thread.currentConversationId
-            ? await conversationManager.getConversationHistoryByConversationId(thread.path, thread.currentConversationId)
-            : 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: buildStructuredContentFromEvents(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) {
-        return errorResponse(c, ErrorCodes.GET_THREAD_MESSAGES_ERROR, "Failed to load thread messages", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-//# sourceMappingURL=threads-messages.route.js.map

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

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

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

@@ -1,62 +0,0 @@
-/**
- * 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"
- * }
- */
-import { PROGRAM_APP_NAMES } from "@tarsk/shared";
-import { validateProgram } from "../projects/projects.open-with.js";
-import open from "open";
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function handleOpenThread(c, threadManager) {
-    try {
-        const threadId = c.req.param("id");
-        const body = await c.req.json();
-        const { program } = body;
-        if (!threadId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
-        }
-        const programError = validateProgram(program);
-        if (programError) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, programError, 400);
-        }
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        const threadPath = thread.path;
-        // Ensure program is defined and is a string before indexing
-        const appNames = typeof program === "string" ? PROGRAM_APP_NAMES[program] : undefined;
-        if (!appNames) {
-            return errorResponse(c, ErrorCodes.OPEN_PROGRAM_ERROR, `Unsupported program: ${program}`, 500);
-        }
-        console.log("[POST /api/threads/:id/open] threadId=%s program=%s threadPath=%s", threadId, program, threadPath);
-        try {
-            await open(threadPath, {
-                app: { name: appNames },
-            });
-            console.log("[POST /api/threads/:id/open] Successfully opened thread in %s", program);
-        }
-        catch (openError) {
-            const message = openError instanceof Error ? openError.message : String(openError);
-            console.error("[POST /api/threads/:id/open] Failed to open thread:", message);
-            return errorResponse(c, ErrorCodes.OPEN_PROGRAM_ERROR, `Failed to open ${program}: ${message}`, 500);
-        }
-        return successResponse(c, { success: true, message: `Thread opened in ${program}` });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.OPEN_PROGRAM_ERROR, "Failed to open thread", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=threads-open.route.js.map

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

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

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

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

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

@@ -1,15 +0,0 @@
-/**
- * PATCH /api/threads/:id
- * Update thread metadata
- */
-import { Context } from "hono";
-import type { ThreadManager } from "../threads/threads.manager.js";
-export declare function handleUpdateThread(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-update.route.d.ts.map

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

@@ -1,30 +0,0 @@
-/**
- * PATCH /api/threads/:id
- * Update thread metadata
- */
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function handleUpdateThread(c, threadManager) {
-    try {
-        const threadId = c.req.param("id");
-        const body = await c.req.json();
-        if (!threadId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID is required", 400);
-        }
-        // Validate model format if present
-        if (body.model && !body.modelProvider) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, `Invalid model format (model=${body.model}, provider=${body.provider}): Model must be in format "{provider}/{model}" (e.g., "openrouter/claude-3-5-sonnet-20241022").`, 400);
-        }
-        // Validate modelProvider format if present
-        if (body.modelProvider && typeof body.modelProvider !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "modelProvider must be a string", 400);
-        }
-        await threadManager.updateThread(threadId, body);
-        return successResponse(c, { success: true, message: "Thread updated successfully" });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.UPDATE_THREAD_ERROR, "Failed to update thread", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=threads-update.route.js.map

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

@@ -1,68 +0,0 @@
-/**
- * SQLite Database Operations for Threads
- *
- * This module handles all CRUD operations for threads in the SQLite database.
- * Includes transaction support for atomic operations.
- */
-import { Thread } from "@tarsk/shared";
-import { Database } from "../../database/database.types";
-/**
- * Insert a new thread into the database
- * @param db SQLite database instance
- * @param thread Thread to insert
- */
-export declare function insertThread(db: Database, thread: Thread): Promise<void>;
-/**
- * Update an existing thread in the database
- * @param db SQLite database instance
- * @param id Thread ID
- * @param updates Partial thread object with fields to update
- */
-export declare function updateThread(db: Database, id: string, updates: Partial<Thread>): Promise<void>;
-/**
- * Mark a thread as deleted (soft delete)
- * @param db SQLite database instance
- * @param id Thread ID
- */
-export declare function deleteThread(db: Database, id: string): Promise<void>;
-/**
- * Get a single thread by ID
- * @param db SQLite database instance
- * @param id Thread ID
- * @returns Thread object or null if not found
- */
-export declare function getThread(db: Database, id: string): Promise<Thread | null>;
-/**
- * Get all active threads from the database
- * @param db SQLite database instance
- * @returns Array of active threads only
- */
-export declare function getAllThreads(db: Database): Promise<Thread[]>;
-/**
- * Get active threads for a specific project
- * @param db SQLite database instance
- * @param projectId Project ID
- * @returns Array of active threads for project only
- */
-export declare function getThreadsByProjectId(db: Database, projectId: string): Promise<Thread[]>;
-/**
- * Check if a thread exists
- * @param db SQLite database instance
- * @param id Thread ID
- * @returns True if thread exists
- */
-export declare function threadExists(db: Database, id: string): Promise<boolean>;
-/**
- * Get thread count
- * @param db SQLite database instance
- * @returns Number of threads
- */
-export declare function getThreadCount(db: Database): Promise<number>;
-/**
- * Get thread count for a specific project
- * @param db SQLite database instance
- * @param projectId Project ID
- * @returns Number of threads in the project
- */
-export declare function getThreadCountByProjectId(db: Database, projectId: string): Promise<number>;
-//# sourceMappingURL=threads.database.d.ts.map