@aaronshaf/ger 0.1.10 → 0.2.0

package/src/cli/commands/extract-url.ts

@@ -0,0 +1,266 @@
+import { Effect, Schema } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { CommentInfo, MessageInfo } from '@/schemas/gerrit'
+import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
+import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
+
+// Schema for validating extract-url options
+const ExtractUrlOptionsSchema: Schema.Schema<
+  {
+    readonly includeComments?: boolean
+    readonly regex?: boolean
+    readonly xml?: boolean
+    readonly json?: boolean
+  },
+  {
+    readonly includeComments?: boolean
+    readonly regex?: boolean
+    readonly xml?: boolean
+    readonly json?: boolean
+  }
+> = Schema.Struct({
+  includeComments: Schema.optional(Schema.Boolean),
+  regex: Schema.optional(Schema.Boolean),
+  xml: Schema.optional(Schema.Boolean),
+  json: Schema.optional(Schema.Boolean),
+})
+
+export interface ExtractUrlOptions extends Schema.Schema.Type<typeof ExtractUrlOptionsSchema> {}
+
+// Schema for validating pattern input
+const PatternSchema: Schema.Schema<string, string> = Schema.String.pipe(
+  Schema.minLength(1, { message: () => 'Pattern cannot be empty' }),
+  Schema.maxLength(500, { message: () => 'Pattern is too long (max 500 characters)' }),
+)
+
+// URL matching regex - matches http:// and https:// URLs
+const URL_REGEX = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g
+
+// Regex validation error class
+export class RegexValidationError extends Error {
+  readonly _tag = 'RegexValidationError'
+  constructor(message: string) {
+    super(message)
+    this.name = 'RegexValidationError'
+  }
+}
+
+// Safely create regex with validation and timeout protection
+const createSafeRegex = (pattern: string): Effect.Effect<RegExp, RegexValidationError> =>
+  Effect.try({
+    try: () => {
+      // Validate regex complexity by checking for dangerous patterns
+      // These patterns check for nested quantifiers that can cause ReDoS
+      const dangerousPatterns = [
+        /\([^)]*[+*][^)]*\)[+*]/, // Nested quantifiers like (a+)+ or (a*)*
+        /\([^)]*[+*][^)]*\)[+*?]/, // Nested quantifiers with ? like (a+)+?
+        /\[[^\]]*\][+*]{2,}/, // Character class with multiple quantifiers like [a-z]++
+      ]
+
+      for (const dangerous of dangerousPatterns) {
+        if (dangerous.test(pattern)) {
+          throw new RegexValidationError(
+            'Pattern contains potentially dangerous nested quantifiers that could cause performance issues',
+          )
+        }
+      }
+
+      // Try to create the regex - this will throw if syntax is invalid
+      return new RegExp(pattern)
+    },
+    catch: (error) => {
+      if (error instanceof RegexValidationError) {
+        return error
+      }
+      return new RegexValidationError(
+        `Invalid regular expression: ${error instanceof Error ? error.message : String(error)}`,
+      )
+    },
+  })
+
+const extractUrlsFromText = (
+  text: string,
+  pattern: string,
+  useRegex: boolean,
+): Effect.Effect<readonly string[], RegexValidationError> =>
+  Effect.gen(function* () {
+    // First, find all URLs in the text
+    const urls = text.match(URL_REGEX) || []
+
+    // Filter URLs by pattern
+    if (useRegex) {
+      const regex = yield* createSafeRegex(pattern)
+      return urls.filter((url) => regex.test(url))
+    } else {
+      // Substring match (case-insensitive)
+      const lowerPattern = pattern.toLowerCase()
+      return urls.filter((url) => url.toLowerCase().includes(lowerPattern))
+    }
+  })
+
+const getCommentsAndMessages = (
+  changeId: string,
+): Effect.Effect<
+  { readonly comments: readonly CommentInfo[]; readonly messages: readonly 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 using functional patterns
+    const allComments = Object.entries(comments).flatMap(([path, fileComments]) =>
+      fileComments.map((comment) => ({
+        ...comment,
+        path: path === '/COMMIT_MSG' ? 'Commit Message' : path,
+      })),
+    )
+
+    // Sort inline comments by date (ascending - oldest first)
+    const sortedComments = [...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: sortedComments, messages: sortedMessages }
+  })
+
+const extractUrlsFromChange = (
+  changeId: string,
+  pattern: string,
+  options: ExtractUrlOptions,
+): Effect.Effect<readonly string[], ApiError | RegexValidationError, GerritApiService> =>
+  Effect.gen(function* () {
+    const { comments, messages } = yield* getCommentsAndMessages(changeId)
+
+    // Extract URLs from messages using functional patterns
+    const messageUrls = yield* Effect.all(
+      messages.map((message) =>
+        extractUrlsFromText(message.message, pattern, options.regex || false),
+      ),
+      { concurrency: 'unbounded' },
+    )
+
+    // Optionally extract URLs from comments
+    const commentUrls = options.includeComments
+      ? yield* Effect.all(
+          comments
+            .filter((comment) => comment.message !== undefined)
+            .map((comment) =>
+              extractUrlsFromText(comment.message!, pattern, options.regex || false),
+            ),
+          { concurrency: 'unbounded' },
+        )
+      : []
+
+    // Flatten all URLs
+    return [...messageUrls.flat(), ...commentUrls.flat()]
+  })
+
+const formatUrlsPretty = (urls: readonly string[]): Effect.Effect<void> =>
+  Effect.sync(() => {
+    for (const url of urls) {
+      console.log(url)
+    }
+  })
+
+const formatUrlsXml = (urls: readonly string[]): Effect.Effect<void> =>
+  Effect.sync(() => {
+    console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+    console.log(`<extract_url_result>`)
+    console.log(`  <status>success</status>`)
+    console.log(`  <urls>`)
+    console.log(`    <count>${urls.length}</count>`)
+    for (const url of urls) {
+      console.log(`    <url>${escapeXML(url)}</url>`)
+    }
+    console.log(`  </urls>`)
+    console.log(`</extract_url_result>`)
+  })
+
+const formatUrlsJson = (urls: readonly string[]): Effect.Effect<void> =>
+  Effect.sync(() => {
+    const output = {
+      status: 'success',
+      urls,
+    }
+    console.log(JSON.stringify(output, null, 2))
+  })
+
+export const extractUrlCommand = (
+  pattern: string,
+  changeId: string | undefined,
+  options: ExtractUrlOptions,
+): Effect.Effect<
+  void,
+  ApiError | Error | GitError | NoChangeIdError | RegexValidationError,
+  GerritApiService
+> =>
+  Effect.gen(function* () {
+    // Validate inputs using Effect Schema
+    const validatedPattern = yield* Schema.decodeUnknown(PatternSchema)(pattern)
+    const validatedOptions = yield* Schema.decodeUnknown(ExtractUrlOptionsSchema)(options)
+
+    // Auto-detect Change-ID from HEAD commit if not provided
+    const resolvedChangeId = changeId || (yield* getChangeIdFromHead())
+
+    // Extract URLs
+    const urls = yield* extractUrlsFromChange(resolvedChangeId, validatedPattern, validatedOptions)
+
+    // Format output using Effect-wrapped functions
+    if (validatedOptions.json) {
+      yield* formatUrlsJson(urls)
+    } else if (validatedOptions.xml) {
+      yield* formatUrlsXml(urls)
+    } else {
+      yield* formatUrlsPretty(urls)
+    }
+  }).pipe(
+    // Regional error boundary for the entire command
+    Effect.catchAll((error) =>
+      Effect.sync(() => {
+        const errorMessage =
+          error instanceof GitError ||
+          error instanceof NoChangeIdError ||
+          error instanceof RegexValidationError ||
+          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(`<extract_url_result>`)
+          console.log(`  <status>error</status>`)
+          console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
+          console.log(`</extract_url_result>`)
+        } else {
+          console.error(`✗ Error: ${errorMessage}`)
+        }
+      }),
+    ),
+  )

