@samaksh/git-worker 0.0.0-stage → 0.2.0

package/dist/stages/report.js

@@ -0,0 +1,103 @@
+import { ok } from "../core/types.js";
+import { sectionHeader, statusLine, divider, renderBranchTable } from "../utils/ui.js";
+import { saveJson, saveMarkdown } from "../services/report/index.js";
+import chalk from "chalk";
+export const reportResultsStage = async (context, deps) => {
+    sectionHeader("Run Report");
+    const results = context.results ?? [];
+    const pushResults = context.pushResults ?? [];
+    // Per-branch status
+    renderBranchTable(results.map((r) => ({
+        name: r.branch.name,
+        status: r.status,
+        detail: r.commitSha
+            ? `commit ${r.commitSha.slice(0, 8)}`
+            : r.reason ?? "",
+    })));
+    // Push results (only non-skipped)
+    const activePushResults = pushResults.filter((p) => p.status !== "skipped");
+    if (activePushResults.length > 0) {
+        console.log("");
+        console.log(chalk.gray("  Push:"));
+        for (const pr of activePushResults) {
+            if (pr.status === "pushed") {
+                statusLine("ok", pr.branch.name, "pushed");
+            }
+            else {
+                statusLine("fail", pr.branch.name, pr.reason ?? "push failed");
+            }
+        }
+    }
+    // Aggregate summary
+    const committed = results.filter((r) => r.status === "committed").length;
+    const failed = results.filter((r) => r.status === "failed").length;
+    const rejected = results.filter((r) => r.status === "rejected").length;
+    const unchanged = results.filter((r) => r.status === "unchanged").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const pushed = pushResults.filter((p) => p.status === "pushed").length;
+    divider();
+    console.log("");
+    console.log(`  ${chalk.bold("Total:")}  ` +
+        [
+            committed > 0 ? chalk.green(`${committed} committed`) : "",
+            pushed > 0 ? chalk.green(`${pushed} pushed`) : "",
+            failed > 0 ? chalk.red(`${failed} failed`) : "",
+            rejected > 0 ? chalk.yellow(`${rejected} rejected`) : "",
+            unchanged > 0 ? chalk.gray(`${unchanged} unchanged`) : "",
+            skipped > 0 ? chalk.gray(`${skipped} skipped`) : "",
+        ].filter(Boolean).join("  "));
+    console.log("");
+    // Save template state if any commits succeeded
+    const rawTemplate = context.activeTemplate?.raw ?? context.template?.raw;
+    if (committed > 0 && context.project && context.target && rawTemplate) {
+        const summary = {
+            committed,
+            failed,
+            skipped: skipped + rejected,
+            total: results.length,
+        };
+        const saveResult = await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate, summary);
+        if (saveResult.ok) {
+            statusLine("ok", `Template saved for '${context.target.path}' (ready for next run)`);
+        }
+        else {
+            statusLine("warn", "Could not save template state", saveResult.error.message);
+        }
+    }
+    else if (committed === 0 && context.project && context.target && rawTemplate) {
+        // No commits but everything matches — offer to save reviewed template
+        const { clack } = await import("../utils/ui.js");
+        if (!context.input.ci) {
+            const save = await clack.confirm({
+                message: "No changes committed. Save current template for next run?",
+                initialValue: true,
+            });
+            if (!clack.isCancel(save) && save) {
+                await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate);
+                statusLine("ok", `Template saved for '${context.target.path}'`);
+            }
+        }
+    }
+    // Write JSON/Markdown reports if configured
+    if (context.project && (deps.config.report.writeJson || deps.config.report.writeMarkdown)) {
+        const report = {
+            runId: context.runId,
+            targetPath: context.target?.path ?? "",
+            startedAt: new Date().toISOString(),
+            completedAt: new Date().toISOString(),
+            plans: context.plans ?? [],
+            results,
+            pushResults,
+        };
+        await saveJson(context.project.reportsDir, report, deps.config).catch(() => { });
+        await saveMarkdown(context.project.reportsDir, report, deps.config).catch(() => { });
+        if (deps.config.report.writeJson) {
+            statusLine("info", `JSON report: ${context.project.reportsDir}/${context.runId}.json`);
+        }
+        if (deps.config.report.writeMarkdown) {
+            statusLine("info", `Markdown report: ${context.project.reportsDir}/${context.runId}.md`);
+        }
+    }
+    console.log("");
+    return ok(context);
+};

