tarsk 0.4.4 → 0.4.6

package/dist/features/threads/threads.database.js

@@ -1,215 +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 { markConversationHistoryAsDeleted } from '../conversations/conversations.database.js';
-/**
- * Insert a new thread into the database
- * @param db SQLite database instance
- * @param thread Thread to insert
- */
-export async function insertThread(db, thread) {
-    try {
-        await db.execute(`
-      INSERT INTO threads (id, projectId, title, path, currentBranch, createdAt, enabledSkills, disabledSkills, currentConversationId, status)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `, [
-            thread.id,
-            thread.projectId,
-            thread.title,
-            thread.path,
-            thread.currentBranch,
-            thread.createdAt.toISOString(),
-            thread.enabledSkills ? JSON.stringify(thread.enabledSkills) : null,
-            thread.disabledSkills ? JSON.stringify(thread.disabledSkills) : null,
-            thread.currentConversationId ?? null,
-            "active", // Default status for new threads
-        ]);
-    }
-    catch (error) {
-        console.error("Failed to insert thread:", error);
-        throw error;
-    }
-}
-/**
- * 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 async function updateThread(db, id, updates) {
-    try {
-        const fields = [];
-        const values = [];
-        if (updates.title !== undefined) {
-            fields.push("title = ?");
-            values.push(updates.title);
-        }
-        if (updates.path !== undefined) {
-            fields.push("path = ?");
-            values.push(updates.path);
-        }
-        if (updates.currentBranch !== undefined) {
-            fields.push("currentBranch = ?");
-            values.push(updates.currentBranch);
-        }
-        if (updates.enabledSkills !== undefined) {
-            fields.push("enabledSkills = ?");
-            values.push(updates.enabledSkills ? JSON.stringify(updates.enabledSkills) : null);
-        }
-        if (updates.disabledSkills !== undefined) {
-            fields.push("disabledSkills = ?");
-            values.push(updates.disabledSkills ? JSON.stringify(updates.disabledSkills) : null);
-        }
-        if (updates.currentConversationId !== undefined) {
-            fields.push("currentConversationId = ?");
-            values.push(updates.currentConversationId ?? null);
-        }
-        if (updates.status !== undefined) {
-            fields.push("status = ?");
-            values.push(updates.status);
-        }
-        if (updates.diffComments !== undefined) {
-            fields.push("diffComments = ?");
-            values.push(updates.diffComments ? JSON.stringify(updates.diffComments) : null);
-        }
-        if (updates.model !== undefined) {
-            fields.push("model = ?");
-            values.push(updates.model ?? null);
-        }
-        if (updates.modelProvider !== undefined) {
-            fields.push("modelProvider = ?");
-            values.push(updates.modelProvider ?? null);
-        }
-        if (fields.length === 0) {
-            return; // No fields to update
-        }
-        values.push(id);
-        const sql = `UPDATE threads SET ${fields.join(", ")} WHERE id = ?`;
-        await db.execute(sql, values);
-    }
-    catch (error) {
-        console.error("Failed to update thread:", error);
-        throw error;
-    }
-}
-/**
- * Mark a thread as deleted (soft delete)
- * @param db SQLite database instance
- * @param id Thread ID
- */
-export async function deleteThread(db, id) {
-    try {
-        // Mark conversation history as deleted
-        await markConversationHistoryAsDeleted(db, id);
-        // Mark thread as deleted instead of deleting it
-        await db.execute("UPDATE threads SET status = ? WHERE id = ?", ["deleted", id]);
-    }
-    catch (error) {
-        console.error("Failed to mark thread as deleted:", error);
-        throw error;
-    }
-}
-/**
- * Get a single thread by ID
- * @param db SQLite database instance
- * @param id Thread ID
- * @returns Thread object or null if not found
- */
-export async function getThread(db, id) {
-    const result = await db.execute("SELECT * FROM threads WHERE id = ?", [id]);
-    const row = result.rows[0];
-    if (!row) {
-        return null;
-    }
-    return deserializeThread(row);
-}
-/**
- * Get all active threads from the database
- * @param db SQLite database instance
- * @returns Array of active threads only
- */
-export async function getAllThreads(db) {
-    try {
-        const result = await db.execute("SELECT * FROM threads WHERE status = ? ORDER BY createdAt DESC", ["active"]);
-        const rows = result.rows;
-        return rows.map(deserializeThread);
-    }
-    catch (error) {
-        console.error("Failed to get all threads:", error);
-        throw error;
-    }
-}
-/**
- * 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 async function getThreadsByProjectId(db, projectId) {
-    try {
-        const result = await db.execute("SELECT * FROM threads WHERE projectId = ? AND status = ? ORDER BY createdAt DESC", [projectId, "active"]);
-        const rows = result.rows;
-        return rows.map(deserializeThread);
-    }
-    catch (error) {
-        console.error("Failed to get threads by project ID:", error);
-        throw error;
-    }
-}
-/**
- * Deserialize a thread row from the database
- * @param row Database row
- * @returns Thread object
- */
-function deserializeThread(row) {
-    return {
-        id: row.id,
-        projectId: row.projectId,
-        title: row.title,
-        path: row.path,
-        currentBranch: row.currentBranch,
-        createdAt: new Date(row.createdAt),
-        enabledSkills: row.enabledSkills ? JSON.parse(row.enabledSkills) : undefined,
-        disabledSkills: row.disabledSkills ? JSON.parse(row.disabledSkills) : undefined,
-        currentConversationId: row.currentConversationId ?? undefined,
-        status: row.status,
-        diffComments: row.diffComments ? JSON.parse(row.diffComments) : undefined,
-        model: row.model ?? undefined,
-        modelProvider: row.modelProvider ?? undefined,
-    };
-}
-/**
- * Check if a thread exists
- * @param db SQLite database instance
- * @param id Thread ID
- * @returns True if thread exists
- */
-export async function threadExists(db, id) {
-    const result = await db.execute("SELECT 1 FROM threads WHERE id = ? LIMIT 1", [id]);
-    return result.rows.length > 0;
-}
-/**
- * Get thread count
- * @param db SQLite database instance
- * @returns Number of threads
- */
-export async function getThreadCount(db) {
-    const result = await db.execute("SELECT COUNT(*) as count FROM threads");
-    return result.rows[0].count;
-}
-/**
- * Get thread count for a specific project
- * @param db SQLite database instance
- * @param projectId Project ID
- * @returns Number of threads in the project
- */
-export async function getThreadCountByProjectId(db, projectId) {
-    const result = await db.execute("SELECT COUNT(*) as count FROM threads WHERE projectId = ?", [
-        projectId,
-    ]);
-    return result.rows[0].count;
-}
-//# sourceMappingURL=threads.database.js.map

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

