@aaronshaf/ger 0.1.0

package/src/cli/commands/setup.ts

@@ -0,0 +1,230 @@
+import chalk from 'chalk'
+import { Effect, pipe, Console } from 'effect'
+import {
+  ConfigService,
+  ConfigServiceLive,
+  ConfigError,
+  type ConfigServiceImpl,
+} from '@/services/config'
+import type { GerritCredentials } from '@/schemas/gerrit'
+import { AppConfig } from '@/schemas/config'
+import { Schema } from '@effect/schema'
+import { input, password } from '@inquirer/prompts'
+import { spawn } from 'node:child_process'
+
+// Check if a command exists on the system
+const checkCommandExists = (command: string): Promise<boolean> =>
+  new Promise((resolve) => {
+    const child = spawn('which', [command], { stdio: 'ignore' })
+    child.on('close', (code) => {
+      resolve(code === 0)
+    })
+    child.on('error', () => {
+      resolve(false)
+    })
+  })
+
+// AI tools to check for in order of preference
+const AI_TOOLS = ['claude', 'llm', 'opencode', 'gemini'] as const
+
+// Effect wrapper for detecting available AI tools
+const detectAvailableAITools = () =>
+  Effect.tryPromise({
+    try: async () => {
+      const availableTools: string[] = []
+
+      for (const tool of AI_TOOLS) {
+        const exists = await checkCommandExists(tool)
+        if (exists) {
+          availableTools.push(tool)
+        }
+      }
+
+      return availableTools
+    },
+    catch: (error) => new ConfigError({ message: `Failed to detect AI tools: ${error}` }),
+  })
+
+// Effect wrapper for getting existing config
+const getExistingConfig = (configService: ConfigServiceImpl) =>
+  configService.getFullConfig.pipe(Effect.orElseSucceed(() => null))
+
+// Test connection with credentials
+const verifyCredentials = (credentials: GerritCredentials) =>
+  Effect.tryPromise({
+    try: async () => {
+      const auth = Buffer.from(`${credentials.username}:${credentials.password}`).toString('base64')
+      const response = await fetch(`${credentials.host}/a/config/server/version`, {
+        headers: { Authorization: `Basic ${auth}` },
+      })
+
+      if (!response.ok) {
+        throw new Error(`Authentication failed: ${response.status}`)
+      }
+
+      return response.ok
+    },
+    catch: (error) => {
+      if (error instanceof Error) {
+        if (error.message.includes('401')) {
+          return new ConfigError({
+            message: 'Invalid credentials. Please check your username and password.',
+          })
+        }
+        if (error.message.includes('ENOTFOUND')) {
+          return new ConfigError({ message: 'Could not connect to Gerrit. Please check the URL.' })
+        }
+        return new ConfigError({ message: error.message })
+      }
+      return new ConfigError({ message: 'Unknown error occurred' })
+    },
+  })
+
+// Pure Effect-based setup implementation using inquirer
+const setupEffect = (configService: ConfigServiceImpl) =>
+  pipe(
+    Effect.all([getExistingConfig(configService), detectAvailableAITools()]),
+    Effect.flatMap(([existingConfig, availableTools]) =>
+      pipe(
+        Console.log(chalk.bold('🔧 Gerrit CLI Setup')),
+        Effect.flatMap(() => Console.log('')),
+        Effect.flatMap(() => {
+          if (existingConfig) {
+            return Console.log(chalk.dim('(Press Enter to keep existing values)'))
+          } else {
+            return pipe(
+              Console.log(chalk.cyan('Please provide your Gerrit connection details:')),
+              Effect.flatMap(() =>
+                Console.log(chalk.dim('Example URL: https://gerrit.example.com')),
+              ),
+              Effect.flatMap(() =>
+                Console.log(
+                  chalk.dim(
+                    'You can find your HTTP password in Gerrit Settings > HTTP Credentials',
+                  ),
+                ),
+              ),
+            )
+          }
+        }),
+        Effect.flatMap(() =>
+          Effect.tryPromise({
+            try: async () => {
+              console.log('')
+
+              // Gerrit Host URL
+              const host = await input({
+                message: 'Gerrit Host URL (e.g., https://gerrit.example.com)',
+                default: existingConfig?.host,
+              })
+
+              // Username
+              const username = await input({
+                message: 'Username (your Gerrit username)',
+                default: existingConfig?.username,
+              })
+
+              // Password - similar to ji's pattern
+              const passwordValue =
+                (await password({
+                  message: 'HTTP Password (generated from Gerrit settings)',
+                })) ||
+                existingConfig?.password ||
+                ''
+
+              console.log('')
+              console.log(chalk.yellow('Optional: AI Configuration'))
+
+              // Show detected AI tools
+              if (availableTools.length > 0) {
+                console.log(chalk.dim(`Detected AI tools: ${availableTools.join(', ')}`))
+              }
+
+              // Get default suggestion
+              const defaultCommand =
+                existingConfig?.aiTool ||
+                (availableTools.includes('claude') ? 'claude' : availableTools[0]) ||
+                ''
+
+              // AI tool command with smart default
+              const aiToolCommand = await input({
+                message:
+                  availableTools.length > 0
+                    ? 'AI tool command (detected from system)'
+                    : 'AI tool command (e.g., claude, llm, opencode, gemini)',
+                default: defaultCommand || 'claude',
+              })
+
+              // Build flat config
+              const configData = {
+                host: host.trim().replace(/\/$/, ''), // Remove trailing slash
+                username: username.trim(),
+                password: passwordValue,
+                ...(aiToolCommand && {
+                  aiTool: aiToolCommand,
+                }),
+                aiAutoDetect: !aiToolCommand,
+              }
+
+              // Validate config using Schema instead of type assertion
+              const fullConfig = Schema.decodeUnknownSync(AppConfig)(configData)
+
+              return fullConfig
+            },
+            catch: (error) => {
+              if (error instanceof Error && error.message.includes('User force closed')) {
+                console.log(`\n${chalk.yellow('Setup cancelled')}`)
+                process.exit(0)
+              }
+              return new ConfigError({
+                message: error instanceof Error ? error.message : 'Failed to get user input',
+              })
+            },
+          }),
+        ),
+      ),
+    ),
+    Effect.tap(() => Console.log('\nVerifying credentials...')),
+    Effect.flatMap((config) =>
+      pipe(
+        verifyCredentials({
+          host: config.host,
+          username: config.username,
+          password: config.password,
+        }),
+        Effect.map(() => config),
+      ),
+    ),
+    Effect.tap(() => Console.log(chalk.green('Successfully authenticated'))),
+    Effect.flatMap((config) => configService.saveFullConfig(config)),
+    Effect.tap(() => Console.log(chalk.green('\nConfiguration saved successfully!'))),
+    Effect.tap(() => Console.log('You can now use:')),
+    Effect.tap(() => Console.log('  • "ger mine" to view your changes')),
+    Effect.tap(() => Console.log('  • "ger show <change-id>" to view change details')),
+    Effect.tap(() => Console.log('  • "ger review <change-id>" to review with AI')),
+    Effect.catchAll((error) =>
+      pipe(
+        Console.error(
+          chalk.red(
+            `\nAuthentication failed: ${error instanceof ConfigError ? error.message : 'Unknown error'}`,
+          ),
+        ),
+        Effect.flatMap(() => Console.error('Please check your credentials and try again.')),
+        Effect.flatMap(() => Effect.fail(error)),
+      ),
+    ),
+  )
+
+export async function setup() {
+  const program = pipe(
+    ConfigService,
+    Effect.flatMap((configService) => setupEffect(configService)),
+  ).pipe(Effect.provide(ConfigServiceLive))
+
+  try {
+    await Effect.runPromise(program)
+  } catch {
+    // Error already handled and displayed
+    process.exit(1)
+  }
+}

