@aaronshaf/ger 0.1.11 → 0.2.1

package/src/services/git-worktree.ts

@@ -5,30 +5,84 @@ import * as path from 'node:path'
 import * as fs from 'node:fs/promises'
 import { spawn } from 'node:child_process'
 
-// Error types
-export class WorktreeCreationError extends Schema.TaggedError<WorktreeCreationError>()(
+// Error types with explicit interfaces
+export interface WorktreeCreationErrorFields {
+  readonly message: string
+  readonly cause?: unknown
+}
+
+const WorktreeCreationErrorSchema = Schema.TaggedError<WorktreeCreationErrorFields>()(
   'WorktreeCreationError',
   {
     message: Schema.String,
     cause: Schema.optional(Schema.Unknown),
   },
-) {}
+) as unknown
+
+export class WorktreeCreationError
+  extends (WorktreeCreationErrorSchema as new (
+    args: WorktreeCreationErrorFields,
+  ) => WorktreeCreationErrorFields & Error & { readonly _tag: 'WorktreeCreationError' })
+  implements Error
+{
+  readonly name = 'WorktreeCreationError'
+}
+
+export interface PatchsetFetchErrorFields {
+  readonly message: string
+  readonly cause?: unknown
+}
 
-export class PatchsetFetchError extends Schema.TaggedError<PatchsetFetchError>()(
+const PatchsetFetchErrorSchema = Schema.TaggedError<PatchsetFetchErrorFields>()(
   'PatchsetFetchError',
   {
     message: Schema.String,
     cause: Schema.optional(Schema.Unknown),
   },
-) {}
+) as unknown
+
+export class PatchsetFetchError
+  extends (PatchsetFetchErrorSchema as new (
+    args: PatchsetFetchErrorFields,
+  ) => PatchsetFetchErrorFields & Error & { readonly _tag: 'PatchsetFetchError' })
+  implements Error
+{
+  readonly name = 'PatchsetFetchError'
+}
+
+export interface DirtyRepoErrorFields {
+  readonly message: string
+}
 
-export class DirtyRepoError extends Schema.TaggedError<DirtyRepoError>()('DirtyRepoError', {
+const DirtyRepoErrorSchema = Schema.TaggedError<DirtyRepoErrorFields>()('DirtyRepoError', {
   message: Schema.String,
-}) {}
+}) as unknown
+
+export class DirtyRepoError
+  extends (DirtyRepoErrorSchema as new (
+    args: DirtyRepoErrorFields,
+  ) => DirtyRepoErrorFields & Error & { readonly _tag: 'DirtyRepoError' })
+  implements Error
+{
+  readonly name = 'DirtyRepoError'
+}
 
-export class NotGitRepoError extends Schema.TaggedError<NotGitRepoError>()('NotGitRepoError', {
+export interface NotGitRepoErrorFields {
+  readonly message: string
+}
+
+const NotGitRepoErrorSchema = Schema.TaggedError<NotGitRepoErrorFields>()('NotGitRepoError', {
   message: Schema.String,
-}) {}
+}) as unknown
+
+export class NotGitRepoError
+  extends (NotGitRepoErrorSchema as new (
+    args: NotGitRepoErrorFields,
+  ) => NotGitRepoErrorFields & Error & { readonly _tag: 'NotGitRepoError' })
+  implements Error
+{
+  readonly name = 'NotGitRepoError'
+}
 
 export type GitError = WorktreeCreationError | PatchsetFetchError | DirtyRepoError | NotGitRepoError
 
@@ -102,23 +156,6 @@ const validateGitRepo = (): Effect.Effect<void, NotGitRepoError, never> =>
     Effect.map(() => undefined),
   )
 
-// Check if working directory is clean
-const validateCleanRepo = (): Effect.Effect<void, DirtyRepoError, never> =>
-  pipe(
-    runGitCommand(['status', '--porcelain']),
-    Effect.mapError(() => new DirtyRepoError({ message: 'Failed to check repository status' })),
-    Effect.flatMap((output) =>
-      output.trim() === ''
-        ? Effect.succeed(undefined)
-        : Effect.fail(
-            new DirtyRepoError({
-              message:
-                'Working directory has uncommitted changes. Please commit or stash changes before review.',
-            }),
-          ),
-    ),
-  )
-
 // Generate unique worktree path
 const generateWorktreePath = (changeId: string): string => {
   const timestamp = Date.now()
@@ -286,11 +323,14 @@ const GitWorktreeServiceImplLive: GitWorktreeServiceImpl = {
     }),
 }
 
