opencode-hive 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",
@@ -27,7 +27,7 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && tsc",
+    "build": "npm run clean && bun build src/index.ts --outdir dist --target node --format esm && tsc --emitDeclarationOnly",
     "dev": "opencode plugin dev",
     "test": "bun test"
   },
@@ -35,10 +35,11 @@
     "@opencode-ai/plugin": ">=0.13.7"
   },
   "dependencies": {
-    "simple-git": "^3.27.0"
+    "hive-core": "workspace:*"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.143",
+    "@opencode-ai/sdk": "^0.13.0",
     "@types/bun": "^1.2.0",
     "@types/node": "^20.0.0",
     "typescript": "^5.0.0"

package/dist/e2e/opencode-runtime-smoke.test.d.ts

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

package/dist/e2e/opencode-runtime-smoke.test.js

@@ -1,243 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { createServer } from "net";
-import { createOpencodeClient, createOpencodeServer, } from "@opencode-ai/sdk";
-const EXPECTED_TOOLS = [
-    "hive_feature_create",
-    "hive_plan_write",
-    "hive_plan_read",
-    "hive_tasks_sync",
-    "hive_exec_start",
-];
-function isRecord(value) {
-    return !!value && typeof value === "object";
-}
-function firstKey(record) {
-    const keys = Object.keys(record);
-    return keys.length > 0 ? keys[0] : null;
-}
-async function getDefaultModel(client) {
-    const providers = (await client.provider.list());
-    if (!isRecord(providers))
-        return null;
-    const connected = providers.connected;
-    if (!Array.isArray(connected) || connected.length === 0)
-        return null;
-    const all = providers.all;
-    if (!Array.isArray(all))
-        return null;
-    const defaultMap = providers.default;
-    const providerID = typeof connected[0] === "string" ? connected[0] : null;
-    if (!providerID)
-        return null;
-    const providerEntry = all.find((p) => isRecord(p) && p.id === providerID);
-    if (!isRecord(providerEntry))
-        return null;
-    const models = providerEntry.models;
-    if (!isRecord(models))
-        return null;
-    const supportsToolCall = (modelInfo) => {
-        if (!isRecord(modelInfo))
-            return false;
-        const v = modelInfo.tool_call ?? modelInfo.toolcall;
-        return v === true;
-    };
-    const defaultModelID = isRecord(defaultMap) && typeof defaultMap[providerID] === "string"
-        ? defaultMap[providerID]
-        : null;
-    if (defaultModelID && supportsToolCall(models[defaultModelID])) {
-        return { providerID, modelID: defaultModelID };
-    }
-    for (const modelID of Object.keys(models)) {
-        if (supportsToolCall(models[modelID])) {
-            return { providerID, modelID };
-        }
-    }
-    const fallback = defaultModelID ?? firstKey(models);
-    if (!fallback)
-        return null;
-    return { providerID, modelID: fallback };
-}
-async function getFreePort() {
-    return await new Promise((resolve, reject) => {
-        const server = createServer();
-        server.unref();
-        server.on("error", reject);
-        server.listen(0, "127.0.0.1", () => {
-            const address = server.address();
-            if (typeof address !== "object" || !address) {
-                server.close();
-                reject(new Error("Failed to get free port"));
-                return;
-            }
-            const port = address.port;
-            server.close(() => resolve(port));
-        });
-    });
-}
-function safeRm(dir) {
-    fs.rmSync(dir, { recursive: true, force: true });
-}
-function pickHivePluginEntry() {
-    const distEntry = path.resolve(import.meta.dir, "..", "..", "dist", "index.js");
-    if (fs.existsSync(distEntry))
-        return distEntry;
-    const tsEntry = path.resolve(import.meta.dir, "..", "index.ts");
-    return tsEntry;
-}
-function extractStringArray(raw) {
-    if (Array.isArray(raw) && raw.every((v) => typeof v === "string"))
-        return raw;
-    if (isRecord(raw) && Array.isArray(raw.ids) && raw.ids.every((v) => typeof v === "string")) {
-        return raw.ids;
-    }
-    return [];
-}
-async function waitForTools(idsProvider, expected, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const ids = await idsProvider();
-        const ok = expected.every((t) => ids.includes(t));
-        if (ok)
-            return ids;
-        await new Promise((r) => setTimeout(r, 200));
-    }
-    return await idsProvider();
-}
-describe("e2e: OpenCode runtime loads opencode-hive", () => {
-    it("exposes hive tools via /experimental/tool/ids", async () => {
-        const tmpBase = "/tmp/hive-e2e-runtime";
-        safeRm(tmpBase);
-        fs.mkdirSync(tmpBase, { recursive: true });
-        const projectDir = fs.mkdtempSync(path.join(tmpBase, "project-"));
-        fs.mkdirSync(path.join(projectDir, ".opencode", "plugin"), { recursive: true });
-        const hivePluginEntry = pickHivePluginEntry();
-        const pluginFile = path.join(projectDir, ".opencode", "plugin", "hive.ts");
-        const pluginSource = `import hive from ${JSON.stringify(hivePluginEntry)}\nexport const HivePlugin = hive\n`;
-        fs.writeFileSync(pluginFile, pluginSource);
-        const previousCwd = process.cwd();
-        const previousConfigDir = process.env.OPENCODE_CONFIG_DIR;
-        const previousDisableDefault = process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS;
-        process.chdir(projectDir);
-        process.env.OPENCODE_CONFIG_DIR = path.join(projectDir, ".opencode");
-        process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = "true";
-        const port = await getFreePort();
-        const config = {
-            plugin: [],
-            logLevel: "ERROR",
-        };
-        const server = await createOpencodeServer({
-            hostname: "127.0.0.1",
-            port,
-            timeout: 20000,
-            config,
-        });
-        const client = createOpencodeClient({
-            baseUrl: server.url,
-            responseStyle: "data",
-            throwOnError: true,
-            directory: projectDir,
-        });
-        const abortController = new AbortController();
-        async function approvePermissions(sessionID) {
-            const sse = await client.event.subscribe({
-                query: { directory: projectDir },
-                signal: abortController.signal,
-            });
-            for await (const evt of sse.stream) {
-                if (!evt || typeof evt !== "object")
-                    continue;
-                const maybeType = evt.type;
-                if (maybeType !== "permission.updated")
-                    continue;
-                const properties = evt.properties;
-                if (!isRecord(properties))
-                    continue;
-                if (properties.sessionID !== sessionID)
-                    continue;
-                const permissionID = typeof properties.id === "string" ? properties.id : null;
-                if (!permissionID)
-                    continue;
-                await client.postSessionIdPermissionsPermissionId({
-                    path: { id: sessionID, permissionID },
-                    body: { response: "once" },
-                    query: { directory: projectDir },
-                });
-            }
-        }
-        try {
-            const ids = await waitForTools(async () => {
-                const raw = (await client.tool.ids({ query: { directory: projectDir } }));
-                return extractStringArray(raw);
-            }, EXPECTED_TOOLS, 10000);
-            for (const toolName of EXPECTED_TOOLS) {
-                expect(ids).toContain(toolName);
-            }
-            const defaultModel = await getDefaultModel(client);
-            if (!defaultModel) {
-                return;
-            }
-            const session = (await client.session.create({
-                body: { title: "hive runtime e2e" },
-                query: { directory: projectDir },
-            }));
-            const sessionID = isRecord(session) && typeof session.id === "string" ? session.id : null;
-            expect(sessionID).not.toBeNull();
-            if (!sessionID)
-                return;
-            const permissionTask = approvePermissions(sessionID);
-            const promptResult = await client.session.prompt({
-                path: { id: sessionID },
-                query: { directory: projectDir },
-                body: {
-                    model: defaultModel,
-                    system: "Call the tool hive_feature_create exactly once with {\"name\":\"rt-feature\"}.",
-                    tools: {
-                        hive_feature_create: true,
-                    },
-                    parts: [
-                        {
-                            type: "text",
-                            text: "Create a Hive feature named rt-feature.",
-                        },
-                    ],
-                },
-            });
-            const hasToolPart = Array.isArray(promptResult?.parts)
-                ? promptResult.parts.some((p) => isRecord(p) && p.type === "tool" && p.tool === "hive_feature_create")
-                : false;
-            if (!hasToolPart) {
-                abortController.abort();
-                await permissionTask.catch(() => undefined);
-                return;
-            }
-            const featureDir = path.join(projectDir, ".hive", "features", "rt-feature");
-            const deadline = Date.now() + 20000;
-            while (Date.now() < deadline && !fs.existsSync(featureDir)) {
-                await new Promise((r) => setTimeout(r, 200));
-            }
-            abortController.abort();
-            await permissionTask.catch(() => undefined);
-            expect(fs.existsSync(featureDir)).toBe(true);
-        }
-        finally {
-            abortController.abort();
-            await server.close();
-            process.chdir(previousCwd);
-            if (previousConfigDir === undefined) {
-                delete process.env.OPENCODE_CONFIG_DIR;
-            }
-            else {
-                process.env.OPENCODE_CONFIG_DIR = previousConfigDir;
-            }
-            if (previousDisableDefault === undefined) {
-                delete process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS;
-            }
-            else {
-                process.env.OPENCODE_DISABLE_DEFAULT_PLUGINS = previousDisableDefault;
-            }
-            safeRm(tmpBase);
-        }
-    }, 60000);
-});

