code-agent-auto-commit 1.0.0

package/dist/cli.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const claude_1 = require("./adapters/claude");
+const codex_1 = require("./adapters/codex");
+const opencode_1 = require("./adapters/opencode");
+const config_1 = require("./core/config");
+const fs_1 = require("./core/fs");
+const run_1 = require("./core/run");
+function parseOptions(args) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const trimmed = arg.slice(2);
+        const eqIndex = trimmed.indexOf("=");
+        if (eqIndex >= 0) {
+            const key = trimmed.slice(0, eqIndex);
+            const value = trimmed.slice(eqIndex + 1);
+            flags[key] = value;
+            continue;
+        }
+        const next = args[i + 1];
+        if (!next || next.startsWith("--")) {
+            flags[trimmed] = true;
+        }
+        else {
+            flags[trimmed] = next;
+            i += 1;
+        }
+    }
+    return { flags, positionals };
+}
+function getStringFlag(flags, key) {
+    const value = flags[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    return undefined;
+}
+function getBooleanFlag(flags, key) {
+    return flags[key] === true;
+}
+function parseScope(value) {
+    if (!value || value === "project") {
+        return "project";
+    }
+    if (value === "global") {
+        return "global";
+    }
+    throw new Error(`Invalid scope: ${value}`);
+}
+function parseTools(value) {
+    if (!value || value === "all") {
+        return ["opencode", "codex", "claude"];
+    }
+    const allowed = new Set(["opencode", "codex", "claude"]);
+    const tools = value.split(",").map((item) => item.trim()).filter(Boolean);
+    for (const tool of tools) {
+        if (!allowed.has(tool)) {
+            throw new Error(`Invalid tool: ${tool}`);
+        }
+    }
+    return tools;
+}
+async function readStdinText() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(String(chunk));
+    }
+    return chunks.join("");
+}
+function printHelp() {
+    console.log(`cac (code-agent-auto-commit)
+
+Usage:
+  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>]
+`);
+}
+async function commandInit(flags) {
+    const worktree = node_path_1.default.resolve(getStringFlag(flags, "worktree") ?? process.cwd());
+    const explicit = getStringFlag(flags, "config");
+    const configPath = explicit ? node_path_1.default.resolve(explicit) : (0, fs_1.getProjectConfigPath)(worktree);
+    (0, config_1.initConfigFile)(configPath, worktree);
+    console.log(`Initialized config: ${configPath}`);
+}
+async function commandInstall(flags) {
+    const worktree = node_path_1.default.resolve(getStringFlag(flags, "worktree") ?? process.cwd());
+    const scope = parseScope(getStringFlag(flags, "scope"));
+    const runnerCommand = getStringFlag(flags, "runner") ?? "cac";
+    const explicitConfig = getStringFlag(flags, "config");
+    const configPath = explicitConfig
+        ? node_path_1.default.resolve(explicitConfig)
+        : node_fs_1.default.existsSync((0, fs_1.getProjectConfigPath)(worktree))
+            ? (0, fs_1.getProjectConfigPath)(worktree)
+            : (0, config_1.resolveConfigPath)({ worktree });
+    if (!node_fs_1.default.existsSync(configPath)) {
+        (0, config_1.initConfigFile)(configPath, worktree);
+    }
+    const tools = parseTools(getStringFlag(flags, "tool"));
+    for (const tool of tools) {
+        if (tool === "opencode") {
+            const pluginPath = (0, opencode_1.installOpenCodeAdapter)({
+                scope,
+                worktree,
+                configPath,
+                runnerCommand,
+            });
+            console.log(`OpenCode installed: ${pluginPath}`);
+        }
+        if (tool === "codex") {
+            const codexPath = (0, codex_1.installCodexAdapter)({
+                scope,
+                worktree,
+                configPath,
+                runnerCommand,
+            });
+            console.log(`Codex installed: ${codexPath}`);
+        }
+        if (tool === "claude") {
+            const claude = (0, claude_1.installClaudeAdapter)({
+                scope,
+                worktree,
+                configPath,
+                runnerCommand,
+            });
+            console.log(`Claude hook installed: ${claude.settingsPath}`);
+            console.log(`Claude script installed: ${claude.scriptPath}`);
+        }
+    }
+}
+async function commandUninstall(flags) {
+    const worktree = node_path_1.default.resolve(getStringFlag(flags, "worktree") ?? process.cwd());
+    const scope = parseScope(getStringFlag(flags, "scope"));
+    const tools = parseTools(getStringFlag(flags, "tool"));
+    for (const tool of tools) {
+        if (tool === "opencode") {
+            console.log(`OpenCode removed: ${(0, opencode_1.uninstallOpenCodeAdapter)(scope, worktree)}`);
+        }
+        if (tool === "codex") {
+            console.log(`Codex removed: ${(0, codex_1.uninstallCodexAdapter)(scope, worktree)}`);
+        }
+        if (tool === "claude") {
+            const result = (0, claude_1.uninstallClaudeAdapter)(scope, worktree);
+            console.log(`Claude hook updated: ${result.settingsPath}`);
+            console.log(`Claude script removed: ${result.scriptPath}`);
+        }
+    }
+}
+async function commandStatus(flags) {
+    const worktree = node_path_1.default.resolve(getStringFlag(flags, "worktree") ?? process.cwd());
+    const scope = parseScope(getStringFlag(flags, "scope"));
+    const explicitConfig = getStringFlag(flags, "config");
+    const loaded = (0, config_1.loadConfig)({ explicitPath: explicitConfig, worktree });
+    console.log(`Config path: ${loaded.path}`);
+    console.log(`Worktree: ${loaded.config.worktree}`);
+    console.log(`Commit mode: ${loaded.config.commit.mode}`);
+    console.log(`AI message: ${loaded.config.ai.enabled ? "enabled" : "disabled"}`);
+    console.log(`Auto push: ${loaded.config.push.enabled ? "enabled" : "disabled"}`);
+    const opencode = (0, opencode_1.opencodeAdapterStatus)(scope, worktree);
+    console.log(`OpenCode adapter: ${opencode.installed ? "installed" : "missing"} (${opencode.path})`);
+    const codex = (0, codex_1.codexAdapterStatus)(scope, worktree);
+    console.log(`Codex adapter: ${codex.installed ? "installed" : "missing"} (${codex.path})`);
+    const claude = (0, claude_1.claudeAdapterStatus)(scope, worktree);
+    console.log(`Claude adapter: ${claude.installed ? "installed" : "missing"} (${claude.settingsPath})`);
+}
+async function commandSetWorktree(flags, positionals) {
+    const nextWorktree = positionals[0];
+    if (!nextWorktree) {
+        throw new Error("Missing worktree path");
+    }
+    const configPath = (0, config_1.resolveConfigPath)({
+        explicitPath: getStringFlag(flags, "config"),
+        worktree: process.cwd(),
+    });
+    const updated = (0, config_1.updateConfigWorktree)(configPath, nextWorktree);
+    console.log(`Updated config: ${configPath}`);
+    console.log(`New worktree: ${updated.worktree}`);
+}
+async function commandRun(flags, positionals) {
+    const tool = (getStringFlag(flags, "tool") ?? "manual");
+    const worktree = getStringFlag(flags, "worktree");
+    const configPath = getStringFlag(flags, "config");
+    let event;
+    const eventJson = getStringFlag(flags, "event-json");
+    if (eventJson) {
+        event = JSON.parse(eventJson);
+    }
+    if (getBooleanFlag(flags, "event-stdin")) {
+        const stdinText = (await readStdinText()).trim();
+        if (stdinText) {
+            event = JSON.parse(stdinText);
+        }
+    }
+    if (!event && positionals.length > 0 && positionals[positionals.length - 1].startsWith("{")) {
+        try {
+            event = JSON.parse(positionals[positionals.length - 1]);
+        }
+        catch {
+            event = undefined;
+        }
+    }
+    if (tool === "codex" && event && typeof event === "object") {
+        const eventType = event.type;
+        if (eventType && eventType !== "agent-turn-complete") {
+            console.log(`Skipped: codex event ${eventType}`);
+            return;
+        }
+    }
+    const result = await (0, run_1.runAutoCommit)({
+        tool,
+        worktree,
+        event,
+        sessionID: getStringFlag(flags, "session-id"),
+    }, {
+        explicitPath: configPath,
+        worktree,
+    });
+    if (result.skipped) {
+        console.log(`Skipped: ${result.reason ?? "unknown"}`);
+        return;
+    }
+    console.log(`Committed: ${result.committed.length}`);
+    for (const item of result.committed) {
+        console.log(`- ${item.hash.slice(0, 12)} ${item.message}`);
+    }
+    console.log(`Pushed: ${result.pushed ? "yes" : "no"}`);
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const command = argv[0];
+    const parsed = parseOptions(argv.slice(1));
+    if (!command || command === "help" || command === "--help") {
+        printHelp();
+        return;
+    }
+    if (command === "init") {
+        await commandInit(parsed.flags);
+        return;
+    }
+    if (command === "install") {
+        await commandInstall(parsed.flags);
+        return;
+    }
+    if (command === "uninstall") {
+        await commandUninstall(parsed.flags);
+        return;
+    }
+    if (command === "status") {
+        await commandStatus(parsed.flags);
+        return;
+    }
+    if (command === "set-worktree") {
+        await commandSetWorktree(parsed.flags, parsed.positionals);
+        return;
+    }
+    if (command === "run") {
+        await commandRun(parsed.flags, parsed.positionals);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+});

