opencode-hive 0.2.0

package/dist/tools/execTools.js

@@ -0,0 +1,123 @@
+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';
+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'),
+    });
+    return {
+        hive_exec_start: {
+            description: 'Create a git worktree and begin work on a task. Sets task status to in_progress.',
+            parameters: z.object({
+                task: z.string().describe('Task folder name (e.g., "01-auth-service")'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ task, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                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 a task: commit changes, apply to main branch, write report, cleanup worktree.',
+            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.'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ task, summary, report, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                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 work on a task: discard changes, cleanup worktree, reset status to pending.',
+            parameters: z.object({
+                task: z.string().describe('Task folder name'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ task, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                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

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { TaskInfo } from '../types.js';
+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_switch: {
+        description: string;
+        parameters: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>;
+        execute: ({ name }: {
+            name: string;
+        }) => Promise<{
+            switched: boolean;
+            name: string;
+            status: import("../types.js").FeatureStatusType | undefined;
+            message: string;
+        }>;
+    };
+    hive_feature_complete: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: 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;
+        }>;
+    };
+    hive_status: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            feature?: undefined;
+            status?: undefined;
+            hasPlan?: undefined;
+            commentCount?: undefined;
+            tasks?: undefined;
+            taskSummary?: undefined;
+        } | {
+            feature: string;
+            status: import("../types.js").FeatureStatusType;
+            hasPlan: boolean;
+            commentCount: number;
+            tasks: TaskInfo[];
+            taskSummary: {
+                pending: number;
+                in_progress: number;
+                done: number;
+                cancelled: number;
+            };
+            error?: undefined;
+        }>;
+    };
+};

package/dist/tools/featureTools.js

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { FeatureService } from '../services/featureService.js';
+export function createFeatureTools(projectRoot) {
+    const featureService = new FeatureService(projectRoot);
+    return {
+        hive_feature_create: {
+            description: 'Create a new feature and set it as active.',
+            parameters: z.object({
+                name: z.string().describe('Feature name (will be used as folder name)'),
+                ticket: z.string().optional().describe('Ticket/issue reference'),
+            }),
+            execute: async ({ name, ticket }) => {
+                const feature = featureService.create(name, ticket);
+                return {
+                    name: feature.name,
+                    status: feature.status,
+                    path: `.hive/features/${name}`,
+                    message: `Feature '${name}' created and set as active. Write a plan with hive_plan_write.`,
+                };
+            },
+        },
+        hive_feature_list: {
+            description: 'List all features.',
+            parameters: z.object({}),
+            execute: async () => {
+                const features = featureService.list();
+                const active = featureService.getActive();
+                const details = features.map(name => {
+                    const info = featureService.getInfo(name);
+                    return {
+                        name,
+                        status: info?.status || 'unknown',
+                        taskCount: info?.tasks.length || 0,
+                        isActive: name === active,
+                    };
+                });
+                return { features: details, active };
+            },
+        },
+        hive_feature_switch: {
+            description: 'Switch to a different feature.',
+            parameters: z.object({
+                name: z.string().describe('Feature name to switch to'),
+            }),
+            execute: async ({ name }) => {
+                featureService.setActive(name);
+                const info = featureService.getInfo(name);
+                return {
+                    switched: true,
+                    name,
+                    status: info?.status,
+                    message: `Switched to feature '${name}'`,
+                };
+            },
+        },
+        hive_feature_complete: {
+            description: 'Mark a feature as completed. This is irreversible.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const info = featureService.getInfo(feature);
+                const pendingTasks = info?.tasks.filter((t) => t.status === 'pending' || t.status === 'in_progress') || [];
+                if (pendingTasks.length > 0) {
+                    return {
+                        error: `Cannot complete: ${pendingTasks.length} task(s) still pending or in progress`,
+                        pendingTasks: pendingTasks.map((t) => t.folder),
+                    };
+                }
+                featureService.complete(feature);
+                return {
+                    completed: true,
+                    name: feature,
+                    message: `Feature '${feature}' marked as completed.`,
+                };
+            },
+        },
+        hive_status: {
+            description: 'Get overview of the active feature: status, plan, tasks.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature. Create one with hive_feature_create.' };
+                }
+                const info = featureService.getInfo(feature);
+                if (!info) {
+                    return { error: `Feature '${feature}' not found` };
+                }
+                const tasksByStatus = {
+                    pending: info.tasks.filter((t) => t.status === 'pending').length,
+                    in_progress: info.tasks.filter((t) => t.status === 'in_progress').length,
+                    done: info.tasks.filter((t) => t.status === 'done').length,
+                    cancelled: info.tasks.filter((t) => t.status === 'cancelled').length,
+                };
+                return {
+                    feature: info.name,
+                    status: info.status,
+                    hasPlan: info.hasPlan,
+                    commentCount: info.commentCount,
+                    tasks: info.tasks,
+                    taskSummary: tasksByStatus,
+                };
+            },
+        },
+    };
+}

package/dist/tools/planTools.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+export declare function createPlanTools(projectRoot: string): {
+    hive_plan_write: {
+        description: string;
+        parameters: z.ZodObject<{
+            content: z.ZodString;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ content, featureName }: {
+            content: string;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            path?: undefined;
+            message?: undefined;
+        } | {
+            path: string;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+    hive_plan_read: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: string;
+        }) => Promise<import("../types.js").PlanReadResult | {
+            error: string;
+        }>;
+    };
+    hive_plan_approve: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            comments?: undefined;
+            approved?: undefined;
+            message?: undefined;
+        } | {
+            error: string;
+            comments: import("../types.js").PlanComment[];
+            approved?: undefined;
+            message?: undefined;
+        } | {
+            approved: boolean;
+            message: string;
+            error?: undefined;
+            comments?: undefined;
+        }>;
+    };
+};

