@samaksh/git-worker 0.2.2 → 0.3.0

package/dist/stages/load-template.js

@@ -2,64 +2,78 @@ import { 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 { detectPreset } from "../config/repo-presets.js";
 import { sectionHeader, statusLine } from "../utils/ui.js";
-export const loadTemplateStage = async (context, deps) => {
-    if (!context.project || !context.target) {
-        return err(workspaceError("Prerequisites missing for template load"));
-    }
-    sectionHeader("Template");
-    const targetPath = context.target.path;
+async function loadSingleTargetTemplate(target, context, deps) {
+    const targetPath = target.path;
     const isEnvTarget = targetPath === ".env" || targetPath.startsWith(".env.");
+    const preset = detectPreset(context.project?.remoteUrl, context.project?.id);
+    const presetFile = preset?.files.find((f) => f.path === targetPath);
     // 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 (context.project) {
+        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 for '${targetPath}'`, `updated ${state.updatedAt}`);
+            if (state.lastRunSummary) {
+                const s = state.lastRunSummary;
+                statusLine("info", `Last run for '${targetPath}': ${s.committed} committed, ${s.failed} failed of ${s.total}`);
+            }
+            if (isEnvTarget) {
+                const parseResult = parseEnvTemplate(state.template);
+                if (parseResult.ok) {
+                    return {
+                        path: targetPath,
+                        engine: "env-reconcile",
+                        raw: state.template,
+                        parsedEnv: parseResult.value,
+                        isDynamic: target.isDynamic,
+                        dynamicVar: target.dynamicVar,
+                        description: target.description,
+                    };
+                }
+            }
+            else {
+                return {
+                    path: targetPath,
+                    engine: "source-of-truth",
+                    raw: state.template,
+                    variables: extractTemplateVariables(state.template),
+                    isDynamic: target.isDynamic,
+                    dynamicVar: target.dynamicVar,
+                    description: target.description,
+                };
+            }
         }
+    }
+    // 2. Check repository preset base template catalog
+    if (presetFile && presetFile.defaultContent) {
+        statusLine("ok", `Loaded preset base template for '${targetPath}'`);
         if (isEnvTarget) {
-            const parseResult = parseEnvTemplate(state.template);
+            const parseResult = parseEnvTemplate(presetFile.defaultContent);
             if (parseResult.ok) {
-                const activeTemplate = {
+                return {
                     path: targetPath,
                     engine: "env-reconcile",
-                    raw: state.template,
+                    raw: presetFile.defaultContent,
                     parsedEnv: parseResult.value,
+                    isDynamic: target.isDynamic,
+                    dynamicVar: target.dynamicVar,
+                    description: target.description || presetFile.description,
                 };
-                return ok({
-                    ...context,
-                    template: parseResult.value,
-                    activeTemplate,
-                    templates: [activeTemplate],
-                });
             }
         }
-        else {
-            const activeTemplate = {
-                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");
+        return {
+            path: targetPath,
+            engine: "source-of-truth",
+            raw: presetFile.defaultContent,
+            variables: extractTemplateVariables(presetFile.defaultContent),
+            isDynamic: target.isDynamic ?? presetFile.isDynamic,
+            dynamicVar: target.dynamicVar ?? presetFile.dynamicVar,
+            description: target.description || presetFile.description,
+        };
     }
-    // 2. First run: synthesize from existing branch content
+    // 3. Try to read from existing branch content
     if (context.eligible && context.eligible.length > 0 && context.project) {
         if (isEnvTarget) {
             const contents = [];
@@ -69,73 +83,59 @@ export const loadTemplateStage = async (context, deps) => {
                     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 = {
-                    path: targetPath,
-                    engine: "env-reconcile",
-                    raw: synthesized,
-                    parsedEnv: parseResult.value,
-                };
-                return ok({
-                    ...context,
-                    template: parseResult.value,
-                    activeTemplate,
-                    templates: [activeTemplate],
-                });
+            if (contents.length > 0) {
+                const synthesized = synthesizeTemplate(contents);
+                const parseResult = parseEnvTemplate(synthesized);
+                if (parseResult.ok) {
+                    statusLine("ok", `Synthesized .env template from branch content for '${targetPath}'`);
+                    return {
+                        path: targetPath,
+                        engine: "env-reconcile",
+                        raw: synthesized,
+                        parsedEnv: parseResult.value,
+                        isDynamic: target.isDynamic,
+                        dynamicVar: target.dynamicVar,
+                    };
+                }
             }
         }
-        else {
+        else if (!target.isDynamic) {
             // 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 = {
+                    statusLine("ok", `Loaded draft for '${targetPath}' from branch '${branch.name}'`);
+                    return {
                         path: targetPath,
                         engine: "source-of-truth",
                         raw: readResult.value,
                         variables: extractTemplateVariables(readResult.value),
+                        isDynamic: target.isDynamic,
+                        dynamicVar: target.dynamicVar,
                     };
-                    return ok({
-                        ...context,
-                        template: {
-                            raw: readResult.value,
-                            assignments: [],
-                            placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
-                        },
-                        activeTemplate,
-                        templates: [activeTemplate],
-                    });
                 }
             }
         }
     }
-    // 3. Fallback starters for new files
+    // 4. 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 = {
+        const parsedEnv = parseResult.ok ? parseResult.value : undefined;
+        statusLine("info", `Using starter template for '${targetPath}'`);
+        return {
             path: targetPath,
             engine: "env-reconcile",
             raw: starterContent,
-            parsedEnv: parseResult.value,
+            parsedEnv,
+            isNewFile: true,
+            isDynamic: target.isDynamic,
+            dynamicVar: target.dynamicVar,
         };
-        statusLine("info", "Using starter template for .env");
-        return ok({
-            ...context,
-            template: parseResult.value,
-            activeTemplate,
-            templates: [activeTemplate],
-        });
     }
-    else if (targetPath.endsWith(".json")) {
+    if (targetPath.endsWith(".json")) {
         starterContent = `{\n  "name": "\${BRANCH_SLUG}",\n  "version": "1.0.0"\n}\n`;
     }
     else if (targetPath.endsWith(".yaml") || targetPath.endsWith(".yml")) {
@@ -147,22 +147,37 @@ export const loadTemplateStage = async (context, deps) => {
     else {
         starterContent = `# Git Worker Template for ${targetPath}\n`;
     }
-    statusLine("info", `Using starter template for ${targetPath}`);
-    const activeTemplate = {
+    statusLine("info", `Using starter template for '${targetPath}'`);
+    return {
         path: targetPath,
         engine: "source-of-truth",
         raw: starterContent,
         variables: extractTemplateVariables(starterContent),
         isNewFile: true,
+        isDynamic: target.isDynamic,
+        dynamicVar: target.dynamicVar,
     };
+}
+export const loadTemplateStage = async (context, deps) => {
+    if (!context.project || (!context.target && !context.targets)) {
+        return err(workspaceError("Prerequisites missing for template load"));
+    }
+    sectionHeader("Template Loading");
+    const targetFiles = context.targets || (context.target ? [context.target] : []);
+    const loadedTemplates = [];
+    for (const target of targetFiles) {
+        const template = await loadSingleTargetTemplate(target, context, deps);
+        loadedTemplates.push(template);
+    }
+    const primaryTemplate = loadedTemplates[0];
     return ok({
         ...context,
-        template: {
-            raw: starterContent,
+        template: primaryTemplate.parsedEnv ?? {
+            raw: primaryTemplate.raw,
             assignments: [],
-            placeholders: activeTemplate.variables?.map((v) => v.name) ?? [],
+            placeholders: primaryTemplate.variables?.map((v) => v.name) ?? [],
         },
-        activeTemplate,
-        templates: [activeTemplate],
+        activeTemplate: primaryTemplate,
+        templates: loadedTemplates,
     });
 };