@@ -1,204 +0,0 @@
-/**
- * ThreadManager handles thread lifecycle and metadata management
- *
- * This manager is responsible for:
- * - Creating new threads for existing projects
- * - Managing thread metadata
- * - Coordinating with GitManager for repository cloning
- * - Providing CRUD operations for threads
- * - Ensuring thread path uniqueness
- */
-import { Thread, ThreadEvent } from "@tarsk/shared";
-import { MetadataManager } from "../metadata/metadata.manager";
-import { GitManager } from "../git/git.manager";
-import type { ProcessingStateManager } from "../../agent/agent.processing-state-manager";
-/**
- * ThreadManager interface defines the contract for thread operations
- */
-export interface ThreadManager {
-    /**
-     * Creates a new thread for an existing project
-     * @param projectId - The parent project ID
-     * @param title - Optional thread title (auto-generated if not provided)
-     * @yields ThreadEvent objects during the creation process
-     */
-    createThread(projectId: string, title?: string): AsyncGenerator<ThreadEvent>;
-    /**
-     * Gets a thread by ID
-     * @param threadId - The thread ID
-     * @returns The thread or null if not found
-     */
-    getThread(threadId: string): Promise<Thread | null>;
-    /**
-     * Lists all threads for a specific project
-     * @param projectId - The project ID to filter threads
-     * @returns Array of threads for the project
-     */
-    listThreads(projectId: string): Promise<Thread[]>;
-    /**
-     * Deletes a thread and removes its directory
-     * @param threadId - The thread ID to delete
-     */
-    deleteThread(threadId: string): Promise<void>;
-    /**
-     * Updates a thread's metadata with partial data
-     * @param threadId - The thread ID to update
-     * @param updates - Partial thread data to merge
-     */
-    updateThread(threadId: string, updates: Partial<Omit<Thread, "id">>): Promise<void>;
-    /**
-     * Selects a thread as the active thread
-     * @param threadId - The thread ID to select
-     */
-    selectThread(threadId: string): Promise<void>;
-    /**
-     * Gets the currently selected thread ID
-     * @returns The selected thread ID or null
-     */
-    getSelectedThreadId(): Promise<string | null>;
-    /**
-     * Lists all files in a thread's directory (tracked and untracked, but not ignored)
-     * @param threadId - The thread ID
-     * @returns Array of file paths relative to the thread root
-     */
-    listFiles(threadId: string): Promise<string[]>;
-}
-/**
- * ThreadManagerImpl provides the implementation for thread operations
- */
-export declare class ThreadManagerImpl implements ThreadManager {
-    private metadataManager;
-    private gitManager;
-    private processingStateManager?;
-    private rootFolder;
-    /**
-     * Create a new ThreadManager
-     * @param metadataManager - Manager for persisting metadata
-     * @param gitManager - Manager for git operations
-     * @param processingStateManager - Optional manager for processing state (for spinner during clone)
-     * @param rootFolder - Base directory where threads will be stored
-     *
-     * Requirements:
-     * - 2.1 - WHEN a user creates a new Thread for a Project, THE CLI SHALL create a new clone of the Project's git repository
-     * - 2.4 - THE System SHALL maintain a title for each Thread
-     */
-    constructor(metadataManager: MetadataManager, gitManager: GitManager, processingStateManager?: ProcessingStateManager, rootFolder?: string);
-    /**
-     * Creates a new thread for an existing project
-     *
-     * This method:
-     * 1. Validates that the project exists
-     * 2. Generates a unique thread ID
-     * 3. Gets the project's git URL
-     * 4. Generates a unique thread path
-     * 5. Delegates to GitManager for cloning
-     * 6. Saves thread metadata
-     * 7. Updates the project's thread list
-     * 8. Yields progress events during the operation
-     *
-     * @param projectId - The parent project ID
-     * @param title - Optional thread title (auto-generated if not provided)
-     * @yields ThreadEvent objects during the creation process
-     *
-     * Requirements:
-     * - 2.1 - WHEN a user creates a new Thread for a Project, THE CLI SHALL create a new clone of the Project's git repository
-     * - 2.2 - WHEN a Thread is created, THE App SHALL display it under its parent Project in the Side_Panel
-     * - 2.4 - THE System SHALL maintain a title for each Thread
-     * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
-     */
-    createThread(projectId: string, title?: string): AsyncGenerator<ThreadEvent>;
-    /**
-     * Gets a thread by ID
-     * @param threadId - The thread ID
-     * @returns The thread or null if not found
-     */
-    getThread(threadId: string): Promise<Thread | null>;
-    /**
-     * Lists all threads for a specific project
-     * @param projectId - The project ID to filter threads
-     * @returns Array of threads for the project
-     *
-     * Requirements:
-     * - 2.1 - WHEN a Thread is created, THE App SHALL display it under its parent Project in the Side_Panel
-     */
-    listThreads(projectId: string): Promise<Thread[]>;
-    /**
-     * Deletes a thread and removes its directory
-     *
-     * This method:
-     * 1. Finds the thread by ID
-     * 2. Removes the thread directory from filesystem
-     * 3. Removes the thread from metadata
-     * 4. Updates the parent project's thread list
-     * 5. Marks the thread as deleted in the database
-     *
-     * @param threadId - The thread ID to delete
-     * @throws Error if thread not found
-     *
-     * Requirements:
-     * - 2.3 - WHEN a user deletes a Thread, THE System SHALL remove the Thread's folder and update the Side_Panel display
-     * - 7.5 - WHEN a Thread is deleted, THE CLI SHALL remove the associated git repository clone from the filesystem
-     */
-    deleteThread(threadId: string): Promise<void>;
-    /**
-     * Updates a thread's metadata with partial data
-     *
-     * This method loads all threads, finds the target, merges the updates,
-     * and persists the result.
-     *
-     * @param threadId - The thread ID to update
-     * @param updates - Partial thread data to merge
-     * @throws Error if thread not found or model format is invalid
-     */
-    updateThread(threadId: string, updates: Partial<Omit<Thread, "id">>): Promise<void>;
-    /**
-     * Selects a thread as the active thread
-     *
-     * @param threadId - The thread ID to select
-     */
-    selectThread(threadId: string): Promise<void>;
-    /**
-     * Gets the currently selected thread ID
-     *
-     * @returns The selected thread ID or null
-     */
-    getSelectedThreadId(): Promise<string | null>;
-    /**
-     * Runs a setup script in the given path and yields progress events
-     * @param threadPath - Path to run the command in
-     * @param commandLine - The command to execute
-     * @yields ThreadEvent progress events
-     */
-    private runSetupScript;
-    /**
-     * Generates a unique thread path
-     *
-     * Path format: {dataDir}/{threadId}
-     *
-     * This ensures thread paths are unique across all projects and threads.
-     *
-     * @param projectPath - The parent project path
-     * @param threadId - The thread ID
-     * @returns The absolute path to the thread folder
-     *
-     * Requirements:
-     * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
-     */
-    private generateThreadPath;
-    /**
-     * Generates a thread title if not provided
-     *
-     * Format: {word1}-{word2} where words are random from a curated list
-     *
-     * @param existingTitles - Set of titles already in use for this project
-     * @returns The generated thread title (e.g. bouncy-panda, sparkly-taco)
-     */
-    private generateThreadTitle;
-    /**
-     * Lists all files in a thread's directory (tracked and untracked, but not ignored)
-     * @param threadId - The thread ID
-     * @returns Array of file paths relative to the thread root
-     */
-    listFiles(threadId: string): Promise<string[]>;
-}
-//# sourceMappingURL=threads.manager.d.ts.map