tarsk 0.2.5 → 0.3.0

package/dist/managers/metadata-manager.js

@@ -0,0 +1,305 @@
+/**
+ * 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) {
+        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),
+            }));
+            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=metadata-manager.js.map

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

@@ -0,0 +1,59 @@
+/**
+ * ModelManager
+ *
+ * Manages available and enabled models across different providers.
+ * Enriches models with pricing (and name/description) from model-info when available (e.g. OpenRouter).
+ */
+import { Model } from '../types/models.js';
+import { MetadataManager } from './metadata-manager.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
+     * Enriches with pricing (and name/description) from model-info when available (e.g. OpenRouter).
+     * @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=model-manager.d.ts.map

package/dist/managers/model-manager.js

@@ -0,0 +1,144 @@
+/**
+ * ModelManager
+ *
+ * Manages available and enabled models across different providers.
+ * Enriches models with pricing (and name/description) from model-info when available (e.g. OpenRouter).
+ */
+import { PROVIDER_DATA } from '../provider-data.js';
+import { getModelInfoForProvider } from '../model-info.js';
+import { PROVIDERS } from '../provider.js';
+/**
+ * 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
+     * Enriches with pricing (and name/description) from model-info when available (e.g. OpenRouter).
+     * @param provider - Provider name (e.g., "openrouter", "openai")
+     * @returns Array of Model objects
+     * @throws Error if provider is not supported
+     */
+    async getAvailableModels(provider) {
+        const providerId = provider.toLowerCase();
+        const providerData = PROVIDER_DATA.find((p) => p.id === providerId);
+        if (!providerData) {
+            throw new Error(`Provider "${provider}" is not supported`);
+        }
+        const modelIds = [...providerData.models];
+        // Resolve API key for providers that fetch model info from their API (OpenRouter, AIHubMix)
+        let apiKey;
+        if (providerId === 'openrouter') {
+            const keys = await this.metadataManager.getProviderKeys();
+            const openRouterProvider = PROVIDERS.find((p) => p.name === 'OpenRouter');
+            apiKey =
+                keys['OpenRouter'] ??
+                    (openRouterProvider?.keyName ? process.env[openRouterProvider.keyName] : undefined);
+        }
+        else if (providerId === 'aihubmix') {
+            const keys = await this.metadataManager.getProviderKeys();
+            const aiHubMixProvider = PROVIDERS.find((p) => p.name === 'AIHubMix');
+            apiKey =
+                keys['AIHubMix'] ??
+                    (aiHubMixProvider?.keyName ? process.env[aiHubMixProvider.keyName] : undefined);
+        }
+        const infoMap = await getModelInfoForProvider(providerId, modelIds, apiKey);
+        return modelIds.map((modelId) => {
+            const info = infoMap.get(modelId);
+            return {
+                id: modelId,
+                name: info?.name ?? modelId,
+                description: info?.description ?? `${provider} model: ${modelId}`,
+                provider: providerId,
+                pricing: info?.pricing,
+                supportedParameters: info?.supportedParameters,
+            };
+        });
+    }
+    /**
+     * 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=model-manager.js.map

package/dist/managers/neovate-executor.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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";
+import { MetadataManager } from "./metadata-manager.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 {
+    private metadataManager;
+    constructor(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
+     */
+    execute(userPrompt: string, context: ExecutionContext): AsyncGenerator<NeovateEvent>;
+}
+//# sourceMappingURL=neovate-executor.d.ts.map