opencode-hive 0.8.0 → 0.8.2

package/dist/utils/paths.d.ts

@@ -1,23 +0,0 @@
-export declare function getHivePath(projectRoot: string): string;
-export declare function getFeaturesPath(projectRoot: string): string;
-export declare function getFeaturePath(projectRoot: string, featureName: string): string;
-export declare function getPlanPath(projectRoot: string, featureName: string): string;
-export declare function getCommentsPath(projectRoot: string, featureName: string): string;
-export declare function getFeatureJsonPath(projectRoot: string, featureName: string): string;
-export declare function getContextPath(projectRoot: string, featureName: string): string;
-export declare function getTasksPath(projectRoot: string, featureName: string): 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 getTaskSpecPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getSubtasksPath(projectRoot: string, featureName: string, taskFolder: string): string;
-export declare function getSubtaskPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
-export declare function getSubtaskStatusPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
-export declare function getSubtaskSpecPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: string): string;
-export declare function getSubtaskReportPath(projectRoot: string, featureName: string, taskFolder: string, subtaskFolder: 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;
-export declare function writeJson<T>(filePath: string, data: T): void;
-export declare function readText(filePath: string): string | null;
-export declare function writeText(filePath: string, content: string): void;

package/dist/utils/paths.js

@@ -1,92 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-const HIVE_DIR = '.hive';
-const FEATURES_DIR = 'features';
-const TASKS_DIR = 'tasks';
-const CONTEXT_DIR = 'context';
-const PLAN_FILE = 'plan.md';
-const COMMENTS_FILE = 'comments.json';
-const FEATURE_FILE = 'feature.json';
-const STATUS_FILE = 'status.json';
-const REPORT_FILE = 'report.md';
-export function getHivePath(projectRoot) {
-    return path.join(projectRoot, HIVE_DIR);
-}
-export function getFeaturesPath(projectRoot) {
-    return path.join(getHivePath(projectRoot), FEATURES_DIR);
-}
-export function getFeaturePath(projectRoot, featureName) {
-    return path.join(getFeaturesPath(projectRoot), featureName);
-}
-export function getPlanPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
-}
-export function getCommentsPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
-}
-export function getFeatureJsonPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
-}
-export function getContextPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
-}
-export function getTasksPath(projectRoot, featureName) {
-    return path.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
-}
-export function getTaskPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTasksPath(projectRoot, featureName), taskFolder);
-}
-export function getTaskStatusPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
-}
-export function getTaskReportPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
-}
-export function getTaskSpecPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), 'spec.md');
-}
-// Subtask paths
-const SUBTASKS_DIR = 'subtasks';
-const SPEC_FILE = 'spec.md';
-export function getSubtasksPath(projectRoot, featureName, taskFolder) {
-    return path.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
-}
-export function getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-    return path.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
-}
-export function getSubtaskStatusPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
-}
-export function getSubtaskSpecPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
-}
-export function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-    return path.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
-}
-export function ensureDir(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-}
-export function fileExists(filePath) {
-    return fs.existsSync(filePath);
-}
-export function readJson(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return JSON.parse(content);
-}
-export function writeJson(filePath, data) {
-    ensureDir(path.dirname(filePath));
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-}
-export function readText(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    return fs.readFileSync(filePath, 'utf-8');
-}
-export function writeText(filePath, content) {
-    ensureDir(path.dirname(filePath));
-    fs.writeFileSync(filePath, content);
-}

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

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

package/dist/utils/paths.test.js

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