opencode-hive 0.4.2 → 0.5.0

package/dist/services/featureService.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs";
+import { FeatureService } from "./featureService";
+import { getFeatureJsonPath, getFeaturePath } from "../utils/paths";
+const TEST_ROOT = "/tmp/hive-test-feature";
+describe("FeatureService", () => {
+    let service;
+    beforeEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+        fs.mkdirSync(TEST_ROOT, { recursive: true });
+        service = new FeatureService(TEST_ROOT);
+    });
+    afterEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    });
+    describe("create", () => {
+        it("creates a new feature with default status", () => {
+            const feature = service.create("test-feature");
+            expect(feature.name).toBe("test-feature");
+            expect(feature.status).toBe("planning");
+            expect(feature.createdAt).toBeDefined();
+            expect(feature.ticket).toBeUndefined();
+        });
+        it("creates a feature with ticket", () => {
+            const feature = service.create("test-feature", "JIRA-123");
+            expect(feature.ticket).toBe("JIRA-123");
+        });
+        it("creates feature directory structure", () => {
+            service.create("my-feature");
+            const featurePath = getFeaturePath(TEST_ROOT, "my-feature");
+            expect(fs.existsSync(featurePath)).toBe(true);
+            expect(fs.existsSync(getFeatureJsonPath(TEST_ROOT, "my-feature"))).toBe(true);
+        });
+        it("throws if feature already exists", () => {
+            service.create("existing");
+            expect(() => service.create("existing")).toThrow();
+        });
+    });
+    describe("get", () => {
+        it("returns feature data", () => {
+            service.create("test-feature", "TICKET-1");
+            const feature = service.get("test-feature");
+            expect(feature).not.toBeNull();
+            expect(feature.name).toBe("test-feature");
+            expect(feature.ticket).toBe("TICKET-1");
+        });
+        it("returns null for non-existing feature", () => {
+            expect(service.get("nope")).toBeNull();
+        });
+    });
+    describe("list", () => {
+        it("returns empty array when no features", () => {
+            expect(service.list()).toEqual([]);
+        });
+        it("returns all feature names", () => {
+            service.create("feature-a");
+            service.create("feature-b");
+            service.create("feature-c");
+            const features = service.list();
+            expect(features).toContain("feature-a");
+            expect(features).toContain("feature-b");
+            expect(features).toContain("feature-c");
+            expect(features.length).toBe(3);
+        });
+    });
+    describe("updateStatus", () => {
+        it("updates feature status", () => {
+            service.create("test");
+            service.updateStatus("test", "approved");
+            const feature = service.get("test");
+            expect(feature.status).toBe("approved");
+        });
+        it("sets approvedAt when status becomes approved", () => {
+            service.create("test");
+            service.updateStatus("test", "approved");
+            const feature = service.get("test");
+            expect(feature.approvedAt).toBeDefined();
+        });
+        it("sets completedAt when status becomes completed", () => {
+            service.create("test");
+            service.updateStatus("test", "completed");
+            const feature = service.get("test");
+            expect(feature.completedAt).toBeDefined();
+        });
+    });
+    describe("complete", () => {
+        it("marks feature as completed", () => {
+            service.create("to-complete");
+            service.complete("to-complete");
+            const feature = service.get("to-complete");
+            expect(feature.status).toBe("completed");
+            expect(feature.completedAt).toBeDefined();
+        });
+    });
+    describe("getInfo", () => {
+        it("returns null for non-existing feature", () => {
+            expect(service.getInfo("nope")).toBeNull();
+        });
+        it("returns feature info with tasks array", () => {
+            service.create("info-test");
+            const info = service.getInfo("info-test");
+            expect(info).not.toBeNull();
+            expect(info.name).toBe("info-test");
+            expect(info.status).toBe("planning");
+            expect(info.tasks).toEqual([]);
+            expect(info.hasPlan).toBe(false);
+            expect(info.commentCount).toBe(0);
+        });
+    });
+    describe("session management", () => {
+        it("setSession stores session ID", () => {
+            service.create("session-test");
+            service.setSession("session-test", "sess_12345");
+            const feature = service.get("session-test");
+            expect(feature.sessionId).toBe("sess_12345");
+        });
+        it("getSession retrieves session ID", () => {
+            service.create("session-test");
+            service.setSession("session-test", "sess_67890");
+            expect(service.getSession("session-test")).toBe("sess_67890");
+        });
+        it("getSession returns undefined when no session", () => {
+            service.create("no-session");
+            expect(service.getSession("no-session")).toBeUndefined();
+        });
+    });
+});

