@aaronshaf/ger 0.1.0

package/src/cli/commands/comment.ts

@@ -0,0 +1,460 @@
+import { Schema, ParseResult, TreeFormatter } from '@effect/schema'
+import { Effect, pipe } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { ChangeInfo, ReviewInput } from '@/schemas/gerrit'
+
+interface CommentOptions {
+  message?: string
+  xml?: boolean
+  file?: string
+  line?: number
+  unresolved?: boolean
+  batch?: boolean
+}
+
+// Schema for batch input validation - array of comments
+const BatchCommentSchema = Schema.Array(
+  Schema.Struct({
+    file: Schema.String,
+    line: Schema.optional(Schema.Number), // Optional when using range
+    range: Schema.optional(
+      Schema.Struct({
+        start_line: Schema.Number,
+        end_line: Schema.Number,
+        start_character: Schema.optional(Schema.Number),
+        end_character: Schema.optional(Schema.Number),
+      }),
+    ),
+    message: Schema.String,
+    path: Schema.optional(Schema.String), // Support both 'file' and 'path' for flexibility
+    side: Schema.optional(Schema.Literal('PARENT', 'REVISION')),
+    unresolved: Schema.optional(Schema.Boolean),
+  }),
+)
+
+type BatchCommentInput = Schema.Schema.Type<typeof BatchCommentSchema>
+
+// Effect-ified stdin reader
+const readStdin = Effect.async<string, Error>((callback) => {
+  let data = ''
+
+  const onData = (chunk: Buffer | string) => {
+    data += chunk
+  }
+  const onEnd = () => callback(Effect.succeed(data))
+  const onError = (error: Error) =>
+    callback(Effect.fail(new Error(`Failed to read stdin: ${error.message}`)))
+
+  process.stdin.on('data', onData)
+  process.stdin.on('end', onEnd)
+  process.stdin.on('error', onError)
+
+  // Cleanup function
+  return Effect.sync(() => {
+    process.stdin.removeListener('data', onData)
+    process.stdin.removeListener('end', onEnd)
+    process.stdin.removeListener('error', onError)
+  })
+})
+
+// Helper to parse JSON with better error handling
+const parseJson = (data: string): Effect.Effect<unknown, Error> =>
+  Effect.try({
+    try: () => JSON.parse(data),
+    catch: (error) => {
+      const errorMsg = error instanceof Error ? error.message : 'parse error'
+      const lines = data.split('\n')
+      const lineCount = lines.length
+
+      // Show first few lines to help identify the issue
+      const preview = lines.slice(0, 10).join('\n')
+      const truncated = lineCount > 10 ? `\n... (${lineCount - 10} more lines)` : ''
+
+      return new Error(
+        `Invalid JSON input: ${errorMsg}\n` +
+          `Input (${data.length} chars, ${lineCount} lines):\n` +
+          `${preview}${truncated}\n\n` +
+          `Expected format: [{"file": "path/to/file", "line": 123, "message": "comment text"}]`,
+      )
+    },
+  })
+
+// Helper to build ReviewInput from batch data
+const buildBatchReview = (batchInput: BatchCommentInput): ReviewInput => {
+  const commentsByFile = batchInput.reduce<
+    Record<
+      string,
+      Array<{
+        line?: number
+        range?: {
+          start_line: number
+          end_line: number
+          start_character?: number
+          end_character?: number
+        }
+        message: string
+        side?: 'PARENT' | 'REVISION'
+        unresolved?: boolean
+      }>
+    >
+  >((acc, comment) => {
+    // Support both 'file' and 'path' properties
+    const filePath = comment.file || comment.path || ''
+    if (filePath && !acc[filePath]) {
+      acc[filePath] = []
+    }
+    if (filePath) {
+      // When range is present, don't include line (Gerrit API preference)
+      const commentObj: any = {
+        message: comment.message,
+        side: comment.side,
+        unresolved: comment.unresolved,
+      }
+
+      if (comment.range) {
+        commentObj.range = comment.range
+      } else if (comment.line) {
+        commentObj.line = comment.line
+      }
+
+      acc[filePath].push(commentObj)
+    }
+    return acc
+  }, {})
+
+  return {
+    comments: commentsByFile,
+  }
+}
+
+// Create ReviewInput based on options
+export const createReviewInputFromString = (
+  content: string,
+  options: CommentOptions,
+): Effect.Effect<ReviewInput, Error> => {
+  // Batch mode with provided content
+  if (options.batch) {
+    return pipe(
+      parseJson(content),
+      Effect.flatMap(
+        Schema.decodeUnknown(BatchCommentSchema, {
+          errors: 'all',
+          onExcessProperty: 'ignore',
+        }),
+      ),
+      Effect.mapError((error) => {
+        let errorMessage = 'Invalid batch input format.\n'
+        if (ParseResult.isParseError(error)) {
+          errorMessage += TreeFormatter.formatErrorSync(error)
+          errorMessage += '\n\nExpected format: [{"file": "...", "line": ..., "message": "..."}]'
+        } else if (error instanceof Error) {
+          errorMessage += error.message
+        } else {
+          errorMessage +=
+            'Expected: [{"file": "...", "line": ..., "message": "...", "side"?: "PARENT|REVISION", "range"?: {...}}]'
+        }
+        return new Error(errorMessage)
+      }),
+      Effect.map(buildBatchReview),
+    )
+  }
+
+  // Overall comment with provided content
+  const message = content.trim()
+  return message.length > 0
+    ? Effect.succeed({ message })
+    : Effect.fail(new Error('Message is required'))
+}
+
+const createReviewInput = (options: CommentOptions): Effect.Effect<ReviewInput, Error> => {
+  // Batch mode
+  if (options.batch) {
+    return pipe(
+      readStdin,
+      Effect.flatMap(parseJson),
+      Effect.flatMap(
+        Schema.decodeUnknown(BatchCommentSchema, {
+          errors: 'all',
+          onExcessProperty: 'ignore',
+        }),
+      ),
+      Effect.mapError((error) => {
+        // Extract the actual schema validation errors
+        let errorMessage = 'Invalid batch input format.\n'
+
+        if (ParseResult.isParseError(error)) {
+          // Format the parse error with details
+          errorMessage += TreeFormatter.formatErrorSync(error)
+          errorMessage += '\n\nExpected format: [{"file": "...", "line": ..., "message": "..."}]'
+        } else if (error instanceof Error) {
+          errorMessage += error.message
+        } else {
+          errorMessage +=
+            'Expected: [{"file": "...", "line": ..., "message": "...", "side"?: "PARENT|REVISION", "range"?: {...}}]'
+        }
+
+        return new Error(errorMessage)
+      }),
+      Effect.map(buildBatchReview),
+    )
+  }
+
+  // Line comment mode
+  if (options.file && options.line) {
+    return options.message
+      ? Effect.succeed({
+          comments: {
+            [options.file]: [
+              {
+                line: options.line,
+                message: options.message,
+                unresolved: options.unresolved,
+              },
+            ],
+          },
+        })
+      : Effect.fail(new Error('Message is required for line comments. Use -m "your message"'))
+  }
+
+  // Overall comment mode
+  if (options.message) {
+    return Effect.succeed({ message: options.message })
+  }
+
+  // If no message provided, read from stdin (for piping support)
+  return pipe(
+    readStdin,
+    Effect.map((stdinContent) => stdinContent.trim()),
+    Effect.flatMap((message) =>
+      message.length > 0
+        ? Effect.succeed({ message })
+        : Effect.fail(
+            new Error('Message is required. Use -m "your message" or pipe content to stdin'),
+          ),
+    ),
+  )
+}
+
+// Export a version that accepts direct input instead of reading stdin
+export const commentCommandWithInput = (
+  changeId: string,
+  input: string,
+  options: CommentOptions,
+): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+  Effect.gen(function* () {
+    const apiService = yield* GerritApiService
+
+    // Build the review input from provided string
+    const review = yield* createReviewInputFromString(input, options)
+
+    // Execute the API calls in sequence
+    const change = yield* pipe(
+      apiService.getChange(changeId),
+      Effect.mapError((error) =>
+        error._tag === 'ApiError' ? new Error(`Failed to get change: ${error.message}`) : error,
+      ),
+    )
+
+    yield* pipe(
+      apiService.postReview(changeId, review),
+      Effect.mapError((error) => {
+        if (error._tag === 'ApiError') {
+          // Build detailed error context for batch comments
+          if (options.batch && review.comments) {
+            const commentDetails = Object.entries(review.comments)
+              .flatMap(([file, comments]) =>
+                comments.map((comment) => {
+                  const parts = [`${file}:${comment.line || 'range'}`]
+                  if (comment.message?.length > 50) {
+                    parts.push(`"${comment.message.slice(0, 50)}..."`)
+                  } else {
+                    parts.push(`"${comment.message}"`)
+                  }
+                  return parts.join(' ')
+                }),
+              )
+              .join(', ')
+
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post: ${commentDetails}`,
+            )
+          }
+
+          // Single line comment context
+          if (options.file && options.line) {
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post to ${options.file}:${options.line}: "${options.message}"`,
+            )
+          }
+
+          // Overall comment context
+          if (options.message) {
+            const msg =
+              options.message.length > 50 ? `${options.message.slice(0, 50)}...` : options.message
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post overall comment: "${msg}"`,
+            )
+          }
+
+          return new Error(`Failed to post comment: ${error.message}`)
+        }
+        return error
+      }),
+    )
+
+    // Format and display output
+    yield* formatOutput(change, review, options, changeId)
+  })
+
+export const commentCommand = (
+  changeId: string,
+  options: CommentOptions,
+): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+  Effect.gen(function* () {
+    const apiService = yield* GerritApiService
+
+    // Build the review input
+    const review = yield* createReviewInput(options)
+
+    // Execute the API calls in sequence
+    const change = yield* pipe(
+      apiService.getChange(changeId),
+      Effect.mapError((error) =>
+        error._tag === 'ApiError' ? new Error(`Failed to get change: ${error.message}`) : error,
+      ),
+    )
+
+    yield* pipe(
+      apiService.postReview(changeId, review),
+      Effect.mapError((error) => {
+        if (error._tag === 'ApiError') {
+          // Build detailed error context for batch comments
+          if (options.batch && review.comments) {
+            const commentDetails = Object.entries(review.comments)
+              .flatMap(([file, comments]) =>
+                comments.map((comment) => {
+                  const parts = [`${file}:${comment.line || 'range'}`]
+                  if (comment.message?.length > 50) {
+                    parts.push(`"${comment.message.slice(0, 50)}..."`)
+                  } else {
+                    parts.push(`"${comment.message}"`)
+                  }
+                  return parts.join(' ')
+                }),
+              )
+              .join(', ')
+
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post: ${commentDetails}`,
+            )
+          }
+
+          // Single line comment context
+          if (options.file && options.line) {
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post to ${options.file}:${options.line}: "${options.message}"`,
+            )
+          }
+
+          // Overall comment context
+          if (options.message) {
+            const msg =
+              options.message.length > 50 ? `${options.message.slice(0, 50)}...` : options.message
+            return new Error(
+              `Failed to post comment: ${error.message}\nTried to post overall comment: "${msg}"`,
+            )
+          }
+
+          return new Error(`Failed to post comment: ${error.message}`)
+        }
+        return error
+      }),
+    )
+
+    // Format and display output
+    yield* formatOutput(change, review, options, changeId)
+  })
+
+// Helper to format XML output
+const formatXmlOutput = (
+  change: ChangeInfo,
+  review: ReviewInput,
+  options: CommentOptions,
+  changeId: string,
+): Effect.Effect<void> =>
+  Effect.sync(() => {
+    const lines: string[] = [
+      `<?xml version="1.0" encoding="UTF-8"?>`,
+      `<comment_result>`,
+      `  <status>success</status>`,
+      `  <change_id>${changeId}</change_id>`,
+      `  <change_number>${change._number}</change_number>`,
+      `  <change_subject><![CDATA[${change.subject}]]></change_subject>`,
+      `  <change_status>${change.status}</change_status>`,
+    ]
+
+    if (options.batch && review.comments) {
+      lines.push(`  <comments>`)
+      for (const [file, comments] of Object.entries(review.comments)) {
+        for (const comment of comments) {
+          lines.push(`    <comment>`)
+          lines.push(`      <file>${file}</file>`)
+          if (comment.line) lines.push(`      <line>${comment.line}</line>`)
+          lines.push(`      <message><![CDATA[${comment.message}]]></message>`)
+          if (comment.unresolved) lines.push(`      <unresolved>true</unresolved>`)
+          lines.push(`    </comment>`)
+        }
+      }
+      lines.push(`  </comments>`)
+    } else if (options.file && options.line) {
+      lines.push(`  <comment>`)
+      lines.push(`    <file>${options.file}</file>`)
+      lines.push(`    <line>${options.line}</line>`)
+      lines.push(`    <message><![CDATA[${options.message}]]></message>`)
+      if (options.unresolved) lines.push(`    <unresolved>true</unresolved>`)
+      lines.push(`  </comment>`)
+    } else {
+      lines.push(`  <message><![CDATA[${options.message}]]></message>`)
+    }
+
+    lines.push(`</comment_result>`)
+    for (const line of lines) {
+      console.log(line)
+    }
+  })
+
+// Helper to format human-readable output
+const formatHumanOutput = (
+  change: ChangeInfo,
+  review: ReviewInput,
+  options: CommentOptions,
+): Effect.Effect<void> =>
+  Effect.sync(() => {
+    console.log(`✓ Comment posted successfully!`)
+    console.log(`Change: ${change.subject} (${change.status})`)
+
+    if (options.batch && review.comments) {
+      const totalComments = Object.values(review.comments).reduce(
+        (sum, comments) => sum + comments.length,
+        0,
+      )
+      console.log(`Posted ${totalComments} line comment(s)`)
+    } else if (options.file && options.line) {
+      console.log(`File: ${options.file}, Line: ${options.line}`)
+      console.log(`Message: ${options.message}`)
+      if (options.unresolved) console.log(`Status: Unresolved`)
+    } else {
+      console.log(`Message: ${review.message}`)
+    }
+  })
+
+// Main output formatter
+const formatOutput = (
+  change: ChangeInfo,
+  review: ReviewInput,
+  options: CommentOptions,
+  changeId: string,
+): Effect.Effect<void> =>
+  options.xml
+    ? formatXmlOutput(change, review, options, changeId)
+    : formatHumanOutput(change, review, options)

package/src/cli/commands/comments.ts

@@ -0,0 +1,85 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { CommentInfo } from '@/schemas/gerrit'
+import { formatCommentsPretty, formatCommentsXml } from '@/utils/comment-formatters'
+import { getDiffContext } from '@/utils/diff-context'
+
+interface CommentsOptions {
+  xml?: boolean
+}
+
+const getCommentsForChange = (
+  changeId: string,
+): Effect.Effect<CommentInfo[], ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Get all comments for the change - let errors propagate for proper handling
+    const comments = yield* gerritApi.getComments(changeId)
+
+    // Flatten all 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 by path and then by line number
+    allComments.sort((a, b) => {
+      const pathCompare = (a.path || '').localeCompare(b.path || '')
+      if (pathCompare !== 0) return pathCompare
+      return (a.line || 0) - (b.line || 0)
+    })
+
+    return allComments
+  })
+
+export const commentsCommand = (
+  changeId: string,
+  options: CommentsOptions,
+): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+  Effect.gen(function* () {
+    // Get all comments
+    const comments = yield* getCommentsForChange(changeId)
+
+    // Get context for each comment using concurrent requests with unbounded concurrency
+    const contextEffects = comments.map((comment) =>
+      comment.path && comment.line
+        ? getDiffContext(changeId, 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 with unbounded concurrency
+    const commentsWithContext = yield* Effect.all(contextEffects, {
+      concurrency: 'unbounded',
+    })
+
+    // Format output
+    if (options.xml) {
+      formatCommentsXml(changeId, commentsWithContext)
+    } else {
+      formatCommentsPretty(commentsWithContext)
+    }
+  }).pipe(
+    // Regional error boundary for the entire command
+    Effect.catchTag('ApiError', (error) => {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<comments_result>`)
+        console.log(`  <status>error</status>`)
+        console.log(`  <error><![CDATA[${error.message}]]></error>`)
+        console.log(`</comments_result>`)
+      } else {
+        console.error(`✗ Failed to fetch comments: ${error.message}`)
+      }
+      return Effect.succeed(undefined)
+    }),
+  )

