opencode-hive 1.3.1 → 1.3.3

package/dist/hive-core/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./utils/paths.js";
+export * from "./utils/detection.js";
+export * from "./services/index.js";

package/dist/hive-core/src/services/agentsMdService.d.ts

@@ -0,0 +1,32 @@
+import type { ContextService } from './contextService.js';
+export interface InitResult {
+    content: string;
+    existed: boolean;
+}
+export interface SyncResult {
+    proposals: string[];
+    diff: string;
+}
+export interface ApplyResult {
+    path: string;
+    chars: number;
+    isNew: boolean;
+}
+export declare class AgentsMdService {
+    private readonly rootDir;
+    private readonly contextService;
+    constructor(rootDir: string, contextService: ContextService);
+    init(): Promise<InitResult>;
+    sync(featureName: string): Promise<SyncResult>;
+    apply(content: string): ApplyResult;
+    private extractFindings;
+    private generateProposals;
+    private formatDiff;
+    private scanAndGenerate;
+    private detectProjectInfo;
+    private detectPackageManager;
+    private detectLanguage;
+    private detectTestFramework;
+    private detectMonorepo;
+    private generateTemplate;
+}

package/dist/hive-core/src/services/configService.d.ts

@@ -0,0 +1,78 @@
+import type { AgentModelConfig, HiveConfig, ResolvedCustomAgentConfig } from '../types.js';
+import type { SandboxConfig } from './dockerSandboxService.js';
+/**
+ * ConfigService manages user config at ~/.config/opencode/agent_hive.json
+ *
+ * This is USER config (not project-scoped):
+ * - VSCode extension reads/writes this
+ * - OpenCode plugin reads this to enable features
+ * - Agent does NOT have tools to access this
+ */
+export declare class ConfigService {
+    private configPath;
+    private cachedConfig;
+    private cachedCustomAgentConfigs;
+    constructor();
+    /**
+     * Get config path
+     */
+    getPath(): string;
+    /**
+     * Get the full config, merged with defaults.
+     */
+    get(): HiveConfig;
+    /**
+     * Update config (partial merge).
+     */
+    set(updates: Partial<HiveConfig>): HiveConfig;
+    /**
+     * Check if config file exists.
+     */
+    exists(): boolean;
+    /**
+     * Initialize config with defaults if it doesn't exist.
+     */
+    init(): HiveConfig;
+    /**
+     * Get agent-specific model config
+     */
+    getAgentConfig(agent: string): AgentModelConfig | ResolvedCustomAgentConfig;
+    getCustomAgentConfigs(): Record<string, ResolvedCustomAgentConfig>;
+    hasConfiguredAgent(agent: string): boolean;
+    private isBuiltInAgent;
+    private isReservedCustomAgentName;
+    private isSupportedCustomAgentBase;
+    private isPlannerAgent;
+    private isObjectRecord;
+    private resolveAutoLoadSkills;
+    /**
+     * Check if OMO-Slim delegation is enabled via user config.
+     */
+    isOmoSlimEnabled(): boolean;
+    /**
+     * Get list of globally disabled skills.
+     */
+    getDisabledSkills(): string[];
+    /**
+     * Get list of globally disabled MCPs.
+     */
+    getDisabledMcps(): string[];
+    /**
+     * Get sandbox configuration for worker isolation.
+     * Returns { mode: 'none' | 'docker', image?: string, persistent?: boolean }
+     */
+    getSandboxConfig(): SandboxConfig;
+    /**
+     * Get hook execution cadence for a specific hook.
+     * Returns the configured cadence or 1 (every turn) if not set.
+     * Validates cadence values and defaults to 1 for invalid values.
+     *
+     * @param hookName - The OpenCode hook name (e.g., 'experimental.chat.system.transform')
+     * @param options - Optional configuration
+     * @param options.safetyCritical - If true, enforces cadence=1 regardless of config
+     * @returns Validated cadence value (always >= 1)
+     */
+    getHookCadence(hookName: string, options?: {
+        safetyCritical?: boolean;
+    }): number;
+}

