opencode-hive 0.4.2 → 0.5.0

package/dist/services/taskService.test.js

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs";
+import { TaskService } from "./taskService";
+import { FeatureService } from "./featureService";
+import { PlanService } from "./planService";
+import { getTaskPath, getTaskStatusPath, getTaskReportPath } from "../utils/paths";
+const TEST_ROOT = "/tmp/hive-test-task";
+describe("TaskService", () => {
+    let taskService;
+    let featureService;
+    let planService;
+    beforeEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+        fs.mkdirSync(TEST_ROOT, { recursive: true });
+        featureService = new FeatureService(TEST_ROOT);
+        planService = new PlanService(TEST_ROOT);
+        taskService = new TaskService(TEST_ROOT);
+        featureService.create("test-feature");
+    });
+    afterEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    });
+    describe("sync", () => {
+        it("throws when no plan exists", () => {
+            featureService.create("no-plan");
+            expect(() => taskService.sync("no-plan")).toThrow();
+        });
+        it("creates tasks from plan", () => {
+            planService.write("test-feature", `# Plan
+
+## Tasks
+
+### 1. Setup Database
+Description
+
+### 2. Create API
+Description
+`);
+            const result = taskService.sync("test-feature");
+            expect(result.created).toContain("01-setup-database");
+            expect(result.created).toContain("02-create-api");
+            expect(result.created.length).toBe(2);
+        });
+        it("keeps done tasks even if removed from plan", () => {
+            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. First Task\nDesc`);
+            taskService.sync("test-feature");
+            taskService.update("test-feature", "01-first-task", { status: "done" });
+            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Different Task\nDesc`);
+            const result = taskService.sync("test-feature");
+            expect(result.kept).toContain("01-first-task");
+        });
+        it("removes cancelled tasks", () => {
+            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Task One\nDesc`);
+            taskService.sync("test-feature");
+            taskService.update("test-feature", "01-task-one", { status: "cancelled" });
+            const result = taskService.sync("test-feature");
+            expect(result.removed).toContain("01-task-one");
+        });
+        it("preserves manual tasks", () => {
+            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Plan Task\nDesc`);
+            taskService.sync("test-feature");
+            taskService.create("test-feature", "manual-task");
+            const result = taskService.sync("test-feature");
+            expect(result.manual).toContain("02-manual-task");
+        });
+    });
+    describe("create", () => {
+        it("creates a manual task", () => {
+            const folder = taskService.create("test-feature", "my-task");
+            expect(folder).toBe("01-my-task");
+            expect(fs.existsSync(getTaskPath(TEST_ROOT, "test-feature", folder))).toBe(true);
+        });
+        it("auto-increments order", () => {
+            taskService.create("test-feature", "first");
+            taskService.create("test-feature", "second");
+            const third = taskService.create("test-feature", "third");
+            expect(third).toBe("03-third");
+        });
+        it("respects explicit order", () => {
+            const folder = taskService.create("test-feature", "specific", 10);
+            expect(folder).toBe("10-specific");
+        });
+        it("creates task with pending status and manual origin", () => {
+            const folder = taskService.create("test-feature", "test");
+            const task = taskService.get("test-feature", folder);
+            expect(task?.status).toBe("pending");
+            expect(task?.origin).toBe("manual");
+        });
+    });
+    describe("update", () => {
+        it("updates task status", () => {
+            const folder = taskService.create("test-feature", "task");
+            taskService.update("test-feature", folder, { status: "in_progress" });
+            const task = taskService.get("test-feature", folder);
+            expect(task?.status).toBe("in_progress");
+        });
+        it("sets startedAt when status becomes in_progress", () => {
+            const folder = taskService.create("test-feature", "task");
+            taskService.update("test-feature", folder, { status: "in_progress" });
+            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
+            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+            expect(status.startedAt).toBeDefined();
+        });
+        it("sets completedAt when status becomes done", () => {
+            const folder = taskService.create("test-feature", "task");
+            taskService.update("test-feature", folder, { status: "done" });
+            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
+            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+            expect(status.completedAt).toBeDefined();
+        });
+        it("updates summary", () => {
+            const folder = taskService.create("test-feature", "task");
+            taskService.update("test-feature", folder, { summary: "Completed setup" });
+            const task = taskService.get("test-feature", folder);
+            expect(task?.summary).toBe("Completed setup");
+        });
+        it("throws for non-existing task", () => {
+            expect(() => taskService.update("test-feature", "nope", { status: "done" })).toThrow();
+        });
+    });
+    describe("get", () => {
+        it("returns task info", () => {
+            const folder = taskService.create("test-feature", "my-task");
+            const task = taskService.get("test-feature", folder);
+            expect(task).not.toBeNull();
+            expect(task.folder).toBe("01-my-task");
+            expect(task.name).toBe("my-task");
+            expect(task.status).toBe("pending");
+            expect(task.origin).toBe("manual");
+        });
+        it("returns null for non-existing task", () => {
+            expect(taskService.get("test-feature", "nope")).toBeNull();
+        });
+    });
+    describe("list", () => {
+        it("returns empty array when no tasks", () => {
+            expect(taskService.list("test-feature")).toEqual([]);
+        });
+        it("returns all tasks sorted", () => {
+            taskService.create("test-feature", "third", 3);
+            taskService.create("test-feature", "first", 1);
+            taskService.create("test-feature", "second", 2);
+            const tasks = taskService.list("test-feature");
+            expect(tasks.length).toBe(3);
+            expect(tasks[0].folder).toBe("01-first");
+            expect(tasks[1].folder).toBe("02-second");
+            expect(tasks[2].folder).toBe("03-third");
+        });
+    });
+    describe("writeReport", () => {
+        it("writes report file", () => {
+            const folder = taskService.create("test-feature", "task");
+            const report = "## Summary\n\nCompleted the task successfully.";
+            taskService.writeReport("test-feature", folder, report);
+            const reportPath = getTaskReportPath(TEST_ROOT, "test-feature", folder);
+            expect(fs.readFileSync(reportPath, "utf-8")).toBe(report);
+        });
+    });
+});

