tarsk 0.4.4 → 0.4.6

package/dist/features/git/git.manager.js

@@ -1,352 +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 { spawnProcess, spawnSyncProcess } from "../../core/utils.js";
-import { mkdir } from "fs/promises";
-import { dirname } from "path";
-/**
- * GitManagerImpl provides the implementation for git operations
- */
-export class GitManagerImpl {
-    /**
-     * Regular expressions for validating different git URL formats
-     */
-    gitUrlPatterns = [
-        // HTTPS URLs: https://github.com/user/repo.git or https://github.com/user/repo
-        /^https:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:[0-9]+)?\/[a-zA-Z0-9._/-]+(\.git)?$/,
-        // Git protocol URLs: git://github.com/user/repo.git or git://github.com/user/repo
-        /^git:\/\/[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:[0-9]+)?\/[a-zA-Z0-9._/-]+(\.git)?$/,
-        // SSH URLs with git@ prefix: git@github.com:user/repo.git or git@github.com:user/repo
-        /^git@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}:[a-zA-Z0-9._/-]+(\.git)?$/,
-        // SSH URLs with ssh:// prefix: ssh://git@github.com/user/repo.git
-        /^ssh:\/\/(git@)?[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(:[0-9]+)?\/[a-zA-Z0-9._/-]+(\.git)?$/,
-    ];
-    /**
-     * 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) {
-        // Check if URL is empty or not a string
-        if (!url || typeof url !== "string") {
-            return false;
-        }
-        // Trim whitespace
-        const trimmedUrl = url.trim();
-        // Check if URL is empty after trimming
-        if (trimmedUrl.length === 0) {
-            return false;
-        }
-        // Test against all supported patterns
-        return this.gitUrlPatterns.some((pattern) => pattern.test(trimmedUrl));
-    }
-    /**
-     * 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
-     */
-    async *cloneRepository(gitUrl, targetPath) {
-        // Validate the git URL first
-        if (!this.validateGitUrl(gitUrl)) {
-            yield {
-                type: "error",
-                message: `Invalid git URL format: ${gitUrl}`,
-                error: new Error(`Invalid git URL format: ${gitUrl}`),
-            };
-            return;
-        }
-        try {
-            // Create the parent directory if it doesn't exist
-            const parentDir = dirname(targetPath);
-            await mkdir(parentDir, { recursive: true });
-            // Spawn git clone process
-            // Use --progress to get progress output on stderr
-            const gitProcess = spawnProcess("git", ["clone", "--progress", gitUrl, targetPath]);
-            // Create a queue for events
-            const eventQueue = [];
-            let processExited = false;
-            let exitCode = null;
-            let processError = null;
-            // Handle stdout data
-            if (gitProcess.stdout) {
-                gitProcess.stdout.on("data", (data) => {
-                    const output = data.toString();
-                    eventQueue.push({
-                        type: "stdout",
-                        data: output,
-                    });
-                });
-            }
-            // Handle stderr data (git clone progress goes to stderr)
-            if (gitProcess.stderr) {
-                gitProcess.stderr.on("data", (data) => {
-                    const output = data.toString();
-                    eventQueue.push({
-                        type: "stderr",
-                        data: output,
-                    });
-                });
-            }
-            // Handle process exit
-            gitProcess.on("close", (code) => {
-                exitCode = code;
-                processExited = true;
-            });
-            // Handle process errors
-            gitProcess.on("error", (err) => {
-                processError = err;
-                processExited = true;
-            });
-            // Yield events as they come in
-            while (!processExited || eventQueue.length > 0) {
-                if (eventQueue.length > 0) {
-                    const event = eventQueue.shift();
-                    if (event) {
-                        yield event;
-                    }
-                }
-                else {
-                    // Wait a bit before checking again
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                }
-            }
-            // Check for process errors
-            if (processError) {
-                const errorMessage = processError instanceof Error ? processError.message : JSON.stringify(processError);
-                yield {
-                    type: "error",
-                    message: errorMessage,
-                    error: processError,
-                };
-                return;
-            }
-            // Check exit code
-            if (exitCode !== 0) {
-                const errorMsg = `Git clone failed with exit code ${exitCode}`;
-                yield {
-                    type: "error",
-                    message: errorMsg,
-                    error: new Error(errorMsg),
-                };
-                return;
-            }
-            // Yield complete event
-            yield {
-                type: "complete",
-            };
-        }
-        catch (error) {
-            // Handle any errors during the process
-            yield {
-                type: "error",
-                message: error instanceof Error ? error.message : String(error),
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
-    /**
-     * 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) {
-        if (!name || typeof name !== "string") {
-            return "branch";
-        }
-        return (name
-            .trim()
-            // Convert to lowercase
-            .toLowerCase()
-            // Replace spaces with dashes
-            .replace(/\s+/g, "-")
-            // Remove invalid characters (keep alphanumeric, dash, underscore, slash, dot)
-            .replace(/[^a-zA-Z0-9\-_/.]/g, "")
-            // Remove leading/trailing slashes and dots
-            .replace(/^[/.]+|[/.]+$/g, "")
-            // Collapse multiple consecutive dashes
-            .replace(/-+/g, "-") ||
-            // Ensure we have something left
-            "branch");
-    }
-    /**
-     * 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
-     */
-    async checkBranchExists(repoPath, branchName) {
-        return new Promise((resolve) => {
-            const gitProcess = spawnProcess("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
-                cwd: repoPath,
-            });
-            gitProcess.on("close", (code) => {
-                // Exit code 0 means the branch exists
-                resolve(code === 0);
-            });
-            gitProcess.on("error", () => {
-                // If there's an error running git, assume branch doesn't exist
-                resolve(false);
-            });
-        });
-    }
-    /**
-     * 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
-     */
-    async *createAndCheckoutBranch(repoPath, branchName) {
-        try {
-            // Spawn git checkout process with -b flag to create new branch
-            const gitProcess = spawnProcess("git", ["checkout", "-b", branchName], {
-                cwd: repoPath,
-            });
-            // Create a queue for events
-            const eventQueue = [];
-            let processExited = false;
-            let exitCode = null;
-            let processError = null;
-            // Handle stdout data
-            if (gitProcess.stdout) {
-                gitProcess.stdout.on("data", (data) => {
-                    const output = data.toString();
-                    eventQueue.push({
-                        type: "stdout",
-                        data: output,
-                    });
-                });
-            }
-            // Handle stderr data
-            if (gitProcess.stderr) {
-                gitProcess.stderr.on("data", (data) => {
-                    const output = data.toString();
-                    eventQueue.push({
-                        type: "stderr",
-                        data: output,
-                    });
-                });
-            }
-            // Handle process exit
-            gitProcess.on("close", (code) => {
-                exitCode = code;
-                processExited = true;
-            });
-            // Handle process errors
-            gitProcess.on("error", (err) => {
-                processError = err;
-                processExited = true;
-            });
-            // Yield events as they come in
-            while (!processExited || eventQueue.length > 0) {
-                if (eventQueue.length > 0) {
-                    const event = eventQueue.shift();
-                    if (event) {
-                        yield event;
-                    }
-                }
-                else {
-                    // Wait a bit before checking again
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                }
-            }
-            // Check for process errors
-            if (processError) {
-                const errorMessage = processError instanceof Error ? processError.message : JSON.stringify(processError);
-                yield {
-                    type: "error",
-                    message: errorMessage,
-                    error: processError,
-                };
-                return;
-            }
-            // Check exit code
-            if (exitCode !== 0) {
-                const errorMsg = `Failed to create and checkout branch '${branchName}' with exit code ${exitCode}`;
-                yield {
-                    type: "error",
-                    message: errorMsg,
-                    error: new Error(errorMsg),
-                };
-                return;
-            }
-            // Yield complete event
-            yield {
-                type: "complete",
-            };
-        }
-        catch (error) {
-            yield {
-                type: "error",
-                message: error instanceof Error ? error.message : String(error),
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-    }
-    async initRepository(repoPath) {
-        // Ensure the directory exists
-        try {
-            await mkdir(repoPath, { recursive: true });
-        }
-        catch (error) {
-            // Directory might already exist, which is fine
-            if (error.code !== "EEXIST") {
-                throw error;
-            }
-        }
-        const result = spawnSyncProcess("git", ["init"], { cwd: repoPath, encoding: "utf-8" });
-        if (result.status !== 0) {
-            const stderrStr = (typeof result.stderr === "string" ? result.stderr : (result.stderr?.toString() ?? "")).trim();
-            const stderr = stderrStr !== "" ? stderrStr : (result.error?.message ?? "Unknown error");
-            throw new Error(`git init failed: ${stderr}`);
-        }
-    }
-}
-//# sourceMappingURL=git.manager.js.map

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

@@ -1,4 +0,0 @@
-import { Hono } from "hono";
-import { MetadataManager } from "../metadata/metadata.manager.js";
-export declare function createGitRoutes(metadataManager: MetadataManager): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=git.routes.d.ts.map

package/dist/features/git/git.routes.js

@@ -1,116 +0,0 @@
-import { Hono } from "hono";
-import { getDatabase } from "../../database/database.js";
-import { invalidateGitStatusCache } from "./git-status-cache.database.js";
-import { gitUsernameHandler } from "./git-username.route.js";
-import { gitStatusHandler } from "./git-status.route.js";
-import { gitDiffHandler } from "./git-diff.route.js";
-import { gitGenerateCommitMessageHandler } from "./git-generate-commit-message.route.js";
-import { gitCommitHandler } from "./git-commit.route.js";
-import { gitPushHandler } from "./git-push.route.js";
-import { gitPullHandler } from "./git-pull.route.js";
-import { gitFetchHandler } from "./git-fetch.route.js";
-import { gitGeneratePrInfoHandler } from "./git-generate-pr-info.route.js";
-import { gitLogHandler } from "./git-log.route.js";
-import { gitCreatePrHandler } from "./git-create-pr.route.js";
-import { gitGithubStatusHandler } from "./git-github-status.route.js";
-import { gitUnifiedStatusHandler } from "./git-unified-status.route.js";
-import { gitCreateRepoHandler } from "./git-create-repo.route.js";
-import { gitPrStatusHandler } from "./git-pr-status.route.js";
-import { gitCreateBranchHandler } from "./git-create-branch.route.js";
-import { gitSyncBranchHandler } from "./git-sync-branch.route.js";
-export function createGitRoutes(metadataManager) {
-    const router = new Hono();
-    // GET /api/git/username - returns the git user.name from local git config
-    router.get("/username", async (c) => {
-        return gitUsernameHandler(c);
-    });
-    // GET /api/git/unified-status/:threadId - returns combined git and GitHub status for a thread
-    // Add ?fresh=true to bypass cache and recompute
-    router.get("/unified-status/:threadId", async (c) => {
-        const db = await getDatabase();
-        return gitUnifiedStatusHandler(c, metadataManager, db);
-    });
-    // DELETE /api/git/unified-status/:threadId/cache - invalidates the cached status for a thread
-    router.delete("/unified-status/:threadId/cache", async (c) => {
-        const threadId = c.req.param("threadId");
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, threadId);
-        return c.json({ success: true });
-    });
-    // GET /api/git/status/:threadId - returns git status for a thread
-    router.get("/status/:threadId", async (c) => {
-        return gitStatusHandler(c, metadataManager);
-    });
-    // GET /api/git/diff/:threadId - returns git diff for a thread
-    router.get("/diff/:threadId", async (c) => {
-        return gitDiffHandler(c, metadataManager);
-    });
-    // POST /api/git/generate-commit-message/:threadId - generates AI commit message
-    router.post("/generate-commit-message/:threadId", async (c) => {
-        return gitGenerateCommitMessageHandler(c, metadataManager);
-    });
-    // POST /api/git/commit/:threadId - commits changes
-    router.post("/commit/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitCommitHandler(c, metadataManager);
-    });
-    // POST /api/git/push/:threadId - pushes commits
-    router.post("/push/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitPushHandler(c, metadataManager);
-    });
-    // POST /api/git/pull/:threadId - pulls from origin
-    router.post("/pull/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitPullHandler(c, metadataManager);
-    });
-    // POST /api/git/fetch/:threadId - fetches from origin
-    router.post("/fetch/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitFetchHandler(c, metadataManager);
-    });
-    // POST /api/git/generate-pr-info/:threadId - generates AI PR title and description
-    router.post("/generate-pr-info/:threadId", async (c) => {
-        return gitGeneratePrInfoHandler(c, metadataManager);
-    });
-    // GET /api/git/log/:threadId - fetches git commit history
-    router.get("/log/:threadId", async (c) => {
-        return gitLogHandler(c, metadataManager);
-    });
-    // POST /api/git/create-pr/:threadId - creates a pull request
-    router.post("/create-pr/:threadId", async (c) => {
-        return gitCreatePrHandler(c, metadataManager);
-    });
-    // GET /api/git/github-status/:threadId - checks if repo is on GitHub
-    router.get("/github-status/:threadId", async (c) => {
-        return gitGithubStatusHandler(c, metadataManager);
-    });
-    // POST /api/git/create-repo/:threadId - creates a GitHub repository
-    router.post("/create-repo/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitCreateRepoHandler(c, metadataManager);
-    });
-    // GET /api/git/pr-status/:threadId - checks PR status for current branch
-    router.get("/pr-status/:threadId", async (c) => {
-        return gitPrStatusHandler(c, metadataManager);
-    });
-    // POST /api/git/create-branch/:threadId - creates a new branch on current thread
-    router.post("/create-branch/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitCreateBranchHandler(c, metadataManager);
-    });
-    // POST /api/git/sync-branch/:threadId - syncs current branch with default branch using rebase
-    router.post("/sync-branch/:threadId", async (c) => {
-        const db = await getDatabase();
-        await invalidateGitStatusCache(db, c.req.param("threadId"));
-        return gitSyncBranchHandler(c, metadataManager);
-    });
-    return router;
-}
-//# sourceMappingURL=git.routes.js.map

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

