code-agent-auto-commit 1.0.0

package/.code-agent-auto-commit.example.json

@@ -0,0 +1,53 @@
+{
+  "version": 1,
+  "enabled": true,
+  "worktree": "/path/to/your/repo",
+  "commit": {
+    "mode": "single",
+    "fallbackPrefix": "chore(auto)",
+    "maxMessageLength": 72
+  },
+  "ai": {
+    "enabled": true,
+    "timeoutMs": 15000,
+    "model": "openai/gpt-4.1-mini",
+    "defaultProvider": "openai",
+    "providers": {
+      "openai": {
+        "api": "openai-completions",
+        "baseUrl": "https://api.openai.com/v1",
+        "apiKeyEnv": "OPENAI_API_KEY"
+      },
+      "anthropic": {
+        "api": "anthropic-messages",
+        "baseUrl": "https://api.anthropic.com/v1",
+        "apiKeyEnv": "ANTHROPIC_API_KEY"
+      },
+      "moonshot": {
+        "api": "openai-completions",
+        "baseUrl": "https://api.moonshot.ai/v1",
+        "apiKeyEnv": "MOONSHOT_API_KEY"
+      },
+      "minimax": {
+        "api": "openai-completions",
+        "baseUrl": "https://api.minimax.chat/v1",
+        "apiKeyEnv": "MINIMAX_API_KEY"
+      },
+      "ollama": {
+        "api": "openai-completions",
+        "baseUrl": "http://127.0.0.1:11434/v1",
+        "apiKeyEnv": "OLLAMA_API_KEY"
+      }
+    }
+  },
+  "push": {
+    "enabled": false,
+    "provider": "github",
+    "remote": "origin",
+    "branch": "main"
+  },
+  "filters": {
+    "include": [],
+    "exclude": [".env", ".env.*", "*.pem", "*.key", "*.p12"]
+  }
+}

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,15 @@
+# Code of Conduct
+
+## Our Pledge
+
+We are committed to a harassment-free experience for everyone.
+
+## Standards
+
+- Be respectful and constructive.
+- Assume good intent.
+- Focus feedback on code and ideas, not people.
+
+## Enforcement
+
+Project maintainers may remove comments, commits, issues, or contributors that violate this policy.