package/dist/stages/resolve-project.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const resolveProjectStage: Stage<RunContext, AppDeps>;

package/dist/stages/resolve-project.js

@@ -0,0 +1,294 @@
+import { ok, err } from "../core/types.js";
+import { clack, banner, statusLine, sectionHeader, sym } from "../utils/ui.js";
+import { inputCancelledError } from "../core/errors.js";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import { listCachedProjects } from "../services/workspace/cache.js";
+import { getWorkspaceRoot } from "../services/workspace/manager.js";
+async function promptCachedRepo(cachedProjects, root) {
+    if (cachedProjects.length === 0) {
+        clack.log.info(`No cached repositories found in ${root}/projects yet.`);
+        return "__BACK__";
+    }
+    console.log("");
+    console.log(chalk.bold(`  ${"Name".padEnd(20)} ${"Remote URL / Path".padEnd(46)} Cached Date`));
+    console.log(chalk.gray("  " + "─".repeat(80)));
+    for (const p of cachedProjects) {
+        const name = chalk.cyan(p.name.slice(0, 18).padEnd(20));
+        const target = (p.remoteUrl || p.sourceRepoPath || "(unknown)").slice(0, 44).padEnd(46);
+        const date = p.createdAt ? p.createdAt.slice(0, 10) : "unknown";
+        console.log(`  ${name} ${chalk.white(target)} ${chalk.gray(date)}`);
+    }
+    console.log(chalk.gray("  " + "─".repeat(80)));
+    console.log("");
+    const selected = await clack.select({
+        message: "Select a cached repository to target:",
+        options: [
+            ...cachedProjects.map((p) => ({
+                value: p.remoteUrl || p.sourceRepoPath || p.id,
+                label: `${sym.branch} ${chalk.bold(p.name)}`,
+                hint: `${p.remoteUrl || p.sourceRepoPath}`,
+            })),
+            {
+                value: "__BACK__",
+                label: "← Back to repository menu",
+            },
+        ],
+    });
+    if (clack.isCancel(selected)) {
+        return null;
+    }
+    return selected;
+}
+export const resolveProjectStage = async (context, deps) => {
+    banner();
+    let targetRepo = context.input.repo;
+    // If repo was not supplied via CLI argument (-r / --repo)
+    if (!targetRepo) {
+        const isCi = context.input.ci ?? false;
+        const cwd = process.cwd();
+        // Check if the current working directory is a git repository
+        const localCheck = await deps.services.workspace.checkLocalRepo(cwd, context.input.remote || deps.config.git.remote);
+        if (isCi) {
+            // In CI mode, cannot prompt: use cwd if git repo, otherwise fail
+            if (localCheck.isRepo) {
+                targetRepo = cwd;
+            }
+            else {
+                clack.log.error(`Current directory '${cwd}' is not a Git repository. Pass --repo <url-or-path> in CI mode.`);
+                return err(inputCancelledError("Not a git repository in CI mode without --repo flag"));
+            }
+        }
+        else {
+            // Interactive TUI mode
+            sectionHeader("Target Repository");
+            const root = getWorkspaceRoot(deps.config);
+            while (!targetRepo) {
+                const cachedProjects = await listCachedProjects(deps.config);
+                // If user specifically requested --cached via CLI
+                if (context.input.cached) {
+                    if (cachedProjects.length === 0) {
+                        clack.log.warn(`No cached repositories found in ${root}/projects yet.`);
+                        context.input.cached = false;
+                        continue;
+                    }
+                    const selected = await promptCachedRepo(cachedProjects, root);
+                    if (selected === null) {
+                        return err(inputCancelledError("Repository selection cancelled"));
+                    }
+                    if (selected === "__BACK__") {
+                        context.input.cached = false;
+                        continue;
+                    }
+                    targetRepo = selected;
+                    break;
+                }
+                if (localCheck.isRepo) {
+                    // Current directory IS a git repo
+                    const remoteInfo = localCheck.remoteUrl
+                        ? ` (remote: ${localCheck.remoteUrl})`
+                        : " (local-only)";
+                    statusLine("ok", "Detected Git repository in current directory", `${cwd}${remoteInfo}`);
+                    console.log("");
+                    const choice = await clack.select({
+                        message: "What repository would you like to target?",
+                        options: [
+                            {
+                                value: "current",
+                                label: "Use current repository",
+                                hint: localCheck.remoteUrl || cwd,
+                            },
+                            {
+                                value: "cached",
+                                label: `📦 Select from cached repositories (${cachedProjects.length} available)`,
+                                hint: "list already cloned repositories (name, remote URL)",
+                            },
+                            {
+                                value: "remote",
+                                label: "Clone a remote repository URL",
+                                hint: "https://... or git@...",
+                            },
+                            {
+                                value: "local-path",
+                                label: "Specify a different local repository path",
+                            },
+                        ],
+                    });
+                    if (clack.isCancel(choice)) {
+                        return err(inputCancelledError("Repository selection cancelled"));
+                    }
+                    if (choice === "current") {
+                        targetRepo = cwd;
+                        break;
+                    }
+                    if (choice === "cached") {
+                        const selected = await promptCachedRepo(cachedProjects, root);
+                        if (selected === null) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        if (selected === "__BACK__") {
+                            continue;
+                        }
+                        targetRepo = selected;
+                        break;
+                    }
+                    if (choice === "remote") {
+                        const remoteUrlInput = await clack.text({
+                            message: "Remote repository URL:",
+                            placeholder: "https://github.com/org/repo.git or git@github.com:org/repo.git",
+                            validate: (v) => {
+                                if (!v || v.trim() === "")
+                                    return "Repository URL cannot be empty";
+                                const trimmed = v.trim();
+                                const isUrl = trimmed.startsWith("http://") ||
+                                    trimmed.startsWith("https://") ||
+                                    trimmed.startsWith("git@") ||
+                                    trimmed.startsWith("ssh://") ||
+                                    trimmed.startsWith("git://");
+                                if (!isUrl) {
+                                    return "Please enter a valid remote URL (e.g. https://github.com/... or git@github.com:...)";
+                                }
+                            },
+                        });
+                        if (clack.isCancel(remoteUrlInput)) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        targetRepo = remoteUrlInput.trim();
+                        break;
+                    }
+                    if (choice === "local-path") {
+                        const pathInput = await clack.text({
+                            message: "Path to local repository:",
+                            placeholder: "/path/to/repo or ../other-repo",
+                            validate: (v) => {
+                                if (!v || v.trim() === "")
+                                    return "Path cannot be empty";
+                                if (!existsSync(resolve(v.trim())))
+                                    return `Path does not exist: ${v.trim()}`;
+                            },
+                        });
+                        if (clack.isCancel(pathInput)) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        targetRepo = pathInput.trim();
+                        break;
+                    }
+                }
+                else {
+                    // Current directory IS NOT a git repo
+                    statusLine("info", "Current directory is not a Git repository", cwd);
+                    console.log("");
+                    const choice = await clack.select({
+                        message: "How would you like to target a repository?",
+                        options: [
+                            ...(cachedProjects.length > 0
+                                ? [
+                                    {
+                                        value: "cached",
+                                        label: `📦 Select from cached repositories (${cachedProjects.length} available)`,
+                                        hint: "list already cloned repositories (name, remote URL)",
+                                    },
+                                ]
+                                : [
+                                    {
+                                        value: "cached",
+                                        label: "📦 Cached repositories (none yet)",
+                                        hint: "view already cloned repositories in ~/.git-worker",
+                                    },
+                                ]),
+                            {
+                                value: "remote",
+                                label: "Clone a remote repository URL",
+                                hint: "recommended — https://... or git@...",
+                            },
+                            {
+                                value: "local-path",
+                                label: "Specify path to a local Git repository",
+                            },
+                        ],
+                    });
+                    if (clack.isCancel(choice)) {
+                        return err(inputCancelledError("Repository selection cancelled"));
+                    }
+                    if (choice === "cached") {
+                        const selected = await promptCachedRepo(cachedProjects, root);
+                        if (selected === null) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        if (selected === "__BACK__") {
+                            continue;
+                        }
+                        targetRepo = selected;
+                        break;
+                    }
+                    if (choice === "remote") {
+                        const remoteUrlInput = await clack.text({
+                            message: "Remote repository URL:",
+                            placeholder: "https://github.com/org/repo.git or git@github.com:org/repo.git",
+                            validate: (v) => {
+                                if (!v || v.trim() === "")
+                                    return "Repository URL cannot be empty";
+                                const trimmed = v.trim();
+                                const isUrl = trimmed.startsWith("http://") ||
+                                    trimmed.startsWith("https://") ||
+                                    trimmed.startsWith("git@") ||
+                                    trimmed.startsWith("ssh://") ||
+                                    trimmed.startsWith("git://");
+                                if (!isUrl) {
+                                    return "Please enter a valid remote URL (e.g. https://github.com/... or git@github.com:...)";
+                                }
+                            },
+                        });
+                        if (clack.isCancel(remoteUrlInput)) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        targetRepo = remoteUrlInput.trim();
+                        break;
+                    }
+                    if (choice === "local-path") {
+                        const pathInput = await clack.text({
+                            message: "Path to local repository:",
+                            placeholder: "/path/to/repo or ../other-repo",
+                            validate: (v) => {
+                                if (!v || v.trim() === "")
+                                    return "Path cannot be empty";
+                                if (!existsSync(resolve(v.trim())))
+                                    return `Path does not exist: ${v.trim()}`;
+                            },
+                        });
+                        if (clack.isCancel(pathInput)) {
+                            return err(inputCancelledError("Repository selection cancelled"));
+                        }
+                        targetRepo = pathInput.trim();
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Now resolve the project workspace
+    const s = clack.spinner();
+    s.start("Resolving project workspace…");
+    const result = await deps.services.workspace.resolveProject(targetRepo, context.input.remote, deps.config);
+    if (!result.ok) {
+        s.stop(chalk.red("Project resolution failed"));
+        clack.log.error(result.error.message);
+        return result;
+    }
+    s.stop(chalk.green("Project workspace ready"));
+    if (result.value.isCached) {
+        statusLine("info", "Using cached repository clone (already downloaded)", result.value.remoteUrl || result.value.managedRepoPath);
+    }
+    else {
+        statusLine("info", `Managed workspace: ${result.value.managedRepoPath}`);
+    }
+    return ok({
+        ...context,
+        input: {
+            ...context.input,
+            repo: targetRepo,
+        },
+        project: result.value,
+    });
+};

package/dist/stages/review.d.ts

@@ -0,0 +1,3 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+export declare const reviewChangesStage: Stage<RunContext, AppDeps>;

package/dist/stages/review.js

@@ -0,0 +1,197 @@
+import { ok, err } from "../core/types.js";
+import { workspaceError, inputCancelledError } from "../core/errors.js";
+import { writeSnapshots } from "../services/review/index.js";
+import { clack, sectionHeader, statusLine, divider, renderDiff, renderBranchTable, sym } from "../utils/ui.js";
+import chalk from "chalk";
+export const reviewChangesStage = async (context, deps) => {
+    if (!context.plans || !context.project) {
+        return err(workspaceError("No plans to review"));
+    }
+    const isCi = context.input.ci ?? false;
+    const autoApprove = context.input.autoApprove || deps.config.review.autoApprove;
+    sectionHeader("Review Changes");
+    // Show summary table first
+    renderBranchTable(context.plans.map((p) => ({
+        name: p.branch.name,
+        status: p.status,
+        detail: p.status === "changed"
+            ? `${p.updatedKeys.length} updated, ${p.addedKeys.length} added`
+            : p.status === "error"
+                ? p.reason ?? "error"
+                : "no changes",
+    })));
+    const changedPlans = context.plans.filter((p) => p.status === "changed");
+    const approvals = [];
+    // Auto-approve unchanged and errors
+    for (const plan of context.plans) {
+        if (plan.status !== "changed") {
+            approvals.push({
+                branchName: plan.branch.name,
+                approved: false,
+                planHash: plan.planHash,
+            });
+        }
+    }
+    if (changedPlans.length === 0) {
+        statusLine("info", "No changed branches to review");
+        return ok({ ...context, approvals });
+    }
+    // Auto-approve all
+    if (autoApprove) {
+        for (const plan of changedPlans) {
+            approvals.push({
+                branchName: plan.branch.name,
+                approved: true,
+                planHash: plan.planHash,
+            });
+        }
+        statusLine("ok", `Auto-approved ${changedPlans.length} branch(es)`);
+        return ok({ ...context, approvals });
+    }
+    if (isCi) {
+        // CI without auto-approve: reject all
+        for (const plan of changedPlans) {
+            approvals.push({
+                branchName: plan.branch.name,
+                approved: false,
+                planHash: plan.planHash,
+            });
+        }
+        statusLine("warn", "CI mode — all branches rejected (use --auto-approve to commit in CI)");
+        return ok({ ...context, approvals });
+    }
+    // Interactive review
+    console.log("");
+    // Ask if user wants batch action or per-branch review
+    const batchChoice = await clack.select({
+        message: `Review ${changedPlans.length} changed branch(es):`,
+        options: [
+            { value: "per-branch", label: "Review each branch individually", hint: "recommended" },
+            { value: "approve-all", label: `Approve all ${changedPlans.length} branches` },
+            { value: "reject-all", label: "Reject all" },
+        ],
+    });
+    if (clack.isCancel(batchChoice)) {
+        return err(inputCancelledError("Review cancelled"));
+    }
+    if (batchChoice === "approve-all") {
+        for (const plan of changedPlans) {
+            approvals.push({ branchName: plan.branch.name, approved: true, planHash: plan.planHash });
+        }
+        statusLine("ok", `Approved all ${changedPlans.length} branch(es)`);
+        return ok({ ...context, approvals });
+    }
+    if (batchChoice === "reject-all") {
+        for (const plan of changedPlans) {
+            approvals.push({ branchName: plan.branch.name, approved: false, planHash: plan.planHash });
+        }
+        statusLine("warn", "All branches rejected");
+        return ok({ ...context, approvals });
+    }
+    // Per-branch review
+    for (const plan of changedPlans) {
+        console.log("");
+        divider();
+        console.log(`  ${sym.branch} ${chalk.bold.cyan(plan.branch.name)}  ${chalk.gray(plan.baseCommitSha.slice(0, 8))}`);
+        console.log(`  ${chalk.gray(plan.path)}`);
+        console.log("");
+        // Show inline diff
+        if (deps.config.report.warnOnSecrets) {
+            console.log(chalk.yellow("  ⚠  Diff may contain secret values — treat with care"));
+            console.log("");
+        }
+        renderDiff(plan.diff, false);
+        // Write snapshots for external diff tool
+        const snapResult = await writeSnapshots(context.project.stagingDir, context.runId, plan);
+        let openDiff = false;
+        if (snapResult.ok) {
+            const choice = await clack.select({
+                message: "Action:",
+                options: [
+                    { value: "approve", label: `${chalk.green("✓")} Approve`, hint: "commit this branch" },
+                    { value: "reject", label: `${chalk.red("✗")} Reject`, hint: "skip this branch" },
+                    { value: "diff", label: `${chalk.cyan("⊞")} Open in diff viewer`, hint: deps.config.editor.name },
+                ],
+            });
+            if (clack.isCancel(choice)) {
+                return err(inputCancelledError("Review cancelled"));
+            }
+            if (choice === "diff") {
+                const { beforePath, afterPath } = snapResult.value;
+                const diffResult = await deps.services.editor.openForDiff(beforePath, afterPath, deps.config);
+                if (!diffResult.ok) {
+                    clack.log.warn(diffResult.error.message);
+                }
+                // Ask again after opening diff
+                const afterDiff = await clack.select({
+                    message: "After reviewing the diff:",
+                    options: [
+                        { value: "approve", label: `${chalk.green("✓")} Approve` },
+                        { value: "reject", label: `${chalk.red("✗")} Reject` },
+                    ],
+                });
+                if (clack.isCancel(afterDiff)) {
+                    return err(inputCancelledError("Review cancelled"));
+                }
+                approvals.push({
+                    branchName: plan.branch.name,
+                    approved: afterDiff === "approve",
+                    planHash: plan.planHash,
+                });
+            }
+            else {
+                approvals.push({
+                    branchName: plan.branch.name,
+                    approved: choice === "approve",
+                    planHash: plan.planHash,
+                });
+            }
+        }
+        else {
+            // No snapshots — just approve/reject
+            const choice = await clack.select({
+                message: "Action:",
+                options: [
+                    { value: "approve", label: `${chalk.green("✓")} Approve` },
+                    { value: "reject", label: `${chalk.red("✗")} Reject` },
+                ],
+            });
+            if (clack.isCancel(choice)) {
+                return err(inputCancelledError("Review cancelled"));
+            }
+            approvals.push({
+                branchName: plan.branch.name,
+                approved: choice === "approve",
+                planHash: plan.planHash,
+            });
+        }
+    }
+    divider();
+    const approved = approvals.filter((a) => a.approved).length;
+    const rejected = approvals.filter((a) => !a.approved && context.plans.find((p) => p.branch.name === a.branchName)?.status === "changed").length;
+    statusLine("ok", `Review complete — ${approved} approved, ${rejected} rejected`);
+    // Confirm before destructive apply
+    if (approved > 0) {
+        console.log("");
+        console.log(chalk.bold("  Summary of approved changes:"));
+        for (const plan of changedPlans) {
+            const a = approvals.find((ap) => ap.branchName === plan.branch.name);
+            if (a?.approved) {
+                const detail = [
+                    plan.updatedKeys.length > 0 ? `update: ${plan.updatedKeys.join(", ")}` : "",
+                    plan.addedKeys.length > 0 ? `add: ${plan.addedKeys.join(", ")}` : "",
+                ].filter(Boolean).join(" | ");
+                statusLine("ok", plan.branch.name, detail);
+            }
+        }
+        console.log("");
+        const confirm = await clack.confirm({
+            message: `Proceed to commit ${approved} branch(es)?`,
+            initialValue: true,
+        });
+        if (clack.isCancel(confirm) || !confirm) {
+            return err(inputCancelledError("Commit aborted by user"));
+        }
+    }
+    return ok({ ...context, approvals });
+};

package/dist/stages/select.d.ts

@@ -0,0 +1,13 @@
+import { Stage } from "../core/pipeline.js";
+import { RunContext, AppDeps } from "../core/types.js";
+/**
+ * Matches a branch name against a pattern.
+ * Supports:
+ * - Regex: /uat.*\/, /^release\//, /pattern/i
+ * - Glob: uat/*, *orders, uat*
+ * - Exact name: main, develop
+ * - Trailing slash prefix: uat/
+ * - Substring fallback: orders
+ */
+export declare function matchesBranchPattern(name: string, pattern: string): boolean;
+export declare const selectTargetsStage: Stage<RunContext, AppDeps>;