tarsk 0.3.3 → 0.3.16

package/dist/managers/ThreadManager.js

@@ -1,325 +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';
-/**
- * ThreadManagerImpl provides the implementation for thread operations
- */
-export class ThreadManagerImpl {
-    metadataManager;
-    gitManager;
-    /**
-     * Create a new ThreadManager
-     * @param metadataManager - Manager for persisting metadata
-     * @param gitManager - Manager for git operations
-     *
-     * 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) {
-        this.metadataManager = metadataManager;
-        this.gitManager = gitManager;
-    }
-    /**
-     * 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) {
-        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;
-            }
-            // Generate unique thread ID
-            const threadId = randomUUID();
-            // Generate thread path: {projectPath}/{threadId}
-            const threadPath = this.generateThreadPath(project.path, 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, threadId, project.name);
-            yield {
-                type: 'progress',
-                message: `Creating thread "${threadTitle}" for project "${project.name}"...`
-            };
-            yield {
-                type: 'progress',
-                message: `Cloning repository to ${threadPath}...`
-            };
-            // Stream git clone events
-            for await (const gitEvent of this.gitManager.cloneRepository(project.gitUrl, threadPath)) {
-                if (gitEvent.type === 'error') {
-                    yield {
-                        type: 'error',
-                        message: `Git clone failed: ${gitEvent.message}`
-                    };
-                    return;
-                }
-                else if (gitEvent.type === 'stdout' || gitEvent.type === 'stderr') {
-                    yield {
-                        type: 'progress',
-                        message: gitEvent.data
-                    };
-                }
-            }
-            // 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') {
-                    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`
-            };
-            // 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
-            yield {
-                type: 'complete',
-                message: 'Thread creation complete',
-                thread
-            };
-        }
-        catch (error) {
-            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
-     *
-     * @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 {
-            const { rm } = await import('fs/promises');
-            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);
-        }
-    }
-    /**
-     * 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
-     */
-    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}`);
-        }
-        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();
-    }
-    /**
-     * Generates a unique thread path
-     *
-     * Path format: {projectPath}/{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(projectPath, threadId) {
-        return join(projectPath, threadId);
-    }
-    /**
-     * Generates a thread title if not provided
-     *
-     * Format: project-name Thread word1-word2
-     *
-     * @param existingTitles - Set of titles already in use
-     * @param threadId - Thread ID used as a fallback
-     * @param projectName - Optional project name to include in title
-     * @returns The generated thread title
-     */
-    generateThreadTitle(existingTitles, threadId, projectName) {
-        const wordsA = [
-            'amber', 'brisk', 'calm', 'drift', 'ember', 'frost', 'glow', 'hollow',
-            'ivory', 'jolly', 'keen', 'lucid', 'mellow', 'noble', 'opal', 'prism',
-            'quiet', 'ripple', 'sunny', 'timber', 'ultra', 'vivid', 'wisp', 'zen'
-        ];
-        const wordsB = [
-            'arch', 'bay', 'crest', 'dune', 'echo', 'fjord', 'glen', 'harbor',
-            'isle', 'jewel', 'knoll', 'lagoon', 'mesa', 'nest', 'oasis', 'peak',
-            'quarry', 'reef', 'strand', 'trail', 'vale', 'wharf', 'yard', 'zephyr'
-        ];
-        const prefix = projectName ? `${projectName} Thread ` : 'Thread ';
-        for (let attempt = 0; attempt < 12; attempt += 1) {
-            const word1 = wordsA[Math.floor(Math.random() * wordsA.length)];
-            const word2 = wordsB[Math.floor(Math.random() * wordsB.length)];
-            const candidate = `${prefix}${word1}-${word2}`;
-            if (!existingTitles.has(candidate)) {
-                return candidate;
-            }
-        }
-        return `${prefix}${threadId.slice(0, 8)}`;
-    }
-}
-//# sourceMappingURL=ThreadManager.js.map

package/dist/model-info-openai.d.ts

@@ -1,17 +0,0 @@
-/**
- * OpenAI model info
- *
- * Provides model information (name, description) for OpenAI models.
- * Pricing is scraped from OpenAI's pricing page and cached locally for 24 hours.
- * Model names and descriptions are generated from model IDs (no API call needed).
- */
-import type { ModelInfo } from './model-info.js';
-/**
- * Get model info for OpenAI models
- *
- * @param modelIds - List of model IDs to get info for
- * @param cacheDir - Directory for caching pricing data (e.g., .metadata)
- * @returns Map of model ID -> ModelInfo (with name, description, and pricing if available)
- */
-export declare function getOpenAIModelInfo(modelIds: string[], cacheDir?: string): Promise<Map<string, ModelInfo>>;
-//# sourceMappingURL=model-info-openai.d.ts.map

package/dist/model-info-openai.js

@@ -1,59 +0,0 @@
-/**
- * OpenAI model info
- *
- * Provides model information (name, description) for OpenAI models.
- * Pricing is scraped from OpenAI's pricing page and cached locally for 24 hours.
- * Model names and descriptions are generated from model IDs (no API call needed).
- */
-import { getOpenAIPricing } from './utils/openai-pricing-scraper.js';
-/** Format OpenAI model id to a readable name (e.g. "gpt-4-turbo" -> "GPT-4 Turbo") */
-function formatOpenAIModelName(modelId) {
-    return modelId
-        .split('-')
-        .map((part) => {
-        if (part === 'gpt')
-            return 'GPT';
-        if (part === 'o')
-            return 'O';
-        if (part === part.toLowerCase() && /^\d+/.test(part)) {
-            return part.charAt(0).toUpperCase() + part.slice(1);
-        }
-        return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-    })
-        .join(' ')
-        .replace(/\s+/g, ' ');
-}
-/**
- * Get model info for OpenAI models
- *
- * @param modelIds - List of model IDs to get info for
- * @param cacheDir - Directory for caching pricing data (e.g., .metadata)
- * @returns Map of model ID -> ModelInfo (with name, description, and pricing if available)
- */
-export async function getOpenAIModelInfo(modelIds, cacheDir) {
-    const result = new Map();
-    // Fetch pricing from scraper if cache directory provided
-    let pricingByModel = new Map();
-    if (cacheDir) {
-        try {
-            pricingByModel = await getOpenAIPricing(cacheDir);
-            console.log('[OpenAI Models] Loaded pricing for', pricingByModel.size, 'models');
-        }
-        catch (error) {
-            console.error('[OpenAI Models] Error fetching pricing:', error);
-        }
-    }
-    // Generate model info for each requested model ID
-    for (const id of modelIds) {
-        const modelInfo = {
-            name: formatOpenAIModelName(id),
-            description: `OpenAI model: ${id}`,
-            pricing: pricingByModel.get(id),
-        };
-        console.log(`[OpenAI Models] Model ${id}:`, modelInfo);
-        result.set(id, modelInfo);
-    }
-    console.log('[OpenAI Models] Generated info for', result.size, 'models');
-    return result;
-}
-//# sourceMappingURL=model-info-openai.js.map