src/main/ipc/utility.ts (1)

205-218: Async conversion looks good; consider removing redundant access() check.

The fs.promises.access() call on lines 205-209 is redundant since fs.promises.stat() on line 212 will throw ENOENT if the file doesn't exist. The outer try/catch already handles this case.

♻️ Optional: Simplify by removing the access() check

     const safePath = validation.normalizedPath!;
 
-    // Check if file exists
-    try {
-      await fs.promises.access(safePath);
-    } catch {
-      return null;
-    }
-
     // Check if it's a file (not directory)
-    const stats = await fs.promises.stat(safePath);
+    let stats: fs.Stats;
+    try {
+      stats = await fs.promises.stat(safePath);
+    } catch {
+      return null;
+    }
     if (!stats.isFile()) {
       return null;
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/main/ipc/utility.ts` around lines 205 - 218, Remove the redundant
fs.promises.access(safePath) check: in the function using safePath, delete the
try/catch that calls fs.promises.access and rely on fs.promises.stat(safePath)
to throw if the path doesn't exist; keep the subsequent isFile() check and the
readFile(safePath, 'utf8') call so behavior and error handling remain the same,
only eliminating the unnecessary access() invocation.

src/main/services/parsing/GitIdentityResolver.ts (3)

55-64: Consider consolidating existence check with stat operation.

The current pattern performs two async filesystem operations: access() to check existence, then stat(). You could simplify to a single stat() call, catching ENOENT to handle the non-existence case.

♻️ Optional: Single stat call with error handling

-      let gitPathExists = false;
-      try {
-        await fs.promises.access(gitPath);
-        gitPathExists = true;
-      } catch {
-        // Path doesn't exist
-      }
-
-      if (gitPathExists) {
-        const stats = await fs.promises.stat(gitPath);
+      let stats: fs.Stats | null = null;
+      try {
+        stats = await fs.promises.stat(gitPath);
+      } catch {
+        // Path doesn't exist or is inaccessible
+      }
+
+      if (stats) {

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/main/services/parsing/GitIdentityResolver.ts` around lines 55 - 64, The
code in GitIdentityResolver currently calls fs.promises.access(gitPath) and then
fs.promises.stat(gitPath); consolidate these into a single
fs.promises.stat(gitPath) call and catch errors: replace the two-step existence
check with one try/catch around stat(gitPath), treat ENOENT as "path doesn't
exist" (skip the stat result) and rethrow or handle other errors; update any
logic that used gitPathExists to use the presence/absence of the stat result.

---

266-279: Redundant nested try/catch blocks.

The nested try/catch structure at lines 268-273 inside 266-276 is redundant since both catch blocks handle errors the same way (ignore and continue). This can be simplified.

♻️ Optional: Simplify error handling

     // Fallback: check filesystem if available
     try {
       const gitPath = path.join(projectPath, '.git');
-      try {
-        const stats = await fs.promises.stat(gitPath);
-        return stats.isFile();
-      } catch {
-        // Path doesn't exist
-      }
+      const stats = await fs.promises.stat(gitPath);
+      return stats.isFile();
     } catch {
-      // Ignore errors - filesystem might not be available
+      // Path doesn't exist or filesystem not available
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/main/services/parsing/GitIdentityResolver.ts` around lines 266 - 279, The
nested try/catch in GitIdentityResolver (the function that checks the .git path)
is redundant; replace the two-level try/catch with a single try/catch: compute
gitPath (path.join(projectPath, '.git')), await fs.promises.stat(gitPath),
return stats.isFile() in the try block, and in the single catch block return
false (or fall through to return false) so errors are handled once and the outer
try/catch is removed.

---

537-552: Same redundant nested try/catch pattern.

Similar to isWorktree, the nested try/catch blocks here can be simplified.

♻️ Optional: Simplify error handling

     // Check if it's a standard git repo (only if filesystem exists)
     // For deleted repos, we'll return 'git' as fallback since we can't verify
     try {
       const gitPath = path.join(projectPath, '.git');
-      try {
-        await fs.promises.access(gitPath);
-        return 'git';
-      } catch {
-        // Path doesn't exist
-      }
+      await fs.promises.access(gitPath);
+      return 'git';
     } catch {
-      // Ignore errors - filesystem might not be available
+      // Path doesn't exist or filesystem not available
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/main/services/parsing/GitIdentityResolver.ts` around lines 537 - 552, The
nested try/catch around checking fs.promises.access(gitPath) is redundant;
simplify by using a single try/catch that attempts await
fs.promises.access(gitPath) and returns 'git' on success, and otherwise falls
through to the final return 'git'. Modify the block in GitIdentityResolver that
builds gitPath and calls fs.promises.access (remove the outer try/catch and keep
a single try/catch around the access call), ensuring any filesystem errors are
caught once and ignored so the function still ultimately returns 'git'.

src/main/services/infrastructure/ConfigManager.ts (1)

414-422: Consider converting persistConfig to async for consistency.

The PR converts reads to async but persistConfig still uses synchronous fs.existsSync, fs.mkdirSync, and fs.writeFileSync. These can block the event loop during config saves, which happen on every update.

♻️ Suggested async conversion

-  private persistConfig(config: AppConfig): void {
+  private async persistConfig(config: AppConfig): Promise<void> {
     const configDir = path.dirname(this.configPath);
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
-    }
+    await fs.promises.mkdir(configDir, { recursive: true });

     const content = JSON.stringify(config, null, 2);
-    fs.writeFileSync(this.configPath, content, 'utf8');
+    await fs.promises.writeFile(this.configPath, content, 'utf8');
   }

Note: This would require updating saveConfig() and all callers to handle the async nature, which may be out of scope for this PR.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/main/services/infrastructure/ConfigManager.ts` around lines 414 - 422,
persistConfig currently uses blocking fs calls (fs.existsSync, fs.mkdirSync,
fs.writeFileSync) which can block the event loop; convert persistConfig to an
async function that returns Promise<void>, use fs.promises (or import { promises
as fs } ) to await fs.mkdir(path.dirname(this.configPath), { recursive: true })
and await fs.writeFile(this.configPath, JSON.stringify(config, null, 2),
'utf8'), handling errors with try/catch and rethrow or log as appropriate;
update saveConfig and any callers to await the new async persistConfig (or
return the Promise) so callers handle async behavior consistently.