tarsk 0.2.5 → 0.3.0

package/dist/managers/neovate-executor.js

@@ -0,0 +1,205 @@
+/**
+ * NeovateExecutor handles execution of neovate commands via the @neovate/code SDK
+ *
+ * This manager is responsible for:
+ * - Executing streaming sessions via the SDK
+ * - Streaming result messages back to the caller
+ * - Handling execution errors
+ */
+import { createSession, } from "@neovate/code";
+import { resolve } from "path";
+import { PROVIDERS } from "../provider.js";
+const getErrorCode = (error) => {
+    if (error && typeof error === "object" && "code" in error) {
+        const code = error.code;
+        if (typeof code === "string") {
+            return code;
+        }
+    }
+    return undefined;
+};
+/**
+ * NeovateExecutorImpl provides the implementation for neovate command execution
+ * using the @neovate/code SDK with streaming sessions.
+ */
+export class NeovateExecutorImpl {
+    metadataManager;
+    constructor(metadataManager) {
+        this.metadataManager = metadataManager;
+    }
+    /**
+     * Executes a neovate prompt using the SDK via streaming sessions
+     *
+     * @param userPrompt - The user's message/prompt to send to neovate
+     * @param context - ExecutionContext with threadId, threadPath, model, and attachments
+     * @yields NeovateEvent objects for message, result, and error events
+     *
+     * Requirements:
+     * - 5.2 - WHEN the CLI receives a chat message, THE CLI SHALL execute the Neovate command
+     * - 5.4 - WHEN the Neovate command executes, THE CLI SHALL stream the output back to the App
+     */
+    async *execute(userPrompt, context) {
+        let session = null;
+        try {
+            // Get the provider name from context (defaults to 'openrouter')
+            const providerName = context.provider;
+            if (!providerName) {
+                console.error(`[ai] No provider specified in context`);
+                throw new Error("No provider specified in execution context");
+            }
+            // Ensure model is always defined
+            // The model is passed from the frontend (e.g., "openrouter/minimax/minimax-m2.1")
+            // We'll validate and ensure it's properly formatted for the SDK
+            let model = context.model?.trim();
+            if (!model) {
+                console.warn("[ai] No model provided in context, using default");
+                throw new Error("No model specified in execution context");
+            }
+            model = model.replace(`${providerName.toLowerCase()}/`, ""); // Remove provider prefix if present
+            const cwd = resolve(context.threadPath);
+            console.log("[ai] Execution context:", {
+                model,
+                cwd,
+                providerName,
+                promptLength: userPrompt.length,
+            });
+            // Get the provider configuration first to access environment variable name
+            const providerConfig = PROVIDERS.find((p) => p.name.toLowerCase() === providerName.toLowerCase());
+            if (!providerConfig) {
+                throw new Error(`Unknown provider: ${providerName}`);
+            }
+            // Try to get API key from environment variables first (takes precedence)
+            let apiKey = providerConfig.keyName ? process.env[providerConfig.keyName] : undefined;
+            let apiKeySource = 'environment';
+            // Fall back to metadata manager if not in environment
+            if (!apiKey) {
+                const providerKeys = await this.metadataManager.getProviderKeys();
+                apiKey = providerKeys[providerConfig.name];
+                apiKeySource = 'configuration';
+            }
+            if (!apiKey) {
+                throw new Error(`No API key found for provider: ${providerName}. ` +
+                    `Set ${providerConfig.keyName || 'an API key'} in environment variables or configuration.`);
+            }
+            console.log(`[ai] API key source for ${providerName}: ${apiKeySource}`);
+            const api = providerConfig.api;
+            if (!api) {
+                throw new Error(`No API URL configured for provider: ${providerName}`);
+            }
+            const providers = {
+                tarsk: {
+                    api,
+                    options: { apiKey: apiKey },
+                    models: { [model]: model },
+                },
+            };
+            const sessionConfig = {
+                model: `tarsk/${model}`,
+                cwd,
+                productName: "Tarsk.io",
+                providers,
+            };
+            console.log("[ai] Creating session:", JSON.stringify(sessionConfig));
+            console.log("[ai] Creating session with model:", model);
+            console.log("[ai] Session config has model:", !!sessionConfig.model);
+            // Create a streaming session - MUST have model defined
+            session = await createSession(sessionConfig);
+            if (!session) {
+                throw new Error("Failed to create session: createSession returned falsy value");
+            }
+            console.log("[ai] Session created:", session.sessionId);
+            // Send the user prompt to the session
+            console.log("[ai] Sending prompt to session...");
+            await session.send(userPrompt);
+            console.log("[ai] Prompt sent, waiting for responses...");
+            // Stream messages from the session
+            let lastMessageContent = null;
+            for await (const msg of session.receive()) {
+                const contentLength = typeof msg?.content === "string" ? msg.content.length : undefined;
+                console.log("[ai] Received msg:", { type: msg?.type, contentLength });
+                console.log("[ai] Msg:", msg);
+                if (msg?.type === "message") {
+                    // Yield conversation messages (assistant responses)
+                    // Use .text property if available (SDK provides both .content and .text)
+                    const messageContent = typeof msg.text === "string"
+                        ? msg.text
+                        : typeof msg.content === "string"
+                            ? msg.content
+                            : JSON.stringify(msg.content);
+                    lastMessageContent = messageContent;
+                    yield {
+                        type: "message",
+                        role: msg.role || "assistant",
+                        content: messageContent,
+                    };
+                }
+                else if (msg?.type === "result") {
+                    // Check if result content is a duplicate of the last message
+                    const resultContent = typeof msg.content === "string"
+                        ? msg.content
+                        : JSON.stringify(msg.content);
+                    // Skip result if it's identical to the last message (avoid duplicate)
+                    if (resultContent !== lastMessageContent) {
+                        // Yield the final result only if it's different from the message
+                        yield {
+                            type: "result",
+                            content: resultContent,
+                        };
+                    }
+                    else {
+                        console.log("[ai] Skipping duplicate result event (same as message)");
+                    }
+                    break; // Exit the loop after receiving the result
+                }
+            }
+        }
+        catch (error) {
+            console.error("[ai] Error during execution:", error);
+            let errCode;
+            let errMessage;
+            let errStack;
+            let errDetails;
+            if (error instanceof Error) {
+                errMessage = error.message || "Unknown error";
+                errStack = error.stack;
+                errCode = getErrorCode(error);
+            }
+            else if (typeof error === "object" && error !== null) {
+                errMessage = error.message
+                    ? String(error.message)
+                    : JSON.stringify(error);
+                errCode = getErrorCode(error);
+                errDetails = error;
+            }
+            else if (typeof error === "string") {
+                errMessage = error;
+            }
+            else {
+                errMessage = String(error);
+            }
+            console.error("[ai] Error details:", { errCode, errMessage, errStack });
+            yield {
+                type: "error",
+                content: errMessage,
+                error: {
+                    code: errCode || "EXECUTION_ERROR",
+                    message: errMessage || "An error occurred during execution",
+                    details: { stack: errStack, originalError: errDetails },
+                },
+            };
+        }
+        finally {
+            // Ensure the session is properly closed
+            if (session) {
+                try {
+                    await session.close?.();
+                    console.log("[ai] Session closed");
+                }
+                catch (closeError) {
+                    console.error("[ai] Error closing session:", closeError);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=neovate-executor.js.map

package/dist/managers/processing-state-manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ProcessingStateManager tracks which threads currently have active chat processing
+ *
+ * This is an in-memory store that tracks thread IDs that are currently
+ * processing chat messages. The frontend can poll this to show/hide spinners.
+ */
+export interface ProcessingStateManager {
+    /**
+     * Mark a thread as currently processing
+     * @param threadId - The thread ID that started processing
+     */
+    setProcessing(threadId: string): void;
+    /**
+     * Mark a thread as no longer processing
+     * @param threadId - The thread ID that finished processing
+     */
+    clearProcessing(threadId: string): void;
+    /**
+     * Check if a thread is currently processing
+     * @param threadId - The thread ID to check
+     * @returns true if the thread is processing
+     */
+    isProcessing(threadId: string): boolean;
+    /**
+     * Get all thread IDs that are currently processing
+     * @returns Array of thread IDs
+     */
+    getProcessingThreadIds(): string[];
+}
+/**
+ * Implementation of ProcessingStateManager using an in-memory Set
+ */
+export declare class ProcessingStateManagerImpl implements ProcessingStateManager {
+    private processingThreads;
+    setProcessing(threadId: string): void;
+    clearProcessing(threadId: string): void;
+    isProcessing(threadId: string): boolean;
+    getProcessingThreadIds(): string[];
+}
+//# sourceMappingURL=processing-state-manager.d.ts.map

package/dist/managers/processing-state-manager.js

@@ -0,0 +1,27 @@
+/**
+ * ProcessingStateManager tracks which threads currently have active chat processing
+ *
+ * This is an in-memory store that tracks thread IDs that are currently
+ * processing chat messages. The frontend can poll this to show/hide spinners.
+ */
+/**
+ * Implementation of ProcessingStateManager using an in-memory Set
+ */
+export class ProcessingStateManagerImpl {
+    processingThreads = new Set();
+    setProcessing(threadId) {
+        this.processingThreads.add(threadId);
+        console.log(`[ProcessingState] Thread ${threadId} started processing. Active: ${this.processingThreads.size}`);
+    }
+    clearProcessing(threadId) {
+        this.processingThreads.delete(threadId);
+        console.log(`[ProcessingState] Thread ${threadId} finished processing. Active: ${this.processingThreads.size}`);
+    }
+    isProcessing(threadId) {
+        return this.processingThreads.has(threadId);
+    }
+    getProcessingThreadIds() {
+        return Array.from(this.processingThreads);
+    }
+}
+//# sourceMappingURL=processing-state-manager.js.map

package/dist/managers/project-manager.d.ts

@@ -0,0 +1,199 @@
+/**
+ * ProjectManager handles project lifecycle and metadata management
+ *
+ * This manager is responsible for:
+ * - Creating new projects from git URLs
+ * - Managing project metadata
+ * - Coordinating with GitManager for repository cloning
+ * - Providing CRUD operations for projects
+ */
+import { Project, ProjectEvent, Command } from '../types/models.js';
+import { MetadataManager } from './metadata-manager.js';
+import { GitManager } from './git-manager.js';
+/**
+ * ProjectManager interface defines the contract for project operations
+ */
+export interface ProjectManager {
+    /**
+     * Creates a new project from a git URL
+     * @param gitUrl - The git repository URL
+     * @yields ProjectEvent objects during the creation process
+     */
+    createProject(gitUrl: string): AsyncGenerator<ProjectEvent>;
+    /**
+     * Gets a project by ID
+     * @param projectId - The project ID
+     * @returns The project or null if not found
+     */
+    getProject(projectId: string): Promise<Project | null>;
+    /**
+     * Lists all projects
+     * @returns Array of all projects
+     */
+    listProjects(): Promise<Project[]>;
+    /**
+     * Deletes a project and all its threads
+     * @param projectId - The project ID to delete
+     */
+    deleteProject(projectId: string): Promise<void>;
+    /**
+     * Opens a project in the specified program
+     * @param projectId - The project ID
+     * @param program - The program to open the project in
+     */
+    openWith(projectId: string, program: string): Promise<void>;
+    /**
+     * Updates the project's open-with program preference
+     * @param projectId - The project ID
+     * @param program - The program name to set
+     */
+    updateOpenWith(projectId: string, program: string): Promise<void>;
+    /**
+     * Saves (adds or updates) a command for a project
+     * @param projectId - The project ID
+     * @param command - The command to save
+     */
+    saveCommand(projectId: string, command: Command): Promise<void>;
+    /**
+     * Deletes a command from a project
+     * @param projectId - The project ID
+     * @param commandId - The ID of the command to delete
+     */
+    deleteCommand(projectId: string, commandId: string): Promise<void>;
+    /**
+     * Runs a command in a thread's directory
+     * @param threadId - The thread ID where to run the command
+     * @param commandLine - The command line to execute
+     * @param cwd - Optional working directory relative to thread path
+     */
+    runCommand(threadId: string, commandLine: string, cwd?: string): AsyncGenerator<unknown>;
+}
+/**
+ * ProjectManagerImpl provides the implementation for project operations
+ */
+export declare class ProjectManagerImpl implements ProjectManager {
+    private rootFolder;
+    private metadataManager;
+    private gitManager;
+    /**
+     * Create a new ProjectManager
+     * @param rootFolder - Base directory where projects will be stored
+     * @param metadataManager - Manager for persisting metadata
+     * @param gitManager - Manager for git operations
+     *
+     * Requirements:
+     * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository into a folder under the Root_Folder
+     * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
+     */
+    constructor(rootFolder: string, metadataManager: MetadataManager, gitManager: GitManager);
+    /**
+     * Creates a new project from a git URL
+     *
+     * This method:
+     * 1. Validates the git URL
+     * 2. Generates a unique project ID
+     * 3. Derives the project name from the git URL
+     * 4. Generates the project path
+     * 5. Delegates to GitManager for cloning
+     * 6. Saves project metadata
+     * 7. Yields progress events during the operation
+     * 8. Creates an initial thread automatically
+     *
+     * @param gitUrl - The git repository URL
+     * @yields ProjectEvent objects during the creation process
+     *
+     * Requirements:
+     * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository into a folder under the Root_Folder
+     * - 1.2 - WHEN a Project is created, THE App SHALL display the Project in the Side_Panel with its associated Thread
+     * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
+     * - 1.5 - WHEN a Project folder is created, THE System SHALL associate it with the provided git URL
+     */
+    createProject(gitUrl: string): AsyncGenerator<ProjectEvent>;
+    /**
+     * Gets a project by ID
+     * @param projectId - The project ID
+     * @returns The project or null if not found
+     */
+    getProject(projectId: string): Promise<Project | null>;
+    /**
+     * Lists all projects
+     * @returns Array of all projects
+     */
+    listProjects(): Promise<Project[]>;
+    /**
+     * Deletes a project and all its threads (cascade delete)
+     *
+     * This method:
+     * 1. Finds the project by ID
+     * 2. Removes all associated threads from metadata
+     * 3. Removes the project directory from filesystem
+     * 4. Removes the project from metadata
+     *
+     * @param projectId - The project ID to delete
+     * @throws Error if project not found
+     *
+     * Requirements:
+     * - 1.1 - Cascade delete for projects (remove all threads)
+     */
+    deleteProject(projectId: string): Promise<void>;
+    /**
+     * Derives a project name from a git URL
+     *
+     * Examples:
+     * - https://github.com/user/repo.git -> repo
+     * - https://github.com/user/repo -> repo
+     * - git@github.com:user/repo.git -> repo
+     *
+     * @param gitUrl - The git URL
+     * @returns The derived project name
+     */
+    private deriveProjectName;
+    /**
+     * Generates a project path under the root folder
+     *
+     * @param projectName - The project name
+     * @returns The absolute path to the project folder
+     *
+     * Requirements:
+     * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
+     */
+    private generateProjectPath;
+    /**
+     * Gets the root folder path
+     * @returns The root folder path
+     */
+    getRootFolder(): string;
+    /**
+     * Opens a project in the specified program
+     *
+     * @param projectId - The project ID
+     * @param program - The program to open the project in (VS Code, Cursor, Windsurf, Xcode, Android Studio, Kiro)
+     */
+    openWith(projectId: string, program: string): Promise<void>;
+    /**
+     * Updates the project's open-with program preference
+     *
+     * @param projectId - The project ID
+     * @param program - The program name to set
+     */
+    updateOpenWith(projectId: string, program: string): Promise<void>;
+    /**
+     * Saves (adds or updates) a command for a project
+     * @param projectId - The project ID
+     * @param command - The command to save
+     */
+    saveCommand(projectId: string, command: Command): Promise<void>;
+    /**
+     * Deletes a command from a project
+     * @param projectId - The project ID
+     * @param commandId - The ID of the command to delete
+     */
+    deleteCommand(projectId: string, commandId: string): Promise<void>;
+    /**
+     * Runs a command in a thread's directory
+     * @param threadId - The thread ID where to run the command
+     * @param commandLine - The command line to execute
+     */
+    runCommand(threadId: string, commandLine: string, cwd?: string): AsyncGenerator<unknown>;
+}
+//# sourceMappingURL=project-manager.d.ts.map