@aaronshaf/ger 1.2.10 → 2.0.0

package/src/services/config.ts

@@ -0,0 +1,250 @@
+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 both the tag value and the type for use in Effect requirements
+export const ConfigService: Context.Tag<ConfigServiceImpl, ConfigServiceImpl> =
+  Context.GenericTag<ConfigServiceImpl>('ConfigService')
+export type ConfigService = Context.Tag.Identifier<typeof ConfigService>
+
+// Export ConfigError fields interface explicitly
+export interface ConfigErrorFields {
+  readonly message: string
+}
+
+// Define error schema (not exported, so type can be implicit)
+const ConfigErrorSchema = Schema.TaggedError<ConfigErrorFields>()('ConfigError', {
+  message: Schema.String,
+} as const) as unknown
+
+// Export the error class with explicit constructor signature for isolatedDeclarations
+export class ConfigError
+  extends (ConfigErrorSchema as new (
+    args: ConfigErrorFields,
+  ) => ConfigErrorFields & Error & { readonly _tag: 'ConfigError' })
+  implements Error
+{
+  readonly name = 'ConfigError'
+}
+
+// File-based storage
+const CONFIG_DIR = path.join(os.homedir(), '.ger')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+const readEnvConfig = (): unknown | null => {
+  const { GERRIT_HOST, GERRIT_USERNAME, GERRIT_PASSWORD } = process.env
+
+  if (GERRIT_HOST && GERRIT_USERNAME && GERRIT_PASSWORD) {
+    return {
+      host: GERRIT_HOST,
+      username: GERRIT_USERNAME,
+      password: GERRIT_PASSWORD,
+      aiAutoDetect: true,
+    }
+  }
+
+  return null
+}
+
+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* () {
+      // First try to read from file
+      const fileContent = readFileConfig()
+      if (fileContent) {
+        // Parse as flat config
+        const fullConfigResult = yield* Schema.decodeUnknown(AppConfig)(fileContent).pipe(
+          Effect.mapError(() => new ConfigError({ message: 'Invalid configuration format' })),
+        )
+        return fullConfigResult
+      }
+
+      // Fallback to environment variables
+      const envContent = readEnvConfig()
+      if (envContent) {
+        const fullConfigResult = yield* Schema.decodeUnknown(AppConfig)(envContent).pipe(
+          Effect.mapError(
+            () => new ConfigError({ message: 'Invalid environment configuration format' }),
+          ),
+        )
+        return fullConfigResult
+      }
+
+      // No configuration found
+      return yield* Effect.fail(
+        new ConfigError({
+          message:
+            'Configuration not found. Run "ger setup" to set up your credentials or set GERRIT_HOST, GERRIT_USERNAME, and GERRIT_PASSWORD environment variables.',
+        }),
+      )
+    })
+
+    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/services/git-worktree.ts

