style(gitService): format code with 4-space indentation and double quotes

package.json

@@ -2,7 +2,7 @@
     "name": "ai-commit-ext",
     "displayName": "AI Commit Ext",
     "description": "Generate commit messages using OpenCode AI",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "publisher": "local",
     "engines": {
         "vscode": "^1.110.0"

src/extension.ts

@@ -41,7 +41,11 @@ async function handleGenerateCommitMessage(): Promise<void> {
     const showNotification = config.get<boolean>("showNotification", true);
 
     try {
-        const opencodeAvailable = await isOpenCodeAvailable();
+        const [opencodeAvailable, gitExtension] = await Promise.all([
+            isOpenCodeAvailable(),
+            vscode.extensions.getExtension<GitExtension>("vscode.git"),
+        ]);
+
         if (!opencodeAvailable) {
             if (showNotification) {
                 vscode.window.showErrorMessage(
@@ -51,8 +55,6 @@ async function handleGenerateCommitMessage(): Promise<void> {
             return;
         }
 
-        const gitExtension =
-            vscode.extensions.getExtension<GitExtension>("vscode.git");
         if (!gitExtension) {
             if (showNotification) {
                 vscode.window.showErrorMessage("Git extension not found");
@@ -114,3 +116,5 @@ async function handleGenerateCommitMessage(): Promise<void> {
 }
 
 export function deactivate(): void {}
+
+export const output = vscode.window.createOutputChannel("ai-commit-ext");

src/gitService.ts

@@ -1,170 +1,173 @@
-import * as vscode from 'vscode';
+import * as vscode from "vscode";
 
 interface GitExtension {
-  getAPI(version: number): GitAPI;
+    getAPI(version: number): GitAPI;
 }
 
 interface GitAPI {
-  repositories: Repository[];
+    repositories: Repository[];
 }
 
 interface Repository {
-  root: string;
+    root: string;
-  rootUri: vscode.Uri;
+    rootUri: vscode.Uri;
-  state: RepositoryState;
+    state: RepositoryState;
-  inputBox: { value: string };
+    inputBox: { value: string };
-  diffWithHEAD(path?: string): Promise<string>;
+    diffWithHEAD(path?: string): Promise<string>;
-  diffIndexWithHEAD(path?: string): Promise<string>;
+    diffIndexWithHEAD(path?: string): Promise<string>;
-  status(): Promise<void>;
+    status(): Promise<void>;
 }
 
 interface RepositoryState {
-  indexChanges: Change[];
+    indexChanges: Change[];
-  workingTreeChanges: Change[];
+    workingTreeChanges: Change[];
 }
 
 interface Change {
-  uri: vscode.Uri;
+    uri: vscode.Uri;
-  status: number;
+    status: number;
 }
 
 export interface GitChange {
-  path: string;
+    path: string;
-  status: 'added' | 'modified' | 'deleted' | 'renamed' | 'untracked';
+    status: "added" | "modified" | "deleted" | "renamed" | "untracked";
-  diff?: string;
+    diff?: string;
 }
 
 export async function getGitChanges(): Promise<GitChange[]> {
-  const repository = await getActiveGitRepository();
+    const repository = await getActiveGitRepository();
-  if (!repository) {
+    if (!repository) {
-    throw new Error('No Git repository found');
+        throw new Error("No Git repository found");
-  }
-
-  const state = repository.state;
-  const changes: GitChange[] = [];
-
-  const stagedChanges = state.indexChanges || [];
-  const unstagedChanges = state.workingTreeChanges || [];
-
-  if (stagedChanges.length > 0) {
-    for (const change of stagedChanges) {
-      changes.push({
-        path: change.uri.fsPath,
-        status: getChangeStatus(change.status),
-      });
     }
-  } else if (unstagedChanges.length > 0) {
-    const config = vscode.workspace.getConfiguration('aiCommitExt');
-    const includeUnstaged = config.get<boolean>('includeUnstaged', false);
-    
-    if (includeUnstaged) {
-      for (const change of unstagedChanges) {
-        changes.push({
-          path: change.uri.fsPath,
-          status: getChangeStatus(change.status),
-        });
-      }
-    }
-  }
 
-  return changes;
+    const state = repository.state;
+    const changes: GitChange[] = [];
+
+    const stagedChanges = state.indexChanges || [];
+    const unstagedChanges = state.workingTreeChanges || [];
+
+    if (stagedChanges.length > 0) {
+        for (const change of stagedChanges) {
+            changes.push({
+                path: change.uri.fsPath,
+                status: getChangeStatus(change.status),
+            });
+        }
+    } else if (unstagedChanges.length > 0) {
+        const config = vscode.workspace.getConfiguration("aiCommitExt");
+        const includeUnstaged = config.get<boolean>("includeUnstaged", false);
+
+        if (includeUnstaged) {
+            for (const change of unstagedChanges) {
+                changes.push({
+                    path: change.uri.fsPath,
+                    status: getChangeStatus(change.status),
+                });
+            }
+        }
+    }
+
+    return changes;
 }
 
 export async function getGitDiff(): Promise<string> {
-  const repository = await getActiveGitRepository();
+    const repository = await getActiveGitRepository();
-  if (!repository) {
+    if (!repository) {
-    throw new Error('No Git repository found');
+        throw new Error("No Git repository found");
-  }
-
-  const state = repository.state;
-  let diffOutput = '';
-
-  const stagedChanges = state.indexChanges || [];
-  const unstagedChanges = state.workingTreeChanges || [];
-  const config = vscode.workspace.getConfiguration('aiCommitExt');
-  const includeUnstaged = config.get<boolean>('includeUnstaged', false);
-
-  if (stagedChanges.length > 0) {
-    for (const change of stagedChanges) {
-      const fileName = change.uri.fsPath.split('/').pop() || '';
-      diffOutput += `## ${fileName} (staged)\n`;
-      
-      try {
-        const diff = await repository.diffIndexWithHEAD(change.uri.fsPath);
-        if (diff) {
-          diffOutput += diff + '\n';
-        }
-      } catch {
-        diffOutput += '(Unable to get diff)\n';
-      }
     }
-  } else if (unstagedChanges.length > 0 && includeUnstaged) {
+
-    for (const change of unstagedChanges) {
+    const state = repository.state;
-      const fileName = change.uri.fsPath.split('/').pop() || '';
+    let diffOutput = "";
-      diffOutput += `## ${fileName} (unstaged)\n`;
+
-      
+    const stagedChanges = state.indexChanges || [];
-      try {
+    const unstagedChanges = state.workingTreeChanges || [];
-        const diff = await repository.diffWithHEAD(change.uri.fsPath);
+    const config = vscode.workspace.getConfiguration("aiCommitExt");
-        if (diff) {
+    const includeUnstaged = config.get<boolean>("includeUnstaged", false);
-          diffOutput += diff + '\n';
+
+    if (stagedChanges.length > 0) {
+        for (const change of stagedChanges) {
+            const fileName = change.uri.fsPath.split("/").pop() || "";
+            diffOutput += `## ${fileName} (staged)\n`;
+
+            try {
+                const diff = await repository.diffIndexWithHEAD(
+                    change.uri.fsPath,
+                );
+                if (diff) {
+                    diffOutput += diff + "\n";
+                }
+            } catch {
+                diffOutput += "(Unable to get diff)\n";
+            }
+        }
+    } else if (unstagedChanges.length > 0 && includeUnstaged) {
+        for (const change of unstagedChanges) {
+            const fileName = change.uri.fsPath.split("/").pop() || "";
+            diffOutput += `## ${fileName} (unstaged)\n`;
+
+            try {
+                const diff = await repository.diffWithHEAD(change.uri.fsPath);
+                if (diff) {
+                    diffOutput += diff + "\n";
+                }
+            } catch {
+                diffOutput += "(Unable to get diff)\n";
+            }
         }
-      } catch {
-        diffOutput += '(Unable to get diff)\n';
-      }
     }
-  }
 
-  if (!diffOutput) {
+    if (!diffOutput) {
-    throw new Error('No changes to commit');
+        throw new Error("No changes to commit");
-  }
+    }
 
-  return diffOutput;
+    return diffOutput;
 }
 
 async function getActiveGitRepository(): Promise<Repository | null> {
-  const gitExtension = vscode.extensions.getExtension<GitExtension>('vscode.git');
+    const gitExtension =
-  if (!gitExtension) {
+        vscode.extensions.getExtension<GitExtension>("vscode.git");
-    throw new Error('Git extension not found');
+    if (!gitExtension) {
-  }
+        throw new Error("Git extension not found");
-  
+    }
-  const api = gitExtension.exports.getAPI(1);
+
-  if (api.repositories.length === 0) {
+    const api = gitExtension.exports.getAPI(1);
-    return null;
+    if (api.repositories.length === 0) {
-  }
+        return null;
-  return api.repositories[0];
+    }
+    return api.repositories[0];
 }
 
-function getChangeStatus(status: number): GitChange['status'] {
+function getChangeStatus(status: number): GitChange["status"] {
-  const Status = {
+    const Status = {
-    INDEX_MODIFIED: 0,
+        INDEX_MODIFIED: 0,
-    INDEX_ADDED: 1,
+        INDEX_ADDED: 1,
-    INDEX_DELETED: 2,
+        INDEX_DELETED: 2,
-    INDEX_RENAMED: 3,
+        INDEX_RENAMED: 3,
-    MODIFIED: 4,
+        MODIFIED: 4,
-    DELETED: 5,
+        DELETED: 5,
-    UNTRACKED: 6,
+        UNTRACKED: 6,
-  };
+    };
-  
+
-  if (status === Status.INDEX_ADDED || status === Status.UNTRACKED) {
+    if (status === Status.INDEX_ADDED || status === Status.UNTRACKED) {
-    return 'added';
+        return "added";
-  }
+    }
-  if (status === Status.INDEX_DELETED || status === Status.DELETED) {
+    if (status === Status.INDEX_DELETED || status === Status.DELETED) {
-    return 'deleted';
+        return "deleted";
-  }
+    }
-  if (status === Status.INDEX_RENAMED) {
+    if (status === Status.INDEX_RENAMED) {
-    return 'renamed';
+        return "renamed";
-  }
+    }
-  
+
-  return 'modified';
+    return "modified";
 }
 
 export async function getRepositoryRoot(): Promise<string | null> {
-  const repository = await getActiveGitRepository();
+    const repository = await getActiveGitRepository();
-  if (!repository) {
+    if (!repository) {
-    return null;
+        return null;
-  }
+    }
-  if (typeof repository.root === 'string') {
+    if (typeof repository.root === "string") {
-    return repository.root;
+        return repository.root;
-  }
+    }
-  return repository.rootUri.fsPath;
+    return repository.rootUri.fsPath;
-}
+}

src/opencodeService.ts

@@ -1,11 +1,14 @@
 import { exec, spawn, ExecException } from "child_process";
 import * as vscode from "vscode";
 import { getGitDiff, getRepositoryRoot } from "./gitService";
+import { output } from "./extension";
 
 export interface GenerateOptions {
     model?: string;
 }
 
+let opencodeAvailableCache: boolean | null = null;
+
 const DEFAULT_PROMPT = `You are a helpful assistant that generates git commit messages.
 Generate a concise Conventional Commit message (max 72 characters for the subject line).
 Format: <type>(<scope>): <description>
@@ -15,9 +18,13 @@ Types: feat, fix, refactor, docs, style, test, chore, perf, ci, build, revert
 Only output the commit message, nothing else.`;
 
 export async function isOpenCodeAvailable(): Promise<boolean> {
+    if (opencodeAvailableCache !== null) {
+        return opencodeAvailableCache;
+    }
     return new Promise((resolve) => {
         exec("which opencode", (error: ExecException | null) => {
-            resolve(!error);
+            opencodeAvailableCache = !error;
+            resolve(opencodeAvailableCache);
         });
     });
 }
@@ -32,8 +39,10 @@ export async function generateCommitMessage(
         );
     }
 
-    const diff = await getGitDiff();
+    const [diff, repoRoot] = await Promise.all([
-    const repoRoot = await getRepositoryRoot();
+        getGitDiff(),
+        getRepositoryRoot(),
+    ]);
 
     const config = vscode.workspace.getConfiguration("aiCommitExt");
     const model = options.model || config.get<string>("model", "");
@@ -45,8 +54,17 @@ ${diff}
 
 Generate a concise Conventional Commit message for these changes:`;
 
+    const log = `[${Date.now()}]\r\n${prompt}`;
+    output.appendLine(log);
+
     return new Promise((resolve, reject) => {
-        const args: string[] = ["run", "--format", "default"];
+        const args: string[] = [
+            "run",
+            "--format",
+            "default",
+            "--variant",
+            "minimal",
+        ];
 
         if (model) {
             args.push("--model", model);