@samaksh/git-worker 0.0.0-stage → 0.2.0

package/dist/services/template/env.js

@@ -0,0 +1,146 @@
+import { ok, err } from "../../core/types.js";
+import { templateError } from "../../core/errors.js";
+/**
+ * Parse a .env template file into structured assignments.
+ * Template uses {KEY} for dynamic placeholders, KEY=value for static.
+ */
+export function parseEnvTemplate(raw) {
+    const lines = raw.replace(/\r\n/g, "\n").split("\n");
+    const assignments = [];
+    const placeholders = new Set();
+    const seenKeys = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Preserve blank lines and full-line comments — skip for assignment parsing
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            continue;
+        }
+        // Handle `export KEY=...`
+        let workingLine = trimmed;
+        if (workingLine.startsWith("export ")) {
+            workingLine = workingLine.slice(7).trimStart();
+        }
+        // Find = sign
+        const eqIndex = workingLine.indexOf("=");
+        if (eqIndex === -1) {
+            return err(templateError(`Line ${i + 1}: missing '=' in assignment`));
+        }
+        const key = workingLine.slice(0, eqIndex).trimEnd();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            return err(templateError(`Line ${i + 1}: invalid key name '${key}'`));
+        }
+        if (seenKeys.has(key)) {
+            return err(templateError(`Duplicate key '${key}' at line ${i + 1} (first seen at line ${seenKeys.get(key) + 1})`));
+        }
+        seenKeys.set(key, i);
+        // Value: everything after the first '=', no trimming (preserve quoting)
+        const value = workingLine.slice(eqIndex + 1);
+        // Check for placeholder {KEY} — must be the entire value
+        const placeholderMatch = value.match(/^\{([A-Za-z_][A-Za-z0-9_]*)\}$/);
+        if (placeholderMatch) {
+            const placeholderName = placeholderMatch[1];
+            placeholders.add(placeholderName);
+            assignments.push({
+                key,
+                value,
+                isStatic: false,
+                isPlaceholder: true,
+                placeholderName,
+                originalLine: line,
+            });
+        }
+        else {
+            assignments.push({
+                key,
+                value,
+                isStatic: true,
+                isPlaceholder: false,
+                originalLine: line,
+            });
+        }
+    }
+    return ok({
+        raw,
+        assignments,
+        placeholders: Array.from(placeholders),
+    });
+}
+/**
+ * Parse a .env file into a map of key → EnvEntry (preserving export, quoting, lineIndex).
+ * Returns an error if duplicate keys are found.
+ * Lines that cannot be parsed as assignments are tracked but not included in the map.
+ */
+export function parseEnvFile(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const map = new Map();
+    const seen = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            continue;
+        let workingLine = trimmed;
+        let hasExport = false;
+        if (workingLine.startsWith("export ")) {
+            hasExport = true;
+            workingLine = workingLine.slice(7).trimStart();
+        }
+        const eqIndex = workingLine.indexOf("=");
+        if (eqIndex === -1) {
+            // Not a valid assignment — preserve line as-is, do not fail
+            continue;
+        }
+        const key = workingLine.slice(0, eqIndex).trimEnd();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        if (seen.has(key)) {
+            return err(templateError(`Duplicate key '${key}' at line ${i + 1} (first seen at line ${seen.get(key) + 1}) in branch file`));
+        }
+        seen.set(key, i);
+        // Value: everything after '=', preserve as-is (no trim)
+        const value = workingLine.slice(eqIndex + 1);
+        map.set(key, { key, value, lineIndex: i, originalLine: line, hasExport });
+    }
+    return ok({ map, lines });
+}
+/**
+ * Synthesize a first-run template draft from common keys across branches.
+ * Uniform values → static assignment. Varying values → dynamic placeholder.
+ */
+export function synthesizeTemplate(branchContents) {
+    if (branchContents.length === 0) {
+        return "# 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";
+    }
+    // Collect all keys and their values per branch
+    const keyValues = new Map(); // key → branchName → value
+    for (const { branchName, content } of branchContents) {
+        const parsed = parseEnvFile(content);
+        if (!parsed.ok)
+            continue;
+        for (const [key, entry] of parsed.value.map) {
+            if (!keyValues.has(key))
+                keyValues.set(key, new Map());
+            keyValues.get(key).set(branchName, entry.value);
+        }
+    }
+    // Build template lines
+    const lines = [
+        "# Git Worker Template",
+        "# Static: KEY=value  — enforced on every branch",
+        "# Dynamic: KEY={KEY} — reads existing value from each branch",
+        "",
+    ];
+    for (const [key, branchMap] of keyValues) {
+        const values = Array.from(branchMap.values());
+        const allSame = values.every((v) => v === values[0]);
+        if (allSame) {
+            lines.push(`${key}=${values[0]}`);
+        }
+        else {
+            lines.push(`# Varies by branch — using dynamic placeholder`);
+            lines.push(`${key}={${key}}`);
+        }
+    }
+    return lines.join("\n") + "\n";
+}

