@aaronshaf/ger 0.1.0

package/src/services/config.ts

@@ -0,0 +1,206 @@
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { Schema } from '@effect/schema'
+import { Context, Effect, Layer } from 'effect'
+import { GerritCredentials } from '@/schemas/gerrit'
+import { AiConfig, AppConfig, aiConfigFromFlat, migrateFromNestedConfig } from '@/schemas/config'
+
+export interface ConfigServiceImpl {
+  readonly getCredentials: Effect.Effect<GerritCredentials, ConfigError>
+  readonly saveCredentials: (credentials: GerritCredentials) => Effect.Effect<void, ConfigError>
+  readonly deleteCredentials: Effect.Effect<void, ConfigError>
+  readonly getAiConfig: Effect.Effect<AiConfig, ConfigError>
+  readonly saveAiConfig: (config: AiConfig) => Effect.Effect<void, ConfigError>
+  readonly getFullConfig: Effect.Effect<AppConfig, ConfigError>
+  readonly saveFullConfig: (config: AppConfig) => Effect.Effect<void, ConfigError>
+}
+
+export class ConfigService extends Context.Tag('ConfigService')<
+  ConfigService,
+  ConfigServiceImpl
+>() {}
+
+export class ConfigError extends Schema.TaggedError<ConfigError>()('ConfigError', {
+  message: Schema.String,
+} as const) {}
+
+// File-based storage
+const CONFIG_DIR = path.join(os.homedir(), '.ger')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+const readFileConfig = (): unknown | null => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const content = fs.readFileSync(CONFIG_FILE, 'utf8')
+      const parsed = JSON.parse(content)
+
+      // Check if this is the old nested format and migrate if needed
+      if (parsed && typeof parsed === 'object' && 'credentials' in parsed) {
+        // Migrate from nested format to flat format with validation
+        const migrated = migrateFromNestedConfig(parsed)
+
+        // Save the migrated config immediately
+        try {
+          writeFileConfig(migrated)
+        } catch (error) {
+          // Log migration write failure but continue to return migrated config
+          console.warn('Warning: Failed to save migrated config to disk:', error)
+          // Config migration succeeded in memory, user can still proceed
+        }
+
+        return migrated
+      }
+
+      return parsed
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null
+}
+
+const writeFileConfig = (config: AppConfig): void => {
+  // Ensure config directory exists
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 })
+  }
+
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8')
+  // Set restrictive permissions
+  fs.chmodSync(CONFIG_FILE, 0o600)
+}
+
+const deleteFileConfig = (): void => {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      fs.unlinkSync(CONFIG_FILE)
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+export const ConfigServiceLive: Layer.Layer<ConfigService, never, never> = Layer.effect(
+  ConfigService,
+  Effect.sync(() => {
+    const getFullConfig = Effect.gen(function* () {
+      const fileContent = readFileConfig()
+      if (!fileContent) {
+        return yield* Effect.fail(
+          new ConfigError({
+            message: 'Configuration not found. Run "ger setup" to set up your credentials.',
+          }),
+        )
+      }
+
+      // Parse as flat config
+      const fullConfigResult = yield* Schema.decodeUnknown(AppConfig)(fileContent).pipe(
+        Effect.mapError(() => new ConfigError({ message: 'Invalid configuration format' })),
+      )
+
+      return fullConfigResult
+    })
+
+    const saveFullConfig = (config: AppConfig) =>
+      Effect.gen(function* () {
+        // Validate config using schema
+        const validatedConfig = yield* Schema.decodeUnknown(AppConfig)(config).pipe(
+          Effect.mapError(() => new ConfigError({ message: 'Invalid configuration format' })),
+        )
+
+        try {
+          writeFileConfig(validatedConfig)
+        } catch {
+          yield* Effect.fail(new ConfigError({ message: 'Failed to save configuration to file' }))
+        }
+      })
+
+    const getCredentials = Effect.gen(function* () {
+      const config = yield* getFullConfig
+      return {
+        host: config.host,
+        username: config.username,
+        password: config.password,
+      }
+    })
+
+    const saveCredentials = (credentials: GerritCredentials) =>
+      Effect.gen(function* () {
+        // Validate credentials using schema
+        const validatedCredentials = yield* Schema.decodeUnknown(GerritCredentials)(
+          credentials,
+        ).pipe(Effect.mapError(() => new ConfigError({ message: 'Invalid credentials format' })))
+
+        // Get existing config or create new one
+        const existingConfig = yield* getFullConfig.pipe(
+          Effect.orElseSucceed(() => {
+            // Create default config using Schema validation instead of type assertion
+            const defaultConfig = {
+              host: validatedCredentials.host,
+              username: validatedCredentials.username,
+              password: validatedCredentials.password,
+              aiAutoDetect: true,
+            }
+            // Validate the default config structure
+            return Schema.decodeUnknownSync(AppConfig)(defaultConfig)
+          }),
+        )
+
+        // Update credentials in flat config
+        const updatedConfig: AppConfig = {
+          ...existingConfig,
+          host: validatedCredentials.host,
+          username: validatedCredentials.username,
+          password: validatedCredentials.password,
+        }
+
+        yield* saveFullConfig(updatedConfig)
+      })
+
+    const deleteCredentials = Effect.gen(function* () {
+      try {
+        deleteFileConfig()
+        yield* Effect.void
+      } catch {
+        // Ignore errors
+        yield* Effect.void
+      }
+    })
+
+    const getAiConfig = Effect.gen(function* () {
+      const config = yield* getFullConfig
+      return aiConfigFromFlat(config)
+    })
+
+    const saveAiConfig = (aiConfig: AiConfig) =>
+      Effect.gen(function* () {
+        // Validate AI config using schema
+        const validatedAiConfig = yield* Schema.decodeUnknown(AiConfig)(aiConfig).pipe(
+          Effect.mapError(() => new ConfigError({ message: 'Invalid AI configuration format' })),
+        )
+
+        // Get existing config
+        const existingConfig = yield* getFullConfig
+
+        // Update AI config in flat structure
+        const updatedConfig: AppConfig = {
+          ...existingConfig,
+          aiTool: validatedAiConfig.tool,
+          aiAutoDetect: validatedAiConfig.autoDetect,
+        }
+
+        yield* saveFullConfig(updatedConfig)
+      })
+
+    return {
+      getCredentials,
+      saveCredentials,
+      deleteCredentials,
+      getAiConfig,
+      saveAiConfig,
+      getFullConfig,
+      saveFullConfig,
+    }
+  }),
+)

package/src/test-utils/mock-generator.ts

@@ -0,0 +1,73 @@
+import type { Schema } from '@effect/schema'
+import type { ChangeInfo, FileDiffContent, FileInfo } from '@/schemas/gerrit'
+
+export const generateMockChange = (
+  overrides?: Partial<Schema.Schema.Type<typeof ChangeInfo>>,
+): Schema.Schema.Type<typeof ChangeInfo> => {
+  const base: Schema.Schema.Type<typeof ChangeInfo> = {
+    id: 'myProject~master~I8473b95934b5732ac55d26311a706c9c2bde9940',
+    project: 'myProject',
+    branch: 'master',
+    change_id: 'I8473b95934b5732ac55d26311a706c9c2bde9940',
+    subject: 'Implementing new feature',
+    status: 'NEW' as const,
+    created: '2023-12-01 10:00:00.000000000',
+    updated: '2023-12-01 15:30:00.000000000',
+    insertions: 25,
+    deletions: 3,
+    _number: 12345,
+    owner: {
+      _account_id: 1000096,
+      name: 'John Developer',
+      email: 'john@example.com',
+      username: 'jdeveloper',
+    },
+  }
+
+  return { ...base, ...overrides }
+}
+
+export const generateMockFiles = (): Record<string, Schema.Schema.Type<typeof FileInfo>> => {
+  return {
+    'src/main.ts': {
+      status: 'M' as const,
+      lines_inserted: 15,
+      lines_deleted: 3,
+      size_delta: 120,
+      size: 1200,
+    },
+    'tests/main.test.ts': {
+      status: 'A' as const,
+      lines_inserted: 45,
+      lines_deleted: 0,
+      size_delta: 450,
+      size: 450,
+    },
+  }
+}
+
+export const generateMockFileDiff = (): Schema.Schema.Type<typeof FileDiffContent> => {
+  return {
+    content: [
+      {
+        ab: ['function main() {', '  console.log("Hello, world!")'],
+      },
+      {
+        a: ['  return 0'],
+        b: ['  return process.exit(0)'],
+      },
+      {
+        ab: ['}'],
+      },
+    ],
+    change_type: 'MODIFIED' as const,
+    diff_header: ['--- a/src/main.ts', '+++ b/src/main.ts'],
+  }
+}
+
+export const generateMockAccount = () => ({
+  _account_id: 1000096,
+  name: 'Test User',
+  email: 'test@example.com',
+  username: 'testuser',
+})

package/src/utils/comment-formatters.ts

@@ -0,0 +1,153 @@
+import type { CommentInfo } from '@/schemas/gerrit'
+import { colors, formatDate } from './formatters'
+
+export interface CommentWithContext {
+  comment: CommentInfo
+  context?: {
+    before: string[]
+    line?: string
+    after: string[]
+  }
+}
+
+export const formatCommentsPretty = (comments: CommentWithContext[]): void => {
+  if (comments.length === 0) {
+    console.log('No comments found on this change')
+    return
+  }
+
+  console.log(`Found ${comments.length} comment${comments.length === 1 ? '' : 's'}:\n`)
+
+  let currentPath: string | undefined
+
+  for (const { comment, context } of comments) {
+    // Group by file
+    if (comment.path !== currentPath) {
+      currentPath = comment.path
+      console.log(`${colors.blue}═══ ${currentPath} ═══${colors.reset}`)
+    }
+
+    // Comment metadata
+    const author = comment.author?.name || 'Unknown'
+    const date = comment.updated ? formatDate(comment.updated) : ''
+    const status = comment.unresolved ? `${colors.yellow}[UNRESOLVED]${colors.reset} ` : ''
+
+    console.log(`\n${status}${colors.dim}${author} • ${date}${colors.reset}`)
+
+    if (comment.line) {
+      console.log(`${colors.dim}Line ${comment.line}:${colors.reset}`)
+
+      // Show context if available
+      if (context && (context.before.length > 0 || context.line || context.after.length > 0)) {
+        console.log(`${colors.dim}───────────────────${colors.reset}`)
+        for (const line of context.before) {
+          console.log(`${colors.dim}  ${line}${colors.reset}`)
+        }
+        if (context.line) {
+          console.log(`${colors.green}> ${context.line}${colors.reset}`)
+        }
+        for (const line of context.after) {
+          console.log(`${colors.dim}  ${line}${colors.reset}`)
+        }
+        console.log(`${colors.dim}───────────────────${colors.reset}`)
+      }
+    }
+
+    // Comment message (indent each line)
+    const messageLines = comment.message.split('\n')
+    for (const line of messageLines) {
+      console.log(`  ${line}`)
+    }
+  }
+}
+
+// Escape special XML characters to prevent XSS
+const escapeXml = (str: string): string => {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+}
+
+export const formatCommentsXml = (changeId: string, comments: CommentWithContext[]): void => {
+  console.log(`<?xml version="1.0" encoding="UTF-8"?>`)
+  console.log(`<comments_result>`)
+  console.log(`  <change_id>${escapeXml(changeId)}</change_id>`)
+  console.log(`  <comment_count>${comments.length}</comment_count>`)
+  console.log(`  <comments>`)
+
+  for (const { comment, context } of comments) {
+    console.log(`    <comment>`)
+    console.log(`      <id>${escapeXml(comment.id)}</id>`)
+    if (comment.path) {
+      console.log(`      <path><![CDATA[${comment.path}]]></path>`)
+    }
+    if (comment.line) {
+      console.log(`      <line>${comment.line}</line>`)
+    }
+    if (comment.range) {
+      console.log(`      <range>`)
+      console.log(`        <start_line>${comment.range.start_line}</start_line>`)
+      console.log(`        <end_line>${comment.range.end_line}</end_line>`)
+      if (comment.range.start_character !== undefined) {
+        console.log(`        <start_character>${comment.range.start_character}</start_character>`)
+      }
+      if (comment.range.end_character !== undefined) {
+        console.log(`        <end_character>${comment.range.end_character}</end_character>`)
+      }
+      console.log(`      </range>`)
+    }
+    if (comment.author) {
+      console.log(`      <author>`)
+      if (comment.author.name) {
+        console.log(`        <name><![CDATA[${comment.author.name}]]></name>`)
+      }
+      if (comment.author.email) {
+        console.log(`        <email>${escapeXml(comment.author.email)}</email>`)
+      }
+      if (comment.author._account_id !== undefined) {
+        console.log(`        <account_id>${comment.author._account_id}</account_id>`)
+      }
+      console.log(`      </author>`)
+    }
+    if (comment.updated) {
+      console.log(`      <updated>${escapeXml(comment.updated)}</updated>`)
+    }
+    if (comment.unresolved !== undefined) {
+      console.log(`      <unresolved>${comment.unresolved}</unresolved>`)
+    }
+    if (comment.in_reply_to) {
+      console.log(`      <in_reply_to>${escapeXml(comment.in_reply_to)}</in_reply_to>`)
+    }
+    console.log(`      <message><![CDATA[${comment.message}]]></message>`)
+
+    if (context && (context.before.length > 0 || context.line || context.after.length > 0)) {
+      console.log(`      <diff_context>`)
+      if (context.before.length > 0) {
+        console.log(`        <before>`)
+        for (const line of context.before) {
+          console.log(`          <line><![CDATA[${line}]]></line>`)
+        }
+        console.log(`        </before>`)
+      }
+      if (context.line) {
+        console.log(`        <target_line><![CDATA[${context.line}]]></target_line>`)
+      }
+      if (context.after.length > 0) {
+        console.log(`        <after>`)
+        for (const line of context.after) {
+          console.log(`          <line><![CDATA[${line}]]></line>`)
+        }
+        console.log(`        </after>`)
+      }
+      console.log(`      </diff_context>`)
+    }
+
+    console.log(`    </comment>`)
+  }
+
+  console.log(`  </comments>`)
+  console.log(`</comments_result>`)
+}

package/src/utils/diff-context.ts

@@ -0,0 +1,103 @@
+import { Effect } from 'effect'
+import { type ApiError, GerritApiService } from '@/api/gerrit'
+import type { FileDiffContent } from '@/schemas/gerrit'
+
+export interface DiffContext {
+  before: string[]
+  line?: string
+  after: string[]
+}
+
+/**
+ * Extracts context around a specific line number from a diff.
+ * This is a more accurate implementation that properly tracks line numbers
+ * across different diff sections.
+ */
+export const extractDiffContext = (
+  diff: FileDiffContent,
+  targetLine: number,
+  contextLines: number = 2,
+): DiffContext => {
+  const context: DiffContext = {
+    before: [],
+    after: [],
+  }
+
+  let currentNewLine = 1
+  const _foundTarget = false
+  const collectedLines: Array<{ line: string; lineNum: number; type: 'context' | 'added' }> = []
+
+  for (const section of diff.content) {
+    // Context lines (present in both old and new)
+    if (section.ab) {
+      for (const line of section.ab) {
+        collectedLines.push({ line, lineNum: currentNewLine, type: 'context' })
+        currentNewLine++
+      }
+    }
+
+    // Added lines (only in new file)
+    if (section.b) {
+      for (const line of section.b) {
+        collectedLines.push({ line, lineNum: currentNewLine, type: 'added' })
+        currentNewLine++
+      }
+    }
+
+    // Skip lines (large unchanged sections)
+    if (section.skip) {
+      // If target is in skipped section, we can't show context
+      if (currentNewLine <= targetLine && targetLine < currentNewLine + section.skip) {
+        return context // Return empty context
+      }
+      currentNewLine += section.skip
+    }
+
+    // Removed lines don't affect new file line numbers
+    // section.a is ignored for line counting
+  }
+
+  // Find the target line and extract context
+  const targetIndex = collectedLines.findIndex((item) => item.lineNum === targetLine)
+  if (targetIndex !== -1) {
+    // Get before context
+    for (let i = Math.max(0, targetIndex - contextLines); i < targetIndex; i++) {
+      context.before.push(collectedLines[i].line)
+    }
+
+    // Get target line
+    context.line = collectedLines[targetIndex].line
+
+    // Get after context
+    for (
+      let i = targetIndex + 1;
+      i < Math.min(collectedLines.length, targetIndex + contextLines + 1);
+      i++
+    ) {
+      context.after.push(collectedLines[i].line)
+    }
+  }
+
+  return context
+}
+
+export const getDiffContext = (
+  changeId: string,
+  path: string,
+  line?: number,
+): Effect.Effect<DiffContext, ApiError, GerritApiService> =>
+  Effect.gen(function* () {
+    if (!line || path === 'Commit Message' || path === '/COMMIT_MSG') {
+      return { before: [], after: [] }
+    }
+
+    const gerritApi = yield* GerritApiService
+
+    try {
+      const diff = yield* gerritApi.getFileDiff(changeId, path)
+      return extractDiffContext(diff, line)
+    } catch {
+      // Return empty context on error
+      return { before: [], after: [] }
+    }
+  })

package/src/utils/diff-formatters.ts

@@ -0,0 +1,141 @@
+import { colors } from './formatters'
+
+interface DiffStats {
+  additions: number
+  deletions: number
+  files: number
+}
+
+/**
+ * Format a unified diff for pretty human-readable output
+ */
+export const formatDiffPretty = (diffContent: string): string => {
+  if (!diffContent || typeof diffContent !== 'string') {
+    const emptyStats = { additions: 0, deletions: 0, files: 0 }
+    return formatDiffSummary(emptyStats) + '\n\n' + 'No diff content available'
+  }
+
+  const lines = diffContent.split('\n')
+  const formattedLines: string[] = []
+  let stats: DiffStats = { additions: 0, deletions: 0, files: 0 }
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git')) {
+      stats.files++
+      // File header with colors
+      formattedLines.push(`${colors.bold}${colors.blue}${line}${colors.reset}`)
+    } else if (line.startsWith('index ')) {
+      // Index line
+      formattedLines.push(`${colors.dim}${line}${colors.reset}`)
+    } else if (line.startsWith('---')) {
+      // Old file marker
+      formattedLines.push(`${colors.red}${line}${colors.reset}`)
+    } else if (line.startsWith('+++')) {
+      // New file marker
+      formattedLines.push(`${colors.green}${line}${colors.reset}`)
+    } else if (line.startsWith('@@')) {
+      // Hunk header
+      formattedLines.push(`${colors.cyan}${line}${colors.reset}`)
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      // Added lines
+      stats.additions++
+      formattedLines.push(`${colors.green}${line}${colors.reset}`)
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      // Removed lines
+      stats.deletions++
+      formattedLines.push(`${colors.red}${line}${colors.reset}`)
+    } else if (line.startsWith(' ')) {
+      // Context lines
+      formattedLines.push(`${colors.dim}${line}${colors.reset}`)
+    } else {
+      // Other lines (usually empty or metadata)
+      formattedLines.push(line)
+    }
+  }
+
+  // Add summary at the top
+  const summary = formatDiffSummary(stats)
+
+  return summary + '\n\n' + formattedLines.join('\n')
+}
+
+/**
+ * Format diff summary statistics
+ */
+export const formatDiffSummary = (stats: DiffStats): string => {
+  const { additions, deletions, files } = stats
+  const total = additions + deletions
+
+  let summary = `${colors.bold}Changes summary:${colors.reset} `
+
+  if (files > 0) {
+    summary += `${files} file${files !== 1 ? 's' : ''} changed`
+  }
+
+  if (additions > 0 || deletions > 0) {
+    if (files > 0) summary += ', '
+
+    if (additions > 0) {
+      summary += `${colors.green}+${additions} addition${additions !== 1 ? 's' : ''}${colors.reset}`
+    }
+
+    if (additions > 0 && deletions > 0) {
+      summary += ', '
+    }
+
+    if (deletions > 0) {
+      summary += `${colors.red}-${deletions} deletion${deletions !== 1 ? 's' : ''}${colors.reset}`
+    }
+  }
+
+  if (total === 0 && files === 0) {
+    summary += 'No changes detected'
+  }
+
+  return summary
+}
+
+/**
+ * Format a list of changed files for pretty output
+ */
+export const formatFilesList = (files: string[]): string => {
+  if (!files || files.length === 0) {
+    return 'No files changed'
+  }
+
+  const header = `${colors.bold}Changed files (${files.length}):${colors.reset}\n`
+  const fileList = files
+    .map((file) => {
+      // Simple file status indicators - we could enhance this if we had status info
+      return `  ${colors.blue}•${colors.reset} ${file}`
+    })
+    .join('\n')
+
+  return header + fileList
+}
+
+/**
+ * Extract diff statistics from unified diff content
+ */
+export const extractDiffStats = (diffContent: string): DiffStats => {
+  if (!diffContent || typeof diffContent !== 'string') {
+    return { additions: 0, deletions: 0, files: 0 }
+  }
+
+  const lines = diffContent.split('\n')
+  let additions = 0
+  let deletions = 0
+  let files = 0
+
+  for (const line of lines) {
+    if (line.startsWith('diff --git')) {
+      files++
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      additions++
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      deletions++
+    }
+  }
+
+  return { additions, deletions, files }
+}