Consolidate duplicate patterns and simplify codebase (#1317)

* refactor(shared): unify binary downloader and session path storage

- Create binary-downloader.ts for common download/extract logic
- Create session-injected-paths.ts for unified path tracking
- Refactor comment-checker, ast-grep, grep downloaders to use shared util
- Consolidate directory injector types into shared module

* feat(shared): implement unified model resolution pipeline

- Create ModelResolutionPipeline for centralized model selection
- Refactor model-resolver to use pipeline
- Update delegate-task and config-handler to use unified logic
- Ensure consistent model resolution across all agent types

* refactor(agents): simplify agent utils and metadata management

- Extract helper functions for config merging and env context
- Register prompt metadata for all agents
- Simplify agent variant detection logic

* cleanup: inline utilities and remove unused exports

- Remove case-insensitive.ts (inline with native JS)
- Simplify opencode-version helpers
- Remove unused getModelLimit, createCompactionContextInjector exports
- Inline transcript entry creation in claude-code-hooks
- Update tests accordingly

---------

Co-authored-by: justsisyphus <justsisyphus@users.noreply.github.com>

src/shared/snake-case.ts

@@ -8,42 +8,37 @@ export function snakeToCamel(str: string): string {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase())
 }
 
+export function transformObjectKeys(
+  obj: Record<string, unknown>,
+  transformer: (key: string) => string,
+  deep: boolean = true
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    const transformedKey = transformer(key)
+    if (deep && isPlainObject(value)) {
+      result[transformedKey] = transformObjectKeys(value, transformer, true)
+    } else if (deep && Array.isArray(value)) {
+      result[transformedKey] = value.map((item) =>
+        isPlainObject(item) ? transformObjectKeys(item, transformer, true) : item
+      )
+    } else {
+      result[transformedKey] = value
+    }
+  }
+  return result
+}
+
 export function objectToSnakeCase(
   obj: Record<string, unknown>,
   deep: boolean = true
 ): Record<string, unknown> {
-   const result: Record<string, unknown> = {}
-   for (const [key, value] of Object.entries(obj)) {
-     const snakeKey = camelToSnake(key)
-     if (deep && isPlainObject(value)) {
-       result[snakeKey] = objectToSnakeCase(value, true)
-     } else if (deep && Array.isArray(value)) {
-       result[snakeKey] = value.map((item) =>
-         isPlainObject(item) ? objectToSnakeCase(item, true) : item
-       )
-     } else {
-       result[snakeKey] = value
-     }
-   }
-   return result
- }
+  return transformObjectKeys(obj, camelToSnake, deep)
+}
 
 export function objectToCamelCase(
   obj: Record<string, unknown>,
   deep: boolean = true
 ): Record<string, unknown> {
-   const result: Record<string, unknown> = {}
-   for (const [key, value] of Object.entries(obj)) {
-     const camelKey = snakeToCamel(key)
-     if (deep && isPlainObject(value)) {
-       result[camelKey] = objectToCamelCase(value, true)
-     } else if (deep && Array.isArray(value)) {
-       result[camelKey] = value.map((item) =>
-         isPlainObject(item) ? objectToCamelCase(item, true) : item
-       )
-     } else {
-       result[camelKey] = value
-     }
-   }
-   return result
- }
+  return transformObjectKeys(obj, snakeToCamel, deep)
+}