package/dist/services/template/interpolator.d.ts

@@ -0,0 +1,30 @@
+import { Result } from "../../core/types.js";
+export type TemplateVariable = {
+    name: string;
+    fallback?: string;
+    raw: string;
+};
+export type BranchContext = {
+    branchName: string;
+    repoName?: string;
+    commitSha?: string;
+};
+/**
+ * Convert a branch name into a DNS/Docker-safe slug.
+ * e.g. "uat/payments-service" -> "uat-payments-service"
+ */
+export declare function slugifyBranchName(branchName: string): string;
+/**
+ * Extract all ${VAR} and ${VAR:-default} placeholders from template text.
+ */
+export declare function extractTemplateVariables(templateText: string): TemplateVariable[];
+/**
+ * Interpolate a template with variables from:
+ * 1. Built-in branch metadata (BRANCH_NAME, BRANCH_SLUG, REPO_NAME, COMMIT_SHA, SHORT_SHA)
+ * 2. Custom variables resolved from the branch's .env file
+ * 3. Fallback defaults (${VAR:-default})
+ */
+export declare function interpolateTemplate(templateText: string, envMap: Map<string, string>, context: BranchContext): Result<{
+    content: string;
+    missingVars: string[];
+}>;

package/dist/services/template/interpolator.js

