opencode-hive 0.2.0

package/dist/services/taskService.js

@@ -0,0 +1,155 @@
+import * as fs from 'fs';
+import { getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, 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.folder, planTask.order);
+                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, folder, order) {
+        const taskPath = getTaskPath(this.projectRoot, featureName, folder);
+        ensureDir(taskPath);
+        const status = {
+            status: 'pending',
+            origin: 'plan',
+        };
+        writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
+    }
+    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 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 });
+        }
+        return tasks;
+    }
+}

package/dist/services/worktreeService.d.ts

@@ -0,0 +1,49 @@
+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 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[]>;
+}
+export declare function createWorktreeService(projectDir: string): WorktreeService;

package/dist/services/worktreeService.js

@@ -0,0 +1,331 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import simpleGit from "simple-git";
+export class WorktreeService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getGit(cwd) {
+        return simpleGit(cwd || this.config.baseDir);
+    }
+    getWorktreesDir() {
+        return path.join(this.config.hiveDir, ".worktrees");
+    }
+    getWorktreePath(feature, step) {
+        return path.join(this.getWorktreesDir(), feature, step);
+    }
+    async getStepStatusPath(feature, step) {
+        const featurePath = path.join(this.config.hiveDir, "features", feature);
+        // Check v2 structure first (tasks/)
+        const tasksPath = path.join(featurePath, "tasks", step, "status.json");
+        try {
+            await fs.access(tasksPath);
+            return tasksPath;
+        }
+        catch { }
+        // Fall back to v1 structure (execution/)
+        return path.join(featurePath, "execution", step, "status.json");
+    }
+    getBranchName(feature, step) {
+        return `hive/${feature}/${step}`;
+    }
+    async create(feature, step, baseBranch) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        const branchName = this.getBranchName(feature, step);
+        const git = this.getGit();
+        await fs.mkdir(path.dirname(worktreePath), { recursive: true });
+        const base = baseBranch || (await git.revparse(["HEAD"])).trim();
+        const existing = await this.get(feature, step);
+        if (existing) {
+            return existing;
+        }
+        try {
+            await git.raw(["worktree", "add", "-b", branchName, worktreePath, base]);
+        }
+        catch {
+            try {
+                await git.raw(["worktree", "add", worktreePath, branchName]);
+            }
+            catch (retryError) {
+                throw new Error(`Failed to create worktree: ${retryError}`);
+            }
+        }
+        const worktreeGit = this.getGit(worktreePath);
+        const commit = (await worktreeGit.revparse(["HEAD"])).trim();
+        return {
+            path: worktreePath,
+            branch: branchName,
+            commit,
+            feature,
+            step,
+        };
+    }
+    async get(feature, step) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        const branchName = this.getBranchName(feature, step);
+        try {
+            await fs.access(worktreePath);
+            const worktreeGit = this.getGit(worktreePath);
+            const commit = (await worktreeGit.revparse(["HEAD"])).trim();
+            return {
+                path: worktreePath,
+                branch: branchName,
+                commit,
+                feature,
+                step,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async getDiff(feature, step, baseCommit) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        const statusPath = await this.getStepStatusPath(feature, step);
+        let base = baseCommit;
+        if (!base) {
+            try {
+                const status = JSON.parse(await fs.readFile(statusPath, "utf-8"));
+                base = status.execution?.baseCommit;
+            }
+            catch { }
+        }
+        if (!base) {
+            base = "HEAD~1";
+        }
+        const worktreeGit = this.getGit(worktreePath);
+        try {
+            await worktreeGit.raw(["add", "-A"]);
+            const diffContent = await worktreeGit.diff([`${base}...HEAD`]);
+            const stat = await worktreeGit.diff([`${base}...HEAD`, "--stat"]);
+            const statLines = stat.split("\n").filter((l) => l.trim());
+            const filesChanged = statLines
+                .slice(0, -1)
+                .map((line) => line.split("|")[0].trim())
+                .filter(Boolean);
+            const summaryLine = statLines[statLines.length - 1] || "";
+            const insertMatch = summaryLine.match(/(\d+) insertion/);
+            const deleteMatch = summaryLine.match(/(\d+) deletion/);
+            return {
+                hasDiff: diffContent.length > 0,
+                diffContent,
+                filesChanged,
+                insertions: insertMatch ? parseInt(insertMatch[1], 10) : 0,
+                deletions: deleteMatch ? parseInt(deleteMatch[1], 10) : 0,
+            };
+        }
+        catch {
+            return {
+                hasDiff: false,
+                diffContent: "",
+                filesChanged: [],
+                insertions: 0,
+                deletions: 0,
+            };
+        }
+    }
+    async exportPatch(feature, step, baseBranch) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        const patchPath = path.join(worktreePath, "..", `${step}.patch`);
+        const base = baseBranch || "HEAD~1";
+        const worktreeGit = this.getGit(worktreePath);
+        const diff = await worktreeGit.diff([`${base}...HEAD`]);
+        await fs.writeFile(patchPath, diff);
+        return patchPath;
+    }
+    async applyDiff(feature, step, baseBranch) {
+        const { hasDiff, diffContent, filesChanged } = await this.getDiff(feature, step, baseBranch);
+        if (!hasDiff) {
+            return { success: true, filesAffected: [] };
+        }
+        try {
+            const git = this.getGit();
+            await git.applyPatch(diffContent);
+            return { success: true, filesAffected: filesChanged };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message || "Failed to apply patch",
+                filesAffected: [],
+            };
+        }
+    }
+    async revertDiff(feature, step, baseBranch) {
+        const { hasDiff, diffContent, filesChanged } = await this.getDiff(feature, step, baseBranch);
+        if (!hasDiff) {
+            return { success: true, filesAffected: [] };
+        }
+        try {
+            const git = this.getGit();
+            await git.applyPatch(diffContent, ["-R"]);
+            return { success: true, filesAffected: filesChanged };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message || "Failed to revert patch",
+                filesAffected: [],
+            };
+        }
+    }
+    parseFilesFromDiff(diffContent) {
+        const files = [];
+        const regex = /^diff --git a\/(.+?) b\//gm;
+        let match;
+        while ((match = regex.exec(diffContent)) !== null) {
+            files.push(match[1]);
+        }
+        return [...new Set(files)];
+    }
+    async revertFromSavedDiff(diffPath) {
+        const diffContent = await fs.readFile(diffPath, "utf-8");
+        if (!diffContent.trim()) {
+            return { success: true, filesAffected: [] };
+        }
+        const filesChanged = this.parseFilesFromDiff(diffContent);
+        try {
+            const git = this.getGit();
+            await git.applyPatch(diffContent, ["-R"]);
+            return { success: true, filesAffected: filesChanged };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message || "Failed to revert patch",
+                filesAffected: [],
+            };
+        }
+    }
+    async remove(feature, step, deleteBranch = false) {
+        const worktreePath = this.getWorktreePath(feature, step);
+        const branchName = this.getBranchName(feature, step);
+        const git = this.getGit();
+        try {
+            await git.raw(["worktree", "remove", worktreePath, "--force"]);
+        }
+        catch {
+            await fs.rm(worktreePath, { recursive: true, force: true });
+        }
+        try {
+            await git.raw(["worktree", "prune"]);
+        }
+        catch {
+            /* intentional */
+        }
+        if (deleteBranch) {
+            try {
+                await git.deleteLocalBranch(branchName, true);
+            }
+            catch {
+                /* intentional */
+            }
+        }
+    }
+    async list(feature) {
+        const worktreesDir = this.getWorktreesDir();
+        const results = [];
+        try {
+            const features = feature ? [feature] : await fs.readdir(worktreesDir);
+            for (const feat of features) {
+                const featurePath = path.join(worktreesDir, feat);
+                const stat = await fs.stat(featurePath).catch(() => null);
+                if (!stat?.isDirectory())
+                    continue;
+                const steps = await fs.readdir(featurePath).catch(() => []);
+                for (const step of steps) {
+                    const info = await this.get(feat, step);
+                    if (info) {
+                        results.push(info);
+                    }
+                }
+            }
+        }
+        catch {
+            /* intentional */
+        }
+        return results;
+    }
+    async cleanup(feature) {
+        const removed = [];
+        const git = this.getGit();
+        try {
+            await git.raw(["worktree", "prune"]);
+        }
+        catch {
+            /* intentional */
+        }
+        const worktrees = await this.list(feature);
+        for (const wt of worktrees) {
+            try {
+                await fs.access(wt.path);
+                const worktreeGit = this.getGit(wt.path);
+                await worktreeGit.revparse(["HEAD"]);
+            }
+            catch {
+                await this.remove(wt.feature, wt.step, false);
+                removed.push(wt.path);
+            }
+        }
+        return { removed, pruned: true };
+    }
+    async checkConflicts(feature, step, baseBranch) {
+        const { hasDiff, diffContent } = await this.getDiff(feature, step, baseBranch);
+        if (!hasDiff) {
+            return [];
+        }
+        try {
+            const git = this.getGit();
+            await git.applyPatch(diffContent, ["--check"]);
+            return [];
+        }
+        catch (error) {
+            const err = error;
+            const stderr = err.message || "";
+            const conflicts = stderr
+                .split("\n")
+                .filter((line) => line.includes("error: patch failed:"))
+                .map((line) => {
+                const match = line.match(/error: patch failed: (.+):/);
+                return match ? match[1] : null;
+            })
+                .filter((f) => f !== null);
+            return conflicts;
+        }
+    }
+    async checkConflictsFromSavedDiff(diffPath, reverse = false) {
+        const diffContent = await fs.readFile(diffPath, "utf-8");
+        if (!diffContent.trim()) {
+            return [];
+        }
+        try {
+            const git = this.getGit();
+            const options = reverse ? ["--check", "-R"] : ["--check"];
+            await git.applyPatch(diffContent, options);
+            return [];
+        }
+        catch (error) {
+            const err = error;
+            const stderr = err.message || "";
+            const conflicts = stderr
+                .split("\n")
+                .filter((line) => line.includes("error: patch failed:"))
+                .map((line) => {
+                const match = line.match(/error: patch failed: (.+):/);
+                return match ? match[1] : null;
+            })
+                .filter((f) => f !== null);
+            return conflicts;
+        }
+    }
+}
+export function createWorktreeService(projectDir) {
+    return new WorktreeService({
+        baseDir: projectDir,
+        hiveDir: path.join(projectDir, ".hive"),
+    });
+}