package/src/cli/commands/show.ts

@@ -0,0 +1,303 @@
+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 { sortMessagesByDate } from '@/utils/message-filters'
+
+interface ShowOptions {
+  xml?: 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 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)
+    })
+
+    // Sort messages by date (newest first)
+    const sortedMessages = sortMessagesByDate(messages)
+
+    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.')
+  }
+}
+
+const formatShowXml = (
+  changeDetails: ChangeDetails,
+  diff: string,
+  commentsWithContext: Array<{ comment: CommentInfo; context?: any }>,
+  messages: MessageInfo[],
+): void => {
+  console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+  console.log(`<show_result>`)
+  console.log(`  <status>success</status>`)
+  console.log(`  <change>`)
+  console.log(`    <id>${escapeXML(changeDetails.id)}</id>`)
+  console.log(`    <number>${changeDetails.number}</number>`)
+  console.log(`    <subject><![CDATA[${sanitizeCDATA(changeDetails.subject)}]]></subject>`)
+  console.log(`    <status>${escapeXML(changeDetails.status)}</status>`)
+  console.log(`    <project>${escapeXML(changeDetails.project)}</project>`)
+  console.log(`    <branch>${escapeXML(changeDetails.branch)}</branch>`)
+  console.log(`    <owner>`)
+  if (changeDetails.owner.name) {
+    console.log(`      <name><![CDATA[${sanitizeCDATA(changeDetails.owner.name)}]]></name>`)
+  }
+  if (changeDetails.owner.email) {
+    console.log(`      <email>${escapeXML(changeDetails.owner.email)}</email>`)
+  }
+  console.log(`    </owner>`)
+  console.log(`    <created>${escapeXML(changeDetails.created || '')}</created>`)
+  console.log(`    <updated>${escapeXML(changeDetails.updated || '')}</updated>`)
+  console.log(`  </change>`)
+  console.log(`  <diff><![CDATA[${sanitizeCDATA(diff)}]]></diff>`)
+
+  // Comments section
+  console.log(`  <comments>`)
+  console.log(`    <count>${commentsWithContext.length}</count>`)
+  for (const { comment } of commentsWithContext) {
+    console.log(`    <comment>`)
+    if (comment.id) console.log(`      <id>${escapeXML(comment.id)}</id>`)
+    if (comment.path) console.log(`      <path><![CDATA[${sanitizeCDATA(comment.path)}]]></path>`)
+    if (comment.line) console.log(`      <line>${comment.line}</line>`)
+    if (comment.author?.name) {
+      console.log(`      <author><![CDATA[${sanitizeCDATA(comment.author.name)}]]></author>`)
+    }
+    if (comment.updated) console.log(`      <updated>${escapeXML(comment.updated)}</updated>`)
+    if (comment.message) {
+      console.log(`      <message><![CDATA[${sanitizeCDATA(comment.message)}]]></message>`)
+    }
+    if (comment.unresolved) console.log(`      <unresolved>true</unresolved>`)
+    console.log(`    </comment>`)
+  }
+  console.log(`  </comments>`)
+
+  // Messages section
+  console.log(`  <messages>`)
+  console.log(`    <count>${messages.length}</count>`)
+  for (const message of messages) {
+    console.log(`    <message>`)
+    console.log(`      <id>${escapeXML(message.id)}</id>`)
+    if (message.author?.name) {
+      console.log(`      <author><![CDATA[${sanitizeCDATA(message.author.name)}]]></author>`)
+    }
+    if (message.author?._account_id) {
+      console.log(`      <author_id>${message.author._account_id}</author_id>`)
+    }
+    console.log(`      <date>${escapeXML(message.date)}</date>`)
+    if (message._revision_number) {
+      console.log(`      <revision>${message._revision_number}</revision>`)
+    }
+    if (message.tag) {
+      console.log(`      <tag>${escapeXML(message.tag)}</tag>`)
+    }
+    console.log(`      <message><![CDATA[${sanitizeCDATA(message.message)}]]></message>`)
+    console.log(`    </message>`)
+  }
+  console.log(`  </messages>`)
+  console.log(`</show_result>`)
+}
+
+export const showCommand = (
+  changeId: string,
+  options: ShowOptions,
+): Effect.Effect<void, ApiError | Error, GerritApiService> =>
+  Effect.gen(function* () {
+    // Fetch all data concurrently
+    const [changeDetails, diff, commentsAndMessages] = yield* Effect.all(
+      [
+        getChangeDetails(changeId),
+        getDiffForChange(changeId),
+        getCommentsAndMessagesForChange(changeId),
+      ],
+      { concurrency: 'unbounded' },
+    )
+
+    const { comments, messages } = commentsAndMessages
+
+    // Get context for each comment using concurrent requests
+    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
+    const commentsWithContext = yield* Effect.all(contextEffects, {
+      concurrency: 'unbounded',
+    })
+
+    // Format output
+    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) {
+        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(`</show_result>`)
+      } else {
+        console.error(`✗ Failed to fetch change details: ${error.message}`)
+      }
+      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'))
+    }
+  })