package/dist/tools/planTools.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { PlanService } from '../services/planService.js';
+import { FeatureService } from '../services/featureService.js';
+export function createPlanTools(projectRoot) {
+    const planService = new PlanService(projectRoot);
+    const featureService = new FeatureService(projectRoot);
+    return {
+        hive_plan_write: {
+            description: 'Create or update the plan.md for the active feature. Clears any existing comments (new plan = fresh review).',
+            parameters: z.object({
+                content: z.string().describe('The markdown content for the plan'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ content, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature. Create one with hive_feature_create first.' };
+                }
+                const path = planService.write(feature, content);
+                return { path, message: `Plan written to ${path}. Comments cleared for fresh review.` };
+            },
+        },
+        hive_plan_read: {
+            description: 'Read the plan.md and any user comments for the active feature.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const result = planService.read(feature);
+                if (!result) {
+                    return { error: `No plan.md found for feature '${feature}'` };
+                }
+                return result;
+            },
+        },
+        hive_plan_approve: {
+            description: 'Approve the plan for execution. After approval, run hive_tasks_sync to generate tasks.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const comments = planService.getComments(feature);
+                if (comments.length > 0) {
+                    return {
+                        error: `Cannot approve: ${comments.length} unresolved comment(s). Address comments and rewrite plan first.`,
+                        comments,
+                    };
+                }
+                planService.approve(feature);
+                return {
+                    approved: true,
+                    message: 'Plan approved. Run hive_tasks_sync to generate tasks from the plan.',
+                };
+            },
+        },
+    };
+}

package/dist/tools/taskTools.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare function createTaskTools(projectRoot: string): {
+    hive_tasks_sync: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+        } | {
+            message: string;
+            created: string[];
+            removed: string[];
+            kept: string[];
+            manual: string[];
+            error?: undefined;
+        }>;
+    };
+    hive_task_create: {
+        description: string;
+        parameters: z.ZodObject<{
+            name: z.ZodString;
+            order: z.ZodOptional<z.ZodNumber>;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ name, order, featureName }: {
+            name: string;
+            order?: number;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            folder?: undefined;
+            origin?: undefined;
+            message?: undefined;
+        } | {
+            folder: string;
+            origin: string;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+    hive_task_update: {
+        description: string;
+        parameters: z.ZodObject<{
+            task: z.ZodString;
+            status: z.ZodOptional<z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                done: "done";
+                cancelled: "cancelled";
+            }>>;
+            summary: z.ZodOptional<z.ZodString>;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ task, status, summary, featureName }: {
+            task: string;
+            status?: "pending" | "in_progress" | "done" | "cancelled";
+            summary?: string;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            updated?: undefined;
+            task?: undefined;
+            status?: undefined;
+            summary?: undefined;
+        } | {
+            updated: boolean;
+            task: string;
+            status: import("../types.js").TaskStatusType;
+            summary: string | undefined;
+            error?: undefined;
+        }>;
+    };
+    hive_task_list: {
+        description: string;
+        parameters: z.ZodObject<{
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ featureName }: {
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            tasks?: undefined;
+        } | {
+            tasks: import("../types.js").TaskInfo[];
+            error?: undefined;
+        }>;
+    };
+};

package/dist/tools/taskTools.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { TaskService } from '../services/taskService.js';
+import { FeatureService } from '../services/featureService.js';
+export function createTaskTools(projectRoot) {
+    const taskService = new TaskService(projectRoot);
+    const featureService = new FeatureService(projectRoot);
+    return {
+        hive_tasks_sync: {
+            description: 'Parse the approved plan.md and sync task folders. Creates new tasks, removes obsolete pending tasks, keeps completed/in-progress tasks.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const featureData = featureService.get(feature);
+                if (!featureData) {
+                    return { error: `Feature '${feature}' not found` };
+                }
+                if (featureData.status === 'planning') {
+                    return { error: 'Plan must be approved before syncing tasks. Run hive_plan_approve first.' };
+                }
+                const result = taskService.sync(feature);
+                if (featureData.status === 'approved') {
+                    featureService.updateStatus(feature, 'executing');
+                }
+                return {
+                    ...result,
+                    message: `Synced tasks: ${result.created.length} created, ${result.removed.length} removed, ${result.kept.length} kept, ${result.manual.length} manual`,
+                };
+            },
+        },
+        hive_task_create: {
+            description: 'Create a manual task (not from plan). Use for hotfixes or ad-hoc work during execution.',
+            parameters: z.object({
+                name: z.string().describe('Task name (will be slugified)'),
+                order: z.number().optional().describe('Task order number (defaults to next available)'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ name, order, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const folder = taskService.create(feature, name, order);
+                return {
+                    folder,
+                    origin: 'manual',
+                    message: `Created manual task '${folder}'. This task will not be affected by hive_tasks_sync.`,
+                };
+            },
+        },
+        hive_task_update: {
+            description: 'Update a task status or summary.',
+            parameters: z.object({
+                task: z.string().describe('Task folder name (e.g., "01-auth-service")'),
+                status: z.enum(['pending', 'in_progress', 'done', 'cancelled']).optional(),
+                summary: z.string().optional().describe('Summary of work done'),
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ task, status, summary, featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const updated = taskService.update(feature, task, { status, summary });
+                return { updated: true, task, status: updated.status, summary: updated.summary };
+            },
+        },
+        hive_task_list: {
+            description: 'List all tasks for the active feature.',
+            parameters: z.object({
+                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+            }),
+            execute: async ({ featureName }) => {
+                const feature = featureName || featureService.getActive();
+                if (!feature) {
+                    return { error: 'No active feature.' };
+                }
+                const tasks = taskService.list(feature);
+                return { tasks };
+            },
+        },
+    };
+}