@aaronshaf/ger 0.1.11 → 0.2.1

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,18 +1,8 @@
-import { Effect, pipe, Schema, Layer } from 'effect'
-import { ReviewStrategyService, type ReviewStrategy } from '@/services/review-strategy'
+import { Effect, pipe, Schema } from 'effect'
+import { ReviewStrategyService, ReviewStrategyError } from '@/services/review-strategy'
 import { commentCommandWithInput } from './comment'
 import { Console } from 'effect'
-import { type ApiError, GerritApiService } from '@/api/gerrit'
-import type { CommentInfo } from '@/schemas/gerrit'
-import { sanitizeCDATA, escapeXML } from '@/utils/shell-safety'
-import { formatDiffPretty } from '@/utils/diff-formatters'
-import { formatDate } from '@/utils/formatters'
-import {
-  formatChangeAsXML,
-  formatCommentsAsXML,
-  formatMessagesAsXML,
-  flattenComments,
-} from '@/utils/review-formatters'
+import { GerritApiService } from '@/api/gerrit'
 import { buildEnhancedPrompt } from '@/utils/review-prompt-builder'
 import * as fs from 'node:fs/promises'
 import * as fsSync from 'node:fs'
@@ -21,7 +11,7 @@ import * as path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { dirname } from 'node:path'
 import * as readline from 'node:readline'
-import { GitWorktreeService, GitWorktreeServiceLive } from '@/services/git-worktree'
+import { GitWorktreeService } from '@/services/git-worktree'
 
 // Get the directory of this module
 const __filename = fileURLToPath(import.meta.url)
@@ -122,7 +112,7 @@ const validateAndFixInlineComments = (
     for (const rawComment of rawComments) {
       // Validate comment structure using Effect Schema
       const parseResult = yield* Schema.decodeUnknown(InlineCommentSchema)(rawComment).pipe(
-        Effect.catchTag('ParseError', (parseError) =>
+        Effect.catchTag('ParseError', (_parseError) =>
           Effect.gen(function* () {
             yield* Console.warn('Skipping comment with invalid structure')
             return yield* Effect.succeed(null)
@@ -188,118 +178,6 @@ const validateAndFixInlineComments = (
     return validComments
   })
 
-// Legacy helper for backward compatibility (will be removed)
-const getChangeDataAsXml = (changeId: string): Effect.Effect<string, ApiError, GerritApiService> =>
-  Effect.gen(function* () {
-    const gerritApi = yield* GerritApiService
-
-    // Fetch all data
-    const change = yield* gerritApi.getChange(changeId)
-    const diffResult = yield* gerritApi.getDiff(changeId)
-    const diff = typeof diffResult === 'string' ? diffResult : JSON.stringify(diffResult)
-    const commentsMap = yield* gerritApi.getComments(changeId)
-    const messages = yield* gerritApi.getMessages(changeId)
-
-    const comments = flattenComments(commentsMap)
-
-    // Build XML string using helper functions
-    const xmlLines: string[] = []
-    xmlLines.push(`<?xml version="1.0" encoding="UTF-8"?>`)
-    xmlLines.push(`<show_result>`)
-    xmlLines.push(`  <status>success</status>`)
-    xmlLines.push(...formatChangeAsXML(change))
-    xmlLines.push(`  <diff><![CDATA[${sanitizeCDATA(diff)}]]></diff>`)
-    xmlLines.push(...formatCommentsAsXML(comments))
-    xmlLines.push(...formatMessagesAsXML(messages))
-    xmlLines.push(`</show_result>`)
-
-    return xmlLines.join('\n')
-  })
-
-// Helper to get change data and format as pretty string
-const getChangeDataAsPretty = (
-  changeId: string,
-): Effect.Effect<string, ApiError, GerritApiService> =>
-  Effect.gen(function* () {
-    const gerritApi = yield* GerritApiService
-
-    // Fetch all data
-    const change = yield* gerritApi.getChange(changeId)
-    const diffResult = yield* gerritApi.getDiff(changeId)
-    const diff = typeof diffResult === 'string' ? diffResult : JSON.stringify(diffResult)
-    const commentsMap = yield* gerritApi.getComments(changeId)
-    const messages = yield* gerritApi.getMessages(changeId)
-
-    const comments = flattenComments(commentsMap)
-
-    // Build pretty string
-    const lines: string[] = []
-
-    // Change details header
-    lines.push('━'.repeat(80))
-    lines.push(`📋 Change ${change._number}: ${change.subject}`)
-    lines.push('━'.repeat(80))
-    lines.push('')
-
-    // Metadata
-    lines.push('📝 Details:')
-    lines.push(`   Project: ${change.project}`)
-    lines.push(`   Branch: ${change.branch}`)
-    lines.push(`   Status: ${change.status}`)
-    lines.push(`   Owner: ${change.owner?.name || change.owner?.email || 'Unknown'}`)
-    lines.push(`   Created: ${change.created ? formatDate(change.created) : 'Unknown'}`)
-    lines.push(`   Updated: ${change.updated ? formatDate(change.updated) : 'Unknown'}`)
-    lines.push(`   Change-Id: ${change.change_id}`)
-    lines.push('')
-
-    // Diff section
-    lines.push('🔍 Diff:')
-    lines.push('─'.repeat(40))
-    lines.push(formatDiffPretty(diff))
-    lines.push('')
-
-    // Comments section
-    if (comments.length > 0) {
-      lines.push('💬 Inline Comments:')
-      lines.push('─'.repeat(40))
-      for (const comment of comments) {
-        const author = comment.author?.name || 'Unknown'
-        const date = comment.updated ? formatDate(comment.updated) : 'Unknown'
-        lines.push(`📅 ${date} - ${author}`)
-        if (comment.path) lines.push(`   File: ${comment.path}`)
-        if (comment.line) lines.push(`   Line: ${comment.line}`)
-        lines.push(`   ${comment.message}`)
-        if (comment.unresolved) lines.push(`   ⚠️ Unresolved`)
-        lines.push('')
-      }
-    }
-
-    // Messages section
-    if (messages.length > 0) {
-      lines.push('📝 Review Activity:')
-      lines.push('─'.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
-        }
-
-        lines.push(`📅 ${date} - ${author}`)
-        lines.push(`   ${cleanMessage}`)
-        lines.push('')
-      }
-    }
-
-    return lines.join('\n')
-  })
-
 // Helper function to prompt user for confirmation
 const promptUser = (message: string): Effect.Effect<boolean, never> =>
   Effect.async<boolean, never>((resume) => {
@@ -314,7 +192,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

@@ -11,6 +11,7 @@ import { AppConfig } from '@/schemas/config'
 import { Schema } from '@effect/schema'
 import { input, password } from '@inquirer/prompts'
 import { spawn } from 'node:child_process'
+import { normalizeGerritHost } from '@/utils/url-parser'
 
 // Check if a command exists on the system
 const checkCommandExists = (command: string): Promise<boolean> =>
@@ -209,7 +210,7 @@ const setupEffect = (configService: ConfigServiceImpl) =>
 
                 // Build flat config
                 const configData = {
-                  host: host.trim().replace(/\/$/, ''), // Remove trailing slash
+                  host: normalizeGerritHost(host),
                   username: username.trim(),
                   password: passwordValue,
                   ...(aiToolCommand && {
@@ -270,7 +271,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)
     }),