opencode-hive 0.8.0 → 0.8.2

package/dist/services/featureService.test.js

@@ -1,127 +0,0 @@
-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/index.d.ts

@@ -1,5 +0,0 @@
-export { WorktreeService, createWorktreeService } from "./worktreeService.js";
-export type { WorktreeInfo, DiffResult, ApplyResult, WorktreeConfig } from "./worktreeService.js";
-export { FeatureService } from "./featureService.js";
-export { PlanService } from "./planService.js";
-export { TaskService } from "./taskService.js";

package/dist/services/index.js

@@ -1,4 +0,0 @@
-export { WorktreeService, createWorktreeService } from "./worktreeService.js";
-export { FeatureService } from "./featureService.js";
-export { PlanService } from "./planService.js";
-export { TaskService } from "./taskService.js";

package/dist/services/planService.d.ts

@@ -1,11 +0,0 @@
-import { PlanComment, PlanReadResult } from '../types.js';
-export declare class PlanService {
-    private projectRoot;
-    constructor(projectRoot: string);
-    write(featureName: string, content: string): string;
-    read(featureName: string): PlanReadResult | null;
-    approve(featureName: string): void;
-    getComments(featureName: string): PlanComment[];
-    addComment(featureName: string, comment: Omit<PlanComment, 'id' | 'timestamp'>): PlanComment;
-    clearComments(featureName: string): void;
-}

package/dist/services/planService.js

@@ -1,59 +0,0 @@
-import { getPlanPath, getCommentsPath, getFeatureJsonPath, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
-export class PlanService {
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-    }
-    write(featureName, content) {
-        const planPath = getPlanPath(this.projectRoot, featureName);
-        writeText(planPath, content);
-        this.clearComments(featureName);
-        return planPath;
-    }
-    read(featureName) {
-        const planPath = getPlanPath(this.projectRoot, featureName);
-        const content = readText(planPath);
-        if (content === null)
-            return null;
-        const feature = readJson(getFeatureJsonPath(this.projectRoot, featureName));
-        const comments = this.getComments(featureName);
-        return {
-            content,
-            status: feature?.status || 'planning',
-            comments,
-        };
-    }
-    approve(featureName) {
-        const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
-        const feature = readJson(featurePath);
-        if (!feature)
-            throw new Error(`Feature '${featureName}' not found`);
-        if (!fileExists(getPlanPath(this.projectRoot, featureName))) {
-            throw new Error(`No plan.md found for feature '${featureName}'`);
-        }
-        feature.status = 'approved';
-        feature.approvedAt = new Date().toISOString();
-        writeJson(featurePath, feature);
-    }
-    getComments(featureName) {
-        const commentsPath = getCommentsPath(this.projectRoot, featureName);
-        const data = readJson(commentsPath);
-        return data?.threads || [];
-    }
-    addComment(featureName, comment) {
-        const commentsPath = getCommentsPath(this.projectRoot, featureName);
-        const data = readJson(commentsPath) || { threads: [] };
-        const newComment = {
-            ...comment,
-            id: `comment-${Date.now()}`,
-            timestamp: new Date().toISOString(),
-        };
-        data.threads.push(newComment);
-        writeJson(commentsPath, data);
-        return newComment;
-    }
-    clearComments(featureName) {
-        const commentsPath = getCommentsPath(this.projectRoot, featureName);
-        writeJson(commentsPath, { threads: [] });
-    }
-}

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

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

package/dist/services/planService.test.js

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

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

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

@@ -1,29 +0,0 @@
-import { TaskStatus, TaskStatusType, TasksSyncResult, TaskInfo, Subtask, SubtaskType } from '../types.js';
-export declare class TaskService {
-    private projectRoot;
-    constructor(projectRoot: string);
-    sync(featureName: string): TasksSyncResult;
-    create(featureName: string, name: string, order?: number): string;
-    private createFromPlan;
-    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;
-    private listFolders;
-    private deleteTask;
-    private getNextOrder;
-    private parseTasksFromPlan;
-    createSubtask(featureName: string, taskFolder: string, name: string, type?: SubtaskType): Subtask;
-    updateSubtask(featureName: string, taskFolder: string, subtaskId: string, status: TaskStatusType): Subtask;
-    listSubtasks(featureName: string, taskFolder: string): Subtask[];
-    deleteSubtask(featureName: string, taskFolder: string, subtaskId: string): void;
-    getSubtask(featureName: string, taskFolder: string, subtaskId: string): Subtask | null;
-    writeSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
-    writeSubtaskReport(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
-    readSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string): string | null;
-    readSubtaskReport(featureName: string, taskFolder: string, subtaskId: string): string | null;
-    private listSubtaskFolders;
-    private findSubtaskFolder;
-    private slugify;
-}