tarsk 0.3.43 → 0.4.4

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,189 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,13 @@
+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