@samaksh/git-worker 0.2.3 → 0.3.0

package/dist/stages/edit-template.js

@@ -3,7 +3,7 @@ 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 { clack, sectionHeader, statusLine, divider } from "../utils/ui.js";
 import { writeFile, readFile, mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -54,143 +54,199 @@ function stripInstructionHeader(content) {
     }
     return lines.slice(headerEnd).join("\n");
 }
+async function editSingleTemplate(template, index, total, tmpDir, deps, context) {
+    const targetPath = template.path;
+    const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
+    let currentRaw = template.raw;
+    const safeFileName = targetPath.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const templateFile = join(tmpDir, `${index + 1}_${safeFileName}`);
+    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", `[${index + 1}/${total}] Opening ${chalk.bold.cyan(targetPath)} in ${editorName}`);
+        console.log(chalk.gray(`  Path: ${templateFile}`));
+        if (template.description) {
+            console.log(chalk.gray(`  Purpose: ${template.description}`));
+        }
+        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 unavailable for ${targetPath}. Continue with current content?`,
+                initialValue: true,
+            });
+            if (clack.isCancel(proceed) || !proceed) {
+                return { ok: false, error: inputCancelledError(`Template edit cancelled for ${targetPath}`) };
+            }
+            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 for ${targetPath}:\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 { ok: false, error: inputCancelledError(`Template edit cancelled for ${targetPath}`) };
+            }
+            currentRaw = stripped;
+            continue;
+        }
+        // 2. Syntax is valid
+        currentRaw = stripped;
+        statusLine("ok", `Syntax validated for ${chalk.bold.cyan(targetPath)}`);
+        break;
+    }
+    // Build updated TargetTemplate
+    if (isEnv) {
+        const parseResult = parseEnvTemplate(currentRaw);
+        if (!parseResult.ok) {
+            return { ok: false, error: parseResult.error };
+        }
+        return {
+            ok: true,
+            template: {
+                ...template,
+                raw: currentRaw,
+                parsedEnv: parseResult.value,
+            },
+        };
+    }
+    else {
+        const variables = extractTemplateVariables(currentRaw);
+        return {
+            ok: true,
+            template: {
+                ...template,
+                raw: currentRaw,
+                variables,
+            },
+        };
+    }
+}
 export const editTemplateStage = async (context, deps) => {
-    if (!context.template && !context.activeTemplate) {
-        return err(workspaceError("No template loaded"));
+    const templates = context.templates || (context.activeTemplate ? [context.activeTemplate] : []);
+    if (templates.length === 0) {
+        return err(workspaceError("No templates loaded for editing"));
     }
-    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
+    // In CI mode, validate all templates and proceed
     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;
+        statusLine("info", `CI mode — validating syntax for ${templates.length} template(s)`);
+        for (const t of templates) {
+            const validation = validateTemplateSyntax(t.path, t.raw);
+            if (!validation.ok) {
+                clack.log.error(`Template syntax error in ${t.path}: ${validation.error.message}`);
+                return validation;
+            }
         }
         return ok(context);
     }
-    sectionHeader("Edit Template");
+    sectionHeader(`Edit Template(s) (${templates.length} file(s) selected)`);
     const tmpDir = await mkdtemp(join(tmpdir(), "git-worker-"));
-    const templateFileName = targetPath.split("/").pop() ?? "template.env";
-    const templateFile = join(tmpDir, templateFileName);
+    const updatedTemplates = [];
     try {
+        for (let i = 0; i < templates.length; i++) {
+            const template = templates[i];
+            const res = await editSingleTemplate(template, i, templates.length, tmpDir, deps, context);
+            if (!res.ok) {
+                return err(res.error);
+            }
+            updatedTemplates.push(res.template);
+        }
+        // Interactive summary and post-edit menu if multiple templates
         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`));
+            divider();
+            console.log(chalk.bold("  Edited Templates Summary:"));
+            for (const t of updatedTemplates) {
+                const details = t.engine === "env-reconcile"
+                    ? `${t.parsedEnv?.assignments.length ?? 0} assignment(s)`
+                    : `${t.variables?.length ?? 0} variable placeholder(s)`;
+                statusLine("ok", t.path, details);
             }
             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?",
