@samaksh/git-worker 0.1.0 → 0.2.1

package/src/stages/resolve-project.ts

@@ -1,341 +0,0 @@
-import { Stage } from "../core/pipeline.js";
-import { RunContext, AppDeps, 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, CachedProjectInfo } from "../services/workspace/cache.js";
-import { getWorkspaceRoot } from "../services/workspace/manager.js";
-
-async function promptCachedRepo(
-  cachedProjects: CachedProjectInfo[],
-  root: string
-): Promise<string | "__BACK__" | null> {
-  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<string>({
-    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: Stage<RunContext, AppDeps> = 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<string>({
-            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 as string).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 as string).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<string>({
-            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 as string).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 as string).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/src/stages/review.ts

@@ -1,228 +0,0 @@
-import { Stage } from "../core/pipeline.js";
-import { RunContext, AppDeps, Approval, ok, err } from "../core/types.js";
-import { workspaceError, inputCancelledError } from "../core/errors.js";
-import { writeSnapshots, parseDiffLines } from "../services/review/index.js";
-import { clack, sectionHeader, statusLine, divider, renderDiff, renderBranchTable, sym } from "../utils/ui.js";
-import chalk from "chalk";
-
-export const reviewChangesStage: Stage<RunContext, AppDeps> = 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: Approval[] = [];
-
-  // 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<string>({
-    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<string>({
-        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<string>({
-          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<string>({
-        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 });
-};