package/CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Contributing
+
+Thanks for contributing.
+
+## Development setup
+
+```bash
+pnpm install
+pnpm run typecheck
+pnpm run build
+pnpm test
+```
+
+## Pull requests
+
+- Keep changes focused and small.
+- Update docs when behavior changes.
+- Add or update tests for logic changes.
+- Do not commit secrets or personal API keys.
+
+## Commit style
+
+Use concise, imperative commit messages.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chat-auto-commit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# code-agent-auto-commit
+
+`code-agent-auto-commit` (`cac`) provides configurable code-agent-end auto-commit(using your git account) for:
+
+- OpenCode
+- Claude Code
+- OpenAI Codex CLI
+
+## Features
+
+- Auto-commit when a chat/agent turn ends
+- Commit strategies:
+  - `single`: all changed files in one commit
+  - `per-file`: one file per commit
+- AI-generated commit messages with multi-provider model configuration
+  - OpenAI-compatible mode (`openai-completions`)
+  - Anthropic-compatible mode (`anthropic-messages`)
+- Optional auto-push to GitHub, GitLab, or generic remotes
+- Tool installers for OpenCode, Codex, and Claude Code
+
+## Installation
+
+```bash
+pnpm add -g code-agent-auto-commit
+```
+
+Then use the short command:
+
+```bash
+cac --help
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize config
+cac init
+
+# 2. Configure AI API key for commit messages
+#    Edit .code-agent-auto-commit.json — set your provider, model, and API key env var.
+#    Or export the key in your shell:
+export MINIMAX_API_KEY='your-api-key'   # or OPENAI_API_KEY, etc.
+
+# 3. Install hooks
+cac install --tool all --scope project
+
+# 4. Verify
+cac status --scope project
+
+# 5. Git config
+git init
+
+# 6. Agentic coding
+opencode / claude / codex
+```
+
+> **Important:** After `cac init`, you **must** configure an AI provider API key.
+> Without a valid key, AI commit messages will not work and `cac` falls back to
+> generic `chore(auto): ...` prefixed messages.
+>
+> **Model tip:** Choose a fast, lightweight model (e.g. `gpt-4.1-mini`,
+> `MiniMax-M2.1-highspeed`). Commit messages are short — speed matters more
+> than intelligence here.
+
+## Commands
+
+```bash
+cac init [--worktree <path>] [--config <path>]
+cac install [--tool all|opencode|codex|claude] [--scope project|global] [--worktree <path>] [--config <path>]
+cac uninstall [--tool all|opencode|codex|claude] [--scope project|global] [--worktree <path>]
+cac status [--scope project|global] [--worktree <path>] [--config <path>]
+cac run [--tool opencode|codex|claude|manual] [--worktree <path>] [--config <path>] [--event-json <json>] [--event-stdin]
+cac set-worktree <path> [--config <path>]
+```
+
+### Command Details
+
+- `cac init`: creates a config file for a worktree. It resolves the target path from `--config` or defaults to `<worktree>/.code-agent-auto-commit.json`.
+- `cac install`: installs adapters/hooks for selected tools (`opencode`, `codex`, `claude`) in `project` or `global` scope. If no config exists at the resolved path, it creates one first.
+- `cac uninstall`: removes previously installed adapters/hooks for selected tools and scope.
+- `cac status`: prints resolved config path, worktree, commit mode, AI/push toggles, and install status of each adapter.
+- `cac run`: executes one auto-commit pass (manual or hook-triggered). It reads config, filters changed files, stages/commits by configured mode, and optionally pushes.
+- `cac set-worktree`: updates only the `worktree` field in the resolved config file.
+
+## Config File
+
+Default project config file:
+
+`.code-agent-auto-commit.json`
+
+You can copy from:
+
+`.code-agent-auto-commit.example.json`
+
+Full schema and options:
+
+- `docs/CONFIG.md`
+- `docs/zh-CN.md`
+
+### AI Key Fields
+
+- `ai.providers.<name>.apiKeyEnv` expects an environment variable name (for example, `MINIMAX_API_KEY`), not the raw key value.
+- If you prefer storing a key directly in config, use `ai.providers.<name>.apiKey`.
+- If AI request fails (missing key, invalid provider/model, or non-2xx response), `cac` falls back to `commit.fallbackPrefix`-style messages.
+
+## AI Models (Multi-Provider)
+
+Model format follows `provider/model` (OpenClaw-style). Example:
+
+```json
+{
+  "ai": {
+    "enabled": true,
+    "model": "openai/gpt-4.1-mini",
+    "defaultProvider": "openai",
+    "providers": {
+      "openai": {
+        "api": "openai-completions",
+        "baseUrl": "https://api.openai.com/v1",
+        "apiKeyEnv": "OPENAI_API_KEY"
+      },
+      "anthropic": {
+        "api": "anthropic-messages",
+        "baseUrl": "https://api.anthropic.com/v1",
+        "apiKeyEnv": "ANTHROPIC_API_KEY"
+      },
+      "moonshot": {
+        "api": "openai-completions",
+        "baseUrl": "https://api.moonshot.ai/v1",
+        "apiKeyEnv": "MOONSHOT_API_KEY"
+      }
+    }
+  }
+}
+```
+
+## Integration Notes
+
+- OpenCode: installs plugin under `.opencode/plugins/` or `~/.config/opencode/plugins/`
+- Codex CLI: writes managed `notify` block in `.codex/config.toml` or `~/.codex/config.toml`
+- Claude Code: installs `Stop` hook in `.claude/settings.json` or `~/.claude/settings.json`
+
+If Codex config already has a custom `notify = ...`, installer stops and asks for manual merge.
+
+## Development
+
+```bash
+pnpm install
+pnpm run typecheck
+pnpm run build
+pnpm test
+```
+
+## Open Source
+
+- Contribution guide: `CONTRIBUTING.md`
+- Security policy: `SECURITY.md`
+- Code of conduct: `CODE_OF_CONDUCT.md`
+
+## License
+
+MIT

package/SECURITY.md

@@ -0,0 +1,17 @@
+# Security Policy
+
+## Reporting a vulnerability
+
+Please report security issues privately to project maintainers instead of opening a public issue.
+
+Include:
+
+- affected version
+- reproduction steps
+- impact assessment
+
+## Secret handling
+
+- Never commit API keys.
+- Prefer environment variables (`OPENAI_API_KEY` by default).
+- Keep `.code-agent-auto-commit.json` free of plaintext secrets when possible.

package/dist/adapters/claude.d.ts