package/dist/core/ai.d.ts

@@ -0,0 +1,2 @@
+import type { AIConfig, CommitSummary } from "../types";
+export declare function generateCommitMessage(ai: AIConfig, summary: CommitSummary, maxLength: number): Promise<string | undefined>;

package/dist/core/ai.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommitMessage = generateCommitMessage;
+const DEFAULT_COMMIT_TYPE = "refector";
+function normalizeCommitType(raw) {
+    const value = raw.trim().toLowerCase();
+    if (value === "feat" || value === "feature") {
+        return "feat";
+    }
+    if (value === "fix" || value === "bugfix" || value === "hotfix") {
+        return "fix";
+    }
+    if (value === "refector"
+        || value === "refactor"
+        || value === "refactoring"
+        || value === "chore"
+        || value === "docs"
+        || value === "style"
+        || value === "test"
+        || value === "perf"
+        || value === "build"
+        || value === "ci"
+        || value === "revert") {
+        return "refector";
+    }
+    return undefined;
+}
+function formatTypedMessage(raw, maxLength) {
+    const conventional = raw.match(/^([a-zA-Z-]+)(?:\([^)]*\))?\s*:\s*(.+)$/);
+    const shorthand = raw.match(/^(feat|feature|fix|bugfix|hotfix|refactor|refector)\b[\s:-]+(.+)$/i);
+    const detectedType = normalizeCommitType(conventional?.[1] ?? shorthand?.[1] ?? "");
+    const type = detectedType ?? DEFAULT_COMMIT_TYPE;
+    const subjectCandidate = (conventional?.[2] ?? shorthand?.[2] ?? raw)
+        .replace(/^['"`]+|['"`]+$/g, "")
+        .replace(/^[-:]+/, "")
+        .trim();
+    if (subjectCandidate.length === 0) {
+        return "";
+    }
+    const prefix = `${type}: `;
+    const full = `${prefix}${subjectCandidate}`;
+    if (full.length <= maxLength) {
+        return full;
+    }
+    const available = maxLength - prefix.length;
+    if (available <= 1) {
+        return prefix.trimEnd().slice(0, maxLength);
+    }
+    return `${prefix}${subjectCandidate.slice(0, available - 1).trimEnd()}…`;
+}
+function normalizeMessage(raw, maxLength) {
+    const withoutThinking = raw
+        .replace(/<think>[\s\S]*?<\/think>/gi, "\n")
+        .replace(/<thinking>[\s\S]*?<\/thinking>/gi, "\n")
+        .replace(/<\/?(think|thinking)>/gi, "\n");
+    const cleaned = withoutThinking
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^['"`]+|['"`]+$/g, "").trim())
+        .find((line) => line.length > 0 && line !== "```")
+        ?? "";
+    if (cleaned.length === 0) {
+        return "";
+    }
+    return formatTypedMessage(cleaned, maxLength);
+}
+function getApiKey(config) {
+    if (config.apiKey && config.apiKey.trim().length > 0) {
+        return config.apiKey.trim();
+    }
+    if (!config.apiKeyEnv) {
+        return undefined;
+    }
+    const fromEnv = process.env[config.apiKeyEnv];
+    if (!fromEnv) {
+        return undefined;
+    }
+    return fromEnv.trim();
+}
+function splitModelRef(modelRef, defaultProvider) {
+    const trimmed = modelRef.trim();
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex === -1) {
+        return {
+            provider: defaultProvider,
+            model: trimmed,
+        };
+    }
+    return {
+        provider: trimmed.slice(0, slashIndex).trim(),
+        model: trimmed.slice(slashIndex + 1).trim(),
+    };
+}
+function buildUserPrompt(summary, maxLength) {
+    return [
+        `Generate a short commit message in format "<type>: <subject>" (<= ${maxLength} chars).`,
+        "Allowed types: feat, fix, refector.",
+        "Changed files:",
+        summary.nameStatus || "(none)",
+        "Diff stat:",
+        summary.diffStat || "(none)",
+        "Patch excerpt:",
+        summary.patch || "(none)",
+    ].join("\n\n");
+}
+async function generateOpenAiStyleMessage(provider, model, summary, maxLength, signal) {
+    const apiKey = getApiKey(provider);
+    const headers = {
+        "Content-Type": "application/json",
+        ...(provider.headers ?? {}),
+    };
+    if (apiKey) {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(`${provider.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            model,
+            temperature: 0.2,
+            messages: [
+                {
+                    role: "system",
+                    content: "You generate exactly one commit message line in format '<type>: <subject>'. Type must be one of feat, fix, refector. No quotes. No code block.",
+                },
+                {
+                    role: "user",
+                    content: buildUserPrompt(summary, maxLength),
+                },
+            ],
+        }),
+        signal,
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const payload = (await response.json());
+    return payload.choices?.[0]?.message?.content;
+}
+async function generateAnthropicStyleMessage(provider, model, summary, maxLength, signal) {
+    const apiKey = getApiKey(provider);
+    if (!apiKey) {
+        return undefined;
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        ...(provider.headers ?? {}),
+    };
+    const response = await fetch(`${provider.baseUrl.replace(/\/$/, "")}/messages`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            model,
+            max_tokens: 120,
+            temperature: 0.2,
+            system: "Generate exactly one commit message line in format '<type>: <subject>'. Type must be feat, fix, or refector.",
+            messages: [
+                {
+                    role: "user",
+                    content: buildUserPrompt(summary, maxLength),
+                },
+            ],
+        }),
+        signal,
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const payload = (await response.json());
+    const firstText = payload.content?.find((item) => item.type === "text")?.text;
+    return firstText;
+}
+async function generateCommitMessage(ai, summary, maxLength) {
+    if (!ai.enabled) {
+        return undefined;
+    }
+    const { provider, model } = splitModelRef(ai.model, ai.defaultProvider);
+    if (!provider || !model) {
+        return undefined;
+    }
+    const providerConfig = ai.providers[provider];
+    if (!providerConfig) {
+        return undefined;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), ai.timeoutMs);
+    try {
+        let content;
+        if (providerConfig.api === "openai-completions") {
+            content = await generateOpenAiStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+        }
+        else {
+            content = await generateAnthropicStyleMessage(providerConfig, model, summary, maxLength, controller.signal);
+        }
+        const normalized = normalizeMessage(content ?? "", maxLength);
+        return normalized || undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,8 @@
+import type { AutoCommitConfig, LoadConfigOptions } from "../types";
+export declare function resolveConfigPath(options: LoadConfigOptions): string;
+export declare function loadConfig(options: LoadConfigOptions): {
+    config: AutoCommitConfig;
+    path: string;
+};
+export declare function initConfigFile(targetPath: string, worktree: string): AutoCommitConfig;
+export declare function updateConfigWorktree(configPath: string, worktree: string): AutoCommitConfig;

package/dist/core/config.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigPath = resolveConfigPath;
+exports.loadConfig = loadConfig;
+exports.initConfigFile = initConfigFile;
+exports.updateConfigWorktree = updateConfigWorktree;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+const DEFAULT_CONFIG = (worktree) => ({
+    version: 1,
+    enabled: true,
+    worktree,
+    commit: {
+        mode: "single",
+        fallbackPrefix: "chore(auto)",
+        maxMessageLength: 72,
+    },
+    ai: {
+        enabled: false,
+        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",
+            },
+            openrouter: {
+                api: "openai-completions",
+                baseUrl: "https://openrouter.ai/api/v1",
+                apiKeyEnv: "OPENROUTER_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",
+            },
+            "kimi-coding": {
+                api: "anthropic-messages",
+                baseUrl: "https://api.moonshot.ai/anthropic",
+                apiKeyEnv: "KIMI_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: "",
+    },
+    filters: {
+        include: [],
+        exclude: [".env", ".env.*", "*.pem", "*.key", "*.p12"],
+    },
+});
+function mergeConfig(base, override) {
+    const mergedAiProviders = {
+        ...base.ai.providers,
+    };
+    const overrideProviders = override.ai?.providers ?? {};
+    for (const [providerName, providerConfig] of Object.entries(overrideProviders)) {
+        mergedAiProviders[providerName] = {
+            ...(base.ai.providers[providerName] ?? {}),
+            ...providerConfig,
+        };
+    }
+    return {
+        ...base,
+        ...override,
+        commit: {
+            ...base.commit,
+            ...override.commit,
+        },
+        ai: {
+            ...base.ai,
+            ...override.ai,
+            providers: mergedAiProviders,
+        },
+        push: {
+            ...base.push,
+            ...override.push,
+        },
+        filters: {
+            ...base.filters,
+            ...override.filters,
+            include: override.filters?.include ?? base.filters.include,
+            exclude: override.filters?.exclude ?? base.filters.exclude,
+        },
+    };
+}
+function normalizeConfig(config) {
+    if (config.commit.mode !== "single" && config.commit.mode !== "per-file") {
+        throw new Error(`Invalid commit.mode: ${config.commit.mode}`);
+    }
+    if (config.push.provider !== "github" && config.push.provider !== "gitlab" && config.push.provider !== "generic") {
+        throw new Error(`Invalid push.provider: ${config.push.provider}`);
+    }
+    if (config.commit.maxMessageLength < 20) {
+        config.commit.maxMessageLength = 20;
+    }
+    if (config.ai.timeoutMs < 1000) {
+        config.ai.timeoutMs = 1000;
+    }
+    if (!config.ai.model.trim()) {
+        config.ai.model = "openai/gpt-4.1-mini";
+    }
+    if (!config.ai.defaultProvider.trim()) {
+        config.ai.defaultProvider = "openai";
+    }
+    const allowedApis = new Set(["openai-completions", "anthropic-messages"]);
+    for (const [provider, providerConfig] of Object.entries(config.ai.providers)) {
+        if (!providerConfig.baseUrl?.trim()) {
+            throw new Error(`Invalid ai.providers.${provider}.baseUrl`);
+        }
+        if (!allowedApis.has(providerConfig.api)) {
+            throw new Error(`Invalid ai.providers.${provider}.api: ${providerConfig.api}`);
+        }
+    }
+    if (!config.ai.providers[config.ai.defaultProvider]) {
+        throw new Error(`Missing ai.providers.${config.ai.defaultProvider}`);
+    }
+    return config;
+}
+function resolveConfigPath(options) {
+    if (options.explicitPath) {
+        return node_path_1.default.resolve(options.explicitPath);
+    }
+    const cwd = node_path_1.default.resolve(options.worktree ?? process.cwd());
+    const projectPath = (0, fs_1.getProjectConfigPath)(cwd);
+    if (node_fs_1.default.existsSync(projectPath)) {
+        return projectPath;
+    }
+    return (0, fs_1.getGlobalConfigPath)();
+}
+function loadConfig(options) {
+    const cwd = node_path_1.default.resolve(options.worktree ?? process.cwd());
+    const configPath = resolveConfigPath(options);
+    const raw = (0, fs_1.readJsonFile)(configPath);
+    const merged = mergeConfig(DEFAULT_CONFIG(cwd), raw ?? {});
+    if (!merged.worktree) {
+        merged.worktree = cwd;
+    }
+    return {
+        config: normalizeConfig(merged),
+        path: configPath,
+    };
+}
+function initConfigFile(targetPath, worktree) {
+    const config = DEFAULT_CONFIG(node_path_1.default.resolve(worktree));
+    (0, fs_1.writeJsonFile)(targetPath, config);
+    return config;
+}
+function updateConfigWorktree(configPath, worktree) {
+    const resolved = node_path_1.default.resolve(worktree);
+    const raw = (0, fs_1.readJsonFile)(configPath) ?? {};
+    const merged = mergeConfig(DEFAULT_CONFIG(resolved), raw);
+    merged.worktree = resolved;
+    const normalized = normalizeConfig(merged);
+    (0, fs_1.writeJsonFile)(configPath, normalized);
+    return normalized;
+}

package/dist/core/exec.d.ts

@@ -0,0 +1,7 @@
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function runCommand(command: string, args: string[], cwd: string): CommandResult;
+export declare function runCommandOrThrow(command: string, args: string[], cwd: string): string;