golem-cc 2.1.2 → 3.0.0

package/.golem/lib/worktree.mjs

@@ -0,0 +1,509 @@
+import { cp, access, stat, realpath } from 'node:fs/promises';
+import { join, resolve, relative, normalize } from 'node:path';
+import { execSync } from 'node:child_process';
+import { expandTilde, getRepoName } from './config.mjs';
+import { table } from './output.mjs';
+
+/**
+ * Check if a source path should be excluded based on the excludes list.
+ * Matches if the source path starts with any exclude entry (after normalization).
+ */
+function isExcluded(relPath, excludes) {
+  const norm = normalize(relPath).replace(/\/+$/, '');
+  return excludes.some(ex => {
+    const normEx = normalize(ex).replace(/\/+$/, '');
+    return norm === normEx || norm.startsWith(normEx + '/');
+  });
+}
+
+/**
+ * Recursively copy a source to destination, skipping excluded paths.
+ * For files: copy if not excluded.
+ * For directories: walk and copy non-excluded entries.
+ */
+async function copyWithExcludes(src, dest, mainRepoPath, excludes) {
+  const relPath = relative(mainRepoPath, src);
+
+  if (isExcluded(relPath, excludes)) return;
+
+  const info = await stat(src);
+
+  if (info.isFile()) {
+    await cp(src, dest);
+    return;
+  }
+
+  if (info.isDirectory()) {
+    const { readdir, mkdir } = await import('node:fs/promises');
+    await mkdir(dest, { recursive: true });
+    const entries = await readdir(src);
+    for (const entry of entries) {
+      await copyWithExcludes(join(src, entry), join(dest, entry), mainRepoPath, excludes);
+    }
+  }
+}
+
+/**
+ * Bootstrap a worktree by copying configured files and running setup.
+ *
+ * @param {string} worktreePath - Path to the new worktree directory
+ * @param {string} mainRepoPath - Path to the main repository
+ * @param {object} config - Loaded golem config (with worktree defaults merged)
+ */
+export async function bootstrapWorktree(worktreePath, mainRepoPath, config) {
+  const { copies = [], excludes = [], setup = '' } = config.worktree || {};
+
+  // Copy each entry from main repo to worktree
+  for (const entry of copies) {
+    const src = join(mainRepoPath, entry);
+
+    // Skip silently if source doesn't exist
+    try {
+      await access(src);
+    } catch {
+      continue;
+    }
+
+    try {
+      await copyWithExcludes(src, join(worktreePath, entry), mainRepoPath, excludes);
+    } catch (err) {
+      console.warn(`Warning: failed to copy ${entry}: ${err.message}`);
+    }
+  }
+
+  // Run setup command if configured
+  if (setup) {
+    try {
+      execSync(setup, { cwd: worktreePath, stdio: 'inherit' });
+    } catch (err) {
+      console.warn(`Warning: setup command failed: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Check if a git branch exists locally.
+ */
+function branchExists(name, cwd) {
+  try {
+    execSync(`git rev-parse --verify refs/heads/${name}`, { cwd, stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a new git worktree with bootstrap.
+ *
+ * @param {string} name - Branch/worktree name
+ * @param {object} config - Loaded golem config (with worktree defaults merged)
+ * @returns {string} Full path to the created worktree
+ */
+export async function worktreeCreate(name, config) {
+  if (!name) {
+    throw new Error('Worktree name is required. Usage: golem worktree create <name>');
+  }
+
+  const mainRepoPath = process.cwd();
+  const repoName = getRepoName();
+  const baseDir = expandTilde(config.worktree.dir);
+  const worktreePath = join(baseDir, repoName, name);
+
+  if (branchExists(name, mainRepoPath)) {
+    execSync(`git worktree add ${worktreePath} ${name}`, { cwd: mainRepoPath, stdio: 'pipe' });
+  } else {
+    execSync(`git worktree add -b ${name} ${worktreePath}`, { cwd: mainRepoPath, stdio: 'pipe' });
+  }
+
+  await bootstrapWorktree(worktreePath, mainRepoPath, config);
+
+  console.log(worktreePath);
+  return worktreePath;
+}
+
+/**
+ * Parse git worktree list --porcelain output into structured data.
+ *
+ * @param {string} porcelainOutput - Output from `git worktree list --porcelain`
+ * @returns {Array<{path: string, head: string, branch: string}>}
+ */
+function parseWorktreePorcelain(porcelainOutput) {
+  const worktrees = [];
+  const lines = porcelainOutput.trim().split('\n');
+  let current = {};
+
+  for (const line of lines) {
+    if (line.startsWith('worktree ')) {
+      // Start of a new worktree entry
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = { path: line.slice('worktree '.length) };
+    } else if (line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length);
+    } else if (line.startsWith('branch ')) {
+      // Extract branch name from refs/heads/branch-name
+      const fullRef = line.slice('branch '.length);
+      current.branch = fullRef.replace(/^refs\/heads\//, '');
+    } else if (line === '') {
+      // Empty line marks end of an entry
+      if (current.path) {
+        worktrees.push(current);
+        current = {};
+      }
+    }
+  }
+
+  // Push the last entry if it exists
+  if (current.path) {
+    worktrees.push(current);
+  }
+
+  return worktrees;
+}
+
+/**
+ * Resolve a path to its real path, following symlinks.
+ * Returns the original path if it doesn't exist or can't be resolved.
+ */
+async function safeRealpath(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return path;
+  }
+}
+
+/**
+ * Get the repository name from git, even when inside a worktree.
+ * First tries to get the name from the git remote URL.
+ * Falls back to the main worktree directory name.
+ */
+function getRepoNameFromGit() {
+  try {
+    // Try to get from remote URL
+    const remoteUrl = execSync('git remote get-url origin', {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+      encoding: 'utf-8'
+    }).trim();
+    const lastSegment = remoteUrl.split('/').pop();
+    return lastSegment.replace(/\.git$/, '');
+  } catch {
+    // No remote - parse the main worktree path from git worktree list
+    try {
+      const output = execSync('git worktree list --porcelain', {
+        cwd: process.cwd(),
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      });
+
+      // The first worktree entry is always the main one
+      const lines = output.trim().split('\n');
+      for (const line of lines) {
+        if (line.startsWith('worktree ')) {
+          const mainPath = line.slice('worktree '.length);
+          return mainPath.split('/').pop();
+        }
+      }
+
+      // Fallback to getRepoName
+      return getRepoName();
+    } catch {
+      // Not in a git repo - fall back to getRepoName()
+      return getRepoName();
+    }
+  }
+}
+
+/**
+ * List all worktrees for the current repository.
+ *
+ * @param {object} config - Loaded golem config (with worktree defaults merged)
+ * @param {object} opts - Options for display
+ * @param {boolean} opts.display - If true, print a formatted table (default: true)
+ * @returns {Promise<Array<{path: string, head: string, branch: string, current: boolean}>>}
+ */
+export async function worktreeList(config, opts = { display: true }) {
+  const repoName = getRepoNameFromGit();
+  const baseDir = expandTilde(config.worktree.dir);
+
+  // Resolve the base dir to handle symlinks (like /var -> /private/var on macOS)
+  const baseDirResolved = await safeRealpath(baseDir);
+  const expectedPrefix = join(baseDirResolved, repoName);
+  const cwd = await safeRealpath(process.cwd());
+
+  // Get all worktrees
+  let output;
+  try {
+    output = execSync('git worktree list --porcelain', {
+      cwd: process.cwd(),
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    throw new Error(`Failed to list worktrees: ${err.message}`);
+  }
+
+  // Parse the porcelain output
+  const allWorktrees = parseWorktreePorcelain(output);
+
+  // Filter to only worktrees under the configured directory for this repo
+  const filtered = allWorktrees.filter(wt =>
+    wt.path.startsWith(expectedPrefix)
+  );
+
+  // Mark the current worktree if we're inside one
+  for (const wt of filtered) {
+    wt.current = cwd.startsWith(wt.path);
+  }
+
+  // Display formatted table if requested
+  if (opts.display) {
+    if (filtered.length === 0) {
+      console.log('No worktrees found.');
+    } else {
+      const rows = filtered.map(wt => [
+        wt.current ? '* ' + wt.branch : wt.branch,
+        wt.path,
+        wt.head.slice(0, 7),
+      ]);
+      table(['Branch', 'Path', 'HEAD'], rows);
+    }
+  }
+
+  return filtered;
+}
+
+/**
+ * Detect if the current working directory is inside a git worktree.
+ * Inside a worktree, --git-common-dir and --git-dir differ.
+ *
+ * @param {string} cwd - Directory to check
+ * @returns {{ isWorktree: boolean, gitCommonDir: string|null, gitDir: string|null }}
+ */
+function detectWorktree(cwd) {
+  try {
+    const gitDir = execSync('git rev-parse --git-dir', {
+      cwd, stdio: 'pipe', encoding: 'utf-8',
+    }).trim();
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd, stdio: 'pipe', encoding: 'utf-8',
+    }).trim();
+    // Inside a worktree, gitDir is something like /path/to/.git/worktrees/<name>
+    // while gitCommonDir is /path/to/.git — they differ.
+    // In the main repo, both resolve to .git (or the same absolute path).
+    // Use resolve() to handle both relative and absolute paths from git.
+    const resolvedDir = resolve(cwd, gitDir);
+    const resolvedCommon = resolve(cwd, gitCommonDir);
+    return {
+      isWorktree: resolvedDir !== resolvedCommon,
+      gitCommonDir: resolvedCommon,
+      gitDir: resolvedDir,
+    };
+  } catch {
+    return { isWorktree: false, gitCommonDir: null, gitDir: null };
+  }
+}
+
+/**
+ * Detect the default branch name (main or master).
+ *
+ * @param {string} cwd - Directory to run git commands in
+ * @returns {string} The default branch name
+ */
+function detectDefaultBranch(cwd) {
+  // Check if 'main' exists
+  try {
+    execSync('git rev-parse --verify refs/heads/main', { cwd, stdio: 'pipe' });
+    return 'main';
+  } catch {
+    // fall through
+  }
+  // Check if 'master' exists
+  try {
+    execSync('git rev-parse --verify refs/heads/master', { cwd, stdio: 'pipe' });
+    return 'master';
+  } catch {
+    // fall through
+  }
+  throw new Error('Could not detect default branch (neither main nor master found).');
+}
+
+/**
+ * Merge the current worktree branch back into the default branch.
+ * Must be run from inside a worktree — fails with clear error otherwise.
+ *
+ * Steps:
+ * 1. Stage and commit any uncommitted changes
+ * 2. Save branch name and worktree path
+ * 3. Navigate to main repo via git-common-dir/..
+ * 4. Remove the worktree (branch/commits survive in .git)
+ * 5. Rebase branch onto default branch
+ * 6. Switch to default branch
+ * 7. Fast-forward merge the branch
+ * 8. Delete the branch
+ *
+ * If rebase fails, stops and prints instructions. Branch and commits are safe.
+ */
+export async function worktreeMerge() {
+  const cwd = process.cwd();
+
+  // Step 0: Detect if we're inside a worktree
+  const { isWorktree, gitCommonDir } = detectWorktree(cwd);
+  if (!isWorktree) {
+    throw new Error(
+      'Not inside a worktree. Run this command from inside a worktree directory.'
+    );
+  }
+
+  // Step 1: Stage and commit any uncommitted changes
+  const status = execSync('git status --porcelain', {
+    cwd, stdio: 'pipe', encoding: 'utf-8',
+  }).trim();
+
+  if (status) {
+    execSync('git add -A', { cwd, stdio: 'pipe' });
+    execSync('git commit -m "wip: uncommitted changes before merge"', {
+      cwd, stdio: 'pipe',
+    });
+  }
+
+  // Step 2: Save branch name and worktree path
+  const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+    cwd, stdio: 'pipe', encoding: 'utf-8',
+  }).trim();
+
+  const worktreePath = execSync('git rev-parse --show-toplevel', {
+    cwd, stdio: 'pipe', encoding: 'utf-8',
+  }).trim();
+
+  // Step 3: Navigate to main repo via git-common-dir/..
+  const mainRepoPath = resolve(gitCommonDir, '..');
+
+  // Step 4: Remove the worktree (branch and commits are safe in .git)
+  execSync(`git worktree remove ${worktreePath}`, {
+    cwd: mainRepoPath, stdio: 'pipe',
+  });
+
+  // Step 5: Detect default branch and rebase
+  const defaultBranch = detectDefaultBranch(mainRepoPath);
+
+  try {
+    execSync(`git rebase ${defaultBranch} ${branch}`, {
+      cwd: mainRepoPath, stdio: 'pipe',
+    });
+  } catch {
+    // Abort the failed rebase so git is clean
+    try {
+      execSync('git rebase --abort', { cwd: mainRepoPath, stdio: 'pipe' });
+    } catch {
+      // rebase --abort may fail if there's nothing to abort
+    }
+    throw new Error(
+      `Rebase of '${branch}' onto '${defaultBranch}' failed due to conflicts.\n` +
+      `Your branch '${branch}' and all commits are safe.\n` +
+      `The worktree has been removed, but you can resolve from the main repo:\n\n` +
+      `  cd ${mainRepoPath}\n` +
+      `  git rebase ${defaultBranch} ${branch}\n` +
+      `  # resolve conflicts, then:\n` +
+      `  git rebase --continue\n` +
+      `  git switch ${defaultBranch}\n` +
+      `  git merge --ff-only ${branch}\n` +
+      `  git branch -d ${branch}`
+    );
+  }
+
+  // Step 6: Switch to default branch
+  execSync(`git switch ${defaultBranch}`, {
+    cwd: mainRepoPath, stdio: 'pipe',
+  });
+
+  // Step 7: Fast-forward merge
+  execSync(`git merge --ff-only ${branch}`, {
+    cwd: mainRepoPath, stdio: 'pipe',
+  });
+
+  // Step 8: Delete the branch
+  execSync(`git branch -d ${branch}`, {
+    cwd: mainRepoPath, stdio: 'pipe',
+  });
+
+  return { branch, defaultBranch, mainRepoPath };
+}
+
+/**
+ * Remove a worktree and delete its branch without merging.
+ * Used for abandoned work.
+ *
+ * @param {string} name - Name of the worktree/branch to remove
+ * @param {object} config - Loaded golem config (with worktree defaults merged)
+ * @returns {Promise<{path: string, branch: string}>}
+ */
+export async function worktreeRemove(name, config) {
+  if (!name) {
+    throw new Error('Worktree name is required. Usage: golem worktree remove <name>');
+  }
+
+  const mainRepoPath = process.cwd();
+  const repoName = getRepoName();
+  const baseDir = expandTilde(config.worktree.dir);
+  const worktreePath = join(baseDir, repoName, name);
+
+  // Resolve both paths to handle symlinks (like /var -> /private/var on macOS)
+  const worktreePathResolved = await safeRealpath(worktreePath);
+
+  // Check if the worktree exists
+  let worktreeList;
+  try {
+    worktreeList = execSync('git worktree list --porcelain', {
+      cwd: mainRepoPath,
+      encoding: 'utf-8',
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    throw new Error(`Failed to list worktrees: ${err.message}`);
+  }
+
+  const worktrees = parseWorktreePorcelain(worktreeList);
+
+  // Resolve all worktree paths and compare
+  const resolvedWorktrees = await Promise.all(
+    worktrees.map(async wt => ({
+      ...wt,
+      resolvedPath: await safeRealpath(wt.path)
+    }))
+  );
+
+  const exists = resolvedWorktrees.some(wt =>
+    wt.resolvedPath === worktreePathResolved || wt.path === worktreePath
+  );
+
+  if (!exists) {
+    throw new Error(`Worktree '${name}' does not exist at ${worktreePath}`);
+  }
+
+  // Remove the worktree
+  try {
+    execSync(`git worktree remove ${worktreePath}`, {
+      cwd: mainRepoPath,
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    throw new Error(`Failed to remove worktree: ${err.message}`);
+  }
+
+  // Delete the branch with -D (force delete, in case it's not merged)
+  try {
+    execSync(`git branch -D ${name}`, {
+      cwd: mainRepoPath,
+      stdio: 'pipe',
+    });
+  } catch (err) {
+    // If branch deletion fails, warn but don't fail the whole operation
+    console.warn(`Warning: failed to delete branch '${name}': ${err.message}`);
+  }
+
+  return { path: worktreePath, branch: name };
+}

package/.golem/prompts/build.md

@@ -0,0 +1,23 @@
+You are an autonomous coding agent working on a single task. You have fresh context — assume no prior knowledge of this codebase.
+
+## Instructions
+
+1. Read `.golem/AGENTS.md` for test, build, and lint commands
+2. Read ALL relevant spec files in `.golem/specs/`
+3. Investigate the codebase — read existing code that's related to your task
+4. Implement the task described below
+5. Run ALL validation gates:
+   - Test command from AGENTS.md
+   - Type checking (if applicable)
+   - Lint (if applicable)
+6. Fix any failures before reporting success
+
+## Rules
+
+- Do NOT commit changes (the orchestrator handles git)
+- Do NOT modify `.golem/IMPLEMENTATION_PLAN.md`
+- Do NOT modify files outside the project directory
+- Keep changes minimal and focused on the task
+- Follow existing code patterns and conventions
+- If tests fail, fix them — do not skip or disable tests
+- If you can't complete the task, explain why clearly

package/.golem/prompts/document-inline.md

@@ -0,0 +1,66 @@
+You are a documentation agent. Your job is to add inline documentation to source files following the conventions of the detected project type.
+
+## Project Type
+
+{{PROJECT_TYPE}}
+
+## Documentation Standards by Type
+
+### JavaScript (JSDoc)
+- Use `/** ... */` block comments on functions, classes, and non-obvious exports
+- Include `@param`, `@returns`, and `@throws` tags where meaningful
+- File header: `/** @file <description of the file's role in the system> */`
+
+### TypeScript (TSDoc)
+- Use `/** ... */` block comments on functions, classes, interfaces, and type aliases
+- Include `@param`, `@returns`, `@throws`, and `@example` tags on public API functions
+- File header: `/** @file <description of the file's role in the system> */`
+
+### Python (Google-style docstrings)
+- Use triple-quoted Google-style docstrings on modules, classes, and functions
+- Include Args, Returns, Raises sections where meaningful
+- Module docstring at the top of every file explaining its purpose
+
+### SQL (comment blocks)
+- Use `--` comment blocks above tables, columns, constraints, stored procedures, and views
+- Group related comments into header blocks for each object
+- Explain relationships, constraints, and non-obvious column purposes
+
+### Vue / Nuxt SFCs
+- `<script>`: JSDoc or TSDoc depending on language (JS or TS)
+- `<template>`: `<!-- ... -->` comments for non-obvious markup, conditional rendering logic, and slot usage
+- `<style>`: `/* ... */` comments for non-obvious selectors, layout tricks, and overrides
+
+### React / Next
+- JSDoc or TSDoc depending on language (JS or TS)
+- Document prop types and their purpose on component functions
+- Document hooks, context providers, and non-obvious rendering logic
+
+## Rules
+
+1. **Document non-obvious functions** — if a function's name and signature don't fully explain what it does, why it exists, or what side effects it has, add documentation
+2. **Add file headers** — every source file gets a header comment explaining what the file does and its role in the system
+3. **Educational tone** — write documentation so someone new to the codebase can learn from it; explain the "why", not just the "what"
+4. **Skip trivial one-liners** — simple getters, identity functions, and self-documenting one-line arrow functions don't need docs unless they have non-obvious side effects
+5. **Update stale docs** — if existing documentation doesn't match current code behavior, update it; stale docs are worse than no docs
+6. **Preserve accurate docs** — don't rewrite documentation that is already correct and clear
+7. **Don't change behavior** — documentation only; never modify logic, add type annotations to JS files, or alter control flow
+8. **Don't restate signatures** — `@param name - the name` adds no value; describe what the parameter controls or why it matters
+9. **Document complex logic inline** — non-obvious conditionals, "why" decisions, and tricky control flow get inline comments where they occur
+10. **Don't touch excluded files** — skip test files, generated files, lock files, node_modules, dist/, and minified/bundled output
+
+## Target Files
+
+{{FILES}}
+
+## Process
+
+For each file:
+1. Read the file
+2. Determine the correct documentation standard from the project type
+3. Add file header if missing
+4. Document non-obvious functions, classes, and exports
+5. Update any stale existing documentation
+6. Add inline comments for complex logic
+7. For Vue SFCs: cover `<template>` and `<style>` sections too
+8. Move to the next file

package/.golem/prompts/document-markdown.md

@@ -0,0 +1,80 @@
+You are a documentation agent. Your job is to generate and update project-level markdown documentation files.
+
+## Output Directory
+
+{{DOCS_PATH}}
+
+## Project Structure
+
+{{PROJECT_STRUCTURE}}
+
+## Directory Layout
+
+Generate the following structure under the docs path. Only create files for things that actually exist in the codebase — never create empty placeholders.
+
+```
+{docsPath}/
+  index.md              — project overview
+  architecture.md       — system design, how components connect
+  getting-started.md    — setup, install, prerequisites, first run
+  configuration.md      — all config options with explanations
+  modules/
+    {module-name}.md    — one per major module or component
+  api/
+    {resource}.md       — API reference (if project has endpoints)
+  database/
+    schema.md           — full schema overview with relationships
+    {table-name}.md     — per-table docs (columns, types, constraints, purpose)
+  guides/
+    setup.md            — dev environment setup
+    {workflow}.md       — project-specific how-to walkthroughs
+  deprecated/
+    {old-thing}.md      — archived docs with deprecation date and replacement notes
+```
+
+## Frontmatter
+
+Every markdown file must include YAML frontmatter with these fields:
+
+```yaml
+---
+title: "Page Title"
+description: "Brief description of what this page covers"
+navigation:
+  order: 1
+---
+```
+
+Use `navigation.order` to control page ordering within each directory. Start at 1 and increment.
+
+## Rules
+
+1. **Use CommonMark only** — no platform-specific markdown extensions (no GitHub admonitions, no MDX unless the project uses it)
+2. **No empty placeholders** — only create docs for modules, APIs, tables, and guides that actually exist in the codebase
+3. **Never delete existing docs** — if a documented module has been removed from the codebase, move its doc to `{docsPath}/deprecated/` with a `deprecated_date` frontmatter field and notes on what replaced it
+4. **Architecture overview** — include a text-based diagram or structured description showing how major components connect
+5. **Module docs from source** — generate one doc per major module explaining purpose, exports, dependencies, and usage; reference file paths, don't dump source code
+6. **Database docs from files** — generate schema docs from migration files, ORM definitions (Prisma, Drizzle, Knex, SQLAlchemy, Alembic), or raw SQL files in the repo; no live database connection
+7. **Relationship descriptions** — document foreign keys, one-to-many, and other relationships in plain language
+8. **Getting-started guide** — use actual project commands, config values, and file paths; not generic boilerplate
+9. **Guides section** — generate project-specific how-tos based on detected workflows (e.g., "How to add a new API endpoint" if the project has an API layer)
+10. **Cross-link related docs** — module docs link to the API docs that expose them, database docs link to the modules that query them
+11. **Don't include source code dumps** — explain behavior and usage, reference file paths for code
+12. **README.md** — generate or update the project root README with project name, description, quick start, and links into the docs directory
+13. **CHANGELOG.md** — generate from git history in plain, non-technical language for managers and non-developers; group by date with sections: New Features, Improvements, Bug Fixes; no jargon
+
+## Process
+
+1. Read the project structure to understand what modules, APIs, database schemas, and configs exist
+2. Create the docs directory structure
+3. Generate `index.md` with project overview
+4. Generate `architecture.md` with system design and component relationships
+5. Generate `getting-started.md` with actual setup instructions
+6. Generate `configuration.md` documenting all config options
+7. Generate module docs for each major module
+8. Generate API docs if the project has endpoints
+9. Generate database docs if schema/migration files exist
+10. Generate guides based on detected project workflows
+11. Move docs for removed modules to `deprecated/`
+12. Update `README.md` at project root
+13. Generate `CHANGELOG.md` from git history