fix: refactor service modules for error handling

- Use HttpClient for gitignore fetch with robust status handling
- Normalize and enhance OpenAI model detection logic
- Improve VCS ignore handling by introducing checkIgnoreError
- Remove direct repoRoot calls and mergeAndSaveScopes for simplification
- Improve hooks error mapping to ConfigError across execution

refactors across multiple service modules improve error handling and
general robustness by introducing http-based fetch, normalization, and
clearer error mapping

Co-Authored-By: Git Agent <noreply@git-agent.dev>

Author: xesrevinu

src/services/commit-service.ts

@@ -9,7 +9,6 @@ import { executeHooks } from "./hooks";
 import { generateCommitMessage, planCommits, type ProviderConfig } from "./openai-client";
 import { generateProjectScopes } from "./scope-service";
 import type { VcsClient, VcsDiff } from "./vcs";
-import { projectConfigPath, mergeAndSaveScopes } from "../config/project";
 
 const maxHookRetries = 3;
 const maxReplans = 2;
@@ -204,8 +203,6 @@ const withAutoScopes = Effect.fn(function* (
     ...(projectConfig ?? emptyProjectConfig()),
     scopes,
   } satisfies ProjectConfig;
-  const repoRoot = yield* vcs.repoRoot(cwd);
-  yield* mergeAndSaveScopes(yield* projectConfigPath(repoRoot), scopes);
   return nextConfig;
 });
 
@@ -457,8 +454,6 @@ const commitGit = Effect.fn(function* (request: CommitRequest, config: ProjectCo
         },
       },
     );
