opencode-hive 0.4.2 → 0.5.0

package/dist/tools/execTools.js

@@ -3,6 +3,7 @@ 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);
@@ -10,15 +11,18 @@ export function createExecTools(projectRoot) {
         baseDir: projectRoot,
         hiveDir: path.join(projectRoot, '.hive'),
     });
+    const getActiveFeature = () => {
+        const ctx = detectContext(projectRoot);
+        return ctx?.feature || null;
+    };
     return {
         hive_exec_start: {
-            description: 'Create a git worktree and begin work on a task. Sets task status to in_progress.',
+            description: 'Create worktree and begin work on task',
             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();
+            execute: async ({ task }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -53,15 +57,14 @@ export function createExecTools(projectRoot) {
             },
         },
         hive_exec_complete: {
-            description: 'Complete a task: commit changes, apply to main branch, write report, cleanup worktree.',
+            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.'),
-                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
             }),
-            execute: async ({ task, summary, report, featureName }) => {
-                const feature = featureName || featureService.getActive();
+            execute: async ({ task, summary, report }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -93,13 +96,12 @@ export function createExecTools(projectRoot) {
             },
         },
         hive_exec_abort: {
-            description: 'Abort work on a task: discard changes, cleanup worktree, reset status to pending.',
+            description: 'Abort task: discard changes, reset status',
             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();
+            execute: async ({ task }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }

package/dist/tools/featureTools.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import type { TaskInfo } from '../types.js';
 export declare function createFeatureTools(projectRoot: string): {
     hive_feature_create: {
         description: string;
@@ -30,27 +29,14 @@ export declare function createFeatureTools(projectRoot: string): {
             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>;
+            _placeholder: z.ZodBoolean;
+            name: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ featureName }: {
-            featureName?: string;
+        execute: ({ name }: {
+            name?: string;
         }) => Promise<{
             error: string;
             pendingTasks?: undefined;
@@ -71,34 +57,4 @@ export declare function createFeatureTools(projectRoot: string): {
             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

@@ -1,7 +1,12 @@
 import { z } from 'zod';
 import { FeatureService } from '../services/featureService.js';
+import { detectContext } from '../utils/detection.js';
 export function createFeatureTools(projectRoot) {
     const featureService = new FeatureService(projectRoot);
+    const getActiveFeature = () => {
+        const ctx = detectContext(projectRoot);
+        return ctx?.feature || null;
+    };
     return {
         hive_feature_create: {
             description: 'Create a new feature and set it as active.',
@@ -24,7 +29,7 @@ export function createFeatureTools(projectRoot) {
             parameters: z.object({}),
             execute: async () => {
                 const features = featureService.list();
-                const active = featureService.getActive();
+                const active = getActiveFeature();
                 const details = features.map(name => {
                     const info = featureService.getInfo(name);
                     return {
@@ -37,29 +42,14 @@ export function createFeatureTools(projectRoot) {
                 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.',
+            description: 'Mark feature as completed (irreversible)',
             parameters: z.object({
-                featureName: z.string().optional().describe('Feature name (defaults to active feature)'),
+                _placeholder: z.boolean().describe('Placeholder. Always pass true.'),
+                name: z.string().optional(),
             }),
-            execute: async ({ featureName }) => {
-                const feature = featureName || featureService.getActive();
+            execute: async ({ name }) => {
+                const feature = name || getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -79,35 +69,5 @@ export function createFeatureTools(projectRoot) {
                 };
             },
         },
-        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

@@ -4,11 +4,9 @@ export declare function createPlanTools(projectRoot: string): {
         description: string;
         parameters: z.ZodObject<{
             content: z.ZodString;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ content, featureName }: {
+        execute: ({ content }: {
             content: string;
-            featureName?: string;
         }) => Promise<{
             error: string;
             path?: undefined;
@@ -21,23 +19,15 @@ export declare function createPlanTools(projectRoot: string): {
     };
     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 | {
+        parameters: z.ZodObject<{}, z.core.$strip>;
+        execute: () => 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<{
+        parameters: z.ZodObject<{}, z.core.$strip>;
+        execute: () => Promise<{
             error: string;
             comments?: undefined;
             approved?: undefined;

package/dist/tools/planTools.js

@@ -1,18 +1,22 @@
 import { z } from 'zod';
 import { PlanService } from '../services/planService.js';
 import { FeatureService } from '../services/featureService.js';
+import { detectContext } from '../utils/detection.js';
 export function createPlanTools(projectRoot) {
     const planService = new PlanService(projectRoot);
     const featureService = new FeatureService(projectRoot);
+    const getActiveFeature = () => {
+        const ctx = detectContext(projectRoot);
+        return ctx?.feature || null;
+    };
     return {
         hive_plan_write: {
-            description: 'Create or update the plan.md for the active feature. Clears any existing comments (new plan = fresh review).',
+            description: 'Write plan.md (clears existing comments)',
             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();
+            execute: async ({ content }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature. Create one with hive_feature_create first.' };
                 }
@@ -21,12 +25,10 @@ export function createPlanTools(projectRoot) {
             },
         },
         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();
+            description: 'Read plan.md and user comments',
+            parameters: z.object({}),
+            execute: async () => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -38,12 +40,10 @@ export function createPlanTools(projectRoot) {
             },
         },
         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();
+            description: 'Approve plan for execution',
+            parameters: z.object({}),
+            execute: async () => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }

package/dist/tools/sessionTools.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare function createSessionTools(projectRoot: string): {
+    hive_session_open: {
+        description: string;
+        parameters: z.ZodObject<{
+            feature: z.ZodOptional<z.ZodString>;
+            task: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ feature, task }: {
+            feature?: string;
+            task?: string;
+        }, toolContext: unknown) => Promise<Record<string, unknown>>;
+    };
+    hive_session_list: {
+        description: string;
+        parameters: z.ZodObject<{}, z.core.$strip>;
+        execute: () => Promise<{
+            error: string;
+            feature?: undefined;
+            master?: undefined;
+            sessions?: undefined;
+        } | {
+            feature: string;
+            master: string | undefined;
+            sessions: {
+                sessionId: string;
+                taskFolder: string | undefined;
+                startedAt: string;
+                lastActiveAt: string;
+                isMaster: boolean;
+            }[];
+            error?: undefined;
+        }>;
+    };
+};

package/dist/tools/sessionTools.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { SessionService } from '../services/sessionService.js';
+import { FeatureService } from '../services/featureService.js';
+import { TaskService } from '../services/taskService.js';
+import { PlanService } from '../services/planService.js';
+import { ContextService } from '../services/contextService.js';
+import { detectContext } from '../utils/detection.js';
+export function createSessionTools(projectRoot) {
+    const sessionService = new SessionService(projectRoot);
+    const featureService = new FeatureService(projectRoot);
+    const taskService = new TaskService(projectRoot);
+    const planService = new PlanService(projectRoot);
+    const contextService = new ContextService(projectRoot);
+    const getActiveFeature = () => {
+        const ctx = detectContext(projectRoot);
+        return ctx?.feature || null;
+    };
+    return {
+        hive_session_open: {
+            description: 'Open a Hive session for a feature or task. Returns full context needed to resume work.',
+            parameters: z.object({
+                feature: z.string().optional().describe('Feature name (defaults to active)'),
+                task: z.string().optional().describe('Task folder to focus on'),
+            }),
+            execute: async ({ feature, task }, toolContext) => {
+                const featureName = feature || getActiveFeature();
+                if (!featureName)
+                    return { error: 'No feature specified and no active feature' };
+                const featureData = featureService.get(featureName);
+                if (!featureData)
+                    return { error: `Feature '${featureName}' not found` };
+                const ctx = toolContext;
+                if (ctx?.sessionID) {
+                    sessionService.track(featureName, ctx.sessionID, task);
+                }
+                const planResult = planService.read(featureName);
+                const tasks = taskService.list(featureName);
+                const contextCompiled = contextService.compile(featureName);
+                const sessions = sessionService.list(featureName);
+                const response = {
+                    feature: {
+                        name: featureData.name,
+                        status: featureData.status,
+                        ticket: featureData.ticket,
+                    },
+                    plan: planResult ? {
+                        content: planResult.content,
+                        commentCount: planResult.comments.length,
+                    } : null,
+                    tasks: tasks.map(t => ({
+                        folder: t.folder,
+                        name: t.name,
+                        status: t.status,
+                        origin: t.origin,
+                    })),
+                    context: contextCompiled || null,
+                    sessions: sessions.map(s => ({
+                        sessionId: s.sessionId,
+                        taskFolder: s.taskFolder,
+                        isMaster: s.sessionId === sessionService.getMaster(featureName),
+                    })),
+                };
+                if (task) {
+                    const taskInfo = taskService.get(featureName, task);
+                    if (taskInfo) {
+                        response.focusedTask = taskInfo;
+                    }
+                }
+                return response;
+            },
+        },
+        hive_session_list: {
+            description: 'List all sessions for the active feature',
+            parameters: z.object({}),
+            execute: async () => {
+                const feature = getActiveFeature();
+                if (!feature)
+                    return { error: 'No active feature' };
+                const sessions = sessionService.list(feature);
+                const master = sessionService.getMaster(feature);
+                return {
+                    feature,
+                    master,
+                    sessions: sessions.map(s => ({
+                        sessionId: s.sessionId,
+                        taskFolder: s.taskFolder,
+                        startedAt: s.startedAt,
+                        lastActiveAt: s.lastActiveAt,
+                        isMaster: s.sessionId === master,
+                    })),
+                };
+            },
+        },
+    };
+}

package/dist/tools/taskTools.d.ts

@@ -2,12 +2,8 @@ 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<{
+        parameters: z.ZodObject<{}, z.core.$strip>;
+        execute: () => Promise<{
             error: string;
         } | {
             message: string;
@@ -23,12 +19,10 @@ export declare function createTaskTools(projectRoot: string): {
         parameters: z.ZodObject<{
             name: z.ZodString;
             order: z.ZodOptional<z.ZodNumber>;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ name, order, featureName }: {
+        execute: ({ name, order }: {
             name: string;
             order?: number;
-            featureName?: string;
         }) => Promise<{
             error: string;
             folder?: undefined;
@@ -52,13 +46,11 @@ export declare function createTaskTools(projectRoot: string): {
                 cancelled: "cancelled";
             }>>;
             summary: z.ZodOptional<z.ZodString>;
-            featureName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-        execute: ({ task, status, summary, featureName }: {
+        execute: ({ task, status, summary }: {
             task: string;
             status?: "pending" | "in_progress" | "done" | "cancelled";
             summary?: string;
-            featureName?: string;
         }) => Promise<{
             error: string;
             updated?: undefined;
@@ -75,12 +67,8 @@ export declare function createTaskTools(projectRoot: string): {
     };
     hive_task_list: {
         description: string;
-        parameters: z.ZodObject<{
-            featureName: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
-        execute: ({ featureName }: {
-            featureName?: string;
-        }) => Promise<{
+        parameters: z.ZodObject<{}, z.core.$strip>;
+        execute: () => Promise<{
             error: string;
             tasks?: undefined;
         } | {

package/dist/tools/taskTools.js

@@ -1,17 +1,20 @@
 import { z } from 'zod';
 import { TaskService } from '../services/taskService.js';
 import { FeatureService } from '../services/featureService.js';
+import { detectContext } from '../utils/detection.js';
 export function createTaskTools(projectRoot) {
     const taskService = new TaskService(projectRoot);
     const featureService = new FeatureService(projectRoot);
+    const getActiveFeature = () => {
+        const ctx = detectContext(projectRoot);
+        return ctx?.feature || null;
+    };
     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();
+            description: 'Generate tasks from approved plan',
+            parameters: z.object({}),
+            execute: async () => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -33,14 +36,13 @@ export function createTaskTools(projectRoot) {
             },
         },
         hive_task_create: {
-            description: 'Create a manual task (not from plan). Use for hotfixes or ad-hoc work during execution.',
+            description: 'Create manual task (not from plan)',
             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();
+            execute: async ({ name, order }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -53,15 +55,14 @@ export function createTaskTools(projectRoot) {
             },
         },
         hive_task_update: {
-            description: 'Update a task status or summary.',
+            description: 'Update 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();
+            execute: async ({ task, status, summary }) => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -71,11 +72,9 @@ export function createTaskTools(projectRoot) {
         },
         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();
+            parameters: z.object({}),
+            execute: async () => {
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export interface TaskStatus {
     summary?: string;
     startedAt?: string;
     completedAt?: string;
+    baseCommit?: string;
 }
 export interface PlanComment {
     id: string;
@@ -52,3 +53,37 @@ export interface FeatureInfo {
     hasPlan: boolean;
     commentCount: number;
 }
+export interface ContextFile {
+    name: string;
+    content: string;
+    updatedAt: string;
+}
+export interface SessionInfo {
+    sessionId: string;
+    taskFolder?: string;
+    startedAt: string;
+    lastActiveAt: string;
+    messageCount?: number;
+}
+export interface SessionsJson {
+    master?: string;
+    sessions: SessionInfo[];
+}
+export interface TaskSpec {
+    taskFolder: string;
+    featureName: string;
+    planSection: string;
+    context: string;
+    priorTasks: Array<{
+        folder: string;
+        summary?: string;
+    }>;
+}
+export interface HiveConfig {
+    enableToolsFor: string[];
+    agents: {
+        worker: {
+            visible: boolean;
+        };
+    };
+}

package/dist/utils/detection.d.ts

@@ -0,0 +1,12 @@
+import { FeatureJson } from '../types.js';
+export interface DetectionResult {
+    projectRoot: string;
+    feature: string | null;
+    task: string | null;
+    isWorktree: boolean;
+    mainProjectRoot: string | null;
+}
+export declare function detectContext(cwd: string): DetectionResult;
+export declare function listFeatures(projectRoot: string): string[];
+export declare function getFeatureData(projectRoot: string, featureName: string): FeatureJson | null;
+export declare function findProjectRoot(startDir: string): string | null;