-// Export service tag for dependency injection
-export class GitWorktreeService extends Context.Tag('GitWorktreeService')<
-  GitWorktreeService,
-  GitWorktreeServiceImpl
->() {}
+// Export service tag for dependency injection with explicit type
+export const GitWorktreeService: Context.Tag<GitWorktreeServiceImpl, GitWorktreeServiceImpl> =
+  Context.GenericTag<GitWorktreeServiceImpl>('GitWorktreeService')
 
-// Export service layer
-export const GitWorktreeServiceLive = Layer.succeed(GitWorktreeService, GitWorktreeServiceImplLive)
+export type GitWorktreeService = Context.Tag.Identifier<typeof GitWorktreeService>
+
+// Export service layer with explicit type
+export const GitWorktreeServiceLive: Layer.Layer<GitWorktreeServiceImpl> = Layer.succeed(
+  GitWorktreeService,
+  GitWorktreeServiceImplLive,
+)

package/src/services/review-strategy.ts

@@ -12,10 +12,23 @@ const extractResponse = (stdout: string): string => {
 }
 
 // Simple strategy focused only on review needs
-export class ReviewStrategyError extends Data.TaggedError('ReviewStrategyError')<{
-  message: string
-  cause?: unknown
-}> {}
+export interface ReviewStrategyErrorFields {
+  readonly message: string
+  readonly cause?: unknown
+}
+
+const ReviewStrategyErrorBase = Data.TaggedError(
+  'ReviewStrategyError',
+)<ReviewStrategyErrorFields> as unknown
+
+export class ReviewStrategyError
+  extends (ReviewStrategyErrorBase as new (
+    args: ReviewStrategyErrorFields,
+  ) => ReviewStrategyErrorFields & Error & { readonly _tag: 'ReviewStrategyError' })
+  implements Error
+{
+  readonly name = 'ReviewStrategyError'
+}
 
 // Review strategy interface - focused on specific review patterns
 export interface ReviewStrategy {
@@ -202,25 +215,30 @@ export const openCodeCliStrategy: ReviewStrategy = {
     }),
 }
 