package/src/cli/commands/review.ts

@@ -1,5 +1,9 @@
 import { Effect, pipe, Schema, Layer } from 'effect'
-import { ReviewStrategyService, type ReviewStrategy } from '@/services/review-strategy'
+import {
+  ReviewStrategyService,
+  type ReviewStrategy,
+  ReviewStrategyError,
+} from '@/services/review-strategy'
 import { commentCommandWithInput } from './comment'
 import { Console } from 'effect'
 import { type ApiError, GerritApiService } from '@/api/gerrit'
@@ -314,7 +318,14 @@ const promptUser = (message: string): Effect.Effect<boolean, never> =>
     })
   })
 
-export const reviewCommand = (changeId: string, options: ReviewOptions = {}) =>
+export const reviewCommand = (
+  changeId: string,
+  options: ReviewOptions = {},
+): Effect.Effect<
+  void,
+  Error | ReviewStrategyError,
+  GerritApiService | ReviewStrategyService | GitWorktreeService
+> =>
   Effect.gen(function* () {
     const reviewStrategy = yield* ReviewStrategyService
     const gitService = yield* GitWorktreeService

package/src/cli/commands/setup.ts

@@ -270,7 +270,7 @@ const setupEffect = (configService: ConfigServiceImpl) =>
     ),
   )
 
