@aaronshaf/ger 3.0.2 → 4.0.0

package/src/cli/commands/update.ts

@@ -0,0 +1,73 @@
+import { execSync } from 'node:child_process'
+import { Console, Effect } from 'effect'
+import chalk from 'chalk'
+export interface UpdateOptions {
+  skipPull?: boolean
+}
+
+const PACKAGE_NAME = '@aaronshaf/ger'
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`
+
+const readCurrentVersion = (): string => {
+  try {
+    // Bun.file is available at runtime; use dynamic require as fallback
+    const raw = require('../../package.json') as { version: string }
+    return raw.version
+  } catch {
+    return '0.0.0'
+  }
+}
+
+class UpdateError extends Error {
+  readonly _tag = 'UpdateError' as const
+  constructor(message: string) {
+    super(message)
+    this.name = 'UpdateError'
+  }
+}
+
+const fetchLatestVersion = (): Effect.Effect<string, UpdateError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const res = await fetch(REGISTRY_URL)
+      if (!res.ok) throw new Error(`Registry returned ${res.status}`)
+      const data = (await res.json()) as { version: string }
+      return data.version
+    },
+    catch: (e) =>
+      new UpdateError(
+        `Failed to check latest version: ${e instanceof Error ? e.message : String(e)}`,
+      ),
+  })
+
+export const updateCommand = (options: UpdateOptions): Effect.Effect<void, UpdateError, never> =>
+  Effect.gen(function* () {
+    if (!options.skipPull) {
+      yield* Console.log(chalk.dim('Checking for updates...'))
+
+      const latest = yield* fetchLatestVersion()
+      const current = readCurrentVersion()
+
+      yield* Console.log(`  Current: ${chalk.cyan(current)}`)
+      yield* Console.log(`  Latest:  ${chalk.cyan(latest)}`)
+
+      if (current === latest) {
+        yield* Console.log(chalk.green(`✓ Already up to date (${current})`))
+        return
+      }
+
+      yield* Console.log('')
+    }
+
+    yield* Console.log(chalk.dim(`Installing ${PACKAGE_NAME}@latest...`))
+    yield* Effect.try({
+      try: () => {
+        execSync(`bun install -g ${PACKAGE_NAME}@latest`, { stdio: 'inherit', timeout: 60000 })
+      },
+      catch: (e) =>
+        new UpdateError(`Install failed: ${e instanceof Error ? e.message : String(e)}`),
+    })
+
+    yield* Console.log('')
+    yield* Console.log(chalk.green('✓ ger updated successfully'))
+  })

package/src/cli/register-analytics-commands.ts

@@ -0,0 +1,90 @@
+import type { Command } from 'commander'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigServiceLive } from '@/services/config'
+import { analyzeCommand } from './commands/analyze'
+import { failuresCommand } from './commands/failures'
+import { updateCommand } from './commands/update'
+
+function executeEffect<E>(
+  effect: Effect.Effect<void, E, never>,
+  options: { xml?: boolean; json?: boolean },
+  resultTag: string,
+): Promise<void> {
+  if (options.xml && options.json) {
+    console.error('✗ Error: --xml and --json are mutually exclusive')
+    process.exit(1)
+  }
+  return Effect.runPromise(effect).catch((error: unknown) => {
+    const msg = error instanceof Error ? error.message : String(error)
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'error', error: msg }, null, 2))
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<${resultTag}>`)
+      console.log(`  <status>error</status>`)
+      console.log(`  <error><![CDATA[${msg}]]></error>`)
+      console.log(`</${resultTag}>`)
+    } else {
+      console.error('✗ Error:', msg)
+    }
+    process.exit(1)
+  })
+}
+
+export function registerAnalyticsCommands(program: Command): void {
+  // update command
+  program
+    .command('update')
+    .description('Update ger to the latest version')
+    .option('--skip-pull', 'Skip version check and install directly')
+    .action(async (options) => {
+      await executeEffect(updateCommand({ skipPull: options.skipPull }), options, 'update_result')
+    })
+
+  // failures command
+  program
+    .command('failures <change-id>')
+    .description('Get the most recent build failure link from Service Cloud Jenkins')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (changeId, options) => {
+      await executeEffect(
+        failuresCommand(changeId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'failures_result',
+      )
+    })
+
+  // analyze command
+  program
+    .command('analyze')
+    .description('Show contribution analytics for merged changes')
+    .option('--start-date <date>', 'Start date (YYYY-MM-DD, default: Jan 1 of current year)')
+    .option('--end-date <date>', 'End date (YYYY-MM-DD, default: today)')
+    .option('--repo <project>', 'Filter by Gerrit project name')
+    .option('--json', 'JSON output')
+    .option('--xml', 'XML output')
+    .option('--markdown', 'Markdown output')
+    .option('--csv', 'CSV output')
+    .option('--output <file>', 'Write output to file')
+    .action(async (options) => {
+      await executeEffect(
+        analyzeCommand({
+          startDate: options.startDate,
+          endDate: options.endDate,
+          repo: options.repo,
+          json: options.json,
+          xml: options.xml,
+          markdown: options.markdown,
+          csv: options.csv,
+          output: options.output,
+        }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(ConfigServiceLive)),
+        options,
+        'analyze_result',
+      )
+    })
+}