-// Review service using strategy pattern
-export class ReviewStrategyService extends Context.Tag('ReviewStrategyService')<
+// Review service interface using strategy pattern
+export interface ReviewStrategyServiceImpl {
+  readonly getAvailableStrategies: () => Effect.Effect<ReviewStrategy[], never>
+  readonly selectStrategy: (
+    preferredName?: string,
+  ) => Effect.Effect<ReviewStrategy, ReviewStrategyError>
+  readonly executeWithStrategy: (
+    strategy: ReviewStrategy,
+    prompt: string,
+    options?: { cwd?: string; systemPrompt?: string },
+  ) => Effect.Effect<string, ReviewStrategyError>
+}
+
+// Export the service tag with explicit type
+export const ReviewStrategyService: Context.Tag<
+  ReviewStrategyServiceImpl,
+  ReviewStrategyServiceImpl
+> = Context.GenericTag<ReviewStrategyServiceImpl>('ReviewStrategyService')
+
+export type ReviewStrategyService = Context.Tag.Identifier<typeof ReviewStrategyService>
+
+export const ReviewStrategyServiceLive: Layer.Layer<ReviewStrategyServiceImpl> = Layer.succeed(
   ReviewStrategyService,
   {
-    readonly getAvailableStrategies: () => Effect.Effect<ReviewStrategy[], never>
-    readonly selectStrategy: (
-      preferredName?: string,
-    ) => Effect.Effect<ReviewStrategy, ReviewStrategyError>
-    readonly executeWithStrategy: (
-      strategy: ReviewStrategy,
-      prompt: string,
-      options?: { cwd?: string; systemPrompt?: string },
-    ) => Effect.Effect<string, ReviewStrategyError>
-  }
->() {}
-
-export const ReviewStrategyServiceLive = Layer.succeed(
-  ReviewStrategyService,
-  ReviewStrategyService.of({
     getAvailableStrategies: () =>
       Effect.gen(function* () {
         const strategies = [claudeCliStrategy, geminiCliStrategy, openCodeCliStrategy]
@@ -270,5 +288,5 @@ export const ReviewStrategyServiceLive = Layer.succeed(
 
     executeWithStrategy: (strategy, prompt, options = {}) =>
       strategy.executeReview(prompt, options),
-  }),
+  },
 )

package/src/utils/change-id.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  isChangeId,
+  isChangeNumber,
+  isValidChangeIdentifier,
+  normalizeChangeIdentifier,
+  getIdentifierType,
+} from './change-id'
+
+describe('change-id utilities', () => {
+  describe('isChangeId', () => {
+    test('returns true for valid Change-ID format', () => {
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(true)
+      expect(isChangeId('I0123456789abcdef0123456789abcdef01234567')).toBe(true)
+    })
+
+    test('returns false for invalid Change-ID format', () => {
+      expect(isChangeId('392385')).toBe(false)
+      expect(isChangeId('if5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false) // lowercase 'i'
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b')).toBe(false) // too short
+      expect(isChangeId('If5a3ae8cb5a107e187447802358417f311d0c4b11')).toBe(false) // too long
+      expect(isChangeId('Gf5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false) // wrong prefix
+    })
+  })
+
+  describe('isChangeNumber', () => {
+    test('returns true for numeric strings', () => {
+      expect(isChangeNumber('392385')).toBe(true)
+      expect(isChangeNumber('12345')).toBe(true)
+      expect(isChangeNumber('1')).toBe(true)
+    })
+
+    test('returns false for non-numeric strings', () => {
+      expect(isChangeNumber('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(false)
+      expect(isChangeNumber('abc')).toBe(false)
+      expect(isChangeNumber('123abc')).toBe(false)
+      expect(isChangeNumber('')).toBe(false)
+    })
+  })
+
+  describe('isValidChangeIdentifier', () => {
+    test('returns true for valid change numbers', () => {
+      expect(isValidChangeIdentifier('392385')).toBe(true)
+      expect(isValidChangeIdentifier('12345')).toBe(true)
+    })
+
+    test('returns true for valid Change-IDs', () => {
+      expect(isValidChangeIdentifier('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(true)
+      expect(isValidChangeIdentifier('I0123456789abcdef0123456789abcdef01234567')).toBe(true)
+    })
+
+    test('returns false for invalid identifiers', () => {
+      expect(isValidChangeIdentifier('abc')).toBe(false)
+      expect(isValidChangeIdentifier('I123')).toBe(false)
+      expect(isValidChangeIdentifier('')).toBe(false)
+    })
+  })
+
+  describe('normalizeChangeIdentifier', () => {
+    test('returns trimmed change number', () => {
+      expect(normalizeChangeIdentifier('392385')).toBe('392385')
+      expect(normalizeChangeIdentifier(' 392385 ')).toBe('392385')
+    })
+
+    test('returns trimmed Change-ID', () => {
+      expect(normalizeChangeIdentifier('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+      expect(normalizeChangeIdentifier(' If5a3ae8cb5a107e187447802358417f311d0c4b1 ')).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('throws error for invalid identifiers', () => {
+      expect(() => normalizeChangeIdentifier('abc')).toThrow(/Invalid change identifier/)
+      expect(() => normalizeChangeIdentifier('I123')).toThrow(/Invalid change identifier/)
+      expect(() => normalizeChangeIdentifier('')).toThrow(/Invalid change identifier/)
+    })
+  })
+
+  describe('getIdentifierType', () => {
+    test('returns "change-number" for numeric strings', () => {
+      expect(getIdentifierType('392385')).toBe('change-number')
+      expect(getIdentifierType(' 12345 ')).toBe('change-number')
+    })
+
+    test('returns "change-id" for Change-ID format', () => {
+      expect(getIdentifierType('If5a3ae8cb5a107e187447802358417f311d0c4b1')).toBe('change-id')
+      expect(getIdentifierType(' If5a3ae8cb5a107e187447802358417f311d0c4b1 ')).toBe('change-id')
+    })
+
+    test('returns "invalid" for invalid identifiers', () => {
+      expect(getIdentifierType('abc')).toBe('invalid')
+      expect(getIdentifierType('I123')).toBe('invalid')
+      expect(getIdentifierType('')).toBe('invalid')
+    })
+  })
+})

package/src/utils/change-id.ts

@@ -0,0 +1,63 @@
+/**
+ * Utilities for handling Gerrit change identifiers
+ * Supports both numeric change numbers (e.g., "392385") and Change-IDs (e.g., "If5a3ae8cb5a107e187447802358417f311d0c4b1")
+ */
+
+/**
+ * Validates if a string is a valid Gerrit Change-ID format
+ * Change-IDs start with 'I' followed by a 40-character SHA-1 hash
+ */
+export function isChangeId(value: string): boolean {
+  return /^I[0-9a-f]{40}$/.test(value)
+}
+
+/**
+ * Validates if a string is a numeric change number
+ */
+export function isChangeNumber(value: string): boolean {
+  return /^\d+$/.test(value)
+}
+
+/**
+ * Validates if a string is either a valid Change-ID or change number
+ */
+export function isValidChangeIdentifier(value: string): boolean {
+  return isChangeId(value) || isChangeNumber(value)
+}
+
+/**
+ * Normalizes a change identifier for use with Gerrit API
+ * Gerrit API accepts both formats, so we just validate and return as-is
+ *
+ * @param value - Either a numeric change number or a Change-ID
+ * @returns The normalized identifier
+ * @throws Error if the identifier is invalid
+ */
+export function normalizeChangeIdentifier(value: string): string {
+  const trimmed = value.trim()
+
+  if (!isValidChangeIdentifier(trimmed)) {
+    throw new Error(
+      `Invalid change identifier: "${value}". Expected either a numeric change number (e.g., "392385") or a Change-ID starting with "I" (e.g., "If5a3ae8cb5a107e187447802358417f311d0c4b1")`,
+    )
+  }
+
+  return trimmed
+}
+
+/**
+ * Gets a user-friendly description of what type of identifier was provided
+ */
+export function getIdentifierType(value: string): 'change-number' | 'change-id' | 'invalid' {
+  const trimmed = value.trim()
+
+  if (isChangeNumber(trimmed)) {
+    return 'change-number'
+  }
+
+  if (isChangeId(trimmed)) {
+    return 'change-id'
+  }
+
+  return 'invalid'
+}

package/src/utils/git-commit.test.ts

@@ -0,0 +1,277 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test'
+import { Effect } from 'effect'
+import {
+  extractChangeIdFromCommitMessage,
+  getLastCommitMessage,
+  getChangeIdFromHead,
+} from './git-commit'
+import * as childProcess from 'node:child_process'
+import { EventEmitter } from 'node:events'
+
+let spawnSpy: ReturnType<typeof spyOn>
+
+describe('git-commit utilities', () => {
+  describe('extractChangeIdFromCommitMessage', () => {
+    test('extracts Change-ID from typical commit message', () => {
+      const message = `feat: add new feature
+
+This is a longer description of the feature.
+
+Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('extracts Change-ID with extra whitespace', () => {
+      const message = `fix: bug fix
+
+Change-Id:   If5a3ae8cb5a107e187447802358417f311d0c4b1   `
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('extracts Change-ID from minimal commit', () => {
+      const message = `Change-Id: I0123456789abcdef0123456789abcdef01234567`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'I0123456789abcdef0123456789abcdef01234567',
+      )
+    })
+
+    test('extracts first Change-ID when multiple exist', () => {
+      const message = `feat: feature
+
+Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1
+Change-Id: I1111111111111111111111111111111111111111`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('returns null when no Change-ID present', () => {
+      const message = `feat: add feature
+
+This commit has no Change-ID footer.`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(null)
+    })
+
+    test('returns null for empty message', () => {
+      expect(extractChangeIdFromCommitMessage('')).toBe(null)
+    })
+
+    test('ignores Change-ID in commit body (not footer)', () => {
+      const message = `feat: update
+
+This mentions Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1 in body
+but it's not in the footer.
+
+Signed-off-by: User`
+
+      // Should not match because it's not at the start of a line (footer position)
+      expect(extractChangeIdFromCommitMessage(message)).toBe(null)
+    })
+
+    test('handles Change-ID with lowercase hex digits', () => {
+      const message = `Change-Id: Iabcdef0123456789abcdef0123456789abcdef01`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'Iabcdef0123456789abcdef0123456789abcdef01',
+      )
+    })
+
+    test('returns null for malformed Change-ID (too short)', () => {
+      const message = `Change-Id: If5a3ae8cb5a107e187447`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(null)
+    })
+
+    test('returns null for malformed Change-ID (too long)', () => {
+      const message = `Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b11111`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(null)
+    })
+
+    test('returns null for Change-ID not starting with I', () => {
+      const message = `Change-Id: Gf5a3ae8cb5a107e187447802358417f311d0c4b1`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(null)
+    })
+
+    test('handles CRLF line endings', () => {
+      const message = `feat: feature\r\n\r\nChange-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1\r\n`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+
+    test('is case-insensitive for "Change-Id" label', () => {
+      const message = `change-id: If5a3ae8cb5a107e187447802358417f311d0c4b1`
+
+      expect(extractChangeIdFromCommitMessage(message)).toBe(
+        'If5a3ae8cb5a107e187447802358417f311d0c4b1',
+      )
+    })
+  })
+
+  describe('getLastCommitMessage', () => {
+    let mockChildProcess: EventEmitter
+
+    beforeEach(() => {
+      mockChildProcess = new EventEmitter()
+      // @ts-ignore - adding missing properties for mock
+      mockChildProcess.stdout = new EventEmitter()
+      // @ts-ignore
+      mockChildProcess.stderr = new EventEmitter()
+
+      spawnSpy = spyOn(childProcess, 'spawn')
+      spawnSpy.mockReturnValue(mockChildProcess as any)
+    })
+
+    afterEach(() => {
+      spawnSpy.mockRestore()
+    })
+
+    test('returns commit message on success', async () => {
+      const commitMessage = `feat: add feature
+
+Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1`
+
+      const effect = getLastCommitMessage()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      // Simulate git command success
+      setImmediate(() => {
+        // @ts-ignore
+        mockChildProcess.stdout.emit('data', Buffer.from(commitMessage))
+        mockChildProcess.emit('close', 0)
+      })
+
+      const result = await resultPromise
+      expect(result).toBe(commitMessage)
+    })
+
+    test('throws GitError when not in git repository', async () => {
+      const effect = getLastCommitMessage()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      setImmediate(() => {
+        // @ts-ignore
+        mockChildProcess.stderr.emit('data', Buffer.from('fatal: not a git repository'))
+        mockChildProcess.emit('close', 128)
+      })
+
+      try {
+        await resultPromise
+        expect(true).toBe(false) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('fatal: not a git repository')
+      }
+    })
+
+    test('throws GitError on spawn error', async () => {
+      const effect = getLastCommitMessage()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      setImmediate(() => {
+        mockChildProcess.emit('error', new Error('ENOENT: git not found'))
+      })
+
+      try {
+        await resultPromise
+        expect(true).toBe(false) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('Failed to execute git command')
+      }
+    })
+  })
+
+  describe('getChangeIdFromHead', () => {
+    let mockChildProcess: EventEmitter
+
+    beforeEach(() => {
+      mockChildProcess = new EventEmitter()
+      // @ts-ignore
+      mockChildProcess.stdout = new EventEmitter()
+      // @ts-ignore
+      mockChildProcess.stderr = new EventEmitter()
+
+      spawnSpy = spyOn(childProcess, 'spawn')
+      spawnSpy.mockReturnValue(mockChildProcess as any)
+    })
+
+    afterEach(() => {
+      spawnSpy.mockRestore()
+    })
+
+    test('returns Change-ID from HEAD commit', async () => {
+      const commitMessage = `feat: add feature
+
+Change-Id: If5a3ae8cb5a107e187447802358417f311d0c4b1`
+
+      const effect = getChangeIdFromHead()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      setImmediate(() => {
+        // @ts-ignore
+        mockChildProcess.stdout.emit('data', Buffer.from(commitMessage))
+        mockChildProcess.emit('close', 0)
+      })
+
+      const result = await resultPromise
+      expect(result).toBe('If5a3ae8cb5a107e187447802358417f311d0c4b1')
+    })
+
+    test('throws NoChangeIdError when commit has no Change-ID', async () => {
+      const commitMessage = `feat: add feature
+
+This commit has no Change-ID.`
+
+      const effect = getChangeIdFromHead()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      setImmediate(() => {
+        // @ts-ignore
+        mockChildProcess.stdout.emit('data', Buffer.from(commitMessage))
+        mockChildProcess.emit('close', 0)
+      })
+
+      try {
+        await resultPromise
+        expect(true).toBe(false) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('No Change-ID found in HEAD commit')
+      }
+    })
+
+    test('throws GitError when not in git repository', async () => {
+      const effect = getChangeIdFromHead()
+
+      const resultPromise = Effect.runPromise(effect)
+
+      setImmediate(() => {
+        // @ts-ignore
+        mockChildProcess.stderr.emit('data', Buffer.from('fatal: not a git repository'))
+        mockChildProcess.emit('close', 128)
+      })
+
+      try {
+        await resultPromise
+        expect(true).toBe(false) // Should not reach here
+      } catch (error: any) {
+        expect(error.message).toContain('fatal: not a git repository')
+      }
+    })
+  })
+})