@aaronshaf/ger 3.0.2 → 4.0.0

package/src/cli/commands/setup.ts

@@ -193,11 +193,8 @@ const setupEffect = (configService: ConfigServiceImpl) =>
                   console.log(chalk.dim(`Detected AI tools: ${availableTools.join(', ')}`))
                 }
 
-                // Get default suggestion
-                const defaultCommand =
-                  existingConfig?.aiTool ||
-                  (availableTools.includes('claude') ? 'claude' : availableTools[0]) ||
-                  ''
+                // Get default suggestion — no default to claude
+                const defaultCommand = existingConfig?.aiTool || (availableTools[0] ?? '')
 
                 // AI tool command with smart default
                 const aiToolCommand = await input({
@@ -205,7 +202,20 @@ const setupEffect = (configService: ConfigServiceImpl) =>
                     availableTools.length > 0
                       ? 'AI tool command (detected from system)'
                       : 'AI tool command (e.g., claude, llm, opencode, gemini)',
-                  default: defaultCommand || 'claude',
+                  default: defaultCommand || undefined,
+                })
+
+                console.log('')
+                console.log(chalk.yellow('Optional: CI Retrigger'))
+                console.log(
+                  chalk.dim(
+                    'Comment to post when triggering a CI build (e.g. a magic trigger string your CI watches for)',
+                  ),
+                )
+
+                const retriggerComment = await input({
+                  message: 'CI retrigger comment (leave blank to skip)',
+                  default: existingConfig?.retriggerComment ?? undefined,
                 })
 
                 // Build flat config
@@ -217,6 +227,9 @@ const setupEffect = (configService: ConfigServiceImpl) =>
                     aiTool: aiToolCommand,
                   }),
                   aiAutoDetect: !aiToolCommand,
+                  ...(retriggerComment.trim() && {
+                    retriggerComment: retriggerComment.trim(),
+                  }),
                 }
 
                 // Validate config using Schema instead of type assertion

package/src/cli/commands/tree-cleanup.ts