@@ -1,82 +0,0 @@
-import { MetadataManager } from "../metadata/metadata.manager.js";
-import { type CatalogProvider } from "../models/models-catalog.js";
-import { type Model, type Api } from "@mariozechner/pi-ai";
-export declare const DEFAULT_MODEL_MAP: Record<string, string>;
-export declare function resolveModelForGit(providerName: string, modelId: string, apiUrl?: string): Model<Api>;
-export declare function resolveProviderAndKey(metadataProviderKeys: Record<string, string>, preferredProvider?: string): Promise<{
-    provider: CatalogProvider;
-    apiKey: string;
-} | null>;
-export declare function generatePRInfoWithAI(commitLog: string, detailedCommits: string, diff: string, currentBranch: string, baseBranch: string, metadataManager: MetadataManager, model?: string, provider?: string): Promise<{
-    title: string;
-    description: string;
-}>;
-export declare function generateCommitMessageWithAI(diff: string, metadataManager: MetadataManager, model?: string, provider?: string): Promise<string>;
-/** Resolve thread path: if absolute use as-is (normalized), else resolve against data dir. */
-export declare function resolveThreadPath(repoPath: string): string;
-/** Get git repo root for a path (directory or subdir of repo). Throws if not a git repo. */
-export declare function getGitRoot(cwd: string): Promise<string>;
-/** Get current git branch */
-export declare function getCurrentBranch(gitRoot: string): Promise<string>;
-/** Get git diff for staged and unstaged changes */
-export declare function getGitDiff(gitRoot: string): Promise<string>;
-/** Get diff for untracked files */
-export declare function getUntrackedFilesDiff(gitRoot: string): Promise<string>;
-/** Get git status output */
-export declare function getGitStatus(gitRoot: string): Promise<string>;
-/** Check if there are unpushed commits */
-export declare function hasUnpushedCommits(gitRoot: string, currentBranch: string): Promise<boolean>;
-/** Check if current branch has commits not yet in the default branch (pushed or not) */
-export declare function hasCommitsAheadOfDefault(gitRoot: string, defaultBranch: string): Promise<boolean>;
-/** Get remote origin URL */
-export declare function getRemoteOrigin(gitRoot: string): Promise<string>;
-/** Get the hash of the origin branch head */
-export declare function getOriginBranchHash(gitRoot: string, branch: string): Promise<string | null>;
-/** Get the merge-base hash between origin branch and current branch */
-export declare function getMergeBaseHash(gitRoot: string, originBranch: string, currentBranch: string): Promise<string | null>;
-/** Check if current branch is behind origin branch */
-export declare function isBranchBehind(gitRoot: string, branch: string): Promise<boolean>;
-/** Get detailed git sync status (Behind, Ahead, Diverged, Up to date) */
-export declare function getGitSyncStatus(gitRoot: string, branch: string): Promise<"Behind" | "Ahead" | "Diverged" | "Up to date">;
-/** Check if remote branch exists */
-export declare function hasRemoteBranch(gitRoot: string, branch: string): Promise<boolean>;
-/** Get default branch from origin/HEAD */
-export declare function getDefaultBranch(gitRoot: string): Promise<string | null>;
-/** Find default branch by checking common candidates */
-export declare function findDefaultBranch(gitRoot: string): Promise<string | null>;
-/** Get commit log between branches */
-export declare function getCommitLog(gitRoot: string, baseBranch: string, currentBranch: string): Promise<string>;
-/** Get detailed commit information */
-export declare function getDetailedCommits(gitRoot: string, baseBranch: string, currentBranch: string): Promise<string>;
-/** Get git log with limit */
-export declare function getGitLog(gitRoot: string, limit: number): Promise<Array<{
-    hash: string;
-    message: string;
-    author: string;
-    date: string;
-}>>;
-/** Stage all changes */
-export declare function stageAllChanges(gitRoot: string): Promise<void>;
-/** Commit changes */
-export declare function commitChanges(gitRoot: string, message: string): Promise<void>;
-/** Push changes to origin */
-export declare function pushToOrigin(gitRoot: string, currentBranch: string): Promise<void>;
-/** Fetch from origin */
-export declare function fetchFromOrigin(gitRoot: string): Promise<void>;
-/** Pull from origin */
-export declare function pullFromOrigin(gitRoot: string): Promise<void>;
-/** Stash changes */
-export declare function stashChanges(gitRoot: string): Promise<void>;
-/** Pop stashed changes */
-export declare function popStashedChanges(gitRoot: string): Promise<void>;
-/** Create GitHub repository using gh CLI */
-export declare function createGitHubRepo(gitRoot: string, repoName?: string, description?: string, isPrivate?: boolean): Promise<string>;
-/** Create pull request using gh CLI */
-export declare function createPullRequest(gitRoot: string, title?: string, description?: string): Promise<string>;
-/** Check if there's an existing PR for the current branch */
-export declare function getPullRequestStatus(gitRoot: string): Promise<{
-    exists: boolean;
-    url?: string;
-    state?: string;
-}>;
-//# sourceMappingURL=git.utils.d.ts.map