package/src/cli/register-commands.ts

@@ -15,9 +15,7 @@ import { commentCommand, COMMENT_HELP_TEXT } from './commands/comment'
 import { commentsCommand } from './commands/comments'
 import { diffCommand } from './commands/diff'
 import { extractUrlCommand } from './commands/extract-url'
-import { incomingCommand } from './commands/incoming'
 import { installHookCommand } from './commands/install-hook'
-import { mineCommand } from './commands/mine'
 import { openCommand } from './commands/open'
 import { pushCommand, PUSH_HELP_TEXT } from './commands/push'
 import { searchCommand, SEARCH_HELP_TEXT } from './commands/search'
@@ -28,8 +26,13 @@ import { workspaceCommand } from './commands/workspace'
 import { sanitizeCDATA } from '@/utils/shell-safety'
 import { registerGroupCommands } from './register-group-commands'
 import { registerReviewerCommands } from './register-reviewer-commands'
+import { registerTreeCommands } from './register-tree-commands'
 import { filesCommand } from './commands/files'
 import { reviewersCommand } from './commands/reviewers'
+import { retriggerCommand, RETRIGGER_HELP_TEXT } from './commands/retrigger'
+import { cherryCommand, CHERRY_HELP_TEXT } from './commands/cherry'
+import { registerListCommands } from './register-list-commands'
+import { registerAnalyticsCommands } from './register-analytics-commands'
 
 // Helper function to output error in plain text, JSON, or XML format
 function outputError(
@@ -154,22 +157,7 @@ export function registerCommands(program: Command): void {
       )
     })
 
-  // mine command
-  program
-    .command('mine')
-    .description('Show your open changes')
-    .option('--xml', 'XML output for LLM consumption')
-    .option('--json', 'JSON output for programmatic consumption')
-    .action(async (options) => {
-      await executeEffect(
-        mineCommand(options).pipe(
-          Effect.provide(GerritApiServiceLive),
-          Effect.provide(ConfigServiceLive),
-        ),
-        options,
-        'mine_result',
-      )
-    })
+  registerListCommands(program)
 
   // search command
   program
@@ -201,15 +189,16 @@ export function registerCommands(program: Command): void {
       })
     })
 
-  // workspace command
+  // workspace command (deprecated — use 'ger tree setup' instead)
   program
     .command('workspace <change-id>')
