tarsk 0.4.4 → 0.4.6

package/dist/features/mcp/mcp.routes.js

@@ -1,159 +0,0 @@
-/**
- * MCP routes for the REST API
- *
- * Handles all MCP-related operations:
- * - GET /api/mcp/config?projectPath=... - Get current MCP config for a project
- * - PUT /api/mcp/config - Save or update a server in the MCP config
- * - DELETE /api/mcp/config/:serverName?projectPath=... - Remove a server from MCP config
- * - GET /api/mcp/popular - List popular MCP servers
- * - GET /api/mcp/search?q=...&limit=... - Search MCP registry
- */
-import { Hono } from "hono";
-import { readFile, writeFile, mkdir, access } from "fs/promises";
-import { join, dirname } from "path";
-import popularServers from "./mcp.popular.json" with { type: "json" };
-const MCP_CONFIG_PATHS = [".agents/mcp.json", "mcp.json"];
-async function readMCPConfig(projectPath) {
-    for (const configPath of MCP_CONFIG_PATHS) {
-        const fullPath = join(projectPath, configPath);
-        try {
-            await access(fullPath);
-            const content = await readFile(fullPath, "utf-8");
-            const config = JSON.parse(content);
-            return { config, filePath: fullPath };
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-async function writeMCPConfig(projectPath, config) {
-    // Prefer .agents/mcp.json, fall back to existing file location
-    const existing = await readMCPConfig(projectPath);
-    const targetPath = existing?.filePath ?? join(projectPath, ".agents/mcp.json");
-    await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, JSON.stringify(config, null, 2), "utf-8");
-}
-export function createMCPRoutes() {
-    const router = new Hono();
-    /**
-     * GET /api/mcp/config?projectPath=...
-     * Get the current MCP configuration for a project
-     */
-    router.get("/config", async (c) => {
-        const projectPath = c.req.query("projectPath");
-        if (!projectPath) {
-            return c.json({ error: { code: "BAD_REQUEST", message: "projectPath query parameter is required" } }, 400);
-        }
-        try {
-            const result = await readMCPConfig(projectPath);
-            if (!result) {
-                return c.json({ servers: {} });
-            }
-            return c.json(result.config);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
-        }
-    });
-    /**
-     * PUT /api/mcp/config
-     * Save or update a single MCP server configuration
-     *
-     * Body: { projectPath: string, serverName: string, serverConfig: MCPServerConfig }
-     */
-    router.put("/config", async (c) => {
-        let body;
-        try {
-            body = await c.req.json();
-        }
-        catch {
-            return c.json({ error: { code: "BAD_REQUEST", message: "Invalid JSON body" } }, 400);
-        }
-        const { projectPath, serverName, serverConfig } = body;
-        if (!projectPath || !serverName || !serverConfig) {
-            return c.json({
-                error: {
-                    code: "BAD_REQUEST",
-                    message: "projectPath, serverName, and serverConfig are required",
-                },
-            }, 400);
-        }
-        try {
-            const existing = await readMCPConfig(projectPath);
-            const config = existing?.config ?? { servers: {} };
-            config.servers[serverName] = serverConfig;
-            await writeMCPConfig(projectPath, config);
-            return c.json({ success: true, message: `Server "${serverName}" saved` });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
-        }
-    });
-    /**
-     * DELETE /api/mcp/config/:serverName?projectPath=...
-     * Remove a server from the MCP configuration
-     */
-    router.delete("/config/:serverName", async (c) => {
-        const serverName = c.req.param("serverName");
-        const projectPath = c.req.query("projectPath");
-        if (!projectPath) {
-            return c.json({ error: { code: "BAD_REQUEST", message: "projectPath query parameter is required" } }, 400);
-        }
-        try {
-            const existing = await readMCPConfig(projectPath);
-            if (!existing) {
-                return c.json({ error: { code: "NOT_FOUND", message: "No MCP configuration found" } }, 404);
-            }
-            if (!existing.config.servers[serverName]) {
-                return c.json({ error: { code: "NOT_FOUND", message: `Server "${serverName}" not found` } }, 404);
-            }
-            delete existing.config.servers[serverName];
-            await writeMCPConfig(projectPath, existing.config);
-            return c.json({ success: true, message: `Server "${serverName}" removed` });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return c.json({ error: { code: "INTERNAL_ERROR", message } }, 500);
-        }
-    });
-    /**
-     * GET /api/mcp/popular
-     * Returns the list of popular MCP servers
-     */
-    router.get("/popular", (c) => {
-        return c.json({ servers: popularServers });
-    });
-    /**
-     * GET /api/mcp/search?q=...&limit=...
-     * Proxies search requests to the MCP registry
-     */
-    router.get("/search", async (c) => {
-        const q = c.req.query("q") ?? "";
-        const limit = c.req.query("limit") ?? "10";
-        try {
-            const url = `https://registry.modelcontextprotocol.io/v0/servers?search=${encodeURIComponent(q)}&limit=${encodeURIComponent(limit)}`;
-            console.log(`[MCP Search] GET ${url}`);
-            const response = await fetch(url, {
-                headers: { Accept: "application/json" },
-            });
-            if (!response.ok) {
-                console.warn(`[MCP Search] Registry returned ${response.status} ${response.statusText}`);
-                return c.json({ error: { code: "REGISTRY_ERROR", message: `Registry returned ${response.status}` } }, 502);
-            }
-            const data = await response.json();
-            console.log(`[MCP Search] Response:`, JSON.stringify(data, null, 2));
-            return c.json(data);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`[MCP Search] Fetch error:`, message);
-            return c.json({ error: { code: "FETCH_ERROR", message } }, 502);
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=mcp.routes.js.map

package/dist/features/mcp/mcp.types.d.ts

@@ -1,80 +0,0 @@
-/**
- * MCP (Model Context Protocol) type definitions
- *
- * This file contains type definitions specific to the MCP implementation
- * in the Tarsk CLI, extending the shared types with implementation details.
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import type { MCPServerConfig, MCPConfig, MCPTool } from "@tarsk/shared";
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-/**
- * MCP Server connection state
- */
-export type MCPServerState = "disconnected" | "connecting" | "connected" | "error";
-/**
- * MCP Server instance with connection state and tools
- */
-export interface MCPServerInstance {
-    /** Server configuration */
-    config: MCPServerConfig;
-    /** Current connection state */
-    state: MCPServerState;
-    /** Available tools from this server */
-    tools: MCPTool[];
-    /** Error message if state is 'error' */
-    error?: string;
-    /** Last modification time of the configuration file */
-    lastModified?: Date;
-    /** MCP client instance */
-    client?: Client;
-}
-/**
- * MCP Manager interface
- */
-export interface MCPManager {
-    /**
-     * Load MCP configuration from file
-     * @param projectPath - Path to the project directory
-     * @returns Promise resolving to MCP configuration or null if not found
-     */
-    loadConfig(projectPath: string): Promise<MCPConfig | null>;
-    /**
-     * Get all available MCP tools for a project
-     * @param projectPath - Path to the project directory
-     * @returns Promise resolving to array of MCP tools
-     */
-    getTools(projectPath: string): Promise<MCPTool[]>;
-    /**
-     * Execute an MCP tool
-     * @param toolName - Name of the tool to execute
-     * @param args - Tool arguments
-     * @param projectPath - Path to the project directory
-     * @returns Promise resolving to tool execution result
-     */
-    executeTool(toolName: string, args: Record<string, unknown>, projectPath: string): Promise<unknown>;
-    /**
-     * Check if MCP configuration needs reloading
-     * @param projectPath - Path to the project directory
-     * @returns Promise resolving to true if configuration needs reloading
-     */
-    needsReload(projectPath: string): Promise<boolean>;
-    /**
-     * Clear cached configuration for a project
-     * @param projectPath - Path to the project directory
-     */
-    clearCache(projectPath: string): void;
-}
-/**
- * MCP Tool wrapper for Pi Agent integration
- */
-export interface MCPToolWrapper extends AgentTool<any> {
-    /** Name of the MCP server that provides this tool */
-    serverName: string;
-    /** Original MCP tool definition */
-    mcpTool: MCPTool;
-    /** Tool parameters schema */
-    parameters: any;
-    /** Tool label for display */
-    label: string;
-}
-//# sourceMappingURL=mcp.types.d.ts.map

package/dist/features/mcp/mcp.types.js

@@ -1,8 +0,0 @@
-/**
- * MCP (Model Context Protocol) type definitions
- *
- * This file contains type definitions specific to the MCP implementation
- * in the Tarsk CLI, extending the shared types with implementation details.
- */
-export {};
-//# sourceMappingURL=mcp.types.js.map

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

@@ -1,126 +0,0 @@
-/**
- * MetadataManager handles persistence of project and thread metadata
- *
- * This manager provides SQLite-based storage with atomic transactions
- * to ensure data consistency.
- */
-import { Project, Thread } from "@tarsk/shared";
-/**
- * MetadataManager manages persistence of projects and threads
- */
-interface AppState {
-    selectedThreadId: string | null;
-    providerKeys: Record<string, string>;
-    enabledModels: Record<string, string[]>;
-    onboardingCompleted: boolean;
-}
-export declare class MetadataManager {
-    private db;
-    /**
-     * Create a new MetadataManager
-     * @param _dataDir - Directory where metadata files will be stored
-     *                  (e.g. ~/Library/Application Support/Tarsk/data)
-     */
-    constructor(_dataDir: string);
-    /**
-     * Initialize metadata database
-     */
-    initialize(): Promise<void>;
-    /**
-     * Save projects to database using atomic transaction
-     * @param projects - Array of projects to save
-     */
-    saveProjects(projects: Project[]): Promise<void>;
-    /**
-     * Load projects from database
-     * @returns Array of projects
-     */
-    loadProjects(): Promise<Project[]>;
-    /**
-     * Save threads to database using atomic transaction
-     * @param threads - Array of threads to save
-     */
-    saveThreads(threads: Thread[]): Promise<void>;
-    /**
-     * Load threads from database
-     * @returns Array of threads
-     */
-    loadThreads(): Promise<Thread[]>;
-    /**
-     * Save application state to database
-     * @param state - Application state to save
-     */
-    saveState(state: AppState): Promise<void>;
-    /**
-     * Load application state from database
-     * @returns Application state
-     */
-    loadState(): Promise<AppState>;
-    /**
-     * Update all provider keys at once
-     * @param keys - Object mapping provider names to API keys
-     */
-    saveAllProviderKeys(keys: Record<string, string>): Promise<void>;
-    /**
-     * Update provider keys
-     * @param providerName - Name of the provider
-     * @param apiKey - API key to save (will be encrypted if not already)
-     */
-    saveProviderKey(providerName: string, apiKey: string): Promise<void>;
-    /**
-     * Get all provider keys
-     * @returns Record of provider names to decrypted API keys
-     */
-    getProviderKeys(): Promise<Record<string, string>>;
-    /**
-     * Set the selected thread ID
-     * @param threadId - Thread ID to select (or null to deselect)
-     */
-    setSelectedThread(threadId: string | null): Promise<void>;
-    /**
-     * Get the selected thread ID
-     * @returns The selected thread ID or null
-     */
-    getSelectedThread(): Promise<string | null>;
-    /**
-     * Enable a model for a provider
-     * @param provider - Provider name
-     * @param modelId - Model ID to enable
-     */
-    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 enabled models for a provider
-     * @param provider - Provider name
-     * @returns Array of enabled model IDs
-     */
-    getEnabledModels(provider: string): Promise<string[]>;
-    /**
-     * Get all enabled models across all providers
-     * @returns Object mapping provider to array of model IDs
-     */
-    getAllEnabledModels(): Promise<Record<string, string[]>>;
-    /**
-     * Set enabled models for a provider
-     * @param provider - Provider name
-     * @param modelIds - Array of model IDs to enable
-     */
-    setEnabledModels(provider: string, modelIds: string[]): Promise<void>;
-    /**
-     * Set onboarding completed flag
-     * @param completed - Whether onboarding is completed
-     */
-    setOnboardingCompleted(completed: boolean): Promise<void>;
-    /**
-     * Get onboarding completed flag
-     * @returns Whether onboarding has been completed
-     */
-    getOnboardingCompleted(): Promise<boolean>;
-}
-export {};
-//# sourceMappingURL=metadata.manager.d.ts.map