@samaksh/git-worker 0.1.0 → 0.2.1

package/src/stages/edit-template.ts

@@ -1,227 +0,0 @@
-import { Stage } from "../core/pipeline.js";
-import { RunContext, AppDeps, TargetTemplate, ok, err } from "../core/types.js";
-import { workspaceError, inputCancelledError } from "../core/errors.js";
-import { parseEnvTemplate } from "../services/template/env.js";
-import { extractTemplateVariables } from "../services/template/interpolator.js";
-import { validateTemplateSyntax } from "../services/template/validator.js";
-import { clack, sectionHeader, statusLine } from "../utils/ui.js";
-import { writeFile, readFile, mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import chalk from "chalk";
-
-const HEADER_SENTINEL = "Git Worker — Template Editor";
-
-function buildInstructionHeader(targetPath: string): string {
-  const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
-  const isJson = targetPath.endsWith(".json");
-
-  // Avoid inserting comments into JSON files
-  if (isJson) return "";
-
-  if (isEnv) {
-    return [
-      "# ─────────────────────────────────────────────────────────────────",
-      `# ${HEADER_SENTINEL}`,
-      "# Use KEY=value    → static value enforced on every branch",
-      "# Use KEY={KEY}    → dynamic: reads existing value from each branch",
-      "# Lines starting with # are comments and are preserved in the file",
-      "# ─────────────────────────────────────────────────────────────────",
-      "",
-    ].join("\n");
-  }
-
-  return [
-    "# ─────────────────────────────────────────────────────────────────",
-    `# ${HEADER_SENTINEL}`,
-    "# This template is the declarative SOURCE OF TRUTH for this file.",
-    "# Variables: ${VAR} or ${VAR:-default} are resolved from branch .env",
-    "# Built-ins: ${BRANCH_NAME}, ${BRANCH_SLUG}, ${REPO_NAME}, ${COMMIT_SHA}",
-    "# ─────────────────────────────────────────────────────────────────",
-    "",
-  ].join("\n");
-}
-
-function stripInstructionHeader(content: string): string {
-  if (!content.includes(HEADER_SENTINEL)) {
-    return content;
-  }
-
-  const lines = content.split("\n");
-  let headerEnd = 0;
-
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes(HEADER_SENTINEL)) {
-      let j = i + 1;
-      while (j < lines.length && (lines[j].startsWith("#") || lines[j].trim() === "")) {
-        j++;
-      }
-      headerEnd = j;
-      break;
-    }
-  }
-
-  return lines.slice(headerEnd).join("\n");
-}
-
-export const editTemplateStage: Stage<RunContext, AppDeps> = async (context, deps) => {
-  if (!context.template && !context.activeTemplate) {
-    return err(workspaceError("No template loaded"));
-  }
-
-  const targetPath = context.target?.path ?? ".env";
-  const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
-  let currentRaw = context.activeTemplate?.raw ?? context.template?.raw ?? "";
-
-  // In CI mode, validate syntax and proceed without interactive editor
-  if (context.input.ci) {
-    statusLine("info", "CI mode — skipping template editor");
-    const validation = validateTemplateSyntax(targetPath, currentRaw);
-    if (!validation.ok) {
-      clack.log.error(`Template syntax error: ${validation.error.message}`);
-      return validation;
-    }
-    return ok(context);
-  }
-
-  sectionHeader("Edit Template");
-
-  const tmpDir = await mkdtemp(join(tmpdir(), "git-worker-"));
-  const templateFileName = targetPath.split("/").pop() ?? "template.env";
-  const templateFile = join(tmpDir, templateFileName);
-
-  try {
-    while (true) {
-      const header = buildInstructionHeader(targetPath);
-      const content = header ? `${header}${currentRaw}` : currentRaw;
-      await writeFile(templateFile, content, "utf-8");
-
-      const editorName = context.input.editor || deps.config.editor.name;
-      statusLine("info", `Opening ${targetPath} in ${editorName} — save and close when done`);
-      console.log(chalk.gray(`  File: ${templateFile}`));
-      if (!header) {
-        console.log(
-          chalk.gray(
-            `  Tip: Use \${VAR} or \${VAR:-default} to resolve variables from each branch's .env`
-          )
-        );
-      }
-      console.log("");
-
-      const editResult = await deps.services.editor.openForEdit(templateFile, deps.config);
-      if (!editResult.ok) {
-        clack.log.warn(editResult.error.message);
-        const proceed = await clack.confirm({
-          message: "Editor not available. Continue with current template?",
-          initialValue: true,
-        });
-        if (clack.isCancel(proceed) || !proceed) {
-          return err(inputCancelledError("Template edit cancelled — editor unavailable"));
-        }
-        break;
-      }
-
-      // Read edited content
-      const edited = await readFile(templateFile, "utf-8");
-      const stripped = stripInstructionHeader(edited).trimEnd() + "\n";
-
-      // 1. Validate syntax immediately
-      const validation = validateTemplateSyntax(targetPath, stripped);
-      if (!validation.ok) {
-        console.log("");
-        clack.log.error(`Syntax Validation Failed:\n  ${chalk.red(validation.error.message)}`);
-        console.log("");
-
-        const fixChoice = await clack.select({
-          message: "How would you like to handle this syntax error?",
-          options: [
-            { value: "re-edit", label: "✏️  Re-edit template to fix the error" },
-            { value: "discard", label: "❌  Discard changes and cancel" },
-          ],
-        });
-
-        if (clack.isCancel(fixChoice) || fixChoice === "discard") {
-          return err(inputCancelledError("Template edit cancelled due to syntax error"));
-        }
-
-        currentRaw = stripped;
-        continue;
-      }
-
-      // 2. Syntax is valid!
-      currentRaw = stripped;
-      statusLine("ok", "Template syntax validated successfully");
-
-      // 3. Post-edit menu
-      const actionChoice = await clack.select({
-        message: "Template ready. What would you like to do next?",
-        options: [
-          {
-            value: "proceed",
-            label: "➜  Proceed to plan changes",
-            hint: "generate diffs across target branches",
-          },
-          {
-            value: "re-edit",
-            label: "✏️   Edit template again",
-            hint: "re-open in editor",
-          },
-          {
-            value: "discard",
-            label: "❌  Discard changes and cancel",
-          },
-        ],
-      });
-
-      if (clack.isCancel(actionChoice) || actionChoice === "discard") {
-        return err(inputCancelledError("Template edit cancelled"));
-      }
-
-      if (actionChoice === "re-edit") {
-        continue;
-      }
-
-      break;
-    }
-
-    // Update context with the validated template
-    if (isEnv) {
-      const parseResult = parseEnvTemplate(currentRaw);
-      if (!parseResult.ok) return parseResult;
-      const activeTemplate: TargetTemplate = {
-        path: targetPath,
-        engine: "env-reconcile",
-        raw: currentRaw,
-        parsedEnv: parseResult.value,
-      };
-      statusLine("ok", `Template ready — ${parseResult.value.assignments.length} assignment(s)`);
-      return ok({
-        ...context,
-        template: parseResult.value,
-        activeTemplate,
-        templates: [activeTemplate],
-      });
-    } else {
-      const variables = extractTemplateVariables(currentRaw);
-      const activeTemplate: TargetTemplate = {
-        path: targetPath,
-        engine: "source-of-truth",
-        raw: currentRaw,
-        variables,
-      };
-      statusLine("ok", `Template ready — ${variables.length} variable placeholder(s) detected`);
-      return ok({
-        ...context,
-        template: {
-          raw: currentRaw,
-          assignments: [],
-          placeholders: variables.map((v) => v.name),
-        },
-        activeTemplate,
-        templates: [activeTemplate],
-      });
-    }
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-  }
-};