@@ -0,0 +1,139 @@
+import { spawnSync, execSync } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import chalk from 'chalk'
+
+export interface TreeCleanupOptions {
+  xml?: boolean
+  json?: boolean
+  force?: boolean
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const getRepoRoot = (): string =>
+  execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim()
+
+const getGerWorktrees = (repoRoot: string): string[] => {
+  const gerDir = path.join(repoRoot, '.ger')
+  if (!fs.existsSync(gerDir)) return []
+  try {
+    return fs
+      .readdirSync(gerDir)
+      .filter((name) => /^\d+$/.test(name))
+      .map((name) => path.join(gerDir, name))
+      .filter((p) => fs.statSync(p).isDirectory())
+  } catch {
+    return []
+  }
+}
+
+const removeWorktree = (worktreePath: string, repoRoot: string, force: boolean): boolean => {
+  const args = force
+    ? ['worktree', 'remove', '--force', worktreePath]
+    : ['worktree', 'remove', worktreePath]
+
+  const result = spawnSync('git', args, { encoding: 'utf8', cwd: repoRoot })
+  return result.status === 0
+}
+
+export const treeCleanupCommand = (
+  changeId: string | undefined,
+  options: TreeCleanupOptions,
+): Effect.Effect<void, Error, never> =>
+  Effect.sync(() => {
+    if (!isInGitRepo()) {
+      throw new Error('Not in a git repository')
+    }
+
+    const repoRoot = getRepoRoot()
+
+    let targets: string[]
+
+    if (changeId !== undefined) {
+      if (!/^\d+$/.test(changeId))
+        throw new Error(`Invalid change ID: ${changeId} (must be a numeric change number)`)
+      const worktreePath = path.join(repoRoot, '.ger', changeId)
+      if (!fs.existsSync(worktreePath)) {
+        throw new Error(`No worktree found for change ${changeId}`)
+      }
+      targets = [worktreePath]
+    } else {
+      targets = getGerWorktrees(repoRoot)
+      if (targets.length === 0) {
+        if (options.json) {
+          console.log(JSON.stringify({ status: 'success', removed: [] }, null, 2))
+        } else if (options.xml) {
+          console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+          console.log(`<tree_cleanup>`)
+          console.log(`  <status>success</status>`)
+          console.log(`  <removed></removed>`)
+          console.log(`</tree_cleanup>`)
+        } else {
+          console.log(chalk.dim('  No ger-managed worktrees to clean up'))
+        }
+        return
+      }
+    }
+
+    const removed: string[] = []
+    const failed: string[] = []
+
+    for (const worktreePath of targets) {
+      if (!options.xml && !options.json) {
+        console.log(chalk.dim(`  Removing ${worktreePath}...`))
+      }
+
+      const ok = removeWorktree(worktreePath, repoRoot, options.force ?? false)
+      if (ok) {
+        removed.push(worktreePath)
+      } else {
+        failed.push(worktreePath)
+        if (!options.xml && !options.json) {
+          console.log(
+            chalk.yellow(
+              `  Warning: Could not remove ${worktreePath} (uncommitted changes? use --force)`,
+            ),
+          )
+        }
+      }
+    }
+
+    // Clean up stale worktree metadata
+    spawnSync('git', ['worktree', 'prune'], { encoding: 'utf8', cwd: repoRoot })
+
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'success', removed, failed }, null, 2))
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<tree_cleanup>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <removed>`)
+      for (const p of removed) {
+        console.log(`    <path><![CDATA[${p}]]></path>`)
+      }
+      console.log(`  </removed>`)
+      console.log(`  <failed>`)
+      for (const p of failed) {
+        console.log(`    <path><![CDATA[${p}]]></path>`)
+      }
+      console.log(`  </failed>`)
+      console.log(`</tree_cleanup>`)
+    } else {
+      if (removed.length > 0) {
+        console.log(
+          chalk.green(`\n  ✓ Removed ${removed.length} worktree${removed.length !== 1 ? 's' : ''}`),
+        )
+      } else {
+        console.log(chalk.yellow('  No worktrees were removed'))
+      }
+    }
+  })

package/src/cli/commands/tree-rebase.ts

@@ -0,0 +1,168 @@
+import { spawnSync, execSync } from 'node:child_process'
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import chalk from 'chalk'
+import { ConfigService, type ConfigError, type ConfigServiceImpl } from '@/services/config'
+
+export interface TreeRebaseOptions {
+  onto?: string
+  interactive?: boolean
+  xml?: boolean
+  json?: boolean
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const getRepoRoot = (): string =>
+  execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim()
+
+const getCwd = (): string => process.cwd()
+
+/** Returns the remote name for the given Gerrit host, or null if not found. */
+const findMatchingRemote = (repoRoot: string, gerritHost: string): string | null => {
+  try {
+    const output = execSync('git remote -v', { encoding: 'utf8', cwd: repoRoot })
+    const gerritHostname = new URL(gerritHost).hostname
+    for (const line of output.split('\n')) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+      if (!match) continue
+      const url = match[2]
+      try {
+        let remoteHostname: string
+        if (url.startsWith('git@')) {
+          remoteHostname = url.split('@')[1].split(':')[0]
+        } else {
+          remoteHostname = new URL(url).hostname
+        }
+        if (remoteHostname === gerritHostname) return match[1]
+      } catch {
+        // ignore malformed URLs
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return null
+}
+
+const detectBaseBranch = (remote: string): string => {
+  // Prefer upstream tracking branch
+  try {
+    const upstream = execSync('git rev-parse --abbrev-ref HEAD@{u}', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    if (upstream && !upstream.includes('@{u}')) return upstream
+  } catch {
+    // no upstream set
+  }
+
+  // Fall back to <remote>/main, then <remote>/master
+  for (const branch of [`${remote}/main`, `${remote}/master`]) {
+    try {
+      execSync(`git rev-parse --verify ${branch}`, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      })
+      return branch
+    } catch {
+      // try next
+    }
+  }
+
+  return `${remote}/main`
+}
+
+/** Verify the current directory is inside a ger-managed worktree (.ger/<number>). */
+const assertInGerWorktree = (repoRoot: string): void => {
+  const cwd = getCwd()
+  const gerDir = path.join(repoRoot, '.ger') + path.sep
+  if (!cwd.startsWith(gerDir)) {
+    throw new Error(
+      `Not inside a ger-managed worktree.\nRun "ger tree setup <change-id>" first, then cd into the worktree.`,
+    )
+  }
+  // The segment after .ger/ should be a numeric change number
+  const rel = cwd.slice(gerDir.length)
+  const changeNum = rel.split(path.sep)[0]
+  if (!/^\d+$/.test(changeNum)) {
+    throw new Error(`Current directory does not look like a ger worktree: ${cwd}`)
+  }
+}
+
+export const treeRebaseCommand = (
+  options: TreeRebaseOptions,
+  // Optional: override gerrit host for testing
+  _gerritHostOverride?: string,
+): Effect.Effect<void, Error | ConfigError, ConfigServiceImpl> =>
+  Effect.gen(function* () {
+    const configService = yield* ConfigService
+    const credentials = yield* configService.getCredentials.pipe(Effect.mapError((e): Error => e))
+    const gerritHost = _gerritHostOverride ?? credentials.host
+
+    if (!isInGitRepo()) {
+      throw new Error('Not in a git repository')
+    }
+
+    const repoRoot = getRepoRoot()
+
+    // Only allow running from inside a ger-managed worktree
+    assertInGerWorktree(repoRoot)
+
+    // Resolve the correct remote matching the configured Gerrit host
+    const remote = findMatchingRemote(repoRoot, gerritHost) ?? 'origin'
+
+    yield* Effect.try({
+      try: () => {
+        const baseBranch = options.onto ?? detectBaseBranch(remote)
+
+        if (!options.xml && !options.json) {
+          console.log(chalk.bold(`Rebasing onto ${chalk.cyan(baseBranch)}...`))
+          console.log(chalk.dim(`  Fetching ${remote}...`))
+        }
+
+        const fetchResult = spawnSync('git', ['fetch', remote], { encoding: 'utf8', cwd: repoRoot })
+        if (fetchResult.status !== 0) {
+          throw new Error(`Failed to fetch ${remote}: ${fetchResult.stderr}`)
+        }
+
+        if (!options.xml && !options.json) {
+          console.log(chalk.dim(`  Running git rebase ${baseBranch}...`))
+        }
+
+        const rebaseArgs = options.interactive
+          ? ['rebase', '-i', baseBranch]
+          : ['rebase', baseBranch]
+        const rebaseResult = spawnSync('git', rebaseArgs, {
+          encoding: 'utf8',
+          stdio: 'inherit',
+        })
+
+        if (rebaseResult.status !== 0) {
+          throw new Error(
+            `Rebase failed. Resolve conflicts then run:\n  git rebase --continue\nor abort with:\n  git rebase --abort`,
+          )
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify({ status: 'success', base: baseBranch }, null, 2))
+        } else if (options.xml) {
+          console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+          console.log(`<tree_rebase>`)
+          console.log(`  <status>success</status>`)
+          console.log(`  <base><![CDATA[${baseBranch}]]></base>`)
+          console.log(`</tree_rebase>`)
+        } else {
+          console.log(chalk.green('\n  ✓ Rebase complete'))
+        }
+      },
+      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+    })
+  })

package/src/cli/commands/tree-setup.ts

@@ -0,0 +1,202 @@
+import { spawnSync, execSync } from 'node:child_process'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { Effect } from 'effect'
+import chalk from 'chalk'
+import { type ApiError, GerritApiService, type GerritApiServiceImpl } from '@/api/gerrit'
+import { type ConfigError, ConfigService, type ConfigServiceImpl } from '@/services/config'
+
+export const TREE_SETUP_HELP_TEXT = `
+Examples:
+  # Set up worktree for latest patchset
+  $ ger tree setup 12345
+
+  # Set up worktree for specific patchset
+  $ ger tree setup 12345:3
+
+  # XML output (for LLM pipelines)
+  $ ger tree setup 12345 --xml
+
+Notes:
+  - Worktree is created at <repo-root>/.ger/<change-number>/
+  - If worktree already exists, prints the path and exits
+  - Use 'ger trees' to list worktrees, 'ger tree cleanup' to remove them`
+
+export interface TreeSetupOptions {
+  xml?: boolean
+  json?: boolean
+}
+
+const parseChangeSpec = (changeSpec: string): { changeId: string; patchset?: string } => {
+  const parts = changeSpec.split(':')
+  return { changeId: parts[0], patchset: parts[1] }
+}
+
+const getGitRemotes = (): Record<string, string> => {
+  try {
+    const output = execSync('git remote -v', { encoding: 'utf8' })
+    const remotes: Record<string, string> = {}
+    for (const line of output.split('\n')) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+      if (match) remotes[match[1]] = match[2]
+    }
+    return remotes
+  } catch {
+    return {}
+  }
+}
+
+const findMatchingRemote = (gerritHost: string): string | null => {
+  const remotes = getGitRemotes()
+  const gerritUrl = new URL(gerritHost)
+  const gerritHostname = gerritUrl.hostname
+  for (const [name, url] of Object.entries(remotes)) {
+    try {
+      let remoteHostname: string
+      if (url.startsWith('git@')) {
+        remoteHostname = url.split('@')[1].split(':')[0]
+      } else if (url.includes('://')) {
+        remoteHostname = new URL(url).hostname
+      } else {
+        continue
+      }
+      if (remoteHostname === gerritHostname) return name
+    } catch {
+      // ignore malformed URLs
+    }
+  }
+  return null
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+const getRepoRoot = (): string => {
+  try {
+    return execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim()
+  } catch {
+    throw new Error('Not in a git repository')
+  }
+}
+
+export const treeSetupCommand = (
+  changeSpec: string,
+  options: TreeSetupOptions,
+): Effect.Effect<void, ApiError | ConfigError | Error, GerritApiServiceImpl | ConfigServiceImpl> =>
+  Effect.gen(function* () {
+    if (!isInGitRepo()) {
+      throw new Error(
+        'Not in a git repository. Please run this command from within a git repository.',
+      )
+    }
+
+    const repoRoot = getRepoRoot()
+    const { changeId, patchset } = parseChangeSpec(changeSpec)
+
+    const configService = yield* ConfigService
+    const credentials = yield* configService.getCredentials
+    const matchingRemote = findMatchingRemote(credentials.host)
+
+    if (!matchingRemote) {
+      throw new Error(`No git remote found matching Gerrit host: ${credentials.host}`)
+    }
+
+    if (!options.xml && !options.json) {
+      console.log(chalk.bold(`Setting up worktree for change ${chalk.cyan(changeId)}...`))
+    }
+
+    const gerritApi = yield* GerritApiService
+    const change = yield* gerritApi.getChange(changeId)
+
+    if (!options.xml && !options.json) {
+      console.log(chalk.dim(`  ${change._number}: ${change.subject}`))
+    }
+
+    const targetPatchset = patchset ?? 'current'
+    const revision = yield* gerritApi.getRevision(changeId, targetPatchset)
+
+    const workspaceName = change._number.toString()
+    if (!/^\d+$/.test(workspaceName)) {
+      throw new Error(`Invalid change number: ${workspaceName}`)
+    }
+    const worktreeDir = path.join(repoRoot, '.ger', workspaceName)
+
+    if (fs.existsSync(worktreeDir)) {
+      if (options.json) {
+        console.log(JSON.stringify({ status: 'success', path: worktreeDir, exists: true }, null, 2))
+      } else if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<tree_setup>`)
+        console.log(`  <path>${worktreeDir}</path>`)
+        console.log(`  <exists>true</exists>`)
+        console.log(`</tree_setup>`)
+      } else {
+        console.log(chalk.yellow('  Worktree already exists'))
+        console.log(`\n  ${chalk.bold('cd')} ${chalk.green(worktreeDir)}`)
+      }
+      return
+    }
+
+    const gerDir = path.join(repoRoot, '.ger')
+    if (!fs.existsSync(gerDir)) {
+      fs.mkdirSync(gerDir, { recursive: true })
+    }
+
+    const changeRef = revision.ref
+    if (!options.xml && !options.json) {
+      console.log(chalk.dim(`  Fetching ${changeRef}...`))
+    }
+
+    const fetchResult = spawnSync('git', ['fetch', matchingRemote, changeRef], {
+      encoding: 'utf8',
+      cwd: repoRoot,
+    })
+    if (fetchResult.status !== 0) {
+      throw new Error(fetchResult.stderr ?? 'Git fetch failed')
+    }
+
+    if (!options.xml && !options.json) {
+      console.log(chalk.dim(`  Creating worktree...`))
+    }
+
+    const worktreeResult = spawnSync('git', ['worktree', 'add', worktreeDir, 'FETCH_HEAD'], {
+      encoding: 'utf8',
+      cwd: repoRoot,
+    })
+    if (worktreeResult.status !== 0) {
+      throw new Error(worktreeResult.stderr ?? 'Git worktree add failed')
+    }
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'success',
+            path: worktreeDir,
+            change_number: change._number,
+            subject: change.subject,
+            created: true,
+          },
+          null,
+          2,
+        ),
+      )
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<tree_setup>`)
+      console.log(`  <path>${worktreeDir}</path>`)
+      console.log(`  <change_number>${change._number}</change_number>`)
+      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+      console.log(`  <created>true</created>`)
+      console.log(`</tree_setup>`)
+    } else {
+      console.log(chalk.green('\n  ✓ Worktree ready'))
+      console.log(`\n  ${chalk.bold('cd')} ${chalk.green(worktreeDir)}`)
+    }
+  })

package/src/cli/commands/trees.ts

@@ -0,0 +1,107 @@
+import { execSync } from 'node:child_process'
+import { Effect } from 'effect'
+import chalk from 'chalk'
+
+export interface TreesOptions {
+  xml?: boolean
+  json?: boolean
+  all?: boolean
+}
+
+interface WorktreeEntry {
+  path: string
+  head: string
+  branch: string | null
+  isDetached: boolean
+  isGerManaged: boolean
+}
+
+const parseWorktreeList = (output: string): WorktreeEntry[] => {
+  const entries: WorktreeEntry[] = []
+  const blocks = output.trim().split('\n\n')
+
+  for (const block of blocks) {
+    const lines = block.trim().split('\n')
+    const pathLine = lines.find((l) => l.startsWith('worktree '))
+    const headLine = lines.find((l) => l.startsWith('HEAD '))
+    const branchLine = lines.find((l) => l.startsWith('branch '))
+    const isDetached = lines.some((l) => l === 'detached')
+
+    if (!pathLine) continue
+
+    const worktreePath = pathLine.slice('worktree '.length)
+    const head = headLine ? headLine.slice('HEAD '.length) : ''
+    const rawBranch = branchLine ? branchLine.slice('branch '.length) : null
+    const branch = rawBranch ? rawBranch.replace('refs/heads/', '') : null
+
+    entries.push({
+      path: worktreePath,
+      head: head.slice(0, 7),
+      branch,
+      isDetached,
+      isGerManaged: worktreePath.includes('/.ger/'),
+    })
+  }
+
+  return entries
+}
+
+const isInGitRepo = (): boolean => {
+  try {
+    execSync('git rev-parse --git-dir', { encoding: 'utf8' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const treesCommand = (options: TreesOptions): Effect.Effect<void, Error, never> =>
+  Effect.sync(() => {
+    if (!isInGitRepo()) {
+      throw new Error('Not in a git repository')
+    }
+
+    let output: string
+    try {
+      output = execSync('git worktree list --porcelain', { encoding: 'utf8' })
+    } catch {
+      throw new Error('Failed to list worktrees')
+    }
+
+    const all = parseWorktreeList(output)
+    const entries = options.all ? all : all.filter((e) => e.isGerManaged)
+
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'success', worktrees: entries }, null, 2))
+      return
+    }
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<worktrees>`)
+      for (const entry of entries) {
+        console.log(`  <worktree>`)
+        console.log(`    <path><![CDATA[${entry.path}]]></path>`)
+        console.log(`    <head>${entry.head}</head>`)
+        if (entry.branch) console.log(`    <branch><![CDATA[${entry.branch}]]></branch>`)
+        console.log(`    <detached>${entry.isDetached}</detached>`)
+        console.log(`    <ger_managed>${entry.isGerManaged}</ger_managed>`)
+        console.log(`  </worktree>`)
+      }
+      console.log(`</worktrees>`)
+      return
+    }
+
+    if (entries.length === 0) {
+      console.log(chalk.dim('  No ger-managed worktrees found'))
+      console.log(chalk.dim(`  Use ${chalk.white('ger tree setup <change-id>')} to create one`))
+      return
+    }
+
+    console.log(chalk.bold('Worktrees:'))
+    for (const entry of entries) {
+      const branchInfo = entry.branch ? chalk.yellow(entry.branch) : chalk.dim('detached HEAD')
+      console.log(`  ${chalk.green(entry.path)}`)
+      console.log(`    ${chalk.dim(entry.head)} ${branchInfo}`)
+    }
+  })