-    const repoRoot = yield* request.vcs.repoRoot(request.cwd);
-    yield* mergeAndSaveScopes(yield* projectConfigPath(repoRoot), refreshedScopes);
     groups = yield* Effect.withSpan(
       planGroups(request.provider, promptStaged.files, promptUnstaged.files, request.intent, {
         ...configWithScopes,

src/services/gitignore-service.ts

@@ -1,5 +1,6 @@
 import { platform } from "node:os";
 import { Effect, FileSystem, Path } from "effect";
+import { HttpClient } from "effect/unstable/http";
 import { ApiError } from "../shared/errors";
 import { buildEnvironment } from "../config/env";
 import { detectTechnologies, type ProviderConfig } from "./openai-client";
@@ -99,28 +100,30 @@ const mergeGitignore = (existing: string, generated: string): string => {
 const fetchGitignore = Effect.fn(function* (technologies: ReadonlyArray<string>) {
   const env = yield* buildEnvironment;
   const baseUrl = env.gitignoreBaseUrl.replace(/\/$/, "");
-  return yield* Effect.tryPromise({
-    try: async () => {
-      const response = await fetch(
-        `${baseUrl}/${technologies.map((item) => encodeURIComponent(item)).join(",")}`,
-      );
-      const text = await response.text();
-      if (!response.ok) {
-        throw new ApiError({
-          message: `failed to fetch gitignore template (${response.status})`,
-          status: response.status,
-          body: text,
-        });
-      }
-      return text;
-    },
-    catch: (cause) =>
+  const url = `${baseUrl}/${technologies.map((item) => encodeURIComponent(item)).join(",")}`;
+  return yield* HttpClient.get(url).pipe(
+    Effect.flatMap((response) =>
+      Effect.flatMap(response.text, (text) =>
+        response.status >= 200 && response.status < 300
+          ? Effect.succeed(text)
+          : Effect.failSync(
+              () =>
+                new ApiError({
+                  message: `failed to fetch gitignore template (${response.status})`,
+                  status: response.status,
+                  body: text,
+                }),
+            ),
+      ),
+    ),
+    Effect.mapError((cause) =>
       ApiError.is(cause)
         ? cause
         : new ApiError({
             message: cause instanceof Error ? cause.message : String(cause),
           }),
-  });
+    ),
+  );
 });
 
 export const generateGitignore = Effect.fn(function* (

src/services/hooks.ts

@@ -31,14 +31,14 @@ const encodeHookInputToJson = Schema.encodeUnknownSync(Schema.Json);
 
 const executeShellHook = Effect.fn(function* (path: string, input: HookInput) {
   const fs = yield* FileSystem.FileSystem;
-  const info = yield* fs.stat(path).pipe(Effect.catch(() => Effect.succeed(undefined)));
-
-  if (info == null) {
-    return {
-      exitCode: 0,
-      stderr: "",
-    } satisfies HookResult;
-  }
+  const info = yield* fs.stat(path).pipe(
+    Effect.mapError(
+      (cause) =>
+        new ConfigError({
+          message: `failed to read hook "${path}": ${cause.message}`,
+        }),
+    ),
+  );
 
   if ((info.mode & 0o111) === 0) {
     return yield* new ConfigError({

src/services/openai-client.ts

@@ -50,24 +50,39 @@ const llmTransientRetrySchedule = Schedule.either(
   ),
 );
 
-const isReasoningModel = (model: string): boolean =>
-  ["o1", "o3", "o4"].some(
-    (prefix) =>
-      model === prefix || model.startsWith(`${prefix}-`) || model.startsWith(`${prefix}/`),
+const normalizeModelId = (model: string): string =>
+  model
+    .trim()
+    .toLowerCase()
+    .split("/")
+    .filter((segment) => segment.length > 0)
+    .at(-1) ?? "";
+
+export const isReasoningModel = (model: string): boolean => {
+  const modelId = normalizeModelId(model);
+
+  return (
+    modelId.startsWith("o1") ||
+    modelId.startsWith("o3") ||
+    modelId.startsWith("o4-mini") ||
+    modelId.startsWith("codex-mini") ||
+    modelId.startsWith("computer-use-preview") ||
+    (modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat"))
   );
+};
 
-const makeLanguageModelLayer = (config: ProviderConfig, maxTokens: number) =>
+const makeLanguageModelLayer = (config: ProviderConfig, maxOutputTokens: number) =>
   OpenAi.OpenAiLanguageModel.layer({
     model: config.model,
     config: isReasoningModel(config.model)
       ? {
-          max_output_tokens: maxTokens,
+          max_output_tokens: maxOutputTokens,
           reasoning: {
             effort: "low",
           },
         }
       : {
-          max_output_tokens: maxTokens,
+          max_output_tokens: maxOutputTokens,
           temperature: 0,
         },
   }).pipe(
@@ -83,7 +98,7 @@ const makeLanguageModelLayer = (config: ProviderConfig, maxTokens: number) =>
     ),
   );
 
-const callLlm = (config: ProviderConfig, system: string, user: string, maxTokens: number) =>
+const callLlm = (config: ProviderConfig, system: string, user: string, maxOutputTokens: number) =>
   LanguageModel.generateText({
     prompt: [
       { role: "system", content: system },
@@ -102,7 +117,7 @@ const callLlm = (config: ProviderConfig, system: string, user: string, maxTokens
               }),
           ),
     ),
-    Effect.provide(makeLanguageModelLayer(config, maxTokens)),
+    Effect.provide(makeLanguageModelLayer(config, maxOutputTokens)),
     Effect.catch((cause) =>
       ApiError.is(cause)
         ? Effect.failSync(() => cause)

src/services/vcs.ts

@@ -70,6 +70,14 @@ const processError = (command: string, cause: unknown) =>
     stderr: cause instanceof Error ? cause.message : String(cause),
   });
 
+const checkIgnoreError = (result: ProcessResult) =>
+  new ProcessExecutionError({
+    command: "git check-ignore --stdin",
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  });
+
 const emptyIgnoreRules = (): IgnoreRules => ({
   directoryNames: new Set(),
   relativePaths: new Set(),
@@ -265,7 +273,7 @@ export const GitClientLive = Layer.effect(
         return new Set([...fallbackIgnored, ...normalizeLines(result.stdout).map(toPortablePath)]);
       }
 
-      return fallbackIgnored;
+      return yield* Effect.failSync(() => checkIgnoreError(result));
     });
 
     const buildScanState = Effect.fn(function* (root: string) {
@@ -587,7 +595,7 @@ export const JjClientLive = Layer.effect(
         return new Set([...fallbackIgnored, ...normalizeLines(result.stdout).map(toPortablePath)]);
       }
 
-      return fallbackIgnored;
+      return yield* Effect.failSync(() => checkIgnoreError(result));
     });
 
     const buildScanState = Effect.fn(function* (root: string) {