tarsk 0.4.4 → 0.4.6

package/dist/features/threads/threads.manager.js

@@ -1,505 +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 { randomUUID } from "crypto";
-import { join } from "path";
-import { execSync } from "child_process";
-import { spawnProcess } from "../../core/utils.js";
-import { rm, stat, mkdir } from "fs/promises";
-import { generateRandomThreadName } from '../../core/random-words.js';
-import { getDatabase } from '../../database/database.js';
-import { deleteThread as deleteThreadFromDb } from './threads.database.js';
-/**
- * ThreadManagerImpl provides the implementation for thread operations
- */
-export class ThreadManagerImpl {
-    metadataManager;
-    gitManager;
-    processingStateManager;
-    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, gitManager, processingStateManager, rootFolder = "") {
-        this.metadataManager = metadataManager;
-        this.gitManager = gitManager;
-        this.processingStateManager = processingStateManager;
-        this.rootFolder = rootFolder;
-    }
-    /**
-     * 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
-     */
-    async *createThread(projectId, title) {
-        let threadId;
-        try {
-            // Load project to verify it exists and get git URL
-            const projects = await this.metadataManager.loadProjects();
-            const project = projects.find((p) => p.id === projectId);
-            if (!project) {
-                yield {
-                    type: "error",
-                    message: `Project not found: ${projectId}`,
-                };
-                return;
-            }
-            // Create project directory if it doesn't exist
-            try {
-                await stat(project.path);
-            }
-            catch {
-                // Create the project directory if it doesn't exist
-                await mkdir(project.path, { recursive: true });
-            }
-            // Generate unique thread ID
-            threadId = randomUUID();
-            // Generate thread path: {rootFolder}/{threadId}
-            const threadPath = this.generateThreadPath(projectId, threadId);
-            // Generate thread title if not provided
-            const existingThreads = await this.metadataManager.loadThreads();
-            const existingTitles = new Set(existingThreads.filter((t) => t.projectId === projectId).map((t) => t.title));
-            const threadTitle = title ?? this.generateThreadTitle(existingTitles);
-            this.processingStateManager?.setProcessing(threadId);
-            yield {
-                type: "progress",
-                message: `Creating thread "${threadTitle}" for project "${project.name}"...`,
-                threadId,
-            };
-            yield {
-                type: "progress",
-                message: `Cloning repository to ${threadPath}...`,
-            };
-            // Handle git clone or directory copy based on project type
-            if (this.gitManager.validateGitUrl(project.gitUrl)) {
-                // Project has valid git URL - clone from git
-                yield {
-                    type: "progress",
-                    message: `Cloning repository to ${threadPath}...`,
-                };
-                for await (const gitEvent of this.gitManager.cloneRepository(project.gitUrl, threadPath)) {
-                    if (gitEvent.type === "error") {
-                        this.processingStateManager?.clearProcessing(threadId);
-                        yield {
-                            type: "error",
-                            message: `Git clone failed: ${gitEvent.message}`,
-                        };
-                        return;
-                    }
-                    else if (gitEvent.type === "stdout" || gitEvent.type === "stderr") {
-                        yield {
-                            type: "progress",
-                            message: gitEvent.data,
-                        };
-                    }
-                }
-            }
-            else {
-                // Project has no valid git URL (scaffolded project) - copy directory
-                yield {
-                    type: "progress",
-                    message: `Copying project files to ${threadPath}...`,
-                };
-                try {
-                    // Check if source directory exists
-                    // Create source directory if it doesn't exist
-                    try {
-                        await stat(project.path);
-                    }
-                    catch {
-                        // Create source directory if it doesn't exist
-                        await mkdir(project.path, { recursive: true });
-                    }
-                    // Use cp command for recursive copy (works on Unix-like systems and Windows with modern Node.js)
-                    if (process.platform === "win32") {
-                        execSync(`xcopy "${project.path}" "${threadPath}" /E /I /H /Y`, { stdio: "pipe" });
-                    }
-                    else {
-                        execSync(`cp -r "${project.path}" "${threadPath}"`, { stdio: "pipe" });
-                    }
-                    yield {
-                        type: "progress",
-                        message: `Project files copied successfully`,
-                    };
-                }
-                catch (error) {
-                    this.processingStateManager?.clearProcessing(threadId);
-                    yield {
-                        type: "error",
-                        message: `Failed to copy project files: ${error instanceof Error ? error.message : String(error)}`,
-                    };
-                    return;
-                }
-            }
-            // Sanitize the thread title to create a valid branch name
-            let branchName = this.gitManager.sanitizeBranchName(threadTitle);
-            yield {
-                type: "progress",
-                message: `Creating branch "${branchName}"...`,
-            };
-            // Check if branch exists and find a unique name if needed
-            let branchExists = await this.gitManager.checkBranchExists(threadPath, branchName);
-            let counter = 2;
-            const baseBranchName = branchName;
-            while (branchExists) {
-                branchName = `${baseBranchName}-${counter}`;
-                branchExists = await this.gitManager.checkBranchExists(threadPath, branchName);
-                counter++;
-            }
-            if (branchName !== baseBranchName) {
-                yield {
-                    type: "progress",
-                    message: `Branch "${baseBranchName}" exists, using "${branchName}" instead`,
-                };
-            }
-            // Create and checkout the new branch
-            for await (const gitEvent of this.gitManager.createAndCheckoutBranch(threadPath, branchName)) {
-                if (gitEvent.type === "error") {
-                    this.processingStateManager?.clearProcessing(threadId);
-                    yield {
-                        type: "error",
-                        message: `Failed to create branch: ${gitEvent.message}`,
-                    };
-                    return;
-                }
-                else if (gitEvent.type === "stdout" || gitEvent.type === "stderr") {
-                    yield {
-                        type: "progress",
-                        message: gitEvent.data,
-                    };
-                }
-            }
-            yield {
-                type: "progress",
-                message: `Branch "${branchName}" created and checked out`,
-            };
-            // Run setup script if project has one configured
-            if (project.setupScript) {
-                yield {
-                    type: "progress",
-                    message: `Running setup script: ${project.setupScript}`,
-                };
-                for await (const event of this.runSetupScript(threadPath, project.setupScript)) {
-                    yield event;
-                }
-            }
-            // Create thread metadata
-            const thread = {
-                id: threadId,
-                projectId,
-                title: threadTitle,
-                path: threadPath,
-                currentBranch: branchName,
-                createdAt: new Date(),
-            };
-            // Save thread metadata
-            const threads = await this.metadataManager.loadThreads();
-            threads.push(thread);
-            await this.metadataManager.saveThreads(threads);
-            // Update project's thread list
-            project.threads.push(threadId);
-            const updatedProjects = projects.map((p) => (p.id === projectId ? project : p));
-            await this.metadataManager.saveProjects(updatedProjects);
-            yield {
-                type: "progress",
-                message: `Thread "${threadTitle}" created successfully`,
-            };
-            // Yield complete event with thread data
-            this.processingStateManager?.clearProcessing(threadId);
-            yield {
-                type: "complete",
-                message: "Thread creation complete",
-                thread,
-            };
-        }
-        catch (error) {
-            if (typeof threadId !== "undefined") {
-                this.processingStateManager?.clearProcessing(threadId);
-            }
-            yield {
-                type: "error",
-                message: `Failed to create thread: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    /**
-     * Gets a thread by ID
-     * @param threadId - The thread ID
-     * @returns The thread or null if not found
-     */
-    async getThread(threadId) {
-        const threads = await this.metadataManager.loadThreads();
-        return threads.find((t) => t.id === threadId) ?? 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
-     */
-    async listThreads(projectId) {
-        const threads = await this.metadataManager.loadThreads();
-        return threads.filter((t) => t.projectId === projectId);
-    }
-    /**
-     * 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
-     */
-    async deleteThread(threadId) {
-        const threads = await this.metadataManager.loadThreads();
-        const threadIndex = threads.findIndex((t) => t.id === threadId);
-        if (threadIndex === -1) {
-            throw new Error(`Thread not found: ${threadId}`);
-        }
-        const thread = threads[threadIndex];
-        // Remove thread directory from filesystem
-        try {
-            await rm(thread.path, { recursive: true, force: true });
-        }
-        catch (error) {
-            throw new Error(`Failed to remove thread directory: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Remove thread from metadata
-        threads.splice(threadIndex, 1);
-        await this.metadataManager.saveThreads(threads);
-        // Update parent project's thread list
-        const projects = await this.metadataManager.loadProjects();
-        const project = projects.find((p) => p.id === thread.projectId);
-        if (project) {
-            project.threads = project.threads.filter((id) => id !== threadId);
-            await this.metadataManager.saveProjects(projects);
-        }
-        // Mark thread as deleted in database
-        try {
-            const db = await getDatabase();
-            await deleteThreadFromDb(db, threadId);
-        }
-        catch (error) {
-            // Log error but don't fail the operation since the thread is already deleted from filesystem and metadata
-            console.error(`Failed to mark thread as deleted in database: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * 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
-     */
-    async updateThread(threadId, updates) {
-        const threads = await this.metadataManager.loadThreads();
-        const threadIndex = threads.findIndex((t) => t.id === threadId);
-        if (threadIndex === -1) {
-            throw new Error(`Thread not found: ${threadId}`);
-        }
-        // Validate model format if present
-        if (updates.model && !updates.modelProvider) {
-            throw new Error(`Invalid model: "${updates.model} provider:${updates.modelProvider}". Model must be in format "{provider}/{model}" (e.g., "openrouter/anthropic/claude-3-5-sonnet-20241022")`);
-        }
-        threads[threadIndex] = { ...threads[threadIndex], ...updates };
-        await this.metadataManager.saveThreads(threads);
-    }
-    /**
-     * Selects a thread as the active thread
-     *
-     * @param threadId - The thread ID to select
-     */
-    async selectThread(threadId) {
-        await this.metadataManager.setSelectedThread(threadId);
-    }
-    /**
-     * Gets the currently selected thread ID
-     *
-     * @returns The selected thread ID or null
-     */
-    async getSelectedThreadId() {
-        return await this.metadataManager.getSelectedThread();
-    }
-    /**
-     * 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
-     */
-    async *runSetupScript(threadPath, commandLine) {
-        const child = spawnProcess(commandLine, [], {
-            shell: true,
-            cwd: threadPath,
-        });
-        const decoder = new TextDecoder();
-        let resolveNext = () => { };
-        const outputQueue = [];
-        const errorQueue = [];
-        child.stdout?.on("data", (data) => {
-            outputQueue.push(decoder.decode(data));
-            resolveNext();
-        });
-        child.stderr?.on("data", (data) => {
-            errorQueue.push(decoder.decode(data));
-            resolveNext();
-        });
-        let isDone = false;
-        child.on("close", (code) => {
-            if (code !== 0) {
-                errorQueue.push(`Process exited with code ${code}`);
-            }
-            isDone = true;
-            resolveNext();
-        });
-        child.on("error", (err) => {
-            errorQueue.push(err.message);
-            isDone = true;
-            resolveNext();
-        });
-        const waitForData = () => new Promise((resolve) => {
-            resolveNext = resolve;
-        });
-        while (!isDone || outputQueue.length > 0 || errorQueue.length > 0) {
-            if (outputQueue.length > 0) {
-                const text = outputQueue.shift();
-                for (const line of text.split("\n").filter((l) => l.trim())) {
-                    yield { type: "progress", message: line };
-                }
-            }
-            else if (errorQueue.length > 0) {
-                const text = errorQueue.shift();
-                for (const line of text.split("\n").filter((l) => l.trim())) {
-                    yield { type: "progress", message: line };
-                }
-            }
-            else {
-                await waitForData();
-            }
-        }
-    }
-    /**
-     * 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
-     */
-    generateThreadPath(_projectId, threadId) {
-        return join(this.rootFolder, threadId);
-    }
-    /**
-     * 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)
-     */
-    generateThreadTitle(existingTitles) {
-        // Generate a random name, ensuring it doesn't already exist
-        let threadTitle = generateRandomThreadName();
-        let attempts = 0;
-        const maxAttempts = 100;
-        while (existingTitles.has(threadTitle) && attempts < maxAttempts) {
-            threadTitle = generateRandomThreadName();
-            attempts++;
-        }
-        return threadTitle;
-    }
-    /**
-     * 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
-     */
-    async listFiles(threadId) {
-        const thread = await this.getThread(threadId);
-        if (!thread) {
-            throw new Error(`Thread not found: ${threadId}`);
-        }
-        return new Promise((resolve, reject) => {
-            // --cached: tracked files
-            // --others: untracked files
-            // --exclude-standard: respect .gitignore
-            const gitProcess = spawnProcess("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
-                cwd: thread.path,
-            });
-            let output = "";
-            let errorOutput = "";
-            gitProcess.stdout?.on("data", (data) => {
-                output += data.toString();
-            });
-            gitProcess.stderr?.on("data", (data) => {
-                errorOutput += data.toString();
-            });
-            gitProcess.on("close", (code) => {
-                if (code === 0) {
-                    const files = output
-                        .split("\n")
-                        .map((line) => line.trim())
-                        .filter((line) => line.length > 0);
-                    resolve(files);
-                }
-                else {
-                    reject(new Error(`git ls-files failed with code ${code}: ${errorOutput}`));
-                }
-            });
-            gitProcess.on("error", (err) => {
-                reject(new Error(`Failed to start git process: ${err.message}`));
-            });
-        });
-    }
-}
-//# sourceMappingURL=threads.manager.js.map

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

@@ -1,20 +0,0 @@
-/**
- * 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 type { ThreadManager } from "./threads.manager.js";
-import type { ConversationManager } from "../conversations/conversations.manager.js";
-import type { GitManager } from "../git/git.manager.js";
-/**
- * Creates thread routes
- * @param threadManager - The ThreadManager instance
- * @param gitManager - The GitManager instance
- * @returns Hono router with thread routes
- */
-export declare function createThreadRoutes(threadManager: ThreadManager, gitManager: GitManager, conversationManager: ConversationManager): Hono;
-//# sourceMappingURL=threads.routes.d.ts.map