tarsk 0.4.4 → 0.4.6

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

@@ -1,50 +0,0 @@
-import { resolveThreadPath, getGitRoot, getCurrentBranch, createPullRequest } from "./git.utils.js";
-export async function gitCreatePrHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        const body = await c.req.json();
-        const { title, description } = body;
-        console.log(`[git-create-pr] Starting PR creation for thread: ${threadId}`);
-        console.log(`[git-create-pr] PR title: "${title}"`);
-        console.log(`[git-create-pr] PR description length: ${description?.length ?? 0} chars`);
-        const thread = await metadataManager
-            .loadThreads()
-            .then((threads) => threads.find((t) => t.id === threadId));
-        if (!thread) {
-            console.log(`[git-create-pr] Thread not found: ${threadId}`);
-            return c.json({ error: "Thread not found" }, 404);
-        }
-        console.log(`[git-create-pr] ✓ Thread found: ${thread.title}`);
-        const repoPath = thread.path;
-        if (!repoPath) {
-            console.log(`[git-create-pr] Thread path not found for threadId: ${threadId}`);
-            return c.json({ error: "Thread path not found" }, 404);
-        }
-        const absolutePath = resolveThreadPath(repoPath);
-        console.log(`[git-create-pr] Resolved path: ${absolutePath}`);
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-            console.log(`[git-create-pr] ✓ Git root: ${gitRoot}`);
-        }
-        catch {
-            console.log(`[git-create-pr] ✗ Not a git repository: ${absolutePath}`);
-            return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
-        }
-        // Get current branch
-        const currentBranch = await getCurrentBranch(gitRoot);
-        console.log(`[git-create-pr] Current branch: ${currentBranch}`);
-        // Try to create PR using gh CLI
-        console.log(`[git-create-pr] Creating PR with GitHub CLI...`);
-        const prUrl = await createPullRequest(gitRoot, title ?? currentBranch, description ?? "");
-        console.log(`[git-create-pr] ✓ PR created successfully: ${prUrl}`);
-        return c.json({ success: true, prUrl });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to create PR";
-        console.log(`[git-create-pr] ✗ PR creation failed: ${message}`);
-        console.log(`[git-create-pr] Error stack: ${error instanceof Error ? error.stack : "No stack available"}`);
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-create-pr.route.js.map

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

