cortex-agents 2.1.0 → 2.3.0

package/dist/cli.js

@@ -4,7 +4,7 @@ import * as path from "path";
 import { fileURLToPath } from "url";
 import prompts from "prompts";
 import { PRIMARY_AGENTS, SUBAGENTS, ALL_AGENTS, getPrimaryChoices, getSubagentChoices, } from "./registry.js";
-const VERSION = "2.1.0";
+const VERSION = "2.3.0";
 const PLUGIN_NAME = "cortex-agents";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -38,6 +38,66 @@ function writeConfig(configPath, config) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
+// ─── Per-Project Model Config (.opencode/models.json) ───────────────────────
+const PROJECT_MODELS_FILE = "models.json";
+function getProjectModelsPath() {
+    return path.join(process.cwd(), ".opencode", PROJECT_MODELS_FILE);
+}
+function hasProjectModelsConfig() {
+    return fs.existsSync(getProjectModelsPath());
+}
+function readProjectModels() {
+    const modelsPath = getProjectModelsPath();
+    if (!fs.existsSync(modelsPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeProjectModels(primary, subagent) {
+    const modelsPath = getProjectModelsPath();
+    const dir = path.dirname(modelsPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const config = {
+        primary: { model: primary },
+        subagent: { model: subagent },
+        agents: {},
+    };
+    for (const name of PRIMARY_AGENTS) {
+        config.agents[name] = { model: primary };
+    }
+    for (const name of SUBAGENTS) {
+        config.agents[name] = { model: subagent };
+    }
+    fs.writeFileSync(modelsPath, JSON.stringify(config, null, 2) + "\n");
+}
+/**
+ * Sync .opencode/models.json → local opencode.json agent model settings.
+ * Creates or merges into local opencode.json at project root.
+ */
+function syncProjectModelsToConfig() {
+    const models = readProjectModels();
+    if (!models)
+        return false;
+    const localPath = path.join(process.cwd(), "opencode.json");
+    const config = fs.existsSync(localPath)
+        ? readConfig(localPath)
+        : { $schema: "https://opencode.ai/config.json" };
+    if (!config.agent)
+        config.agent = {};
+    for (const [name, entry] of Object.entries(models.agents)) {
+        if (!config.agent[name])
+            config.agent[name] = {};
+        config.agent[name].model = entry.model;
+    }
+    writeConfig(localPath, config);
+    return true;
+}
 // ─── File Copy Helpers ───────────────────────────────────────────────────────
 function copyDirRecursive(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
@@ -137,8 +197,16 @@ function install() {
     // Copy agents and skills into the global opencode config dir
     console.log("Installing agents and skills...");
     installAgentsAndSkills(globalDir);
+    // Sync per-project models if .opencode/models.json exists
+    if (hasProjectModelsConfig()) {
+        console.log("\nPer-project model config found (.opencode/models.json)");
+        if (syncProjectModelsToConfig()) {
+            console.log("  Synced model settings to local opencode.json");
+        }
+    }
     console.log("\nDone! Next steps:");
-    console.log(`  1. Run 'npx ${PLUGIN_NAME} configure' to select your models`);
+    console.log(`  1. Run 'npx ${PLUGIN_NAME} configure' to select your models (global)`);
+    console.log(`     Or 'npx ${PLUGIN_NAME} configure --project' for per-project config`);
     console.log("  2. Restart OpenCode to load the plugin\n");
 }
 function uninstall() {
@@ -180,23 +248,82 @@ function uninstall() {
 async function configure() {
     const args = process.argv.slice(3);
     const isReset = args.includes("--reset");
+    const isProject = args.includes("--project");
     // Handle --reset flag
     if (isReset) {
-        return configureReset();
+        return configureReset(isProject);
+    }
+    const scope = isProject ? "Per-Project" : "Global";
+    console.log(`\n🔧 Cortex Agents — ${scope} Model Configuration\n`);
+    if (isProject) {
+        const opencodeDir = path.join(process.cwd(), ".opencode");
+        if (!fs.existsSync(opencodeDir)) {
+            console.log(`⚠  No .opencode/ directory found in ${process.cwd()}.`);
+            console.log(`   Run 'npx ${PLUGIN_NAME} install' first, or use 'configure' without --project for global config.\n`);
+            process.exit(1);
+        }
+        console.log(`Project: ${process.cwd()}`);
+        console.log(`Config:  .opencode/models.json + opencode.json\n`);
     }
-    console.log(`\n🔧 Cortex Agents — Model Configuration\n`);
-    // Ensure plugin is installed first
+    // Ensure plugin is installed first (for global mode)
     const configInfo = findOpencodeConfig();
     const config = configInfo
         ? readConfig(configInfo.path)
         : { $schema: "https://opencode.ai/config.json" };
-    if (!config.plugin?.includes(PLUGIN_NAME)) {
+    if (!isProject && !config.plugin?.includes(PLUGIN_NAME)) {
         console.log(`⚠  Plugin not installed. Adding '${PLUGIN_NAME}' to config first.\n`);
         if (!config.plugin)
             config.plugin = [];
         config.plugin.push(PLUGIN_NAME);
     }
     // ── Primary model selection ────────────────────────────────
+    const { primary, subagent } = await promptModelSelection();
+    // ── Write config ───────────────────────────────────────────
+    if (isProject) {
+        // Per-project: write .opencode/models.json + sync to local opencode.json
+        writeProjectModels(primary, subagent);
+        syncProjectModelsToConfig();
+        const modelsPath = getProjectModelsPath();
+        const localConfigPath = path.join(process.cwd(), "opencode.json");
+        console.log("━".repeat(50));
+        console.log(`✓ Per-project config saved:\n`);
+        console.log(`  Models:  ${modelsPath}`);
+        console.log(`  Runtime: ${localConfigPath}\n`);
+    }
+    else {
+        // Global: write to opencode.json (existing behavior)
+        if (!config.agent)
+            config.agent = {};
+        for (const name of PRIMARY_AGENTS) {
+            if (!config.agent[name])
+                config.agent[name] = {};
+            config.agent[name].model = primary;
+        }
+        for (const name of SUBAGENTS) {
+            if (!config.agent[name])
+                config.agent[name] = {};
+            config.agent[name].model = subagent;
+        }
+        const targetPath = configInfo?.path || path.join(getGlobalDir(), "opencode.json");
+        writeConfig(targetPath, config);
+        console.log("━".repeat(50));
+        console.log(`✓ Configuration saved to ${targetPath}\n`);
+    }
+    console.log("  Primary agents:");
+    for (const name of PRIMARY_AGENTS) {
+        console.log(`    ${name.padEnd(10)} → ${primary}`);
+    }
+    console.log("\n  Subagents:");
+    for (const name of SUBAGENTS) {
+        console.log(`    ${name.padEnd(10)} → ${subagent}`);
+    }
+    console.log("\nRestart OpenCode to apply changes.\n");
+}
+/**
+ * Interactive prompt for primary + subagent model selection.
+ * Shared between global and per-project configure flows.
+ */
+async function promptModelSelection() {
     const primaryChoices = getPrimaryChoices();
     primaryChoices.push({
         title: "Enter custom model ID",
@@ -211,7 +338,6 @@ async function configure() {
         choices: primaryChoices,
         hint: "Use arrow keys, Enter to confirm",
     });
-    // User cancelled (Ctrl+C)
     if (primaryModel === undefined) {
         console.log("\nConfiguration cancelled.\n");
         process.exit(0);
@@ -265,36 +391,54 @@ async function configure() {
         subagent = custom;
     }
     console.log(`✓ Subagent model: ${subagent}\n`);
-    // ── Write to opencode.json ─────────────────────────────────
-    if (!config.agent)
-        config.agent = {};
-    for (const name of PRIMARY_AGENTS) {
-        if (!config.agent[name])
-            config.agent[name] = {};
-        config.agent[name].model = primary;
-    }
-    for (const name of SUBAGENTS) {
-        if (!config.agent[name])
-            config.agent[name] = {};
-        config.agent[name].model = subagent;
-    }
-    const targetPath = configInfo?.path || path.join(getGlobalDir(), "opencode.json");
-    writeConfig(targetPath, config);
-    // ── Print summary ──────────────────────────────────────────
-    console.log("━".repeat(50));
-    console.log(`✓ Configuration saved to ${targetPath}\n`);
-    console.log("  Primary agents:");
-    for (const name of PRIMARY_AGENTS) {
-        console.log(`    ${name.padEnd(10)} → ${primary}`);
-    }
-    console.log("\n  Subagents:");
-    for (const name of SUBAGENTS) {
-        console.log(`    ${name.padEnd(10)} → ${subagent}`);
-    }
-    console.log("\nRestart OpenCode to apply changes.\n");
+    return { primary, subagent };
 }
-function configureReset() {
-    console.log(`\n🔧 Cortex Agents — Reset Model Configuration\n`);
+function configureReset(isProject = false) {
+    const scope = isProject ? "Per-Project" : "Global";
+    console.log(`\n🔧 Cortex Agents — Reset ${scope} Model Configuration\n`);
+    if (isProject) {
+        // Reset per-project config
+        const modelsPath = getProjectModelsPath();
+        let removedModels = false;
+        if (fs.existsSync(modelsPath)) {
+            fs.unlinkSync(modelsPath);
+            console.log(`✓ Removed ${modelsPath}`);
+            removedModels = true;
+        }
+        // Also clean agent models from local opencode.json
+        const localConfigPath = path.join(process.cwd(), "opencode.json");
+        if (fs.existsSync(localConfigPath)) {
+            const config = readConfig(localConfigPath);
+            if (config.agent) {
+                let resetCount = 0;
+                for (const name of ALL_AGENTS) {
+                    if (config.agent[name]?.model) {
+                        delete config.agent[name].model;
+                        resetCount++;
+                        if (Object.keys(config.agent[name]).length === 0) {
+                            delete config.agent[name];
+                        }
+                    }
+                }
+                if (Object.keys(config.agent).length === 0) {
+                    delete config.agent;
+                }
+                if (resetCount > 0) {
+                    writeConfig(localConfigPath, config);
+                    console.log(`✓ Removed ${resetCount} agent model entries from ${localConfigPath}`);
+                    removedModels = true;
+                }
+            }
+        }
+        if (!removedModels) {
+            console.log("No per-project model configuration found. Nothing to reset.\n");
+            return;
+        }
+        console.log("\nAgents will now fall back to global or OpenCode default models.");
+        console.log("Restart OpenCode to apply changes.\n");
+        return;
+    }
+    // Global reset (existing behavior)
     const configInfo = findOpencodeConfig();
     if (!configInfo) {
         console.log("No OpenCode config found. Nothing to reset.\n");
@@ -355,12 +499,20 @@ function status() {
         : 0;
     console.log(`\nAgents installed: ${agentCount}`);
     console.log(`Skills installed: ${skillCount}`);
-    // Show model configuration
+    // Show per-project model configuration
+    const projectModels = readProjectModels();
+    if (projectModels) {
+        console.log("\nPer-Project Models (.opencode/models.json):");
+        console.log(`  Primary agents:  ${projectModels.primary.model}`);
+        console.log(`  Subagents:       ${projectModels.subagent.model}`);
+    }
+    // Show global/active model configuration
     if (config.agent) {
         const primaryModels = PRIMARY_AGENTS.map((n) => config.agent?.[n]?.model).filter(Boolean);
         const subagentModels = SUBAGENTS.map((n) => config.agent?.[n]?.model).filter(Boolean);
         if (primaryModels.length > 0 || subagentModels.length > 0) {
-            console.log("\nModel Configuration:");
+            const source = projectModels ? "Active" : "Global";
+            console.log(`\n${source} Model Configuration (opencode.json):`);
             if (primaryModels.length > 0) {
                 const unique = [...new Set(primaryModels)];
                 console.log(`  Primary agents:  ${unique.join(", ")}`);
@@ -370,14 +522,16 @@ function status() {
                 console.log(`  Subagents:       ${unique.join(", ")}`);
             }
         }
-        else {
+        else if (!projectModels) {
             console.log("\nModels: Not configured (using OpenCode defaults)");
-            console.log(`  Run 'npx ${PLUGIN_NAME} configure' to select models.`);
+            console.log(`  Run 'npx ${PLUGIN_NAME} configure' for global config`);
+            console.log(`  Run 'npx ${PLUGIN_NAME} configure --project' for per-project config`);
         }
     }
-    else {
+    else if (!projectModels) {
         console.log("\nModels: Not configured (using OpenCode defaults)");
-        console.log(`  Run 'npx ${PLUGIN_NAME} configure' to select models.`);
+        console.log(`  Run 'npx ${PLUGIN_NAME} configure' for global config`);
+        console.log(`  Run 'npx ${PLUGIN_NAME} configure --project' for per-project config`);
     }
     if (!isInstalled) {
         console.log(`\nRun 'npx ${PLUGIN_NAME} install' to add to config.`);
@@ -387,48 +541,59 @@ function status() {
 function help() {
     console.log(`${PLUGIN_NAME} v${VERSION}
 
-Cortex agents for OpenCode — agent handover notifications, mermaid documentation,
-worktree workflow, plan persistence, and session management.
+Supercharge OpenCode with structured workflows, intelligent agents,
+and automated development practices.
 
 USAGE:
   npx ${PLUGIN_NAME} <command> [options]
 
 COMMANDS:
   install              Install plugin, agents, and skills into OpenCode config
-  configure            Interactive model selection for all agents
+  configure            Interactive model selection (global)
+  configure --project  Interactive model selection (per-project, saves to .opencode/)
   configure --reset    Reset model configuration to OpenCode defaults
+  configure --project --reset  Reset per-project model configuration
   uninstall            Remove plugin, agents, skills, and model config
   status               Show installation and model configuration status
   help                 Show this help message
 
 EXAMPLES:
-  npx ${PLUGIN_NAME} install           # Install plugin
-  npx ${PLUGIN_NAME} configure         # Select models interactively
-  npx ${PLUGIN_NAME} configure --reset # Reset to default models
-  npx ${PLUGIN_NAME} status            # Check status
+  npx ${PLUGIN_NAME} install                    # Install plugin
+  npx ${PLUGIN_NAME} configure                  # Global model selection
+  npx ${PLUGIN_NAME} configure --project        # Per-project models (.opencode/models.json)
+  npx ${PLUGIN_NAME} configure --reset          # Reset global models
+  npx ${PLUGIN_NAME} configure --project --reset # Reset per-project models
+  npx ${PLUGIN_NAME} status                     # Check status
 
-AGENT TIERS:
-  Primary agents (build, plan, debug):
+AGENTS:
+  Primary (build, plan, debug):
     Handle complex tasks — select your best model.
 
   Subagents (fullstack, testing, security, devops):
     Handle focused tasks — a fast/cheap model works great.
 
-INCLUDED TOOLS:
-  cortex_init, cortex_status    - .cortex directory management
-  worktree_create, worktree_list, worktree_remove, worktree_open
-  branch_create, branch_status, branch_switch
-  plan_save, plan_list, plan_load, plan_delete
-  session_save, session_list, session_load
-  docs_init, docs_save, docs_list, docs_index  - mermaid documentation
-
-FEATURES:
-  Agent handover notifications  - Toast alerts when agents switch
-  Mermaid documentation system  - Auto-prompted docs with diagrams
+TOOLS (23):
+  cortex_init, cortex_status      .cortex directory management
+  cortex_configure                Per-project model configuration
+  worktree_create, worktree_list  Git worktree management
+  worktree_remove, worktree_open
+  worktree_launch                 Launch worktree (terminal/PTY/background)
+  branch_create, branch_status    Git branch operations
+  branch_switch
+  plan_save, plan_list            Plan persistence
+  plan_load, plan_delete
+  session_save, session_list      Session management
+  session_load
+  docs_init, docs_save            Mermaid documentation
+  docs_list, docs_index
+  task_finalize                   Commit, push, and create PR
 
-INCLUDED SKILLS:
-  web-development, testing-strategies, security-hardening,
-  deployment-automation, code-quality, git-workflow
+SKILLS (14):
+  web-development, frontend-development, backend-development,
+  mobile-development, desktop-development, database-design,
+  api-design, architecture-patterns, design-patterns,
+  testing-strategies, security-hardening, deployment-automation,
+  performance-optimization, code-quality, git-workflow
 `);
 }
 // ─── CLI Entry Point ─────────────────────────────────────────────────────────

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAqBlD,eAAO,MAAM,YAAY,EAAE,MA8D1B,CAAC;AAGF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAsBlD,eAAO,MAAM,YAAY,EAAE,MAmE1B,CAAC;AAGF,eAAe,YAAY,CAAC"}

package/dist/index.js

@@ -5,6 +5,7 @@ import * as branch from "./tools/branch";
 import * as plan from "./tools/plan";
 import * as session from "./tools/session";
 import * as docs from "./tools/docs";
+import * as task from "./tools/task";
 // Agent descriptions for handover toast notifications
 const AGENT_DESCRIPTIONS = {
     build: "Development mode — ready to implement",
@@ -21,13 +22,15 @@ export const CortexPlugin = async (ctx) => {
             // Cortex tools - .cortex directory management
             cortex_init: cortex.init,
             cortex_status: cortex.status,
-            // Worktree tools - git worktree management
-            worktree_create: worktree.create,
+            cortex_configure: cortex.configure,
+            // Worktree tools - git worktree management (factories for toast notifications)
+            worktree_create: worktree.createCreate(ctx.client),
             worktree_list: worktree.list,
-            worktree_remove: worktree.remove,
+            worktree_remove: worktree.createRemove(ctx.client),
             worktree_open: worktree.open,
-            // Branch tools - git branch operations
-            branch_create: branch.create,
+            worktree_launch: worktree.createLaunch(ctx.client, ctx.$),
+            // Branch tools - git branch operations (factory for toast notifications)
+            branch_create: branch.createCreate(ctx.client),
             branch_status: branch.status,
             branch_switch: branch.switch_,
             // Plan tools - implementation plan persistence
@@ -44,6 +47,8 @@ export const CortexPlugin = async (ctx) => {
             docs_save: docs.save,
             docs_list: docs.list,
             docs_index: docs.index,
+            // Task tools - finalize workflow (commit, push, PR)
+            task_finalize: task.finalize,
         },
         // Agent handover toast notifications
         async event({ event }) {

package/dist/tools/branch.d.ts

@@ -1,4 +1,10 @@
-export declare const create: {
+import type { PluginInput } from "@opencode-ai/plugin";
+type Client = PluginInput["client"];
+/**
+ * Factory function that creates the branch_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export declare function createCreate(client: Client): {
     description: string;
     args: {
         name: import("zod").ZodString;

package/dist/tools/branch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/tools/branch.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;CA8CjB,CAAC;AAEH,eAAO,MAAM,MAAM;;;;CAiGjB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAmClB,CAAC;AAGH,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/tools/branch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAMvD,KAAK,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;EA0E1C;AAED,eAAO,MAAM,MAAM;;;;CAkGjB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;CAmClB,CAAC;AAGH,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC"}

package/dist/tools/branch.js

@@ -1,57 +1,91 @@
 import { tool } from "@opencode-ai/plugin";
+import { git } from "../utils/shell.js";
 const PROTECTED_BRANCHES = ["main", "master", "develop", "production", "staging"];
-export const create = tool({
-    description: "Create and checkout a new git branch with proper naming convention",
-    args: {
-        name: tool.schema
-            .string()
-            .describe("Branch name slug (e.g., 'user-authentication', 'fix-login')"),
-        type: tool.schema
-            .enum(["feature", "bugfix", "hotfix", "refactor", "docs", "test", "chore"])
-            .describe("Branch type - determines prefix"),
-    },
-    async execute(args, context) {
-        const { name, type } = args;
-        const branchName = `${type}/${name}`;
-        // Check if we're in a git repository
-        try {
-            await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
-        }
-        catch {
-            return "✗ Error: Not in a git repository";
-        }
-        // Check if branch already exists
-        try {
-            const branches = await Bun.$ `git branch --list ${branchName}`.cwd(context.worktree).text();
-            if (branches.trim()) {
-                return `✗ Error: Branch '${branchName}' already exists.
+/**
+ * Factory function that creates the branch_create tool with access
+ * to the OpenCode client for toast notifications.
+ */
+export function createCreate(client) {
+    return tool({
+        description: "Create and checkout a new git branch with proper naming convention",
+        args: {
+            name: tool.schema
+                .string()
+                .describe("Branch name slug (e.g., 'user-authentication', 'fix-login')"),
+            type: tool.schema
+                .enum(["feature", "bugfix", "hotfix", "refactor", "docs", "test", "chore"])
+                .describe("Branch type - determines prefix"),
+        },
+        async execute(args, context) {
+            const { name, type } = args;
+            const branchName = `${type}/${name}`;
+            // Check if we're in a git repository
+            try {
+                await git(context.worktree, "rev-parse", "--git-dir");
+            }
+            catch {
+                return "✗ Error: Not in a git repository";
+            }
+            // Check if branch already exists
+            try {
+                const { stdout } = await git(context.worktree, "branch", "--list", branchName);
+                if (stdout.trim()) {
+                    return `✗ Error: Branch '${branchName}' already exists.
 
 Use branch_switch to switch to it, or choose a different name.`;
+                }
             }
-        }
-        catch {
-            // Ignore error, branch check is optional
-        }
-        // Create and checkout the branch
-        try {
-            await Bun.$ `git checkout -b ${branchName}`.cwd(context.worktree);
-        }
-        catch (error) {
-            return `✗ Error creating branch: ${error.message || error}`;
-        }
-        return `✓ Created and switched to branch: ${branchName}
+            catch {
+                // Ignore error, branch check is optional
+            }
+            // Create and checkout the branch
+            try {
+                await git(context.worktree, "checkout", "-b", branchName);
+            }
+            catch (error) {
+                try {
+                    await client.tui.showToast({
+                        body: {
+                            title: `Branch: ${branchName}`,
+                            message: `Failed to create: ${error.message || error}`,
+                            variant: "error",
+                            duration: 8000,
+                        },
+                    });
+                }
+                catch {
+                    // Toast failure is non-fatal
+                }
+                return `✗ Error creating branch: ${error.message || error}`;
+            }
+            // Notify via toast
+            try {
+                await client.tui.showToast({
+                    body: {
+                        title: `Branch: ${branchName}`,
+                        message: `Created and checked out`,
+                        variant: "success",
+                        duration: 4000,
+                    },
+                });
+            }
+            catch {
+                // Toast failure is non-fatal
+            }
+            return `✓ Created and switched to branch: ${branchName}
 
 You are now on branch '${branchName}'.
 Make your changes and commit when ready.`;
-    },
-});
+        },
+    });
+}
 export const status = tool({
     description: "Get current git branch status - branch name, uncommitted changes, and whether on protected branch",
     args: {},
     async execute(args, context) {
         // Check if we're in a git repository
         try {
-            await Bun.$ `git rev-parse --git-dir`.cwd(context.worktree).text();
+            await git(context.worktree, "rev-parse", "--git-dir");
         }
         catch {
             return "✗ Not in a git repository";
@@ -64,7 +98,8 @@ export const status = tool({
         let aheadBehind = "";
         // Get current branch
         try {
-            currentBranch = (await Bun.$ `git branch --show-current`.cwd(context.worktree).text()).trim();
+            const { stdout } = await git(context.worktree, "branch", "--show-current");
+            currentBranch = stdout.trim();
             if (!currentBranch) {
                 currentBranch = "(detached HEAD)";
             }
@@ -76,17 +111,17 @@ export const status = tool({
         isProtected = PROTECTED_BRANCHES.includes(currentBranch);
         // Check for changes
         try {
-            const statusOutput = await Bun.$ `git status --porcelain`.cwd(context.worktree).text();
-            const lines = statusOutput.trim().split("\n").filter((l) => l);
+            const { stdout } = await git(context.worktree, "status", "--porcelain");
+            const lines = stdout.trim().split("\n").filter((l) => l);
             for (const line of lines) {
-                const status = line.substring(0, 2);
-                if (status[0] !== " " && status[0] !== "?") {
+                const st = line.substring(0, 2);
+                if (st[0] !== " " && st[0] !== "?") {
                     stagedChanges = true;
                 }
-                if (status[1] !== " " && status[1] !== "?") {
+                if (st[1] !== " " && st[1] !== "?") {
                     hasChanges = true;
                 }
-                if (status === "??") {
+                if (st === "??") {
                     untrackedFiles = true;
                 }
             }
@@ -96,8 +131,8 @@ export const status = tool({
         }
         // Check ahead/behind
         try {
-            const result = await Bun.$ `git rev-list --left-right --count HEAD...@{upstream}`.cwd(context.worktree).text();
-            const [ahead, behind] = result.trim().split(/\s+/);
+            const { stdout } = await git(context.worktree, "rev-list", "--left-right", "--count", "HEAD...@{upstream}");
+            const [ahead, behind] = stdout.trim().split(/\s+/);
             if (parseInt(ahead) > 0 || parseInt(behind) > 0) {
                 aheadBehind = `Ahead: ${ahead}, Behind: ${behind}`;
             }
@@ -146,10 +181,10 @@ export const switch_ = tool({
         const { branch } = args;
         // Check if branch exists
         try {
-            const branches = await Bun.$ `git branch --list ${branch}`.cwd(context.worktree).text();
-            if (!branches.trim()) {
+            const { stdout } = await git(context.worktree, "branch", "--list", branch);
+            if (!stdout.trim()) {
                 // Try remote branch
-                const remoteBranches = await Bun.$ `git branch -r --list origin/${branch}`.cwd(context.worktree).text();
+                const { stdout: remoteBranches } = await git(context.worktree, "branch", "-r", "--list", `origin/${branch}`);
                 if (!remoteBranches.trim()) {
                     return `✗ Error: Branch '${branch}' not found locally or on origin.
 
@@ -162,7 +197,7 @@ Use branch_create to create a new branch.`;
         }
         // Switch to branch
         try {
-            await Bun.$ `git checkout ${branch}`.cwd(context.worktree);
+            await git(context.worktree, "checkout", branch);
         }
         catch (error) {
             return `✗ Error switching branch: ${error.message || error}