@@ -0,0 +1,20 @@
+import type { InstallScope } from "../types";
+export interface ClaudeInstallInput {
+    scope: InstallScope;
+    worktree: string;
+    configPath: string;
+    runnerCommand: string;
+}
+export declare function installClaudeAdapter(input: ClaudeInstallInput): {
+    settingsPath: string;
+    scriptPath: string;
+};
+export declare function uninstallClaudeAdapter(scope: InstallScope, worktree: string): {
+    settingsPath: string;
+    scriptPath: string;
+};
+export declare function claudeAdapterStatus(scope: InstallScope, worktree: string): {
+    settingsPath: string;
+    scriptPath: string;
+    installed: boolean;
+};

package/dist/adapters/claude.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installClaudeAdapter = installClaudeAdapter;
+exports.uninstallClaudeAdapter = uninstallClaudeAdapter;
+exports.claudeAdapterStatus = claudeAdapterStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../core/fs");
+function settingsPath(scope, worktree) {
+    if (scope === "global") {
+        return node_path_1.default.join(node_os_1.default.homedir(), ".claude", "settings.json");
+    }
+    return node_path_1.default.join(worktree, ".claude", "settings.json");
+}
+function hookScriptPath(scope, worktree) {
+    if (scope === "global") {
+        return node_path_1.default.join(node_os_1.default.homedir(), ".claude", "hooks", "code-agent-auto-commit.sh");
+    }
+    return node_path_1.default.join(worktree, ".claude", "hooks", "code-agent-auto-commit.sh");
+}
+function readSettings(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {};
+    }
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    if (!raw.trim()) {
+        return {};
+    }
+    return JSON.parse(raw);
+}
+function writeSettings(filePath, settings) {
+    (0, fs_1.ensureDirForFile)(filePath);
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+function buildScript(configPath, runnerCommand) {
+    return `#!/usr/bin/env bash
+set -euo pipefail
+
+WORKTREE="\${CLAUDE_PROJECT_DIR:-$PWD}"
+${runnerCommand} run --tool claude --worktree "$WORKTREE" --config ${JSON.stringify(configPath)} --event-stdin || true
+`;
+}
+function installClaudeAdapter(input) {
+    const resolvedWorktree = node_path_1.default.resolve(input.worktree);
+    const resolvedConfig = node_path_1.default.resolve(input.configPath);
+    const targetSettingsPath = settingsPath(input.scope, resolvedWorktree);
+    const targetScriptPath = hookScriptPath(input.scope, resolvedWorktree);
+    const command = `bash ${JSON.stringify(targetScriptPath)}`;
+    (0, fs_1.writeTextFile)(targetScriptPath, buildScript(resolvedConfig, input.runnerCommand));
+    node_fs_1.default.chmodSync(targetScriptPath, 0o755);
+    const settings = readSettings(targetSettingsPath);
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    const stopHooks = settings.hooks.Stop ?? [];
+    const alreadyExists = stopHooks.some((entry) => entry.hooks.some((hook) => hook.command === command));
+    if (!alreadyExists) {
+        stopHooks.push({
+            matcher: "",
+            hooks: [
+                {
+                    type: "command",
+                    command,
+                },
+            ],
+        });
+    }
+    settings.hooks.Stop = stopHooks;
+    writeSettings(targetSettingsPath, settings);
+    return {
+        settingsPath: targetSettingsPath,
+        scriptPath: targetScriptPath,
+    };
+}
+function uninstallClaudeAdapter(scope, worktree) {
+    const resolvedWorktree = node_path_1.default.resolve(worktree);
+    const targetSettingsPath = settingsPath(scope, resolvedWorktree);
+    const targetScriptPath = hookScriptPath(scope, resolvedWorktree);
+    const command = `bash ${JSON.stringify(targetScriptPath)}`;
+    if (node_fs_1.default.existsSync(targetSettingsPath)) {
+        const settings = readSettings(targetSettingsPath);
+        const stopHooks = settings.hooks?.Stop ?? [];
+        const cleaned = stopHooks
+            .map((entry) => ({
+            ...entry,
+            hooks: entry.hooks.filter((hook) => hook.command !== command),
+        }))
+            .filter((entry) => entry.hooks.length > 0);
+        if (!settings.hooks) {
+            settings.hooks = {};
+        }
+        if (cleaned.length > 0) {
+            settings.hooks.Stop = cleaned;
+        }
+        else {
+            delete settings.hooks.Stop;
+        }
+        if (Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+        }
+        writeSettings(targetSettingsPath, settings);
+    }
+    if (node_fs_1.default.existsSync(targetScriptPath)) {
+        node_fs_1.default.unlinkSync(targetScriptPath);
+    }
+    return {
+        settingsPath: targetSettingsPath,
+        scriptPath: targetScriptPath,
+    };
+}
+function claudeAdapterStatus(scope, worktree) {
+    const resolvedWorktree = node_path_1.default.resolve(worktree);
+    const targetSettingsPath = settingsPath(scope, resolvedWorktree);
+    const targetScriptPath = hookScriptPath(scope, resolvedWorktree);
+    const command = `bash ${JSON.stringify(targetScriptPath)}`;
+    if (!node_fs_1.default.existsSync(targetSettingsPath)) {
+        return {
+            settingsPath: targetSettingsPath,
+            scriptPath: targetScriptPath,
+            installed: false,
+        };
+    }
+    const settings = readSettings(targetSettingsPath);
+    const hasHook = (settings.hooks?.Stop ?? []).some((entry) => entry.hooks.some((hook) => hook.command === command));
+    return {
+        settingsPath: targetSettingsPath,
+        scriptPath: targetScriptPath,
+        installed: hasHook && node_fs_1.default.existsSync(targetScriptPath),
+    };
+}

package/dist/adapters/codex.d.ts

@@ -0,0 +1,13 @@
+import type { InstallScope } from "../types";
+export interface CodexInstallInput {
+    scope: InstallScope;
+    worktree: string;
+    configPath: string;
+    runnerCommand: string;
+}
+export declare function installCodexAdapter(input: CodexInstallInput): string;
+export declare function uninstallCodexAdapter(scope: InstallScope, worktree: string): string;
+export declare function codexAdapterStatus(scope: InstallScope, worktree: string): {
+    path: string;
+    installed: boolean;
+};

package/dist/adapters/codex.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCodexAdapter = installCodexAdapter;
+exports.uninstallCodexAdapter = uninstallCodexAdapter;
+exports.codexAdapterStatus = codexAdapterStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../core/fs");
+const START_MARKER = "# BEGIN code-agent-auto-commit";
+const END_MARKER = "# END code-agent-auto-commit";
+function codexConfigPath(scope, worktree) {
+    if (scope === "global") {
+        return node_path_1.default.join(node_os_1.default.homedir(), ".codex", "config.toml");
+    }
+    return node_path_1.default.join(worktree, ".codex", "config.toml");
+}
+function tomlString(value) {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+    return `"${escaped}"`;
+}
+function buildNotifyBlock(worktree, configPath, runnerCommand) {
+    const command = [runnerCommand, "run", "--tool", "codex", "--worktree", worktree, "--config", configPath];
+    const rendered = command.map((item) => tomlString(item)).join(", ");
+    return [
+        START_MARKER,
+        `notify = [${rendered}]`,
+        END_MARKER,
+    ].join("\n");
+}
+function stripManagedBlock(content) {
+    const blockRegex = new RegExp(`${START_MARKER}[\\s\\S]*?${END_MARKER}\\n?`, "g");
+    return content.replace(blockRegex, "");
+}
+function installCodexAdapter(input) {
+    const filePath = codexConfigPath(input.scope, node_path_1.default.resolve(input.worktree));
+    (0, fs_1.ensureDirForFile)(filePath);
+    const existing = node_fs_1.default.existsSync(filePath) ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+    const withoutBlock = stripManagedBlock(existing);
+    if (/^\s*notify\s*=\s*/m.test(withoutBlock)) {
+        throw new Error(`Codex config already contains notify=. Merge manually in ${filePath}`);
+    }
+    const block = buildNotifyBlock(node_path_1.default.resolve(input.worktree), node_path_1.default.resolve(input.configPath), input.runnerCommand);
+    const output = withoutBlock.trimEnd().length > 0 ? `${withoutBlock.trimEnd()}\n\n${block}\n` : `${block}\n`;
+    node_fs_1.default.writeFileSync(filePath, output, "utf8");
+    return filePath;
+}
+function uninstallCodexAdapter(scope, worktree) {
+    const filePath = codexConfigPath(scope, node_path_1.default.resolve(worktree));
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return filePath;
+    }
+    const existing = node_fs_1.default.readFileSync(filePath, "utf8");
+    const updated = stripManagedBlock(existing).trimEnd();
+    node_fs_1.default.writeFileSync(filePath, updated.length > 0 ? `${updated}\n` : "", "utf8");
+    return filePath;
+}
+function codexAdapterStatus(scope, worktree) {
+    const filePath = codexConfigPath(scope, node_path_1.default.resolve(worktree));
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return { path: filePath, installed: false };
+    }
+    const content = node_fs_1.default.readFileSync(filePath, "utf8");
+    return {
+        path: filePath,
+        installed: content.includes(START_MARKER),
+    };
+}

