opencode-hive 0.4.4 → 0.5.0

package/README.md

@@ -36,9 +36,7 @@ npm install opencode-hive
 |------|-------------|
 | `hive_feature_create` | Create a new feature |
 | `hive_feature_list` | List all features |
-| `hive_feature_switch` | Switch to a feature |
 | `hive_feature_complete` | Mark feature as complete |
-| `hive_status` | Get feature overview |
 
 ### Planning
 | Tool | Description |

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

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

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

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

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

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

@@ -0,0 +1,127 @@
+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");
+    });
+});