@samaksh/git-worker 0.2.3 → 0.3.1

package/dist/cli/index.js

@@ -1,13 +1,24 @@
 #!/usr/bin/env node
 import { Command } from "commander";
+import { createRequire } from "module";
 import { run } from "../app.js";
 import { handleCacheList, handleCacheClean } from "./commands.js";
 import chalk from "chalk";
+let version = "0.3.1";
+try {
+    const require = createRequire(import.meta.url);
+    const pkg = require("../../package.json");
+    if (pkg?.version)
+        version = pkg.version;
+}
+catch {
+    // fallback
+}
 const program = new Command();
 program
     .name("git-worker")
     .description("Safe, composable CLI/TUI for applying reviewed file changes across many Git branches")
-    .version("0.2.3")
+    .version(version)
     .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.*/)")

package/dist/config/repo-presets.d.ts

@@ -0,0 +1,16 @@
+export type RepoPresetFile = {
+    path: string;
+    description: string;
+    isDynamic?: boolean;
+    dynamicVar?: string;
+    defaultContent: string;
+};
+export type RepoPreset = {
+    id: string;
+    name: string;
+    matchRemote: RegExp | string[];
+    matchName?: RegExp | string[];
+    files: RepoPresetFile[];
+};
+export declare const REPO_PRESETS: RepoPreset[];
+export declare function detectPreset(remoteUrl?: string, repoName?: string): RepoPreset | undefined;

package/dist/config/repo-presets.js