package/dist/adapters/opencode.d.ts

@@ -0,0 +1,13 @@
+import type { InstallScope } from "../types";
+export interface AdapterInstallInput {
+    scope: InstallScope;
+    worktree: string;
+    configPath: string;
+    runnerCommand: string;
+}
+export declare function installOpenCodeAdapter(input: AdapterInstallInput): string;
+export declare function uninstallOpenCodeAdapter(scope: InstallScope, worktree: string): string;
+export declare function opencodeAdapterStatus(scope: InstallScope, worktree: string): {
+    path: string;
+    installed: boolean;
+};

package/dist/adapters/opencode.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installOpenCodeAdapter = installOpenCodeAdapter;
+exports.uninstallOpenCodeAdapter = uninstallOpenCodeAdapter;
+exports.opencodeAdapterStatus = opencodeAdapterStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../core/fs");
+const PLUGIN_FILENAME = "code-agent-auto-commit.ts";
+function resolvePluginPath(scope, worktree) {
+    if (scope === "global") {
+        return node_path_1.default.join((0, fs_1.getUserConfigHome)(), "opencode", "plugins", PLUGIN_FILENAME);
+    }
+    return node_path_1.default.join(worktree, ".opencode", "plugins", PLUGIN_FILENAME);
+}
+function pluginContent(worktree, configPath, runnerCommand) {
+    const target = JSON.stringify(worktree);
+    const cfg = JSON.stringify(configPath);
+    const runner = JSON.stringify(runnerCommand);
+    return `import type { Plugin } from "@opencode-ai/plugin"
+
+const TARGET_WORKTREE = ${target}
+const CONFIG_PATH = ${cfg}
+const RUNNER_COMMAND = ${runner}
+
+export const ChatAutoCommitPlugin: Plugin = async ({ $, client, worktree }) => {
+  const done = new Set<string>()
+
+  return {
+    event: async ({ event }) => {
+      if (event.type !== "session.status") return
+      if (worktree !== TARGET_WORKTREE) return
+
+      if (event.properties.status.type === "busy") {
+        done.delete(event.properties.sessionID)
+        return
+      }
+
+      if (event.properties.status.type !== "idle") return
+      if (done.has(event.properties.sessionID)) return
+
+      const result = await $\`${"${RUNNER_COMMAND}"} run --tool opencode --worktree ${"${worktree}"} --config ${"${CONFIG_PATH}"} --session-id ${"${event.properties.sessionID}"}\`.quiet().nothrow()
+      if (result.exitCode !== 0) {
+        await client.app.log({
+          body: {
+            service: "code-agent-auto-commit",
+            level: "warn",
+            message: "auto-commit runner failed",
+            extra: {
+              sessionID: event.properties.sessionID,
+              stderr: result.stderr.toString(),
+            },
+          },
+        })
+        done.add(event.properties.sessionID)
+        return
+      }
+
+      done.add(event.properties.sessionID)
+      await client.app.log({
+        body: {
+          service: "code-agent-auto-commit",
+          level: "info",
+          message: "auto-commit runner finished",
+          extra: {
+            sessionID: event.properties.sessionID,
+          },
+        },
+      })
+    },
+  }
+}
+
+`;
+}
+function installOpenCodeAdapter(input) {
+    const targetPath = resolvePluginPath(input.scope, node_path_1.default.resolve(input.worktree));
+    (0, fs_1.ensureDirForFile)(targetPath);
+    (0, fs_1.writeTextFile)(targetPath, pluginContent(node_path_1.default.resolve(input.worktree), node_path_1.default.resolve(input.configPath), input.runnerCommand));
+    return targetPath;
+}
+function uninstallOpenCodeAdapter(scope, worktree) {
+    const targetPath = resolvePluginPath(scope, node_path_1.default.resolve(worktree));
+    if (node_fs_1.default.existsSync(targetPath)) {
+        node_fs_1.default.unlinkSync(targetPath);
+    }
+    return targetPath;
+}
+function opencodeAdapterStatus(scope, worktree) {
+    const targetPath = resolvePluginPath(scope, node_path_1.default.resolve(worktree));
+    return {
+        path: targetPath,
+        installed: node_fs_1.default.existsSync(targetPath),
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};