@aaronshaf/ger 1.2.11 → 2.0.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/groups-members.ts

@@ -0,0 +1,104 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { sanitizeCDATA } from '@/utils/shell-safety'
+
+interface GroupsMembersOptions {
+  xml?: boolean
+}
+
+/**
+ * Lists all members of a Gerrit group.
+ *
+ * @param groupId - The group ID (numeric), UUID, or group name
+ * @param options - Configuration options
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when members are listed
+ */
+export const groupsMembersCommand = (
+  groupId: string,
+  options: GroupsMembersOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Fetch group members
+    const members = yield* gerritApi.getGroupMembers(groupId).pipe(
+      Effect.catchTag('ApiError', (error) =>
+        Effect.gen(function* () {
+          if (options.xml) {
+            console.log('<?xml version="1.0" encoding="UTF-8"?>')
+            console.log('<group_members_result>')
+            console.log('  <status>error</status>')
+            console.log(`  <error><![CDATA[${sanitizeCDATA(error.message)}]]></error>`)
+            console.log('</group_members_result>')
+          } else {
+            if (error.status === 404) {
+              console.error(`✗ Group "${groupId}" not found`)
+            } else if (error.status === 403) {
+              console.error(`✗ Permission denied to view members of group "${groupId}"`)
+            } else {
+              console.error(`✗ Failed to get group members: ${error.message}`)
+            }
+          }
+          return yield* Effect.fail(error)
+        }),
+      ),
+    )
+
+    // Handle empty results
+    if (members.length === 0) {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<group_members_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <group_id><![CDATA[${sanitizeCDATA(groupId)}]]></group_id>`)
+        console.log(`  <count>0</count>`)
+        console.log(`  <members />`)
+        console.log(`</group_members_result>`)
+      } else {
+        console.log(`Group "${groupId}" has no members`)
+      }
+      return
+    }
+
+    // Output results
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<group_members_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <group_id><![CDATA[${sanitizeCDATA(groupId)}]]></group_id>`)
+      console.log(`  <count>${members.length}</count>`)
+      console.log(`  <members>`)
+      for (const member of members) {
+        console.log(`    <member>`)
+        console.log(`      <account_id>${member._account_id}</account_id>`)
+        if (member.name) {
+          console.log(`      <name><![CDATA[${sanitizeCDATA(member.name)}]]></name>`)
+        }
+        if (member.email) {
+          console.log(`      <email><![CDATA[${sanitizeCDATA(member.email)}]]></email>`)
+        }
+        if (member.username) {
+          console.log(`      <username><![CDATA[${sanitizeCDATA(member.username)}]]></username>`)
+        }
+        console.log(`    </member>`)
+      }
+      console.log(`  </members>`)
+      console.log(`</group_members_result>`)
+    } else {
+      // Plain text output
+      console.log(`Members of "${groupId}" (${members.length}):\n`)
+      for (const member of members) {
+        const name = member.name || member.username || `Account ${member._account_id}`
+        console.log(name)
+        if (member.email) {
+          console.log(`  Email: ${member.email}`)
+        }
+        if (member.username && member.username !== member.name) {
+          console.log(`  Username: ${member.username}`)
+        }
+        console.log(`  Account ID: ${member._account_id}`)
+        console.log('')
+      }
+    }
+  })

package/src/cli/commands/groups-show.ts

