tarsk 0.4.4 → 0.4.6

package/dist/agent/agent.model-resolver.js

@@ -1,67 +0,0 @@
-/**
- * Model resolver for Pi Agent
- * Handles provider mapping and model resolution for different AI providers
- */
-import { getModel } from "@mariozechner/pi-ai";
-/**
- * Maps provider names to Pi AI known provider identifiers
- */
-export const PROVIDER_NAME_TO_PI = {
-    anthropic: "anthropic",
-    openai: "openai",
-    google: "google",
-    groq: "groq",
-    cerebras: "cerebras",
-    xai: "xai",
-    openrouter: "openrouter",
-    "github copilot": "github-copilot",
-    minimax: "minimax",
-    "kimi coding plan": "kimi-coding",
-    "hugging face": "huggingface",
-    codex: "openai-codex",
-    mistral: "mistral",
-};
-/**
- * Determines the API type based on the provider's API URL
- */
-export function determineApiType(apiUrl) {
-    if (apiUrl.includes("/anthropic/"))
-        return "anthropic-messages";
-    if (apiUrl.includes("api.anthropic.com"))
-        return "anthropic-messages";
-    return "openai-completions";
-}
-/**
- * Resolves a model configuration for the Pi Agent
- * First attempts to use known providers from pi-ai registry,
- * then falls back to creating a custom model configuration
- */
-export function resolveModel(providerName, modelId, providerConfig) {
-    const piProvider = PROVIDER_NAME_TO_PI[providerName.toLowerCase()];
-    if (piProvider) {
-        try {
-            return getModel(piProvider, modelId);
-        }
-        catch {
-            // Model not in pi-ai registry — fall through to custom model
-        }
-    }
-    const baseUrl = providerConfig.api;
-    if (!baseUrl) {
-        throw new Error(`No API URL configured for provider: ${providerName}`);
-    }
-    const apiType = determineApiType(baseUrl);
-    return {
-        id: modelId,
-        name: modelId,
-        api: apiType,
-        provider: providerName.toLowerCase(),
-        baseUrl,
-        reasoning: false,
-        input: ["text"],
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-        contextWindow: 128000,
-        maxTokens: 16384,
-    };
-}
-//# sourceMappingURL=agent.model-resolver.js.map

package/dist/agent/agent.process-manager.d.ts

@@ -1,57 +0,0 @@
-/**
- * ProcessManager handles running and stopping dev server processes
- *
- * This manager is responsible for:
- * - Starting dev server processes with output capture
- * - Detecting URLs from process output
- * - Stopping running processes
- * - Streaming output back to the frontend
- */
-import { EventEmitter } from "events";
-export interface ProcessOutput {
-    type: "stdout" | "stderr" | "url" | "error" | "complete";
-    content?: string;
-    url?: string;
-    error?: unknown;
-}
-export declare class ProcessManager extends EventEmitter {
-    private processes;
-    private detectedUrls;
-    private queues;
-    private resolvers;
-    /**
-     * Run a command and stream its output
-     * @param projectId - The project ID (used as a key)
-     * @param command - The command to run (e.g., "npm run dev")
-     * @param cwd - Working directory to run the command in
-     * @param threadId - The thread ID to cache the URL for
-     * @returns AsyncGenerator that yields ProcessOutput events
-     */
-    runProcess(projectId: string, command: string, cwd: string, threadId: string): AsyncGenerator<ProcessOutput>;
-    /**
-     * Stop a running process
-     * @param projectId - The project ID
-     * @param threadId - The thread ID to clear the URL from cache
-     * @returns true if process was stopped, false if no process was running
-     */
-    stopProcess(projectId: string, threadId?: string): boolean;
-    /**
-     * Check if a process is running for a project
-     * @param projectId - The project ID
-     * @returns true if a process is running
-     */
-    isRunning(projectId: string): boolean;
-    /**
-     * Get the detected URL for a running process
-     * @param projectId - The project ID
-     * @returns The URL if detected, undefined otherwise
-     */
-    getDetectedUrl(projectId: string): string | undefined;
-    /**
-     * Detect URL from text output
-     * @param text - The text to search for URLs
-     * @returns The first detected URL or undefined
-     */
-    private detectUrl;
-}
-//# sourceMappingURL=agent.process-manager.d.ts.map