-export async function setup() {
+export async function setup(): Promise<void> {
   const program = pipe(
     ConfigService,
     Effect.flatMap((configService) => setupEffect(configService)),

package/src/cli/commands/show.ts

@@ -6,10 +6,11 @@ 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 { sortMessagesByDate } from '@/utils/message-filters'
+import { getChangeIdFromHead, GitError, NoChangeIdError } from '@/utils/git-commit'
 
 interface ShowOptions {
   xml?: boolean
+  json?: boolean
 }
 
 interface ChangeDetails {
@@ -86,15 +87,19 @@ const getCommentsAndMessagesForChange = (
       }
     }
 
-    // Sort inline comments by path and then by line number
+    // Sort inline comments by date (ascending - oldest first)
     allComments.sort((a, b) => {
-      const pathCompare = (a.path || '').localeCompare(b.path || '')
-      if (pathCompare !== 0) return pathCompare
-      return (a.line || 0) - (b.line || 0)
+      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 (newest first)
-    const sortedMessages = sortMessagesByDate(messages)
+    // 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 }
   })
@@ -172,6 +177,74 @@ const formatShowPretty = (
   }
 }
 
+// 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 = (
+  changeDetails: ChangeDetails,
+  diff: string,
+  commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
+  messages: MessageInfo[],
+): 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,
+      }),
+    ),
+  }
+
+  console.log(JSON.stringify(output, null, 2))
+}
+
 const formatShowXml = (
   changeDetails: ChangeDetails,
   diff: string,
@@ -248,16 +321,19 @@ const formatShowXml = (
 }
 
 export const showCommand = (
-  changeId: string,
+  changeId: string | undefined,
   options: ShowOptions,
-): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+): 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(changeId),
-        getDiffForChange(changeId),
-        getCommentsAndMessagesForChange(changeId),
+        getChangeDetails(resolvedChangeId),
+        getDiffForChange(resolvedChangeId),
+        getCommentsAndMessagesForChange(resolvedChangeId),
       ],
       { concurrency: 'unbounded' },
     )
@@ -267,7 +343,7 @@ export const showCommand = (
     // Get context for each comment using concurrent requests
     const contextEffects = comments.map((comment) =>
       comment.path && comment.line
-        ? getDiffContext(changeId, comment.path, comment.line).pipe(
+        ? 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 })),
@@ -281,22 +357,40 @@ export const showCommand = (
     })
 
     // Format output
-    if (options.xml) {
+    if (options.json) {
+      formatShowJson(changeDetails, diff, commentsWithContext, messages)
+    } else if (options.xml) {
       formatShowXml(changeDetails, diff, commentsWithContext, messages)
     } else {
       formatShowPretty(changeDetails, diff, commentsWithContext, messages)
     }
   }).pipe(
     // Regional error boundary for the entire command
-    Effect.catchTag('ApiError', (error) => {
-      if (options.xml) {
+    Effect.catchAll((error) => {
+      const errorMessage =
+        error instanceof GitError || error instanceof NoChangeIdError || 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(`<show_result>`)
         console.log(`  <status>error</status>`)
-        console.log(`  <error><![CDATA[${error.message}]]></error>`)
+        console.log(`  <error><![CDATA[${sanitizeCDATA(errorMessage)}]]></error>`)
         console.log(`</show_result>`)
       } else {
-        console.error(`✗ Failed to fetch change details: ${error.message}`)
+        console.error(`✗ Error: ${errorMessage}`)
       }
       return Effect.succeed(undefined)
     }),