@@ -0,0 +1,75 @@
+import { ok } from "../../core/types.js";
+const VARIABLE_REGEX = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+/**
+ * Convert a branch name into a DNS/Docker-safe slug.
+ * e.g. "uat/payments-service" -> "uat-payments-service"
+ */
+export function slugifyBranchName(branchName) {
+    return branchName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Extract all ${VAR} and ${VAR:-default} placeholders from template text.
+ */
+export function extractTemplateVariables(templateText) {
+    const vars = [];
+    const seen = new Set();
+    VARIABLE_REGEX.lastIndex = 0;
+    let match;
+    while ((match = VARIABLE_REGEX.exec(templateText)) !== null) {
+        const raw = match[0];
+        const name = match[1];
+        const fallback = match[2];
+        const key = `${name}::${fallback ?? ""}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            vars.push({ name, fallback, raw });
+        }
+    }
+    return vars;
+}
+/**
+ * Interpolate a template with variables from:
+ * 1. Built-in branch metadata (BRANCH_NAME, BRANCH_SLUG, REPO_NAME, COMMIT_SHA, SHORT_SHA)
+ * 2. Custom variables resolved from the branch's .env file
+ * 3. Fallback defaults (${VAR:-default})
+ */
+export function interpolateTemplate(templateText, envMap, context) {
+    const branchName = context.branchName;
+    const branchSlug = slugifyBranchName(branchName);
+    const repoName = context.repoName ?? "";
+    const commitSha = context.commitSha ?? "";
+    const shortSha = commitSha.slice(0, 7);
+    const builtins = new Map([
+        ["BRANCH_NAME", branchName],
+        ["BRANCH_SLUG", branchSlug],
+        ["REPO_NAME", repoName],
+        ["COMMIT_SHA", commitSha],
+        ["SHORT_SHA", shortSha],
+    ]);
+    const missingSet = new Set();
+    VARIABLE_REGEX.lastIndex = 0;
+    const content = templateText.replace(VARIABLE_REGEX, (fullMatch, varName, fallback) => {
+        // 1. Built-in variables
+        if (builtins.has(varName)) {
+            return builtins.get(varName);
+        }
+        // 2. Variables from branch .env
+        if (envMap.has(varName) && envMap.get(varName) !== undefined) {
+            return envMap.get(varName);
+        }
+        // 3. Fallback default (${VAR:-default})
+        if (fallback !== undefined) {
+            return fallback;
+        }
+        // 4. Missing required variable without fallback
+        missingSet.add(varName);
+        return fullMatch;
+    });
+    return ok({
+        content,
+        missingVars: Array.from(missingSet),
+    });
+}

package/dist/services/template/transform.d.ts

@@ -0,0 +1,22 @@
+import { TemplateDocument, Result } from "../../core/types.js";
+export type TransformResult = {
+    content: string;
+    changed: boolean;
+    addedKeys: string[];
+    updatedKeys: string[];
+};
+export type TemplateService = {
+    transform(branchContent: string, template: TemplateDocument, branchValues: Map<string, string>): Result<TransformResult>;
+};
+/**
+ * Apply the template to a branch's existing .env content.
+ *
+ * Rules:
+ *  - Static key: update the value in-place (preserve `export` prefix if present)
+ *  - Dynamic key (placeholder): if key exists in branch, leave it as-is; if missing, use branchValues
+ *  - Keys not mentioned in template: preserved untouched
+ *  - Preserve key ordering, comments, blank lines
+ *  - Appended keys are added at end
+ */
+export declare function transformEnv(branchContent: string, template: TemplateDocument, branchValues: Map<string, string>): Result<TransformResult>;
+export declare function createTemplateService(): TemplateService;

package/dist/services/template/transform.js

@@ -0,0 +1,75 @@
+import { ok, err } from "../../core/types.js";
+import { templateError } from "../../core/errors.js";
+import { parseEnvFile } from "./env.js";
+/**
+ * Apply the template to a branch's existing .env content.
+ *
+ * Rules:
+ *  - Static key: update the value in-place (preserve `export` prefix if present)
+ *  - Dynamic key (placeholder): if key exists in branch, leave it as-is; if missing, use branchValues
+ *  - Keys not mentioned in template: preserved untouched
+ *  - Preserve key ordering, comments, blank lines
+ *  - Appended keys are added at end
+ */
+export function transformEnv(branchContent, template, branchValues) {
+    const parseResult = parseEnvFile(branchContent);
+    if (!parseResult.ok)
+        return parseResult;
+    const { map: existingMap, lines } = parseResult.value;
+    const resultLines = [...lines];
+    const updatedKeys = [];
+    const addedKeys = [];
+    for (const assignment of template.assignments) {
+        if (assignment.isPlaceholder && assignment.placeholderName) {
+            // Dynamic: read from branch
+            if (existingMap.has(assignment.key)) {
+                // Key exists — preserve exactly as-is, do nothing
+                continue;
+            }
+            else {
+                // Key missing — append with provided value
+                const val = branchValues.get(assignment.key);
+                if (val === undefined) {
+                    return err(templateError(`Missing value for '${assignment.key}' — not found in branch and no value provided`));
+                }
+                resultLines.push(`${assignment.key}=${val}`);
+                addedKeys.push(assignment.key);
+            }
+        }
+        else {
+            // Static: enforce the template value
+            if (existingMap.has(assignment.key)) {
+                const existing = existingMap.get(assignment.key);
+                // Reconstruct line, preserving `export` keyword if it was there
+                const prefix = existing.hasExport ? "export " : "";
+                const newLine = `${prefix}${assignment.key}=${assignment.value}`;
+                if (resultLines[existing.lineIndex] !== newLine) {
+                    resultLines[existing.lineIndex] = newLine;
+                    updatedKeys.push(assignment.key);
+                }
+            }
+            else {
+                resultLines.push(`${assignment.key}=${assignment.value}`);
+                addedKeys.push(assignment.key);
+            }
+        }
+    }
+    // Reconstruct preserving trailing newline convention
+    const hadTrailingNewline = branchContent.endsWith("\n");
+    let newContent = resultLines.join("\n");
+    if (hadTrailingNewline && !newContent.endsWith("\n")) {
+        newContent += "\n";
+    }
+    const changed = newContent !== branchContent;
+    return ok({
+        content: newContent,
+        changed,
+        addedKeys,
+        updatedKeys,
+    });
+}
+export function createTemplateService() {
+    return {
+        transform: transformEnv,
+    };
+}

package/dist/services/template/validator.d.ts

@@ -0,0 +1,5 @@
+import { Result } from "../../core/types.js";
+/**
+ * Validate the syntax of a template based on its file format and delimiters.
+ */
+export declare function validateTemplateSyntax(filePath: string, content: string): Result<void>;

package/dist/services/template/validator.js

@@ -0,0 +1,68 @@
+import { ok, err } from "../../core/types.js";
+import { templateError } from "../../core/errors.js";
+import { parseEnvTemplate } from "./env.js";
+import yaml from "yaml";
+function checkUnclosedDelimiters(content) {
+    let idx = 0;
+    while ((idx = content.indexOf("${", idx)) !== -1) {
+        const closeIdx = content.indexOf("}", idx);
+        const newlineIdx = content.indexOf("\n", idx);
+        if (closeIdx === -1 || (newlineIdx !== -1 && closeIdx > newlineIdx)) {
+            const lineNum = content.slice(0, idx).split("\n").length;
+            return err(templateError(`Unclosed variable delimiter '\${' at line ${lineNum}`));
+        }
+        idx = closeIdx + 1;
+    }
+    return ok(undefined);
+}
+function validateJson(content) {
+    // Replace ${...} placeholders with a dummy string token to check JSON syntax
+    const sanitized = content.replace(/\$\{([^}]*)\}/g, "__GW_PLACEHOLDER__");
+    try {
+        JSON.parse(sanitized);
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(templateError(`JSON syntax error: ${e.message}`));
+    }
+}
+function validateYaml(content) {
+    // Replace ${...} placeholders with safe string to check YAML syntax
+    const sanitized = content.replace(/\$\{([^}]*)\}/g, "__GW_PLACEHOLDER__");
+    try {
+        yaml.parse(sanitized);
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(templateError(`YAML syntax error: ${e.message}`));
+    }
+}
+/**
+ * Validate the syntax of a template based on its file format and delimiters.
+ */
+export function validateTemplateSyntax(filePath, content) {
+    // Check unclosed delimiters first for all template formats
+    const delimiterCheck = checkUnclosedDelimiters(content);
+    if (!delimiterCheck.ok) {
+        return delimiterCheck;
+    }
+    const fileName = filePath.split("/").pop() ?? filePath;
+    // 1. .env files
+    if (fileName === ".env" || fileName.startsWith(".env.")) {
+        const envParse = parseEnvTemplate(content);
+        if (!envParse.ok) {
+            return envParse;
+        }
+        return ok(undefined);
+    }
+    // 2. JSON files
+    if (fileName.endsWith(".json")) {
+        return validateJson(content);
+    }
+    // 3. YAML files
+    if (fileName.endsWith(".yaml") || fileName.endsWith(".yml")) {
+        return validateYaml(content);
+    }
+    // Other text/Dockerfile: valid syntax if delimiters are closed
+    return ok(undefined);
+}

package/dist/services/workspace/cache.d.ts

@@ -0,0 +1,32 @@
+import { Result } from "../../core/types.js";
+import { extractRepoName } from "./manager.js";
+import { AppConfig } from "../../config/schema.js";
+export { extractRepoName };
+export type CachedProjectInfo = {
+    id: string;
+    name: string;
+    sourceRepoPath: string;
+    remoteUrl?: string;
+    createdAt: string;
+    gitWorkerVersion?: string;
+    projectDir: string;
+    hasRepo: boolean;
+};
+/**
+ * List all cached projects in the git-worker workspace root (~/.git-worker/projects)
+ */
+export declare function listCachedProjects(config?: AppConfig): Promise<CachedProjectInfo[]>;
+/**
+ * Clear a specific project cache by project ID, name, remote URL, or path.
+ */
+export declare function clearProjectCache(target: string, config?: AppConfig): Promise<Result<{
+    removed: string;
+    projectDir: string;
+}>>;
+/**
+ * Clear all cached projects and workspaces in ~/.git-worker/projects.
+ */
+export declare function clearAllCache(config?: AppConfig): Promise<Result<{
+    count: number;
+    root: string;
+}>>;

package/dist/services/workspace/cache.js

@@ -0,0 +1,107 @@
+import { existsSync } from "fs";
+import { readdir, readFile, rm, mkdir } from "fs/promises";
+import { join } from "path";
+import { ok, err } from "../../core/types.js";
+import { workspaceError } from "../../core/errors.js";
+import { getWorkspaceRoot, extractRepoName } from "./manager.js";
+export { extractRepoName };
+/**
+ * List all cached projects in the git-worker workspace root (~/.git-worker/projects)
+ */
+export async function listCachedProjects(config) {
+    const root = getWorkspaceRoot(config);
+    const projectsDir = join(root, "projects");
+    if (!existsSync(projectsDir)) {
+        return [];
+    }
+    try {
+        const entries = await readdir(projectsDir, { withFileTypes: true });
+        const projects = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const projectDir = join(projectsDir, entry.name);
+            const markerPath = join(projectDir, ".git-worker-marker");
+            if (existsSync(markerPath)) {
+                try {
+                    const raw = await readFile(markerPath, "utf-8");
+                    const data = JSON.parse(raw);
+                    const hasRepo = existsSync(join(projectDir, "repo"));
+                    const name = data.name ||
+                        extractRepoName(data.remoteUrl || data.sourceRepoPath, entry.name);
+                    projects.push({
+                        id: data.id || entry.name,
+                        name,
+                        sourceRepoPath: data.sourceRepoPath || "",
+                        remoteUrl: data.remoteUrl || undefined,
+                        createdAt: data.createdAt || "",
+                        gitWorkerVersion: data.gitWorkerVersion,
+                        projectDir,
+                        hasRepo,
+                    });
+                }
+                catch {
+                    // malformed marker, still list with id
+                    projects.push({
+                        id: entry.name,
+                        name: entry.name,
+                        sourceRepoPath: "",
+                        projectDir,
+                        createdAt: "",
+                        hasRepo: existsSync(join(projectDir, "repo")),
+                    });
+                }
+            }
+        }
+        return projects.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Clear a specific project cache by project ID, name, remote URL, or path.
+ */
+export async function clearProjectCache(target, config) {
+    const projects = await listCachedProjects(config);
+    const trimmed = target.trim();
+    const match = projects.find((p) => p.id === trimmed ||
+        p.id.startsWith(trimmed) ||
+        p.name.toLowerCase() === trimmed.toLowerCase() ||
+        (p.remoteUrl && (p.remoteUrl === trimmed || p.remoteUrl.includes(trimmed))) ||
+        p.sourceRepoPath === trimmed ||
+        p.sourceRepoPath.includes(trimmed));
+    if (!match) {
+        return err(workspaceError(`No cached project found matching '${target}'. Run 'git-worker cache list' to view all cached projects.`));
+    }
+    try {
+        await rm(match.projectDir, { recursive: true, force: true });
+        return ok({
+            removed: `${match.name} (${match.remoteUrl || match.sourceRepoPath || match.id})`,
+            projectDir: match.projectDir,
+        });
+    }
+    catch (e) {
+        return err(workspaceError(`Failed to remove project cache: ${e.message}`, e));
+    }
+}
+/**
+ * Clear all cached projects and workspaces in ~/.git-worker/projects.
+ */
+export async function clearAllCache(config) {
+    const root = getWorkspaceRoot(config);
+    const projectsDir = join(root, "projects");
+    if (!existsSync(projectsDir)) {
+        return ok({ count: 0, root: projectsDir });
+    }
+    try {
+        const projects = await listCachedProjects(config);
+        const count = projects.length;
+        await rm(projectsDir, { recursive: true, force: true });
+        await mkdir(projectsDir, { recursive: true });
+        return ok({ count, root: projectsDir });
+    }
+    catch (e) {
+        return err(workspaceError(`Failed to clear cache: ${e.message}`, e));
+    }
+}

package/dist/services/workspace/manager.d.ts

@@ -0,0 +1,44 @@
+import { Result, ManagedProject } from "../../core/types.js";
+import { AppConfig } from "../../config/schema.js";
+export type RepoInfo = {
+    isRepo: boolean;
+    remoteUrl?: string;
+    remoteName?: string;
+};
+export type WorkspaceManager = {
+    resolveProject(sourceRepoPath: string, remote: string | undefined, config: AppConfig): Promise<Result<ManagedProject>>;
+    checkLocalRepo(dirPath: string, preferredRemote?: string): Promise<RepoInfo>;
+    ensureManagedClone(project: ManagedProject): Promise<Result<{
+        isCached: boolean;
+    }>>;
+    verifyOwnership(project: ManagedProject): Result<void>;
+    acquireLock(project: ManagedProject, timeoutMs: number): Promise<Result<() => void>>;
+    releaseLock(project: ManagedProject): void;
+};
+/**
+ * Extract a human-readable repository name from a remote URL or file path.
+ * e.g. "https://github.com/org/repo.git" -> "repo"
+ * e.g. "git@github.com:org/repo.git" -> "repo"
+ * e.g. "/path/to/my-repo" -> "my-repo"
+ */
+export declare function extractRepoName(urlOrPath?: string, fallbackId?: string): string;
+export declare function getWorkspaceRoot(config?: AppConfig): string;
+/**
+ * Verify that the given path is inside our workspace and the marker file is valid.
+ * This is the ownership guard that must run before any destructive ops.
+ */
+export declare function verifyOwnership(project: ManagedProject): Result<void>;
+export declare function checkLocalRepo(dirPath: string, preferredRemote?: string): Promise<RepoInfo>;
+export declare function resolveProject(sourceRepoPath: string, remote: string | undefined, config: AppConfig): Promise<Result<ManagedProject>>;
+export declare function ensureManagedClone(project: ManagedProject): Promise<Result<{
+    isCached: boolean;
+}>>;
+export declare function releaseLock(project: ManagedProject): void;
+/**
+ * Acquire a file-based lock on the managed checkout.
+ * Returns a release function to call when done.
+ * Checks for and cleans up stale locks from terminated processes.
+ * Waits up to timeoutMs for the lock to become available.
+ */
+export declare function acquireLock(project: ManagedProject, timeoutMs: number): Promise<Result<() => void>>;
+export declare function createWorkspaceManager(): WorkspaceManager;