package/dist/tools/execTools.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare function createExecTools(projectRoot: string): {
+    hive_exec_start: {
+        description: string;
+        parameters: z.ZodObject<{
+            task: z.ZodString;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ task, featureName }: {
+            task: string;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            worktreePath?: undefined;
+            branch?: undefined;
+            message?: undefined;
+        } | {
+            worktreePath: string;
+            branch: string;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+    hive_exec_complete: {
+        description: string;
+        parameters: z.ZodObject<{
+            task: z.ZodString;
+            summary: z.ZodString;
+            report: z.ZodOptional<z.ZodString>;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ task, summary, report, featureName }: {
+            task: string;
+            summary: string;
+            report?: string;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            completed?: undefined;
+            task?: undefined;
+            summary?: undefined;
+            message?: undefined;
+        } | {
+            completed: boolean;
+            task: string;
+            summary: string;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+    hive_exec_abort: {
+        description: string;
+        parameters: z.ZodObject<{
+            task: z.ZodString;
+            featureName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        execute: ({ task, featureName }: {
+            task: string;
+            featureName?: string;
+        }) => Promise<{
+            error: string;
+            aborted?: undefined;
+            task?: undefined;
+            message?: undefined;
+        } | {
+            aborted: boolean;
+            task: string;
+            message: string;
+            error?: undefined;
+        }>;
+    };
+};