@@ -0,0 +1,342 @@
+import { Effect, Console, pipe, Layer, Context } from 'effect'
+import { Schema } from 'effect'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import * as fs from 'node:fs/promises'
+import { spawn } from 'node:child_process'
+
+// 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
+}
+
+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
+}
+
+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 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 GitWorktreeError =
+  | WorktreeCreationError
+  | PatchsetFetchError
+  | DirtyRepoError
+  | NotGitRepoError
+
+// Worktree info
+export interface WorktreeInfo {
+  path: string
+  changeId: string
+  originalCwd: string
+  timestamp: number
+  pid: number
+}
+
+// Git command runner with Effect
+const runGitCommand = (
+  args: string[],
+  options: { cwd?: string } = {},
+): Effect.Effect<string, GitWorktreeError, never> =>
+  Effect.async<string, GitWorktreeError, never>((resume) => {
+    const child = spawn('git', args, {
+      cwd: options.cwd || process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resume(Effect.succeed(stdout.trim()))
+      } else {
+        const errorMessage = `Git command failed: git ${args.join(' ')}\nStderr: ${stderr}`
+
+        // Classify error based on command and output
+        if (args[0] === 'worktree' && args[1] === 'add') {
+          resume(Effect.fail(new WorktreeCreationError({ message: errorMessage })))
+        } else if (args[0] === 'fetch' || args[0] === 'checkout') {
+          resume(Effect.fail(new PatchsetFetchError({ message: errorMessage })))
+        } else {
+          resume(Effect.fail(new WorktreeCreationError({ message: errorMessage })))
+        }
+      }
+    })
+
+    child.on('error', (error) => {
+      resume(
+        Effect.fail(
+          new WorktreeCreationError({
+            message: `Failed to spawn git: ${error.message}`,
+            cause: error,
+          }),
+        ),
+      )
+    })
+  })
+
+// Check if current directory is a git repository
+const validateGitRepo = (): Effect.Effect<void, NotGitRepoError, never> =>
+  pipe(
+    runGitCommand(['rev-parse', '--git-dir']),
+    Effect.mapError(
+      () => new NotGitRepoError({ message: 'Current directory is not a git repository' }),
+    ),
+    Effect.map(() => undefined),
+  )
+
+// Generate unique worktree path
+const generateWorktreePath = (changeId: string): string => {
+  const timestamp = Date.now()
+  const pid = process.pid
+  const uniqueId = `${changeId}-${timestamp}-${pid}`
+  return path.join(os.homedir(), '.ger', 'worktrees', uniqueId)
+}
+
+// Ensure .ger directory exists
+const ensureGerDirectory = (): Effect.Effect<void, never, never> =>
+  Effect.tryPromise({
+    try: async () => {
+      const gerDir = path.join(os.homedir(), '.ger', 'worktrees')
+      await fs.mkdir(gerDir, { recursive: true })
+    },
+    catch: () => undefined, // Ignore errors, will fail later if directory can't be created
+  }).pipe(Effect.catchAll(() => Effect.succeed(undefined)))
+
+// Build Gerrit refspec for change
+const buildRefspec = (changeNumber: string, patchsetNumber: number = 1): string => {
+  // Extract change number from changeId if it contains non-numeric characters
+  const numericChangeNumber = changeNumber.replace(/\D/g, '')
+  return `refs/changes/${numericChangeNumber.slice(-2)}/${numericChangeNumber}/${patchsetNumber}`
+}
+
+// Get the current HEAD commit hash to avoid branch conflicts
+const getCurrentCommit = (): Effect.Effect<string, GitWorktreeError, never> =>
+  pipe(
+    runGitCommand(['rev-parse', 'HEAD']),
+    Effect.map((output) => output.trim()),
+    Effect.catchAll(() =>
+      // Fallback: try to get commit from default branch
+      pipe(
+        runGitCommand(['rev-parse', 'origin/main']),
+        Effect.catchAll(() => runGitCommand(['rev-parse', 'origin/master'])),
+        Effect.catchAll(() => Effect.succeed('HEAD')),
+      ),
+    ),
+  )
+
+// Get latest patchset number for a change
+const getLatestPatchsetNumber = (
+  changeId: string,
+): Effect.Effect<number, PatchsetFetchError, never> =>
+  pipe(
+    runGitCommand(['ls-remote', 'origin', `refs/changes/*/${changeId.replace(/\D/g, '')}/*`]),
+    Effect.mapError(
+      (error) =>
+        new PatchsetFetchError({ message: `Failed to get patchset info: ${error.message}` }),
+    ),
+    Effect.map((output) => {
+      const lines = output.split('\n').filter((line) => line.trim())
+      if (lines.length === 0) {
+        return 1 // Default to patchset 1 if no refs found
+      }
+
+      // Extract patchset numbers and return the highest
+      const patchsetNumbers = lines
+        .map((line) => {
+          const match = line.match(/refs\/changes\/\d+\/\d+\/(\d+)$/)
+          return match ? parseInt(match[1], 10) : 0
+        })
+        .filter((num) => num > 0)
+
+      return patchsetNumbers.length > 0 ? Math.max(...patchsetNumbers) : 1
+    }),
+  )
+
+// GitWorktreeService implementation
+export interface GitWorktreeServiceImpl {
+  validatePreconditions: () => Effect.Effect<void, GitWorktreeError, never>
+  createWorktree: (changeId: string) => Effect.Effect<WorktreeInfo, GitWorktreeError, never>
+  fetchAndCheckoutPatchset: (
+    worktreeInfo: WorktreeInfo,
+  ) => Effect.Effect<void, GitWorktreeError, never>
+  cleanup: (worktreeInfo: WorktreeInfo) => Effect.Effect<void, never, never>
+  getChangedFiles: () => Effect.Effect<string[], GitWorktreeError, never>
+}
+
+const GitWorktreeServiceImplLive: GitWorktreeServiceImpl = {
+  validatePreconditions: () =>
+    Effect.gen(function* () {
+      yield* validateGitRepo()
+      yield* Console.log('✓ Git repository validation passed')
+    }),
+
+  createWorktree: (changeId: string) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Creating worktree for change ${changeId}...`)
+
+      // Get current commit hash to avoid branch conflicts
+      const currentCommit = yield* getCurrentCommit()
+      yield* Console.log(`→ Using base commit: ${currentCommit.substring(0, 7)}`)
+
+      // Ensure .ger directory exists
+      yield* ensureGerDirectory()
+
+      // Generate unique path
+      const worktreePath = generateWorktreePath(changeId)
+      const originalCwd = process.cwd()
+
+      // Create worktree using commit hash (no branch conflicts)
+      yield* runGitCommand(['worktree', 'add', '--detach', worktreePath, currentCommit])
+
+      const worktreeInfo: WorktreeInfo = {
+        path: worktreePath,
+        changeId,
+        originalCwd,
+        timestamp: Date.now(),
+        pid: process.pid,
+      }
+
+      yield* Console.log(`✓ Worktree created at ${worktreePath}`)
+      return worktreeInfo
+    }),
+
+  fetchAndCheckoutPatchset: (worktreeInfo: WorktreeInfo) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Fetching and checking out patchset for ${worktreeInfo.changeId}...`)
+
+      // Get latest patchset number
+      const patchsetNumber = yield* getLatestPatchsetNumber(worktreeInfo.changeId)
+      const refspec = buildRefspec(worktreeInfo.changeId, patchsetNumber)
+
+      yield* Console.log(`→ Using refspec: ${refspec}`)
+
+      // Fetch the change
+      yield* runGitCommand(['fetch', 'origin', refspec], { cwd: worktreeInfo.path })
+
+      // Checkout FETCH_HEAD
+      yield* runGitCommand(['checkout', 'FETCH_HEAD'], { cwd: worktreeInfo.path })
+
+      yield* Console.log(`✓ Checked out patchset ${patchsetNumber} for ${worktreeInfo.changeId}`)
+    }),
+
+  cleanup: (worktreeInfo: WorktreeInfo) =>
+    Effect.gen(function* () {
+      yield* Console.log(`→ Cleaning up worktree for ${worktreeInfo.changeId}...`)
+
+      // Always restore original working directory first
+      try {
+        process.chdir(worktreeInfo.originalCwd)
+      } catch (error) {
+        yield* Console.warn(`Warning: Could not restore original directory: ${error}`)
+      }
+
+      // Attempt to remove worktree (don't fail if this doesn't work)
+      yield* pipe(
+        runGitCommand(['worktree', 'remove', '--force', worktreeInfo.path]),
+        Effect.catchAll((error) =>
+          Effect.gen(function* () {
+            yield* Console.warn(`Warning: Could not remove worktree: ${error.message}`)
+            yield* Console.warn(`Manual cleanup may be required: ${worktreeInfo.path}`)
+          }),
+        ),
+      )
+
+      yield* Console.log(`✓ Cleanup completed for ${worktreeInfo.changeId}`)
+    }),
+
+  getChangedFiles: () =>
+    Effect.gen(function* () {
+      // Get list of changed files in current worktree
+      const output = yield* runGitCommand(['diff', '--name-only', 'HEAD~1'])
+      const files = output.split('\n').filter((file) => file.trim())
+      return files
+    }),
+}
+
+// Export service tag for dependency injection with explicit type
+export const GitWorktreeService: Context.Tag<GitWorktreeServiceImpl, GitWorktreeServiceImpl> =
+  Context.GenericTag<GitWorktreeServiceImpl>('GitWorktreeService')
+
+export type GitWorktreeService = Context.Tag.Identifier<typeof GitWorktreeService>
+
+// Export service layer with explicit type
+export const GitWorktreeServiceLive: Layer.Layer<GitWorktreeServiceImpl> = Layer.succeed(
+  GitWorktreeService,
+  GitWorktreeServiceImplLive,
+)