package/dist/e2e/plugin-smoke.test.d.ts

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

package/dist/e2e/plugin-smoke.test.js

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import * as fs from "fs";
-import * as path from "path";
-import { createOpencodeClient } from "@opencode-ai/sdk";
-import plugin from "../index";
-const OPENCODE_CLIENT = createOpencodeClient({ baseUrl: "http://localhost:1" });
-const EXPECTED_TOOLS = [
-    "hive_feature_create",
-    "hive_feature_list",
-    "hive_feature_complete",
-    "hive_plan_write",
-    "hive_plan_read",
-    "hive_plan_approve",
-    "hive_tasks_sync",
-    "hive_task_create",
-    "hive_task_update",
-    "hive_exec_start",
-    "hive_exec_complete",
-    "hive_exec_abort",
-];
-const TEST_ROOT_BASE = "/tmp/hive-e2e-plugin";
-function createStubShell() {
-    let shell;
-    const fn = ((..._args) => {
-        throw new Error("shell not available in this test");
-    });
-    shell = Object.assign(fn, {
-        braces(pattern) {
-            return [pattern];
-        },
-        escape(input) {
-            return input;
-        },
-        env() {
-            return shell;
-        },
-        cwd() {
-            return shell;
-        },
-        nothrow() {
-            return shell;
-        },
-        throws() {
-            return shell;
-        },
-    });
-    return shell;
-}
-function createToolContext(sessionID) {
-    return {
-        sessionID,
-        messageID: "msg_test",
-        agent: "test",
-        abort: new AbortController().signal,
-    };
-}
-function createProject(worktree) {
-    return {
-        id: "test",
-        worktree,
-        time: { created: Date.now() },
-    };
-}
-describe("e2e: opencode-hive plugin (in-process)", () => {
-    let testRoot;
-    beforeEach(() => {
-        fs.rmSync(TEST_ROOT_BASE, { recursive: true, force: true });
-        fs.mkdirSync(TEST_ROOT_BASE, { recursive: true });
-        testRoot = fs.mkdtempSync(path.join(TEST_ROOT_BASE, "project-"));
-    });
-    afterEach(() => {
-        fs.rmSync(TEST_ROOT_BASE, { recursive: true, force: true });
-    });
-    it("registers expected tools and basic workflow works", async () => {
-        const ctx = {
-            directory: testRoot,
-            worktree: testRoot,
-            serverUrl: new URL("http://localhost:1"),
-            project: createProject(testRoot),
-            client: OPENCODE_CLIENT,
-            $: createStubShell(),
-        };
-        const hooks = await plugin(ctx);
-        expect(hooks.tool).toBeDefined();
-        for (const toolName of EXPECTED_TOOLS) {
-            expect(hooks.tool?.[toolName]).toBeDefined();
-            expect(typeof hooks.tool?.[toolName].execute).toBe("function");
-        }
-        const sessionID = "sess_plugin_smoke";
-        const toolContext = createToolContext(sessionID);
-        const createOutput = await hooks.tool.hive_feature_create.execute({ name: "smoke-feature" }, toolContext);
-        expect(createOutput).toContain('Feature "smoke-feature" created');
-        const plan = `# Smoke Feature\n\n## Overview\n\nTest\n\n## Tasks\n\n### 1. First Task\nDo it\n`;
-        const planOutput = await hooks.tool.hive_plan_write.execute({ content: plan, feature: "smoke-feature" }, toolContext);
-        expect(planOutput).toContain("Plan written");
-        const approveOutput = await hooks.tool.hive_plan_approve.execute({ feature: "smoke-feature" }, toolContext);
-        expect(approveOutput).toContain("Plan approved");
-        const syncOutput = await hooks.tool.hive_tasks_sync.execute({ feature: "smoke-feature" }, toolContext);
-        expect(syncOutput).toContain("Tasks synced");
-        const taskFolder = path.join(testRoot, ".hive", "features", "smoke-feature", "tasks", "01-first-task");
-        expect(fs.existsSync(taskFolder)).toBe(true);
-        // Open a session to test session tracking
-        const sessionOutput = await hooks.tool.hive_session_open.execute({ feature: "smoke-feature" }, toolContext);
-        expect(sessionOutput).toContain("smoke-feature");
-        // Session is now stored in sessions.json via SessionService
-        const sessionsPath = path.join(testRoot, ".hive", "features", "smoke-feature", "sessions.json");
-        const sessions = JSON.parse(fs.readFileSync(sessionsPath, "utf-8"));
-        expect(sessions.master).toBe(sessionID);
-    });
-    it("system prompt hook injects Hive instructions", async () => {
-        const ctx = {
-            directory: testRoot,
-            worktree: testRoot,
-            serverUrl: new URL("http://localhost:1"),
-            project: createProject(testRoot),
-            client: OPENCODE_CLIENT,
-            $: createStubShell(),
-        };
-        const hooks = await plugin(ctx);
-        await hooks.tool.hive_feature_create.execute({ name: "active" }, createToolContext("sess"));
-        const output = { system: [] };
-        await hooks["experimental.chat.system.transform"]?.({}, output);
-        const joined = output.system.join("\n");
-        expect(joined).toContain("## Hive - Feature Development System");
-        expect(joined).toContain("hive_feature_create");
-    });
-});

