@aaronshaf/ger 1.2.10 → 2.0.0

package/src/cli/commands/show.ts

@@ -0,0 +1,491 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { CommentInfo, MessageInfo } from '@/schemas/gerrit'
+import { formatCommentsPretty } from '@/utils/comment-formatters'
+import { getDiffContext } from '@/utils/diff-context'
+import { formatDiffPretty } from '@/utils/diff-formatters'
+import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
+import { formatDate } from '@/utils/formatters'
+import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
+import { writeFileSync } from 'node:fs'
+
+export const SHOW_HELP_TEXT = `
+Examples:
+  # Show specific change (using change number)
+  $ ger show 392385
+
+  # Show specific change (using Change-ID)
+  $ ger show If5a3ae8cb5a107e187447802358417f311d0c4b1
+
+  # Auto-detect Change-ID from HEAD commit
+  $ ger show
+  $ ger show --xml
+  $ ger show --json
+
+  # Extract build failure URL with jq
+  $ ger show 392090 --json | jq -r '.messages[] | select(.message | contains("Build Failed")) | .message' | grep -oP 'https://[^\\s]+'
+
+Note: When no change-id is provided, it will be automatically extracted from the
+      Change-ID footer in your HEAD commit. You must be in a git repository with
+      a commit that has a Change-ID.`
+
+interface ShowOptions {
+  xml?: boolean
+  json?: boolean
+}
+
+interface ChangeDetails {
+  id: string
+  number: number
+  subject: string
+  status: string
+  project: string
+  branch: string
+  owner: {
+    name?: string
+    email?: string
+  }
+  created?: string
+  updated?: string
+  commitMessage: string
+}
+
+const getChangeDetails = (
+  changeId: string,
+): Effect.Effect<ChangeDetails, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+    const change = yield* gerritApi.getChange(changeId)
+
+    return {
+      id: change.change_id,
+      number: change._number,
+      subject: change.subject,
+      status: change.status,
+      project: change.project,
+      branch: change.branch,
+      owner: {
+        name: change.owner?.name,
+        email: change.owner?.email,
+      },
+      created: change.created,
+      updated: change.updated,
+      commitMessage: change.subject, // For now, using subject as commit message
+    }
+  })
+
+const getDiffForChange = (changeId: string): Effect.Effect<string, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+    const diff = yield* gerritApi.getDiff(changeId, { format: 'unified' })
+    return typeof diff === 'string' ? diff : JSON.stringify(diff, null, 2)
+  })
+
+const getCommentsAndMessagesForChange = (
+  changeId: string,
+): Effect.Effect<
+  { comments: CommentInfo[]; messages: MessageInfo[] },
+  ApiError,
+  GerritApiService
+> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Get both inline comments and review messages concurrently
+    const [comments, messages] = yield* Effect.all(
+      [gerritApi.getComments(changeId), gerritApi.getMessages(changeId)],
+      { concurrency: 'unbounded' },
+    )
+
+    // Flatten all inline comments from all files
+    const allComments: CommentInfo[] = []
+    for (const [path, fileComments] of Object.entries(comments)) {
+      for (const comment of fileComments) {
+        allComments.push({
+          ...comment,
+          path: path === '/COMMIT_MSG' ? 'Commit Message' : path,
+        })
+      }
+    }
+
+    // Sort inline comments by date (ascending - oldest first)
+    allComments.sort((a, b) => {
+      const dateA = a.updated ? new Date(a.updated).getTime() : 0
+      const dateB = b.updated ? new Date(b.updated).getTime() : 0
+      return dateA - dateB
+    })
+
+    // Sort messages by date (ascending - oldest first)
+    const sortedMessages = [...messages].sort((a, b) => {
+      const dateA = new Date(a.date).getTime()
+      const dateB = new Date(b.date).getTime()
+      return dateA - dateB
+    })
+
+    return { comments: allComments, messages: sortedMessages }
+  })
+
+const formatShowPretty = (
+  changeDetails: ChangeDetails,
+  diff: string,
+  commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
+  messages: MessageInfo[],
+): void => {
+  // Change details header
+  console.log('━'.repeat(80))
+  console.log(`📋 Change ${changeDetails.number}: ${changeDetails.subject}`)
+  console.log('━'.repeat(80))
+  console.log()
+
+  // Metadata
+  console.log('📝 Details:')
+  console.log(`   Project: ${changeDetails.project}`)
+  console.log(`   Branch: ${changeDetails.branch}`)
+  console.log(`   Status: ${changeDetails.status}`)
+  console.log(`   Owner: ${changeDetails.owner.name || changeDetails.owner.email || 'Unknown'}`)
+  console.log(
+    `   Created: ${changeDetails.created ? formatDate(changeDetails.created) : 'Unknown'}`,
+  )
+  console.log(
+    `   Updated: ${changeDetails.updated ? formatDate(changeDetails.updated) : 'Unknown'}`,
+  )
+  console.log(`   Change-Id: ${changeDetails.id}`)
+  console.log()
+
+  // Diff section
+  console.log('🔍 Diff:')
+  console.log('─'.repeat(40))
+  console.log(formatDiffPretty(diff))
+  console.log()
+
+  // Comments and Messages section
+  const hasComments = commentsWithContext.length > 0
+  const hasMessages = messages.length > 0
+
+  if (hasComments) {
+    console.log('💬 Inline Comments:')
+    console.log('─'.repeat(40))
+    formatCommentsPretty(commentsWithContext)
+    console.log()
+  }
+
+  if (hasMessages) {
+    console.log('📝 Review Activity:')
+    console.log('─'.repeat(40))
+    for (const message of messages) {
+      const author = message.author?.name || 'Unknown'
+      const date = formatDate(message.date)
+      const cleanMessage = message.message.trim()
+
+      // Skip very short automated messages
+      if (
+        cleanMessage.length < 10 &&
+        (cleanMessage.includes('Build') || cleanMessage.includes('Patch'))
+      ) {
+        continue
+      }
+
+      console.log(`📅 ${date} - ${author}`)
+      console.log(`   ${cleanMessage}`)
+      console.log()
+    }
+  }
+
+  if (!hasComments && !hasMessages) {
+    console.log('💬 Comments & Activity:')
+    console.log('─'.repeat(40))
+    console.log('No comments or review activity found.')
+  }
+}
+
+// Helper to remove undefined values from objects
+const removeUndefined = <T extends Record<string, any>>(obj: T): Partial<T> => {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, value]) => value !== undefined),
+  ) as Partial<T>
+}
+
+const formatShowJson = async (
+  changeDetails: ChangeDetails,
+  diff: string,
+  commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
+  messages: MessageInfo[],
+): Promise<void> => {
+  const output = {
+    status: 'success',
+    change: removeUndefined({
+      id: changeDetails.id,
+      number: changeDetails.number,
+      subject: changeDetails.subject,
+      status: changeDetails.status,
+      project: changeDetails.project,
+      branch: changeDetails.branch,
+      owner: removeUndefined(changeDetails.owner),
+      created: changeDetails.created,
+      updated: changeDetails.updated,
+    }),
+    diff,
+    comments: commentsWithContext.map(({ comment, context }) =>
+      removeUndefined({
+        id: comment.id,
+        path: comment.path,
+        line: comment.line,
+        range: comment.range,
+        author: comment.author
+          ? removeUndefined({
+              name: comment.author.name,
+              email: comment.author.email,
+              account_id: comment.author._account_id,
+            })
+          : undefined,
+        updated: comment.updated,
+        message: comment.message,
+        unresolved: comment.unresolved,
+        in_reply_to: comment.in_reply_to,
+        context,
+      }),
+    ),
+    messages: messages.map((message) =>
+      removeUndefined({
+        id: message.id,
+        author: message.author
+          ? removeUndefined({
+              name: message.author.name,
+              email: message.author.email,
+              account_id: message.author._account_id,
+            })
+          : undefined,
+        date: message.date,
+        message: message.message,
+        revision: message._revision_number,
+        tag: message.tag,
+      }),
+    ),
+  }
+
+  const jsonOutput = JSON.stringify(output, null, 2) + '\n'
+  // Write to stdout and ensure all data is flushed before process exits
+  // Using process.stdout.write with drain handling for large payloads
+  return new Promise<void>((resolve, reject) => {
+    const written = process.stdout.write(jsonOutput, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+
+    if (!written) {
+      // If write returned false, buffer is full, wait for drain
+      process.stdout.once('drain', resolve)
+      process.stdout.once('error', reject)
+    }
+  })
+}
+
+const formatShowXml = async (
+  changeDetails: ChangeDetails,
+  diff: string,
+  commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
+  messages: MessageInfo[],
+): Promise<void> => {
+  // Build complete XML output as a single string to avoid multiple writes
+  const xmlParts: string[] = []
+  xmlParts.push(`<?xml version="1.0" encoding="UTF-8"?>`)
+  xmlParts.push(`<show_result>`)
+  xmlParts.push(`  <status>success</status>`)
+  xmlParts.push(`  <change>`)
+  xmlParts.push(`    <id>${escapeXML(changeDetails.id)}</id>`)
+  xmlParts.push(`    <number>${changeDetails.number}</number>`)
+  xmlParts.push(`    <subject><![CDATA[${sanitizeCDATA(changeDetails.subject)}]]></subject>`)
+  xmlParts.push(`    <status>${escapeXML(changeDetails.status)}</status>`)
+  xmlParts.push(`    <project>${escapeXML(changeDetails.project)}</project>`)
+  xmlParts.push(`    <branch>${escapeXML(changeDetails.branch)}</branch>`)
+  xmlParts.push(`    <owner>`)
+  if (changeDetails.owner.name) {
+    xmlParts.push(`      <name><![CDATA[${sanitizeCDATA(changeDetails.owner.name)}]]></name>`)
+  }
+  if (changeDetails.owner.email) {
+    xmlParts.push(`      <email>${escapeXML(changeDetails.owner.email)}</email>`)
+  }
+  xmlParts.push(`    </owner>`)
+  xmlParts.push(`    <created>${escapeXML(changeDetails.created || '')}</created>`)
+  xmlParts.push(`    <updated>${escapeXML(changeDetails.updated || '')}</updated>`)
+  xmlParts.push(`  </change>`)
+  xmlParts.push(`  <diff><![CDATA[${sanitizeCDATA(diff)}]]></diff>`)
+
+  // Comments section
+  xmlParts.push(`  <comments>`)
+  xmlParts.push(`    <count>${commentsWithContext.length}</count>`)
+  for (const { comment } of commentsWithContext) {
+    xmlParts.push(`    <comment>`)
+    if (comment.id) xmlParts.push(`      <id>${escapeXML(comment.id)}</id>`)
+    if (comment.path) xmlParts.push(`      <path><![CDATA[${sanitizeCDATA(comment.path)}]]></path>`)
+    if (comment.line) xmlParts.push(`      <line>${comment.line}</line>`)
+    if (comment.author?.name) {
+      xmlParts.push(`      <author><![CDATA[${sanitizeCDATA(comment.author.name)}]]></author>`)
+    }
+    if (comment.updated) xmlParts.push(`      <updated>${escapeXML(comment.updated)}</updated>`)
+    if (comment.message) {
+      xmlParts.push(`      <message><![CDATA[${sanitizeCDATA(comment.message)}]]></message>`)
+    }
+    if (comment.unresolved) xmlParts.push(`      <unresolved>true</unresolved>`)
+    xmlParts.push(`    </comment>`)
+  }
+  xmlParts.push(`  </comments>`)
+
+  // Messages section
+  xmlParts.push(`  <messages>`)
+  xmlParts.push(`    <count>${messages.length}</count>`)
+  for (const message of messages) {
+    xmlParts.push(`    <message>`)
+    xmlParts.push(`      <id>${escapeXML(message.id)}</id>`)
+    if (message.author?.name) {
+      xmlParts.push(`      <author><![CDATA[${sanitizeCDATA(message.author.name)}]]></author>`)
+    }
+    if (message.author?._account_id) {
+      xmlParts.push(`      <author_id>${message.author._account_id}</author_id>`)
+    }
+    xmlParts.push(`      <date>${escapeXML(message.date)}</date>`)
+    if (message._revision_number) {
+      xmlParts.push(`      <revision>${message._revision_number}</revision>`)
+    }
+    if (message.tag) {
+      xmlParts.push(`      <tag>${escapeXML(message.tag)}</tag>`)
+    }
+    xmlParts.push(`      <message><![CDATA[${sanitizeCDATA(message.message)}]]></message>`)
+    xmlParts.push(`    </message>`)
+  }
+  xmlParts.push(`  </messages>`)
+  xmlParts.push(`</show_result>`)
+
+  const xmlOutput = xmlParts.join('\n') + '\n'
+  // Write to stdout with proper drain handling for large payloads
+  return new Promise<void>((resolve, reject) => {
+    const written = process.stdout.write(xmlOutput, (err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve()
+      }
+    })
+
+    if (!written) {
+      process.stdout.once('drain', resolve)
+      process.stdout.once('error', reject)
+    }
+  })
+}
+
+export const showCommand = (
+  changeId: string | undefined,
+  options: ShowOptions,
+): Effect.Effect<void, ApiError | Error | GitError | NoChangeIdError, GerritApiService> =>
+  Effect.gen(function* () {
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    // Fetch all data concurrently
+    const [changeDetails, diff, commentsAndMessages] = yield* Effect.all(
+      [
+        getChangeDetails(resolvedChangeId),
+        getDiffForChange(resolvedChangeId),
+        getCommentsAndMessagesForChange(resolvedChangeId),
+      ],
+      { concurrency: 'unbounded' },
+    )
+
+    const { comments, messages } = commentsAndMessages
+
+    // Get context for each comment using concurrent requests
+    const contextEffects = comments.map((comment) =>
+      comment.path && comment.line
+        ? getDiffContext(resolvedChangeId, comment.path, comment.line).pipe(
+            Effect.map((context) => ({ comment, context })),
+            // Graceful degradation for diff fetch failures
+            Effect.catchAll(() => Effect.succeed({ comment, context: undefined })),
+          )
+        : Effect.succeed({ comment, context: undefined }),
+    )
+
+    // Execute all context fetches concurrently
+    const commentsWithContext = yield* Effect.all(contextEffects, {
+      concurrency: 'unbounded',
+    })
+
+    // Format output
+    if (options.json) {
+      yield* Effect.promise(() =>
+        formatShowJson(changeDetails, diff, commentsWithContext, messages),
+      )
+    } else if (options.xml) {
+      yield* Effect.promise(() => formatShowXml(changeDetails, diff, commentsWithContext, messages))
+    } else {
+      formatShowPretty(changeDetails, diff, commentsWithContext, messages)
+    }
+  }).pipe(
+    // Regional error boundary for the entire command
+    Effect.catchAll((error) => {
+      const errorMessage =
+        error instanceof GitError || error instanceof NoChangeIdError || error instanceof Error
+          ? error.message
+          : String(error)
+
+      if (options.json) {
+        return Effect.promise(
+          () =>
+            new Promise<void>((resolve, reject) => {
+              const errorOutput =
+                JSON.stringify(
+                  {
+                    status: 'error',
+                    error: errorMessage,
+                  },
+                  null,
+                  2,
+                ) + '\n'
+              const written = process.stdout.write(errorOutput, (err) => {
+                if (err) {
+                  reject(err)
+                } else {
+                  resolve()
+                }
+              })
+
+              if (!written) {
+                // Wait for drain if buffer is full
+                process.stdout.once('drain', resolve)
+                process.stdout.once('error', reject)
+              }
+            }),
+        )
+      } else if (options.xml) {
+        return Effect.promise(
+          () =>
+            new Promise<void>((resolve, reject) => {
+              const xmlError =
+                `<?xml version="1.0" encoding="UTF-8"?>\n` +
+                `<show_result>\n` +
+                `  <status>error</status>\n` +
+                `  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>\n` +
+                `</show_result>\n`
+              const written = process.stdout.write(xmlError, (err) => {
+                if (err) {
+                  reject(err)
+                } else {
+                  resolve()
+                }
+              })
+
+              if (!written) {
+                process.stdout.once('drain', resolve)
+                process.stdout.once('error', reject)
+              }
+            }),
+        )
+      } else {
+        console.error(`✗ Error: ${errorMessage}`)
+      }
+      return Effect.succeed(undefined)
+    }),
+  )

