opencode-hive 0.5.1 → 0.6.0

package/dist/index.js

@@ -12,7 +12,7 @@ const HIVE_SYSTEM_PROMPT = `
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (16 total)
+### Tools (17 total)
 
 | Domain | Tools |
 |--------|-------|
@@ -20,6 +20,7 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
 | Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
+| Merge | hive_merge, hive_worktree_list |
 | Context | hive_context_write, hive_context_read, hive_context_list |
 | Session | hive_session_open, hive_session_list |
 
@@ -30,7 +31,11 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 3. User adds comments in VSCode → \`hive_plan_read\` to see them
 4. Revise plan → User approves
 5. \`hive_tasks_sync()\` - Generate tasks from plan
-6. \`hive_exec_start(task)\` → work → \`hive_exec_complete(task, summary)\`
+6. \`hive_exec_start(task)\` → work in worktree → \`hive_exec_complete(task, summary)\`
+7. \`hive_merge(task)\` - Merge task branch into main (when ready)
+
+**Important:** \`hive_exec_complete\` commits changes to task branch but does NOT merge.
+Use \`hive_merge\` to explicitly integrate changes. Worktrees persist until manually removed.
 
 ### Plan Format
 
@@ -299,7 +304,7 @@ const plugin = async (ctx) => {
                 },
             }),
             hive_exec_complete: tool({
-                description: 'Complete task: apply changes, write report',
+                description: 'Complete task: commit changes to branch, write report (does NOT merge or cleanup)',
                 args: {
                     task: tool.schema.string().describe('Task folder name'),
                     summary: tool.schema.string().describe('Summary of what was done'),
@@ -314,22 +319,15 @@ const plugin = async (ctx) => {
                         return `Error: Task "${task}" not found`;
                     if (taskInfo.status !== 'in_progress')
                         return "Error: Task not in progress";
+                    const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
                     const diff = await worktreeService.getDiff(feature, task);
-                    let changesApplied = false;
-                    let applyError = "";
-                    if (diff?.hasDiff) {
-                        const result = await worktreeService.applyDiff(feature, task);
-                        changesApplied = result.success;
-                        if (!result.success) {
-                            applyError = result.error || "Unknown apply error";
-                        }
-                    }
                     const reportLines = [
                         `# Task Report: ${task}`,
                         '',
                         `**Feature:** ${feature}`,
                         `**Completed:** ${new Date().toISOString()}`,
-                        `**Status:** ${applyError ? 'completed with errors' : 'success'}`,
+                        `**Status:** success`,
+                        `**Commit:** ${commitResult.sha || 'none'}`,
                         '',
                         '---',
                         '',
@@ -353,11 +351,8 @@ const plugin = async (ctx) => {
                     }
                     taskService.writeReport(feature, task, reportLines.join('\n'));
                     taskService.update(feature, task, { status: 'done', summary });
-                    await worktreeService.remove(feature, task);
-                    if (applyError) {
-                        return `Task "${task}" completed but changes failed to apply: ${applyError}`;
-                    }
-                    return `Task "${task}" completed.${changesApplied ? " Changes applied." : ""}`;
+                    const worktree = await worktreeService.get(feature, task);
+                    return `Task "${task}" completed. Changes committed to branch ${worktree?.branch || 'unknown'}.\nUse hive_merge to integrate changes. Worktree preserved at ${worktree?.path || 'unknown'}.`;
                 },
             }),
             hive_exec_abort: tool({
@@ -375,6 +370,52 @@ const plugin = async (ctx) => {
                     return `Task "${task}" aborted. Status reset to pending.`;
                 },
             }),