package/dist/services/contextService.d.ts

@@ -1,15 +0,0 @@
-export interface ContextFile {
-    name: string;
-    content: string;
-    updatedAt: string;
-}
-export declare class ContextService {
-    private projectRoot;
-    constructor(projectRoot: string);
-    write(featureName: string, fileName: string, content: string): string;
-    read(featureName: string, fileName: string): string | null;
-    list(featureName: string): ContextFile[];
-    delete(featureName: string, fileName: string): boolean;
-    compile(featureName: string): string;
-    private normalizeFileName;
-}

package/dist/services/contextService.js

@@ -1,59 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { getContextPath, ensureDir, fileExists, readText, writeText } from '../utils/paths.js';
-export class ContextService {
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-    }
-    write(featureName, fileName, content) {
-        const contextPath = getContextPath(this.projectRoot, featureName);
-        ensureDir(contextPath);
-        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
-        writeText(filePath, content);
-        return filePath;
-    }
-    read(featureName, fileName) {
-        const contextPath = getContextPath(this.projectRoot, featureName);
-        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
-        return readText(filePath);
-    }
-    list(featureName) {
-        const contextPath = getContextPath(this.projectRoot, featureName);
-        if (!fileExists(contextPath))
-            return [];
-        const files = fs.readdirSync(contextPath, { withFileTypes: true })
-            .filter(f => f.isFile() && f.name.endsWith('.md'))
-            .map(f => f.name);
-        return files.map(name => {
-            const filePath = path.join(contextPath, name);
-            const stat = fs.statSync(filePath);
-            const content = readText(filePath) || '';
-            return {
-                name: name.replace(/\.md$/, ''),
-                content,
-                updatedAt: stat.mtime.toISOString(),
-            };
-        });
-    }
-    delete(featureName, fileName) {
-        const contextPath = getContextPath(this.projectRoot, featureName);
-        const filePath = path.join(contextPath, this.normalizeFileName(fileName));
-        if (fileExists(filePath)) {
-            fs.unlinkSync(filePath);
-            return true;
-        }
-        return false;
-    }
-    compile(featureName) {
-        const files = this.list(featureName);
-        if (files.length === 0)
-            return '';
-        const sections = files.map(f => `## ${f.name}\n\n${f.content}`);
-        return sections.join('\n\n---\n\n');
-    }
-    normalizeFileName(name) {
-        const normalized = name.replace(/\.md$/, '');
-        return `${normalized}.md`;
-    }
-}