package/src/cli/commands/status.ts

@@ -0,0 +1,35 @@
+import { Effect } from 'effect'
+import { GerritApiService } from '@/api/gerrit'
+
+interface StatusOptions {
+  xml?: boolean
+}
+
+export const statusCommand = (
+  options: StatusOptions,
+): Effect.Effect<void, Error, GerritApiService> =>
+  Effect.gen(function* () {
+    const apiService = yield* GerritApiService
+
+    const isConnected = yield* apiService.testConnection
+
+    if (options.xml) {
+      // XML output for LLM consumption
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<status_result>`)
+      console.log(`  <connected>${isConnected}</connected>`)
+      console.log(`</status_result>`)
+    } else {
+      // Pretty output by default
+      if (isConnected) {
+        console.log('✓ Connected to Gerrit successfully!')
+      } else {
+        console.log('✗ Failed to connect to Gerrit')
+        console.log('Please check your credentials and network connection')
+      }
+    }
+
+    if (!isConnected) {
+      yield* Effect.fail(new Error('Connection failed'))
+    }
+  })

package/src/cli/commands/submit.ts

@@ -0,0 +1,108 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+
+interface SubmitOptions {
+  xml?: boolean
+}
+
+/**
+ * Submits a Gerrit change for merging after verifying it meets submit requirements.
+ *
+ * Pre-validates that the change has required approvals and is in the correct state
+ * before attempting submission.
+ *
+ * @param changeId - Change number or Change-ID to submit
+ * @param options - Configuration options
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when the change is submitted or validation fails
+ */
+export const submitCommand = (
+  changeId?: string,
+  options: SubmitOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    if (!changeId || changeId.trim() === '') {
+      console.error('✗ Change ID is required')
+      console.error('  Usage: ger submit <change-id>')
+      return
+    }
+
+    // Pre-check: Fetch change to verify it's submittable
+    const change = yield* gerritApi.getChange(changeId)
+
+    // Check if the change is submittable
+    if (change.submittable === false) {
+      const reasons: string[] = []
+
+      // Check status
+      if (change.status !== 'NEW') {
+        reasons.push(`Change status is ${change.status} (must be NEW)`)
+      }
+
+      // Check for work in progress
+      if (change.work_in_progress) {
+        reasons.push('Change is marked as work-in-progress')
+      }
+
+      // Check labels for required approvals
+      if (change.labels) {
+        const codeReview = change.labels['Code-Review']
+        const verified = change.labels['Verified']
+
+        if (codeReview && !codeReview.approved) {
+          reasons.push('Missing Code-Review+2 approval')
+        }
+
+        if (verified && !verified.approved) {
+          reasons.push('Missing Verified+1 approval')
+        }
+      }
+
+      // If no specific reasons found but not submittable, add generic reason
+      if (reasons.length === 0) {
+        reasons.push('Change does not meet submit requirements')
+      }
+
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<submit_result>`)
+        console.log(`  <status>error</status>`)
+        console.log(`  <change_number>${change._number}</change_number>`)
+        console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+        console.log(`  <submittable>false</submittable>`)
+        console.log(`  <reasons>`)
+        for (const reason of reasons) {
+          console.log(`    <reason><![CDATA[${reason}]]></reason>`)
+        }
+        console.log(`  </reasons>`)
+        console.log(`</submit_result>`)
+      } else {
+        console.error(`✗ Change ${change._number} cannot be submitted:`)
+        console.error(`  ${change.subject}`)
+        console.error(``)
+        console.error(`  Reasons:`)
+        for (const reason of reasons) {
+          console.error(`  - ${reason}`)
+        }
+      }
+      return
+    }
+
+    // Change is submittable, proceed with submission
+    const result = yield* gerritApi.submitChange(changeId)
+
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<submit_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_number>${change._number}</change_number>`)
+      console.log(`  <subject><![CDATA[${change.subject}]]></subject>`)
+      console.log(`  <submit_status>${result.status}</submit_status>`)
+      console.log(`</submit_result>`)
+    } else {
+      console.log(`✓ Submitted change ${change._number}: ${change.subject}`)
+      console.log(`  Status: ${result.status}`)
+    }
+  })