opencode-hive 0.8.0 → 0.8.2

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

package/dist/tools/sessionTools.js

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

@@ -1,79 +0,0 @@
-import { z } from 'zod';
-export declare function createTaskTools(projectRoot: string): {
-    hive_tasks_sync: {
-        description: string;
-        parameters: z.ZodObject<{}, z.core.$strip>;
-        execute: () => 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>;
-        }, z.core.$strip>;
-        execute: ({ name, order }: {
-            name: string;
-            order?: number;
-        }) => 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>;
-        }, z.core.$strip>;
-        execute: ({ task, status, summary }: {
-            task: string;
-            status?: "pending" | "in_progress" | "done" | "cancelled";
-            summary?: 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<{}, z.core.$strip>;
-        execute: () => Promise<{
-            error: string;
-            tasks?: undefined;
-        } | {
-            tasks: import("../types.js").TaskInfo[];
-            error?: undefined;
-        }>;
-    };
-};

package/dist/tools/taskTools.js

@@ -1,86 +0,0 @@
-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: 'Generate tasks from approved plan',
-            parameters: z.object({}),
-            execute: async () => {
-                const feature = getActiveFeature();
-                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 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)'),
-            }),
-            execute: async ({ name, order }) => {
-                const feature = getActiveFeature();
-                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 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'),
-            }),
-            execute: async ({ task, status, summary }) => {
-                const feature = getActiveFeature();
-                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({}),
-            execute: async () => {
-                const feature = getActiveFeature();
-                if (!feature) {
-                    return { error: 'No active feature.' };
-                }
-                const tasks = taskService.list(feature);
-                return { tasks };
-            },
-        },
-    };
-}

package/dist/types.d.ts

@@ -1,106 +0,0 @@
-export type FeatureStatusType = 'planning' | 'approved' | 'executing' | 'completed';
-export interface FeatureJson {
-    name: string;
-    status: FeatureStatusType;
-    ticket?: string;
-    sessionId?: string;
-    createdAt: string;
-    approvedAt?: string;
-    completedAt?: string;
-}
-export type TaskStatusType = 'pending' | 'in_progress' | 'done' | 'cancelled';
-export type TaskOrigin = 'plan' | 'manual';
-export type SubtaskType = 'test' | 'implement' | 'review' | 'verify' | 'research' | 'debug' | 'custom';
-export interface Subtask {
-    id: string;
-    name: string;
-    folder: string;
-    status: TaskStatusType;
-    type?: SubtaskType;
-    createdAt?: string;
-    completedAt?: string;
-}
-export interface SubtaskStatus {
-    status: TaskStatusType;
-    type?: SubtaskType;
-    createdAt: string;
-    completedAt?: string;
-}
-export interface TaskStatus {
-    status: TaskStatusType;
-    origin: TaskOrigin;
-    summary?: string;
-    startedAt?: string;
-    completedAt?: string;
-    baseCommit?: string;
-    subtasks?: Subtask[];
-}
-export interface PlanComment {
-    id: string;
-    line: number;
-    body: string;
-    author: string;
-    timestamp: string;
-}
-export interface CommentsJson {
-    threads: PlanComment[];
-}
-export interface PlanReadResult {
-    content: string;
-    status: FeatureStatusType;
-    comments: PlanComment[];
-}
-export interface TasksSyncResult {
-    created: string[];
-    removed: string[];
-    kept: string[];
-    manual: string[];
-}
-export interface TaskInfo {
-    folder: string;
-    name: string;
-    status: TaskStatusType;
-    origin: TaskOrigin;
-    summary?: string;
-}
-export interface FeatureInfo {
-    name: string;
-    status: FeatureStatusType;
-    tasks: TaskInfo[];
-    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/types.js

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

package/dist/utils/detection.d.ts

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

package/dist/utils/detection.js

@@ -1,73 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { getFeaturesPath, getFeaturePath, readJson } from './paths.js';
-export function detectContext(cwd) {
-    const result = {
-        projectRoot: cwd,
-        feature: null,
-        task: null,
-        isWorktree: false,
-        mainProjectRoot: null,
-    };
-    const worktreeMatch = cwd.match(/(.+)\/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
-    if (worktreeMatch) {
-        result.mainProjectRoot = worktreeMatch[1];
-        result.feature = worktreeMatch[2];
-        result.task = worktreeMatch[3];
-        result.isWorktree = true;
-        result.projectRoot = worktreeMatch[1];
-        return result;
-    }
-    const gitPath = path.join(cwd, '.git');
-    if (fs.existsSync(gitPath)) {
-        const stat = fs.statSync(gitPath);
-        if (stat.isFile()) {
-            const gitContent = fs.readFileSync(gitPath, 'utf-8').trim();
-            const gitdirMatch = gitContent.match(/gitdir:\s*(.+)/);
-            if (gitdirMatch) {
-                const gitdir = gitdirMatch[1];
-                const worktreePathMatch = gitdir.match(/(.+)\/\.git\/worktrees\/(.+)/);
-                if (worktreePathMatch) {
-                    const mainRepo = worktreePathMatch[1];
-                    const cwdWorktreeMatch = cwd.match(/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
-                    if (cwdWorktreeMatch) {
-                        result.mainProjectRoot = mainRepo;
-                        result.feature = cwdWorktreeMatch[1];
-                        result.task = cwdWorktreeMatch[2];
-                        result.isWorktree = true;
-                        result.projectRoot = mainRepo;
-                        return result;
-                    }
-                }
-            }
-        }
-    }
-    return result;
-}
-export function listFeatures(projectRoot) {
-    const featuresPath = getFeaturesPath(projectRoot);
-    if (!fs.existsSync(featuresPath))
-        return [];
-    return fs.readdirSync(featuresPath, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name);
-}
-export function getFeatureData(projectRoot, featureName) {
-    const featurePath = getFeaturePath(projectRoot, featureName);
-    const featureJsonPath = path.join(featurePath, 'feature.json');
-    return readJson(featureJsonPath);
-}
-export function findProjectRoot(startDir) {
-    let current = startDir;
-    const root = path.parse(current).root;
-    while (current !== root) {
-        if (fs.existsSync(path.join(current, '.hive'))) {
-            return current;
-        }
-        if (fs.existsSync(path.join(current, '.git'))) {
-            return current;
-        }
-        current = path.dirname(current);
-    }
-    return null;
-}