package/dist/services/worktreeService.js

@@ -87,7 +87,7 @@ export class WorktreeService {
         if (!base) {
             try {
                 const status = JSON.parse(await fs.readFile(statusPath, "utf-8"));
-                base = status.execution?.baseCommit;
+                base = status.baseCommit; // Read baseCommit directly from task status
             }
             catch { }
         }
@@ -139,12 +139,16 @@ export class WorktreeService {
         if (!hasDiff) {
             return { success: true, filesAffected: [] };
         }
+        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
         try {
+            await fs.writeFile(patchPath, diffContent);
             const git = this.getGit();
-            await git.applyPatch(diffContent);
+            await git.applyPatch(patchPath);
+            await fs.unlink(patchPath).catch(() => { });
             return { success: true, filesAffected: filesChanged };
         }
         catch (error) {
+            await fs.unlink(patchPath).catch(() => { });
             const err = error;
             return {
                 success: false,
@@ -158,12 +162,16 @@ export class WorktreeService {
         if (!hasDiff) {
             return { success: true, filesAffected: [] };
         }
+        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
         try {
+            await fs.writeFile(patchPath, diffContent);
             const git = this.getGit();
-            await git.applyPatch(diffContent, ["-R"]);
+            await git.applyPatch(patchPath, ["-R"]);
+            await fs.unlink(patchPath).catch(() => { });
             return { success: true, filesAffected: filesChanged };
         }
         catch (error) {
+            await fs.unlink(patchPath).catch(() => { });
             const err = error;
             return {
                 success: false,
@@ -259,16 +267,27 @@ export class WorktreeService {
         catch {
             /* intentional */
         }
-        const worktrees = await this.list(feature);
-        for (const wt of worktrees) {
-            try {
-                await fs.access(wt.path);
-                const worktreeGit = this.getGit(wt.path);
-                await worktreeGit.revparse(["HEAD"]);
-            }
-            catch {
-                await this.remove(wt.feature, wt.step, false);
-                removed.push(wt.path);
+        const worktreesDir = this.getWorktreesDir();
+        const features = feature ? [feature] : await fs.readdir(worktreesDir).catch(() => []);
+        for (const feat of features) {
+            const featurePath = path.join(worktreesDir, feat);
+            const stat = await fs.stat(featurePath).catch(() => null);
+            if (!stat?.isDirectory())
+                continue;
+            const steps = await fs.readdir(featurePath).catch(() => []);
+            for (const step of steps) {
+                const worktreePath = path.join(featurePath, step);
+                const stepStat = await fs.stat(worktreePath).catch(() => null);
+                if (!stepStat?.isDirectory())
+                    continue;
+                try {
+                    const worktreeGit = this.getGit(worktreePath);
+                    await worktreeGit.revparse(["HEAD"]);
+                }
+                catch {
+                    await this.remove(feat, step, false);
+                    removed.push(worktreePath);
+                }
             }
         }
         return { removed, pruned: true };
@@ -278,12 +297,16 @@ export class WorktreeService {
         if (!hasDiff) {
             return [];
         }
+        const patchPath = path.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
         try {
+            await fs.writeFile(patchPath, diffContent);
             const git = this.getGit();
-            await git.applyPatch(diffContent, ["--check"]);
+            await git.applyPatch(patchPath, ["--check"]);
+            await fs.unlink(patchPath).catch(() => { });
             return [];
         }
         catch (error) {
+            await fs.unlink(patchPath).catch(() => { });
             const err = error;
             const stderr = err.message || "";
             const conflicts = stderr
@@ -298,14 +321,16 @@ export class WorktreeService {
         }
     }
     async checkConflictsFromSavedDiff(diffPath, reverse = false) {
-        const diffContent = await fs.readFile(diffPath, "utf-8");
-        if (!diffContent.trim()) {
+        try {
+            await fs.access(diffPath);
+        }
+        catch {
             return [];
         }
         try {
             const git = this.getGit();
             const options = reverse ? ["--check", "-R"] : ["--check"];
-            await git.applyPatch(diffContent, options);
+            await git.applyPatch(diffPath, options);
             return [];
         }
         catch (error) {

package/dist/services/worktreeService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/worktreeService.test.js

@@ -0,0 +1,117 @@
+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", 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");
+        });
+    });
+    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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -4,11 +4,9 @@ export declare function createExecTools(projectRoot: string): {
         description: string;
         parameters: z.ZodObject<{
             task: z.ZodString;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ task, featureName }: {
+        execute: ({ task }: {
             task: string;
-            featureName?: string;
         }) => Promise<{
             error: string;
             worktreePath?: undefined;
@@ -27,13 +25,11 @@ export declare function createExecTools(projectRoot: string): {
             task: z.ZodString;
             summary: z.ZodString;
             report: z.ZodOptional<z.ZodString>;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ task, summary, report, featureName }: {
+        execute: ({ task, summary, report }: {
             task: string;
             summary: string;
             report?: string;
-            featureName?: string;
         }) => Promise<{
             error: string;
             completed?: undefined;
@@ -52,11 +48,9 @@ export declare function createExecTools(projectRoot: string): {
         description: string;
         parameters: z.ZodObject<{
             task: z.ZodString;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ task, featureName }: {
+        execute: ({ task }: {
             task: string;
-            featureName?: string;
         }) => Promise<{
             error: string;
             aborted?: undefined;