tarsk 0.4.4 → 0.4.6

package/dist/database/database.js

@@ -1,480 +0,0 @@
-/**
- * SQLite Database Connection Management
- *
- * This module handles:
- * - SQLite database connection initialization
- * - Database file creation at ~/Library/Application Support/Tarsk/data/tarsk.db
- * - Schema initialization
- * - Connection lifecycle management
- */
-import { createClient } from "@libsql/client";
-import { join } from "path";
-import { homedir } from "os";
-import { mkdirSync } from "fs";
-/**
- * Get the database file path
- * @returns Absolute path to tarsk.db
- */
-export function getDatabasePath() {
-    const appSupportDir = join(homedir(), "Library", "Application Support", "Tarsk");
-    const dataDir = join(appSupportDir, "data");
-    return join(dataDir, "tarsk.db");
-}
-/**
- * Initialize the database connection and create tables if needed
- * @returns SQLite database instance
- */
-export async function initializeDatabase() {
-    const dbPath = getDatabasePath();
-    try {
-        // Ensure data directory exists
-        const dataDir = join(homedir(), "Library", "Application Support", "Tarsk", "data");
-        mkdirSync(dataDir, { recursive: true });
-        // Open database connection (creates file if not exists)
-        const db = createClient({
-            url: `file:${dbPath}`,
-        });
-        // Enable foreign keys
-        await db.execute("PRAGMA foreign_keys = ON");
-        // Initialize schema
-        await initializeSchema(db);
-        return db;
-    }
-    catch (error) {
-        console.error("Failed to initialize database:", error);
-        throw error;
-    }
-}
-/**
- * Initialize database schema with all required tables
- * @param db SQLite database instance
- */
-export async function initializeSchema(db) {
-    try {
-        // Create projects table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS projects (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        gitUrl TEXT NOT NULL,
-        path TEXT NOT NULL,
-        createdAt TEXT NOT NULL,
-        openWith TEXT,
-        commands TEXT,
-        setupScript TEXT,
-        runCommand TEXT,
-        commitMethod TEXT
-      )
-    `);
-        // Create threads table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS threads (
-        id TEXT PRIMARY KEY,
-        projectId TEXT NOT NULL,
-        title TEXT NOT NULL,
-        path TEXT NOT NULL,
-        currentBranch TEXT NOT NULL,
-        createdAt TEXT NOT NULL,
-        enabledSkills TEXT,
-        disabledSkills TEXT,
-        currentConversationId TEXT,
-        status TEXT NOT NULL DEFAULT 'active',
-        model TEXT,
-        diffComments TEXT,
-        FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE
-      )
-    `);
-        // Create state table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS state (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      )
-    `);
-        // Create conversation_history table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS conversation_history (
-        id TEXT PRIMARY KEY,
-        threadId TEXT NOT NULL,
-        conversationId TEXT NOT NULL,
-        timestamp TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'active',
-        request_message TEXT NOT NULL,
-        request_model TEXT NOT NULL,
-        request_attachments TEXT,
-        request_planMode INTEGER,
-        response_content TEXT,
-        response_events TEXT,
-        response_completedAt TEXT,
-        input_tokens INTEGER DEFAULT 0,
-        output_tokens INTEGER DEFAULT 0,
-        FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
-      )
-    `);
-        // Create todos table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS todos (
-        id TEXT PRIMARY KEY,
-        threadId TEXT NOT NULL,
-        description TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'pending',
-        assignedTo TEXT NOT NULL DEFAULT 'agent',
-        createdAt TEXT NOT NULL,
-        updatedAt TEXT NOT NULL,
-        FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
-      )
-    `);
-        // Create project_todos table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS project_todos (
-        id TEXT PRIMARY KEY,
-        projectId TEXT NOT NULL,
-        threadId TEXT,
-        title TEXT NOT NULL,
-        description TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'Ready',
-        working INTEGER NOT NULL DEFAULT 0,
-        createdAt TEXT NOT NULL,
-        updatedAt TEXT NOT NULL,
-        FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE
-      )
-    `);
-        // Create git_status_cache table
-        await db.execute(`
-      CREATE TABLE IF NOT EXISTS git_status_cache (
-        threadId TEXT PRIMARY KEY,
-        data TEXT NOT NULL,
-        cachedAt TEXT NOT NULL
-      )
-    `);
-        // Create indexes for efficient queries
-        await db.execute(`
-      CREATE INDEX IF NOT EXISTS idx_threads_projectId ON threads(projectId)
-    `);
-        await db.execute(`
-      CREATE INDEX IF NOT EXISTS idx_todos_threadId ON todos(threadId)
-    `);
-        await db.execute(`
-      CREATE INDEX IF NOT EXISTS idx_project_todos_projectId ON project_todos(projectId)
-    `);
-        await db.execute(`
-      CREATE INDEX IF NOT EXISTS idx_conversation_history_threadId ON conversation_history(threadId)
-    `);
-        await db.execute(`
-      CREATE INDEX IF NOT EXISTS idx_conversation_history_conversationId ON conversation_history(conversationId)
-    `);
-        // Run migrations to apply schema updates to existing databases
-        await runMigrations(db);
-    }
-    catch (error) {
-        console.error("Failed to initialize database schema:", error);
-        throw error;
-    }
-}
-async function runMigrations(db) {
-    try {
-        // Check if conversation_history table exists
-        const conversationHistoryExists = await db.execute(`SELECT name FROM sqlite_master WHERE type='table' AND name='conversation_history'`);
-        if (conversationHistoryExists.rows.length > 0) {
-            // Migration: Add conversationId column to conversation_history if it doesn't exist
-            const conversationHistoryInfo = await db.execute(`PRAGMA table_info(conversation_history)`);
-            const hasConversationId = conversationHistoryInfo.rows.some((col) => col.name === "conversationId");
-            if (!hasConversationId) {
-                console.log("[db] Running migration: Adding conversationId column to conversation_history");
-                await db.execute(`ALTER TABLE conversation_history ADD COLUMN conversationId TEXT NOT NULL DEFAULT ''`);
-            }
-            // Migration: Drop prompt_id, message_type, and sequence_id columns if they exist
-            const hasPromptIdColumn = conversationHistoryInfo.rows.some((col) => col.name === "prompt_id");
-            const hasMessageTypeColumn = conversationHistoryInfo.rows.some((col) => col.name === "message_type");
-            const hasSequenceIdColumn = conversationHistoryInfo.rows.some((col) => col.name === "sequence_id");
-            const hasStatusColumn = conversationHistoryInfo.rows.some((col) => col.name === "status");
-            const hasInputTokensColumn = conversationHistoryInfo.rows.some((col) => col.name === "input_tokens");
-            const hasOutputTokensColumn = conversationHistoryInfo.rows.some((col) => col.name === "output_tokens");
-            if (!hasStatusColumn) {
-                console.log("[db] Running migration: Adding status column to conversation_history");
-                await db.execute(`ALTER TABLE conversation_history ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
-            }
-            if (!hasInputTokensColumn) {
-                console.log("[db] Running migration: Adding input_tokens column to conversation_history");
-                await db.execute(`ALTER TABLE conversation_history ADD COLUMN input_tokens INTEGER DEFAULT 0`);
-            }
-            if (!hasOutputTokensColumn) {
-                console.log("[db] Running migration: Adding output_tokens column to conversation_history");
-                await db.execute(`ALTER TABLE conversation_history ADD COLUMN output_tokens INTEGER DEFAULT 0`);
-            }
-            if (hasPromptIdColumn || hasMessageTypeColumn || hasSequenceIdColumn) {
-                console.log("[db] Running migration: Dropping prompt_id, message_type, and sequence_id columns from conversation_history");
-                // SQLite doesn't support DROP COLUMN directly, so we need to recreate table
-                await db.execute(`
-          CREATE TABLE conversation_history_new AS SELECT 
-            id, 
-            threadId, 
-            conversationId, 
-            timestamp,
-            status,
-            request_message, 
-            request_model, 
-            request_attachments, 
-            request_planMode, 
-            response_content, 
-            response_events, 
-            response_completedAt,
-            input_tokens,
-            output_tokens
-          FROM conversation_history
-        `);
-                await db.execute(`DROP TABLE conversation_history`);
-                await db.execute(`ALTER TABLE conversation_history_new RENAME TO conversation_history`);
-                // Recreate indexes
-                await db.execute(`
-          CREATE INDEX IF NOT EXISTS idx_conversation_history_threadId ON conversation_history(threadId)
-        `);
-                await db.execute(`
-          CREATE INDEX IF NOT EXISTS idx_conversation_history_conversationId ON conversation_history(conversationId)
-        `);
-            }
-            // Migration: Add ON DELETE CASCADE to conversation_history.threadId foreign key
-            // Check if foreign key has CASCADE by examining the table SQL
-            const tableInfo = await db.execute(`
-        SELECT sql FROM sqlite_master 
-        WHERE type='table' AND name='conversation_history'
-      `);
-            if (tableInfo.rows.length > 0) {
-                const tableSql = tableInfo.rows[0].sql;
-                if (!tableSql.includes("ON DELETE CASCADE")) {
-                    console.log("[db] Running migration: Adding ON DELETE CASCADE to conversation_history.threadId foreign key");
-                    // Recreate table with CASCADE
-                    await db.execute(`
-            CREATE TABLE conversation_history_new AS SELECT 
-              id, 
-              threadId, 
-              conversationId, 
-              timestamp,
-              status,
-              request_message, 
-              request_model, 
-              request_attachments, 
-              request_planMode, 
-              response_content, 
-              response_events, 
-              response_completedAt,
-              input_tokens,
-              output_tokens
-            FROM conversation_history
-          `);
-                    await db.execute(`DROP TABLE conversation_history`);
-                    await db.execute(`
-            CREATE TABLE conversation_history (
-              id TEXT PRIMARY KEY,
-              threadId TEXT NOT NULL,
-              conversationId TEXT NOT NULL,
-              timestamp TEXT NOT NULL,
-              status TEXT NOT NULL DEFAULT 'active',
-              request_message TEXT NOT NULL,
-              request_model TEXT NOT NULL,
-              request_attachments TEXT,
-              request_planMode INTEGER,
-              response_content TEXT,
-              response_events TEXT,
-              response_completedAt TEXT,
-              input_tokens INTEGER DEFAULT 0,
-              output_tokens INTEGER DEFAULT 0,
-              FOREIGN KEY (threadId) REFERENCES threads(id) ON DELETE CASCADE
-            )
-          `);
-                    await db.execute(`
-            INSERT INTO conversation_history SELECT 
-              id, 
-              threadId, 
-              conversationId, 
-              timestamp,
-              status,
-              request_message, 
-              request_model, 
-              request_attachments, 
-              request_planMode, 
-              response_content, 
-              response_events, 
-              response_completedAt,
-              input_tokens,
-              output_tokens
-            FROM conversation_history_new
-          `);
-                    await db.execute(`DROP TABLE conversation_history_new`);
-                    // Recreate indexes
-                    await db.execute(`
-            CREATE INDEX IF NOT EXISTS idx_conversation_history_threadId ON conversation_history(threadId)
-          `);
-                    await db.execute(`
-            CREATE INDEX IF NOT EXISTS idx_conversation_history_conversationId ON conversation_history(conversationId)
-          `);
-                }
-            }
-        }
-        // Check if threads table exists
-        const threadsExists = await db.execute(`SELECT name FROM sqlite_master WHERE type='table' AND name='threads'`);
-        if (threadsExists.rows.length > 0) {
-            // Migration: Add ON DELETE CASCADE to threads.projectId foreign key
-            const threadsTableInfo = await db.execute(`
-        SELECT sql FROM sqlite_master 
-        WHERE type='table' AND name='threads'
-      `);
-            if (threadsTableInfo.rows.length > 0) {
-                const tableSql = threadsTableInfo.rows[0].sql;
-                if (!tableSql.includes("ON DELETE CASCADE")) {
-                    console.log("[db] Running migration: Adding ON DELETE CASCADE to threads.projectId foreign key");
-                    // Clean up any existing threads_new table from interrupted migration
-                    await db.execute(`DROP TABLE IF EXISTS threads_new`);
-                    // Temporarily disable foreign key constraints for the migration
-                    await db.execute("PRAGMA foreign_keys = OFF");
-                    try {
-                        // Recreate table with CASCADE
-                        await db.execute(`
-              CREATE TABLE threads_new AS SELECT 
-                id, 
-                projectId, 
-                title, 
-                path, 
-                currentBranch, 
-                createdAt, 
-                enabledSkills, 
-                disabledSkills, 
-                currentConversationId,
-                status
-              FROM threads
-            `);
-                        await db.execute(`DROP TABLE threads`);
-                        await db.execute(`
-              CREATE TABLE threads (
-                id TEXT PRIMARY KEY,
-                projectId TEXT NOT NULL,
-                title TEXT NOT NULL,
-                path TEXT NOT NULL,
-                currentBranch TEXT NOT NULL,
-                createdAt TEXT NOT NULL,
-                enabledSkills TEXT,
-                disabledSkills TEXT,
-                currentConversationId TEXT,
-                status TEXT NOT NULL DEFAULT 'active',
-                FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE
-              )
-            `);
-                        await db.execute(`
-              INSERT INTO threads SELECT 
-                id, 
-                projectId, 
-                title, 
-                path, 
-                currentBranch, 
-                createdAt, 
-                enabledSkills, 
-                disabledSkills, 
-                currentConversationId,
-                status
-              FROM threads_new
-            `);
-                        await db.execute(`DROP TABLE threads_new`);
-                        // Recreate index
-                        await db.execute(`
-              CREATE INDEX IF NOT EXISTS idx_threads_projectId ON threads(projectId)
-            `);
-                    }
-                    finally {
-                        // Re-enable foreign key constraints
-                        await db.execute("PRAGMA foreign_keys = ON");
-                    }
-                }
-            }
-            // Migration: Add currentConversationId column to threads if it doesn't exist
-            const threadsInfo = await db.execute(`PRAGMA table_info(threads)`);
-            const hasCurrentConversationId = threadsInfo.rows.some((col) => col.name === "currentConversationId");
-            const hasStatusColumn = threadsInfo.rows.some((col) => col.name === "status");
-            if (!hasCurrentConversationId) {
-                console.log("[db] Running migration: Adding currentConversationId column to threads");
-                await db.execute(`ALTER TABLE threads ADD COLUMN currentConversationId TEXT`);
-            }
-            if (!hasStatusColumn) {
-                console.log("[db] Running migration: Adding status column to threads");
-                await db.execute(`ALTER TABLE threads ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
-            }
-            const hasDiffComments = threadsInfo.rows.some((col) => col.name === "diffComments");
-            if (!hasDiffComments) {
-                console.log("[db] Running migration: Adding diffComments column to threads");
-                await db.execute(`ALTER TABLE threads ADD COLUMN diffComments TEXT`);
-            }
-            const hasModel = threadsInfo.rows.some((col) => col.name === "model");
-            if (!hasModel) {
-                console.log("[db] Running migration: Adding model column to threads");
-                await db.execute(`ALTER TABLE threads ADD COLUMN model TEXT`);
-            }
-            const hasModelProvider = threadsInfo.rows.some((col) => col.name === "modelProvider");
-            if (!hasModelProvider) {
-                console.log("[db] Running migration: Adding modelProvider column to threads");
-                await db.execute(`ALTER TABLE threads ADD COLUMN modelProvider TEXT`);
-            }
-            // Migration: Update existing model data to include provider
-            const hasModelColumn = threadsInfo.rows.some((col) => col.name === "model");
-            if (hasModelColumn) {
-                console.log("[db] Running migration: Updating existing model data to include provider");
-                // Set modelProvider to 'unknown' for threads that have model but no modelProvider
-                // This indicates the provider couldn't be determined from the model format
-                await db.execute(`
-          UPDATE threads 
-          SET modelProvider = 'unknown'
-          WHERE model IS NOT NULL AND modelProvider IS NULL
-        `);
-                console.log("[db] Updated rows:", (await db.execute("SELECT id, model, modelProvider FROM threads")).rows);
-            }
-        }
-        // Migration: Add threadId to project_todos
-        const projectTodosInfo = await db.execute(`PRAGMA table_info(project_todos)`);
-        const hasThreadIdColumn = projectTodosInfo.rows.some((col) => col.name === "threadId");
-        if (!hasThreadIdColumn) {
-            console.log("[db] Running migration: Adding threadId column to project_todos");
-            await db.execute(`ALTER TABLE project_todos ADD COLUMN threadId TEXT`);
-        }
-        // Migration: Create git_status_cache table if it doesn't exist
-        const gitStatusCacheExists = await db.execute(`SELECT name FROM sqlite_master WHERE type='table' AND name='git_status_cache'`);
-        if (gitStatusCacheExists.rows.length === 0) {
-            console.log("[db] Running migration: Creating git_status_cache table");
-            await db.execute(`
-        CREATE TABLE git_status_cache (
-          threadId TEXT PRIMARY KEY,
-          data TEXT NOT NULL,
-          cachedAt TEXT NOT NULL
-        )
-      `);
-        }
-    }
-    catch (error) {
-        console.error("Failed to run migrations:", error);
-        throw error;
-    }
-}
-/**
- * Close database connection
- * @param db SQLite database instance
- */
-export async function closeDatabase(_db) {
-    // libsql-js doesn't have an explicit close method for file-based connections
-}
-// Singleton instance
-let dbInstance = null;
-/**
- * Get or create the singleton database instance
- * @returns SQLite database instance
- */
-export async function getDatabase() {
-    dbInstance ??= await initializeDatabase();
-    return dbInstance;
-}
-/**
- * Close the singleton database instance
- */
-export async function closeDatabaseInstance() {
-    if (dbInstance) {
-        await closeDatabase(dbInstance);
-        dbInstance = null;
-    }
-}
-//# sourceMappingURL=database.js.map

package/dist/database/database.state.d.ts

@@ -1,52 +0,0 @@
-/**
- * SQLite Database Operations for Application State
- *
- * This module handles key-value state storage in the SQLite database.
- * Supports complex values through JSON serialization.
- */
-import { Database } from "./database.types";
-/**
- * Set a state value
- * @param db SQLite database instance
- * @param key State key
- * @param value State value (will be JSON serialized)
- */
-export declare function setState(db: Database, key: string, value: unknown): Promise<void>;
-/**
- * Get a state value
- * @param db SQLite database instance
- * @param key State key
- * @returns Deserialized state value or null if not found
- */
-export declare function getState(db: Database, key: string): Promise<unknown>;
-/**
- * Get all state as a record
- * @param db SQLite database instance
- * @returns Record of all state key-value pairs
- */
-export declare function getAllState(db: Database): Promise<Record<string, unknown>>;
-/**
- * Delete a state value
- * @param db SQLite database instance
- * @param key State key
- */
-export declare function deleteState(db: Database, key: string): Promise<void>;
-/**
- * Check if a state key exists
- * @param db SQLite database instance
- * @param key State key
- * @returns True if key exists
- */
-export declare function stateKeyExists(db: Database, key: string): Promise<boolean>;
-/**
- * Clear all state
- * @param db SQLite database instance
- */
-export declare function clearAllState(db: Database): Promise<void>;
-/**
- * Get state value count
- * @param db SQLite database instance
- * @returns Number of state entries
- */
-export declare function getStateCount(db: Database): Promise<number>;
-//# sourceMappingURL=database.state.d.ts.map

package/dist/database/database.state.js

@@ -1,119 +0,0 @@
-/**
- * SQLite Database Operations for Application State
- *
- * This module handles key-value state storage in the SQLite database.
- * Supports complex values through JSON serialization.
- */
-/**
- * Set a state value
- * @param db SQLite database instance
- * @param key State key
- * @param value State value (will be JSON serialized)
- */
-export async function setState(db, key, value) {
-    try {
-        const serialized = JSON.stringify(value);
-        await db.execute("INSERT OR REPLACE INTO state (key, value) VALUES (?, ?)", [key, serialized]);
-    }
-    catch (error) {
-        console.error(`Failed to set state for key "${key}":`, error);
-        throw error;
-    }
-}
-/**
- * Get a state value
- * @param db SQLite database instance
- * @param key State key
- * @returns Deserialized state value or null if not found
- */
-export async function getState(db, key) {
-    const result = await db.execute("SELECT value FROM state WHERE key = ?", [key]);
-    const row = result.rows[0];
-    if (!row) {
-        return null;
-    }
-    try {
-        return JSON.parse(row.value);
-    }
-    catch (error) {
-        console.error(`Failed to parse state value for key "${key}":`, error);
-        return null;
-    }
-}
-/**
- * Get all state as a record
- * @param db SQLite database instance
- * @returns Record of all state key-value pairs
- */
-export async function getAllState(db) {
-    try {
-        const result = await db.execute("SELECT key, value FROM state");
-        const rows = result.rows;
-        const stateResult = {};
-        for (const row of rows) {
-            // Skip encryption_key as it's handled separately by crypto module
-            if (row.key === "encryption_key") {
-                continue;
-            }
-            try {
-                stateResult[row.key] = JSON.parse(row.value);
-            }
-            catch (error) {
-                console.error(`Failed to parse state value for key "${row.key}":`, error);
-                stateResult[row.key] = null;
-            }
-        }
-        return stateResult;
-    }
-    catch (error) {
-        console.error("Failed to get all state:", error);
-        throw error;
-    }
-}
-/**
- * Delete a state value
- * @param db SQLite database instance
- * @param key State key
- */
-export async function deleteState(db, key) {
-    try {
-        await db.execute("DELETE FROM state WHERE key = ?", [key]);
-    }
-    catch (error) {
-        console.error(`Failed to delete state for key "${key}":`, error);
-        throw error;
-    }
-}
-/**
- * Check if a state key exists
- * @param db SQLite database instance
- * @param key State key
- * @returns True if key exists
- */
-export async function stateKeyExists(db, key) {
-    const result = await db.execute("SELECT 1 FROM state WHERE key = ? LIMIT 1", [key]);
-    return result.rows.length > 0;
-}
-/**
- * Clear all state
- * @param db SQLite database instance
- */
-export async function clearAllState(db) {
-    try {
-        await db.execute("DELETE FROM state");
-    }
-    catch (error) {
-        console.error("Failed to clear all state:", error);
-        throw error;
-    }
-}
-/**
- * Get state value count
- * @param db SQLite database instance
- * @returns Number of state entries
- */
-export async function getStateCount(db) {
-    const result = await db.execute("SELECT COUNT(*) as count FROM state");
-    return result.rows[0].count;
-}
-//# sourceMappingURL=database.state.js.map

package/dist/database/database.test-utils.d.ts

@@ -1,22 +0,0 @@
-/**
- * Test Database Utilities
- *
- * Provides in-memory SQLite database for testing using libsql-js
- * for compatibility with Node test environment.
- */
-import type { Database } from "./database.types";
-/**
- * Create an in-memory database for testing
- * @returns SQLite database instance compatible with libsql-js API
- */
-export declare function createTestDatabase(): Promise<Database>;
-/**
- * Mock the database module for testing
- * @returns Mock database functions
- */
-export declare function createMockDatabase(): Promise<{
-    initializeDatabase: () => import("@libsql/client").Client;
-    getDatabase: () => import("@libsql/client").Client;
-    getDatabasePath: () => string;
-}>;
-//# sourceMappingURL=database.test-utils.d.ts.map