tarsk 0.4.4 → 0.4.6

package/dist/features/providers/providers-post-keys.route.d.ts

@@ -1,14 +0,0 @@
-/**
- * POST /api/providers/keys
- * Save a provider API key
- */
-import type { Context } from "hono";
-import type { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function postProviderKeys(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    success: true;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=providers-post-keys.route.d.ts.map

package/dist/features/providers/providers-post-keys.route.js

@@ -1,25 +0,0 @@
-/**
- * POST /api/providers/keys
- * Save a provider API key
- */
-import { updateEnvFile } from "../../core/env-manager.js";
-import { resolveProviderKeyName } from "./provider-resolver.js";
-export async function postProviderKeys(c, metadataManager) {
-    try {
-        const { providerName, apiKey } = await c.req.json();
-        if (!providerName) {
-            return c.json({ error: "providerName is required" }, 400);
-        }
-        await metadataManager.saveProviderKey(providerName, apiKey);
-        // Also update .env if provider has a keyName (from catalog or hardcoded)
-        const keyName = await resolveProviderKeyName(providerName);
-        if (keyName) {
-            await updateEnvFile({ [keyName]: apiKey });
-        }
-        return c.json({ success: true });
-    }
-    catch (error) {
-        return c.json({ error: `Failed to save provider key: ${String(error)}` }, 500);
-    }
-}
-//# sourceMappingURL=providers-post-keys.route.js.map

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

@@ -1,19 +0,0 @@
-/**
- * Provider routes for the REST API
- *
- * Handles all provider-related operations:
- * - GET /api/providers - List all built-in providers
- * - POST /api/providers/keys - Save a provider API key
- * - POST /api/providers/bulk-keys - Save all provider API keys at once
- * - GET /api/providers/:name/credits - Get current balance for a provider
- * - POST /api/providers/open-external - Open an external URL
- */
-import { Hono } from "hono";
-import type { MetadataManager } from "../metadata/metadata.manager.js";
-/**
- * Creates provider routes
- * @param metadataManager - Manager for metadata persistence
- * @returns Hono router with provider routes
- */
-export declare function createProviderRoutes(metadataManager: MetadataManager): Hono;
-//# sourceMappingURL=providers.routes.d.ts.map

package/dist/features/providers/providers.routes.js

@@ -1,31 +0,0 @@
-/**
- * Provider routes for the REST API
- *
- * Handles all provider-related operations:
- * - GET /api/providers - List all built-in providers
- * - POST /api/providers/keys - Save a provider API key
- * - POST /api/providers/bulk-keys - Save all provider API keys at once
- * - GET /api/providers/:name/credits - Get current balance for a provider
- * - POST /api/providers/open-external - Open an external URL
- */
-import { Hono } from "hono";
-import { getProviders } from "./providers-get.route.js";
-import { postProviderKeys } from "./providers-post-keys.route.js";
-import { postProviderBulkKeys } from "./providers-post-bulk-keys.route.js";
-import { getProviderCredits } from "./providers-get-credits.route.js";
-import { openExternalUrl } from "./providers-open-external.route.js";
-/**
- * Creates provider routes
- * @param metadataManager - Manager for metadata persistence
- * @returns Hono router with provider routes
- */
-export function createProviderRoutes(metadataManager) {
-    const router = new Hono();
-    router.get("/", (c) => getProviders(c, metadataManager));
-    router.post("/keys", (c) => postProviderKeys(c, metadataManager));
-    router.post("/bulk-keys", (c) => postProviderBulkKeys(c, metadataManager));
-    router.get("/:name/credits", (c) => getProviderCredits(c, metadataManager));
-    router.post("/open-external", (c) => openExternalUrl(c));
-    return router;
-}
-//# sourceMappingURL=providers.routes.js.map

package/dist/features/rules/rules-post.route.d.ts

@@ -1,43 +0,0 @@
-/**
- * POST /api/rules
- * Create a new rule
- * Body: { projectId, name, description, alwaysApply, scope }
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function createRule(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        timestamp: string;
-    };
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        timestamp: string;
-    };
-}, 501, "json">) | (Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        timestamp: string;
-    };
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    success: true;
-    rule: {
-        name: any;
-        path: string;
-        alwaysApply: any;
-        scope: any;
-        description: any;
-    };
-}, 201, "json">) | (Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        details: import("hono/utils/types").JSONValue;
-        timestamp: string;
-    };
-}, 500, "json">)>;
-//# sourceMappingURL=rules-post.route.d.ts.map

package/dist/features/rules/rules-post.route.js

@@ -1,89 +0,0 @@
-/**
- * POST /api/rules
- * Create a new rule
- * Body: { projectId, name, description, alwaysApply, scope }
- */
-import { promises as fs } from "fs";
-import path from "path";
-export async function createRule(c, projectManager) {
-    try {
-        const body = await c.req.json();
-        const { projectId, name, description, alwaysApply, scope } = body;
-        if (!projectId || !name || !description) {
-            return c.json({
-                error: {
-                    code: "MISSING_FIELDS",
-                    message: "projectId, name, and description are required",
-                    timestamp: new Date().toISOString(),
-                },
-            }, 400);
-        }
-        if (scope !== "local" && scope !== "global") {
-            return c.json({
-                error: {
-                    code: "INVALID_SCOPE",
-                    message: 'scope must be either "local" or "global"',
-                    timestamp: new Date().toISOString(),
-                },
-            }, 400);
-        }
-        // For now, only support local scope
-        if (scope === "global") {
-            return c.json({
-                error: {
-                    code: "NOT_IMPLEMENTED",
-                    message: "Global scope is not yet implemented",
-                    timestamp: new Date().toISOString(),
-                },
-            }, 501);
-        }
-        // Get project information to find repository path
-        const project = await projectManager.getProject(projectId);
-        if (!project) {
-            return c.json({
-                error: {
-                    code: "PROJECT_NOT_FOUND",
-                    message: `Project not found: ${projectId}`,
-                    timestamp: new Date().toISOString(),
-                },
-            }, 404);
-        }
-        // Use the project's repository path
-        const projectPath = project.path;
-        // Create .agents/rules directory if it doesn't exist
-        const rulesDir = path.join(projectPath, ".agents", "rules");
-        await fs.mkdir(rulesDir, { recursive: true });
-        // Create rule file content with front matter
-        const ruleContent = `---
-description: ${description.replace(/"/g, '\\"')}
-alwaysApply: ${alwaysApply}
----
-
-Describe your rules here as markdown which will be used when Tarsk sees is prompted with a request that is related to the description of this rule.`;
-        // Write rule file
-        const ruleFilePath = path.join(rulesDir, `${name}.md`);
-        await fs.writeFile(ruleFilePath, ruleContent, "utf-8");
-        return c.json({
-            success: true,
-            rule: {
-                name,
-                path: `.agents/rules/${name}.md`,
-                alwaysApply,
-                scope,
-                description,
-            },
-        }, 201);
-    }
-    catch (error) {
-        console.error("Failed to create rule:", error);
-        return c.json({
-            error: {
-                code: "CREATE_FAILED",
-                message: error instanceof Error ? error.message : "Failed to create rule",
-                details: error,
-                timestamp: new Date().toISOString(),
-            },
-        }, 500);
-    }
-}
-//# sourceMappingURL=rules-post.route.js.map

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

@@ -1,36 +0,0 @@
-/**
- * Rule Manager
- *
- * Loads and manages agent rules from .md/.mdc files with frontmatter.
- * Rules can be stored in:
- * - Project-specific: ./.agents/rules/ (relative to thread path)
- * - Global: ~/.agents/rules/
- *
- * Rules with alwaysApply: true are loaded in full into the context.
- * Rules with alwaysApply: false or missing are loaded as references.
- */
-import type { Rule } from "@tarsk/shared";
-/**
- * RuleManager handles loading and managing agent rules
- */
-export declare class RuleManager {
-    /**
-     * Load all available rules for a given thread
-     * Project rules override global ones with the same name
-     */
-    loadRules(threadPath: string): Promise<Rule[]>;
-    /**
-     * Load rules from a specific directory (recursive)
-     */
-    private loadRulesFromDir;
-    /**
-     * Get a specific rule by name
-     */
-    getRule(name: string, threadPath: string): Promise<Rule | null>;
-    /**
-     * Format rules for inclusion in system prompt
-     * Returns formatted string with alwaysApply rules in full and others as references
-     */
-    formatRulesForPrompt(rules: Rule[]): string;
-}
-//# sourceMappingURL=rules.manager.d.ts.map

package/dist/features/rules/rules.manager.js

@@ -1,203 +0,0 @@
-/**
- * Rule Manager
- *
- * Loads and manages agent rules from .md/.mdc files with frontmatter.
- * Rules can be stored in:
- * - Project-specific: ./.agents/rules/ (relative to thread path)
- * - Global: ~/.agents/rules/
- *
- * Rules with alwaysApply: true are loaded in full into the context.
- * Rules with alwaysApply: false or missing are loaded as references.
- */
-import { readdir, readFile } from "fs/promises";
-import { join, relative } from "path";
-import { existsSync } from "fs";
-import { homedir } from "os";
-/**
- * Parse frontmatter from rule markdown content
- * Returns { metadata, content } where content is the body after frontmatter
- */
-function parseRuleFrontmatter(markdown) {
-    const lines = markdown.split("\n");
-    // Check if file starts with ---
-    if (lines[0]?.trim() !== "---") {
-        return {
-            metadata: {},
-            content: markdown.trim(),
-        };
-    }
-    // Find the closing ---
-    let endIndex = -1;
-    for (let i = 1; i < lines.length; i++) {
-        if (lines[i]?.trim() === "---") {
-            endIndex = i;
-            break;
-        }
-    }
-    // No closing --- found
-    if (endIndex === -1) {
-        return {
-            metadata: {},
-            content: markdown.trim(),
-        };
-    }
-    // Parse frontmatter
-    const frontmatterLines = lines.slice(1, endIndex);
-    const metadata = {};
-    for (const line of frontmatterLines) {
-        const colonIndex = line.indexOf(":");
-        if (colonIndex === -1)
-            continue;
-        const key = line.slice(0, colonIndex).trim();
-        let value = line.slice(colonIndex + 1).trim();
-        // Remove surrounding quotes if present
-        if ((value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        // Map YAML keys to TypeScript property names
-        if (key === "description") {
-            metadata.description = value;
-        }
-        else if (key === "alwaysApply") {
-            // Parse boolean value
-            metadata.alwaysApply = value.toLowerCase() === "true";
-        }
-    }
-    // Content is everything after the closing ---
-    const content = lines
-        .slice(endIndex + 1)
-        .join("\n")
-        .trim();
-    return { metadata, content };
-}
-/**
- * Get the global rules directory path
- */
-function getGlobalRulesDir() {
-    return join(homedir(), ".agents", "rules");
-}
-/**
- * Get the project-specific rules directory path
- */
-function getProjectRulesDir(threadPath) {
-    return join(threadPath, ".agents", "rules");
-}
-/**
- * RuleManager handles loading and managing agent rules
- */
-export class RuleManager {
-    /**
-     * Load all available rules for a given thread
-     * Project rules override global ones with the same name
-     */
-    async loadRules(threadPath) {
-        const rules = new Map();
-        // Load global rules first
-        const globalDir = getGlobalRulesDir();
-        if (existsSync(globalDir)) {
-            const globalRules = await this.loadRulesFromDir(globalDir, threadPath, "global");
-            for (const rule of globalRules) {
-                rules.set(rule.name, rule);
-            }
-        }
-        // Load project rules (override global)
-        const projectDir = getProjectRulesDir(threadPath);
-        if (existsSync(projectDir)) {
-            const projectRules = await this.loadRulesFromDir(projectDir, threadPath, "project");
-            for (const rule of projectRules) {
-                rules.set(rule.name, rule);
-            }
-        }
-        return Array.from(rules.values());
-    }
-    /**
-     * Load rules from a specific directory (recursive)
-     */
-    async loadRulesFromDir(dir, threadPath, scope) {
-        const rules = [];
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    // Recursively load from subdirectories
-                    const subRules = await this.loadRulesFromDir(fullPath, threadPath, scope);
-                    rules.push(...subRules);
-                }
-                else if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdc"))) {
-                    try {
-                        // Read and parse rule file
-                        const fileContent = await readFile(fullPath, "utf-8");
-                        const { metadata, content } = parseRuleFrontmatter(fileContent);
-                        // Generate rule name from filename (without extension)
-                        const ruleName = entry.name.replace(/\.(md|mdc)$/, "");
-                        // Calculate relative path from thread root
-                        const relativePath = relative(threadPath, fullPath);
-                        // Create rule object
-                        const rule = {
-                            name: ruleName,
-                            content,
-                            metadata: {
-                                description: metadata.description,
-                                alwaysApply: metadata.alwaysApply ?? false, // Default to false
-                            },
-                            scope,
-                            filePath: fullPath,
-                            relativePath,
-                        };
-                        rules.push(rule);
-                    }
-                    catch (error) {
-                        console.error(`Failed to load rule from ${entry.name}:`, error);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Directory doesn't exist or can't be read - that's okay
-            console.error(`Failed to load rules from ${dir}:`, error);
-        }
-        return rules;
-    }
-    /**
-     * Get a specific rule by name
-     */
-    async getRule(name, threadPath) {
-        const rules = await this.loadRules(threadPath);
-        return rules.find((rule) => rule.name === name) ?? null;
-    }
-    /**
-     * Format rules for inclusion in system prompt
-     * Returns formatted string with alwaysApply rules in full and others as references
-     */
-    formatRulesForPrompt(rules) {
-        if (rules.length === 0) {
-            return "";
-        }
-        let rulesSection = "\n\n# Rules\n\n";
-        const alwaysApplyRules = rules.filter((rule) => rule.metadata.alwaysApply);
-        const conditionalRules = rules.filter((rule) => !rule.metadata.alwaysApply);
-        if (alwaysApplyRules.length > 0) {
-            rulesSection += "## Always-Applicable Rules\n\n";
-            for (const rule of alwaysApplyRules) {
-                rulesSection += `### ${rule.name}\n\n`;
-                if (rule.metadata.description) {
-                    rulesSection += `**Description**: ${rule.metadata.description}\n\n`;
-                }
-                rulesSection += rule.content;
-                rulesSection += "\n\n---\n\n";
-            }
-        }
-        if (conditionalRules.length > 0) {
-            rulesSection += "## Conditional Rules\n\n";
-            for (const rule of conditionalRules) {
-                const description = rule.metadata.description ?? "various guidelines";
-                rulesSection += `- Follow rules from ${rule.relativePath} if the user asks about ${description}\n`;
-            }
-            rulesSection += "\n";
-        }
-        return rulesSection;
-    }
-}
-//# sourceMappingURL=rules.manager.js.map

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

@@ -1,12 +0,0 @@
-/**
- * Rules API Routes
- *
- * Endpoints for managing and querying rules
- */
-import { Hono } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-/**
- * Create rule routes
- */
-export declare function createRuleRoutes(router: Hono, projectManager: ProjectManager): void;
-//# sourceMappingURL=rules.routes.d.ts.map

package/dist/features/rules/rules.routes.js

@@ -1,13 +0,0 @@
-/**
- * Rules API Routes
- *
- * Endpoints for managing and querying rules
- */
-import { createRule } from "./rules-post.route.js";
-/**
- * Create rule routes
- */
-export function createRuleRoutes(router, projectManager) {
-    router.post("/api/rules", (c) => createRule(c, projectManager));
-}
-//# sourceMappingURL=rules.routes.js.map

package/dist/features/run/run-get-running.route.d.ts

@@ -1,15 +0,0 @@
-/**
- * GET /api/projects/:id/running
- * Check if a process is running for a project
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function getRunning(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        details?: import("hono/utils/types").JSONValue | undefined;
-        timestamp: string;
-    };
-}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
-//# sourceMappingURL=run-get-running.route.d.ts.map

package/dist/features/run/run-get-running.route.js

@@ -1,21 +0,0 @@
-/**
- * GET /api/projects/:id/running
- * Check if a process is running for a project
- */
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function getRunning(c, projectManager) {
-    try {
-        const projectId = c.req.param("id");
-        if (!projectId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
-        }
-        const isRunning = await projectManager.isProcessRunning(projectId);
-        return successResponse(c, { isRunning });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.CHECK_RUNNING_ERROR, "Failed to check running status", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=run-get-running.route.js.map

package/dist/features/run/run-post-start.route.d.ts

@@ -1,8 +0,0 @@
-/**
- * POST /api/projects/:id/run
- * Starts the dev server process
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function postRunStart(c: Context, projectManager: ProjectManager): Promise<Response>;
-//# sourceMappingURL=run-post-start.route.d.ts.map

package/dist/features/run/run-post-start.route.js

@@ -1,21 +0,0 @@
-/**
- * POST /api/projects/:id/run
- * Starts the dev server process
- */
-import { streamAsyncGenerator } from "../../core/stream-helper.js";
-import { errorResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function postRunStart(c, projectManager) {
-    try {
-        const projectId = c.req.param("id");
-        if (!projectId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
-        }
-        return streamAsyncGenerator(c, projectManager.startRunningProcess(projectId));
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.RUN_PROCESS_ERROR, "Failed to start process", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=run-post-start.route.js.map

package/dist/features/run/run-post-stop.route.d.ts

@@ -1,15 +0,0 @@
-/**
- * POST /api/projects/:id/stop
- * Stops the dev server process
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function postRunStop(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        details?: import("hono/utils/types").JSONValue | undefined;
-        timestamp: string;
-    };
-}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
-//# sourceMappingURL=run-post-stop.route.d.ts.map

package/dist/features/run/run-post-stop.route.js

@@ -1,24 +0,0 @@
-/**
- * POST /api/projects/:id/stop
- * Stops the dev server process
- */
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function postRunStop(c, projectManager) {
-    try {
-        const projectId = c.req.param("id");
-        if (!projectId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
-        }
-        const stopped = await projectManager.stopRunningProcess(projectId);
-        if (!stopped) {
-            return errorResponse(c, ErrorCodes.NO_PROCESS_RUNNING, "No process running for this project", 400);
-        }
-        return successResponse(c, { success: true, message: "Process stopped" });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.STOP_PROCESS_ERROR, "Failed to stop process", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=run-post-stop.route.js.map

package/dist/features/run/run-post-suggest.route.d.ts

@@ -1,15 +0,0 @@
-/**
- * POST /api/projects/:id/run-suggest
- * Suggests a run command based on package.json
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function postRunSuggest(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        details?: import("hono/utils/types").JSONValue | undefined;
-        timestamp: string;
-    };
-}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
-//# sourceMappingURL=run-post-suggest.route.d.ts.map

package/dist/features/run/run-post-suggest.route.js

@@ -1,21 +0,0 @@
-/**
- * POST /api/projects/:id/run-suggest
- * Suggests a run command based on package.json
- */
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export async function postRunSuggest(c, projectManager) {
-    try {
-        const projectId = c.req.param("id");
-        if (!projectId) {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
-        }
-        const runCommand = await projectManager.suggestRunCommand(projectId);
-        return successResponse(c, { runCommand });
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return errorResponse(c, ErrorCodes.SUGGEST_RUN_COMMAND_ERROR, "Failed to suggest run command", 500, errorMessage);
-    }
-}
-//# sourceMappingURL=run-post-suggest.route.js.map

package/dist/features/run/run-put-command.route.d.ts

@@ -1,15 +0,0 @@
-/**
- * PUT /api/projects/:id/run-command
- * Update the run command for a project
- */
-import type { Context } from "hono";
-import type { ProjectManager } from "../projects/projects.manager.js";
-export declare function putRunCommand(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
-    error: {
-        code: string;
-        message: string;
-        details?: import("hono/utils/types").JSONValue | undefined;
-        timestamp: string;
-    };
-}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
-//# sourceMappingURL=run-put-command.route.d.ts.map