-    .description(
-      'Create or switch to a git worktree for a Gerrit change (accepts change number or Change-ID)',
-    )
+    .description('[deprecated: use "ger tree setup"] Create a git worktree for a Gerrit change')
     .option('--xml', 'XML output for LLM consumption')
     .option('--json', 'JSON output for programmatic consumption')
     .action(async (changeId, options) => {
+      if (!options.xml && !options.json) {
+        console.error('Note: "ger workspace" is deprecated. Use "ger tree setup" instead.')
+      }
       await executeEffect(
         workspaceCommand(changeId, options).pipe(
           Effect.provide(GerritApiServiceLive),
@@ -220,23 +209,7 @@ export function registerCommands(program: Command): void {
       )
     })
 
-  // incoming command
-  program
-    .command('incoming')
-    .description('Show incoming changes for review (where you are a reviewer)')
-    .option('--xml', 'XML output for LLM consumption')
-    .option('--json', 'JSON output for programmatic consumption')
-    .option('-i, --interactive', 'Interactive mode with detailed view and diff')
-    .action(async (options) => {
-      await executeEffect(
-        incomingCommand(options).pipe(
-          Effect.provide(GerritApiServiceLive),
-          Effect.provide(ConfigServiceLive),
-        ),
-        options,
-        'incoming_result',
-      )
-    })
+  registerTreeCommands(program)
 
   // abandon / restore / set-ready / set-wip commands
   registerStateCommands(program)
@@ -246,11 +219,12 @@ export function registerCommands(program: Command): void {
     .command('rebase [change-id]')
     .description('Rebase a change onto target branch (auto-detects from HEAD if not provided)')
     .option('--base <ref>', 'Base revision to rebase onto (default: target branch HEAD)')
+    .option('--allow-conflicts', 'Allow rebasing even if conflicts exist')
     .option('--xml', 'XML output for LLM consumption')
     .option('--json', 'JSON output for programmatic consumption')
     .action(async (changeId, options) => {
       await executeEffect(
-        rebaseCommand(changeId, options).pipe(
+        rebaseCommand(changeId, { ...options, allowConflicts: options.allowConflicts }).pipe(
           Effect.provide(GerritApiServiceLive),
           Effect.provide(ConfigServiceLive),
         ),
@@ -340,6 +314,26 @@ export function registerCommands(program: Command): void {
   // Register all group-related commands
   registerGroupCommands(program)
 
+  // retrigger command
+  program
+    .command('retrigger [change-id]')
+    .description(
+      'Post the CI retrigger comment on a change (auto-detects from HEAD if no change-id given)',
+    )
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .addHelpText('after', RETRIGGER_HELP_TEXT)
+    .action(async (changeId, options) => {
+      await executeEffect(
+        retriggerCommand(changeId as string | undefined, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'retrigger_result',
+      )
+    })
+
   // comments command
   program
     .command('comments <change-id>')
@@ -637,4 +631,26 @@ Note:
         process.exit(1)
       }
     })
+
+  registerAnalyticsCommands(program)
+
+  // cherry command
+  program
+    .command('cherry <change-id>')
+    .description('Fetch and cherry-pick a Gerrit change onto the current branch')
+    .option('-n, --no-commit', 'Stage changes without committing')
+    .option('--no-verify', 'Bypass git commit hooks during cherry-pick')
+    .option('--remote <name>', 'Use specific git remote (default: auto-detect)')
+    .addHelpText('after', CHERRY_HELP_TEXT)
+    .action(async (changeId, options) => {
+      await executeEffect(
+        cherryCommand(changeId, {
+          noCommit: options.noCommit,
+          noVerify: options.noVerify,
+          remote: options.remote,
+        }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(ConfigServiceLive)),
+        options,
+        'cherry_result',
+      )
+    })
 }

package/src/cli/register-list-commands.ts

@@ -0,0 +1,105 @@
+import type { Command } from 'commander'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigServiceLive } from '@/services/config'
+import { listCommand } from './commands/list'
+
+function executeEffect<E>(
+  effect: Effect.Effect<void, E, never>,
+  options: { xml?: boolean; json?: boolean },
+  resultTag: string,
+): Promise<void> {
+  if (options.xml && options.json) {
+    console.error('✗ Error: --xml and --json are mutually exclusive')
+    process.exit(1)
+  }
+  return Effect.runPromise(effect).catch((error: unknown) => {
+    const msg = error instanceof Error ? error.message : String(error)
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'error', error: msg }, null, 2))
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<${resultTag}>`)
+      console.log(`  <status>error</status>`)
+      console.log(`  <error><![CDATA[${msg}]]></error>`)
+      console.log(`</${resultTag}>`)
+    } else {
+      console.error('✗ Error:', msg)
+    }
+    process.exit(1)
+  })
+}
+
+export function registerListCommands(program: Command): void {
+  // list command (primary)
+  program
+    .command('list')
+    .description('List your changes or changes needing your review')
+    .option('--status <status>', 'Filter by status: open, merged, abandoned (default: open)')
+    .option('-n, --limit <number>', 'Maximum number of changes to show (default: 25)', parseInt)
+    .option('--detailed', 'Show detailed information for each change')
+    .option('--reviewer', 'Show changes where you are a reviewer')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (options) => {
+      await executeEffect(
+        listCommand(options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'list_result',
+      )
+    })
+
+  // mine command (alias for list)
+  program
+    .command('mine')
+    .description('Show your open changes (alias for "ger list")')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (options) => {
+      await executeEffect(
+        listCommand(options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'list_result',
+      )
+    })
+
+  const registerReviewerListCommand = (name: string, description: string): void => {
+    program
+      .command(name)
+      .description(description)
+      .option('--status <status>', 'Filter by status: open, merged, abandoned (default: open)')
+      .option('-n, --limit <number>', 'Maximum number of changes to show (default: 25)', parseInt)
+      .option('--detailed', 'Show detailed information for each change')
+      .option('--all-verified', 'Include all verification states (default: open only)')
+      .option('-f, --filter <query>', 'Append custom Gerrit query syntax')
+      .option('--xml', 'XML output for LLM consumption')
+      .option('--json', 'JSON output for programmatic consumption')
+      .action(async (options) => {
+        await executeEffect(
+          listCommand({
+            ...options,
+            reviewer: true,
+            allVerified: options.allVerified,
+            filter: options.filter,
+          }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(ConfigServiceLive)),
+          options,
+          'list_result',
+        )
+      })
+  }
+
+  registerReviewerListCommand(
+    'incoming',
+    'Show changes where you are a reviewer or CC\'d (alias for "ger list --reviewer")',
+  )
+  registerReviewerListCommand(
+    'team',
+    'Show changes where you are a reviewer or CC\'d (alias for "ger list --reviewer")',
+  )
+}

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

@@ -0,0 +1,128 @@
+import type { Command } from 'commander'
+import { Effect } from 'effect'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { ConfigServiceLive } from '@/services/config'
+import { treeSetupCommand, TREE_SETUP_HELP_TEXT } from './commands/tree-setup'
+import { treesCommand } from './commands/trees'
+import { treeCleanupCommand } from './commands/tree-cleanup'
+import { treeRebaseCommand } from './commands/tree-rebase'
+
+async function executeEffect<E>(
+  effect: Effect.Effect<void, E, never>,
+  options: { xml?: boolean; json?: boolean },
+  resultTag: string,
+): Promise<void> {
+  if (options.xml && options.json) {
+    console.error('--xml and --json are mutually exclusive')
+    process.exit(1)
+  }
+  try {
+    await Effect.runPromise(effect)
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    if (options.json) {
+      console.log(JSON.stringify({ status: 'error', error: errorMessage }, null, 2))
+    } else if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<${resultTag}>`)
+      console.log(`  <status>error</status>`)
+      console.log(`  <error><![CDATA[${errorMessage}]]></error>`)
+      console.log(`</${resultTag}>`)
+    } else {
+      console.error('✗ Error:', errorMessage)
+    }
+    process.exit(1)
+  }
+}
+
+export function registerTreeCommands(program: Command): void {
+  const tree = program
+    .command('tree')
+    .description('Manage git worktrees for reviewing Gerrit changes')
+
+  tree
+    .command('setup <change-id>')
+    .description('Create a git worktree for reviewing a change')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .addHelpText('after', TREE_SETUP_HELP_TEXT)
+    .action(async (changeId: string, options: { xml?: boolean; json?: boolean }) => {
+      await executeEffect(
+        treeSetupCommand(changeId, options).pipe(
+          Effect.provide(GerritApiServiceLive),
+          Effect.provide(ConfigServiceLive),
+        ),
+        options,
+        'tree_setup_result',
+      )
+    })
+
+  tree
+    .command('cleanup [change-id]')
+    .description('Remove ger-managed worktrees (all, or a specific one by change number)')
+    .option('--force', 'Force removal even with uncommitted changes')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  # Remove all ger-managed worktrees
+  $ ger tree cleanup
+
+  # Remove worktree for a specific change
+  $ ger tree cleanup 12345
+
+  # Force removal (discards uncommitted changes)
+  $ ger tree cleanup 12345 --force`,
+    )
+    .action(
+      async (
+        changeId: string | undefined,
+        options: { force?: boolean; xml?: boolean; json?: boolean },
+      ) => {
+        await executeEffect(treeCleanupCommand(changeId, options), options, 'tree_cleanup_result')
+      },
+    )
+
+  tree
+    .command('rebase')
+    .description('Fetch origin and rebase the current worktree')
+    .option('--onto <branch>', 'Branch to rebase onto (default: auto-detect)')
+    .option('-i, --interactive', 'Interactive rebase')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .addHelpText(
+      'after',
+      `
+Examples:
+  # Rebase onto auto-detected upstream
+  $ ger tree rebase
+
+  # Rebase onto a specific branch
+  $ ger tree rebase --onto origin/main
+
+  # Interactive rebase
+  $ ger tree rebase -i`,
+    )
+    .action(
+      async (options: { onto?: string; interactive?: boolean; xml?: boolean; json?: boolean }) => {
+        await executeEffect(
+          treeRebaseCommand(options).pipe(Effect.provide(ConfigServiceLive)),
+          options,
+          'tree_rebase_result',
+        )
+      },
+    )
+
+  // 'trees' is a top-level command (matches gerry's naming)
+  program
+    .command('trees')
+    .description('List ger-managed git worktrees in the current repository')
+    .option('--all', 'Show all worktrees including the main checkout')
+    .option('--xml', 'XML output for LLM consumption')
+    .option('--json', 'JSON output for programmatic consumption')
+    .action(async (options: { all?: boolean; xml?: boolean; json?: boolean }) => {
+      await executeEffect(treesCommand(options), options, 'trees_result')
+    })
+}

package/src/schemas/config.ts

@@ -7,6 +7,7 @@ export const AppConfig: Schema.Struct<{
   password: typeof Schema.String
   aiTool: Schema.optional<Schema.Literal<['claude', 'llm', 'opencode', 'gemini']>>
   aiAutoDetect: Schema.optionalWith<typeof Schema.Boolean, { default: () => boolean }>
+  retriggerComment: Schema.optional<typeof Schema.String>
 }> = Schema.Struct({
   // Gerrit credentials (flattened)
   host: Schema.String.pipe(
@@ -24,6 +25,8 @@ export const AppConfig: Schema.Struct<{
   // AI configuration (flattened)
   aiTool: Schema.optional(Schema.Literal('claude', 'llm', 'opencode', 'gemini')),
   aiAutoDetect: Schema.optionalWith(Schema.Boolean, { default: (): boolean => true }),
+  // CI retrigger comment
+  retriggerComment: Schema.optional(Schema.String),
 })
 
 export type AppConfig = Schema.Schema.Type<typeof AppConfig>

package/src/services/config.ts

@@ -14,6 +14,8 @@ export interface ConfigServiceImpl {
   readonly saveAiConfig: (config: AiConfig) => Effect.Effect<void, ConfigError>
   readonly getFullConfig: Effect.Effect<AppConfig, ConfigError>
   readonly saveFullConfig: (config: AppConfig) => Effect.Effect<void, ConfigError>
+  readonly getRetriggerComment: Effect.Effect<string | undefined, ConfigError>
+  readonly saveRetriggerComment: (comment: string) => Effect.Effect<void, ConfigError>
 }
 
 // Export both the tag value and the type for use in Effect requirements
@@ -237,6 +239,17 @@ export const ConfigServiceLive: Layer.Layer<ConfigService, never, never> = Layer
         yield* saveFullConfig(updatedConfig)
       })
 
+    const getRetriggerComment = Effect.gen(function* () {
+      const config = yield* getFullConfig.pipe(Effect.orElseSucceed(() => null))
+      return config?.retriggerComment
+    })
+
+    const saveRetriggerComment = (comment: string) =>
+      Effect.gen(function* () {
+        const existingConfig = yield* getFullConfig
+        yield* saveFullConfig({ ...existingConfig, retriggerComment: comment })
+      })
+
     return {
       getCredentials,
       saveCredentials,
@@ -245,6 +258,8 @@ export const ConfigServiceLive: Layer.Layer<ConfigService, never, never> = Layer
       saveAiConfig,
       getFullConfig,
       saveFullConfig,
+      getRetriggerComment,
+      saveRetriggerComment,
     }
   }),
 )