+            const action = await clack.select({
+                message: "All templates reviewed. 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",
-                    },
+                    ...(updatedTemplates.length > 1
+                        ? [
+                            {
+                                value: "re-edit-one",
+                                label: "✏️   Re-edit a specific file",
+                                hint: "choose one file to modify again",
+                            },
+                        ]
+                        : [
+                            {
+                                value: "re-edit-first",
+                                label: "✏️   Re-edit template",
+                                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 (clack.isCancel(action) || action === "discard") {
+                return err(inputCancelledError("Template editing cancelled"));
             }
-            if (actionChoice === "re-edit") {
+            if (action === "proceed") {
+                break;
+            }
+            if (action === "re-edit-first") {
+                const res = await editSingleTemplate(updatedTemplates[0], 0, 1, tmpDir, deps, context);
+                if (!res.ok)
+                    return err(res.error);
+                updatedTemplates[0] = res.template;
                 continue;
             }
-            break;
-        }
-        // Update context with the validated template
-        if (isEnv) {
-            const parseResult = parseEnvTemplate(currentRaw);
-            if (!parseResult.ok)
-                return parseResult;
-            const activeTemplate = {
-                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 = {
-                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],
-            });
+            if (action === "re-edit-one") {
+                const pickedPath = await clack.select({
+                    message: "Select file to re-edit:",
+                    options: updatedTemplates.map((t, idx) => ({
+                        value: idx,
+                        label: t.path,
+                    })),
+                });
+                if (!clack.isCancel(pickedPath)) {
+                    const idx = Number(pickedPath);
+                    const res = await editSingleTemplate(updatedTemplates[idx], idx, updatedTemplates.length, tmpDir, deps, context);
+                    if (!res.ok)
+                        return err(res.error);
+                    updatedTemplates[idx] = res.template;
+                }
+            }
         }
+        const primaryTemplate = updatedTemplates[0];
+        return ok({
+            ...context,
+            templates: updatedTemplates,
+            activeTemplate: primaryTemplate,
+            template: primaryTemplate.parsedEnv ?? {
+                raw: primaryTemplate.raw,
+                assignments: [],
+                placeholders: primaryTemplate.variables?.map((v) => v.name) ?? [],
+            },
+        });
     }
     finally {
         await rm(tmpDir, { recursive: true, force: true }).catch(() => { });

package/dist/stages/eligibility.js

@@ -1,19 +1,21 @@
 import { ok, err } from "../core/types.js";
 import { workspaceError } from "../core/errors.js";
+import { parseEnvFile } from "../services/template/env.js";
 import { clack, sectionHeader, statusLine } from "../utils/ui.js";
 export const checkEligibilityStage = async (context, deps) => {
-    if (!context.selectedBranches || !context.target || !context.project) {
+    const targets = context.targets || (context.target ? [context.target] : []);
+    if (!context.selectedBranches || targets.length === 0 || !context.project) {
         return err(workspaceError("Prerequisites missing for eligibility check"));
     }
     sectionHeader("Eligibility Check");
     const eligible = [];
     const ineligible = [];
-    const isEnvTarget = context.target.path === ".env" || context.target.path.startsWith(".env.");
+    const hasEnvTarget = targets.some((t) => t.path === ".env" || t.path.startsWith(".env."));
     const total = context.selectedBranches.length;
     const isBatchMode = total > 8;
     const s = clack.spinner();
     if (isBatchMode) {
-        s.start(`Checking eligibility for ${total} branches…`);
+        s.start(`Checking eligibility for ${total} branches across ${targets.length} target file(s)…`);
     }
     // Concurrent execution pool (up to 16 workers in parallel)
     const concurrency = Math.min(16, total);
@@ -23,28 +25,55 @@ export const checkEligibilityStage = async (context, deps) => {
         while (currentIndex < total) {
             const idx = currentIndex++;
             const branch = context.selectedBranches[idx];
-            // 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";
+            // Read branch .env if available to resolve dynamic paths or check variable availability
+            let envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
+            const envMap = new Map();
+            if (envRead.ok) {
+                const parsed = parseEnvFile(envRead.value);
+                if (parsed.ok) {
+                    for (const [k, v] of parsed.value.map) {
+                        envMap.set(k.toLowerCase(), v.value);
+                        envMap.set(k, v.value);
+                    }
+                }
+            }
+            let existingFileCount = 0;
+            let missingDynamicVar;
+            for (const target of targets) {
+                let checkPath = target.path;
+                if (target.isDynamic && (target.dynamicVar || target.path.includes("{servicename}"))) {
+                    const varName = target.dynamicVar || "servicename";
+                    const resolvedVal = envMap.get(varName) ||
+                        envMap.get(varName.toLowerCase()) ||
+                        envMap.get(varName.toUpperCase()) ||
+                        envMap.get("SERVICE_NAME");
+                    if (resolvedVal) {
+                        checkPath = target.path.replace(`{${varName}}`, resolvedVal);
+                    }
+                    else {
+                        missingDynamicVar = varName;
+                    }
                 }
-                else {
-                    envNote = " • .env missing (variables will require fallbacks)";
+                const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, checkPath);
+                if (targetRead.ok) {
+                    existingFileCount++;
                 }
             }
-            const fileStatus = targetFound ? "target file found" : "target file will be created";
+            let envNote = "";
+            if (!hasEnvTarget) {
+                envNote = envRead.ok ? " • .env present" : " • .env missing";
+            }
+            if (missingDynamicVar) {
+                envNote += ` • note: '${missingDynamicVar}' missing in .env`;
+            }
+            const fileStatus = `${existingFileCount}/${targets.length} target file(s) found`;
             eligible.push(branch);
             completed++;
             if (isBatchMode) {
                 s.message(`Checking eligibility (${completed}/${total})…`);
             }
             else {
-                statusLine(targetFound ? "ok" : "info", branch.name, `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`);
+                statusLine("ok", branch.name, `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`);
             }
         }
     });