@@ -1,14 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitCreateRepoHandler(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;
-    repoUrl: string;
-    branchName: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-create-repo.route.d.ts.map

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

@@ -1,108 +0,0 @@
-import { resolveThreadPath, getGitRoot, getRemoteOrigin, createGitHubRepo } 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) {
-    return new Promise((resolve, reject) => {
-        const proc = spawnProcess("git", ["checkout", "-b", branchName], {
-            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 gitCreateRepoHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        const body = await c.req.json().catch(() => ({}));
-        const { repoName, description, isPrivate } = body;
-        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);
-        }
-        // Check if origin remote already exists
-        const remoteUrl = await getRemoteOrigin(gitRoot);
-        if (remoteUrl) {
-            return c.json({ error: "Repository already has a remote origin" }, 400);
-        }
-        // Create GitHub repository using gh CLI
-        const repoUrl = await createGitHubRepo(gitRoot, repoName, description, isPrivate);
-        // Create a new branch after repo creation
-        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);
-        // 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, repoUrl, branchName });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to create repository";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-create-repo.route.js.map

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

@@ -1,30 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitDiffHandler(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<{
-    files: {
-        path: string;
-        status: "added" | "modified" | "deleted" | "renamed" | "untracked";
-        oldPath?: string | undefined;
-        oldContent: string;
-        newContent: string;
-        hunks: {
-            oldStart: number;
-            oldLines: number;
-            newStart: number;
-            newLines: number;
-            changes: {
-                type: "add" | "delete" | "context";
-                content: string;
-                oldLineNumber?: number | undefined;
-                newLineNumber?: number | undefined;
-            }[];
-        }[];
-    }[];
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-diff.route.d.ts.map

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

@@ -1,189 +0,0 @@
-import { spawnProcess } from "../../core/utils.js";
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import { resolveThreadPath, getGitRoot, getGitStatus } from "./git.utils.js";
-export async function gitDiffHandler(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 absolutePath = resolveThreadPath(repoPath);
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-        }
-        catch {
-            return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
-        }
-        // Get list of changed files with their status
-        const statusOutput = await getGitStatus(gitRoot);
-        const changedFiles = [];
-        const statusLines = statusOutput
-            .trim()
-            .split("\n")
-            .filter((line) => line.length > 0);
-        for (const line of statusLines) {
-            // Git status --porcelain format: XY PATH
-            // Status codes are before the first space
-            const trimmedLine = line.trim();
-            const spaceIndex = trimmedLine.indexOf(" ");
-            if (spaceIndex === -1)
-                continue; // No space found
-            const statusCode = trimmedLine.substring(0, spaceIndex);
-            let filePath = trimmedLine.substring(spaceIndex + 1).trim();
-            let oldPath;
-            // Handle renamed files
-            if (statusCode.startsWith("R") || statusCode.startsWith("C")) {
-                const parts = filePath.split(" -> ");
-                oldPath = parts[0];
-                filePath = parts[1] || parts[0];
-            }
-            let status = "modified";
-            if (statusCode.includes("A") || statusCode.includes("?")) {
-                status = "added";
-            }
-            else if (statusCode.includes("D")) {
-                status = "deleted";
-            }
-            else if (statusCode.includes("R")) {
-                status = "renamed";
-            }
-            changedFiles.push({ path: filePath, status, oldPath });
-        }
-        // Get diff for each file
-        const filesWithDiff = [];
-        for (const file of changedFiles) {
-            let oldContent = "";
-            let newContent = "";
-            const hunks = [];
-            if (file.status === "deleted") {
-                // Get old content for deleted files
-                const content = await new Promise((resolve) => {
-                    const proc = spawnProcess("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
-                    let out = "";
-                    proc.stdout?.on("data", (d) => {
-                        out += d.toString();
-                    });
-                    proc.on("close", () => resolve(out));
-                    proc.on("error", () => resolve(""));
-                });
-                oldContent = content;
-            }
-            else if (file.status === "added" && file.path.startsWith("(new)")) {
-                // Untracked file - get content from filesystem
-                try {
-                    newContent = readFileSync(resolve(gitRoot, file.path.replace("(new) ", "")), "utf-8");
-                }
-                catch {
-                    newContent = "";
-                }
-            }
-            else {
-                // Get diff for modified/added files
-                const diffOutput = await new Promise((resolve) => {
-                    const proc = spawnProcess("git", file.status === "added"
-                        ? ["diff", "--cached", "--", file.path]
-                        : ["diff", "HEAD", "--", file.path], { cwd: gitRoot });
-                    let out = "";
-                    proc.stdout?.on("data", (d) => {
-                        out += d.toString();
-                    });
-                    proc.on("close", () => resolve(out));
-                    proc.on("error", () => resolve(""));
-                });
-                // Parse the diff output
-                const lines = diffOutput.split("\n");
-                let currentHunk = null;
-                let oldLineNum = 0;
-                let newLineNum = 0;
-                // Get old content from HEAD
-                const oldContentOutput = await new Promise((resolve) => {
-                    const proc = spawnProcess("git", ["show", `HEAD:${file.path}`], { cwd: gitRoot });
-                    let out = "";
-                    proc.stdout?.on("data", (d) => {
-                        out += d.toString();
-                    });
-                    proc.on("close", () => resolve(out));
-                    proc.on("error", () => resolve(""));
-                });
-                oldContent = oldContentOutput;
-                // Get new content from working directory
-                try {
-                    newContent = readFileSync(resolve(gitRoot, file.path), "utf-8");
-                }
-                catch {
-                    newContent = "";
-                }
-                for (const line of lines) {
-                    // Parse hunk header
-                    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-                    if (hunkMatch) {
-                        if (currentHunk) {
-                            hunks.push(currentHunk);
-                        }
-                        currentHunk = {
-                            oldStart: parseInt(hunkMatch[1]),
-                            oldLines: parseInt(hunkMatch[2] || "1"),
-                            newStart: parseInt(hunkMatch[3]),
-                            newLines: parseInt(hunkMatch[4] || "1"),
-                            changes: [],
-                        };
-                        oldLineNum = currentHunk.oldStart;
-                        newLineNum = currentHunk.newStart;
-                        continue;
-                    }
-                    if (currentHunk) {
-                        if (line.startsWith("+") && !line.startsWith("+++")) {
-                            currentHunk.changes.push({
-                                type: "add",
-                                content: line.substring(1),
-                                newLineNumber: newLineNum++,
-                            });
-                        }
-                        else if (line.startsWith("-") && !line.startsWith("---")) {
-                            currentHunk.changes.push({
-                                type: "delete",
-                                content: line.substring(1),
-                                oldLineNumber: oldLineNum++,
-                            });
-                        }
-                        else if (line.startsWith(" ")) {
-                            currentHunk.changes.push({
-                                type: "context",
-                                content: line.substring(1),
-                                oldLineNumber: oldLineNum++,
-                                newLineNumber: newLineNum++,
-                            });
-                        }
-                        else if (line.match(/^\\ No newline/)) {
-                            // Skip this line
-                        }
-                    }
-                }
-                if (currentHunk) {
-                    hunks.push(currentHunk);
-                }
-            }
-            filesWithDiff.push({
-                ...file,
-                oldContent,
-                newContent,
-                hunks,
-            });
-        }
-        return c.json({ files: filesWithDiff });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to get git diff";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-diff.route.js.map

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

@@ -1,12 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitFetchHandler(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;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-fetch.route.d.ts.map

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

@@ -1,31 +0,0 @@
-import { resolveThreadPath, getGitRoot, fetchFromOrigin } from "./git.utils.js";
-export async function gitFetchHandler(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 absolutePath = resolveThreadPath(repoPath);
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-        }
-        catch {
-            return c.json({ error: `Path is not a git repository: ${absolutePath}` }, 400);
-        }
-        await fetchFromOrigin(gitRoot);
-        return c.json({ success: true });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to fetch from origin";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-fetch.route.js.map

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

@@ -1,12 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitGenerateCommitMessageHandler(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<{
-    message: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-generate-commit-message.route.d.ts.map

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

@@ -1,76 +0,0 @@
-import { existsSync } from "fs";
-import { resolveThreadPath, getGitRoot, getGitDiff, getUntrackedFilesDiff } from "./git.utils.js";
-import { generateCommitMessageWithAI } from "./git.utils.js";
-export async function gitGenerateCommitMessageHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        process.stdout.write(`[generate-commit-message] threadId=${threadId}\n`);
-        const thread = await metadataManager
-            .loadThreads()
-            .then((threads) => threads.find((t) => t.id === threadId));
-        if (!thread) {
-            process.stdout.write("[generate-commit-message] thread not found\n");
-            return c.json({ error: "Thread not found" }, 404);
-        }
-        else {
-            console.log(thread);
-        }
-        // Check path first before provider
-        const repoPath = thread.path;
-        if (!repoPath) {
-            process.stdout.write("[generate-commit-message] thread path missing\n");
-            return c.json({ error: "Thread path not found" }, 404);
-        }
-        // Get provider from thread's modelProvider, with exception handling if missing
-        const provider = thread.modelProvider;
-        if (!provider) {
-            throw new Error("Provider not found in thread metadata and cannot be extracted from model");
-        }
-        // Get model from thread
-        const model = thread.model;
-        const absolutePath = resolveThreadPath(repoPath);
-        process.stdout.write(`[generate-commit-message] resolved path: ${absolutePath}\n`);
-        if (!existsSync(absolutePath)) {
-            process.stdout.write(`[generate-commit-message] path does not exist: ${absolutePath}\n`);
-            return c.json({
-                error: `Thread repo path does not exist: ${absolutePath}. Check that the project folder is present.`,
-            }, 400);
-        }
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-            process.stdout.write(`[generate-commit-message] git root: ${gitRoot}\n`);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            process.stdout.write(`[generate-commit-message] not a git repo: ${msg}\n`);
-            return c.json({
-                error: `Path is not a git repository: ${absolutePath}. ${msg}`,
-            }, 400);
-        }
-        // Get git diff (staged first, then unstaged). If repo has no commits, git diff --cached fails on HEAD; fall back to git diff.
-        let diff = await getGitDiff(gitRoot);
-        // If diff is empty, include untracked files (git diff does not show them)
-        if (!diff.trim()) {
-            const untrackedDiff = await getUntrackedFilesDiff(gitRoot);
-            if (untrackedDiff) {
-                process.stdout.write(`[generate-commit-message] building diff for untracked files\n`);
-                diff = untrackedDiff;
-            }
-        }
-        if (!diff.trim()) {
-            process.stdout.write("[generate-commit-message] no changes to generate message for\n");
-            return c.json({ error: "No changes to generate commit message for" }, 400);
-        }
-        process.stdout.write(`[generate-commit-message] diff length=${diff.length} chars, generating message with AI\n`);
-        // Use AI to generate commit message
-        const commitMessage = await generateCommitMessageWithAI(diff, metadataManager, model, provider);
-        process.stdout.write(`[generate-commit-message] generated: ${commitMessage.replace(/\n/g, " ")}\n`);
-        return c.json({ message: commitMessage });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to generate commit message";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-generate-commit-message.route.js.map

package/dist/features/git/git-generate-pr-info.route.d.ts

@@ -1,13 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function gitGeneratePrInfoHandler(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<{
-    title: string;
-    description: string;
-    baseBranch: string | null;
-    currentBranch: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
-//# sourceMappingURL=git-generate-pr-info.route.d.ts.map