package/dist/services/planService.test.d.ts

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

package/dist/services/planService.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs";
+import { PlanService } from "./planService";
+import { FeatureService } from "./featureService";
+import { getPlanPath, getCommentsPath } from "../utils/paths";
+const TEST_ROOT = "/tmp/hive-test-plan";
+describe("PlanService", () => {
+    let planService;
+    let featureService;
+    beforeEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+        fs.mkdirSync(TEST_ROOT, { recursive: true });
+        featureService = new FeatureService(TEST_ROOT);
+        planService = new PlanService(TEST_ROOT);
+        featureService.create("test-feature");
+    });
+    afterEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    });
+    describe("write", () => {
+        it("writes plan content to file", () => {
+            const content = "# My Plan\n\n## Tasks\n\n### 1. First Task";
+            planService.write("test-feature", content);
+            const planPath = getPlanPath(TEST_ROOT, "test-feature");
+            expect(fs.readFileSync(planPath, "utf-8")).toBe(content);
+        });
+        it("clears existing comments when writing", () => {
+            const commentsPath = getCommentsPath(TEST_ROOT, "test-feature");
+            fs.writeFileSync(commentsPath, JSON.stringify({
+                threads: [{ id: "1", line: 1, body: "test", author: "user", timestamp: new Date().toISOString() }]
+            }));
+            planService.write("test-feature", "# New Plan");
+            const comments = planService.getComments("test-feature");
+            expect(comments).toEqual([]);
+        });
+    });
+    describe("read", () => {
+        it("returns null when no plan exists", () => {
+            featureService.create("empty-feature");
+            const result = planService.read("empty-feature");
+            expect(result).toBeNull();
+        });
+        it("returns plan content and status", () => {
+            const content = "# Test Plan";
+            planService.write("test-feature", content);
+            const result = planService.read("test-feature");
+            expect(result).not.toBeNull();
+            expect(result.content).toBe(content);
+            expect(result.status).toBe("planning");
+            expect(result.comments).toEqual([]);
+        });
+        it("includes comments in result", () => {
+            planService.write("test-feature", "# Plan");
+            planService.addComment("test-feature", {
+                line: 1,
+                body: "Looks good!",
+                author: "reviewer",
+            });
+            const result = planService.read("test-feature");
+            expect(result.comments.length).toBe(1);
+            expect(result.comments[0].body).toBe("Looks good!");
+        });
+    });
+    describe("approve", () => {
+        it("sets feature status to approved", () => {
+            planService.write("test-feature", "# Plan");
+            planService.approve("test-feature");
+            const feature = featureService.get("test-feature");
+            expect(feature.status).toBe("approved");
+        });
+        it("read returns approved status", () => {
+            planService.write("test-feature", "# Plan");
+            planService.approve("test-feature");
+            const result = planService.read("test-feature");
+            expect(result.status).toBe("approved");
+        });
+    });
+    describe("comments", () => {
+        it("addComment adds a comment", () => {
+            planService.write("test-feature", "# Plan");
+            planService.addComment("test-feature", {
+                line: 5,
+                body: "What about error handling?",
+                author: "reviewer",
+            });
+            const comments = planService.getComments("test-feature");
+            expect(comments.length).toBe(1);
+            expect(comments[0].body).toBe("What about error handling?");
+            expect(comments[0].id).toBeDefined();
+            expect(comments[0].timestamp).toBeDefined();
+        });
+        it("getComments returns empty array when no comments", () => {
+            planService.write("test-feature", "# Plan");
+            expect(planService.getComments("test-feature")).toEqual([]);
+        });
+        it("clearComments removes all comments", () => {
+            planService.write("test-feature", "# Plan");
+            planService.addComment("test-feature", {
+                line: 1,
+                body: "Comment 1",
+                author: "a",
+            });
+            planService.addComment("test-feature", {
+                line: 2,
+                body: "Comment 2",
+                author: "b",
+            });
+            planService.clearComments("test-feature");
+            expect(planService.getComments("test-feature")).toEqual([]);
+        });
+        it("getComments returns empty array for non-existing feature", () => {
+            expect(planService.getComments("nope")).toEqual([]);
+        });
+    });
+});

