tarsk 0.4.4 → 0.4.6

package/dist/features/conversations/token-usage.route.js

@@ -1,419 +0,0 @@
-/**
- * Token usage API route
- * Provides detailed token and cost information for conversations
- */
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-/**
- * Get detailed token usage for a specific conversation
- */
-export async function handleGetConversationUsage(c, conversationManager, threadManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        const conversationId = c.req.param("conversationId");
-        if (!threadId || typeof threadId !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
-        }
-        if (!conversationId || typeof conversationId !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "conversationId is required and must be a string", 400);
-        }
-        // Verify thread exists
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        // Get conversation history
-        const history = await conversationManager.getConversationHistory(thread.path);
-        if (!history) {
-            return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Conversation history not found", 404);
-        }
-        // Find all conversations with the same conversationId
-        const conversations = history.messages.filter((msg) => msg.conversationId === conversationId);
-        if (conversations.length === 0) {
-            return errorResponse(c, ErrorCodes.NO_CONVERSATION, "Conversation not found", 404);
-        }
-        // Extract detailed usage from all conversations
-        const totalUsage = {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                total: 0,
-            },
-        };
-        const footprintUsage = {
-            input: 0,
-            output: 0,
-            totalTokens: 0,
-        };
-        const modelInfo = {
-            api: "",
-            provider: "",
-            model: "",
-        };
-        let peakInput = 0;
-        let latestOutput = 0;
-        // Process all conversations to extract usage information
-        for (const conversation of conversations) {
-            if (!conversation.response) {
-                continue;
-            }
-            // Determine which event type is the authoritative source for this conversation's usage.
-            // Prefer `message` events (from message_start) to avoid double-counting when both
-            // `message` and `toolcall_delta` events carry usage data for the same API call.
-            const hasMessageUsage = conversation.response.events.some((e) => e.type === "message" &&
-                e.message?.usage &&
-                (e.message.usage.input > 0 ||
-                    e.message.usage.output > 0 ||
-                    e.message.usage.cacheRead > 0 ||
-                    e.message.usage.cacheWrite > 0));
-            // Process all events in this conversation
-            for (const event of conversation.response.events) {
-                if (hasMessageUsage) {
-                    // Use message events as the single source of truth
-                    if (event.type === "message" && event.message?.usage) {
-                        const usage = event.message.usage;
-                        const hasRealUsage = usage.input > 0 || usage.output > 0 || usage.cacheRead > 0 || usage.cacheWrite > 0;
-                        if (!hasRealUsage)
-                            continue;
-                        totalUsage.input += usage.input ?? 0;
-                        totalUsage.output += usage.output ?? 0;
-                        totalUsage.cacheRead += usage.cacheRead ?? 0;
-                        totalUsage.cacheWrite += usage.cacheWrite ?? 0;
-                        // Track for footprint (highest input = peak context window usage)
-                        if ((usage.input ?? 0) >= peakInput) {
-                            peakInput = usage.input ?? 0;
-                            latestOutput = usage.output ?? 0;
-                        }
-                        // Track model info from message
-                        if (event.message.model)
-                            modelInfo.model = event.message.model;
-                        if (event.message.api)
-                            modelInfo.api = event.message.api;
-                        if (event.message.provider)
-                            modelInfo.provider = event.message.provider;
-                        // Add cost information if available
-                        if (usage.cost) {
-                            totalUsage.cost.input += usage.cost.input ?? 0;
-                            totalUsage.cost.output += usage.cost.output ?? 0;
-                            totalUsage.cost.cacheRead += usage.cost.cacheRead ?? 0;
-                            totalUsage.cost.cacheWrite += usage.cost.cacheWrite ?? 0;
-                            totalUsage.cost.total += usage.cost.total ?? 0;
-                        }
-                    }
-                }
-                else {
-                    // Fall back to toolcall_delta events when no message events carry usage
-                    if (event.type === "toolcall_delta" && event.partial?.usage) {
-                        const usage = event.partial.usage;
-                        totalUsage.input += usage.input ?? 0;
-                        totalUsage.output += usage.output ?? 0;
-                        totalUsage.cacheRead += usage.cacheRead ?? 0;
-                        totalUsage.cacheWrite += usage.cacheWrite ?? 0;
-                        // Track for footprint
-                        if ((usage.input ?? 0) >= peakInput) {
-                            peakInput = usage.input ?? 0;
-                            latestOutput = usage.output ?? 0;
-                        }
-                        // Track model info from the last event
-                        if (event.partial.api)
-                            modelInfo.api = event.partial.api;
-                        if (event.partial.provider)
-                            modelInfo.provider = event.partial.provider;
-                        if (event.partial.model)
-                            modelInfo.model = event.partial.model;
-                        // Add cost information if available
-                        if (usage.cost) {
-                            totalUsage.cost.input += usage.cost.input ?? 0;
-                            totalUsage.cost.output += usage.cost.output ?? 0;
-                            totalUsage.cost.cacheRead += usage.cost.cacheRead ?? 0;
-                            totalUsage.cost.cacheWrite += usage.cost.cacheWrite ?? 0;
-                            totalUsage.cost.total += usage.cost.total ?? 0;
-                        }
-                    }
-                }
-            }
-        }
-        // Calculate total tokens if not provided
-        totalUsage.totalTokens = totalUsage.input + totalUsage.output;
-        // Set final footprint
-        footprintUsage.input = peakInput;
-        footprintUsage.output = latestOutput;
-        footprintUsage.totalTokens = peakInput + latestOutput;
-        // Get the latest conversation for metadata
-        const latestConversation = conversations[conversations.length - 1];
-        return successResponse(c, {
-            conversationId,
-            threadId,
-            timestamp: latestConversation.response?.completedAt ?? new Date().toISOString(),
-            usage: totalUsage,
-            footprint: footprintUsage,
-            model: modelInfo,
-            // Include the database-stored totals for comparison
-            databaseTotals: {
-                inputTokens: latestConversation.inputTokens ?? 0,
-                outputTokens: latestConversation.outputTokens ?? 0,
-            },
-            // Message metadata
-            messageCount: conversations.reduce((total, conv) => total + (conv.response?.events.length ?? 0), 0),
-            hasToolCalls: conversations.some((conv) => conv.response?.events.some((e) => e.type === "toolcall_delta")),
-        });
-    }
-    catch (error) {
-        console.error("[token-usage] Error getting conversation usage:", error);
-        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to retrieve conversation usage", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * Get aggregated token usage for an entire thread
- */
-export async function handleGetThreadUsage(c, conversationManager, threadManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        if (!threadId || typeof threadId !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
-        }
-        // Verify thread exists
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        // Get conversation history
-        const history = await conversationManager.getConversationHistory(thread.path);
-        if (!history) {
-            return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Conversation history not found", 404);
-        }
-        // Aggregate usage across all conversations
-        const totalUsage = {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                total: 0,
-            },
-        };
-        const conversationsUsage = [];
-        const modelUsage = new Map();
-        // Process each conversation
-        for (const conversation of history.messages) {
-            if (!conversation.response)
-                continue;
-            const conversationUsage = {
-                conversationId: conversation.conversationId,
-                timestamp: conversation.response.completedAt,
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: {
-                    input: 0,
-                    output: 0,
-                    cacheRead: 0,
-                    cacheWrite: 0,
-                    total: 0,
-                },
-                model: {
-                    api: "",
-                    provider: "",
-                    model: "",
-                },
-            };
-            // Track which models are used in this conversation to count each once
-            const modelsUsedInConversation = new Set();
-            // Determine which event type is the authoritative source for this conversation's usage.
-            // Prefer `message` events (from message_start) to avoid double-counting.
-            const hasMessageUsage = conversation.response.events.some((e) => e.type === "message" &&
-                e.message?.usage &&
-                (e.message.usage.input > 0 ||
-                    e.message.usage.output > 0 ||
-                    e.message.usage.cacheRead > 0 ||
-                    e.message.usage.cacheWrite > 0));
-            // Extract usage from events
-            for (const event of conversation.response.events) {
-                if (hasMessageUsage) {
-                    // Use message events as the single source of truth
-                    if (event.type === "message" && event.message?.usage) {
-                        const usage = event.message.usage;
-                        const hasRealUsage = usage.input > 0 || usage.output > 0 || usage.cacheRead > 0 || usage.cacheWrite > 0;
-                        if (!hasRealUsage)
-                            continue;
-                        conversationUsage.input += usage.input ?? 0;
-                        conversationUsage.output += usage.output ?? 0;
-                        conversationUsage.cacheRead += usage.cacheRead ?? 0;
-                        conversationUsage.cacheWrite += usage.cacheWrite ?? 0;
-                        if (usage.cost) {
-                            conversationUsage.cost.input += usage.cost.input ?? 0;
-                            conversationUsage.cost.output += usage.cost.output ?? 0;
-                            conversationUsage.cost.cacheRead += usage.cost.cacheRead ?? 0;
-                            conversationUsage.cost.cacheWrite += usage.cost.cacheWrite ?? 0;
-                            conversationUsage.cost.total += usage.cost.total ?? 0;
-                        }
-                        // Track model info
-                        if (event.message.model) {
-                            conversationUsage.model.model = event.message.model;
-                            const modelKey = event.message.model;
-                            if (!modelUsage.has(modelKey)) {
-                                modelUsage.set(modelKey, { input: 0, output: 0, conversations: 0 });
-                            }
-                            const modelStats = modelUsage.get(modelKey);
-                            modelStats.input += usage.input ?? 0;
-                            modelStats.output += usage.output ?? 0;
-                            modelsUsedInConversation.add(modelKey);
-                        }
-                        if (event.message.api)
-                            conversationUsage.model.api = event.message.api;
-                        if (event.message.provider)
-                            conversationUsage.model.provider = event.message.provider;
-                    }
-                }
-                else {
-                    // Fall back to toolcall_delta events when no message events carry usage
-                    if (event.type === "toolcall_delta" && event.partial?.usage) {
-                        const usage = event.partial.usage;
-                        conversationUsage.input += usage.input ?? 0;
-                        conversationUsage.output += usage.output ?? 0;
-                        conversationUsage.cacheRead += usage.cacheRead ?? 0;
-                        conversationUsage.cacheWrite += usage.cacheWrite ?? 0;
-                        if (usage.cost) {
-                            conversationUsage.cost.input += usage.cost.input ?? 0;
-                            conversationUsage.cost.output += usage.cost.output ?? 0;
-                            conversationUsage.cost.cacheRead += usage.cost.cacheRead ?? 0;
-                            conversationUsage.cost.cacheWrite += usage.cost.cacheWrite ?? 0;
-                            conversationUsage.cost.total += usage.cost.total ?? 0;
-                        }
-                        // Track model info
-                        if (event.partial.model) {
-                            conversationUsage.model.model = event.partial.model;
-                            const modelKey = event.partial.model;
-                            if (!modelUsage.has(modelKey)) {
-                                modelUsage.set(modelKey, { input: 0, output: 0, conversations: 0 });
-                            }
-                            const modelStats = modelUsage.get(modelKey);
-                            modelStats.input += usage.input ?? 0;
-                            modelStats.output += usage.output ?? 0;
-                            modelsUsedInConversation.add(modelKey);
-                        }
-                        if (event.partial.api)
-                            conversationUsage.model.api = event.partial.api;
-                        if (event.partial.provider)
-                            conversationUsage.model.provider = event.partial.provider;
-                    }
-                }
-            }
-            // Increment conversation count once per model used in this conversation
-            for (const modelKey of modelsUsedInConversation) {
-                const modelStats = modelUsage.get(modelKey);
-                modelStats.conversations += 1;
-            }
-            conversationUsage.totalTokens = conversationUsage.input + conversationUsage.output;
-            // Add to totals
-            totalUsage.input += conversationUsage.input;
-            totalUsage.output += conversationUsage.output;
-            totalUsage.cacheRead += conversationUsage.cacheRead;
-            totalUsage.cacheWrite += conversationUsage.cacheWrite;
-            totalUsage.cost.input += conversationUsage.cost.input;
-            totalUsage.cost.output += conversationUsage.cost.output;
-            totalUsage.cost.cacheRead += conversationUsage.cost.cacheRead;
-            totalUsage.cost.cacheWrite += conversationUsage.cost.cacheWrite;
-            totalUsage.cost.total += conversationUsage.cost.total;
-            conversationsUsage.push(conversationUsage);
-        }
-        totalUsage.totalTokens = totalUsage.input + totalUsage.output;
-        // Convert model usage map to array
-        const modelBreakdown = Array.from(modelUsage.entries()).map(([model, stats]) => ({
-            model,
-            ...stats,
-            totalTokens: stats.input + stats.output,
-        }));
-        return successResponse(c, {
-            threadId,
-            totalUsage,
-            conversationCount: conversationsUsage.length,
-            conversations: conversationsUsage,
-            modelBreakdown,
-            lastUpdated: history.lastUpdated,
-        });
-    }
-    catch (error) {
-        console.error("[token-usage] Error getting thread usage:", error);
-        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to retrieve thread usage", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * Get simple usage summary for a thread (for UI display)
- */
-export async function handleGetThreadUsageSummary(c, conversationManager, threadManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        if (!threadId || typeof threadId !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
-        }
-        // Verify thread exists
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        // Get conversation history
-        const history = await conversationManager.getConversationHistory(thread.path);
-        if (!history) {
-            return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Conversation history not found", 404);
-        }
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let totalCost = 0;
-        let conversationCount = 0;
-        for (const conversation of history.messages) {
-            if (conversation.response) {
-                totalInputTokens += conversation.inputTokens ?? 0;
-                totalOutputTokens += conversation.outputTokens ?? 0;
-                conversationCount++;
-                // Prefer cost from message events; fall back to toolcall_delta if none present.
-                // This mirrors the same prefer-message strategy used in the other handlers.
-                const hasMessageCost = conversation.response.events.some((e) => e.type === "message" && e.message?.usage?.cost && (e.message.usage.cost.total ?? 0) > 0);
-                if (hasMessageCost) {
-                    for (const event of conversation.response.events) {
-                        if (event.type === "message" && event.message?.usage?.cost?.total) {
-                            totalCost += event.message.usage.cost.total;
-                        }
-                    }
-                }
-                else {
-                    for (const event of conversation.response.events) {
-                        if (event.type === "toolcall_delta" && event.partial?.usage?.cost?.total) {
-                            totalCost += event.partial.usage.cost.total;
-                        }
-                    }
-                }
-            }
-        }
-        return successResponse(c, {
-            threadId,
-            totalInputTokens,
-            totalOutputTokens,
-            totalTokens: totalInputTokens + totalOutputTokens,
-            totalCost,
-            conversationCount,
-            averageTokensPerConversation: conversationCount > 0
-                ? Math.round((totalInputTokens + totalOutputTokens) / conversationCount)
-                : 0,
-        });
-    }
-    catch (error) {
-        console.error("[token-usage] Error getting usage summary:", error);
-        return errorResponse(c, ErrorCodes.INTERNAL_ERROR, "Failed to retrieve usage summary", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-//# sourceMappingURL=token-usage.route.js.map

package/dist/features/git/git-commit.route.d.ts

@@ -1,12 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitCommitHandler(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    success: true;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-commit.route.d.ts.map

package/dist/features/git/git-commit.route.js

@@ -1,39 +0,0 @@
-import { resolveThreadPath, getGitRoot, stageAllChanges, commitChanges } from "./git.utils.js";
-export async function gitCommitHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        const body = await c.req.json();
-        const { message } = body;
-        if (!message) {
-            return c.json({ error: "Commit message is required" }, 400);
-        }
-        const thread = await metadataManager
-            .loadThreads()
-            .then((threads) => threads.find((t) => t.id === threadId));
-        if (!thread) {
-            return c.json({ error: "Thread not found" }, 404);
-        }
-        const repoPath = thread.path;
-        if (!repoPath) {
-            return c.json({ error: "Thread path not found" }, 404);
-        }
-        const absolutePath = resolveThreadPath(repoPath);
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-        }
-        catch {
-            return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
-        }
-        // Stage all changes
-        await stageAllChanges(gitRoot);
-        // Commit changes
-        await commitChanges(gitRoot, message);
-        return c.json({ success: true });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to commit changes";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-commit.route.js.map

package/dist/features/git/git-create-branch.route.d.ts

@@ -1,28 +0,0 @@
-/**
- * POST /api/git/create-branch/:threadId
- * Create a new branch on an existing thread's repository
- *
- * Response:
- * {
- *   "success": true,
- *   "branchName": "auto-generated-branch-name"
- * }
- *
- * On error:
- * {
- *   "error": "error message"
- * }
- */
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitCreateBranchHandler(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    success: true;
-    branchName: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-create-branch.route.d.ts.map

package/dist/features/git/git-create-branch.route.js

@@ -1,119 +0,0 @@
-/**
- * POST /api/git/create-branch/:threadId
- * Create a new branch on an existing thread's repository
- *
- * Response:
- * {
- *   "success": true,
- *   "branchName": "auto-generated-branch-name"
- * }
- *
- * On error:
- * {
- *   "error": "error message"
- * }
- */
-import { resolveThreadPath, getGitRoot } from "./git.utils.js";
-import { spawnProcess } from "../../core/utils.js";
-import { generateRandomThreadName } from "../../core/random-words.js";
-function sanitizeBranchName(name) {
-    if (!name || typeof name !== "string") {
-        return "branch";
-    }
-    return (name
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, "-")
-        .replace(/[^a-zA-Z0-9\-_/.]/g, "")
-        .replace(/^[/.]+|[/.]+$/g, "")
-        .replace(/-+/g, "-") || "branch");
-}
-function checkBranchExists(gitRoot, branchName) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
-            cwd: gitRoot,
-        });
-        proc.on("close", (code) => {
-            resolve(code === 0);
-        });
-        proc.on("error", () => {
-            resolve(false);
-        });
-    });
-}
-function createAndCheckoutBranch(gitRoot, branchName, baseBranch) {
-    const args = baseBranch
-        ? ["checkout", "-b", branchName, `origin/${baseBranch}`]
-        : ["checkout", "-b", branchName];
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", args, {
-            cwd: gitRoot,
-        });
-        let err = "";
-        if (proc.stderr) {
-            proc.stderr.on("data", (d) => {
-                err += d.toString();
-            });
-        }
-        proc.on("close", (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                reject(new Error(err || `Failed to create branch "${branchName}"`));
-            }
-        });
-        proc.on("error", reject);
-    });
-}
-export async function gitCreateBranchHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        const thread = await metadataManager
-            .loadThreads()
-            .then((threads) => threads.find((t) => t.id === threadId));
-        if (!thread) {
-            return c.json({ error: "Thread not found" }, 404);
-        }
-        const repoPath = thread.path;
-        if (!repoPath) {
-            return c.json({ error: "Thread path not found" }, 404);
-        }
-        const body = (await c.req.json().catch(() => ({})));
-        const baseBranch = body.baseBranch;
-        const absolutePath = resolveThreadPath(repoPath);
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-        }
-        catch {
-            return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
-        }
-        // Auto-generate branch name using random words
-        let branchName = sanitizeBranchName(generateRandomThreadName());
-        // Check if branch exists and find a unique name if needed
-        let branchExists = await checkBranchExists(gitRoot, branchName);
-        let counter = 2;
-        const baseBranchName = branchName;
-        while (branchExists) {
-            branchName = `${baseBranchName}-${counter}`;
-            branchExists = await checkBranchExists(gitRoot, branchName);
-            counter++;
-        }
-        // Create and checkout the new branch
-        await createAndCheckoutBranch(gitRoot, branchName, baseBranch);
-        // Update thread's currentBranch in metadata
-        const threads = await metadataManager.loadThreads();
-        const threadIndex = threads.findIndex((t) => t.id === threadId);
-        if (threadIndex !== -1) {
-            threads[threadIndex].currentBranch = branchName;
-            await metadataManager.saveThreads(threads);
-        }
-        return c.json({ success: true, branchName });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to create branch";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-create-branch.route.js.map

package/dist/features/git/git-create-pr.route.d.ts

@@ -1,13 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitCreatePrHandler(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    success: true;
-    prUrl: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-create-pr.route.d.ts.map