@@ -0,0 +1,169 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { sanitizeCDATA } from '@/utils/shell-safety'
+
+interface GroupsShowOptions {
+  xml?: boolean
+}
+
+/**
+ * Shows detailed information about a specific Gerrit group.
+ *
+ * @param groupId - The group ID (numeric), UUID, or group name
+ * @param options - Configuration options
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when group details are displayed
+ */
+export const groupsShowCommand = (
+  groupId: string,
+  options: GroupsShowOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Fetch group details (includes members and subgroups)
+    const group = yield* gerritApi.getGroupDetail(groupId).pipe(
+      Effect.catchTag('ApiError', (error) =>
+        Effect.gen(function* () {
+          if (options.xml) {
+            console.log('<?xml version="1.0" encoding="UTF-8"?>')
+            console.log('<group_detail_result>')
+            console.log('  <status>error</status>')
+            console.log(`  <error><![CDATA[${sanitizeCDATA(error.message)}]]></error>`)
+            console.log('</group_detail_result>')
+          } else {
+            if (error.status === 404) {
+              console.error(`✗ Group "${groupId}" not found`)
+            } else if (error.status === 403) {
+              console.error(`✗ Permission denied to view group "${groupId}"`)
+            } else {
+              console.error(`✗ Failed to get group details: ${error.message}`)
+            }
+          }
+          return yield* Effect.fail(error)
+        }),
+      ),
+    )
+
+    // Output results
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<group_detail_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <group>`)
+      console.log(`    <id><![CDATA[${sanitizeCDATA(group.id)}]]></id>`)
+      if (group.name) {
+        console.log(`    <name><![CDATA[${sanitizeCDATA(group.name)}]]></name>`)
+      }
+      if (group.description) {
+        console.log(
+          `    <description><![CDATA[${sanitizeCDATA(group.description)}]]></description>`,
+        )
+      }
+      if (group.owner) {
+        console.log(`    <owner><![CDATA[${sanitizeCDATA(group.owner)}]]></owner>`)
+      }
+      if (group.owner_id) {
+        console.log(`    <owner_id><![CDATA[${sanitizeCDATA(group.owner_id)}]]></owner_id>`)
+      }
+      if (group.group_id !== undefined) {
+        console.log(`    <group_id>${group.group_id}</group_id>`)
+      }
+      if (group.options?.visible_to_all !== undefined) {
+        console.log(`    <visible_to_all>${group.options.visible_to_all}</visible_to_all>`)
+      }
+      if (group.created_on) {
+        console.log(`    <created_on><![CDATA[${sanitizeCDATA(group.created_on)}]]></created_on>`)
+      }
+      if (group.url) {
+        console.log(`    <url><![CDATA[${sanitizeCDATA(group.url)}]]></url>`)
+      }
+
+      // Members
+      if (group.members && group.members.length > 0) {
+        console.log(`    <members>`)
+        for (const member of group.members) {
+          console.log(`      <member>`)
+          console.log(`        <account_id>${member._account_id}</account_id>`)
+          if (member.name) {
+            console.log(`        <name><![CDATA[${sanitizeCDATA(member.name)}]]></name>`)
+          }
+          if (member.email) {
+            console.log(`        <email><![CDATA[${sanitizeCDATA(member.email)}]]></email>`)
+          }
+          if (member.username) {
+            console.log(
+              `        <username><![CDATA[${sanitizeCDATA(member.username)}]]></username>`,
+            )
+          }
+          console.log(`      </member>`)
+        }
+        console.log(`    </members>`)
+      }
+
+      // Subgroups
+      if (group.includes && group.includes.length > 0) {
+        console.log(`    <subgroups>`)
+        for (const subgroup of group.includes) {
+          console.log(`      <subgroup>`)
+          console.log(`        <id><![CDATA[${sanitizeCDATA(subgroup.id)}]]></id>`)
+          if (subgroup.name) {
+            console.log(`        <name><![CDATA[${sanitizeCDATA(subgroup.name)}]]></name>`)
+          }
+          console.log(`      </subgroup>`)
+        }
+        console.log(`    </subgroups>`)
+      }
+
+      console.log(`  </group>`)
+      console.log(`</group_detail_result>`)
+    } else {
+      // Plain text output
+      const name = group.name || group.id
+      console.log(`Group: ${name}`)
+      console.log(`ID: ${group.id}`)
+      if (group.group_id !== undefined) {
+        console.log(`Numeric ID: ${group.group_id}`)
+      }
+      if (group.owner) {
+        console.log(`Owner: ${group.owner}`)
+      }
+      if (group.description) {
+        console.log(`Description: ${group.description}`)
+      }
+      if (group.options?.visible_to_all !== undefined) {
+        console.log(`Visible to all: ${group.options.visible_to_all ? 'Yes' : 'No'}`)
+      }
+      if (group.created_on) {
+        console.log(`Created: ${group.created_on}`)
+      }
+
+      // Members
+      if (group.members && group.members.length > 0) {
+        console.log(`\nMembers (${group.members.length}):`)
+        for (const member of group.members) {
+          const memberName = member.name || member.username || `Account ${member._account_id}`
+          console.log(`  • ${memberName}`)
+          if (member.email) {
+            console.log(`    Email: ${member.email}`)
+          }
+          if (member.username && member.username !== memberName) {
+            console.log(`    Username: ${member.username}`)
+          }
+        }
+      } else {
+        console.log(`\nMembers: None`)
+      }
+
+      // Subgroups
+      if (group.includes && group.includes.length > 0) {
+        console.log(`\nSubgroups (${group.includes.length}):`)
+        for (const subgroup of group.includes) {
+          const subgroupName = subgroup.name || subgroup.id
+          console.log(`  • ${subgroupName}`)
+        }
+      } else {
+        console.log(`\nSubgroups: None`)
+      }
+    }
+  })

package/src/cli/commands/groups.ts

@@ -0,0 +1,137 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import { sanitizeCDATA } from '@/utils/shell-safety'
+
+interface GroupsOptions {
+  pattern?: string
+  owned?: boolean
+  project?: string
+  user?: string
+  limit?: string
+  xml?: boolean
+}
+
+/**
+ * Lists Gerrit groups with optional filtering.
+ *
+ * @param options - Configuration options
+ * @param options.pattern - Optional regex pattern to filter groups by name
+ * @param options.owned - Show only groups owned by the current user
+ * @param options.project - Show groups with permissions on specific project
+ * @param options.user - Show groups a specific user belongs to
+ * @param options.limit - Maximum number of results (default: 25)
+ * @param options.xml - Whether to output in XML format for LLM consumption
+ * @returns Effect that completes when groups are listed
+ */
+export const groupsCommand = (
+  options: GroupsOptions = {},
+): Effect.Effect<void, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    const gerritApi = yield* GerritApiService
+
+    // Parse limit option
+    const limit = options.limit ? Number.parseInt(options.limit, 10) : 25
+
+    // Fetch groups
+    const groups = yield* gerritApi
+      .listGroups({
+        pattern: options.pattern,
+        owned: options.owned,
+        project: options.project,
+        user: options.user,
+        limit: Number.isNaN(limit) || limit < 1 ? 25 : limit,
+      })
+      .pipe(
+        Effect.catchTag('ApiError', (error) =>
+          Effect.gen(function* () {
+            if (options.xml) {
+              console.log('<?xml version="1.0" encoding="UTF-8"?>')
+              console.log('<groups_result>')
+              console.log('  <status>error</status>')
+              console.log(`  <error><![CDATA[${sanitizeCDATA(error.message)}]]></error>`)
+              console.log('</groups_result>')
+            } else {
+              if (error.status === 403) {
+                console.error('✗ Permission denied to list groups')
+              } else {
+                console.error(`✗ Failed to list groups: ${error.message}`)
+              }
+            }
+            return yield* Effect.fail(error)
+          }),
+        ),
+      )
+
+    // Handle empty results
+    if (groups.length === 0) {
+      if (options.xml) {
+        console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+        console.log(`<groups_result>`)
+        console.log(`  <status>success</status>`)
+        console.log(`  <count>0</count>`)
+        console.log(`  <groups />`)
+        console.log(`</groups_result>`)
+      } else {
+        console.log('No groups found')
+      }
+      return
+    }
+
+    // Output results
+    if (options.xml) {
+      console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+      console.log(`<groups_result>`)
+      console.log(`  <status>success</status>`)
+      console.log(`  <count>${groups.length}</count>`)
+      console.log(`  <groups>`)
+      for (const group of groups) {
+        console.log(`    <group>`)
+        console.log(`      <id><![CDATA[${sanitizeCDATA(group.id)}]]></id>`)
+        if (group.name) {
+          console.log(`      <name><![CDATA[${sanitizeCDATA(group.name)}]]></name>`)
+        }
+        if (group.description) {
+          console.log(
+            `      <description><![CDATA[${sanitizeCDATA(group.description)}]]></description>`,
+          )
+        }
+        if (group.owner) {
+          console.log(`      <owner><![CDATA[${sanitizeCDATA(group.owner)}]]></owner>`)
+        }
+        if (group.owner_id) {
+          console.log(`      <owner_id><![CDATA[${sanitizeCDATA(group.owner_id)}]]></owner_id>`)
+        }
+        if (group.group_id !== undefined) {
+          console.log(`      <group_id>${group.group_id}</group_id>`)
+        }
+        if (group.options?.visible_to_all !== undefined) {
+          console.log(`      <visible_to_all>${group.options.visible_to_all}</visible_to_all>`)
+        }
+        if (group.created_on) {
+          console.log(
+            `      <created_on><![CDATA[${sanitizeCDATA(group.created_on)}]]></created_on>`,
+          )
+        }
+        if (group.url) {
+          console.log(`      <url><![CDATA[${sanitizeCDATA(group.url)}]]></url>`)
+        }
+        console.log(`    </group>`)
+      }
+      console.log(`  </groups>`)
+      console.log(`</groups_result>`)
+    } else {
+      // Plain text output - more detailed than projects
+      console.log(`Available groups (${groups.length}):\n`)
+      for (const group of groups) {
+        const name = group.name || group.id
+        console.log(name)
+        if (group.description) {
+          console.log(`  Description: ${group.description}`)
+        }
+        if (group.owner) {
+          console.log(`  Owner: ${group.owner}`)
+        }
+        console.log('')
+      }
+    }
+  })