refactor(opencode): replace availability cache with path cache, enhance parsing, enable shell

AGENTS.md

@@ -4,19 +4,43 @@
 
 - **Compile**: `npm run compile` (or `tsc -p ./`)
 - **Watch**: `npm run watch`
-- **Package extension**: `npm run build` → produces `.vsix` file
-- **Test**: Press F5 to launch extension in debug mode
+- **Package**: `npm run build` → produces `.vsix` in project root
+- **Test**: `npm run test` — currently a no-op (`echo "No tests yet"`); press F5 in VS Code to debug the extension
+- **Verify**: `npx tsc --noEmit` — strict mode, TS 6.0 (uses `ignoreDeprecations: "6.0"`)
+- No linter or formatter is configured
 
-## Project Structure
+## Architecture
 
-- `src/extension.ts` - Extension entry point, registers `aiCommitExt.generate` command
-- `src/opencodeService.ts` - Spawns `opencode run` CLI, parses output for commit message
-- `src/gitService.ts` - Uses VS Code Git extension API to get diffs and repo root
+| File | Role |
+|---|---|
+| `src/extension.ts` | Entrypoint; registers `aiCommitExt.generate` command; orchestrates flow |
+| `src/opencodeService.ts` | Spawns `opencode run --format default --variant minimal` with the prompt on stdin; parses stdout for the commit message |
+| `src/gitService.ts` | Uses VS Code's built-in Git extension API (`vscode.git`) for diffs and repo root |
 
-## Key Details
+## Key Behaviors
 
-- Output compiled to `out/` directory
-- Extension activates only on command invocation (not on startup)
-- OpenCode CLI is required on PATH; checked via `which opencode`
-- Generated message written to SCM input box via `repository.inputBox.value`
-- Timeout: 120 seconds for OpenCode response
+- **Activation**: `onCommand` only — not on startup
+- **Diff logic**: Prefers staged changes. Falls back to unstaged **only if** `aiCommitExt.includeUnstaged` is `true` (default `false`).
+- **Prompt**: Hardcoded in `opencodeService.ts` — enforces Conventional Commit format (`<type>(<scope>): <description>`, max 72-char subject). Types: feat, fix, refactor, docs, style, test, chore, perf, ci, build, revert.
+- **Parsing**: Uses `\b(type)(\(scope\))?:\s` regex that matches anywhere in a line (not just line-start), so backtick-wrapped or prose-embedded commit messages are found. ANSI escape sequences are stripped before matching. Falls back to first content line, then `"chore: generated commit message"`.
+- **Stdout is logged** to the output channel ("ai-commit-ext") for debugging.
+- **`--pure` flag**: Not used — opencode loads its user config (`~/.config/opencode/opencode.json`) which needs to configure the model. The extension does NOT pass a hardcoded `--model` flag; the user's config determines the model.
+- **`shell: true`**: Spawn uses a shell so opencode can find `git` and other tools via the shell's PATH (VS Code's GUI-launched process has a minimal PATH).
+- **Timeout**: 120 seconds for OpenCode response.
+- **Model**: Default is whatever opencode's user config sets. Override via `aiCommitExt.model` setting or `GenerateOptions.model`.
+- **OpenCode CLI**: Required on `$PATH`; resolved to an absolute path via `which opencode` and cached — used in `spawn()` to avoid PATH lookup mismatches between the shell and VS Code's process environment.
+
+## Configuration (`aiCommitExt.*`)
+
+| Setting | Default | Purpose |
+|---|---|---|
+| `model` | `""` | OpenCode model override |
+| `includeUnstaged` | `false` | Use unstaged changes when nothing staged |
+| `showNotification` | `true` | Show VS Code notifications on success/error |
+
+## Build Artifacts & Cleanup
+
+- Compiled output → `out/` (gitignored)
+- Packaged extension → `*.vsix` (gitignored)
+- `node_modules/` (gitignored)
+- `npm run compile` before packaging (`vscode:prepublish` hook)

package.json

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

src/opencodeService.ts

@@ -8,7 +8,7 @@ export interface GenerateOptions {
     userSuggestion?: string;
 }
 
-let opencodeAvailableCache: boolean | null = null;
+let opencodePathCache: string | 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).
@@ -19,28 +19,42 @@ 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;
+    try {
+        await getOpenCodePath();
+        return true;
+    } catch {
+        return false;
     }
