opencode-hive 0.6.0 → 0.8.1

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;
-        }>;
-    };
-};

package/dist/tools/featureTools.js

@@ -1,73 +0,0 @@
-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.',
-            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 = getActiveFeature();
-                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_complete: {
-            description: 'Mark feature as completed (irreversible)',
-            parameters: z.object({
-                _placeholder: z.boolean().describe('Placeholder. Always pass true.'),
-                name: z.string().optional(),
-            }),
-            execute: async ({ name }) => {
-                const feature = name || getActiveFeature();
-                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.`,
-                };
-            },
-        },
-    };
-}

package/dist/tools/planTools.d.ts

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-export declare function createPlanTools(projectRoot: string): {
-    hive_plan_write: {
-        description: string;
-        parameters: z.ZodObject<{
-            content: z.ZodString;
-        }, z.core.$strip>;
-        execute: ({ content }: {
-            content: string;
-        }) => Promise<{
-            error: string;
-            path?: undefined;
-            message?: undefined;
-        } | {
-            path: string;
-            message: string;
-            error?: undefined;
-        }>;
-    };
-    hive_plan_read: {
-        description: string;
-        parameters: z.ZodObject<{}, z.core.$strip>;
-        execute: () => Promise<import("../types.js").PlanReadResult | {
-            error: string;
-        }>;
-    };
-    hive_plan_approve: {
-        description: string;
-        parameters: z.ZodObject<{}, z.core.$strip>;
-        execute: () => 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

@@ -1,65 +0,0 @@
-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: 'Write plan.md (clears existing comments)',
-            parameters: z.object({
-                content: z.string().describe('The markdown content for the plan'),
-            }),
-            execute: async ({ content }) => {
-                const feature = getActiveFeature();
-                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 plan.md and user comments',
-            parameters: z.object({}),
-            execute: async () => {
-                const feature = getActiveFeature();
-                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 plan for execution',
-            parameters: z.object({}),
-            execute: async () => {
-                const feature = getActiveFeature();
-                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/sessionTools.d.ts

@@ -1,35 +0,0 @@
-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;
-        }>;
-    };
-};