package/dist/services/sessionService.d.ts

@@ -0,0 +1,31 @@
+export interface SessionInfo {
+    sessionId: string;
+    taskFolder?: string;
+    startedAt: string;
+    lastActiveAt: string;
+    messageCount?: number;
+}
+export interface SessionsJson {
+    master?: string;
+    sessions: SessionInfo[];
+}
+export declare class SessionService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    private getSessionsPath;
+    private getSessions;
+    private saveSessions;
+    track(featureName: string, sessionId: string, taskFolder?: string): SessionInfo;
+    setMaster(featureName: string, sessionId: string): void;
+    getMaster(featureName: string): string | undefined;
+    list(featureName: string): SessionInfo[];
+    get(featureName: string, sessionId: string): SessionInfo | undefined;
+    getByTask(featureName: string, taskFolder: string): SessionInfo | undefined;
+    remove(featureName: string, sessionId: string): boolean;
+    /**
+     * Find which feature a session belongs to by searching all features
+     */
+    findFeatureBySession(sessionId: string): string | null;
+    fork(featureName: string, fromSessionId?: string): SessionInfo;
+    fresh(featureName: string, title?: string): SessionInfo;
+}

package/dist/services/sessionService.js

@@ -0,0 +1,125 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getFeaturePath, ensureDir, readJson, writeJson } from '../utils/paths.js';
+export class SessionService {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    getSessionsPath(featureName) {
+        return path.join(getFeaturePath(this.projectRoot, featureName), 'sessions.json');
+    }
+    getSessions(featureName) {
+        const sessionsPath = this.getSessionsPath(featureName);
+        return readJson(sessionsPath) || { sessions: [] };
+    }
+    saveSessions(featureName, data) {
+        const sessionsPath = this.getSessionsPath(featureName);
+        ensureDir(path.dirname(sessionsPath));
+        writeJson(sessionsPath, data);
+    }
+    track(featureName, sessionId, taskFolder) {
+        const data = this.getSessions(featureName);
+        const now = new Date().toISOString();
+        let session = data.sessions.find(s => s.sessionId === sessionId);
+        if (session) {
+            session.lastActiveAt = now;
+            if (taskFolder)
+                session.taskFolder = taskFolder;
+        }
+        else {
+            session = {
+                sessionId,
+                taskFolder,
+                startedAt: now,
+                lastActiveAt: now,
+            };
+            data.sessions.push(session);
+        }
+        if (!data.master) {
+            data.master = sessionId;
+        }
+        this.saveSessions(featureName, data);
+        return session;
+    }
+    setMaster(featureName, sessionId) {
+        const data = this.getSessions(featureName);
+        data.master = sessionId;
+        this.saveSessions(featureName, data);
+    }
+    getMaster(featureName) {
+        return this.getSessions(featureName).master;
+    }
+    list(featureName) {
+        return this.getSessions(featureName).sessions;
+    }
+    get(featureName, sessionId) {
+        return this.getSessions(featureName).sessions.find(s => s.sessionId === sessionId);
+    }
+    getByTask(featureName, taskFolder) {
+        return this.getSessions(featureName).sessions.find(s => s.taskFolder === taskFolder);
+    }
+    remove(featureName, sessionId) {
+        const data = this.getSessions(featureName);
+        const index = data.sessions.findIndex(s => s.sessionId === sessionId);
+        if (index === -1)
+            return false;
+        data.sessions.splice(index, 1);
+        if (data.master === sessionId) {
+            data.master = data.sessions[0]?.sessionId;
+        }
+        this.saveSessions(featureName, data);
+        return true;
+    }
+    /**
+     * Find which feature a session belongs to by searching all features
+     */
+    findFeatureBySession(sessionId) {
+        const featuresPath = path.join(this.projectRoot, '.hive', 'features');
+        if (!fs.existsSync(featuresPath))
+            return null;
+        const features = fs.readdirSync(featuresPath, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+        for (const feature of features) {
+            const sessions = this.getSessions(feature);
+            if (sessions.sessions.some(s => s.sessionId === sessionId)) {
+                return feature;
+            }
+            if (sessions.master === sessionId) {
+                return feature;
+            }
+        }
+        return null;
+    }
+    fork(featureName, fromSessionId) {
+        const data = this.getSessions(featureName);
+        const now = new Date().toISOString();
+        const sourceSession = fromSessionId
+            ? data.sessions.find(s => s.sessionId === fromSessionId)
+            : data.sessions.find(s => s.sessionId === data.master);
+        const newSessionId = `ses_fork_${Date.now()}`;
+        const newSession = {
+            sessionId: newSessionId,
+            taskFolder: sourceSession?.taskFolder,
+            startedAt: now,
+            lastActiveAt: now,
+        };
+        data.sessions.push(newSession);
+        this.saveSessions(featureName, data);
+        return newSession;
+    }
+    fresh(featureName, title) {
+        const data = this.getSessions(featureName);
+        const now = new Date().toISOString();
+        const newSessionId = `ses_${title ? title.replace(/\s+/g, '_').toLowerCase() : Date.now()}`;
+        const newSession = {
+            sessionId: newSessionId,
+            startedAt: now,
+            lastActiveAt: now,
+        };
+        data.sessions.push(newSession);
+        this.saveSessions(featureName, data);
+        return newSession;
+    }
+}

package/dist/services/taskService.d.ts

@@ -5,7 +5,8 @@ export declare class TaskService {
     sync(featureName: string): TasksSyncResult;
     create(featureName: string, name: string, order?: number): string;
     private createFromPlan;
-    update(featureName: string, taskFolder: string, updates: Partial<Pick<TaskStatus, 'status' | 'summary'>>): TaskStatus;
+    writeSpec(featureName: string, taskFolder: string, content: string): string;
+    update(featureName: string, taskFolder: string, updates: Partial<Pick<TaskStatus, 'status' | 'summary' | 'baseCommit'>>): TaskStatus;
     get(featureName: string, taskFolder: string): TaskInfo | null;
     list(featureName: string): TaskInfo[];
     writeReport(featureName: string, taskFolder: string, report: string): string;

package/dist/services/taskService.js

@@ -1,5 +1,5 @@
 import * as fs from 'fs';
-import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, getPlanPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
+import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, getTaskSpecPath, getPlanPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
 export class TaskService {
     projectRoot;
     constructor(projectRoot) {
@@ -45,7 +45,7 @@ export class TaskService {
         }
         for (const planTask of planTasks) {
             if (!existingByName.has(planTask.folder)) {
-                this.createFromPlan(featureName, planTask.folder, planTask.order);
+                this.createFromPlan(featureName, planTask, planTasks);
                 result.created.push(planTask.folder);
             }
         }
@@ -65,14 +65,55 @@ export class TaskService {
         writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
         return folder;
     }
-    createFromPlan(featureName, folder, order) {
-        const taskPath = getTaskPath(this.projectRoot, featureName, folder);
+    createFromPlan(featureName, task, allTasks) {
+        const taskPath = getTaskPath(this.projectRoot, featureName, task.folder);
         ensureDir(taskPath);
         const status = {
             status: 'pending',
             origin: 'plan',
         };
-        writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
+        writeJson(getTaskStatusPath(this.projectRoot, featureName, task.folder), status);
+        // Write enhanced spec.md with full context
+        const specLines = [
+            `# Task ${task.order}: ${task.name}`,
+            '',
+            `**Feature:** ${featureName}`,
+            `**Folder:** ${task.folder}`,
+            `**Status:** pending`,
+            '',
+            '---',
+            '',
+            '## Description',
+            '',
+            task.description || '_No description provided in plan_',
+            '',
+        ];
+        // Add prior tasks section if not first task
+        if (task.order > 1) {
+            const priorTasks = allTasks.filter(t => t.order < task.order);
+            if (priorTasks.length > 0) {
+                specLines.push('---', '', '## Prior Tasks', '');
+                for (const prior of priorTasks) {
+                    specLines.push(`- **${prior.order}. ${prior.name}** (${prior.folder})`);
+                }
+                specLines.push('');
+            }
+        }
+        // Add next tasks section if not last task
+        const nextTasks = allTasks.filter(t => t.order > task.order);
+        if (nextTasks.length > 0) {
+            specLines.push('---', '', '## Upcoming Tasks', '');
+            for (const next of nextTasks) {
+                specLines.push(`- **${next.order}. ${next.name}** (${next.folder})`);
+            }
+            specLines.push('');
+        }
+        writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specLines.join('\n'));
+    }
+    writeSpec(featureName, taskFolder, content) {
+        const specPath = getTaskSpecPath(this.projectRoot, featureName, taskFolder);
+        writeText(specPath, content);
+        return specPath;
     }
     update(featureName, taskFolder, updates) {
         const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
@@ -142,13 +183,47 @@ export class TaskService {
     }
     parseTasksFromPlan(content) {
         const tasks = [];
-        const taskPattern = /^###\s+(\d+)\.\s+(.+)$/gm;
-        let match;
-        while ((match = taskPattern.exec(content)) !== null) {
-            const order = parseInt(match[1], 10);
-            const name = match[2].trim().toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
-            const folder = `${String(order).padStart(2, '0')}-${name}`;
-            tasks.push({ folder, order });
+        const lines = content.split('\n');
+        let currentTask = null;
+        let descriptionLines = [];
+        for (const line of lines) {
+            // Check for task header: ### N. Task Name
+            const taskMatch = line.match(/^###\s+(\d+)\.\s+(.+)$/);
+            if (taskMatch) {
+                // Save previous task if exists
+                if (currentTask) {
+                    currentTask.description = descriptionLines.join('\n').trim();
+                    tasks.push(currentTask);
+                }
+                const order = parseInt(taskMatch[1], 10);
+                const rawName = taskMatch[2].trim();
+                const folderName = rawName.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                const folder = `${String(order).padStart(2, '0')}-${folderName}`;
+                currentTask = {
+                    folder,
+                    order,
+                    name: rawName,
+                    description: '',
+                };
+                descriptionLines = [];
+            }
+            else if (currentTask) {
+                // Check for end of task section (next ## header or ### without number)
+                if (line.match(/^##\s+/) || line.match(/^###\s+[^0-9]/)) {
+                    currentTask.description = descriptionLines.join('\n').trim();
+                    tasks.push(currentTask);
+                    currentTask = null;
+                    descriptionLines = [];
+                }
+                else {
+                    descriptionLines.push(line);
+                }
+            }
+        }
+        // Don't forget the last task
+        if (currentTask) {
+            currentTask.description = descriptionLines.join('\n').trim();
+            tasks.push(currentTask);
         }
         return tasks;
     }

package/dist/services/taskService.test.d.ts

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