opencode-hive 0.6.0 → 0.8.1

package/dist/services/taskService.js

@@ -1,230 +0,0 @@
-import * as fs from 'fs';
-import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, getTaskSpecPath, getPlanPath, ensureDir, readJson, writeJson, readText, writeText, fileExists, } from '../utils/paths.js';
-export class TaskService {
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-    }
-    sync(featureName) {
-        const planPath = getPlanPath(this.projectRoot, featureName);
-        const planContent = readText(planPath);
-        if (!planContent) {
-            throw new Error(`No plan.md found for feature '${featureName}'`);
-        }
-        const planTasks = this.parseTasksFromPlan(planContent);
-        const existingTasks = this.list(featureName);
-        const result = {
-            created: [],
-            removed: [],
-            kept: [],
-            manual: [],
-        };
-        const existingByName = new Map(existingTasks.map(t => [t.folder, t]));
-        for (const existing of existingTasks) {
-            if (existing.origin === 'manual') {
-                result.manual.push(existing.folder);
-                continue;
-            }
-            if (existing.status === 'done' || existing.status === 'in_progress') {
-                result.kept.push(existing.folder);
-                continue;
-            }
-            if (existing.status === 'cancelled') {
-                this.deleteTask(featureName, existing.folder);
-                result.removed.push(existing.folder);
-                continue;
-            }
-            const stillInPlan = planTasks.some(p => p.folder === existing.folder);
-            if (!stillInPlan) {
-                this.deleteTask(featureName, existing.folder);
-                result.removed.push(existing.folder);
-            }
-            else {
-                result.kept.push(existing.folder);
-            }
-        }
-        for (const planTask of planTasks) {
-            if (!existingByName.has(planTask.folder)) {
-                this.createFromPlan(featureName, planTask, planTasks);
-                result.created.push(planTask.folder);
-            }
-        }
-        return result;
-    }
-    create(featureName, name, order) {
-        const tasksPath = getTasksPath(this.projectRoot, featureName);
-        const existingFolders = this.listFolders(featureName);
-        const nextOrder = order ?? this.getNextOrder(existingFolders);
-        const folder = `${String(nextOrder).padStart(2, '0')}-${name}`;
-        const taskPath = getTaskPath(this.projectRoot, featureName, folder);
-        ensureDir(taskPath);
-        const status = {
-            status: 'pending',
-            origin: 'manual',
-        };
-        writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
-        return 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, 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);
-        const current = readJson(statusPath);
-        if (!current) {
-            throw new Error(`Task '${taskFolder}' not found`);
-        }
-        const updated = {
-            ...current,
-            ...updates,
-        };
-        if (updates.status === 'in_progress' && !current.startedAt) {
-            updated.startedAt = new Date().toISOString();
-        }
-        if (updates.status === 'done' && !current.completedAt) {
-            updated.completedAt = new Date().toISOString();
-        }
-        writeJson(statusPath, updated);
-        return updated;
-    }
-    get(featureName, taskFolder) {
-        const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
-        const status = readJson(statusPath);
-        if (!status)
-            return null;
-        return {
-            folder: taskFolder,
-            name: taskFolder.replace(/^\d+-/, ''),
-            status: status.status,
-            origin: status.origin,
-            summary: status.summary,
-        };
-    }
-    list(featureName) {
-        const folders = this.listFolders(featureName);
-        return folders
-            .map(folder => this.get(featureName, folder))
-            .filter((t) => t !== null);
-    }
-    writeReport(featureName, taskFolder, report) {
-        const reportPath = getTaskReportPath(this.projectRoot, featureName, taskFolder);
-        writeText(reportPath, report);
-        return reportPath;
-    }
-    listFolders(featureName) {
-        const tasksPath = getTasksPath(this.projectRoot, featureName);
-        if (!fileExists(tasksPath))
-            return [];
-        return fs.readdirSync(tasksPath, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name)
-            .sort();
-    }
-    deleteTask(featureName, taskFolder) {
-        const taskPath = getTaskPath(this.projectRoot, featureName, taskFolder);
-        if (fileExists(taskPath)) {
-            fs.rmSync(taskPath, { recursive: true });
-        }
-    }
-    getNextOrder(existingFolders) {
-        if (existingFolders.length === 0)
-            return 1;
-        const orders = existingFolders
-            .map(f => parseInt(f.split('-')[0], 10))
-            .filter(n => !isNaN(n));
-        return Math.max(...orders, 0) + 1;
-    }
-    parseTasksFromPlan(content) {
-        const tasks = [];
-        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

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

package/dist/services/taskService.test.js

@@ -1,159 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import { TaskService } from "./taskService";
-import { FeatureService } from "./featureService";
-import { PlanService } from "./planService";
-import { getTaskPath, getTaskStatusPath, getTaskReportPath } from "../utils/paths";
-const TEST_ROOT = "/tmp/hive-test-task";
-describe("TaskService", () => {
-    let taskService;
-    let featureService;
-    let planService;
-    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);
-        taskService = new TaskService(TEST_ROOT);
-        featureService.create("test-feature");
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
-    });
-    describe("sync", () => {
-        it("throws when no plan exists", () => {
-            featureService.create("no-plan");
-            expect(() => taskService.sync("no-plan")).toThrow();
-        });
-        it("creates tasks from plan", () => {
-            planService.write("test-feature", `# Plan
-
-## Tasks
-
-### 1. Setup Database
-Description
-
-### 2. Create API
-Description
-`);
-            const result = taskService.sync("test-feature");
-            expect(result.created).toContain("01-setup-database");
-            expect(result.created).toContain("02-create-api");
-            expect(result.created.length).toBe(2);
-        });
-        it("keeps done tasks even if removed from plan", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. First Task\nDesc`);
-            taskService.sync("test-feature");
-            taskService.update("test-feature", "01-first-task", { status: "done" });
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Different Task\nDesc`);
-            const result = taskService.sync("test-feature");
-            expect(result.kept).toContain("01-first-task");
-        });
-        it("removes cancelled tasks", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Task One\nDesc`);
-            taskService.sync("test-feature");
-            taskService.update("test-feature", "01-task-one", { status: "cancelled" });
-            const result = taskService.sync("test-feature");
-            expect(result.removed).toContain("01-task-one");
-        });
-        it("preserves manual tasks", () => {
-            planService.write("test-feature", `# Plan\n\n## Tasks\n\n### 1. Plan Task\nDesc`);
-            taskService.sync("test-feature");
-            taskService.create("test-feature", "manual-task");
-            const result = taskService.sync("test-feature");
-            expect(result.manual).toContain("02-manual-task");
-        });
-    });
-    describe("create", () => {
-        it("creates a manual task", () => {
-            const folder = taskService.create("test-feature", "my-task");
-            expect(folder).toBe("01-my-task");
-            expect(fs.existsSync(getTaskPath(TEST_ROOT, "test-feature", folder))).toBe(true);
-        });
-        it("auto-increments order", () => {
-            taskService.create("test-feature", "first");
-            taskService.create("test-feature", "second");
-            const third = taskService.create("test-feature", "third");
-            expect(third).toBe("03-third");
-        });
-        it("respects explicit order", () => {
-            const folder = taskService.create("test-feature", "specific", 10);
-            expect(folder).toBe("10-specific");
-        });
-        it("creates task with pending status and manual origin", () => {
-            const folder = taskService.create("test-feature", "test");
-            const task = taskService.get("test-feature", folder);
-            expect(task?.status).toBe("pending");
-            expect(task?.origin).toBe("manual");
-        });
-    });
-    describe("update", () => {
-        it("updates task status", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "in_progress" });
-            const task = taskService.get("test-feature", folder);
-            expect(task?.status).toBe("in_progress");
-        });
-        it("sets startedAt when status becomes in_progress", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "in_progress" });
-            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
-            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-            expect(status.startedAt).toBeDefined();
-        });
-        it("sets completedAt when status becomes done", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { status: "done" });
-            const statusPath = getTaskStatusPath(TEST_ROOT, "test-feature", folder);
-            const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-            expect(status.completedAt).toBeDefined();
-        });
-        it("updates summary", () => {
-            const folder = taskService.create("test-feature", "task");
-            taskService.update("test-feature", folder, { summary: "Completed setup" });
-            const task = taskService.get("test-feature", folder);
-            expect(task?.summary).toBe("Completed setup");
-        });
-        it("throws for non-existing task", () => {
-            expect(() => taskService.update("test-feature", "nope", { status: "done" })).toThrow();
-        });
-    });
-    describe("get", () => {
-        it("returns task info", () => {
-            const folder = taskService.create("test-feature", "my-task");
-            const task = taskService.get("test-feature", folder);
-            expect(task).not.toBeNull();
-            expect(task.folder).toBe("01-my-task");
-            expect(task.name).toBe("my-task");
-            expect(task.status).toBe("pending");
-            expect(task.origin).toBe("manual");
-        });
-        it("returns null for non-existing task", () => {
-            expect(taskService.get("test-feature", "nope")).toBeNull();
-        });
-    });
-    describe("list", () => {
-        it("returns empty array when no tasks", () => {
-            expect(taskService.list("test-feature")).toEqual([]);
-        });
-        it("returns all tasks sorted", () => {
-            taskService.create("test-feature", "third", 3);
-            taskService.create("test-feature", "first", 1);
-            taskService.create("test-feature", "second", 2);
-            const tasks = taskService.list("test-feature");
-            expect(tasks.length).toBe(3);
-            expect(tasks[0].folder).toBe("01-first");
-            expect(tasks[1].folder).toBe("02-second");
-            expect(tasks[2].folder).toBe("03-third");
-        });
-    });
-    describe("writeReport", () => {
-        it("writes report file", () => {
-            const folder = taskService.create("test-feature", "task");
-            const report = "## Summary\n\nCompleted the task successfully.";
-            taskService.writeReport("test-feature", folder, report);
-            const reportPath = getTaskReportPath(TEST_ROOT, "test-feature", folder);
-            expect(fs.readFileSync(reportPath, "utf-8")).toBe(report);
-        });
-    });
-});