@@ -0,0 +1,271 @@
+export const REPO_PRESETS = [
+    {
+        id: "clomodel",
+        name: "CLO Model (ACEBRE_CLOmodel)",
+        matchRemote: [
+            "https://github.hdfcbank.com/HDFCBANK/ACEBRE_CLOmodel.git",
+            "git@github.hdfcbank.com:HDFCBANK/ACEBRE_CLOmodel.git",
+            "acebre_clomodel.git",
+            "ACEBRE_CLOmodel.git",
+            "clomodel",
+        ],
+        matchName: ["ACEBRE_CLOmodel", "CLOmodel", "clomodel"],
+        files: [
+            {
+                path: ".env",
+                description: "Environment variables configuration",
+                defaultContent: `# CLO Model Environment Configuration
+SERVICE_NAME={SERVICE_NAME}
+servicename={servicename}
+ENV={ENV:-uat}
+PORT={PORT:-8080}
+LOG_LEVEL={LOG_LEVEL:-INFO}
+MODEL_VERSION={MODEL_VERSION:-1.0.0}
+`,
+            },
+            {
+                path: "Dockerfile_model",
+                description: "Model service Dockerfile",
+                defaultContent: `# CLO Model Service Dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# System dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    curl \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install service-specific requirements
+COPY \${servicename:-common}/requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source code and scripts
+COPY . .
+RUN chmod +x *.sh common/*.sh 2>/dev/null || true
+
+ENV SERVICE_NAME="\${SERVICE_NAME}"
+ENV PORT="\${PORT:-8080}"
+EXPOSE \${PORT:-8080}
+
+CMD ["./run.sh"]
+`,
+            },
+            {
+                path: "Jenkinsfile",
+                description: "Jenkins CI/CD Pipeline definition",
+                defaultContent: `pipeline {
+    agent any
+    environment {
+        SERVICE_NAME = "\${SERVICE_NAME}"
+        BRANCH_SLUG = "\${BRANCH_SLUG}"
+        DOCKER_IMAGE = "clomodel/\${BRANCH_SLUG}:\${COMMIT_SHA}"
+    }
+    stages {
+        stage('Checkout') {
+            steps {
+                checkout scm
+            }
+        }
+        stage('Build & Test') {
+            steps {
+                sh 'chmod +x init.sh && ./init.sh'
+                sh 'pytest tests/ || echo "No tests configured"'
+            }
+        }
+        stage('Docker Build') {
+            steps {
+                sh "docker build -f Dockerfile_model -t \${DOCKER_IMAGE} ."
+            }
+        }
+        stage('SonarQube Analysis') {
+            steps {
+                sh 'sonar-scanner -Dproject.settings=sonar-project.properties'
+            }
+        }
+    }
+}
+`,
+            },
+            {
+                path: "app_env.properties",
+                description: "Application properties file",
+                defaultContent: `# CLO Model Application Properties
+app.service.name=\${SERVICE_NAME}
+app.service.branch=\${BRANCH_NAME}
+app.service.port=\${PORT:-8080}
+app.service.env=\${ENV:-uat}
+app.log.level=\${LOG_LEVEL:-INFO}
+app.model.version=\${MODEL_VERSION:-1.0.0}
+`,
+            },
+            {
+                path: "get_property_from_env_file.sh",
+                description: "Shell helper script to extract properties from .env",
+                defaultContent: `#!/usr/bin/env bash
+# Helper script to extract a property value from a .env file
+# Usage: ./get_property_from_env_file.sh <KEY> [ENV_FILE]
+
+set -euo pipefail
+
+KEY="\${1:-}"
+ENV_FILE="\${2:-.env}"
+
+if [ -z "$KEY" ]; then
+    echo "Usage: $0 <PROPERTY_KEY> [ENV_FILE]" >&2
+    exit 1
+fi
+
+if [ ! -f "$ENV_FILE" ]; then
+    echo "Error: Environment file '$ENV_FILE' not found." >&2
+    exit 1
+fi
+
+# Extract key value ignoring comments and export prefix
+VAL=$(grep -E "^(export[[:space:]]+)?\${KEY}=" "$ENV_FILE" | head -n 1 | cut -d '=' -f2- | tr -d '\\r"' || true)
+echo "$VAL"
+`,
+            },
+            {
+                path: "init.sh",
+                description: "Environment initialization script",
+                defaultContent: `#!/usr/bin/env bash
+# CLO Model Initialization Script
+set -euo pipefail
+
+echo "Initializing \${SERVICE_NAME:-clo-model} for branch \${BRANCH_NAME:-main}..."
+
+# Ensure log directory exists
+mkdir -p logs
+
+# Validate and load configuration
+if [ -f .env ]; then
+    echo "Loading environment from .env..."
+    set -a
+    source .env
+    set +a
+fi
+
+echo "Initialization complete."
+`,
+            },
+            {
+                path: "run.sh",
+                description: "Service startup execution script",
+                defaultContent: `#!/usr/bin/env bash
+# CLO Model Service Execution Script
+set -euo pipefail
+
+export SERVICE_NAME="\${SERVICE_NAME:-clo-model}"
+export PORT="\${PORT:-8080}"
+export LOG_LEVEL="\${LOG_LEVEL:-INFO}"
+
+echo "Starting \${SERVICE_NAME} on port \${PORT}..."
+
+# Execute main service entry point
+if [ -f "\${servicename:-.}/main.py" ]; then
+    python3 "\${servicename:-.}/main.py" --port "\${PORT}"
+else
+    python3 -m http.server "\${PORT}"
+fi
+`,
+            },
+            {
+                path: "sonar-project.properties",
+                description: "SonarQube static analysis configuration",
+                defaultContent: `# SonarQube Project Configuration
+sonar.projectKey=clomodel-\${SERVICE_NAME:-default}
+sonar.projectName=CLO Model - \${SERVICE_NAME:-default}
+sonar.projectVersion=\${MODEL_VERSION:-1.0.0}
+sonar.sources=.
+sonar.exclusions=**/tests/**,**/logs/**,**/__pycache__/**
+sonar.python.version=3.10
+sonar.sourceEncoding=UTF-8
+`,
+            },
+            {
+                path: "common/run.sh",
+                description: "Shared common run script",
+                defaultContent: `#!/usr/bin/env bash
+# Shared execution wrapper for CLO Model services
+set -euo pipefail
+
+echo "[common/run.sh] Preparing environment for \${SERVICE_NAME}..."
+mkdir -p logs
+
+exec ./run.sh "$@"
+`,
+            },
+            {
+                path: "common/var_log.oy",
+                description: "Common logger utility module",
+                defaultContent: `"""
+Common Logging Utility for CLO Model Services.
+Configures structured log output and log rotation.
+"""
+import os
+import sys
+import logging
+
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
+SERVICE_NAME = os.environ.get("SERVICE_NAME", "clo-model")
+
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL, logging.INFO),
+    format=f"%(asctime)s [%(levelname)s] [{SERVICE_NAME}] %(name)s: %(message)s",
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+
+logger = logging.getLogger(SERVICE_NAME)
+`,
+            },
+            {
+                path: "{servicename}/requirements.txt",
+                description: "Python dependencies (path resolved dynamically from branch .env 'servicename')",
+                isDynamic: true,
+                dynamicVar: "servicename",
+                defaultContent: `# Python dependencies for {servicename}
+flask>=2.3.0
+gunicorn>=20.1.0
+requests>=2.31.0
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+pydantic>=2.0.0
+`,
+            },
+        ],
+    },
+];
+export function detectPreset(remoteUrl, repoName) {
+    if (!remoteUrl && !repoName)
+        return undefined;
+    const target = (remoteUrl || repoName || "").toLowerCase();
+    for (const preset of REPO_PRESETS) {
+        if (Array.isArray(preset.matchRemote)) {
+            for (const m of preset.matchRemote) {
+                if (target.includes(m.toLowerCase()))
+                    return preset;
+            }
+        }
+        else if (preset.matchRemote instanceof RegExp && preset.matchRemote.test(target)) {
+            return preset;
+        }
+        if (preset.matchName && repoName) {
+            const t2 = repoName.toLowerCase();
+            if (Array.isArray(preset.matchName)) {
+                for (const m of preset.matchName) {
+                    if (t2.includes(m.toLowerCase()))
+                        return preset;
+                }
+            }
+            else if (preset.matchName instanceof RegExp && preset.matchName.test(t2)) {
+                return preset;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/core/types.d.ts

@@ -21,6 +21,9 @@ export type BranchRef = {
 };
 export type TargetFile = {
     path: string;
+    description?: string;
+    isDynamic?: boolean;
+    dynamicVar?: string;
 };
 export type TemplateEngineType = "env-reconcile" | "source-of-truth";
 export type TargetTemplate = {
@@ -34,6 +37,9 @@ export type TargetTemplate = {
         raw: string;
     }>;
     isNewFile?: boolean;
+    isDynamic?: boolean;
+    dynamicVar?: string;
+    description?: string;
 };
 export type ManagedProject = {
     id: string;

package/dist/stages/apply.js

@@ -9,113 +9,136 @@ export const applyChangesStage = async (context, deps) => {
     }
     sectionHeader("Applying Changes");
     const results = [];
-    const approvedPlans = context.plans.filter((p) => {
-        const approval = context.approvals.find((a) => a.branchName === p.branch.name);
-        return approval?.approved === true;
-    });
-    // Handle unapproved/error plans first
+    // Group all plans by branch
+    const allBranchPlans = new Map();
     for (const plan of context.plans) {
-        const approval = context.approvals.find((a) => a.branchName === plan.branch.name);
-        if (approval?.approved)
-            continue; // Will be handled below
-        if (plan.status === "unchanged") {
-            results.push({ branch: plan.branch, status: "unchanged", reason: "No changes" });
+        const list = allBranchPlans.get(plan.branch.name) || [];
+        list.push(plan);
+        allBranchPlans.set(plan.branch.name, list);
+    }
+    // Filter approved plans grouped by branch
+    const approvedBranchMap = new Map();
+    for (const [branchName, plans] of allBranchPlans.entries()) {
+        const approvedPlansForBranch = plans.filter((p) => {
+            const approval = context.approvals.find((a) => a.branchName === p.branch.name && a.planHash === p.planHash);
+            return approval?.approved === true;
+        });
+        if (approvedPlansForBranch.length > 0) {
+            approvedBranchMap.set(branchName, approvedPlansForBranch);
         }
-        else if (plan.status === "error") {
-            results.push({ branch: plan.branch, status: "failed", reason: plan.reason });
+    }
+    // Record unapproved, error, or unchanged branch results
+    for (const [branchName, plans] of allBranchPlans.entries()) {
+        if (approvedBranchMap.has(branchName))
+            continue; // Handled below
+        const firstBranch = plans[0].branch;
+        const hasError = plans.some((p) => p.status === "error");
+        const hasChanged = plans.some((p) => p.status === "changed");
+        if (hasError) {
+            const errPlan = plans.find((p) => p.status === "error");
+            results.push({ branch: firstBranch, status: "failed", reason: errPlan?.reason ?? "Planning error" });
         }
-        else {
+        else if (hasChanged) {
+            const wasReviewed = context.approvals.some((a) => a.branchName === branchName);
             results.push({
-                branch: plan.branch,
-                status: approval ? "rejected" : "skipped",
-                reason: approval ? "User rejected" : "Not reviewed",
+                branch: firstBranch,
+                status: wasReviewed ? "rejected" : "skipped",
+                reason: wasReviewed ? "User rejected" : "Not approved",
             });
         }
+        else {
+            results.push({ branch: firstBranch, status: "unchanged", reason: "No changes across files" });
+        }
     }
-    if (approvedPlans.length === 0) {
+    if (approvedBranchMap.size === 0) {
         statusLine("info", "No approved changes to apply");
         return ok({ ...context, results });
     }
-    for (const plan of approvedPlans) {
+    for (const [branchName, plansToApply] of approvedBranchMap.entries()) {
+        const branch = plansToApply[0].branch;
         const s = clack.spinner();
-        s.start(`Applying ${plan.branch.name}…`);
+        s.start(`Applying ${branchName} (${plansToApply.length} file(s))…`);
         try {
-            // Verify ownership before any destructive op
+            // 1. Verify workspace ownership before destructive op
             const ownerCheck = deps.services.workspace.verifyOwnership(context.project);
             if (!ownerCheck.ok) {
-                s.stop(chalk.red(`${plan.branch.name} — ownership verification failed`));
-                results.push({ branch: plan.branch, status: "failed", reason: ownerCheck.error.message });
+                s.stop(chalk.red(`${branchName} — ownership verification failed`));
+                results.push({ branch, status: "failed", reason: ownerCheck.error.message });
                 continue;
             }
-            // ── Stale-plan guard ────────────────────────────────────────────
-            // Fetch latest SHA and verify it matches the reviewed plan
-            const currentShaResult = await deps.services.gitOps.getBranchSha(context.project.managedRepoPath, plan.branch.isRemote && plan.branch.remote
-                ? `${plan.branch.remote}/${plan.branch.name}`
-                : plan.branch.name);
+            // 2. Stale-plan guard
+            const baseCommitSha = plansToApply[0].baseCommitSha;
+            const currentShaResult = await deps.services.gitOps.getBranchSha(context.project.managedRepoPath, branch.isRemote && branch.remote
+                ? `${branch.remote}/${branch.name}`
+                : branch.name);
             if (!currentShaResult.ok) {
-                s.stop(chalk.red(`${plan.branch.name} — could not verify branch tip`));
-                results.push({ branch: plan.branch, status: "failed", reason: "Could not verify branch tip" });
-                // Clean up before next branch
+                s.stop(chalk.red(`${branchName} — could not verify branch tip`));
+                results.push({ branch, status: "failed", reason: "Could not verify branch tip" });
                 await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
                 await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode).catch(() => { });
                 continue;
             }
-            if (currentShaResult.value !== plan.baseCommitSha) {
-                s.stop(chalk.yellow(`${plan.branch.name} — branch advanced since review (stale plan)`));
+            if (currentShaResult.value !== baseCommitSha) {
+                s.stop(chalk.yellow(`${branchName} — branch advanced since review (stale plan)`));
                 results.push({
-                    branch: plan.branch,
+                    branch,
                     status: "failed",
-                    reason: `Branch advanced: reviewed at ${plan.baseCommitSha.slice(0, 8)}, now at ${currentShaResult.value.slice(0, 8)}. Re-run to replan.`,
+                    reason: `Branch advanced: reviewed at ${baseCommitSha.slice(0, 8)}, now at ${currentShaResult.value.slice(0, 8)}. Re-run to replan.`,
                 });
                 continue;
             }
-            // ── Clean before checkout ───────────────────────────────────────
+            // 3. Clean before checkout
             await deps.services.gitOps.resetHard(context.project.managedRepoPath);
             await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode);
-            // ── Checkout branch ─────────────────────────────────────────────
-            const checkoutResult = await deps.services.gitOps.checkoutBranch(context.project.managedRepoPath, plan.branch.name);
+            // 4. Checkout branch
+            const checkoutResult = await deps.services.gitOps.checkoutBranch(context.project.managedRepoPath, branch.name);
             if (!checkoutResult.ok) {
-                s.stop(chalk.red(`${plan.branch.name} — checkout failed`));
-                results.push({ branch: plan.branch, status: "failed", reason: checkoutResult.error.message });
+                s.stop(chalk.red(`${branchName} — checkout failed`));
+                results.push({ branch, status: "failed", reason: checkoutResult.error.message });
                 await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
                 await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode).catch(() => { });
                 continue;
             }
-            // ── Clean after checkout ─────────────────────────────────────────
+            // 5. Clean after checkout
             await deps.services.gitOps.resetHard(context.project.managedRepoPath);
             await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode);
-            // ── Verify before-content hash ──────────────────────────────────
-            const currentFileResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, plan.branch, plan.path);
-            const currentContent = currentFileResult.ok ? currentFileResult.value : "";
-            const currentHash = sha256(currentContent);
-            if (currentHash !== plan.beforeContentHash) {
-                s.stop(chalk.yellow(`${plan.branch.name} — file content changed since review`));
+            // 6. Verify before-content hash and stage each file
+            let branchFileError;
+            for (const plan of plansToApply) {
+                const currentFileResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, plan.path);
+                const currentContent = currentFileResult.ok ? currentFileResult.value : "";
+                const currentHash = sha256(currentContent);
+                if (currentHash !== plan.beforeContentHash) {
+                    branchFileError = `File '${plan.path}' changed since review`;
+                    break;
+                }
+                const writeResult = await deps.services.gitOps.writeAndStage(context.project.managedRepoPath, plan.path, plan.afterContent);
+                if (!writeResult.ok) {
+                    branchFileError = `Write failed for '${plan.path}': ${writeResult.error.message}`;
+                    break;
+                }
+            }
+            if (branchFileError) {
+                s.stop(chalk.yellow(`${branchName} — ${branchFileError}`));
                 results.push({
-                    branch: plan.branch,
+                    branch,
                     status: "failed",
-                    reason: "File content changed since review. Re-run to replan.",
+                    reason: `${branchFileError}. Re-run to replan.`,
                 });
                 await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
                 await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode).catch(() => { });
                 continue;
             }
-            // ── Write and stage ─────────────────────────────────────────────
-            const writeResult = await deps.services.gitOps.writeAndStage(context.project.managedRepoPath, plan.path, plan.afterContent);
-            if (!writeResult.ok) {
-                s.stop(chalk.red(`${plan.branch.name} — write failed`));
-                results.push({ branch: plan.branch, status: "failed", reason: writeResult.error.message });
-                await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
-                continue;
-            }
-            // ── Verify only the intended path is staged ─────────────────────
+            // 7. Verify staged files match expected paths
             const stagedResult = await deps.services.gitOps.getStagedFiles(context.project.managedRepoPath);
             if (stagedResult.ok) {
                 const staged = stagedResult.value;
-                const unexpected = staged.filter((f) => f !== plan.path);
+                const expectedSet = new Set(plansToApply.map((p) => p.path));
+                const unexpected = staged.filter((f) => !expectedSet.has(f));
                 if (unexpected.length > 0) {
-                    s.stop(chalk.red(`${plan.branch.name} — unexpected staged files`));
+                    s.stop(chalk.red(`${branchName} — unexpected staged files`));
                     results.push({
-                        branch: plan.branch,
+                        branch,
                         status: "failed",
                         reason: `Unexpected staged files: ${unexpected.join(", ")}. Aborting commit for safety.`,
                     });
@@ -123,32 +146,30 @@ export const applyChangesStage = async (context, deps) => {
                     continue;
                 }
                 if (staged.length === 0) {
-                    // No-op commit — already matches
-                    s.stop(chalk.gray(`${plan.branch.name} — no staged changes (already matches)`));
-                    results.push({ branch: plan.branch, status: "unchanged", reason: "Content identical after write" });
+                    s.stop(chalk.gray(`${branchName} — no staged changes (already matches)`));
+                    results.push({ branch, status: "unchanged", reason: "Content identical after write" });
                     continue;
                 }
             }
-            // ── Commit ──────────────────────────────────────────────────────
+            // 8. Commit all staged files in one atomic commit
             const commitMsg = deps.config.git.commitMessage;
             const commitResult = await deps.services.gitOps.commit(context.project.managedRepoPath, commitMsg);
             if (!commitResult.ok) {
-                s.stop(chalk.red(`${plan.branch.name} — commit failed`));
-                results.push({ branch: plan.branch, status: "failed", reason: commitResult.error.message });
+                s.stop(chalk.red(`${branchName} — commit failed`));
+                results.push({ branch, status: "failed", reason: commitResult.error.message });
                 await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
                 continue;
             }
-            s.stop(chalk.green(`${plan.branch.name} — committed ${commitResult.value.slice(0, 8)}`));
+            s.stop(chalk.green(`${branchName} — committed ${commitResult.value.slice(0, 8)} (${plansToApply.length} file(s))`));
             results.push({
-                branch: plan.branch,
+                branch,
                 status: "committed",
                 commitSha: commitResult.value,
             });
         }
         catch (e) {
-            s.stop(chalk.red(`${plan.branch.name} — unexpected error`));
-            results.push({ branch: plan.branch, status: "failed", reason: e.message });
-            // Clean up managed checkout before next branch
+            s.stop(chalk.red(`${branchName} — unexpected error`));
+            results.push({ branch, status: "failed", reason: e.message });
             await deps.services.gitOps.resetHard(context.project.managedRepoPath).catch(() => { });
             await deps.services.gitOps.clean(context.project.managedRepoPath, deps.config.git.cleanMode).catch(() => { });
         }