package/src/stages/eligibility.ts

@@ -1,67 +0,0 @@
-import { Stage } from "../core/pipeline.js";
-import { RunContext, AppDeps, BranchRef, ok, err } from "../core/types.js";
-import { workspaceError } from "../core/errors.js";
-import { clack, sectionHeader, statusLine } from "../utils/ui.js";
-
-export const checkEligibilityStage: Stage<RunContext, AppDeps> = async (context, deps) => {
-  if (!context.selectedBranches || !context.target || !context.project) {
-    return err(workspaceError("Prerequisites missing for eligibility check"));
-  }
-
-  sectionHeader("Eligibility Check");
-
-  const eligible: BranchRef[] = [];
-  const ineligible: Array<{ branch: BranchRef; reason: string }> = [];
-  const isEnvTarget =
-    context.target.path === ".env" || context.target.path.startsWith(".env.");
-
-  for (const branch of context.selectedBranches) {
-    // 1. Check if the target file exists in the branch
-    const targetRead = await deps.services.git.readFileFromBranch(
-      context.project.managedRepoPath,
-      branch,
-      context.target.path
-    );
-    const targetFound = targetRead.ok;
-
-    // 2. If target is a non-.env file, check if .env is available as variable source
-    let envNote = "";
-    if (!isEnvTarget) {
-      const envRead = await deps.services.git.readFileFromBranch(
-        context.project.managedRepoPath,
-        branch,
-        ".env"
-      );
-      if (envRead.ok) {
-        envNote = " • .env present";
-      } else {
-        envNote = " • .env missing (variables will require fallbacks)";
-      }
-    }
-
-    const fileStatus = targetFound ? "target file found" : "target file will be created";
-    eligible.push(branch);
-    statusLine(
-      targetFound ? "ok" : "info",
-      branch.name,
-      `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`
-    );
-  }
-
-  if (ineligible.length > 0) {
-    console.log("");
-    clack.log.warn(`${ineligible.length} branch(es) ineligible:`);
-    for (const { branch, reason } of ineligible) {
-      statusLine("warn", branch.name, reason);
-    }
-  }
-
-  if (eligible.length === 0) {
-    clack.log.error("No eligible branches found.");
-    return err(workspaceError("No eligible branches"));
-  }
-
-  statusLine("ok", `${eligible.length} eligible branch(es) ready`);
-
-  return ok({ ...context, eligible });
-};

