tarsk 0.4.4 → 0.4.6

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

@@ -1,208 +0,0 @@
-import { existsSync } from "fs";
-import { resolveThreadPath, getGitRoot, getCurrentBranch, findDefaultBranch } from "./git.utils.js";
-export async function gitSyncBranchHandler(c, metadataManager) {
-    try {
-        const threadId = c.req.param("threadId");
-        console.log(`[sync-branch] Starting sync for thread: ${threadId}`);
-        const thread = await metadataManager
-            .loadThreads()
-            .then((threads) => threads.find((t) => t.id === threadId));
-        if (!thread) {
-            console.log(`[sync-branch] Thread not found: ${threadId}`);
-            return c.json({ error: "Thread not found" }, 404);
-        }
-        const repoPath = thread.path;
-        if (!repoPath) {
-            console.log(`[sync-branch] Thread path not found for threadId: ${threadId}`);
-            return c.json({ error: "Thread path not found" }, 404);
-        }
-        const absolutePath = resolveThreadPath(repoPath);
-        console.log(`[sync-branch] Resolved path: ${absolutePath}`);
-        if (!existsSync(absolutePath)) {
-            console.log(`[sync-branch] Path does not exist: ${absolutePath}`);
-            return c.json({
-                error: `Thread repo path does not exist: ${absolutePath}`,
-            }, 400);
-        }
-        let gitRoot;
-        try {
-            gitRoot = await getGitRoot(absolutePath);
-            console.log(`[sync-branch] Git root: ${gitRoot}`);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            console.log(`[sync-branch] Not a git repository: ${msg}`);
-            return c.json({
-                error: `Path is not a git repository: ${msg}`,
-            }, 400);
-        }
-        // Get current branch and default branch
-        const currentBranch = await getCurrentBranch(gitRoot);
-        const defaultBranch = await findDefaultBranch(gitRoot);
-        console.log(`[sync-branch] Current branch: ${currentBranch}, Default branch: ${defaultBranch}`);
-        if (!defaultBranch) {
-            console.log(`[sync-branch] Could not determine default branch`);
-            return c.json({
-                error: "Could not determine default branch",
-            }, 400);
-        }
-        if (currentBranch === defaultBranch) {
-            console.log(`[sync-branch] Already on default branch: ${defaultBranch}`);
-            return c.json({
-                error: `Already on default branch (${defaultBranch})`,
-            }, 400);
-        }
-        // Check if branch is diverged (has unpushed commits and is behind remote)
-        const { spawnProcess } = await import("../../core/utils.js");
-        return new Promise((resolve) => {
-            console.log(`[sync-branch] Checking branch status...`);
-            const statusProc = spawnProcess("git", ["status", "-sb"], { cwd: gitRoot });
-            let statusOutput = "";
-            statusProc.on("close", (statusCode) => {
-                if (statusCode !== 0) {
-                    console.log(`[sync-branch] Failed to get git status: code ${statusCode}`);
-                    resolve(c.json({
-                        error: "Failed to check git status",
-                        code: statusCode,
-                    }, 400));
-                    return;
-                }
-                statusOutput = statusOutput.trim();
-                console.log(`[sync-branch] git status output: ${statusOutput}`);
-                // Check if branch is diverged (contains "ahead" and "behind")
-                const isDiverged = statusOutput.includes("ahead") && statusOutput.includes("behind");
-                if (isDiverged) {
-                    console.log(`[sync-branch] Branch is diverged, pushing commits first...`);
-                    // First push the commits
-                    const pushProc = spawnProcess("git", ["push", "origin", currentBranch], { cwd: gitRoot });
-                    let pushOut = "";
-                    let pushErr = "";
-                    if (pushProc.stdout) {
-                        pushProc.stdout.on("data", (d) => {
-                            pushOut += d.toString();
-                            console.log(`[sync-branch] push stdout: ${d.toString().trim()}`);
-                        });
-                    }
-                    if (pushProc.stderr) {
-                        pushProc.stderr.on("data", (d) => {
-                            pushErr += d.toString();
-                            console.log(`[sync-branch] push stderr: ${d.toString().trim()}`);
-                        });
-                    }
-                    pushProc.on("close", (pushCode) => {
-                        if (pushCode !== 0) {
-                            console.log(`[sync-branch] Failed to push commits: code ${pushCode}`);
-                            resolve(c.json({
-                                error: `Failed to push commits before sync: ${pushErr || pushOut}`,
-                                code: pushCode,
-                            }, 400));
-                            return;
-                        }
-                        console.log(`[sync-branch] ✓ Pushed commits successfully`);
-                        // Now proceed with sync after push
-                        performSync();
-                    });
-                    pushProc.on("error", (error) => {
-                        console.log(`[sync-branch] ✗ Push process error: ${error instanceof Error ? error.message : String(error)}`);
-                        resolve(c.json({
-                            error: `Failed to push commits: ${error instanceof Error ? error.message : String(error)}`,
-                        }, 500));
-                    });
-                }
-                else {
-                    console.log(`[sync-branch] Branch is not diverged, proceeding with sync...`);
-                    performSync();
-                }
-            });
-            if (statusProc.stdout) {
-                statusProc.stdout.on("data", (d) => {
-                    statusOutput += d.toString();
-                });
-            }
-            if (statusProc.stderr) {
-                statusProc.stderr.on("data", (d) => {
-                    statusOutput += d.toString();
-                });
-            }
-            statusProc.on("error", (error) => {
-                console.log(`[sync-branch] ✗ Status process error: ${error instanceof Error ? error.message : String(error)}`);
-                resolve(c.json({
-                    error: `Failed to check git status: ${error instanceof Error ? error.message : String(error)}`,
-                }, 500));
-            });
-            // Function to perform the actual sync
-            function performSync() {
-                // First, configure git to use rebase for pulls (handles divergent branches)
-                console.log(`[sync-branch] Configuring git pull strategy to rebase...`);
-                const configProc = spawnProcess("git", ["config", "pull.rebase", "true"], { cwd: gitRoot });
-                configProc.on("close", (configCode) => {
-                    if (configCode !== 0) {
-                        console.log(`[sync-branch] Failed to configure git: code ${configCode}`);
-                        resolve(c.json({
-                            error: "Failed to configure git pull strategy",
-                            code: configCode,
-                        }, 400));
-                        return;
-                    }
-                    console.log(`[sync-branch] Git config set successfully`);
-                    console.log(`[sync-branch] Starting git pull --rebase origin ${defaultBranch}...`);
-                    // Now perform git pull with rebase
-                    const pullProc = spawnProcess("git", ["pull", "--rebase", "origin", defaultBranch], {
-                        cwd: gitRoot,
-                    });
-                    let out = "";
-                    let err = "";
-                    if (pullProc.stdout) {
-                        pullProc.stdout.on("data", (d) => {
-                            out += d.toString();
-                            console.log(`[sync-branch] stdout: ${d.toString().trim()}`);
-                        });
-                    }
-                    if (pullProc.stderr) {
-                        pullProc.stderr.on("data", (d) => {
-                            err += d.toString();
-                            console.log(`[sync-branch] stderr: ${d.toString().trim()}`);
-                        });
-                    }
-                    pullProc.on("close", (code) => {
-                        if (code === 0) {
-                            console.log(`[sync-branch] ✓ Successfully synced ${currentBranch} with ${defaultBranch}`);
-                            resolve(c.json({
-                                success: true,
-                                message: `Successfully synced ${currentBranch} with ${defaultBranch}`,
-                                branch: currentBranch,
-                                defaultBranch,
-                            }));
-                        }
-                        else {
-                            console.log(`[sync-branch] ✗ Failed to sync with exit code ${code}`);
-                            console.log(`[sync-branch] Error output: ${err || out}`);
-                            resolve(c.json({
-                                error: `Failed to sync with ${defaultBranch}: ${err || out}`,
-                                code,
-                            }, 400));
-                        }
-                    });
-                    pullProc.on("error", (error) => {
-                        console.log(`[sync-branch] ✗ Process error: ${error instanceof Error ? error.message : String(error)}`);
-                        resolve(c.json({
-                            error: `Failed to sync branch: ${error instanceof Error ? error.message : String(error)}`,
-                        }, 500));
-                    });
-                });
-                configProc.on("error", (error) => {
-                    console.log(`[sync-branch] ✗ Config process error: ${error instanceof Error ? error.message : String(error)}`);
-                    resolve(c.json({
-                        error: `Failed to configure git: ${error instanceof Error ? error.message : String(error)}`,
-                    }, 500));
-                });
-            }
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to sync branch";
-        console.log(`[sync-branch] ✗ Unexpected error: ${message}`);
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-sync-branch.route.js.map

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

@@ -1,30 +0,0 @@
-import type { Context } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-import { Database } from "../../database/database.types.js";
-export declare function gitUnifiedStatusHandler(c: Context, metadataManager: MetadataManager, db: Database): Promise<(Response & import("hono").TypedResponse<{
-    cached: true;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 404, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    cached: false;
-    hasChanges: boolean;
-    changedFilesCount: number;
-    currentBranch: string;
-    hasUnpushedCommits: boolean;
-    hasRemoteBranch: boolean;
-    commitsAheadOfDefault: boolean;
-    isOnGitHub: boolean;
-    remoteUrl: string;
-    canCreateRepo: boolean;
-    repoUrl: string;
-    status: "Behind" | "Diverged" | "Ahead" | "Up to date";
-    defaultBranch: string | null;
-    prExists: boolean;
-    prUrl: string | undefined;
-    prState: string | undefined;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    error: string;
-}, 500, "json">)>;
-//# sourceMappingURL=git-unified-status.route.d.ts.map

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

@@ -1,165 +0,0 @@
-import { existsSync } from "fs";
-import { getGitStatusCache, setGitStatusCache } from "./git-status-cache.database.js";
-import { resolveThreadPath, getGitRoot, getGitStatus, getCurrentBranch, hasUnpushedCommits, getRemoteOrigin, getGitSyncStatus, hasRemoteBranch, getPullRequestStatus, findDefaultBranch, hasCommitsAheadOfDefault, } from "./git.utils.js";
-export async function gitUnifiedStatusHandler(c, metadataManager, db) {
-    try {
-        const threadId = c.req.param("threadId");
-        const fresh = c.req.query("fresh") === "true";
-        // Return cached result if available and fresh is not requested
-        if (!fresh) {
-            const cached = await getGitStatusCache(db, threadId);
-            if (cached) {
-                return c.json({ ...cached, cached: true });
-            }
-        }
-        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);
-        }
-        // === Git Status Information ===
-        // 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);
-        // === GitHub Status Information ===
-        // 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 if remote branch exists
-        let hasRemoteBranchExists = false;
-        if (remoteUrl && currentBranch && currentBranch !== "HEAD") {
-            try {
-                hasRemoteBranchExists = await hasRemoteBranch(gitRoot, currentBranch);
-            }
-            catch (error) {
-                // If we can't determine remote branch existence, default to false
-                console.warn(`Failed to check remote branch existence: ${error instanceof Error ? error.message : String(error)}`);
-                hasRemoteBranchExists = false;
-            }
-        }
-        // Get default branch
-        let defaultBranchName = null;
-        try {
-            defaultBranchName = await findDefaultBranch(gitRoot);
-        }
-        catch (error) {
-            console.warn(`Failed to find default branch: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Check if current branch has commits ahead of default branch (covers pushed + unpushed)
-        let commitsAheadOfDefault = false;
-        if (defaultBranchName && currentBranch && currentBranch !== defaultBranchName) {
-            try {
-                commitsAheadOfDefault = await hasCommitsAheadOfDefault(gitRoot, defaultBranchName);
-            }
-            catch {
-                commitsAheadOfDefault = false;
-            }
-        }
-        // Check git sync status
-        let status = "Up to date";
-        if (isOnGitHub && remoteUrl) {
-            try {
-                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";
-            }
-        }
-        // === PR Status Information ===
-        // Check PR status (only if on GitHub)
-        let prStatus = { exists: false };
-        if (isOnGitHub) {
-            try {
-                prStatus = await getPullRequestStatus(gitRoot);
-            }
-            catch (error) {
-                // If we can't determine PR status, default to false
-                console.warn(`Failed to check PR status: ${error instanceof Error ? error.message : String(error)}`);
-                prStatus = { exists: false };
-            }
-        }
-        // === Combined Response ===
-        const result = {
-            // Git status fields
-            hasChanges,
-            changedFilesCount,
-            currentBranch,
-            hasUnpushedCommits: hasUnpushed,
-            hasRemoteBranch: hasRemoteBranchExists,
-            commitsAheadOfDefault,
-            // GitHub status fields
-            isOnGitHub,
-            remoteUrl,
-            canCreateRepo: !isOnGitHub && remoteUrl.length === 0,
-            repoUrl,
-            status,
-            defaultBranch: defaultBranchName,
-            // PR status fields
-            prExists: prStatus.exists,
-            prUrl: prStatus.url,
-            prState: prStatus.state,
-        };
-        await setGitStatusCache(db, threadId, result);
-        return c.json({ ...result, cached: false });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : "Failed to get unified git status";
-        return c.json({ error: message }, 500);
-    }
-}
-//# sourceMappingURL=git-unified-status.route.js.map

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

@@ -1,3 +0,0 @@
-import type { Context } from "hono";
-export declare function gitUsernameHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=git-username.route.d.ts.map

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

@@ -1,24 +0,0 @@
-import { spawnProcess } from "../../core/utils.js";
-export function gitUsernameHandler(c) {
-    return new Promise((resolve) => {
-        const proc = spawnProcess("git", ["config", "user.name"]);
-        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) {
-                resolve(c.json({ name: out.trim() }));
-            }
-            else {
-                resolve(c.json({ name: "" }));
-            }
-        });
-        proc.on("error", (_e) => resolve(c.json({ name: "" })));
-    });
-}
-//# sourceMappingURL=git-username.route.js.map

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

@@ -1,139 +0,0 @@
-/**
- * GitManager handles git operations including URL validation and repository cloning
- *
- * This manager is responsible for:
- * - Validating git URLs in various formats
- * - Cloning repositories with streaming output
- * - Handling git operation errors
- */
-import { GitEvent } from "@tarsk/shared";
-/**
- * GitManager interface defines the contract for git operations
- */
-export interface GitManager {
-    /**
-     * Validates a git URL format
-     * @param url - The git URL to validate
-     * @returns true if the URL is a valid git URL, false otherwise
-     */
-    validateGitUrl(url: string): boolean;
-    /**
-     * Clones a git repository to the specified target path
-     * @param gitUrl - The git repository URL to clone
-     * @param targetPath - The local path where the repository should be cloned
-     * @yields GitEvent objects for stdout, stderr, complete, and error events
-     */
-    cloneRepository(gitUrl: string, targetPath: string): AsyncGenerator<GitEvent>;
-    /**
-     * Sanitizes a branch name to ensure it only contains valid git branch characters
-     * Replaces spaces with dashes and removes invalid characters
-     * @param name - The branch name to sanitize
-     * @returns The sanitized branch name
-     */
-    sanitizeBranchName(name: string): string;
-    /**
-     * Checks if a branch exists in a git repository
-     * @param repoPath - The path to the git repository
-     * @param branchName - The branch name to check
-     * @returns true if the branch exists, false otherwise
-     */
-    checkBranchExists(repoPath: string, branchName: string): Promise<boolean>;
-    /**
-     * Creates and checks out a new branch in a git repository
-     * @param repoPath - The path to the git repository
-     * @param branchName - The branch name to create
-     * @yields GitEvent objects for stdout, stderr, complete, and error events
-     */
-    createAndCheckoutBranch(repoPath: string, branchName: string): AsyncGenerator<GitEvent>;
-    /**
-     * Initializes a new git repository at the given path
-     * @param repoPath - The path where to run git init
-     */
-    initRepository(repoPath: string): Promise<void>;
-}
-/**
- * GitManagerImpl provides the implementation for git operations
- */
-export declare class GitManagerImpl implements GitManager {
-    /**
-     * Regular expressions for validating different git URL formats
-     */
-    private readonly gitUrlPatterns;
-    /**
-     * Validates a git URL against common git URL formats
-     *
-     * Supports the following formats:
-     * - HTTPS: https://github.com/user/repo.git
-     * - Git protocol: git://github.com/user/repo.git
-     * - SSH (git@): git@github.com:user/repo.git
-     * - SSH (ssh://): ssh://git@github.com/user/repo.git
-     *
-     * @param url - The URL to validate
-     * @returns true if the URL matches a valid git URL format, false otherwise
-     *
-     * Requirements: 7.1 - WHEN cloning a git repository, THE CLI SHALL validate the git URL format
-     */
-    validateGitUrl(url: string): boolean;
-    /**
-     * Clones a git repository to the specified target path with streaming output
-     *
-     * This method:
-     * 1. Validates the git URL
-     * 2. Creates the target directory if needed
-     * 3. Spawns a git clone process
-     * 4. Streams stdout and stderr output
-     * 5. Handles completion and errors
-     *
-     * @param gitUrl - The git repository URL to clone
-     * @param targetPath - The local path where the repository should be cloned
-     * @yields GitEvent objects during the clone operation
-     *
-     * Requirements:
-     * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository
-     * - 1.3 - WHEN the clone operation executes, THE CLI SHALL stream the git clone output back to the App
-     * - 7.1 - WHEN cloning a git repository, THE CLI SHALL validate the git URL format
-     * - 7.2 - IF a git clone operation fails, THEN THE CLI SHALL return a descriptive error message
-     * - 7.3 - WHEN a clone operation is in progress, THE CLI SHALL stream git output to provide progress feedback
-     */
-    cloneRepository(gitUrl: string, targetPath: string): AsyncGenerator<GitEvent>;
-    /**
-     * Sanitizes a branch name to ensure it only contains valid git branch characters
-     *
-     * This method:
-     * 1. Trims whitespace
-     * 2. Converts to lowercase
-     * 3. Replaces spaces with dashes
-     * 4. Removes invalid characters (only allows alphanumeric, dash, underscore, slash, dot)
-     * 5. Removes leading/trailing slashes and dots
-     * 6. Collapses multiple consecutive dashes into one
-     *
-     * @param name - The branch name to sanitize
-     * @returns The sanitized branch name (all lowercase)
-     */
-    sanitizeBranchName(name: string): string;
-    /**
-     * Checks if a branch exists in a git repository
-     *
-     * Uses `git show-ref` to check for the branch without checking out
-     *
-     * @param repoPath - The path to the git repository
-     * @param branchName - The branch name to check
-     * @returns true if the branch exists, false otherwise
-     */
-    checkBranchExists(repoPath: string, branchName: string): Promise<boolean>;
-    /**
-     * Creates and checks out a new branch in a git repository with streaming output
-     *
-     * This method:
-     * 1. Creates a new branch from the current HEAD
-     * 2. Checks out the new branch
-     * 3. Streams output during the operation
-     *
-     * @param repoPath - The path to the git repository
-     * @param branchName - The branch name to create
-     * @yields GitEvent objects during the branch creation
-     */
-    createAndCheckoutBranch(repoPath: string, branchName: string): AsyncGenerator<GitEvent>;
-    initRepository(repoPath: string): Promise<void>;
-}
-//# sourceMappingURL=git.manager.d.ts.map