opencode-hive 0.8.0 → 0.8.1

package/dist/services/worktreeService.test.js

@@ -1,185 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { WorktreeService } from "./worktreeService";
-const TEST_ROOT = "/tmp/hive-test-worktree";
-describe("WorktreeService", () => {
-    let service;
-    beforeEach(async () => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-        fs.mkdirSync(TEST_ROOT, { recursive: true });
-        const { execSync } = await import("child_process");
-        execSync("git init", { cwd: TEST_ROOT });
-        execSync("git config user.email 'test@test.com'", { cwd: TEST_ROOT });
-        execSync("git config user.name 'Test'", { cwd: TEST_ROOT });
-        fs.writeFileSync(path.join(TEST_ROOT, "README.md"), "# Test");
-        execSync("git add . && git commit -m 'init'", { cwd: TEST_ROOT });
-        service = new WorktreeService({ baseDir: TEST_ROOT, hiveDir: path.join(TEST_ROOT, ".hive") });
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-    });
-    describe("create", () => {
-        it("creates a worktree", async () => {
-            const result = await service.create("my-feature", "01-setup");
-            expect(result.path).toContain(".hive/.worktrees/my-feature/01-setup");
-            expect(result.branch).toBe("hive/my-feature/01-setup");
-            expect(fs.existsSync(result.path)).toBe(true);
-        });
-        it("worktree contains files from base branch", async () => {
-            const result = await service.create("my-feature", "01-setup");
-            expect(fs.existsSync(path.join(result.path, "README.md"))).toBe(true);
-        });
-    });
-    describe("get", () => {
-        it("returns null for non-existing worktree", async () => {
-            const result = await service.get("nope", "nope");
-            expect(result).toBeNull();
-        });
-        it("returns worktree info after creation", async () => {
-            await service.create("my-feature", "01-task");
-            const result = await service.get("my-feature", "01-task");
-            expect(result).not.toBeNull();
-            expect(result.feature).toBe("my-feature");
-            expect(result.step).toBe("01-task");
-        });
-    });
-    describe("list", () => {
-        it("returns empty array when no worktrees", async () => {
-            const result = await service.list();
-            expect(result).toEqual([]);
-        });
-        it("lists all worktrees", async () => {
-            await service.create("feature-a", "01-task");
-            await service.create("feature-b", "01-task");
-            const result = await service.list();
-            expect(result.length).toBe(2);
-        });
-        it("filters by feature", async () => {
-            await service.create("feature-a", "01-task");
-            await service.create("feature-a", "02-task");
-            await service.create("feature-b", "01-task");
-            const result = await service.list("feature-a");
-            expect(result.length).toBe(2);
-            expect(result.every(w => w.feature === "feature-a")).toBe(true);
-        });
-    });
-    describe("remove", () => {
-        it("removes worktree", async () => {
-            const created = await service.create("my-feature", "01-task");
-            expect(fs.existsSync(created.path)).toBe(true);
-            await service.remove("my-feature", "01-task");
-            expect(fs.existsSync(created.path)).toBe(false);
-        });
-        it("removes branch when deleteBranch is true", async () => {
-            await service.create("my-feature", "01-task");
-            const { execSync } = await import("child_process");
-            await service.remove("my-feature", "01-task", true);
-            const branches = execSync("git branch", { cwd: TEST_ROOT, encoding: "utf-8" });
-            expect(branches).not.toContain("hive/my-feature/01-task");
-        });
-    });
-    describe("getDiff", () => {
-        it("returns empty diff when no changes", async () => {
-            await service.create("my-feature", "01-task");
-            const diff = await service.getDiff("my-feature", "01-task");
-            expect(diff.hasDiff).toBe(false);
-            expect(diff.diffContent).toBe("");
-            expect(diff.filesChanged).toEqual([]);
-        });
-        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");
-            execSync("git add .", { cwd: worktree.path });
-            execSync("git commit -m 'add file'", { cwd: worktree.path });
-            const diff = await service.getDiff("my-feature", "01-task");
-            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 () => {
-            const wt1 = await service.create("cleanup-test", "01-task");
-            const wt2 = await service.create("cleanup-test", "02-task");
-            fs.writeFileSync(path.join(wt1.path, ".git"), "gitdir: /nonexistent\n");
-            fs.writeFileSync(path.join(wt2.path, ".git"), "gitdir: /nonexistent\n");
-            expect(fs.existsSync(wt1.path)).toBe(true);
-            expect(fs.existsSync(wt2.path)).toBe(true);
-            const result = await service.cleanup("cleanup-test");
-            expect(result.removed.length).toBe(2);
-            expect(fs.existsSync(wt1.path)).toBe(false);
-            expect(fs.existsSync(wt2.path)).toBe(false);
-            const remaining = await service.list("cleanup-test");
-            expect(remaining).toEqual([]);
-        });
-    });
-});

