@samaksh/git-worker 0.0.0-stage → 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { run } from "../app.js";
+import { handleCacheList, handleCacheClean } from "./commands.js";
+import chalk from "chalk";
+
+const program = new Command();
+
+program
+  .name("git-worker")
+  .description("Safe, composable CLI/TUI for applying reviewed file changes across many Git branches")
+  .version("0.1.0")
+  .option("-r, --repo <path>", "Repository path or remote URL (default: current directory)")
+  .option("-c, --cached", "Select from previously cloned and cached repositories")
+  .option("-b, --branch <pattern>", "Branch pattern — glob (uat/*) or regex (/uat.*/)")
+  .option("-i, --invert-branch", "Invert the branch selection pattern")
+  .option("-f, --file <path>", "Target file path inside the repository (e.g. .env)")
+  .option("-e, --editor <name>", "Editor to use: code (VS Code) or vim")
+  .option("-m, --commit-msg <message>", "Commit message")
+  .option("-p, --push <policy>", "Push policy: prompt (default) | always | never")
+  .option("--remote <name>", "Git remote name (default: origin)")
+  .option("--auto-approve", "Auto-approve all changes (skip interactive review)")
+  .option("--ci", "CI mode: non-interactive, fail on missing dynamic values")
+  .action(async (opts) => {
+    // Validate push policy
+    if (opts.push && !["prompt", "always", "never"].includes(opts.push)) {
+      console.error(chalk.red(`  ✗ Invalid push policy '${opts.push}'. Must be: prompt | always | never`));
+      process.exit(1);
+    }
+
+    // Validate incompatible combinations
+    if (opts.ci && opts.push === "prompt") {
+      console.error(chalk.yellow(`  ⚠ Warning: --ci with --push prompt will not push (no interactive prompt in CI). Use --push always or --push never.`));
+    }
+
+    try {
+      const result = await run({
+        repo: opts.repo,
+        cached: opts.cached ?? false,
+        branch: opts.branch,
+        invertBranch: opts.invertBranch ?? false,
+        file: opts.file,
+        editor: opts.editor,
+        commitMsg: opts.commitMsg,
+        push: opts.push as "prompt" | "always" | "never" | undefined,
+        remote: opts.remote,
+        autoApprove: opts.autoApprove ?? false,
+        ci: opts.ci ?? false,
+      });
+
+      if (!result.ok) {
+        const { error } = result;
+        if (error.category === "INPUT_CANCELLED") {
+          console.log(chalk.gray("\n  Cancelled."));
+          process.exit(0);
+        }
+        console.error(chalk.red(`\n  ✗ [${error.category}] ${error.message}`));
+        process.exit(1);
+      }
+
+      process.exit(0);
+    } catch (e: any) {
+      console.error(chalk.red(`\n  ✗ Fatal: ${e.message}`));
+      if (process.env.DEBUG) {
+        console.error(e.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+// ── Cache management subcommands ──────────────────────────────────────────
+
+const cacheCmd = program
+  .command("cache")
+  .description("Manage git-worker's cached workspaces and repositories (~/.git-worker)");
+
+cacheCmd
+  .command("list")
+  .alias("ls")
+  .description("List all cached projects")
+  .action(async () => {
+    try {
+      await handleCacheList();
+      process.exit(0);
+    } catch (e: any) {
+      console.error(chalk.red(`  ✗ Error: ${e.message}`));
+      process.exit(1);
+    }
+  });
+
+cacheCmd
+  .command("clean [target]")
+  .alias("clear")
+  .description("Clean workspace cache (all or a specific project)")
+  .option("-a, --all", "Clean all cached projects")
+  .option("-y, --yes", "Skip confirmation prompt")
+  .action(async (target, opts) => {
+    try {
+      await handleCacheClean(target, opts);
+      process.exit(0);
+    } catch (e: any) {
+      console.error(chalk.red(`  ✗ Error: ${e.message}`));
+      process.exit(1);
+    }
+  });
+
+// Convenient top-level alias: git-worker clean [target] [-a]
+program
+  .command("clean [target]")
+  .description("Shorthand to clean cached workspace(s)")
+  .option("-a, --all", "Clean all cached projects")
+  .option("-y, --yes", "Skip confirmation prompt")
+  .action(async (target, opts) => {
+    try {
+      await handleCacheClean(target, opts);
+      process.exit(0);
+    } catch (e: any) {
+      console.error(chalk.red(`  ✗ Error: ${e.message}`));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/config/defaults.ts

@@ -0,0 +1,46 @@
+import { AppConfig } from "./schema.js";
+
+export const DEFAULT_CONFIG: AppConfig = {
+  git: {
+    remote: "origin",
+    fetchPrune: true,
+    cleanMode: "tracked-and-untracked",
+    pushPolicy: "prompt",
+    commitMessage: "chore: sync configuration",
+  },
+  workspace: {
+    root: ".git-worker",
+    lockTimeoutMs: 30000,
+  },
+  editor: {
+    name: "code",
+    editCommand: ["code", "--wait", "{file}"],
+    diffCommand: ["code", "--diff", "{before}", "{after}"],
+  },
+  template: {
+    placeholderOpen: "{",
+    placeholderClose: "}",
+    missingValuePolicy: "prompt-each-branch",
+    emptyValueIsPresent: true,
+    unmanagedKeyPolicy: "preserve",
+    removedTemplateKeyPolicy: "preserve",
+  },
+  review: {
+    autoApprove: false,
+    readOnlySnapshots: true,
+  },
+  execution: {
+    concurrency: 1,
+    stopOnBranchError: false,
+  },
+  report: {
+    writeJson: false,
+    writeMarkdown: false,
+    redactValues: true,
+    warnOnSecrets: true,
+  },
+  safety: {
+    rejectNoRemote: true,
+    saveOnPartialSuccess: true,
+  },
+};

package/src/config/load.ts

@@ -0,0 +1,70 @@
+import { AppConfig, AppConfigSchema } from "./schema.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import { CliInput } from "../core/types.js";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+
+function loadProjectConfig(repoPath: string): Partial<AppConfig> {
+  const candidates = [
+    join(resolve(repoPath), "git-worker.config.json"),
+    join(resolve(repoPath), ".git-worker.config.json"),
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      try {
+        const raw = readFileSync(candidate, "utf-8");
+        return JSON.parse(raw) as Partial<AppConfig>;
+      } catch {
+        // ignore malformed
+      }
+    }
+  }
+  return {};
+}
+
+function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>): T {
+  const result = { ...base };
+  for (const key of Object.keys(override) as (keyof T)[]) {
+    const overrideVal = override[key];
+    if (overrideVal === undefined) continue;
+    if (
+      typeof overrideVal === "object" &&
+      overrideVal !== null &&
+      !Array.isArray(overrideVal) &&
+      typeof result[key] === "object" &&
+      result[key] !== null
+    ) {
+      result[key] = deepMerge(result[key] as Record<string, unknown>, overrideVal as Record<string, unknown>) as T[keyof T];
+    } else {
+      result[key] = overrideVal as T[keyof T];
+    }
+  }
+  return result;
+}
+
+export function loadConfig(cliInput: CliInput): AppConfig {
+  // Load project config from repo directory
+  const repoPath = cliInput.repo || process.cwd();
+  const projectConfig = loadProjectConfig(repoPath);
+
+  // Merge: defaults < project config < CLI overrides
+  const cliOverrides: Partial<AppConfig> = {
+    git: {
+      ...DEFAULT_CONFIG.git,
+      ...(cliInput.push ? { pushPolicy: cliInput.push } : {}),
+      ...(cliInput.commitMsg ? { commitMessage: cliInput.commitMsg } : {}),
+      ...(cliInput.remote ? { remote: cliInput.remote } : {}),
+    },
+    editor: {
+      ...DEFAULT_CONFIG.editor,
+      ...(cliInput.editor ? { name: cliInput.editor } : {}),
+    },
+    review: {
+      ...DEFAULT_CONFIG.review,
+      ...(cliInput.autoApprove !== undefined ? { autoApprove: cliInput.autoApprove } : {}),
+    },
+  };
+
+  const merged = deepMerge(deepMerge(DEFAULT_CONFIG as Record<string, unknown>, projectConfig as Record<string, unknown>) as AppConfig, cliOverrides);
+  return Object.freeze(AppConfigSchema.parse(merged)) as AppConfig;
+}

package/src/config/schema.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+export const AppConfigSchema = z.object({
+  git: z.object({
+    remote: z.string().default("origin"),
+    fetchPrune: z.boolean().default(true),
+    cleanMode: z.enum(["tracked-and-untracked", "tracked-only"]).default("tracked-and-untracked"),
+    pushPolicy: z.enum(["prompt", "always", "never"]).default("prompt"),
+    commitMessage: z.string().default("chore: sync configuration"),
+  }),
+  workspace: z.object({
+    root: z.string().default(".git-worker"),
+    lockTimeoutMs: z.number().default(30000),
+  }),
+  editor: z.object({
+    name: z.string().default("code"),
+    editCommand: z.array(z.string()).default(["code", "--wait", "{file}"]),
+    diffCommand: z.array(z.string()).default(["code", "--diff", "{before}", "{after}"]),
+  }),
+  template: z.object({
+    placeholderOpen: z.string().default("{"),
+    placeholderClose: z.string().default("}"),
+    missingValuePolicy: z.enum(["prompt-each-branch"]).default("prompt-each-branch"),
+    emptyValueIsPresent: z.boolean().default(true),
+    unmanagedKeyPolicy: z.enum(["preserve"]).default("preserve"),
+    removedTemplateKeyPolicy: z.enum(["preserve"]).default("preserve"),
+  }),
+  review: z.object({
+    autoApprove: z.boolean().default(false),
+    readOnlySnapshots: z.boolean().default(true),
+  }),
+  execution: z.object({
+    concurrency: z.number().default(1),
+    stopOnBranchError: z.boolean().default(false),
+  }),
+  report: z.object({
+    writeJson: z.boolean().default(false),
+    writeMarkdown: z.boolean().default(false),
+    redactValues: z.boolean().default(true),
+    warnOnSecrets: z.boolean().default(true),
+  }),
+  safety: z.object({
+    rejectNoRemote: z.boolean().default(true),
+    saveOnPartialSuccess: z.boolean().default(true),
+  }),
+});
+
+export type AppConfig = z.infer<typeof AppConfigSchema>;

package/src/core/errors.ts

@@ -0,0 +1,45 @@
+import { AppError } from "./types.js";
+
+export function configError(msg: string, details?: unknown): AppError {
+  return new AppError("CONFIG", msg, details);
+}
+
+export function gitError(msg: string, details?: unknown): AppError {
+  return new AppError("GIT", msg, details);
+}
+
+export function editorError(msg: string, details?: unknown): AppError {
+  return new AppError("EDITOR", msg, details);
+}
+
+export function templateError(msg: string, details?: unknown): AppError {
+  return new AppError("TEMPLATE", msg, details);
+}
+
+export function eligibilityError(msg: string, details?: unknown): AppError {
+  return new AppError("ELIGIBILITY", msg, details);
+}
+
+export function inputCancelledError(msg: string, details?: unknown): AppError {
+  return new AppError("INPUT_CANCELLED", msg, details);
+}
+
+export function stalePlanError(msg: string, details?: unknown): AppError {
+  return new AppError("STALE_PLAN", msg, details);
+}
+
+export function applyError(msg: string, details?: unknown): AppError {
+  return new AppError("APPLY", msg, details);
+}
+
+export function pushError(msg: string, details?: unknown): AppError {
+  return new AppError("PUSH", msg, details);
+}
+
+export function workspaceError(msg: string, details?: unknown): AppError {
+  return new AppError("WORKSPACE", msg, details);
+}
+
+export function validationError(msg: string, details?: unknown): AppError {
+  return new AppError("VALIDATION", msg, details);
+}

package/src/core/pipeline.ts

@@ -0,0 +1,17 @@
+import { Result, AppError, ok } from "./types.js";
+
+export type Stage<C, D> = (context: C, deps: D) => Promise<Result<C, AppError>>;
+
+export function pipeline<C, D>(...stages: Stage<C, D>[]): Stage<C, D> {
+  return async (initial: C, deps: D): Promise<Result<C, AppError>> => {
+    let current = initial;
+    for (const stage of stages) {
+      const result = await stage(current, deps);
+      if (!result.ok) {
+        return result;
+      }
+      current = result.value;
+    }
+    return ok(current);
+  };
+}

package/src/core/types.ts

@@ -0,0 +1,188 @@
+export type Result<T, E = AppError> =
+  | { ok: true; value: T }
+  | { ok: false; error: E };
+
+export type AppErrorCategory =
+  | "CONFIG"
+  | "GIT"
+  | "EDITOR"
+  | "TEMPLATE"
+  | "ELIGIBILITY"
+  | "INPUT_CANCELLED"
+  | "STALE_PLAN"
+  | "APPLY"
+  | "PUSH"
+  | "WORKSPACE"
+  | "VALIDATION";
+
+export class AppError extends Error {
+  category: AppErrorCategory;
+  details?: unknown;
+
+  constructor(category: AppErrorCategory, message: string, details?: unknown) {
+    super(message);
+    this.name = "AppError";
+    this.category = category;
+    this.details = details;
+  }
+}
+
+export function ok<T>(value: T): Result<T> {
+  return { ok: true, value };
+}
+
+export function err<E extends AppError>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+export type BranchRef = {
+  name: string;
+  remote?: string;
+  sha: string;
+  isRemote: boolean;
+};
+
+export type TargetFile = {
+  path: string;
+};
+
+export type TemplateEngineType = "env-reconcile" | "source-of-truth";
+
+export type TargetTemplate = {
+  path: string;
+  engine: TemplateEngineType;
+  raw: string;
+  parsedEnv?: TemplateDocument;
+  variables?: Array<{ name: string; fallback?: string; raw: string }>;
+  isNewFile?: boolean;
+};
+
+export type ManagedProject = {
+  id: string;
+  sourceRepoPath: string;
+  remoteUrl?: string;
+  managedRepoPath: string;
+  stagingDir: string;
+  stateDir: string;
+  reportsDir: string;
+  markerPath: string;
+  isCached?: boolean;
+};
+
+export type TemplateDocument = {
+  raw: string;
+  assignments: TemplateAssignment[];
+  placeholders: string[];
+};
+
+export type TemplateAssignment = {
+  key: string;
+  value: string;
+  isStatic: boolean;
+  isPlaceholder: boolean;
+  placeholderName?: string;
+  originalLine: string;
+};
+
+export type EnvEntry = {
+  key: string;
+  value: string;
+  lineIndex: number;
+  originalLine: string;
+  hasExport: boolean;
+};
+
+export type BranchContent = {
+  branch: BranchRef;
+  exists: boolean;
+  content?: string;
+  error?: string;
+};
+
+export type MissingValueRequest = {
+  branch: BranchRef;
+  key: string;
+};
+
+export type BranchPlan = {
+  branch: BranchRef;
+  baseCommitSha: string;
+  path: string;
+  beforeContent: string;
+  beforeContentHash: string;
+  afterContent: string;
+  afterContentHash: string;
+  diff: string;
+  planHash: string;
+  status: "changed" | "unchanged" | "error";
+  reason?: string;
+  addedKeys: string[];
+  updatedKeys: string[];
+  missingVars?: string[];
+  isNewFile?: boolean;
+};
+
+export type Approval = {
+  branchName: string;
+  approved: boolean;
+  planHash: string;
+};
+
+export type BranchResult = {
+  branch: BranchRef;
+  status: "skipped" | "rejected" | "unchanged" | "committed" | "failed";
+  commitSha?: string;
+  reason?: string;
+};
+
+export type PushResult = {
+  branch: BranchRef;
+  status: "pushed" | "skipped" | "failed";
+  reason?: string;
+};
+
+export type CliInput = {
+  repo?: string;
+  cached?: boolean;
+  branch?: string;
+  invertBranch?: boolean;
+  file?: string;
+  editor?: string;
+  commitMsg?: string;
+  push?: "prompt" | "always" | "never";
+  remote?: string;
+  autoApprove?: boolean;
+  ci?: boolean;
+};
+
+export type AppServices = {
+  git: import("../services/git/reader.js").GitReader;
+  gitOps: import("../services/git/ops.js").GitOps;
+  workspace: import("../services/workspace/manager.js").WorkspaceManager;
+  template: import("../services/template/transform.js").TemplateService;
+  state: import("../services/state/index.js").StateService;
+  editor: import("../services/editor/index.js").EditorService;
+  review: import("../services/review/index.js").ReviewService;
+};
+
+export type AppDeps = {
+  config: import("../config/schema.js").AppConfig;
+  services: AppServices;
+};
+
+export type RunContext = {
+  runId: string;
+  input: CliInput;
+  project?: ManagedProject;
+  selectedBranches?: BranchRef[];
+  target?: TargetFile;
+  targets?: TargetFile[];
+  eligible?: BranchRef[];
+  template?: TemplateDocument;
+  activeTemplate?: TargetTemplate;
+  templates?: TargetTemplate[];
+  plans?: BranchPlan[];
+  approvals?: Approval[];
+  results?: BranchResult[];
+  pushResults?: PushResult[];
+};

package/src/services/editor/index.ts

@@ -0,0 +1,85 @@
+import { Result, ok, err } from "../../core/types.js";
+import { editorError, inputCancelledError } from "../../core/errors.js";
+import { spawn } from "child_process";
+import { AppConfig } from "../../config/schema.js";
+import { existsSync } from "fs";
+import { which } from "../../utils/which.js";
+
+export type EditorService = {
+  openForEdit(templatePath: string, config: AppConfig): Promise<Result<void>>;
+  openForDiff(beforePath: string, afterPath: string, config: AppConfig): Promise<Result<void>>;
+};
+
+/**
+ * Substitute {file}, {before}, {after} placeholders in a command template.
+ */
+function buildCommand(
+  template: string[],
+  vars: Record<string, string>
+): string[] {
+  return template.map((part) => {
+    let result = part;
+    for (const [k, v] of Object.entries(vars)) {
+      result = result.replace(`{${k}}`, v);
+    }
+    return result;
+  });
+}
+
+/**
+ * Spawn a command and wait for it to exit.
+ * Returns an error if the process exits with a non-zero code.
+ */
+async function runCommand(
+  cmd: string[],
+  description: string
+): Promise<Result<void>> {
+  return new Promise((resolve) => {
+    const [bin, ...args] = cmd;
+    const proc = spawn(bin, args, { stdio: "inherit" });
+
+    proc.on("error", (e: any) => {
+      if (e.code === "ENOENT") {
+        resolve(err(editorError(`Editor '${bin}' not found. Install it or set a different editor via --editor or git-worker.config.json.`)));
+      } else {
+        resolve(err(editorError(`${description} failed: ${e.message}`)));
+      }
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(ok(undefined));
+      } else {
+        // Some editors (like VS Code) return non-zero on cancel
+        resolve(ok(undefined));
+      }
+    });
+  });
+}
+
+export async function openForEdit(
+  templatePath: string,
+  config: AppConfig
+): Promise<Result<void>> {
+  const cmd = buildCommand(config.editor.editCommand, { file: templatePath });
+  return runCommand(cmd, "Editor");
+}
+
+export async function openForDiff(
+  beforePath: string,
+  afterPath: string,
+  config: AppConfig
+): Promise<Result<void>> {
+  const cmd = buildCommand(config.editor.diffCommand, {
+    before: beforePath,
+    after: afterPath,
+  });
+  return runCommand(cmd, "Diff viewer");
+}
+
+export function createEditorService(): EditorService {
+  return {
+    openForEdit,
+    openForDiff,
+  };
+}