package/dist/agent/agent.process-manager.js

@@ -1,262 +0,0 @@
-/**
- * ProcessManager handles running and stopping dev server processes
- *
- * This manager is responsible for:
- * - Starting dev server processes with output capture
- * - Detecting URLs from process output
- * - Stopping running processes
- * - Streaming output back to the frontend
- */
-import { spawnProcess } from "../core/utils.js";
-import { EventEmitter } from "events";
-import { devServerCache } from "../core/dev-server-cache.js";
-let Utils = null;
-let utilsLoaded = false;
-// Lazy load Utils from electrobun (optional - may not be available in pure server mode)
-async function loadUtils() {
-    if (utilsLoaded)
-        return;
-    utilsLoaded = true;
-    try {
-        const electrobun = await import("electrobun/bun");
-        Utils = electrobun.Utils;
-    }
-    catch {
-        // electrobun not available in pure server mode - that's OK
-    }
-}
-// Common patterns for detecting dev server URLs in output
-const URL_PATTERNS = [
-    // http(s)://localhost:PORT
-    /https?:\/\/localhost[:/](\d+)/i,
-    // localhost:PORT
-    /localhost:(\d+)/i,
-    // 127.0.0.1:PORT
-    /127\.0\.0\.1:(\d+)/i,
-    // http://0.0.0.0:PORT or http://[::]:PORT (for IPv6)
-    /https?:\/\/(0\.0\.0\.0|\[::?\]):(\d+)/i,
-    // Local address patterns like http://192.168...
-    /https?:\/\/(192\.168\.\d+\.\d+):(\d+)/i,
-];
-export class ProcessManager extends EventEmitter {
-    processes = new Map();
-    detectedUrls = new Map();
-    queues = new Map();
-    resolvers = new Map();
-    /**
-     * Run a command and stream its output
-     * @param projectId - The project ID (used as a key)
-     * @param command - The command to run (e.g., "npm run dev")
-     * @param cwd - Working directory to run the command in
-     * @param threadId - The thread ID to cache the URL for
-     * @returns AsyncGenerator that yields ProcessOutput events
-     */
-    async *runProcess(projectId, command, cwd, threadId) {
-        console.log("CLI ProcessManager: runProcess called for project:", projectId, "thread:", threadId, "command:", command, "cwd:", cwd);
-        // Load utils (may fail gracefully if electrobun not available)
-        await loadUtils();
-        // Check if a process is already running for this project
-        if (this.processes.has(projectId)) {
-            console.log("CLI ProcessManager: Process already running for project:", projectId);
-            yield {
-                type: "error",
-                error: new Error("A process is already running for this project"),
-            };
-            return;
-        }
-        console.log("CLI ProcessManager: Starting new process for project:", projectId);
-        // Initialize queue for this process
-        this.queues.set(projectId, []);
-        this.resolvers.set(projectId, []);
-        const addToQueue = (output) => {
-            const queue = this.queues.get(projectId);
-            if (queue) {
-                queue.push(output);
-                // Call any pending resolvers
-                const res = this.resolvers.get(projectId);
-                if (res && res.length > 0) {
-                    const resolver = res.shift();
-                    if (resolver)
-                        resolver();
-                }
-            }
-        };
-        const waitForQueue = () => {
-            return new Promise((resolve) => {
-                const queue = this.queues.get(projectId);
-                if (queue && queue.length > 0) {
-                    resolve();
-                }
-                else {
-                    const res = this.resolvers.get(projectId);
-                    if (res)
-                        res.push(resolve);
-                }
-            });
-        };
-        try {
-            const [cmd, ...args] = command.split(" ");
-            console.log("CLI ProcessManager: Spawning process:", cmd, "with args:", args);
-            const childProcess = spawnProcess(cmd, args, {
-                cwd,
-                shell: true,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            this.processes.set(projectId, childProcess);
-            console.log("CLI ProcessManager: Process spawned with PID:", childProcess.pid);
-            let urlDetected = false;
-            let urlBuffer = "";
-            // Handle stdout - add to queue immediately
-            childProcess.stdout?.on("data", (data) => {
-                const text = data.toString();
-                urlBuffer += text;
-                // Try to detect URL
-                if (!urlDetected) {
-                    const detectedUrl = this.detectUrl(urlBuffer);
-                    if (detectedUrl) {
-                        urlDetected = true;
-                        this.detectedUrls.set(projectId, detectedUrl);
-                        // Store URL in the thread-based cache
-                        devServerCache.setUrl(threadId, detectedUrl);
-                        // Open the URL in the system's default browser (only in desktop mode with electrobun)
-                        if (Utils) {
-                            Utils.openExternal(detectedUrl);
-                        }
-                        addToQueue({ type: "url", url: detectedUrl });
-                    }
-                }
-                addToQueue({ type: "stdout", content: text });
-            });
-            // Handle stderr - add to queue immediately
-            childProcess.stderr?.on("data", (data) => {
-                const text = data.toString();
-                urlBuffer += text;
-                // Try to detect URL in stderr as well
-                if (!urlDetected) {
-                    const detectedUrl = this.detectUrl(urlBuffer);
-                    if (detectedUrl) {
-                        urlDetected = true;
-                        this.detectedUrls.set(projectId, detectedUrl);
-                        // Store URL in the thread-based cache
-                        devServerCache.setUrl(threadId, detectedUrl);
-                        // Open the URL in the system's default browser (only in desktop mode with electrobun)
-                        if (Utils) {
-                            Utils.openExternal(detectedUrl);
-                        }
-                        addToQueue({ type: "url", url: detectedUrl });
-                    }
-                }
-                addToQueue({ type: "stderr", content: text });
-            });
-            // Handle process end
-            let processEnded = false;
-            childProcess.on("close", () => {
-                processEnded = true;
-                this.processes.delete(projectId);
-                addToQueue({ type: "complete" });
-                // Call any pending resolvers to flush the queue
-                const res = this.resolvers.get(projectId);
-                if (res) {
-                    res.forEach((r) => r());
-                    res.length = 0;
-                }
-            });
-            childProcess.on("error", (err) => {
-                processEnded = true;
-                this.processes.delete(projectId);
-                addToQueue({ type: "error", error: err });
-                // Call any pending resolvers to flush the queue
-                const res = this.resolvers.get(projectId);
-                if (res) {
-                    res.forEach((r) => r());
-                    res.length = 0;
-                }
-            });
-            // Yield items from the queue
-            while (true) {
-                const queue = this.queues.get(projectId);
-                if (queue && queue.length > 0) {
-                    const output = queue.shift();
-                    if (output) {
-                        yield output;
-                        if (output.type === "complete" || output.type === "error") {
-                            break;
-                        }
-                    }
-                }
-                else if (processEnded) {
-                    break;
-                }
-                else {
-                    // Wait for more data
-                    await waitForQueue();
-                }
-            }
-        }
-        catch (error) {
-            this.processes.delete(projectId);
-            this.detectedUrls.delete(projectId);
-            yield { type: "error", error };
-        }
-        finally {
-            // Cleanup
-            this.queues.delete(projectId);
-            this.resolvers.delete(projectId);
-        }
-    }
-    /**
-     * Stop a running process
-     * @param projectId - The project ID
-     * @param threadId - The thread ID to clear the URL from cache
-     * @returns true if process was stopped, false if no process was running
-     */
-    stopProcess(projectId, threadId) {
-        const process = this.processes.get(projectId);
-        if (!process) {
-            return false;
-        }
-        process.kill();
-        this.processes.delete(projectId);
-        this.detectedUrls.delete(projectId);
-        // Clear URL from thread-based cache if threadId is provided
-        if (threadId) {
-            devServerCache.clearUrl(threadId);
-        }
-        return true;
-    }
-    /**
-     * Check if a process is running for a project
-     * @param projectId - The project ID
-     * @returns true if a process is running
-     */
-    isRunning(projectId) {
-        return this.processes.has(projectId);
-    }
-    /**
-     * Get the detected URL for a running process
-     * @param projectId - The project ID
-     * @returns The URL if detected, undefined otherwise
-     */
-    getDetectedUrl(projectId) {
-        return this.detectedUrls.get(projectId);
-    }
-    /**
-     * Detect URL from text output
-     * @param text - The text to search for URLs
-     * @returns The first detected URL or undefined
-     */
-    detectUrl(text) {
-        for (const pattern of URL_PATTERNS) {
-            const match = text.match(pattern);
-            if (match) {
-                // For simple localhost patterns, construct the full URL
-                if (match[1] && !match[0].includes("://")) {
-                    return `http://localhost:${match[1]}`;
-                }
-                return match[0];
-            }
-        }
-        return undefined;
-    }
-}
-//# sourceMappingURL=agent.process-manager.js.map

package/dist/agent/agent.processing-state-manager.d.ts

@@ -1,74 +0,0 @@
-/**
- * ProcessingStateManager tracks which threads currently have active chat processing
- *
- * This is an in-memory store that tracks thread IDs that are currently
- * processing chat messages. The frontend can poll this to show/hide spinners.
- * It also buffers streaming events so late subscribers can replay them.
- */
-import type { AgentEvent } from "@tarsk/shared";
-export type StreamSubscriber = (event: AgentEvent) => void;
-export interface ProcessingStateManager {
-    /**
-     * Mark a thread as currently processing
-     * @param threadId - The thread ID that started processing
-     */
-    setProcessing(threadId: string): void;
-    /**
-     * Mark a thread as no longer processing
-     * @param threadId - The thread ID that finished processing
-     */
-    clearProcessing(threadId: string): void;
-    /**
-     * Check if a thread is currently processing
-     * @param threadId - The thread ID to check
-     * @returns true if the thread is processing
-     */
-    isProcessing(threadId: string): boolean;
-    /**
-     * Get all thread IDs that are currently processing
-     * @returns Array of thread IDs
-     */
-    getProcessingThreadIds(): string[];
-    /**
-     * Push a streaming event for a thread (buffered for late subscribers)
-     */
-    pushEvent(threadId: string, event: AgentEvent): void;
-    /**
-     * Subscribe to a thread's stream. Replays buffered events immediately,
-     * then delivers new events as they arrive. Returns an unsubscribe function.
-     */
-    subscribe(threadId: string, subscriber: StreamSubscriber): () => void;
-    /**
-     * Get buffered events for a thread
-     */
-    getBufferedEvents(threadId: string): AgentEvent[];
-    /**
-     * Register the AbortController for a thread's active execution so it can
-     * be cancelled via the stop endpoint regardless of connection state.
-     */
-    registerAbortController(threadId: string, controller: AbortController): void;
-    /**
-     * Abort the active execution for a thread.
-     * @returns true if an active controller was found and aborted
-     */
-    abortThread(threadId: string): boolean;
-}
-/**
- * Implementation of ProcessingStateManager using an in-memory Set
- */
-export declare class ProcessingStateManagerImpl implements ProcessingStateManager {
-    private processingThreads;
-    private eventBuffers;
-    private subscribers;
-    private abortControllers;
-    setProcessing(threadId: string): void;
-    registerAbortController(threadId: string, controller: AbortController): void;
-    abortThread(threadId: string): boolean;
-    clearProcessing(threadId: string): void;
-    isProcessing(threadId: string): boolean;
-    getProcessingThreadIds(): string[];
-    pushEvent(threadId: string, event: AgentEvent): void;
-    subscribe(threadId: string, subscriber: StreamSubscriber): () => void;
-    getBufferedEvents(threadId: string): AgentEvent[];
-}
-//# sourceMappingURL=agent.processing-state-manager.d.ts.map

package/dist/agent/agent.processing-state-manager.js

@@ -1,87 +0,0 @@
-/**
- * ProcessingStateManager tracks which threads currently have active chat processing
- *
- * This is an in-memory store that tracks thread IDs that are currently
- * processing chat messages. The frontend can poll this to show/hide spinners.
- * It also buffers streaming events so late subscribers can replay them.
- */
-/**
- * Implementation of ProcessingStateManager using an in-memory Set
- */
-export class ProcessingStateManagerImpl {
-    processingThreads = new Set();
-    eventBuffers = new Map();
-    subscribers = new Map();
-    abortControllers = new Map();
-    setProcessing(threadId) {
-        this.processingThreads.add(threadId);
-        this.eventBuffers.set(threadId, []);
-        console.log(`[ProcessingState] Thread ${threadId} started processing. Active: ${this.processingThreads.size}`);
-    }
-    registerAbortController(threadId, controller) {
-        this.abortControllers.set(threadId, controller);
-    }
-    abortThread(threadId) {
-        const controller = this.abortControllers.get(threadId);
-        if (!controller)
-            return false;
-        console.log(`[ProcessingState] Aborting thread ${threadId} via stop endpoint`);
-        controller.abort();
-        this.abortControllers.delete(threadId);
-        return true;
-    }
-    clearProcessing(threadId) {
-        this.abortControllers.delete(threadId);
-        this.processingThreads.delete(threadId);
-        // Notify subscribers that stream is complete, then clean up
-        const subs = this.subscribers.get(threadId);
-        if (subs) {
-            for (const sub of subs) {
-                sub({ type: "complete", content: "" });
-            }
-            this.subscribers.delete(threadId);
-        }
-        // Keep the buffer briefly for any final subscribers, then clean up
-        setTimeout(() => {
-            this.eventBuffers.delete(threadId);
-        }, 5000);
-        console.log(`[ProcessingState] Thread ${threadId} finished processing. Active: ${this.processingThreads.size}`);
-    }
-    isProcessing(threadId) {
-        return this.processingThreads.has(threadId);
-    }
-    getProcessingThreadIds() {
-        return Array.from(this.processingThreads);
-    }
-    pushEvent(threadId, event) {
-        const buffer = this.eventBuffers.get(threadId);
-        if (buffer) {
-            buffer.push(event);
-        }
-        const subs = this.subscribers.get(threadId);
-        if (subs) {
-            for (const sub of subs) {
-                sub(event);
-            }
-        }
-    }
-    subscribe(threadId, subscriber) {
-        if (!this.subscribers.has(threadId)) {
-            this.subscribers.set(threadId, new Set());
-        }
-        this.subscribers.get(threadId).add(subscriber);
-        return () => {
-            const subs = this.subscribers.get(threadId);
-            if (subs) {
-                subs.delete(subscriber);
-                if (subs.size === 0) {
-                    this.subscribers.delete(threadId);
-                }
-            }
-        };
-    }
-    getBufferedEvents(threadId) {
-        return this.eventBuffers.get(threadId) ?? [];
-    }
-}
-//# sourceMappingURL=agent.processing-state-manager.js.map

package/dist/agent/agent.prompt-loader.d.ts

@@ -1,16 +0,0 @@
-/**
- * System prompt loader for Pi Agent
- * Loads agent system prompt from agents.md file with fallback
- */
-import type { Skill, AgentDefinition } from "@tarsk/shared";
-/**
- * Load agent system prompt from agents.md file
- * System prompt is the DEFAULT_PROMPT, agents.md is appended as developer context
- *
- * @param threadPath - Path to the thread directory (required)
- * @param skills - Optional array of activated skills to inject into the prompt
- * @param planMode - Optional flag to enable plan mode instructions
- * @param agents - Optional array of available agent definitions to inject into the prompt
- */
-export declare function loadAgentSystemPrompt(threadPath: string, skills?: Skill[], planMode?: boolean, agents?: AgentDefinition[]): Promise<string>;
-//# sourceMappingURL=agent.prompt-loader.d.ts.map