opencode-hive 0.6.0 → 0.8.1

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,89 +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 interface TaskStatus {
-    status: TaskStatusType;
-    origin: TaskOrigin;
-    summary?: string;
-    startedAt?: string;
-    completedAt?: string;
-    baseCommit?: string;
-}
-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;
-}

package/dist/utils/paths.d.ts

@@ -1,18 +0,0 @@
-export declare function getHivePath(projectRoot: string): string;
-export declare function getFeaturesPath(projectRoot: string): string;
-export declare function getFeaturePath(projectRoot: string, featureName: string): string;
-export declare function getPlanPath(projectRoot: string, featureName: string): string;
-export declare function getCommentsPath(projectRoot: string, featureName: string): string;
-export declare function getFeatureJsonPath(projectRoot: string, featureName: string): string;
-export declare function getContextPath(projectRoot: string, featureName: string): string;
-export declare function getTasksPath(projectRoot: string, featureName: string): string;
-export declare function getTaskPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getTaskStatusPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getTaskReportPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getTaskSpecPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function ensureDir(dirPath: string): void;
-export declare function fileExists(filePath: string): boolean;
-export declare function readJson<T>(filePath: string): T | null;
-export declare function writeJson<T>(filePath: string, data: T): void;
-export declare function readText(filePath: string): string | null;
-export declare function writeText(filePath: string, content: string): void;

package/dist/utils/paths.js

@@ -1,74 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-const HIVE_DIR = '.hive';
-const FEATURES_DIR = 'features';
-const TASKS_DIR = 'tasks';
-const CONTEXT_DIR = 'context';
-const PLAN_FILE = 'plan.md';
-const COMMENTS_FILE = 'comments.json';
-const FEATURE_FILE = 'feature.json';
-const STATUS_FILE = 'status.json';
-const REPORT_FILE = 'report.md';
-export function getHivePath(projectRoot) {
-    return path.join(projectRoot, HIVE_DIR);
-}
-export function getFeaturesPath(projectRoot) {
-    return path.join(getHivePath(projectRoot), FEATURES_DIR);
-}
-export function getFeaturePath(projectRoot, featureName) {
-    return path.join(getFeaturesPath(projectRoot), featureName);
-}
-export function getPlanPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
-}
-export function getCommentsPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
-}
-export function getFeatureJsonPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
-}
-export function getContextPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
-}
-export function getTasksPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
-}
-export function getTaskPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTasksPath(projectRoot, featureName), taskFolder);
-}
-export function getTaskStatusPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
-}
-export function getTaskReportPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
-}
-export function getTaskSpecPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), 'spec.md');
-}
-export function ensureDir(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-}
-export function fileExists(filePath) {
-    return fs.existsSync(filePath);
-}
-export function readJson(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return JSON.parse(content);
-}
-export function writeJson(filePath, data) {
-    ensureDir(path.dirname(filePath));
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-}
-export function readText(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    return fs.readFileSync(filePath, 'utf-8');
-}
-export function writeText(filePath, content) {
-    ensureDir(path.dirname(filePath));
-    fs.writeFileSync(filePath, content);
-}

package/dist/utils/paths.test.d.ts

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

package/dist/utils/paths.test.js

@@ -1,100 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { getHivePath, getFeaturesPath, getFeaturePath, getPlanPath, getCommentsPath, getFeatureJsonPath, getContextPath, getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, ensureDir, fileExists, readJson, writeJson, readText, writeText, } from "./paths";
-const TEST_ROOT = "/tmp/hive-test-paths";
-describe("paths.ts", () => {
-    beforeEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-        fs.mkdirSync(TEST_ROOT, { recursive: true });
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-    });
-    describe("path generators", () => {
-        it("getHivePath returns correct path", () => {
-            expect(getHivePath(TEST_ROOT)).toBe(path.join(TEST_ROOT, ".hive"));
-        });
-        it("getFeaturesPath returns correct path", () => {
-            expect(getFeaturesPath(TEST_ROOT)).toBe(path.join(TEST_ROOT, ".hive", "features"));
-        });
-        it("getFeaturePath returns correct path", () => {
-            expect(getFeaturePath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature"));
-        });
-        it("getPlanPath returns correct path", () => {
-            expect(getPlanPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "plan.md"));
-        });
-        it("getCommentsPath returns correct path", () => {
-            expect(getCommentsPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "comments.json"));
-        });
-        it("getFeatureJsonPath returns correct path", () => {
-            expect(getFeatureJsonPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "feature.json"));
-        });
-        it("getContextPath returns correct path", () => {
-            expect(getContextPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "context"));
-        });
-        it("getTasksPath returns correct path", () => {
-            expect(getTasksPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks"));
-        });
-        it("getTaskPath returns correct path", () => {
-            expect(getTaskPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup"));
-        });
-        it("getTaskStatusPath returns correct path", () => {
-            expect(getTaskStatusPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup", "status.json"));
-        });
-        it("getTaskReportPath returns correct path", () => {
-            expect(getTaskReportPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup", "report.md"));
-        });
-    });
-    describe("file utilities", () => {
-        it("ensureDir creates directory recursively", () => {
-            const deepPath = path.join(TEST_ROOT, "a", "b", "c");
-            ensureDir(deepPath);
-            expect(fs.existsSync(deepPath)).toBe(true);
-        });
-        it("ensureDir is idempotent", () => {
-            const dirPath = path.join(TEST_ROOT, "existing");
-            fs.mkdirSync(dirPath, { recursive: true });
-            expect(() => ensureDir(dirPath)).not.toThrow();
-        });
-        it("fileExists returns true for existing file", () => {
-            const filePath = path.join(TEST_ROOT, "exists.txt");
-            fs.writeFileSync(filePath, "content");
-            expect(fileExists(filePath)).toBe(true);
-        });
-        it("fileExists returns false for non-existing file", () => {
-            expect(fileExists(path.join(TEST_ROOT, "nope.txt"))).toBe(false);
-        });
-        it("writeJson and readJson roundtrip", () => {
-            const filePath = path.join(TEST_ROOT, "data.json");
-            const data = { name: "test", count: 42, nested: { value: true } };
-            writeJson(filePath, data);
-            const result = readJson(filePath);
-            expect(result).toEqual(data);
-        });
-        it("readJson returns null for non-existing file", () => {
-            expect(readJson(path.join(TEST_ROOT, "nope.json"))).toBeNull();
-        });
-        it("writeText and readText roundtrip", () => {
-            const filePath = path.join(TEST_ROOT, "text.md");
-            const content = "# Hello\n\nThis is content.";
-            writeText(filePath, content);
-            const result = readText(filePath);
-            expect(result).toBe(content);
-        });
-        it("readText returns null for non-existing file", () => {
-            expect(readText(path.join(TEST_ROOT, "nope.md"))).toBeNull();
-        });
-        it("writeJson creates parent directories", () => {
-            const filePath = path.join(TEST_ROOT, "deep", "nested", "data.json");
-            const expected = { test: true };
-            writeJson(filePath, expected);
-            expect(readJson(filePath)).toEqual(expected);
-        });
-        it("writeText creates parent directories", () => {
-            const filePath = path.join(TEST_ROOT, "deep", "nested", "file.txt");
-            writeText(filePath, "content");
-            expect(readText(filePath)).toBe("content");
-        });
-    });
-});