@samaksh/git-worker 0.0.0-stage → 0.1.0

package/src/services/template/env.ts

@@ -0,0 +1,169 @@
+import { TemplateDocument, TemplateAssignment, Result, EnvEntry, 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: string): Result<TemplateDocument> {
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  const assignments: TemplateAssignment[] = [];
+  const placeholders = new Set<string>();
+  const seenKeys = new Map<string, number>();
+
+  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: string
+): Result<{ map: Map<string, EnvEntry>; lines: string[] }> {
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  const map = new Map<string, EnvEntry>();
+  const seen = new Map<string, number>();
+
+  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: Array<{ branchName: string; content: string }>
+): string {
+  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<string, Map<string, string>>(); // 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: string[] = [
+    "# 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/src/services/template/interpolator.ts

@@ -0,0 +1,109 @@
+import { Result, ok } from "../../core/types.js";
+
+export type TemplateVariable = {
+  name: string;
+  fallback?: string;
+  raw: string;
+};
+
+export type BranchContext = {
+  branchName: string;
+  repoName?: string;
+  commitSha?: string;
+};
+
+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: string): string {
+  return branchName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Extract all ${VAR} and ${VAR:-default} placeholders from template text.
+ */
+export function extractTemplateVariables(templateText: string): TemplateVariable[] {
+  const vars: TemplateVariable[] = [];
+  const seen = new Set<string>();
+
+  VARIABLE_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
+
+  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: string,
+  envMap: Map<string, string>,
+  context: BranchContext
+): Result<{ content: string; missingVars: string[] }> {
+  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<string, string>([
+    ["BRANCH_NAME", branchName],
+    ["BRANCH_SLUG", branchSlug],
+    ["REPO_NAME", repoName],
+    ["COMMIT_SHA", commitSha],
+    ["SHORT_SHA", shortSha],
+  ]);
+
+  const missingSet = new Set<string>();
+
+  VARIABLE_REGEX.lastIndex = 0;
+  const content = templateText.replace(
+    VARIABLE_REGEX,
+    (fullMatch, varName: string, fallback?: string) => {
+      // 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/src/services/template/transform.ts

@@ -0,0 +1,97 @@
+import { TemplateDocument, Result, ok, err } from "../../core/types.js";
+import { templateError } from "../../core/errors.js";
+import { parseEnvFile } from "./env.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 function transformEnv(
+  branchContent: string,
+  template: TemplateDocument,
+  branchValues: Map<string, string>
+): Result<TransformResult> {
+  const parseResult = parseEnvFile(branchContent);
+  if (!parseResult.ok) return parseResult;
+
+  const { map: existingMap, lines } = parseResult.value;
+  const resultLines = [...lines];
+  const updatedKeys: string[] = [];
+  const addedKeys: string[] = [];
+
+  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(): TemplateService {
+  return {
+    transform: transformEnv,
+  };
+}

package/src/services/template/validator.ts

@@ -0,0 +1,75 @@
+import { Result, ok, err } from "../../core/types.js";
+import { templateError } from "../../core/errors.js";
+import { parseEnvTemplate } from "./env.js";
+import yaml from "yaml";
+
+function checkUnclosedDelimiters(content: string): Result<void> {
+  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: string): Result<void> {
+  // 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: any) {
+    return err(templateError(`JSON syntax error: ${e.message}`));
+  }
+}
+
+function validateYaml(content: string): Result<void> {
+  // 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: any) {
+    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: string, content: string): Result<void> {
+  // 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/src/services/workspace/cache.ts

@@ -0,0 +1,144 @@
+import { existsSync } from "fs";
+import { readdir, readFile, rm, mkdir } from "fs/promises";
+import { join } from "path";
+import { Result, ok, err } from "../../core/types.js";
+import { workspaceError } from "../../core/errors.js";
+import { getWorkspaceRoot, 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 async function listCachedProjects(config?: AppConfig): Promise<CachedProjectInfo[]> {
+  const root = getWorkspaceRoot(config);
+  const projectsDir = join(root, "projects");
+
+  if (!existsSync(projectsDir)) {
+    return [];
+  }
+
+  try {
+    const entries = await readdir(projectsDir, { withFileTypes: true });
+    const projects: CachedProjectInfo[] = [];
+
+    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: string,
+  config?: AppConfig
+): Promise<Result<{ removed: string; projectDir: string }>> {
+  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: any) {
+    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?: AppConfig
+): Promise<Result<{ count: number; root: string }>> {
+  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: any) {
+    return err(workspaceError(`Failed to clear cache: ${e.message}`, e));
+  }
+}