package/dist/hive-core/src/services/contextService.d.ts

@@ -0,0 +1,25 @@
+import type { ContextFile } from '../types.js';
+export type { ContextFile };
+export declare const RESERVED_OVERVIEW_CONTEXT = "overview";
+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[];
+    getOverview(featureName: string): ContextFile | null;
+    listExecutionContext(featureName: string): ContextFile[];
+    delete(featureName: string, fileName: string): boolean;
+    compile(featureName: string): string;
+    archive(featureName: string): {
+        archived: string[];
+        archivePath: string;
+    };
+    stats(featureName: string): {
+        count: number;
+        totalChars: number;
+        oldest?: string;
+        newest?: string;
+    };
+    private normalizeFileName;
+}

package/dist/hive-core/src/services/dockerSandboxService.d.ts

@@ -0,0 +1,76 @@
+export interface SandboxConfig {
+    mode: 'none' | 'docker';
+    image?: string;
+    persistent?: boolean;
+}
+/**
+ * DockerSandboxService handles Level 1 Docker sandboxing for Hive workers.
+ * Uses ephemeral containers (docker run --rm) with volume mounts.
+ *
+ * Level 1: Lightweight docker run (no devcontainer.json, no persistent containers)
+ */
+export declare class DockerSandboxService {
+    /**
+     * Detects appropriate Docker image based on project files in worktree.
+     *
+     * @param worktreePath - Path to the worktree directory
+     * @returns Docker image name, or null if Dockerfile exists (user manages their own)
+     */
+    static detectImage(worktreePath: string): string | null;
+    /**
+     * Builds docker run command with volume mount and working directory.
+     *
+     * @param worktreePath - Path to the worktree directory
+     * @param command - Command to execute inside container
+     * @param image - Docker image to use
+     * @returns Complete docker run command string
+     */
+    static buildRunCommand(worktreePath: string, command: string, image: string): string;
+    /**
+     * Generates a container name from a worktree path.
+     * Extracts feature and task from .hive/.worktrees/<feature>/<task> pattern.
+     *
+     * @param worktreePath - Path to the worktree directory
+     * @returns Container name (e.g., 'hive-my-feature-my-task')
+     */
+    static containerName(worktreePath: string): string;
+    /**
+     * Ensures a persistent container exists for the worktree.
+     * If container already running, returns its name.
+     * Otherwise, creates a new detached container.
+     *
+     * @param worktreePath - Path to the worktree directory
+     * @param image - Docker image to use
+     * @returns Container name
+     */
+    static ensureContainer(worktreePath: string, image: string): string;
+    /**
+     * Builds a docker exec command for persistent containers.
+     *
+     * @param containerName - Name of the running container
+     * @param command - Command to execute
+     * @returns Complete docker exec command string
+     */
+    static buildExecCommand(containerName: string, command: string): string;
+    /**
+     * Stops and removes a persistent container for a worktree.
+     *
+     * @param worktreePath - Path to the worktree directory
+     */
+    static stopContainer(worktreePath: string): void;
+    /**
+     * Checks if Docker is available on the system.
+     *
+     * @returns true if docker is available, false otherwise
+     */
+    static isDockerAvailable(): boolean;
+    /**
+     * Wraps a command with Docker container execution based on config.
+     *
+     * @param worktreePath - Path to the worktree directory
+     * @param command - Command to execute
+     * @param config - Sandbox configuration
+     * @returns Wrapped command (or original if no wrapping needed)
+     */
+    static wrapCommand(worktreePath: string, command: string, config: SandboxConfig): string;
+}

package/dist/hive-core/src/services/featureService.d.ts

@@ -0,0 +1,19 @@
+import type { FeatureJson, FeatureStatusType, FeatureInfo } from '../types.js';
+export declare class FeatureService {
+    private projectRoot;
+    private reviewService;
+    constructor(projectRoot: string);
+    private getReviewService;
+    create(name: string, ticket?: string): FeatureJson;
+    get(name: string): FeatureJson | null;
+    list(): string[];
+    getActive(): FeatureJson | null;
+    setActive(name: string): void;
+    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;
+    private readActiveFeatureName;
+}