-    return new Promise((resolve) => {
-        exec("which opencode", (error: ExecException | null) => {
-            opencodeAvailableCache = !error;
-            resolve(opencodeAvailableCache);
-        });
+}
+
+async function getOpenCodePath(): Promise<string> {
+    if (opencodePathCache !== null) {
+        return opencodePathCache;
+    }
+    return new Promise((resolve, reject) => {
+        exec(
+            "which opencode",
+            (error: ExecException | null, stdout: string) => {
+                if (error) {
+                    reject(
+                        new Error(
+                            "OpenCode not found. Please install from https://opencode.ai",
+                        ),
+                    );
+                } else {
+                    opencodePathCache = stdout.trim();
+                    resolve(opencodePathCache);
+                }
+            },
+        );
     });
 }
 
 export async function generateCommitMessage(
     options: GenerateOptions = {},
 ): Promise<string> {
-    const opencodeAvailable = await isOpenCodeAvailable();
-    if (!opencodeAvailable) {
-        throw new Error(
-            "OpenCode is not installed. Please install it from https://opencode.ai",
-        );
-    }
-
-    const [diff, repoRoot] = await Promise.all([
+    const [opencodePath, diff, repoRoot] = await Promise.all([
+        getOpenCodePath(),
         getGitDiff(),
         getRepositoryRoot(),
     ]);
@@ -70,17 +84,13 @@ ${diff}
 Generate a concise Conventional Commit message for these changes:`;
     }
 
-    const log = `[${Date.now()}]\r\n${prompt}`;
-    output.appendLine(log);
+    output.appendLine(`[${Date.now()}]\r\n${prompt}`);
 
     return new Promise((resolve, reject) => {
         const args: string[] = [
             "run",
-            "--pure",
             "--format",
             "default",
-            "-m",
-            "opencode/gpt-5-nano",
             "--variant",
             "minimal",
         ];
@@ -89,10 +99,20 @@ Generate a concise Conventional Commit message for these changes:`;
             args.push("--model", model);
         }
 
-        const proc = spawn("opencode", args, {
+        const proc = spawn(opencodePath, args, {
             stdio: ["pipe", "pipe", "pipe"],
-            shell: false,
+            shell: true,
             cwd: repoRoot || undefined,
+            env: {
+                ...process.env,
+                OPENCODE_SERVER_PASSWORD: undefined,
+                OPENCODE_SERVER_USERNAME: undefined,
+                OPENCODE_CLIENT: undefined,
+                OPENCODE_HOST: undefined,
+                OPENCODE_PORT: undefined,
+                OPENCODE_SKIP_START: undefined,
+                OPENCODE_BINARY: undefined,
+            },
         });
 
         let stdout = "";
@@ -106,7 +126,8 @@ Generate a concise Conventional Commit message for these changes:`;
         });
         proc.stdin?.write(prompt + "\n", (err) => {
             if (err) {
-                new Error(`OpenCode write error with ${err}`);
+                reject(new Error(`OpenCode write error with ${err}`));
+                return;
             }
             proc.stdin?.end();
         });
@@ -119,6 +140,7 @@ Generate a concise Conventional Commit message for these changes:`;
                 return;
             }
 
+            output.appendLine(stdout);
             const message = parseCommitMessage(stdout);
             resolve(message);
         });
@@ -135,31 +157,32 @@ Generate a concise Conventional Commit message for these changes:`;
 }
 
 function parseCommitMessage(output: string): string {
-    const lines = output.split("\n").filter((line) => line.trim());
+    const clean = output.replace(/\x1b\[[0-9;]*m/g, "");
+    const lines = clean.split("\n").filter((line) => line.trim());
+
+    const ccTypes = [
+        "feat",
+        "fix",
+        "refactor",
+        "docs",
+        "style",
+        "test",
+        "chore",
+        "perf",
+        "ci",
+        "build",
+        "revert",
+    ];
+
+    const pat = new RegExp(`\\b(${ccTypes.join("|")})(\\([^)]*\\))?:\\s`);
 
     for (const line of lines) {
         const trimmed = line.trim();
-
-        if (
-            trimmed.includes(":") &&
-            (trimmed.startsWith("feat") ||
-                trimmed.startsWith("fix") ||
-                trimmed.startsWith("refactor") ||
-                trimmed.startsWith("docs") ||
-                trimmed.startsWith("style") ||
-                trimmed.startsWith("test") ||
-                trimmed.startsWith("chore") ||
-                trimmed.startsWith("perf") ||
-                trimmed.startsWith("ci") ||
-                trimmed.startsWith("build") ||
-                trimmed.startsWith("revert"))
-        ) {
-            return trimmed.substring(0, 200);
+        const m = trimmed.match(pat);
+        if (m) {
+            return trimmed.substring(m.index!).substring(0, 200);
         }
     }
 
-    const cleaned =
-        output.trim().split("\n")[0]?.substring(0, 200) ||
-        "chore: generated commit message";
-    return cleaned;
+    return lines[0]?.substring(0, 200) || "chore: generated commit message";
 }