package/dist/services/worktreeService.d.ts

@@ -1,66 +0,0 @@
-export interface WorktreeInfo {
-    path: string;
-    branch: string;
-    commit: string;
-    feature: string;
-    step: string;
-}
-export interface DiffResult {
-    hasDiff: boolean;
-    diffContent: string;
-    filesChanged: string[];
-    insertions: number;
-    deletions: number;
-}
-export interface ApplyResult {
-    success: boolean;
-    error?: string;
-    filesAffected: string[];
-}
-export interface CommitResult {
-    committed: boolean;
-    sha: string;
-    message?: string;
-}
-export interface MergeResult {
-    success: boolean;
-    merged: boolean;
-    sha?: string;
-    filesChanged?: string[];
-    conflicts?: string[];
-    error?: string;
-}
-export interface WorktreeConfig {
-    baseDir: string;
-    hiveDir: string;
-}
-export declare class WorktreeService {
-    private config;
-    constructor(config: WorktreeConfig);
-    private getGit;
-    private getWorktreesDir;
-    private getWorktreePath;
-    private getStepStatusPath;
-    private getBranchName;
-    create(feature: string, step: string, baseBranch?: string): Promise<WorktreeInfo>;
-    get(feature: string, step: string): Promise<WorktreeInfo | null>;
-    getDiff(feature: string, step: string, baseCommit?: string): Promise<DiffResult>;
-    exportPatch(feature: string, step: string, baseBranch?: string): Promise<string>;
-    applyDiff(feature: string, step: string, baseBranch?: string): Promise<ApplyResult>;
-    revertDiff(feature: string, step: string, baseBranch?: string): Promise<ApplyResult>;
-    private parseFilesFromDiff;
-    revertFromSavedDiff(diffPath: string): Promise<ApplyResult>;
-    remove(feature: string, step: string, deleteBranch?: boolean): Promise<void>;
-    list(feature?: string): Promise<WorktreeInfo[]>;
-    cleanup(feature?: string): Promise<{
-        removed: string[];
-        pruned: boolean;
-    }>;
-    checkConflicts(feature: string, step: string, baseBranch?: string): Promise<string[]>;
-    checkConflictsFromSavedDiff(diffPath: string, reverse?: boolean): Promise<string[]>;
-    commitChanges(feature: string, step: string, message?: string): Promise<CommitResult>;
-    merge(feature: string, step: string, strategy?: 'merge' | 'squash' | 'rebase'): Promise<MergeResult>;
-    hasUncommittedChanges(feature: string, step: string): Promise<boolean>;
-    private parseConflictsFromError;
-}
-export declare function createWorktreeService(projectDir: string): WorktreeService;