@samaksh/git-worker 0.1.0 → 0.2.1

package/src/cli/commands.ts

@@ -1,142 +0,0 @@
-import chalk from "chalk";
-import { clack, sectionHeader, statusLine } from "../utils/ui.js";
-import {
-  listCachedProjects,
-  clearProjectCache,
-  clearAllCache,
-} from "../services/workspace/cache.js";
-import { getWorkspaceRoot } from "../services/workspace/manager.js";
-
-export async function handleCacheList(): Promise<void> {
-  const root = getWorkspaceRoot();
-  sectionHeader("Cached Projects (~/.git-worker)");
-
-  const projects = await listCachedProjects();
-  if (projects.length === 0) {
-    console.log("");
-    clack.log.info(`No cached repositories found in ${root}/projects`);
-    console.log("");
-    return;
-  }
-
-  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 projects) {
-    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(
-    chalk.gray(
-      `  Total: ${projects.length} repository/repositories cached in ${root}/projects`
-    )
-  );
-  console.log("");
-}
-
-export async function handleCacheClean(
-  target?: string,
-  options?: { all?: boolean; yes?: boolean; force?: boolean }
-): Promise<void> {
-  const root = getWorkspaceRoot();
-  const projects = await listCachedProjects();
-
-  if (projects.length === 0) {
-    clack.log.info(`No cached repositories found in ${root}/projects`);
-    return;
-  }
-
-  const skipConfirm = options?.yes || options?.force || Boolean(process.env.CI);
-
-  // 1. If explicit --all flag provided
-  if (options?.all) {
-    if (!skipConfirm) {
-      const confirm = await clack.confirm({
-        message: `Are you sure you want to remove ALL ${projects.length} cached project(s) from ${root}?`,
-        initialValue: true,
-      });
-      if (clack.isCancel(confirm) || !confirm) {
-        clack.log.warn("Cache clean cancelled.");
-        return;
-      }
-    }
-
-    const result = await clearAllCache();
-    if (!result.ok) {
-      clack.log.error(result.error.message);
-      process.exit(1);
-    }
-    statusLine("ok", `Cleared all cached projects (${result.value.count} removed)`);
-    return;
-  }
-
-  // 2. If a specific target ID / URL / path was passed as positional argument
-  if (target) {
-    const result = await clearProjectCache(target);
-    if (!result.ok) {
-      clack.log.error(result.error.message);
-      process.exit(1);
-    }
-    statusLine("ok", `Removed cache for: ${result.value.removed}`);
-    return;
-  }
-
-  // 3. Interactive prompt
-  sectionHeader("Clean Cache");
-
-  const choice = await clack.select<string>({
-    message: "Select cache to remove:",
-    options: [
-      {
-        value: "__ALL__",
-        label: `Clear ALL cached projects (${projects.length} projects)`,
-        hint: `removes all checkouts in ${root}/projects`,
-      },
-      ...projects.map((p) => ({
-        value: p.id,
-        label: `${p.name}  (${p.remoteUrl || p.sourceRepoPath})`,
-        hint: `ID: ${p.id}  (${p.createdAt ? p.createdAt.slice(0, 10) : ""})`,
-      })),
-    ],
-  });
-
-  if (clack.isCancel(choice)) {
-    clack.log.warn("Cancelled.");
-    return;
-  }
-
-  if (choice === "__ALL__") {
-    const confirm = await clack.confirm({
-      message: `Are you sure you want to remove ALL ${projects.length} cached project(s)?`,
-      initialValue: true,
-    });
-    if (clack.isCancel(confirm) || !confirm) {
-      clack.log.warn("Cancelled.");
-      return;
-    }
-    const result = await clearAllCache();
-    if (!result.ok) {
-      clack.log.error(result.error.message);
-      process.exit(1);
-    }
-    statusLine("ok", `Cleared all cached projects (${result.value.count} removed)`);
-    return;
-  }
-
-  // Specific selected project
-  const result = await clearProjectCache(choice);
-  if (!result.ok) {
-    clack.log.error(result.error.message);
-    process.exit(1);
-  }
-  statusLine("ok", `Removed cache for: ${result.value.removed}`);
-}

package/src/cli/index.ts

@@ -1,123 +0,0 @@
-#!/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

@@ -1,46 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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[];
-};