tarsk 0.4.4 → 0.4.6

package/dist/features/models/models-provider-refresh.route.js

@@ -1,20 +0,0 @@
-/**
- * POST /api/models/:provider/refresh
- * Refresh the available models for a provider
- * Note: With provider-data.ts, this is a no-op but kept for backward compatibility
- */
-export async function handleProviderRefresh(c, modelManager) {
-    try {
-        const provider = c.req.param("provider");
-        if (!provider) {
-            return c.json({ error: "provider is required" }, 400);
-        }
-        const models = await modelManager.getAvailableModels(provider);
-        return c.json({ success: true, provider, modelCount: models.length });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=models-provider-refresh.route.js.map

package/dist/features/models/models.manager.d.ts

@@ -1,58 +0,0 @@
-/**
- * ModelManager
- *
- * Manages available and enabled models across different providers.
- * Uses the remote models catalog (models.tarsk.io) as the source for
- * model lists, names, and pricing.
- */
-import { Model } from "@tarsk/shared";
-import { MetadataManager } from "../metadata/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.
-     * Uses the remote catalog as the source for model lists, names, and pricing.
-     */
-    getAvailableModels(provider: string): Promise<Model[]>;
-    private buildModelsFromCatalog;
-    /**
-     * 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=models.manager.d.ts.map

package/dist/features/models/models.manager.js

@@ -1,138 +0,0 @@
-/**
- * ModelManager
- *
- * Manages available and enabled models across different providers.
- * Uses the remote models catalog (models.tarsk.io) as the source for
- * model lists, names, and pricing.
- */
-import { getCatalogProvider } from "./models-catalog.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.
-     * Uses the remote catalog as the source for model lists, names, and pricing.
-     */
-    async getAvailableModels(provider) {
-        const providerId = provider.toLowerCase();
-        // Get from catalog
-        const catalogProvider = await getCatalogProvider(providerId);
-        if (!catalogProvider) {
-            throw new Error(`Provider "${provider}" is not supported`);
-        }
-        return this.buildModelsFromCatalog(catalogProvider, providerId);
-    }
-    buildModelsFromCatalog(catalogProvider, providerId) {
-        return Object.values(catalogProvider.models).map((catalogModel) => ({
-            id: catalogModel.id,
-            name: catalogModel.name || catalogModel.id,
-            description: `${providerId} model: ${catalogModel.id}`,
-            provider: providerId,
-            pricing: catalogModel.cost
-                ? {
-                    prompt: catalogModel.cost.input,
-                    completion: catalogModel.cost.output,
-                }
-                : undefined,
-            supportedParameters: catalogModel.tool_call !== undefined
-                ? {
-                    tools: catalogModel.tool_call,
-                }
-                : undefined,
-            tarsk_use: catalogModel.tarsk_use,
-            coding_index: catalogModel.coding_index,
-            supportsImages: catalogModel.modalities
-                ? catalogModel.modalities.input.includes("image")
-                : undefined,
-            contextWindow: catalogModel.limit?.context,
-        }));
-    }
-    /**
-     * 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=models.manager.js.map

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

@@ -1,18 +0,0 @@
-/**
- * Model routes for the REST API
- *
- * Handles all model-related operations:
- * - GET /api/models - Get available models for a provider
- * - POST /api/models/:provider/:modelId/enable - Enable a model
- * - POST /api/models/:provider/:modelId/disable - Disable a model
- * - GET /api/models/enabled - Get all enabled models
- */
-import { Hono } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-/**
- * Creates model routes
- * @param metadataManager - Manager for metadata persistence
- * @returns Hono router with model routes
- */
-export declare function createModelRoutes(metadataManager: MetadataManager): Hono;
-//# sourceMappingURL=models.routes.d.ts.map

package/dist/features/models/models.routes.js

@@ -1,83 +0,0 @@
-/**
- * Model routes for the REST API
- *
- * Handles all model-related operations:
- * - GET /api/models - Get available models for a provider
- * - POST /api/models/:provider/:modelId/enable - Enable a model
- * - POST /api/models/:provider/:modelId/disable - Disable a model
- * - GET /api/models/enabled - Get all enabled models
- */
-import { Hono } from "hono";
-import { ModelManager } from "../models/models.manager.js";
-import { handleGetAvailableModels } from "./models-get-available.route.js";
-import { handleGetEnabledModels } from "./models-get-enabled.route.js";
-import { handleModelEnable } from "./models-model-enable.route.js";
-import { handleModelDisable } from "./models-model-disable.route.js";
-import { handleProviderRefresh } from "./models-provider-refresh.route.js";
-import { handleGetModelsCatalog } from "./models-catalog.route.js";
-import { handleGetModelInfo } from "./models-get-model-info.route.js";
-/**
- * Creates model routes
- * @param metadataManager - Manager for metadata persistence
- * @returns Hono router with model routes
- */
-export function createModelRoutes(metadataManager) {
-    const router = new Hono();
-    const modelManager = new ModelManager(metadataManager);
-    /**
-     * GET /api/models?provider=openrouter&supportedTools=true
-     * Get available models for a provider
-     *
-     * Query parameters:
-     * - provider: Required. Provider name (e.g., "openrouter", "openai")
-     * - supportedTools: Optional. If "true", only return models with tools support
-     */
-    router.get("/", async (c) => {
-        return handleGetAvailableModels(c, modelManager);
-    });
-    /**
-     * GET /api/models/info?modelId=provider/model
-     * Get detailed information about a specific model including context window
-     */
-    router.get("/info", async (c) => {
-        return handleGetModelInfo(c, modelManager);
-    });
-    /**
-     * GET /api/models/enabled
-     * Get all enabled models across all providers
-     */
-    router.get("/enabled", async (c) => {
-        return handleGetEnabledModels(c, modelManager);
-    });
-    /**
-     * GET /api/models/catalog
-     * Get the full models catalog (cached with SWR)
-     */
-    router.get("/catalog", async (c) => {
-        return handleGetModelsCatalog(c);
-    });
-    /**
-     * POST /api/models/:provider/:modelId/enable
-     * Enable a model for a provider
-     */
-    router.post("/:provider/:modelId/enable", async (c) => {
-        return handleModelEnable(c, modelManager);
-    });
-    /**
-     * POST /api/models/:provider/:modelId/disable
-     * Disable a model for a provider
-     */
-    router.post("/:provider/:modelId/disable", async (c) => {
-        return handleModelDisable(c, modelManager);
-    });
-    /**
-     * POST /api/models/:provider/refresh
-     * Refresh the available models for a provider
-     * Note: With provider-data.ts, this is a no-op but kept for backward compatibility
-     */
-    router.post("/:provider/refresh", async (c) => {
-        return handleProviderRefresh(c, modelManager);
-    });
-    return router;
-}
-//# sourceMappingURL=models.routes.js.map

package/dist/features/models/open-router-models.d.ts

@@ -1,38 +0,0 @@
-/**
- * OpenRouter Models Manager
- *
- * Manages available models from the OpenRouter provider
- * using @mariozechner/pi-ai's model registry.
- */
-import { Model } from "@tarsk/shared";
-/**
- * OpenRouterModels manages access to OpenRouter models via pi-ai
- */
-export declare class OpenRouterModels {
-    private cache;
-    /**
-     * Get available models from OpenRouter via pi-ai registry
-     *
-     * @returns Array of Model objects
-     */
-    getModels(): Promise<Model[]>;
-    /**
-     * Get a specific model by ID
-     * @param modelId - The model ID to fetch
-     * @returns Model object or null if not found
-     */
-    getModelById(modelId: string): Promise<Model | null>;
-    /**
-     * Clear the cache
-     */
-    clearCache(): void;
-}
-/**
- * Get or create the singleton instance
- */
-export declare function getOpenRouterModels(): OpenRouterModels;
-/**
- * Reset the singleton instance (useful for testing)
- */
-export declare function resetOpenRouterModels(): void;
-//# sourceMappingURL=open-router-models.d.ts.map

package/dist/features/models/open-router-models.js

@@ -1,73 +0,0 @@
-/**
- * OpenRouter Models Manager
- *
- * Manages available models from the OpenRouter provider
- * using @mariozechner/pi-ai's model registry.
- */
-import { getModels } from "@mariozechner/pi-ai";
-/**
- * OpenRouterModels manages access to OpenRouter models via pi-ai
- */
-export class OpenRouterModels {
-    cache = null;
-    /**
-     * Get available models from OpenRouter via pi-ai registry
-     *
-     * @returns Array of Model objects
-     */
-    async getModels() {
-        if (this.cache) {
-            return this.cache;
-        }
-        try {
-            const piModels = getModels("openrouter");
-            const models = piModels
-                .map((m) => ({
-                id: m.id,
-                name: m.name || m.id,
-                description: `OpenRouter model: ${m.id}`,
-                provider: "openrouter",
-                pricing: {
-                    prompt: m.cost?.input ?? 0,
-                    completion: m.cost?.output ?? 0,
-                },
-            }))
-                .sort((a, b) => a.id.localeCompare(b.id));
-            this.cache = models;
-            return models;
-        }
-        catch (error) {
-            throw new Error(`Failed to load OpenRouter models: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get a specific model by ID
-     * @param modelId - The model ID to fetch
-     * @returns Model object or null if not found
-     */
-    async getModelById(modelId) {
-        this.cache ??= await this.getModels();
-        return this.cache.find((m) => m.id === modelId) ?? null;
-    }
-    /**
-     * Clear the cache
-     */
-    clearCache() {
-        this.cache = null;
-    }
-}
-let instance = null;
-/**
- * Get or create the singleton instance
- */
-export function getOpenRouterModels() {
-    instance ??= new OpenRouterModels();
-    return instance;
-}
-/**
- * Reset the singleton instance (useful for testing)
- */
-export function resetOpenRouterModels() {
-    instance = null;
-}
-//# sourceMappingURL=open-router-models.js.map

package/dist/features/models/openai-models.d.ts

@@ -1,63 +0,0 @@
-/**
- * OpenAI Models Fetcher
- *
- * Handles fetching available models from OpenAI API
- * with local caching and TTL management.
- */
-import { Model } from "@tarsk/shared";
-/**
- * OpenAIModels manages fetching and caching of OpenAI models
- */
-export declare class OpenAIModels {
-    private cache;
-    private cacheTTL;
-    private apiKey;
-    /**
-     * Create a new OpenAIModels instance
-     * @param apiKey - OpenAI API key (optional, will be fetched from OPENAI_API_KEY env var)
-     */
-    constructor(apiKey?: string);
-    /**
-     * Set the API key
-     * @param apiKey - OpenAI API key
-     */
-    setApiKey(apiKey: string): void;
-    /**
-     * Check if cache is valid
-     * @returns true if cache exists and is not expired
-     */
-    private isCacheValid;
-    /**
-     * Set cache TTL in milliseconds
-     * @param ttl - Time to live in milliseconds
-     */
-    setCacheTTL(ttl: number): void;
-    /**
-     * Clear the cache
-     */
-    clearCache(): void;
-    /**
-     * Fetch available models from OpenAI API
-     * Uses cache if valid, otherwise fetches fresh data
-     *
-     * API Reference: https://platform.openai.com/docs/api-reference/models/list
-     *
-     * @returns Array of Model objects
-     * @throws Error if API key is not set or API call fails
-     */
-    getModels(): Promise<Model[]>;
-    /**
-     * Format model ID to a readable name
-     * @param modelId - The model ID
-     * @returns Formatted model name
-     */
-    private formatModelName;
-    /**
-     * Get a specific model by ID
-     * @param modelId - The model ID to fetch
-     * @returns Model object or null if not found
-     */
-    getModelById(modelId: string): Promise<Model | null>;
-}
-export declare function getOpenAIModels(): OpenAIModels;
-//# sourceMappingURL=openai-models.d.ts.map

package/dist/features/models/openai-models.js

@@ -1,150 +0,0 @@
-/**
- * OpenAI Models Fetcher
- *
- * Handles fetching available models from OpenAI API
- * with local caching and TTL management.
- */
-/**
- * OpenAIModels manages fetching and caching of OpenAI models
- */
-export class OpenAIModels {
-    cache = null;
-    cacheTTL = 1000 * 60 * 60; // 1 hour in milliseconds
-    apiKey = null;
-    /**
-     * Create a new OpenAIModels instance
-     * @param apiKey - OpenAI API key (optional, will be fetched from OPENAI_API_KEY env var)
-     */
-    constructor(apiKey) {
-        this.apiKey = apiKey ?? process.env.OPENAI_API_KEY ?? null;
-    }
-    /**
-     * Set the API key
-     * @param apiKey - OpenAI API key
-     */
-    setApiKey(apiKey) {
-        this.apiKey = apiKey;
-        // Invalidate cache when API key changes
-        this.cache = null;
-    }
-    /**
-     * Check if cache is valid
-     * @returns true if cache exists and is not expired
-     */
-    isCacheValid() {
-        if (!this.cache) {
-            return false;
-        }
-        const now = Date.now();
-        return now - this.cache.timestamp < this.cacheTTL;
-    }
-    /**
-     * Set cache TTL in milliseconds
-     * @param ttl - Time to live in milliseconds
-     */
-    setCacheTTL(ttl) {
-        this.cacheTTL = ttl;
-    }
-    /**
-     * Clear the cache
-     */
-    clearCache() {
-        this.cache = null;
-    }
-    /**
-     * Fetch available models from OpenAI API
-     * Uses cache if valid, otherwise fetches fresh data
-     *
-     * API Reference: https://platform.openai.com/docs/api-reference/models/list
-     *
-     * @returns Array of Model objects
-     * @throws Error if API key is not set or API call fails
-     */
-    async getModels() {
-        // Return cached data if valid
-        if (this.isCacheValid() && this.cache) {
-            return this.cache.models;
-        }
-        if (!this.apiKey) {
-            throw new Error("OpenAI API key is not set. Please set OPENAI_API_KEY environment variable or provide it to the constructor.");
-        }
-        try {
-            const response = await fetch("https://api.openai.com/v1/models", {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                },
-            });
-            if (!response.ok) {
-                throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
-            }
-            const data = (await response.json());
-            // Transform OpenAI response to our Model interface
-            // Only includes models that are likely suitable for chat/completion
-            const models = data.data
-                .filter((item) => {
-                // Filter to only include gpt models and models suitable for API use
-                const id = item.id.toLowerCase();
-                return id.includes("gpt") && !id.includes("vision-request") && !id.includes("dall-e");
-            })
-                .map((item) => ({
-                id: item.id,
-                name: this.formatModelName(item.id),
-                description: `OpenAI model: ${item.id}`,
-                provider: "openai",
-                pricing: {
-                    prompt: 0, // OpenAI API doesn't provide pricing in the models list
-                    completion: 0, // Users should check pricing on OpenAI's website
-                },
-            }));
-            // Store in cache
-            this.cache = {
-                models,
-                timestamp: Date.now(),
-            };
-            return models;
-        }
-        catch (error) {
-            throw new Error(`Failed to fetch OpenAI models: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Format model ID to a readable name
-     * @param modelId - The model ID
-     * @returns Formatted model name
-     */
-    formatModelName(modelId) {
-        // Convert "gpt-4-turbo" to "GPT-4 Turbo"
-        return modelId
-            .split("-")
-            .map((part) => {
-            if (part === "gpt")
-                return "GPT";
-            // Handle version numbers like "4turbo"
-            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 a specific model by ID
-     * @param modelId - The model ID to fetch
-     * @returns Model object or null if not found
-     */
-    async getModelById(modelId) {
-        const models = await this.getModels();
-        return models.find((m) => m.id === modelId) ?? null;
-    }
-}
-/**
- * Get or create a singleton OpenAIModels instance
- */
-let instance = null;
-export function getOpenAIModels() {
-    instance ??= new OpenAIModels();
-    return instance;
-}
-//# sourceMappingURL=openai-models.js.map

package/dist/features/onboarding/onboarding-get-git-check.route.d.ts

@@ -1,11 +0,0 @@
-/**
- * GET /api/onboarding/git-check
- * Check if git is installed by running 'git --version'
- */
-import type { Context } from "hono";
-export declare function getGitCheck(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    gitInstalled: boolean;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=onboarding-get-git-check.route.d.ts.map

package/dist/features/onboarding/onboarding-get-git-check.route.js

@@ -1,28 +0,0 @@
-/**
- * GET /api/onboarding/git-check
- * Check if git is installed by running 'git --version'
- */
-import { spawnProcess } from "../../core/utils.js";
-export async function getGitCheck(c) {
-    try {
-        const gitInstalled = await new Promise((resolve) => {
-            const proc = spawnProcess("git", ["--version"]);
-            let _err = "";
-            proc.stderr?.on("data", (d) => {
-                _err += d.toString();
-            });
-            proc.on("close", (code) => {
-                resolve(code === 0);
-            });
-            proc.on("error", () => {
-                resolve(false);
-            });
-        });
-        return c.json({ gitInstalled });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to check git installation";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=onboarding-get-git-check.route.js.map