opencode-hive 0.4.2 → 0.5.0

package/dist/utils/detection.js

@@ -0,0 +1,73 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { getFeaturesPath, getFeaturePath, readJson } from './paths.js';
+export function detectContext(cwd) {
+    const result = {
+        projectRoot: cwd,
+        feature: null,
+        task: null,
+        isWorktree: false,
+        mainProjectRoot: null,
+    };
+    const worktreeMatch = cwd.match(/(.+)\/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
+    if (worktreeMatch) {
+        result.mainProjectRoot = worktreeMatch[1];
+        result.feature = worktreeMatch[2];
+        result.task = worktreeMatch[3];
+        result.isWorktree = true;
+        result.projectRoot = worktreeMatch[1];
+        return result;
+    }
+    const gitPath = path.join(cwd, '.git');
+    if (fs.existsSync(gitPath)) {
+        const stat = fs.statSync(gitPath);
+        if (stat.isFile()) {
+            const gitContent = fs.readFileSync(gitPath, 'utf-8').trim();
+            const gitdirMatch = gitContent.match(/gitdir:\s*(.+)/);
+            if (gitdirMatch) {
+                const gitdir = gitdirMatch[1];
+                const worktreePathMatch = gitdir.match(/(.+)\/\.git\/worktrees\/(.+)/);
+                if (worktreePathMatch) {
+                    const mainRepo = worktreePathMatch[1];
+                    const cwdWorktreeMatch = cwd.match(/\.hive\/\.worktrees\/([^/]+)\/([^/]+)/);
+                    if (cwdWorktreeMatch) {
+                        result.mainProjectRoot = mainRepo;
+                        result.feature = cwdWorktreeMatch[1];
+                        result.task = cwdWorktreeMatch[2];
+                        result.isWorktree = true;
+                        result.projectRoot = mainRepo;
+                        return result;
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+export function listFeatures(projectRoot) {
+    const featuresPath = getFeaturesPath(projectRoot);
+    if (!fs.existsSync(featuresPath))
+        return [];
+    return fs.readdirSync(featuresPath, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+}
+export function getFeatureData(projectRoot, featureName) {
+    const featurePath = getFeaturePath(projectRoot, featureName);
+    const featureJsonPath = path.join(featurePath, 'feature.json');
+    return readJson(featureJsonPath);
+}
+export function findProjectRoot(startDir) {
+    let current = startDir;
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (fs.existsSync(path.join(current, '.hive'))) {
+            return current;
+        }
+        if (fs.existsSync(path.join(current, '.git'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return null;
+}

package/dist/utils/paths.d.ts

@@ -9,7 +9,7 @@ export declare function getTasksPath(projectRoot: string, featureName: string):
 export declare function getTaskPath(projectRoot: string, featureName: string, taskFolder: string): string;
 export declare function getTaskStatusPath(projectRoot: string, featureName: string, taskFolder: string): string;
 export declare function getTaskReportPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getActiveFeaturePath(projectRoot: string): string;
+export declare function getTaskSpecPath(projectRoot: string, featureName: string, taskFolder: string): string;
 export declare function ensureDir(dirPath: string): void;
 export declare function fileExists(filePath: string): boolean;
 export declare function readJson<T>(filePath: string): T | null;

package/dist/utils/paths.js

@@ -9,7 +9,6 @@ const COMMENTS_FILE = 'comments.json';
 const FEATURE_FILE = 'feature.json';
 const STATUS_FILE = 'status.json';
 const REPORT_FILE = 'report.md';
-const ACTIVE_FILE = 'active-feature';
 export function getHivePath(projectRoot) {
     return path.join(projectRoot, HIVE_DIR);
 }
@@ -43,8 +42,8 @@ export function getTaskStatusPath(projectRoot, featureName, taskFolder) {
 export function getTaskReportPath(projectRoot, featureName, taskFolder) {
     return path.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
 }
-export function getActiveFeaturePath(projectRoot) {
-    return path.join(getHivePath(projectRoot), ACTIVE_FILE);
+export function getTaskSpecPath(projectRoot, featureName, taskFolder) {
+    return path.join(getTaskPath(projectRoot, featureName, taskFolder), 'spec.md');
 }
 export function ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {

package/dist/utils/paths.test.d.ts

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

package/dist/utils/paths.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs";
+import * as path from "path";
+import { getHivePath, getFeaturesPath, getFeaturePath, getPlanPath, getCommentsPath, getFeatureJsonPath, getContextPath, getTasksPath, getTaskPath, getTaskStatusPath, getTaskReportPath, ensureDir, fileExists, readJson, writeJson, readText, writeText, } from "./paths";
+const TEST_ROOT = "/tmp/hive-test-paths";
+describe("paths.ts", () => {
+    beforeEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+        fs.mkdirSync(TEST_ROOT, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(TEST_ROOT, { recursive: true, force: true });
+    });
+    describe("path generators", () => {
+        it("getHivePath returns correct path", () => {
+            expect(getHivePath(TEST_ROOT)).toBe(path.join(TEST_ROOT, ".hive"));
+        });
+        it("getFeaturesPath returns correct path", () => {
+            expect(getFeaturesPath(TEST_ROOT)).toBe(path.join(TEST_ROOT, ".hive", "features"));
+        });
+        it("getFeaturePath returns correct path", () => {
+            expect(getFeaturePath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature"));
+        });
+        it("getPlanPath returns correct path", () => {
+            expect(getPlanPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "plan.md"));
+        });
+        it("getCommentsPath returns correct path", () => {
+            expect(getCommentsPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "comments.json"));
+        });
+        it("getFeatureJsonPath returns correct path", () => {
+            expect(getFeatureJsonPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "feature.json"));
+        });
+        it("getContextPath returns correct path", () => {
+            expect(getContextPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "context"));
+        });
+        it("getTasksPath returns correct path", () => {
+            expect(getTasksPath(TEST_ROOT, "my-feature")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks"));
+        });
+        it("getTaskPath returns correct path", () => {
+            expect(getTaskPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup"));
+        });
+        it("getTaskStatusPath returns correct path", () => {
+            expect(getTaskStatusPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup", "status.json"));
+        });
+        it("getTaskReportPath returns correct path", () => {
+            expect(getTaskReportPath(TEST_ROOT, "my-feature", "01-setup")).toBe(path.join(TEST_ROOT, ".hive", "features", "my-feature", "tasks", "01-setup", "report.md"));
+        });
+    });
+    describe("file utilities", () => {
+        it("ensureDir creates directory recursively", () => {
+            const deepPath = path.join(TEST_ROOT, "a", "b", "c");
+            ensureDir(deepPath);
+            expect(fs.existsSync(deepPath)).toBe(true);
+        });
+        it("ensureDir is idempotent", () => {
+            const dirPath = path.join(TEST_ROOT, "existing");
+            fs.mkdirSync(dirPath, { recursive: true });
+            expect(() => ensureDir(dirPath)).not.toThrow();
+        });
+        it("fileExists returns true for existing file", () => {
+            const filePath = path.join(TEST_ROOT, "exists.txt");
+            fs.writeFileSync(filePath, "content");
+            expect(fileExists(filePath)).toBe(true);
+        });
+        it("fileExists returns false for non-existing file", () => {
+            expect(fileExists(path.join(TEST_ROOT, "nope.txt"))).toBe(false);
+        });
+        it("writeJson and readJson roundtrip", () => {
+            const filePath = path.join(TEST_ROOT, "data.json");
+            const data = { name: "test", count: 42, nested: { value: true } };
+            writeJson(filePath, data);
+            const result = readJson(filePath);
+            expect(result).toEqual(data);
+        });
+        it("readJson returns null for non-existing file", () => {
+            expect(readJson(path.join(TEST_ROOT, "nope.json"))).toBeNull();
+        });
+        it("writeText and readText roundtrip", () => {
+            const filePath = path.join(TEST_ROOT, "text.md");
+            const content = "# Hello\n\nThis is content.";
+            writeText(filePath, content);
+            const result = readText(filePath);
+            expect(result).toBe(content);
+        });
+        it("readText returns null for non-existing file", () => {
+            expect(readText(path.join(TEST_ROOT, "nope.md"))).toBeNull();
+        });
+        it("writeJson creates parent directories", () => {
+            const filePath = path.join(TEST_ROOT, "deep", "nested", "data.json");
+            const expected = { test: true };
+            writeJson(filePath, expected);
+            expect(readJson(filePath)).toEqual(expected);
+        });
+        it("writeText creates parent directories", () => {
+            const filePath = path.join(TEST_ROOT, "deep", "nested", "file.txt");
+            writeText(filePath, "content");
+            expect(readText(filePath)).toBe("content");
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-hive",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",