package/dist/hive-core/src/services/index.d.ts

@@ -0,0 +1,16 @@
+export { FeatureService } from './featureService.js';
+export { PlanService } from './planService.js';
+export { TaskService } from './taskService.js';
+export { SubtaskService } from './subtaskService.js';
+export { WorktreeService, createWorktreeService } from './worktreeService.js';
+export type { WorktreeInfo, DiffResult, ApplyResult, CommitResult, MergeResult, WorktreeConfig } from './worktreeService.js';
+export { ContextService } from './contextService.js';
+export { ReviewService } from './reviewService.js';
+export { SessionService } from './sessionService.js';
+export { ConfigService } from './configService.js';
+export { AgentsMdService } from './agentsMdService.js';
+export type { InitResult, SyncResult, ApplyResult as AgentsMdApplyResult } from './agentsMdService.js';
+export { DockerSandboxService } from './dockerSandboxService.js';
+export type { SandboxConfig } from './dockerSandboxService.js';
+export { buildEffectiveDependencies, computeRunnableAndBlocked } from './taskDependencyGraph.js';
+export type { TaskWithDeps, RunnableBlockedResult } from './taskDependencyGraph.js';

package/dist/hive-core/src/services/planService.d.ts

@@ -0,0 +1,15 @@
+import type { PlanComment, PlanReadResult } from '../types.js';
+export declare class PlanService {
+    private projectRoot;
+    private reviewService;
+    constructor(projectRoot: string);
+    private getReviewService;
+    write(featureName: string, content: string): string;
+    read(featureName: string): PlanReadResult | null;
+    approve(featureName: string): void;
+    isApproved(featureName: string): boolean;
+    revokeApproval(featureName: string): void;
+    getComments(featureName: string): PlanComment[];
+    addComment(featureName: string, comment: Omit<PlanComment, 'id'>): PlanComment;
+    clearComments(featureName: string): void;
+}

package/dist/hive-core/src/services/reviewService.d.ts

@@ -0,0 +1,12 @@
+import type { ReviewCounts, ReviewDocument, ReviewThread } from '../types.js';
+export declare class ReviewService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    getThreads(featureName: string, document: ReviewDocument): ReviewThread[];
+    saveThreads(featureName: string, document: ReviewDocument, threads: ReviewThread[]): void;
+    clear(featureName: string, document: ReviewDocument): void;
+    countByDocument(featureName: string): ReviewCounts;
+    hasUnresolvedThreads(featureName: string, document?: ReviewDocument): boolean;
+    private readComments;
+    private getCanonicalPath;
+}

package/dist/hive-core/src/services/sessionService.d.ts

@@ -0,0 +1,18 @@
+import { SessionInfo } from '../types.js';
+export declare class SessionService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    private getSessionsPath;
+    private getSessions;
+    private saveSessions;
+    track(featureName: string, sessionId: string, taskFolder?: string): SessionInfo;
+    setMaster(featureName: string, sessionId: string): void;
+    getMaster(featureName: string): string | undefined;
+    list(featureName: string): SessionInfo[];
+    get(featureName: string, sessionId: string): SessionInfo | undefined;
+    getByTask(featureName: string, taskFolder: string): SessionInfo | undefined;
+    remove(featureName: string, sessionId: string): boolean;
+    findFeatureBySession(sessionId: string): string | null;
+    fork(featureName: string, fromSessionId?: string): SessionInfo;
+    fresh(featureName: string, title?: string): SessionInfo;
+}

package/dist/hive-core/src/services/subtaskService.d.ts