package/src/stages/load-template.ts

@@ -1,188 +0,0 @@
-import { Stage } from "../core/pipeline.js";
-import { RunContext, AppDeps, TargetTemplate, ok, err } from "../core/types.js";
-import { workspaceError } from "../core/errors.js";
-import { parseEnvTemplate, synthesizeTemplate } from "../services/template/env.js";
-import { extractTemplateVariables } from "../services/template/interpolator.js";
-import { sectionHeader, statusLine } from "../utils/ui.js";
-
-export const loadTemplateStage: Stage<RunContext, AppDeps> = async (context, deps) => {
-  if (!context.project || !context.target) {
-    return err(workspaceError("Prerequisites missing for template load"));
-  }
-
-  sectionHeader("Template");
-
-  const targetPath = context.target.path;
-  const isEnvTarget = targetPath === ".env" || targetPath.startsWith(".env.");
-
-  // 1. Try to load saved template from ~/.git-worker state
-  const stateResult = await deps.services.state.loadTemplate(
-    context.project.stateDir,
-    targetPath
-  );
-
-  if (stateResult.ok && stateResult.value) {
-    const state = stateResult.value;
-    statusLine("ok", "Loaded saved template", `last updated ${state.updatedAt}`);
-    if (state.lastRunSummary) {
-      const s = state.lastRunSummary;
-      statusLine(
-        "info",
-        `Last run: ${s.committed} committed, ${s.failed} failed, ${s.skipped} skipped of ${s.total}`
-      );
-    }
-
-    if (isEnvTarget) {
-      const parseResult = parseEnvTemplate(state.template);
-      if (parseResult.ok) {
-        const activeTemplate: TargetTemplate = {
-          path: targetPath,
-          engine: "env-reconcile",
-          raw: state.template,
-          parsedEnv: parseResult.value,
-        };
-        return ok({
-          ...context,
-          template: parseResult.value,
-          activeTemplate,
-          templates: [activeTemplate],
-        });
-      }
-    } else {
-      const activeTemplate: TargetTemplate = {
-        path: targetPath,
-        engine: "source-of-truth",
-        raw: state.template,
-        variables: extractTemplateVariables(state.template),
-      };
-      return ok({
-        ...context,
-        template: {
-          raw: state.template,
-          assignments: [],
-          placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
-        },
-        activeTemplate,
-        templates: [activeTemplate],
-      });
-    }
-
-    statusLine("warn", "Saved template was invalid — synthesizing a new one");
-  } else {
-    statusLine("info", "No saved template — synthesizing first-run draft");
-  }
-
-  // 2. First run: synthesize from existing branch content
-  if (context.eligible && context.eligible.length > 0 && context.project) {
-    if (isEnvTarget) {
-      const contents: Array<{ branchName: string; content: string }> = [];
-
-      for (const branch of context.eligible.slice(0, 5)) {
-        const readResult = await deps.services.git.readFileFromBranch(
-          context.project.managedRepoPath,
-          branch,
-          targetPath
-        );
-        if (readResult.ok) {
-          contents.push({ branchName: branch.name, content: readResult.value });
-        }
-      }
-
-      const synthesized = synthesizeTemplate(contents);
-      const parseResult = parseEnvTemplate(synthesized);
-      if (parseResult.ok) {
-        statusLine("ok", "Synthesized .env template from branch content");
-        const activeTemplate: TargetTemplate = {
-          path: targetPath,
-          engine: "env-reconcile",
-          raw: synthesized,
-          parsedEnv: parseResult.value,
-        };
-        return ok({
-          ...context,
-          template: parseResult.value,
-          activeTemplate,
-          templates: [activeTemplate],
-        });
-      }
-    } else {
-      // Source-of-truth: read sample from first branch that has the file
-      for (const branch of context.eligible) {
-        const readResult = await deps.services.git.readFileFromBranch(
-          context.project.managedRepoPath,
-          branch,
-          targetPath
-        );
-        if (readResult.ok) {
-          statusLine("ok", `Loaded draft template from branch '${branch.name}'`);
-          const activeTemplate: TargetTemplate = {
-            path: targetPath,
-            engine: "source-of-truth",
-            raw: readResult.value,
-            variables: extractTemplateVariables(readResult.value),
-          };
-          return ok({
-            ...context,
-            template: {
-              raw: readResult.value,
-              assignments: [],
-              placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
-            },
-            activeTemplate,
-            templates: [activeTemplate],
-          });
-        }
-      }
-    }
-  }
-
-  // 3. Fallback starters for new files
-  let starterContent = "";
-  if (isEnvTarget) {
-    starterContent =
-      "# Git Worker Template\n# Use KEY=value for static values enforced on all branches\n# Use KEY={KEY} to read existing value from each branch\n";
-    const parseResult = parseEnvTemplate(starterContent);
-    if (!parseResult.ok) return parseResult;
-    const activeTemplate: TargetTemplate = {
-      path: targetPath,
-      engine: "env-reconcile",
-      raw: starterContent,
-      parsedEnv: parseResult.value,
-    };
-    statusLine("info", "Using starter template for .env");
-    return ok({
-      ...context,
-      template: parseResult.value,
-      activeTemplate,
-      templates: [activeTemplate],
-    });
-  } else if (targetPath.endsWith(".json")) {
-    starterContent = `{\n  "name": "\${BRANCH_SLUG}",\n  "version": "1.0.0"\n}\n`;
-  } else if (targetPath.endsWith(".yaml") || targetPath.endsWith(".yml")) {
-    starterContent = `# Git Worker YAML Template\nname: "\${BRANCH_SLUG}"\nservice:\n  port: \${PORT:-8080}\n`;
-  } else if (targetPath.toLowerCase().includes("dockerfile")) {
-    starterContent = `# Git Worker Dockerfile Template\nFROM node:20-alpine\nENV SERVICE=\${BRANCH_SLUG}\nEXPOSE \${PORT:-8080}\n`;
-  } else {
-    starterContent = `# Git Worker Template for ${targetPath}\n`;
-  }
-
-  statusLine("info", `Using starter template for ${targetPath}`);
-  const activeTemplate: TargetTemplate = {
-    path: targetPath,
-    engine: "source-of-truth",
-    raw: starterContent,
-    variables: extractTemplateVariables(starterContent),
-    isNewFile: true,
-  };
-
-  return ok({
-    ...context,
-    template: {
-      raw: starterContent,
-      assignments: [],
-      placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
-    },
-    activeTemplate,
-    templates: [activeTemplate],
-  });
-};