+            hive_merge: tool({
+                description: 'Merge completed task branch into current branch (explicit integration)',
+                args: {
+                    task: tool.schema.string().describe('Task folder name to merge'),
+                    strategy: tool.schema.enum(['merge', 'squash', 'rebase']).optional().describe('Merge strategy (default: merge)'),
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ task, strategy = 'merge', feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const taskInfo = taskService.get(feature, task);
+                    if (!taskInfo)
+                        return `Error: Task "${task}" not found`;
+                    if (taskInfo.status !== 'done')
+                        return "Error: Task must be completed before merging. Use hive_exec_complete first.";
+                    const result = await worktreeService.merge(feature, task, strategy);
+                    if (!result.success) {
+                        if (result.conflicts && result.conflicts.length > 0) {
+                            return `Merge failed with conflicts in:\n${result.conflicts.map(f => `- ${f}`).join('\n')}\n\nResolve conflicts manually or try a different strategy.`;
+                        }
+                        return `Merge failed: ${result.error}`;
+                    }
+                    return `Task "${task}" merged successfully using ${strategy} strategy.\nCommit: ${result.sha}\nFiles changed: ${result.filesChanged?.length || 0}`;
+                },
+            }),
+            hive_worktree_list: tool({
+                description: 'List all worktrees for current feature',
+                args: {
+                    feature: tool.schema.string().optional().describe('Feature name (defaults to active)'),
+                },
+                async execute({ feature: explicitFeature }) {
+                    const feature = resolveFeature(explicitFeature);
+                    if (!feature)
+                        return "Error: No feature specified. Create a feature or provide feature param.";
+                    const worktrees = await worktreeService.list(feature);
+                    if (worktrees.length === 0)
+                        return "No worktrees found for this feature.";
+                    const lines = ['| Task | Branch | Has Changes |', '|------|--------|-------------|'];
+                    for (const wt of worktrees) {
+                        const hasChanges = await worktreeService.hasUncommittedChanges(wt.feature, wt.step);
+                        lines.push(`| ${wt.step} | ${wt.branch} | ${hasChanges ? 'Yes' : 'No'} |`);
+                    }
+                    return lines.join('\n');
+                },
+            }),
             // Context Tools
             hive_context_write: tool({
                 description: 'Write a context file for the feature. Context files store persistent notes, decisions, and reference material.',

package/dist/services/worktreeService.d.ts

@@ -17,6 +17,19 @@ export interface ApplyResult {
     error?: string;
     filesAffected: string[];
 }
+export interface CommitResult {
+    committed: boolean;
+    sha: string;
+    message?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    merged: boolean;
+    sha?: string;
+    filesChanged?: string[];
+    conflicts?: string[];
+    error?: string;
+}
 export interface WorktreeConfig {
     baseDir: string;
     hiveDir: string;
@@ -45,5 +58,9 @@ export declare class WorktreeService {
     }>;
     checkConflicts(feature: string, step: string, baseBranch?: string): Promise<string[]>;
     checkConflictsFromSavedDiff(diffPath: string, reverse?: boolean): Promise<string[]>;
+    commitChanges(feature: string, step: string, message?: string): Promise<CommitResult>;
+    merge(feature: string, step: string, strategy?: 'merge' | 'squash' | 'rebase'): Promise<MergeResult>;
+    hasUncommittedChanges(feature: string, step: string): Promise<boolean>;
+    private parseConflictsFromError;
 }
 export declare function createWorktreeService(projectDir: string): WorktreeService;

package/dist/services/worktreeService.js

@@ -97,8 +97,18 @@ export class WorktreeService {
         const worktreeGit = this.getGit(worktreePath);
         try {
             await worktreeGit.raw(["add", "-A"]);
-            const diffContent = await worktreeGit.diff([`${base}...HEAD`]);
-            const stat = await worktreeGit.diff([`${base}...HEAD`, "--stat"]);
+            const status = await worktreeGit.status();
+            const hasStaged = status.staged.length > 0;
+            let diffContent = "";
+            let stat = "";
+            if (hasStaged) {
+                diffContent = await worktreeGit.diff(["--cached"]);
+                stat = diffContent ? await worktreeGit.diff(["--cached", "--stat"]) : "";
+            }
+            else {
+                diffContent = await worktreeGit.diff([`${base}..HEAD`]).catch(() => "");
+                stat = diffContent ? await worktreeGit.diff([`${base}..HEAD`, "--stat"]) : "";
+            }
             const statLines = stat.split("\n").filter((l) => l.trim());
             const filesChanged = statLines
                 .slice(0, -1)
@@ -347,6 +357,138 @@ export class WorktreeService {
             return conflicts;
         }
     }
+    async commitChanges(feature, step, message) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        try {
+            await fs.access(worktreePath);
+        }
+        catch {
+            return { committed: false, sha: "", message: "Worktree not found" };
+        }
+        const worktreeGit = this.getGit(worktreePath);
+        try {
+            await worktreeGit.add("-A");
+            const status = await worktreeGit.status();
+            const hasChanges = status.staged.length > 0 || status.modified.length > 0 || status.not_added.length > 0;
+            if (!hasChanges) {
+                const currentSha = (await worktreeGit.revparse(["HEAD"])).trim();
+                return { committed: false, sha: currentSha, message: "No changes to commit" };
+            }
+            const commitMessage = message || `hive(${step}): task changes`;
+            const result = await worktreeGit.commit(commitMessage, ["--allow-empty-message"]);
+            return {
+                committed: true,
+                sha: result.commit,
+                message: commitMessage,
+            };
+        }
+        catch (error) {
+            const err = error;
+            const currentSha = (await worktreeGit.revparse(["HEAD"]).catch(() => "")).trim();
+            return {
+                committed: false,
+                sha: currentSha,
+                message: err.message || "Commit failed",
+            };
+        }
+    }
+    async merge(feature, step, strategy = 'merge') {
+        const branchName = this.getBranchName(feature, step);
+        const git = this.getGit();
+        try {
+            const branches = await git.branch();
+            if (!branches.all.includes(branchName)) {
+                return { success: false, merged: false, error: `Branch ${branchName} not found` };
+            }
+            const currentBranch = branches.current;
+            const diffStat = await git.diff([`${currentBranch}...${branchName}`, "--stat"]);
+            const filesChanged = diffStat
+                .split("\n")
+                .filter(l => l.trim() && l.includes("|"))
+                .map(l => l.split("|")[0].trim());
+            if (strategy === 'squash') {
+                await git.raw(["merge", "--squash", branchName]);
+                const result = await git.commit(`hive: merge ${step} (squashed)`);
+                return {
+                    success: true,
+                    merged: true,
+                    sha: result.commit,
+                    filesChanged,
+                };
+            }
+            else if (strategy === 'rebase') {
+                const commits = await git.log([`${currentBranch}..${branchName}`]);
+                const commitsToApply = [...commits.all].reverse();
+                for (const commit of commitsToApply) {
+                    await git.raw(["cherry-pick", commit.hash]);
+                }
+                const head = (await git.revparse(["HEAD"])).trim();
+                return {
+                    success: true,
+                    merged: true,
+                    sha: head,
+                    filesChanged,
+                };
+            }
+            else {
+                const result = await git.merge([branchName, "--no-ff", "-m", `hive: merge ${step}`]);
+                const head = (await git.revparse(["HEAD"])).trim();
+                return {
+                    success: true,
+                    merged: !result.failed,
+                    sha: head,
+                    filesChanged,
+                    conflicts: result.conflicts?.map(c => c.file || String(c)) || [],
+                };
+            }
+        }
+        catch (error) {
+            const err = error;
+            if (err.message?.includes("CONFLICT") || err.message?.includes("conflict")) {
+                await git.raw(["merge", "--abort"]).catch(() => { });
+                await git.raw(["rebase", "--abort"]).catch(() => { });
+                await git.raw(["cherry-pick", "--abort"]).catch(() => { });
+                return {
+                    success: false,
+                    merged: false,
+                    error: "Merge conflicts detected",
+                    conflicts: this.parseConflictsFromError(err.message || ""),
+                };
+            }
+            return {
+                success: false,
+                merged: false,
+                error: err.message || "Merge failed",
+            };
+        }
+    }
+    async hasUncommittedChanges(feature, step) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        try {
+            const worktreeGit = this.getGit(worktreePath);
+            const status = await worktreeGit.status();
+            return status.modified.length > 0 ||
+                status.not_added.length > 0 ||
+                status.staged.length > 0 ||
+                status.deleted.length > 0 ||
+                status.created.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    parseConflictsFromError(errorMessage) {
+        const conflicts = [];
+        const lines = errorMessage.split("\n");
+        for (const line of lines) {
+            if (line.includes("CONFLICT") && line.includes("Merge conflict in")) {
+                const match = line.match(/Merge conflict in (.+)/);
+                if (match)
+                    conflicts.push(match[1]);
+            }
+        }
+        return conflicts;
+    }
 }
 export function createWorktreeService(projectDir) {
     return new WorktreeService({

package/dist/services/worktreeService.test.js

@@ -87,7 +87,7 @@ describe("WorktreeService", () => {
             expect(diff.diffContent).toBe("");
             expect(diff.filesChanged).toEqual([]);
         });
-        it("returns diff when files changed", async () => {
+        it("returns diff when files changed and committed", async () => {
             const worktree = await service.create("my-feature", "01-task");
             fs.writeFileSync(path.join(worktree.path, "new-file.txt"), "content");
             const { execSync } = await import("child_process");
@@ -97,6 +97,74 @@ describe("WorktreeService", () => {
             expect(diff.hasDiff).toBe(true);
             expect(diff.filesChanged).toContain("new-file.txt");
         });
+        it("returns diff for uncommitted staged changes", async () => {
+            const worktree = await service.create("my-feature", "01-task");
+            fs.writeFileSync(path.join(worktree.path, "uncommitted.txt"), "staged content");
+            const diff = await service.getDiff("my-feature", "01-task");
+            expect(diff.hasDiff).toBe(true);
+            expect(diff.filesChanged).toContain("uncommitted.txt");
+        });
+    });
+    describe("commitChanges", () => {
+        it("commits all staged changes", async () => {
+            const worktree = await service.create("my-feature", "01-task");
+            fs.writeFileSync(path.join(worktree.path, "file.txt"), "content");
+            const result = await service.commitChanges("my-feature", "01-task", "test commit");
+            expect(result.committed).toBe(true);
+            expect(result.sha).toBeTruthy();
+        });
+        it("returns committed=false when no changes", async () => {
+            await service.create("my-feature", "01-task");
+            const result = await service.commitChanges("my-feature", "01-task");
+            expect(result.committed).toBe(false);
+            expect(result.message).toBe("No changes to commit");
+        });
+        it("returns error when worktree not found", async () => {
+            const result = await service.commitChanges("nope", "nope");
+            expect(result.committed).toBe(false);
+            expect(result.message).toBe("Worktree not found");
+        });
+    });
+    describe("hasUncommittedChanges", () => {
+        it("returns false when no changes", async () => {
+            await service.create("my-feature", "01-task");
+            const result = await service.hasUncommittedChanges("my-feature", "01-task");
+            expect(result).toBe(false);
+        });
+        it("returns true when files modified", async () => {
+            const worktree = await service.create("my-feature", "01-task");
+            fs.writeFileSync(path.join(worktree.path, "new.txt"), "content");
+            const result = await service.hasUncommittedChanges("my-feature", "01-task");
+            expect(result).toBe(true);
+        });
+    });
+    describe("merge", () => {
+        it("merges task branch into main", async () => {
+            const worktree = await service.create("my-feature", "01-task");
+            fs.writeFileSync(path.join(worktree.path, "feature.txt"), "feature content");
+            const { execSync } = await import("child_process");
+            execSync("git add . && git commit -m 'feature'", { cwd: worktree.path });
+            const result = await service.merge("my-feature", "01-task");
+            expect(result.success).toBe(true);
+            expect(result.merged).toBe(true);
+            expect(fs.existsSync(path.join(TEST_ROOT, "feature.txt"))).toBe(true);
+        });
+        it("returns error for non-existent branch", async () => {
+            const result = await service.merge("nope", "nope");
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("not found");
+        });
+        it("supports squash strategy", async () => {
+            const worktree = await service.create("my-feature", "01-task");
+            fs.writeFileSync(path.join(worktree.path, "file1.txt"), "1");
+            const { execSync } = await import("child_process");
+            execSync("git add . && git commit -m 'commit 1'", { cwd: worktree.path });
+            fs.writeFileSync(path.join(worktree.path, "file2.txt"), "2");
+            execSync("git add . && git commit -m 'commit 2'", { cwd: worktree.path });
+            const result = await service.merge("my-feature", "01-task", "squash");
+            expect(result.success).toBe(true);
+            expect(result.merged).toBe(true);
+        });
     });
     describe("cleanup", () => {
         it("removes invalid worktrees for a feature", async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",