tarsk 0.3.43 → 0.4.4

package/dist/features/git/git-generate-pr-info.route.js

@@ -0,0 +1,147 @@
+import { spawnProcess } from "../../core/utils.js";
+import { resolveThreadPath, getGitRoot, getCurrentBranch, getDefaultBranch, findDefaultBranch, getCommitLog, getDetailedCommits, generatePRInfoWithAI, } from "./git.utils.js";
+export async function gitGeneratePrInfoHandler(c, metadataManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        console.log(`[pr-generation] Starting PR info generation for thread: ${threadId}`);
+        const thread = await metadataManager
+            .loadThreads()
+            .then((threads) => threads.find((t) => t.id === threadId));
+        if (!thread) {
+            console.log(`[pr-generation] Thread not found: ${threadId}`);
+            return c.json({ error: "Thread not found" }, 404);
+        }
+        console.log(`[pr-generation] ✓ Thread found: ${thread.title}, model: ${thread.model}, modelProvider: ${thread.modelProvider}`);
+        // Check path first
+        const repoPath = thread.path;
+        if (!repoPath) {
+            console.log(`[pr-generation] Thread path not found for threadId: ${threadId}`);
+            return c.json({ error: "Thread path not found" }, 404);
+        }
+        // Get provider from thread's modelProvider, like commit message generation
+        const provider = thread.modelProvider;
+        if (!provider) {
+            console.log(`[pr-generation] ✗ Provider not found in thread metadata`);
+            return c.json({
+                title: "Update",
+                description: "",
+                error: "Provider not found in thread metadata",
+            }, 400);
+        }
+        // Get model from thread
+        const model = thread.model;
+        console.log(`[pr-generation] Using provider: ${provider}, model: ${model}`);
+        const absolutePath = resolveThreadPath(repoPath);
+        console.log(`[pr-generation] Resolved path: ${absolutePath}`);
+        let gitRoot;
+        try {
+            gitRoot = await getGitRoot(absolutePath);
+            console.log(`[pr-generation] ✓ Git root: ${gitRoot}`);
+        }
+        catch {
+            console.log(`[pr-generation] ✗ 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(`[pr-generation] Current branch: ${currentBranch}`);
+        // Get git diff (staged + unstaged). If no commits yet (HEAD missing), use git diff.
+        console.log(`[pr-generation] Collecting git diff...`);
+        const diff = await new Promise((resolveDiff, reject) => {
+            const runPlainDiff = () => {
+                console.log(`[pr-generation] No HEAD found, using plain git diff`);
+                const proc2 = spawnProcess("git", ["diff"], { cwd: gitRoot });
+                let out2 = "";
+                proc2.stdout?.on("data", (d) => {
+                    out2 += d.toString();
+                });
+                proc2.on("close", () => {
+                    console.log(`[pr-generation] ✓ Plain diff collected, length: ${out2.length}`);
+                    resolveDiff(out2);
+                });
+                proc2.on("error", reject);
+            };
+            const proc = spawnProcess("git", ["diff", "HEAD"], { cwd: gitRoot });
+            let out = "";
+            let err = "";
+            proc.stdout?.on("data", (d) => {
+                out += d.toString();
+            });
+            proc.stderr?.on("data", (d) => {
+                err += d.toString();
+            });
+            proc.on("close", (code) => {
+                if (code === 0) {
+                    console.log(`[pr-generation] ✓ HEAD diff collected, length: ${out.length}`);
+                    resolveDiff(out);
+                }
+                else {
+                    const noHead = /HEAD|revision|unknown revision/i.test(err);
+                    if (noHead)
+                        runPlainDiff();
+                    else {
+                        console.log(`[pr-generation] ✗ Failed to get git diff: ${err}`);
+                        reject(new Error(err || "Failed to get git diff"));
+                    }
+                }
+            });
+            proc.on("error", reject);
+        });
+        // Find the default/base branch (try origin/HEAD, then common defaults)
+        console.log(`[pr-generation] Finding base branch...`);
+        const baseBranch = await getDefaultBranch(gitRoot);
+        console.log(`[pr-generation] getDefaultBranch result: ${baseBranch}`);
+        // Fallback: try common default branch names
+        const effectiveBaseBranch = baseBranch ?? (await findDefaultBranch(gitRoot));
+        console.log(`[pr-generation] Effective base branch: ${effectiveBaseBranch}`);
+        // Get commits between base branch and current branch (if we have a base branch and aren't on it)
+        let commitLog = "";
+        if (effectiveBaseBranch && currentBranch !== effectiveBaseBranch) {
+            console.log(`[pr-generation] Getting commit log between ${effectiveBaseBranch} and ${currentBranch}...`);
+            commitLog = await getCommitLog(gitRoot, effectiveBaseBranch, currentBranch);
+            console.log(`[pr-generation] ✓ Commit log collected, length: ${commitLog.length}`);
+        }
+        else {
+            console.log(`[pr-generation] No commit log needed (same branch or no base branch)`);
+        }
+        // Get detailed commit info for better PR generation
+        let detailedCommits = "";
+        if (effectiveBaseBranch && currentBranch !== effectiveBaseBranch && commitLog) {
+            console.log(`[pr-generation] Getting detailed commits...`);
+            detailedCommits = await getDetailedCommits(gitRoot, effectiveBaseBranch, currentBranch);
+            console.log(`[pr-generation] ✓ Detailed commits collected, length: ${detailedCommits.length}`);
+        }
+        if (!diff.trim() && !commitLog.trim()) {
+            console.log(`[pr-generation] ✗ No changes found - diff length: ${diff.length}, commit log length: ${commitLog.length}`);
+            return c.json({
+                error: effectiveBaseBranch
+                    ? `No changes to generate PR info for. The current branch "${currentBranch}" has no uncommitted changes and no commits ahead of "${effectiveBaseBranch}".`
+                    : "No changes to generate PR info for. Make sure you have uncommitted changes or commits ahead of the base branch.",
+            }, 400);
+        }
+        console.log(`[pr-generation] Calling generatePRInfoWithAI...`);
+        // Use AI to generate PR info
+        const prInfo = await generatePRInfoWithAI(commitLog, detailedCommits, diff, currentBranch, effectiveBaseBranch ?? "", metadataManager, model, provider);
+        console.log(`[pr-generation] ✓ PR info generated - title: "${prInfo.title}", description length: ${prInfo.description.length}`);
+        console.log(`[pr-generation] ✓ PR generation completed successfully`);
+        return c.json({
+            title: prInfo.title,
+            description: prInfo.description,
+            baseBranch: effectiveBaseBranch,
+            currentBranch,
+        });
+    }
+    catch (error) {
+        console.log(`[pr-generation] ✗ Error during PR generation: ${error instanceof Error ? error.message : String(error)}`);
+        console.log(`[pr-generation] Error stack: ${error instanceof Error ? error.stack : "No stack available"}`);
+        // Return default PR info on error
+        return c.json({
+            title: "Update",
+            description: "",
+            baseBranch: null,
+            currentBranch: "",
+            error: error instanceof Error ? error.message : "Failed to generate PR info",
+        });
+    }
+}
+//# sourceMappingURL=git-generate-pr-info.route.js.map

package/dist/features/git/git-github-status.route.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from "hono";
+import { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function gitGithubStatusHandler(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<{
+    isOnGitHub: boolean;
+    remoteUrl: string;
+    canCreateRepo: boolean;
+    repoUrl: string;
+    status: "Behind" | "Diverged" | "Ahead" | "Up to date";
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=git-github-status.route.d.ts.map

package/dist/features/git/git-github-status.route.js

@@ -0,0 +1,68 @@
+import { resolveThreadPath, getGitRoot, getRemoteOrigin, getCurrentBranch, getGitSyncStatus, } from "./git.utils.js";
+export async function gitGithubStatusHandler(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);
+        }
+        // Check if origin remote is a GitHub URL
+        const remoteUrl = await getRemoteOrigin(gitRoot);
+        const isOnGitHub = remoteUrl.includes("github.com");
+        // Extract repo URL from remote URL (handle both https and ssh formats)
+        let repoUrl = "";
+        if (isOnGitHub) {
+            if (remoteUrl.startsWith("https://")) {
+                repoUrl = remoteUrl.replace(/\.git$/, "");
+            }
+            else if (remoteUrl.startsWith("git@")) {
+                // Convert git@github.com:user/repo.git to https://github.com/user/repo
+                const match = remoteUrl.match(/git@github\.com:(.+?)\.git$/);
+                if (match) {
+                    repoUrl = `https://github.com/${match[1]}`;
+                }
+            }
+        }
+        // Check git sync status
+        let status = "Up to date";
+        if (isOnGitHub && remoteUrl) {
+            try {
+                const currentBranch = await getCurrentBranch(gitRoot);
+                if (currentBranch && currentBranch !== "HEAD") {
+                    status = await getGitSyncStatus(gitRoot, currentBranch);
+                }
+            }
+            catch (error) {
+                // If we can't determine the status, default to Up to date
+                console.warn(`Failed to check git sync status: ${error instanceof Error ? error.message : String(error)}`);
+                status = "Up to date";
+            }
+        }
+        return c.json({
+            isOnGitHub,
+            remoteUrl,
+            canCreateRepo: !isOnGitHub && remoteUrl.length === 0,
+            repoUrl,
+            status,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to check GitHub status";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=git-github-status.route.js.map

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

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

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

@@ -0,0 +1,33 @@
+import { resolveThreadPath, getGitRoot, getGitLog } from "./git.utils.js";
+export async function gitLogHandler(c, metadataManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        const limit = c.req.query("limit") ? parseInt(c.req.query("limit")) : 50;
+        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 git log
+        const commits = await getGitLog(gitRoot, limit);
+        return c.json({ commits });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to fetch git log";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=git-log.route.js.map

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

@@ -0,0 +1,15 @@
+import type { Context } from "hono";
+import { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function gitPrStatusHandler(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<{
+    exists: boolean;
+    url?: string | undefined;
+    state?: string | undefined;
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=git-pr-status.route.d.ts.map

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

@@ -0,0 +1,33 @@
+import { resolveThreadPath, getGitRoot, getPullRequestStatus } from "./git.utils.js";
+export async function gitPrStatusHandler(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);
+        }
+        // Check PR status
+        const prStatus = await getPullRequestStatus(gitRoot);
+        return c.json({ success: true, ...prStatus });
+    }
+    catch (error) {
+        console.error("Failed to check PR status:", error);
+        const message = error instanceof Error ? error.message : "Failed to check PR status";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=git-pr-status.route.js.map

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

@@ -0,0 +1,12 @@
+import type { Context } from "hono";
+import { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function gitPullHandler(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-pull.route.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+import type { Context } from "hono";
+import { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function gitPushHandler(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-push.route.d.ts.map

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

@@ -0,0 +1,46 @@
+import { resolveThreadPath, getGitRoot, getCurrentBranch, pushToOrigin } from "./git.utils.js";
+export async function gitPushHandler(c, metadataManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        console.log(`[git-push] Starting push for thread: ${threadId}`);
+        const thread = await metadataManager
+            .loadThreads()
+            .then((threads) => threads.find((t) => t.id === threadId));
+        if (!thread) {
+            console.log(`[git-push] Thread not found: ${threadId}`);
+            return c.json({ error: "Thread not found" }, 404);
+        }
+        console.log(`[git-push] ✓ Thread found: ${thread.title}`);
+        const repoPath = thread.path;
+        if (!repoPath) {
+            console.log(`[git-push] Thread path not found for threadId: ${threadId}`);
+            return c.json({ error: "Thread path not found" }, 404);
+        }
+        const absolutePath = resolveThreadPath(repoPath);
+        console.log(`[git-push] Resolved path: ${absolutePath}`);
+        let gitRoot;
+        try {
+            gitRoot = await getGitRoot(absolutePath);
+            console.log(`[git-push] ✓ Git root: ${gitRoot}`);
+        }
+        catch {
+            console.log(`[git-push] ✗ 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-push] Current branch: ${currentBranch}`);
+        // Push to origin
+        console.log(`[git-push] Starting push to origin for branch: ${currentBranch}`);
+        await pushToOrigin(gitRoot, currentBranch);
+        console.log(`[git-push] ✓ Successfully pushed ${currentBranch} to origin`);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to push changes";
+        console.log(`[git-push] ✗ Push failed: ${message}`);
+        console.log(`[git-push] Error stack: ${error instanceof Error ? error.stack : "No stack available"}`);
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=git-push.route.js.map

package/dist/features/git/git-status-cache.database.d.ts

@@ -0,0 +1,7 @@
+import { Database } from "../../database/database.types.js";
+export declare function getGitStatusCache(db: Database, threadId: string): Promise<object | null>;
+export declare function setGitStatusCache(db: Database, threadId: string, data: object): Promise<void>;
+export declare function getGitStatusCacheAnyAge(db: Database, threadId: string): Promise<object | null>;
+export declare function getGitStatusCacheBulk(db: Database, threadIds: string[]): Promise<Map<string, object>>;
+export declare function invalidateGitStatusCache(db: Database, threadId: string): Promise<void>;
+//# sourceMappingURL=git-status-cache.database.d.ts.map

package/dist/features/git/git-status-cache.database.js

@@ -0,0 +1,53 @@
+const CACHE_TTL_MS = 30_000;
+export async function getGitStatusCache(db, threadId) {
+    const result = await db.execute("SELECT data, cachedAt FROM git_status_cache WHERE threadId = ?", [threadId]);
+    const row = result.rows[0];
+    if (!row)
+        return null;
+    if (Date.now() - new Date(row.cachedAt).getTime() > CACHE_TTL_MS)
+        return null;
+    try {
+        return JSON.parse(row.data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function setGitStatusCache(db, threadId, data) {
+    await db.execute("INSERT OR REPLACE INTO git_status_cache (threadId, data, cachedAt) VALUES (?, ?, ?)", [threadId, JSON.stringify(data), new Date().toISOString()]);
+}
+export async function getGitStatusCacheAnyAge(db, threadId) {
+    const result = await db.execute("SELECT data FROM git_status_cache WHERE threadId = ?", [
+        threadId,
+    ]);
+    const row = result.rows[0];
+    if (!row)
+        return null;
+    try {
+        return JSON.parse(row.data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function getGitStatusCacheBulk(db, threadIds) {
+    if (threadIds.length === 0)
+        return new Map();
+    const placeholders = threadIds.map(() => "?").join(", ");
+    const result = await db.execute(`SELECT threadId, data FROM git_status_cache WHERE threadId IN (${placeholders})`, threadIds);
+    const map = new Map();
+    for (const row of result.rows) {
+        const r = row;
+        try {
+            map.set(r.threadId, JSON.parse(r.data));
+        }
+        catch {
+            // skip malformed entries
+        }
+    }
+    return map;
+}
+export async function invalidateGitStatusCache(db, threadId) {
+    await db.execute("DELETE FROM git_status_cache WHERE threadId = ?", [threadId]);
+}
+//# sourceMappingURL=git-status-cache.database.js.map

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

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

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

@@ -0,0 +1,62 @@
+import { existsSync } from "fs";
+import { resolveThreadPath, getGitRoot, getGitStatus, getCurrentBranch, hasUnpushedCommits, } from "./git.utils.js";
+export async function gitStatusHandler(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);
+        if (!existsSync(absolutePath)) {
+            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);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return c.json({
+                error: `Path is not a git repository: ${absolutePath}. ${msg}`,
+            }, 400);
+        }
+        // Check for uncommitted changes and count files
+        const { hasChanges, changedFilesCount } = await new Promise((resolve) => {
+            getGitStatus(gitRoot)
+                .then((statusOutput) => {
+                const lines = statusOutput
+                    .trim()
+                    .split("\n")
+                    .filter((line) => line.length > 0);
+                resolve({
+                    hasChanges: lines.length > 0,
+                    changedFilesCount: lines.length,
+                });
+            })
+                .catch(() => resolve({ hasChanges: false, changedFilesCount: 0 }));
+        });
+        // Get current branch
+        const currentBranch = await getCurrentBranch(gitRoot);
+        // Check if there are unpushed commits
+        const hasUnpushed = await hasUnpushedCommits(gitRoot, currentBranch);
+        return c.json({
+            hasChanges,
+            changedFilesCount,
+            currentBranch,
+            hasUnpushedCommits: hasUnpushed,
+        });
+    }
+    catch {
+        return c.json({ error: "Failed to get git status" }, 500);
+    }
+}
+//# sourceMappingURL=git-status.route.js.map

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

@@ -0,0 +1,4 @@
+import type { Context } from "hono";
+import { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function gitSyncBranchHandler(c: Context, metadataManager: MetadataManager): Promise<Response>;
+//# sourceMappingURL=git-sync-branch.route.d.ts.map