package/src/cli/commands/diff.ts

@@ -0,0 +1,71 @@
+import { Schema } from '@effect/schema'
+import { Effect, pipe } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { DiffOptions, DiffCommandOptions } from '@/schemas/gerrit'
+import { DiffCommandOptions as DiffCommandOptionsSchema } from '@/schemas/gerrit'
+import { formatDiffPretty, formatFilesList } from '@/utils/diff-formatters'
+import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
+
+export const diffCommand = (
+  changeId: string,
+  options: DiffCommandOptions,
+): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+  Effect.gen(function* () {
+    // Validate input options using Effect Schema
+    const validatedOptions = yield* pipe(
+      options,
+      Schema.decodeUnknown(DiffCommandOptionsSchema, {
+        errors: 'all',
+        onExcessProperty: 'ignore',
+      }),
+      Effect.mapError(() => new Error('Invalid diff command options')),
+    )
+    const apiService = yield* GerritApiService
+
+    const diffOptions: DiffOptions = {
+      format: validatedOptions.filesOnly ? 'files' : validatedOptions.format || 'unified',
+      file: validatedOptions.file,
+    }
+
+    const diff = yield* apiService
+      .getDiff(changeId, diffOptions)
+      .pipe(
+        Effect.catchTag('ApiError', (error) =>
+          Effect.fail(new Error(`Failed to get diff: ${error.message}`)),
+        ),
+      )
+
+    if (validatedOptions.xml) {
+      // XML output for LLM consumption
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<diff_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <change_id>${escapeXML(changeId)}</change_id>`)
+
+      if (Array.isArray(diff)) {
+        console.log(`  <files>`)
+        diff.forEach((file) => {
+          console.log(`    <file>${escapeXML(file)}</file>`)
+        })
+        console.log(`  </files>`)
+      } else if (typeof diff === 'string') {
+        console.log(`  <content><![CDATA[${sanitizeCDATA(diff)}]]></content>`)
+      } else {
+        console.log(
+          `  <content><![CDATA[${sanitizeCDATA(JSON.stringify(diff, null, 2))}]]></content>`,
+        )
+      }
+
+      console.log(`</diff_result>`)
+    } else {
+      // Human-readable output (default) - pretty formatted
+      if (Array.isArray(diff)) {
+        console.log(formatFilesList(diff))
+      } else if (typeof diff === 'string') {
+        console.log(formatDiffPretty(diff))
+      } else {
+        // JSON data - format as pretty JSON for readability
+        console.log(JSON.stringify(diff, null, 2))
+      }
+    }
+  })