tarsk 0.4.4 → 0.4.6

package/dist/features/metadata/metadata.manager.js

@@ -1,423 +0,0 @@
-/**
- * MetadataManager handles persistence of project and thread metadata
- *
- * This manager provides SQLite-based storage with atomic transactions
- * to ensure data consistency.
- */
-import { getDatabase } from '../../database/database.js';
-import * as dbProjects from '../projects/projects.database.js';
-import * as dbThreads from '../threads/threads.database.js';
-import * as dbState from '../../database/database.state.js';
-import { encryptProviderKey, decryptProviderKey, isEncryptedKey, } from '../../database/database.encryption.js';
-export class MetadataManager {
-    db;
-    /**
-     * Create a new MetadataManager
-     * @param _dataDir - Directory where metadata files will be stored
-     *                  (e.g. ~/Library/Application Support/Tarsk/data)
-     */
-    constructor(_dataDir) {
-        // Database will be initialized in initialize() method
-        this.db = null;
-    }
-    /**
-     * Initialize metadata database
-     */
-    async initialize() {
-        // Initialize database connection
-        this.db = await getDatabase();
-        // Just verify connection is working
-        try {
-            await this.db.execute("SELECT 1");
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize database: ${String(error)}`);
-        }
-    }
-    /**
-     * Save projects to database using atomic transaction
-     * @param projects - Array of projects to save
-     */
-    async saveProjects(projects) {
-        try {
-            await this.db.execute("BEGIN TRANSACTION");
-            try {
-                // Get existing projects to find which ones are being deleted
-                const existingProjects = await dbProjects.getAllProjects(this.db);
-                const existingProjectIds = new Set(existingProjects.map((p) => p.id));
-                const newProjectIds = new Set(projects.map((p) => p.id));
-                // Delete projects that are being removed (cascade will delete their threads)
-                for (const projectId of existingProjectIds) {
-                    if (!newProjectIds.has(projectId)) {
-                        // This project is being deleted
-                        await dbProjects.deleteProject(this.db, projectId);
-                    }
-                }
-                // Update or insert projects
-                for (const project of projects) {
-                    if (existingProjectIds.has(project.id)) {
-                        // Project exists, update it
-                        await dbProjects.updateProject(this.db, project.id, project);
-                    }
-                    else {
-                        // New project, insert it
-                        await dbProjects.insertProject(this.db, project);
-                    }
-                }
-                await this.db.execute("COMMIT");
-            }
-            catch (error) {
-                await this.db.execute("ROLLBACK");
-                throw error;
-            }
-        }
-        catch (error) {
-            console.error("Failed to save projects:", error);
-            throw new Error(`Failed to save projects: ${String(error)}`);
-        }
-    }
-    /**
-     * Load projects from database
-     * @returns Array of projects
-     */
-    async loadProjects() {
-        try {
-            return dbProjects.getAllProjects(this.db);
-        }
-        catch (error) {
-            throw new Error(`Failed to load projects: ${String(error)}`);
-        }
-    }
-    /**
-     * Save threads to database using atomic transaction
-     * @param threads - Array of threads to save
-     */
-    async saveThreads(threads) {
-        try {
-            await this.db.execute("BEGIN TRANSACTION");
-            try {
-                // Get existing threads to find which ones are being deleted
-                const existingThreads = await dbThreads.getAllThreads(this.db);
-                const existingThreadIds = new Set(existingThreads.map((t) => t.id));
-                const newThreadIds = new Set(threads.map((t) => t.id));
-                // Delete threads that are being removed
-                for (const threadId of existingThreadIds) {
-                    if (!newThreadIds.has(threadId)) {
-                        // This thread is being deleted
-                        await dbThreads.deleteThread(this.db, threadId);
-                    }
-                }
-                // Update or insert threads
-                for (const thread of threads) {
-                    if (existingThreadIds.has(thread.id)) {
-                        // Thread exists, update it
-                        await dbThreads.updateThread(this.db, thread.id, thread);
-                    }
-                    else {
-                        // New thread, insert it
-                        await dbThreads.insertThread(this.db, thread);
-                    }
-                }
-                await this.db.execute("COMMIT");
-            }
-            catch (error) {
-                await this.db.execute("ROLLBACK");
-                throw error;
-            }
-        }
-        catch (error) {
-            console.error("Failed to save threads:", error);
-            throw new Error(`Failed to save threads: ${String(error)}`);
-        }
-    }
-    /**
-     * Load threads from database
-     * @returns Array of threads
-     */
-    async loadThreads() {
-        try {
-            return dbThreads.getAllThreads(this.db);
-        }
-        catch (error) {
-            throw new Error(`Failed to load threads: ${String(error)}`);
-        }
-    }
-    /**
-     * Save application state to database
-     * @param state - Application state to save
-     */
-    async saveState(state) {
-        try {
-            await this.db.execute("BEGIN TRANSACTION");
-            try {
-                // Save each state field
-                await dbState.setState(this.db, "selectedThreadId", state.selectedThreadId);
-                await dbState.setState(this.db, "enabledModels", state.enabledModels);
-                await dbState.setState(this.db, "onboardingCompleted", state.onboardingCompleted);
-                // Save provider keys (encrypted, but skip if already encrypted)
-                const encryptedKeys = {};
-                for (const [provider, key] of Object.entries(state.providerKeys)) {
-                    if (!key) {
-                        encryptedKeys[provider] = "";
-                    }
-                    else if (isEncryptedKey(key)) {
-                        // Already encrypted, use as-is
-                        encryptedKeys[provider] = key;
-                    }
-                    else {
-                        // Plain-text, encrypt it
-                        encryptedKeys[provider] = await encryptProviderKey(key);
-                    }
-                }
-                await dbState.setState(this.db, "providerKeys", encryptedKeys);
-                await this.db.execute("COMMIT");
-            }
-            catch (error) {
-                await this.db.execute("ROLLBACK");
-                throw error;
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to save state: ${String(error)}`);
-        }
-    }
-    /**
-     * Load application state from database
-     * @returns Application state
-     */
-    async loadState() {
-        try {
-            const allState = await dbState.getAllState(this.db);
-            // Reconstruct AppState from key-value pairs (excluding encryption_key)
-            const selectedThreadId = allState.selectedThreadId ?? null;
-            const onboardingCompleted = allState.onboardingCompleted || false;
-            const enabledModels = allState.enabledModels || {};
-            // Load and decrypt provider keys
-            const encryptedKeys = allState.providerKeys || {};
-            const providerKeys = {};
-            let needsMigration = false;
-            for (const [provider, encryptedKey] of Object.entries(encryptedKeys)) {
-                if (!encryptedKey) {
-                    providerKeys[provider] = "";
-                    continue;
-                }
-                // Check if key is encrypted
-                if (isEncryptedKey(encryptedKey)) {
-                    try {
-                        const decrypted = await decryptProviderKey(encryptedKey);
-                        providerKeys[provider] = decrypted;
-                    }
-                    catch (error) {
-                        console.error(`[MetadataManager] Failed to decrypt key for ${provider}:`, error);
-                        providerKeys[provider] = "";
-                    }
-                }
-                else {
-                    // Plain-text key found - needs migration
-                    console.log(`[MetadataManager] Found plain-text key for ${provider}, will encrypt on save`);
-                    providerKeys[provider] = encryptedKey;
-                    needsMigration = true;
-                }
-            }
-            // If we found plain-text keys, migrate them
-            if (needsMigration) {
-                console.log("[MetadataManager] Migrating plain-text keys to encrypted format");
-                await this.saveAllProviderKeys(providerKeys);
-            }
-            return {
-                selectedThreadId,
-                onboardingCompleted,
-                providerKeys,
-                enabledModels,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to load state: ${String(error)}`);
-        }
-    }
-    /**
-     * Update all provider keys at once
-     * @param keys - Object mapping provider names to API keys
-     */
-    async saveAllProviderKeys(keys) {
-        try {
-            const state = await this.loadState();
-            // Encrypt all keys before saving (skip if already encrypted)
-            const encryptedKeys = {};
-            for (const [provider, key] of Object.entries(keys)) {
-                if (!key) {
-                    encryptedKeys[provider] = "";
-                }
-                else if (isEncryptedKey(key)) {
-                    // Already encrypted, use as-is
-                    encryptedKeys[provider] = key;
-                }
-                else {
-                    // Plain-text, encrypt it
-                    encryptedKeys[provider] = await encryptProviderKey(key);
-                }
-            }
-            state.providerKeys = { ...state.providerKeys, ...encryptedKeys };
-            await this.saveState(state);
-        }
-        catch (error) {
-            throw new Error(`Failed to save provider keys: ${String(error)}`);
-        }
-    }
-    /**
-     * Update provider keys
-     * @param providerName - Name of the provider
-     * @param apiKey - API key to save (will be encrypted if not already)
-     */
-    async saveProviderKey(providerName, apiKey) {
-        try {
-            const state = await this.loadState();
-            // Encrypt the API key before saving (skip if already encrypted)
-            if (!apiKey) {
-                state.providerKeys[providerName] = "";
-            }
-            else if (isEncryptedKey(apiKey)) {
-                // Already encrypted, use as-is
-                state.providerKeys[providerName] = apiKey;
-            }
-            else {
-                // Plain-text, encrypt it
-                state.providerKeys[providerName] = await encryptProviderKey(apiKey);
-            }
-            await this.saveState(state);
-        }
-        catch (error) {
-            throw new Error(`Failed to save provider key: ${String(error)}`);
-        }
-    }
-    /**
-     * Get all provider keys
-     * @returns Record of provider names to decrypted API keys
-     */
-    async getProviderKeys() {
-        try {
-            const state = await this.loadState();
-            const decryptedKeys = {};
-            // Decrypt all provider keys before returning
-            for (const [providerName, encryptedKey] of Object.entries(state.providerKeys)) {
-                if (isEncryptedKey(encryptedKey)) {
-                    try {
-                        const decryptedKey = await decryptProviderKey(encryptedKey);
-                        decryptedKeys[providerName] = decryptedKey;
-                    }
-                    catch (error) {
-                        console.error(`Failed to decrypt key for provider ${providerName}:`, error);
-                        decryptedKeys[providerName] = ""; // Use empty string if decryption fails
-                    }
-                }
-                else {
-                    // Key is not encrypted, use as-is
-                    decryptedKeys[providerName] = encryptedKey;
-                }
-            }
-            return decryptedKeys;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error("[MetadataManager] Failed to get provider keys:", errorMessage);
-            throw new Error(`Failed to get provider keys: ${errorMessage}`);
-        }
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Set onboarding completed flag
-     * @param completed - Whether onboarding is completed
-     */
-    async setOnboardingCompleted(completed) {
-        const state = await this.loadState();
-        state.onboardingCompleted = completed;
-        await this.saveState(state);
-    }
-    /**
-     * Get onboarding completed flag
-     * @returns Whether onboarding has been completed
-     */
-    async getOnboardingCompleted() {
-        const state = await this.loadState();
-        return state.onboardingCompleted;
-    }
-}
-//# sourceMappingURL=metadata.manager.js.map

package/dist/features/models/model-info-aihubmix.d.ts

@@ -1,25 +0,0 @@
-/**
- * AIHubMix model info and pricing
- *
- * Fetches model information (name, description, pricing) from the AIHubMix API.
- * AIHubMix API: https://docs.aihubmix.com/api/models
- */
-import type { ModelInfo } from "./model-info.js";
-/**
- * Fetch model info and pricing from AIHubMix API
- *
- * @param modelIds - List of model IDs to fetch info for
- * @param apiKey - AIHubMix API key
- * @returns Map of model ID -> ModelInfo (with pricing and metadata)
- */
-export declare function getAIHubMixModelInfo(modelIds: string[], apiKey: string): Promise<Map<string, ModelInfo>>;
-/**
- * Fetch account credits/balance for AIHubMix using a user's API key.
- * Returns remaining balance as (quota - used_quota) / 500000, matching UI units.
- */
-export declare function getAIHubMixCredits(apiKey: string): Promise<{
-    balance: number | null;
-    status: string;
-    reason?: string;
-}>;
-//# sourceMappingURL=model-info-aihubmix.d.ts.map

package/dist/features/models/model-info-aihubmix.js

@@ -1,117 +0,0 @@
-/**
- * AIHubMix model info and pricing
- *
- * Fetches model information (name, description, pricing) from the AIHubMix API.
- * AIHubMix API: https://docs.aihubmix.com/api/models
- */
-const AIHUBMIX_MODELS_URL = "https://aihubmix.com/api/v1/models";
-/**
- * Parse AIHubMix price to per-token USD.
- * AIHubMix returns prices in USD per 1,000,000 tokens (per-million). Convert
- * to USD per single token for internal `ModelInfoPricing` which stores cost
- * per token.
- */
-function parsePrice(value) {
-    let n = 0;
-    if (typeof value === "number" && !Number.isNaN(value)) {
-        n = value;
-    }
-    else if (typeof value === "string") {
-        const parsed = Number.parseFloat(value);
-        if (!Number.isNaN(parsed))
-            n = parsed;
-    }
-    if (n === 0)
-        return 0;
-    // Convert from USD per 1,000,000 tokens to USD per 1 token
-    return n / 1_000_000;
-}
-/**
- * Fetch model info and pricing from AIHubMix API
- *
- * @param modelIds - List of model IDs to fetch info for
- * @param apiKey - AIHubMix API key
- * @returns Map of model ID -> ModelInfo (with pricing and metadata)
- */
-export async function getAIHubMixModelInfo(modelIds, apiKey) {
-    const result = new Map();
-    const emptyInfo = () => ({});
-    try {
-        const response = await fetch(AIHUBMIX_MODELS_URL, {
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-        });
-        if (!response.ok) {
-            // Pricing unknown when API call fails; still return entries for all IDs
-            for (const id of modelIds) {
-                result.set(id, emptyInfo());
-            }
-            return result;
-        }
-        const body = (await response.json());
-        const models = body.data ?? [];
-        const byId = new Map();
-        for (const m of models) {
-            if (m.model_id)
-                byId.set(m.model_id, m);
-        }
-        for (const id of modelIds) {
-            const remote = byId.get(id);
-            const hasPricing = Boolean(remote?.pricing) &&
-                (remote?.pricing?.input !== undefined || remote?.pricing?.output !== undefined);
-            const pricing = hasPricing
-                ? {
-                    prompt: parsePrice(remote?.pricing?.input),
-                    completion: parsePrice(remote?.pricing?.output),
-                }
-                : undefined;
-            // Check if model supports function calling/tools
-            const hasTools = typeof remote?.features === "string" &&
-                (remote.features.includes("function_calling") || remote.features.includes("tools"));
-            result.set(id, {
-                pricing,
-                name: remote?.model_id,
-                description: remote?.desc,
-                supportedParameters: hasTools ? { tools: true } : undefined,
-            });
-        }
-    }
-    catch (error) {
-        console.error("[AIHubMix Models API] Error fetching models:", error);
-        for (const id of modelIds) {
-            result.set(id, emptyInfo());
-        }
-    }
-    return result;
-}
-/**
- * Fetch account credits/balance for AIHubMix using a user's API key.
- * Returns remaining balance as (quota - used_quota) / 500000, matching UI units.
- */
-export async function getAIHubMixCredits(apiKey) {
-    try {
-        const response = await fetch("https://aihubmix.com/api/user/self", {
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            return { balance: null, status: "unknown", reason: `API error: ${response.status}` };
-        }
-        const body = (await response.json());
-        const quota = Number(body.data?.quota ?? NaN);
-        const used = Number(body.data?.used_quota ?? NaN);
-        if (Number.isNaN(quota) || Number.isNaN(used)) {
-            return { balance: null, status: "unknown" };
-        }
-        const remaining = (quota - used) / 500000;
-        return { balance: remaining, status: "success" };
-    }
-    catch (error) {
-        return { balance: null, status: "unknown", reason: String(error) };
-    }
-}
-//# sourceMappingURL=model-info-aihubmix.js.map

package/dist/features/models/model-info-openrouter.d.ts

@@ -1,25 +0,0 @@
-/**
- * OpenRouter model info and pricing
- *
- * Fetches model information (name, description, pricing) from the OpenRouter API.
- * OpenRouter API: https://openrouter.ai/docs/api/api-reference/models/get-models
- */
-import type { ModelInfo } from "./model-info.js";
-/**
- * Fetch model info and pricing from OpenRouter API
- *
- * @param modelIds - List of model IDs to fetch info for
- * @param apiKey - OpenRouter API key
- * @returns Map of model ID -> ModelInfo (with pricing and metadata)
- */
-export declare function getOpenRouterModelInfo(modelIds: string[], apiKey: string): Promise<Map<string, ModelInfo>>;
-/**
- * Fetch account credits/balance for OpenRouter using a user's API key.
- * Returns remaining balance as total_credits - total_usage (OpenRouter returns credits as a numeric unit).
- */
-export declare function getOpenRouterCredits(apiKey: string): Promise<{
-    balance: number | null;
-    status: string;
-    reason?: string;
-}>;
-//# sourceMappingURL=model-info-openrouter.d.ts.map

package/dist/features/models/model-info-openrouter.js

@@ -1,104 +0,0 @@
-/**
- * OpenRouter model info and pricing
- *
- * Fetches model information (name, description, pricing) from the OpenRouter API.
- * OpenRouter API: https://openrouter.ai/docs/api/api-reference/models/get-models
- */
-const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
-/** Parse OpenRouter price string (per-token USD) to number */
-function parsePrice(value) {
-    if (typeof value === "number" && !Number.isNaN(value))
-        return value;
-    if (typeof value === "string") {
-        const n = Number.parseFloat(value);
-        return Number.isNaN(n) ? 0 : n;
-    }
-    return 0;
-}
-/**
- * Fetch model info and pricing from OpenRouter API
- *
- * @param modelIds - List of model IDs to fetch info for
- * @param apiKey - OpenRouter API key
- * @returns Map of model ID -> ModelInfo (with pricing and metadata)
- */
-export async function getOpenRouterModelInfo(modelIds, apiKey) {
-    const result = new Map();
-    const emptyInfo = () => ({});
-    try {
-        const response = await fetch(OPENROUTER_MODELS_URL, {
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            // Pricing unknown when API call fails; still return entries for all IDs
-            for (const id of modelIds) {
-                result.set(id, emptyInfo());
-            }
-            return result;
-        }
-        const body = (await response.json());
-        const models = body.data ?? [];
-        const byId = new Map();
-        for (const m of models) {
-            if (m.id)
-                byId.set(m.id, m);
-        }
-        for (const id of modelIds) {
-            const remote = byId.get(id);
-            const hasPricing = Boolean(remote?.pricing) &&
-                (remote?.pricing?.prompt !== undefined || remote?.pricing?.completion !== undefined);
-            const pricing = hasPricing
-                ? {
-                    prompt: parsePrice(remote?.pricing?.prompt),
-                    completion: parsePrice(remote?.pricing?.completion),
-                }
-                : undefined;
-            const hasTools = Array.isArray(remote?.supported_parameters) &&
-                remote.supported_parameters.includes("tools");
-            result.set(id, {
-                pricing,
-                name: remote?.name,
-                description: remote?.description,
-                supportedParameters: hasTools ? { tools: true } : undefined,
-            });
-        }
-    }
-    catch (error) {
-        console.error("[OpenRouter Models API] Error fetching models:", error);
-        for (const id of modelIds) {
-            result.set(id, emptyInfo());
-        }
-    }
-    return result;
-}
-/**
- * Fetch account credits/balance for OpenRouter using a user's API key.
- * Returns remaining balance as total_credits - total_usage (OpenRouter returns credits as a numeric unit).
- */
-export async function getOpenRouterCredits(apiKey) {
-    try {
-        const response = await fetch("https://openrouter.ai/api/v1/credits", {
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-            },
-        });
-        if (!response.ok) {
-            return { balance: null, status: "unknown", reason: `API error: ${response.status}` };
-        }
-        const data = (await response.json());
-        const totalCredits = data.data?.total_credits ?? 0;
-        const totalUsage = data.data?.total_usage ?? 0;
-        const remainingBalance = totalCredits - totalUsage;
-        return {
-            balance: data.data ? remainingBalance : null,
-            status: data.data ? "success" : "unknown",
-        };
-    }
-    catch (error) {
-        return { balance: null, status: "unknown", reason: String(error) };
-    }
-}
-//# sourceMappingURL=model-info-openrouter.js.map