package/dist/services/featureService.d.ts

@@ -1,14 +0,0 @@
-import { FeatureJson, FeatureStatusType, FeatureInfo } from '../types.js';
-export declare class FeatureService {
-    private projectRoot;
-    constructor(projectRoot: string);
-    create(name: string, ticket?: string): FeatureJson;
-    get(name: string): FeatureJson | null;
-    list(): string[];
-    updateStatus(name: string, status: FeatureStatusType): FeatureJson;
-    getInfo(name: string): FeatureInfo | null;
-    private getTasks;
-    complete(name: string): FeatureJson;
-    setSession(name: string, sessionId: string): void;
-    getSession(name: string): string | undefined;
-}

package/dist/services/featureService.js

@@ -1,107 +0,0 @@
-import * as fs from 'fs';
-import { getFeaturePath, getFeaturesPath, getFeatureJsonPath, getContextPath, getTasksPath, getPlanPath, getCommentsPath, ensureDir, readJson, writeJson, fileExists, } from '../utils/paths.js';
-export class FeatureService {
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-    }
-    create(name, ticket) {
-        const featurePath = getFeaturePath(this.projectRoot, name);
-        if (fileExists(featurePath)) {
-            throw new Error(`Feature '${name}' already exists`);
-        }
-        ensureDir(featurePath);
-        ensureDir(getContextPath(this.projectRoot, name));
-        ensureDir(getTasksPath(this.projectRoot, name));
-        const feature = {
-            name,
-            status: 'planning',
-            ticket,
-            createdAt: new Date().toISOString(),
-        };
-        writeJson(getFeatureJsonPath(this.projectRoot, name), feature);
-        return feature;
-    }
-    get(name) {
-        return readJson(getFeatureJsonPath(this.projectRoot, name));
-    }
-    list() {
-        const featuresPath = getFeaturesPath(this.projectRoot);
-        if (!fileExists(featuresPath))
-            return [];
-        return fs.readdirSync(featuresPath, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name);
-    }
-    updateStatus(name, status) {
-        const feature = this.get(name);
-        if (!feature)
-            throw new Error(`Feature '${name}' not found`);
-        feature.status = status;
-        if (status === 'approved' && !feature.approvedAt) {
-            feature.approvedAt = new Date().toISOString();
-        }
-        if (status === 'completed' && !feature.completedAt) {
-            feature.completedAt = new Date().toISOString();
-        }
-        writeJson(getFeatureJsonPath(this.projectRoot, name), feature);
-        return feature;
-    }
-    getInfo(name) {
-        const feature = this.get(name);
-        if (!feature)
-            return null;
-        const tasks = this.getTasks(name);
-        const hasPlan = fileExists(getPlanPath(this.projectRoot, name));
-        const comments = readJson(getCommentsPath(this.projectRoot, name));
-        const commentCount = comments?.threads?.length || 0;
-        return {
-            name: feature.name,
-            status: feature.status,
-            tasks,
-            hasPlan,
-            commentCount,
-        };
-    }
-    getTasks(featureName) {
-        const tasksPath = getTasksPath(this.projectRoot, featureName);
-        if (!fileExists(tasksPath))
-            return [];
-        const folders = fs.readdirSync(tasksPath, { withFileTypes: true })
-            .filter(d => d.isDirectory())
-            .map(d => d.name)
-            .sort();
-        return folders.map(folder => {
-            const statusPath = `${tasksPath}/${folder}/status.json`;
-            const status = readJson(statusPath);
-            const name = folder.replace(/^\d+-/, '');
-            return {
-                folder,
-                name,
-                status: status?.status || 'pending',
-                origin: status?.origin || 'plan',
-                summary: status?.summary,
-            };
-        });
-    }
-    complete(name) {
-        const feature = this.get(name);
-        if (!feature)
-            throw new Error(`Feature '${name}' not found`);
-        if (feature.status === 'completed') {
-            throw new Error(`Feature '${name}' is already completed`);
-        }
-        return this.updateStatus(name, 'completed');
-    }
-    setSession(name, sessionId) {
-        const feature = this.get(name);
-        if (!feature)
-            throw new Error(`Feature '${name}' not found`);
-        feature.sessionId = sessionId;
-        writeJson(getFeatureJsonPath(this.projectRoot, name), feature);
-    }
-    getSession(name) {
-        const feature = this.get(name);
-        return feature?.sessionId;
-    }
-}

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

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