@@ -0,0 +1,17 @@
+import { Subtask, SubtaskType, TaskStatusType } from '../types.js';
+export declare class SubtaskService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    create(featureName: string, taskFolder: string, name: string, type?: SubtaskType): Subtask;
+    update(featureName: string, taskFolder: string, subtaskId: string, status: TaskStatusType): Subtask;
+    list(featureName: string, taskFolder: string): Subtask[];
+    get(featureName: string, taskFolder: string, subtaskId: string): Subtask | null;
+    writeSpec(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    writeReport(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    readSpec(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    readReport(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    delete(featureName: string, taskFolder: string, subtaskId: string): void;
+    private listFolders;
+    private findFolder;
+    private slugify;
+}

package/dist/hive-core/src/services/taskDependencyGraph.d.ts

@@ -0,0 +1,41 @@
+import type { TaskStatusType } from '../types.js';
+/**
+ * Minimal task info needed for dependency graph computation.
+ */
+export interface TaskWithDeps {
+    folder: string;
+    status: TaskStatusType;
+    dependsOn?: string[];
+}
+/**
+ * Result of computing runnable and blocked tasks.
+ */
+export interface RunnableBlockedResult {
+    /** Task folders that are pending and have all dependencies satisfied (done) */
+    runnable: string[];
+    /** Map of task folder -> array of unsatisfied dependency folders */
+    blocked: Record<string, string[]>;
+}
+/**
+ * Compute which pending tasks are runnable (all deps done) and which are blocked.
+ *
+ * A task is runnable if:
+ * - Its status is 'pending'
+ * - All its dependencies have status 'done'
+ *
+ * A task is blocked if:
+ * - Its status is 'pending'
+ * - At least one dependency does NOT have status 'done'
+ *
+ * Only 'done' satisfies a dependency. Other statuses (in_progress, cancelled,
+ * failed, blocked, partial) do NOT satisfy dependencies.
+ *
+ * @param tasks - Array of tasks with their status and dependencies
+ * @returns Object with runnable task folders and blocked tasks with their missing deps
+ */
+export declare function computeRunnableAndBlocked(tasks: TaskWithDeps[]): RunnableBlockedResult;
+/**
+ * Compute effective dependencies for each task, applying legacy numeric
+ * sequential fallback when dependsOn is undefined.
+ */
+export declare function buildEffectiveDependencies(tasks: TaskWithDeps[]): Map<string, string[]>;

package/dist/hive-core/src/services/taskService.d.ts

@@ -0,0 +1,124 @@
+import { LockOptions } from '../utils/paths.js';
+import { TaskStatus, TaskStatusType, TasksSyncResult, TaskInfo, Subtask, SubtaskType, WorkerSession } from '../types.js';
+/** Current schema version for TaskStatus */
+export declare const TASK_STATUS_SCHEMA_VERSION = 1;
+/** Fields that can be updated by background workers without clobbering completion-owned fields */
+export interface BackgroundPatchFields {
+    idempotencyKey?: string;
+    workerSession?: Partial<WorkerSession>;
+}
+/** Fields owned by the completion flow (not to be touched by background patches) */
+export interface CompletionFields {
+    status?: TaskStatusType;
+    summary?: string;
+    completedAt?: string;
+}
+export declare class TaskService {
+    private projectRoot;
+    constructor(projectRoot: string);
+    sync(featureName: string): TasksSyncResult;
+    /**
+     * Create a manual task with auto-incrementing index.
+     * Folder format: "01-task-name", "02-task-name", etc.
+     * Index ensures alphabetical sort = chronological order.
+     */
+    create(featureName: string, name: string, order?: number): string;
+    private createFromPlan;
+    buildSpecContent(params: {
+        featureName: string;
+        task: {
+            folder: string;
+            name: string;
+            order: number;
+            description?: string;
+        };
+        dependsOn: string[];
+        allTasks: Array<{
+            folder: string;
+            name: string;
+            order: number;
+        }>;
+        planContent?: string | null;
+        contextFiles?: Array<{
+            name: string;
+            content: string;
+        }>;
+        completedTasks?: Array<{
+            name: string;
+            summary: string;
+        }>;
+    }): string;
+    private extractPlanSection;
+    /**
+     * Resolve dependency numbers to folder names.
+     * - If dependsOnNumbers is null (not specified), apply implicit sequential default (N-1 for N > 1).
+     * - If dependsOnNumbers is [] (explicit "none"), return empty array.
+     * - Otherwise, map numbers to corresponding task folders.
+     */
+    private resolveDependencies;
+    /**
+     * Validate the dependency graph for errors before creating tasks.
+     * Throws descriptive errors pointing the operator to fix plan.md.
+     *
+     * Checks for:
+     * - Unknown task numbers in dependencies
+     * - Self-dependencies
+     * - Cycles (using DFS topological sort)
+     */
+    private validateDependencyGraph;
+    /**
+     * Detect cycles in the dependency graph using DFS.
+     * Throws a descriptive error if a cycle is found.
+     */
+    private detectCycles;
+    writeSpec(featureName: string, taskFolder: string, content: string): string;
+    /**
+     * Update task status with locked atomic write.
+     * Uses file locking to prevent race conditions between concurrent updates.
+     *
+     * @param featureName - Feature name
+     * @param taskFolder - Task folder name
+     * @param updates - Fields to update (status, summary, baseCommit)
+     * @param lockOptions - Optional lock configuration
+     * @returns Updated TaskStatus
+     */
+    update(featureName: string, taskFolder: string, updates: Partial<Pick<TaskStatus, 'status' | 'summary' | 'baseCommit'>>, lockOptions?: LockOptions): TaskStatus;
+    /**
+     * Patch only background-owned fields without clobbering completion-owned fields.
+     * Safe for concurrent use by background workers.
+     *
+     * Uses deep merge for workerSession to allow partial updates like:
+     * - patchBackgroundFields(..., { workerSession: { lastHeartbeatAt: '...' } })
+     *   will update only lastHeartbeatAt, preserving other workerSession fields.
+     *
+     * @param featureName - Feature name
+     * @param taskFolder - Task folder name
+     * @param patch - Background-owned fields to update
+     * @param lockOptions - Optional lock configuration
+     * @returns Updated TaskStatus
+     */
+    patchBackgroundFields(featureName: string, taskFolder: string, patch: BackgroundPatchFields, lockOptions?: LockOptions): TaskStatus;
+    /**
+     * Get raw TaskStatus including all fields (for internal use or debugging).
+     */
+    getRawStatus(featureName: string, taskFolder: string): TaskStatus | null;
+    get(featureName: string, taskFolder: string): TaskInfo | null;
+    list(featureName: string): TaskInfo[];
+    writeReport(featureName: string, taskFolder: string, report: string): string;
+    private listFolders;
+    private deleteTask;
+    private getNextOrder;
+    private parseTasksFromPlan;
+    createSubtask(featureName: string, taskFolder: string, name: string, type?: SubtaskType): Subtask;
+    updateSubtask(featureName: string, taskFolder: string, subtaskId: string, status: TaskStatusType): Subtask;
+    listSubtasks(featureName: string, taskFolder: string): Subtask[];
+    deleteSubtask(featureName: string, taskFolder: string, subtaskId: string): void;
+    getSubtask(featureName: string, taskFolder: string, subtaskId: string): Subtask | null;
+    writeSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    writeSubtaskReport(featureName: string, taskFolder: string, subtaskId: string, content: string): string;
+    readSubtaskSpec(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    readSubtaskReport(featureName: string, taskFolder: string, subtaskId: string): string | null;
+    private listSubtaskFolders;
+    private findSubtaskFolder;
+    private slugify;
+}

package/dist/hive-core/src/services/worktreeService.d.ts

@@ -0,0 +1,66 @@
+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 CommitResult {
+    committed: boolean;
+    sha: string;
+    message?: string;
+}
+export interface MergeResult {
+    success: boolean;
+    merged: boolean;
+    sha?: string;
+    filesChanged?: string[];
+    conflicts?: string[];
+    error?: 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[]>;
+    commitChanges(feature: string, step: string, message?: string): Promise<CommitResult>;
+    merge(feature: string, step: string, strategy?: "merge" | "squash" | "rebase", message?: string): Promise<MergeResult>;
+    hasUncommittedChanges(feature: string, step: string): Promise<boolean>;
+    private parseConflictsFromError;
+}
+export declare function createWorktreeService(projectDir: string): WorktreeService;