package/dist/tools/contextTools.d.ts

@@ -1,93 +0,0 @@
-import { z } from 'zod';
-export declare function createContextTools(projectRoot: string): {
-    hive_context_write: {
-        description: string;
-        parameters: z.ZodObject<{
-            name: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strip>;
-        execute: ({ name, content }: {
-            name: string;
-            content: string;
-        }) => Promise<{
-            error: string;
-            success?: undefined;
-            path?: undefined;
-        } | {
-            success: boolean;
-            path: string;
-            error?: undefined;
-        }>;
-    };
-    hive_context_read: {
-        description: string;
-        parameters: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-        execute: ({ name }: {
-            name?: string;
-        }) => Promise<{
-            error: string;
-            name?: undefined;
-            content?: undefined;
-            message?: undefined;
-            compiled?: undefined;
-        } | {
-            name: string;
-            content: string;
-            error?: undefined;
-            message?: undefined;
-            compiled?: undefined;
-        } | {
-            message: string;
-            error?: undefined;
-            name?: undefined;
-            content?: undefined;
-            compiled?: undefined;
-        } | {
-            compiled: string;
-            error?: undefined;
-            name?: undefined;
-            content?: undefined;
-            message?: undefined;
-        }>;
-    };
-    hive_context_list: {
-        description: string;
-        parameters: z.ZodObject<{}, z.core.$strip>;
-        execute: () => Promise<{
-            error: string;
-            files?: undefined;
-            message?: undefined;
-        } | {
-            files: never[];
-            message: string;
-            error?: undefined;
-        } | {
-            files: {
-                name: string;
-                updatedAt: string;
-                previewLength: number;
-            }[];
-            error?: undefined;
-            message?: undefined;
-        }>;
-    };
-    hive_context_delete: {
-        description: string;
-        parameters: z.ZodObject<{
-            name: z.ZodString;
-        }, z.core.$strip>;
-        execute: ({ name }: {
-            name: string;
-        }) => Promise<{
-            error: string;
-            success?: undefined;
-            deleted?: undefined;
-        } | {
-            success: boolean;
-            deleted: string;
-            error?: undefined;
-        }>;
-    };
-};

package/dist/tools/contextTools.js

@@ -1,83 +0,0 @@
-import { z } from 'zod';
-import { ContextService } from '../services/contextService.js';
-import { FeatureService } from '../services/featureService.js';
-import { detectContext } from '../utils/detection.js';
-export function createContextTools(projectRoot) {
-    const contextService = new ContextService(projectRoot);
-    const featureService = new FeatureService(projectRoot);
-    const getActiveFeature = () => {
-        const ctx = detectContext(projectRoot);
-        return ctx?.feature || null;
-    };
-    return {
-        hive_context_write: {
-            description: 'Write a context file for the active feature. Context files store persistent notes, decisions, and reference material.',
-            parameters: z.object({
-                name: z.string().describe('Context file name (e.g., "architecture", "decisions", "notes")'),
-                content: z.string().describe('Markdown content to write'),
-            }),
-            execute: async ({ name, content }) => {
-                const feature = getActiveFeature();
-                if (!feature)
-                    return { error: 'No active feature' };
-                const filePath = contextService.write(feature, name, content);
-                return { success: true, path: filePath };
-            },
-        },
-        hive_context_read: {
-            description: 'Read a specific context file or all context for the active feature',
-            parameters: z.object({
-                name: z.string().optional().describe('Context file name. If omitted, returns all context compiled.'),
-            }),
-            execute: async ({ name }) => {
-                const feature = getActiveFeature();
-                if (!feature)
-                    return { error: 'No active feature' };
-                if (name) {
-                    const content = contextService.read(feature, name);
-                    if (!content)
-                        return { error: `Context file '${name}' not found` };
-                    return { name, content };
-                }
-                const compiled = contextService.compile(feature);
-                if (!compiled)
-                    return { message: 'No context files found' };
-                return { compiled };
-            },
-        },
-        hive_context_list: {
-            description: 'List all context files for the active feature',
-            parameters: z.object({}),
-            execute: async () => {
-                const feature = getActiveFeature();
-                if (!feature)
-                    return { error: 'No active feature' };
-                const files = contextService.list(feature);
-                if (files.length === 0)
-                    return { files: [], message: 'No context files' };
-                return {
-                    files: files.map(f => ({
-                        name: f.name,
-                        updatedAt: f.updatedAt,
-                        previewLength: f.content.length,
-                    })),
-                };
-            },
-        },
-        hive_context_delete: {
-            description: 'Delete a context file',
-            parameters: z.object({
-                name: z.string().describe('Context file name to delete'),
-            }),
-            execute: async ({ name }) => {
-                const feature = getActiveFeature();
-                if (!feature)
-                    return { error: 'No active feature' };
-                const deleted = contextService.delete(feature, name);
-                if (!deleted)
-                    return { error: `Context file '${name}' not found` };
-                return { success: true, deleted: name };
-            },
-        },
-    };
-}

package/dist/tools/execTools.d.ts

@@ -1,66 +0,0 @@
-import { z } from 'zod';
-export declare function createExecTools(projectRoot: string): {
-    hive_exec_start: {
-        description: string;
-        parameters: z.ZodObject<{
-            task: z.ZodString;
-        }, z.core.$strip>;
-        execute: ({ task }: {
-            task: string;
-        }) => Promise<{
-            error: string;
-            worktreePath?: undefined;
-            branch?: undefined;
-            message?: undefined;
-        } | {
-            worktreePath: string;
-            branch: string;
-            message: string;
-            error?: undefined;
-        }>;
-    };
-    hive_exec_complete: {
-        description: string;
-        parameters: z.ZodObject<{
-            task: z.ZodString;
-            summary: z.ZodString;
-            report: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-        execute: ({ task, summary, report }: {
-            task: string;
-            summary: string;
-            report?: string;
-        }) => Promise<{
-            error: string;
-            completed?: undefined;
-            task?: undefined;
-            summary?: undefined;
-            message?: undefined;
-        } | {
-            completed: boolean;
-            task: string;
-            summary: string;
-            message: string;
-            error?: undefined;
-        }>;
-    };
-    hive_exec_abort: {
-        description: string;
-        parameters: z.ZodObject<{
-            task: z.ZodString;
-        }, z.core.$strip>;
-        execute: ({ task }: {
-            task: string;
-        }) => Promise<{
-            error: string;
-            aborted?: undefined;
-            task?: undefined;
-            message?: undefined;
-        } | {
-            aborted: boolean;
-            task: string;
-            message: string;
-            error?: undefined;
-        }>;
-    };
-};

package/dist/tools/execTools.js

@@ -1,125 +0,0 @@
-import * as path from 'path';
-import { z } from 'zod';
-import { TaskService } from '../services/taskService.js';
-import { FeatureService } from '../services/featureService.js';
-import { WorktreeService } from '../services/worktreeService';
-import { detectContext } from '../utils/detection.js';
-export function createExecTools(projectRoot) {
-    const taskService = new TaskService(projectRoot);
-    const featureService = new FeatureService(projectRoot);
-    const worktreeService = new WorktreeService({
-        baseDir: projectRoot,
-        hiveDir: path.join(projectRoot, '.hive'),
-    });
-    const getActiveFeature = () => {
-        const ctx = detectContext(projectRoot);
-        return ctx?.feature || null;
-    };
-    return {
-        hive_exec_start: {
-            description: 'Create worktree and begin work on task',
-            parameters: z.object({
-                task: z.string().describe('Task folder name (e.g., "01-auth-service")'),
-            }),
-            execute: async ({ task }) => {
-                const feature = getActiveFeature();
-                if (!feature) {
-                    return { error: 'No active feature.' };
-                }
-                const featureData = featureService.get(feature);
-                if (!featureData || featureData.status === 'planning') {
-                    return { error: 'Feature must be approved before starting execution.' };
-                }
-                const taskInfo = taskService.get(feature, task);
-                if (!taskInfo) {
-                    return { error: `Task '${task}' not found` };
-                }
-                if (taskInfo.status === 'done') {
-                    return { error: `Task '${task}' is already completed` };
-                }
-                if (taskInfo.status === 'in_progress') {
-                    const existing = await worktreeService.get(feature, task);
-                    if (existing) {
-                        return {
-                            worktreePath: existing.path,
-                            branch: existing.branch,
-                            message: `Task already in progress. Worktree at ${existing.path}`,
-                        };
-                    }
-                }
-                const worktree = await worktreeService.create(feature, task);
-                taskService.update(feature, task, { status: 'in_progress' });
-                return {
-                    worktreePath: worktree.path,
-                    branch: worktree.branch,
-                    message: `Worktree created at ${worktree.path}. Work on branch ${worktree.branch}.`,
-                };
-            },
-        },
-        hive_exec_complete: {
-            description: 'Complete task: apply changes, write report',
-            parameters: z.object({
-                task: z.string().describe('Task folder name'),
-                summary: z.string().describe('Summary of what was done'),
-                report: z.string().optional().describe('Detailed report (markdown). If not provided, summary is used.'),
-            }),
-            execute: async ({ task, summary, report }) => {
-                const feature = getActiveFeature();
-                if (!feature) {
-                    return { error: 'No active feature.' };
-                }
-                const taskInfo = taskService.get(feature, task);
-                if (!taskInfo) {
-                    return { error: `Task '${task}' not found` };
-                }
-                if (taskInfo.status !== 'in_progress') {
-                    return { error: `Task '${task}' is not in progress (status: ${taskInfo.status})` };
-                }
-                const worktree = await worktreeService.get(feature, task);
-                if (!worktree) {
-                    return { error: `No worktree found for task '${task}'` };
-                }
-                const diff = await worktreeService.getDiff(feature, task);
-                if (diff) {
-                    await worktreeService.applyDiff(feature, task);
-                }
-                const reportContent = report || `# ${task}\n\n## Summary\n\n${summary}\n`;
-                taskService.writeReport(feature, task, reportContent);
-                taskService.update(feature, task, { status: 'done', summary });
-                await worktreeService.remove(feature, task);
-                return {
-                    completed: true,
-                    task,
-                    summary,
-                    message: `Task '${task}' completed. Changes applied to main branch.`,
-                };
-            },
-        },
-        hive_exec_abort: {
-            description: 'Abort task: discard changes, reset status',
-            parameters: z.object({
-                task: z.string().describe('Task folder name'),
-            }),
-            execute: async ({ task }) => {
-                const feature = getActiveFeature();
-                if (!feature) {
-                    return { error: 'No active feature.' };
-                }
-                const taskInfo = taskService.get(feature, task);
-                if (!taskInfo) {
-                    return { error: `Task '${task}' not found` };
-                }
-                if (taskInfo.status !== 'in_progress') {
-                    return { error: `Task '${task}' is not in progress` };
-                }
-                await worktreeService.remove(feature, task);
-                taskService.update(feature, task, { status: 'pending' });
-                return {
-                    aborted: true,
-                    task,
-                    message: `Task '${task}' aborted. Worktree removed, status reset to pending.`,
-                };
-            },
-        },
-    };
-}

package/dist/tools/featureTools.d.ts

@@ -1,60 +0,0 @@
-import { z } from 'zod';
-export declare function createFeatureTools(projectRoot: string): {
-    hive_feature_create: {
-        description: string;
-        parameters: z.ZodObject<{
-            name: z.ZodString;
-            ticket: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-        execute: ({ name, ticket }: {
-            name: string;
-            ticket?: string;
-        }) => Promise<{
-            name: string;
-            status: import("../types.js").FeatureStatusType;
-            path: string;
-            message: string;
-        }>;
-    };
-    hive_feature_list: {
-        description: string;
-        parameters: z.ZodObject<{}, z.core.$strip>;
-        execute: () => Promise<{
-            features: {
-                name: string;
-                status: string;
-                taskCount: number;
-                isActive: boolean;
-            }[];
-            active: string | null;
-        }>;
-    };
-    hive_feature_complete: {
-        description: string;
-        parameters: z.ZodObject<{
-            _placeholder: z.ZodBoolean;
-            name: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-        execute: ({ name }: {
-            name?: string;
-        }) => Promise<{
-            error: string;
-            pendingTasks?: undefined;
-            completed?: undefined;
-            name?: undefined;
-            message?: undefined;
-        } | {
-            error: string;
-            pendingTasks: string[];
-            completed?: undefined;
-            name?: undefined;
-            message?: undefined;
-        } | {
-            completed: boolean;
-            name: string;
-            message: string;
-            error?: undefined;
-            pendingTasks?: undefined;
-        }>;
-    };
-};