tarsk 0.2.5 → 0.3.0

package/dist/managers/MetadataManager.js

@@ -0,0 +1,309 @@
+/**
+ * MetadataManager handles persistence of project and thread metadata
+ *
+ * This manager provides JSON file-based storage with atomic writes
+ * to ensure data consistency even if the process crashes during write operations.
+ */
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+export class MetadataManager {
+    projectsFile;
+    threadsFile;
+    stateFile;
+    metadataDir;
+    /**
+     * Create a new MetadataManager
+     * @param rootFolder - Base directory where metadata will be stored
+     */
+    constructor(rootFolder) {
+        this.metadataDir = join(rootFolder, '.metadata');
+        this.projectsFile = join(this.metadataDir, 'projects.json');
+        this.threadsFile = join(this.metadataDir, 'threads.json');
+        this.stateFile = join(this.metadataDir, 'state.json');
+    }
+    /**
+     * Initialize metadata directory if it doesn't exist
+     */
+    async initialize() {
+        try {
+            await fs.mkdir(this.metadataDir, { recursive: true });
+            // Create empty files if they don't exist
+            try {
+                await fs.access(this.projectsFile);
+            }
+            catch {
+                await this.saveProjects([]);
+            }
+            try {
+                await fs.access(this.threadsFile);
+            }
+            catch {
+                await this.saveThreads([]);
+            }
+            try {
+                await fs.access(this.stateFile);
+            }
+            catch {
+                await this.saveState({ selectedThreadId: null, providerKeys: {}, enabledModels: {} });
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize metadata directory: ${error}`);
+        }
+    }
+    /**
+     * Save projects to disk using atomic write
+     * @param projects - Array of projects to save
+     */
+    async saveProjects(projects) {
+        await this.atomicWrite(this.projectsFile, projects);
+    }
+    /**
+     * Load projects from disk
+     * @returns Array of projects
+     */
+    async loadProjects() {
+        try {
+            const data = await fs.readFile(this.projectsFile, 'utf-8');
+            const projects = JSON.parse(data);
+            // Convert date strings back to Date objects
+            return projects.map((project) => ({
+                ...project,
+                createdAt: new Date(project.createdAt)
+            }));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist yet, return empty array
+                return [];
+            }
+            throw new Error(`Failed to load projects: ${error}`);
+        }
+    }
+    /**
+     * Save threads to disk using atomic write
+     * @param threads - Array of threads to save
+     */
+    async saveThreads(threads) {
+        console.log('[MetadataManager] Saving threads:', threads.map(t => ({
+            id: t.id,
+            title: t.title,
+        })));
+        await this.atomicWrite(this.threadsFile, threads);
+    }
+    /**
+     * Load threads from disk
+     * @returns Array of threads
+     */
+    async loadThreads() {
+        try {
+            const data = await fs.readFile(this.threadsFile, 'utf-8');
+            const threads = JSON.parse(data);
+            // Convert date strings back to Date objects
+            const result = threads.map((thread) => ({
+                ...thread,
+                createdAt: new Date(thread.createdAt)
+            }));
+            console.log('[MetadataManager] Loaded threads:', result.map((t) => ({
+                id: t.id,
+                title: t.title,
+            })));
+            return result;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist yet, return empty array
+                return [];
+            }
+            throw new Error(`Failed to load threads: ${error}`);
+        }
+    }
+    /**
+     * Perform atomic write using temp file
+     *
+     * This ensures that if the process crashes during write,
+     * we don't end up with corrupted or partial data.
+     *
+     * @param filePath - Target file path
+     * @param data - Data to write
+     */
+    async atomicWrite(filePath, data) {
+        const tempFile = `${filePath}.tmp`;
+        try {
+            // Ensure directory exists
+            await fs.mkdir(dirname(filePath), { recursive: true });
+            // Write to temp file
+            const jsonData = JSON.stringify(data, null, 2);
+            await fs.writeFile(tempFile, jsonData, 'utf-8');
+            // Atomic rename (overwrites target file)
+            await fs.rename(tempFile, filePath);
+        }
+        catch (error) {
+            // Clean up temp file if it exists
+            try {
+                await fs.unlink(tempFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw new Error(`Failed to write ${filePath}: ${error}`);
+        }
+    }
+    /**
+     * Get the metadata directory path
+     */
+    getMetadataDir() {
+        return this.metadataDir;
+    }
+    /**
+     * Get the projects file path
+     */
+    getProjectsFile() {
+        return this.projectsFile;
+    }
+    /**
+     * Get the threads file path
+     */
+    getThreadsFile() {
+        return this.threadsFile;
+    }
+    /**
+     * Save application state to disk
+     * @param state - Application state to save
+     */
+    async saveState(state) {
+        await this.atomicWrite(this.stateFile, state);
+    }
+    /**
+     * Load application state from disk
+     * @returns Application state
+     */
+    async loadState() {
+        try {
+            const data = await fs.readFile(this.stateFile, 'utf-8');
+            const state = JSON.parse(data);
+            // Ensure providerKeys exists
+            if (!state.providerKeys) {
+                state.providerKeys = {};
+            }
+            // Ensure enabledModels exists
+            if (!state.enabledModels) {
+                state.enabledModels = {};
+            }
+            return state;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return { selectedThreadId: null, providerKeys: {}, enabledModels: {} };
+            }
+            throw new Error(`Failed to load state: ${error}`);
+        }
+    }
+    /**
+     * Update all provider keys at once
+     * @param keys - Object mapping provider names to API keys
+     */
+    async saveAllProviderKeys(keys) {
+        const state = await this.loadState();
+        state.providerKeys = { ...state.providerKeys, ...keys };
+        await this.saveState(state);
+    }
+    /**
+     * Update provider keys
+     * @param providerName - Name of the provider
+     * @param apiKey - API key to save
+     */
+    async saveProviderKey(providerName, apiKey) {
+        const state = await this.loadState();
+        state.providerKeys[providerName] = apiKey;
+        await this.saveState(state);
+    }
+    /**
+     * Get all provider keys
+     * @returns Record of provider names to API keys
+     */
+    async getProviderKeys() {
+        const state = await this.loadState();
+        return state.providerKeys;
+    }
+    /**
+     * Set the selected thread ID
+     * @param threadId - Thread ID to select (or null to deselect)
+     */
+    async setSelectedThread(threadId) {
+        const state = await this.loadState();
+        state.selectedThreadId = threadId;
+        await this.saveState(state);
+    }
+    /**
+     * Get the selected thread ID
+     * @returns The selected thread ID or null
+     */
+    async getSelectedThread() {
+        const state = await this.loadState();
+        return state.selectedThreadId;
+    }
+    /**
+     * Enable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to enable
+     */
+    async enableModel(provider, modelId) {
+        const state = await this.loadState();
+        if (!state.enabledModels[provider]) {
+            state.enabledModels[provider] = [];
+        }
+        if (!state.enabledModels[provider].includes(modelId)) {
+            state.enabledModels[provider].push(modelId);
+        }
+        await this.saveState(state);
+    }
+    /**
+     * Disable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to disable
+     */
+    async disableModel(provider, modelId) {
+        const state = await this.loadState();
+        if (state.enabledModels[provider]) {
+            state.enabledModels[provider] = state.enabledModels[provider].filter((id) => id !== modelId);
+            if (state.enabledModels[provider].length === 0) {
+                delete state.enabledModels[provider];
+            }
+        }
+        await this.saveState(state);
+    }
+    /**
+     * Get enabled models for a provider
+     * @param provider - Provider name
+     * @returns Array of enabled model IDs
+     */
+    async getEnabledModels(provider) {
+        const state = await this.loadState();
+        return state.enabledModels[provider] || [];
+    }
+    /**
+     * Get all enabled models across all providers
+     * @returns Object mapping provider to array of model IDs
+     */
+    async getAllEnabledModels() {
+        const state = await this.loadState();
+        return state.enabledModels;
+    }
+    /**
+     * Set enabled models for a provider
+     * @param provider - Provider name
+     * @param modelIds - Array of model IDs to enable
+     */
+    async setEnabledModels(provider, modelIds) {
+        const state = await this.loadState();
+        if (modelIds.length === 0) {
+            delete state.enabledModels[provider];
+        }
+        else {
+            state.enabledModels[provider] = modelIds;
+        }
+        await this.saveState(state);
+    }
+}
+//# sourceMappingURL=MetadataManager.js.map

package/dist/managers/ModelManager.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ModelManager
+ *
+ * Manages available and enabled models across different providers
+ */
+import { Model } from '../types/models.js';
+import { MetadataManager } from './MetadataManager.js';
+/**
+ * ModelManager handles model availability and selection
+ */
+export declare class ModelManager {
+    private metadataManager;
+    /**
+     * Create a new ModelManager
+     * @param metadataManager - MetadataManager instance for persistence
+     */
+    constructor(metadataManager: MetadataManager);
+    /**
+     * Get available models for a provider
+     * @param provider - Provider name (e.g., "openrouter", "openai")
+     * @returns Array of Model objects
+     * @throws Error if provider is not supported
+     */
+    getAvailableModels(provider: string): Promise<Model[]>;
+    /**
+     * Get enabled models for a provider
+     * @param provider - Provider name
+     * @returns Array of Model objects that are enabled
+     */
+    getEnabledModels(provider: string): Promise<Model[]>;
+    /**
+     * Get a specific model by ID from a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID
+     * @returns Model object or null if not found
+     */
+    getModel(provider: string, modelId: string): Promise<Model | null>;
+    /**
+     * Enable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to enable
+     * @throws Error if model is not found
+     */
+    enableModel(provider: string, modelId: string): Promise<void>;
+    /**
+     * Disable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to disable
+     */
+    disableModel(provider: string, modelId: string): Promise<void>;
+    /**
+     * Get all enabled models across all providers
+     * @returns Object mapping provider to array of enabled Models
+     */
+    getAllEnabledModels(): Promise<Record<string, Model[]>>;
+}
+//# sourceMappingURL=ModelManager.d.ts.map

package/dist/managers/ModelManager.js

@@ -0,0 +1,129 @@
+/**
+ * ModelManager
+ *
+ * Manages available and enabled models across different providers
+ */
+import { PROVIDER_DATA } from '../provider-data.js';
+/**
+ * Convert provider model names to Model interface
+ * @param provider - Provider ID
+ * @param modelNames - Array of model name strings
+ * @returns Array of Model objects
+ */
+function convertProvidersToModels(provider, modelNames) {
+    return modelNames.map((modelId) => ({
+        id: modelId,
+        name: modelId, // Use model ID as name since provider-data doesn't have human-readable names
+        description: `${provider} model: ${modelId}`,
+        provider: provider,
+        pricing: {
+            prompt: 0,
+            completion: 0,
+        },
+    }));
+}
+/**
+ * ModelManager handles model availability and selection
+ */
+export class ModelManager {
+    metadataManager;
+    /**
+     * Create a new ModelManager
+     * @param metadataManager - MetadataManager instance for persistence
+     */
+    constructor(metadataManager) {
+        this.metadataManager = metadataManager;
+    }
+    /**
+     * Get available models for a provider
+     * @param provider - Provider name (e.g., "openrouter", "openai")
+     * @returns Array of Model objects
+     * @throws Error if provider is not supported
+     */
+    async getAvailableModels(provider) {
+        const providerData = PROVIDER_DATA.find(p => p.id === provider.toLowerCase());
+        if (!providerData) {
+            throw new Error(`Provider "${provider}" is not supported`);
+        }
+        return convertProvidersToModels(provider, providerData.models);
+    }
+    /**
+     * Get enabled models for a provider
+     * @param provider - Provider name
+     * @returns Array of Model objects that are enabled
+     */
+    async getEnabledModels(provider) {
+        const enabledModelIds = await this.metadataManager.getEnabledModels(provider);
+        if (enabledModelIds.length === 0) {
+            return [];
+        }
+        try {
+            const availableModels = await this.getAvailableModels(provider);
+            return availableModels.filter((model) => enabledModelIds.includes(model.id));
+        }
+        catch (error) {
+            // If we can't fetch available models, return empty
+            console.error(`Failed to get enabled models for ${provider}:`, error);
+            return [];
+        }
+    }
+    /**
+     * Get a specific model by ID from a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID
+     * @returns Model object or null if not found
+     */
+    async getModel(provider, modelId) {
+        try {
+            const availableModels = await this.getAvailableModels(provider);
+            return availableModels.find((m) => m.id === modelId) || null;
+        }
+        catch (error) {
+            console.error(`Failed to get model ${modelId} from ${provider}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Enable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to enable
+     * @throws Error if model is not found
+     */
+    async enableModel(provider, modelId) {
+        // Verify the model exists
+        const model = await this.getModel(provider, modelId);
+        if (!model) {
+            throw new Error(`Model "${modelId}" not found in provider "${provider}"`);
+        }
+        await this.metadataManager.enableModel(provider, modelId);
+    }
+    /**
+     * Disable a model for a provider
+     * @param provider - Provider name
+     * @param modelId - Model ID to disable
+     */
+    async disableModel(provider, modelId) {
+        await this.metadataManager.disableModel(provider, modelId);
+    }
+    /**
+     * Get all enabled models across all providers
+     * @returns Object mapping provider to array of enabled Models
+     */
+    async getAllEnabledModels() {
+        const enabledByProvider = await this.metadataManager.getAllEnabledModels();
+        const result = {};
+        for (const provider of Object.keys(enabledByProvider)) {
+            try {
+                const models = await this.getEnabledModels(provider);
+                if (models.length > 0) {
+                    result[provider] = models;
+                }
+            }
+            catch (error) {
+                console.error(`Failed to get enabled models for ${provider}:`, error);
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=ModelManager.js.map

package/dist/managers/NeovateExecutor.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { NeovateEvent, ExecutionContext } from '../types/models.js';
+/**
+ * NeovateExecutor interface defines the contract for neovate command execution
+ */
+export interface NeovateExecutor {
+    /**
+     * Executes a neovate command with the given prompt and context
+     * @param prompt - The user's message/prompt to send to neovate
+     * @param context - ExecutionContext containing thread info and options
+     * @yields NeovateEvent objects for system, message, result, and error events
+     */
+    execute(prompt: string, context: ExecutionContext): AsyncGenerator<NeovateEvent>;
+}
+/**
+ * NeovateExecutorImpl provides the implementation for neovate command execution
+ * using the @neovate/code SDK with streaming sessions.
+ */
+export declare class NeovateExecutorImpl implements NeovateExecutor {
+    /**
+     * 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
+     */
+    execute(userPrompt: string, context: ExecutionContext): AsyncGenerator<NeovateEvent>;
+}
+//# sourceMappingURL=NeovateExecutor.d.ts.map

package/dist/managers/NeovateExecutor.js

@@ -0,0 +1,138 @@
+/**
+ * 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';
+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 {
+    /**
+     * 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 {
+            // 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('[NeovateExecutor] No model provided in context, using default');
+                model = 'openrouter/minimax/minimax-m2.1';
+            }
+            const cwd = resolve(context.threadPath);
+            console.log('[NeovateExecutor] Execution context:', { model, cwd, promptLength: userPrompt.length });
+            // CRITICAL FIX: Ensure model is passed correctly to createSession
+            // The model MUST be a non-empty string, not null or undefined
+            const sessionConfig = {
+                model, // This is the critical parameter
+                cwd,
+                productName: 'Tarsk.io'
+            };
+            console.log('[NeovateExecutor] Creating session with model:', model);
+            console.log('[NeovateExecutor] 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('[NeovateExecutor] Session created:', session.sessionId);
+            // Send the user prompt to the session
+            console.log('[NeovateExecutor] Sending prompt to session...');
+            await session.send(userPrompt);
+            console.log('[NeovateExecutor] Prompt sent, waiting for responses...');
+            // Stream messages from the session
+            for await (const msg of session.receive()) {
+                const contentLength = typeof msg?.content === 'string' ? msg.content.length : undefined;
+                console.log('[NeovateExecutor] Received msg:', { type: msg?.type, contentLength });
+                if (msg?.type === 'message') {
+                    // Yield conversation messages (assistant responses)
+                    yield {
+                        type: 'message',
+                        role: msg.role || 'assistant',
+                        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                    };
+                }
+                else if (msg?.type === 'result') {
+                    // Yield the final result
+                    yield {
+                        type: 'result',
+                        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                    };
+                    break; // Exit the loop after receiving the result
+                }
+            }
+        }
+        catch (error) {
+            console.error('[NeovateExecutor] 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('[NeovateExecutor] Error details:', { errCode, errMessage, errStack });
+            yield {
+                type: 'error',
+                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('[NeovateExecutor] Session closed');
+                }
+                catch (closeError) {
+                    console.error('[NeovateExecutor] Error closing session:', closeError);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=NeovateExecutor.js.map