opencode-hive 0.4.4 → 0.5.1

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,22 +42,6 @@ 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 feature as completed (irreversible)',
             parameters: z.object({
@@ -60,7 +49,7 @@ export function createFeatureTools(projectRoot) {
                 name: z.string().optional(),
             }),
             execute: async ({ name }) => {
-                const feature = name || featureService.getActive();
+                const feature = name || getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }

package/dist/tools/planTools.js

@@ -1,9 +1,14 @@
 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)',
@@ -11,7 +16,7 @@ export function createPlanTools(projectRoot) {
                 content: z.string().describe('The markdown content for the plan'),
             }),
             execute: async ({ content }) => {
-                const feature = featureService.getActive();
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature. Create one with hive_feature_create first.' };
                 }
@@ -23,7 +28,7 @@ export function createPlanTools(projectRoot) {
             description: 'Read plan.md and user comments',
             parameters: z.object({}),
             execute: async () => {
-                const feature = featureService.getActive();
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -38,7 +43,7 @@ export function createPlanTools(projectRoot) {
             description: 'Approve plan for execution',
             parameters: z.object({}),
             execute: async () => {
-                const feature = featureService.getActive();
+                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.js

@@ -1,15 +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: 'Generate tasks from approved plan',
             parameters: z.object({}),
             execute: async () => {
-                const feature = featureService.getActive();
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -37,7 +42,7 @@ export function createTaskTools(projectRoot) {
                 order: z.number().optional().describe('Task order number (defaults to next available)'),
             }),
             execute: async ({ name, order }) => {
-                const feature = featureService.getActive();
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -57,7 +62,7 @@ export function createTaskTools(projectRoot) {
                 summary: z.string().optional().describe('Summary of work done'),
             }),
             execute: async ({ task, status, summary }) => {
-                const feature = featureService.getActive();
+                const feature = getActiveFeature();
                 if (!feature) {
                     return { error: 'No active feature.' };
                 }
@@ -69,7 +74,7 @@ export function createTaskTools(projectRoot) {
             description: 'List all tasks for the active feature.',
             parameters: z.object({}),
             execute: async () => {
-                const feature = featureService.getActive();
+                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;

package/dist/utils/detection.js

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

@@ -9,7 +9,7 @@ export declare function getTasksPath(projectRoot: string, featureName: 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 getActiveFeaturePath(projectRoot: 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;

package/dist/utils/paths.js

@@ -9,7 +9,6 @@ const COMMENTS_FILE = 'comments.json';
 const FEATURE_FILE = 'feature.json';
 const STATUS_FILE = 'status.json';
 const REPORT_FILE = 'report.md';
-const ACTIVE_FILE = 'active-feature';
 export function getHivePath(projectRoot) {
     return path.join(projectRoot, HIVE_DIR);
 }
@@ -43,8 +42,8 @@ export function getTaskStatusPath(projectRoot, featureName, taskFolder) {
 export function getTaskReportPath(projectRoot, featureName, taskFolder) {
     return path.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
 }
-export function getActiveFeaturePath(projectRoot) {
-    return path.join(getHivePath(projectRoot), ACTIVE_FILE);
+export function getTaskSpecPath(projectRoot, featureName, taskFolder) {
+    return path.join(getTaskPath(projectRoot, featureName, taskFolder), 'spec.md');
 }
 export function ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {

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

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

package/dist/utils/paths.test.js

@@ -0,0 +1,100 @@
+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");
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",