@inixiative/hivemind 0.1.0

package/dist/mcp/tools/setup.js

@@ -0,0 +1,75 @@
+import { existsSync } from 'fs';
+import { getProjectPaths } from '../../db/getProjectPaths';
+import { initializeDb } from '../../db/initializeDb';
+import { formatDatetime } from '../../datetime/formatDatetime';
+import { getGitInfo } from '../../git/getGitInfo';
+export const setupTool = {
+    name: 'hivemind_setup',
+    description: 'Initialize hivemind for a project. Detects git repo info automatically.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name. If omitted, will use git repo name or prompt.',
+            },
+            useGit: {
+                type: 'boolean',
+                description: 'Use git repo info for project name (default: true if in git repo)',
+            },
+        },
+    },
+};
+/**
+ * Execute setup - may return prompt for user input
+ */
+export function executeSetup(input) {
+    const gitInfo = getGitInfo();
+    // If no project specified and we're in a git repo, ask to use it
+    if (!input.project && gitInfo.isRepo && input.useGit === undefined) {
+        return {
+            needsInput: true,
+            gitInfo: {
+                repoName: gitInfo.repoName,
+                branch: gitInfo.branch,
+                root: gitInfo.root,
+            },
+            message: `Git repository detected: ${gitInfo.repoName}\nUse this for project name? (set useGit: true/false)`,
+        };
+    }
+    // Determine project name
+    let projectName;
+    if (input.project) {
+        projectName = input.project;
+    }
+    else if (input.useGit !== false && gitInfo.isRepo && gitInfo.repoName) {
+        projectName = gitInfo.repoName;
+    }
+    else {
+        projectName = process.cwd().split('/').pop() || 'default';
+    }
+    // Initialize
+    const paths = getProjectPaths(projectName);
+    const isNew = !existsSync(paths.dbPath);
+    const db = initializeDb(projectName);
+    let stats = '';
+    if (!isNew) {
+        const agentCount = db.prepare('SELECT COUNT(*) as c FROM agents').get().c;
+        const planCount = db.prepare('SELECT COUNT(*) as c FROM plans').get().c;
+        const eventCount = db.prepare('SELECT COUNT(*) as c FROM events').get().c;
+        stats = `\nstats: ${agentCount} agents, ${planCount} plans, ${eventCount} events`;
+    }
+    db.close();
+    return {
+        needsInput: false,
+        project: projectName,
+        dbPath: paths.dbPath,
+        message: `hivemind ${isNew ? 'created' : 'connected'}: ${projectName}\ndb: ${paths.dbPath}${stats}\ntimestamp: ${formatDatetime()}`,
+    };
+}

package/dist/mcp/tools/status.d.ts

@@ -0,0 +1,44 @@
+import type { Agent } from '../../agents/types';
+import type { WorktreeRecord } from '../../worktrees/types';
+import type { Event } from '../../events/types';
+import type { Plan } from '../../plans/types';
+export declare const statusTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type StatusInput = {
+    project: string;
+};
+export type PlanWithTasks = Plan & {
+    taskCounts: {
+        pending: number;
+        in_progress: number;
+        done: number;
+        total: number;
+    };
+};
+export type StatusResult = {
+    project: string;
+    activeAgents: Agent[];
+    worktrees: WorktreeRecord[];
+    plans: PlanWithTasks[];
+    recentEvents: Event[];
+    summary: string;
+};
+export declare function executeStatus(input: StatusInput): StatusResult;

package/dist/mcp/tools/status.js

@@ -0,0 +1,74 @@
+import { getConnection } from '../../db/getConnection';
+import { getActiveAgents } from '../../agents/getActiveAgents';
+import { getAllWorktrees } from '../../worktrees/getAllWorktrees';
+import { getRecentEvents } from '../../events/getRecentEvents';
+import { getActivePlans } from '../../plans/getActivePlans';
+export const statusTool = {
+    name: 'hivemind_status',
+    description: 'Get current hivemind status: active agents, worktrees, recent events.',
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name',
+            },
+        },
+        required: ['project'],
+    },
+};
+export function executeStatus(input) {
+    const db = getConnection(input.project);
+    const activeAgents = getActiveAgents(db);
+    const worktrees = getAllWorktrees(db);
+    const recentEvents = getRecentEvents(db, 10);
+    // Get active plans with task counts
+    const activePlans = getActivePlans(db);
+    const plans = activePlans.map((plan) => {
+        const counts = db
+            .prepare(`
+      SELECT
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+        SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) as in_progress,
+        SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done,
+        COUNT(*) as total
+      FROM tasks
+      WHERE plan_id = ?
+    `)
+            .get(plan.id);
+        return {
+            ...plan,
+            taskCounts: {
+                pending: counts?.pending ?? 0,
+                in_progress: counts?.in_progress ?? 0,
+                done: counts?.done ?? 0,
+                total: counts?.total ?? 0,
+            },
+        };
+    });
+    // Count plans with open work
+    const plansWithWork = plans.filter((p) => p.taskCounts.pending > 0 || p.taskCounts.in_progress > 0);
+    const summary = [
+        `hivemind:${input.project}`,
+        `${activeAgents.length} active agent(s)`,
+        `${worktrees.length} worktree(s)`,
+        plansWithWork.length > 0 ? `${plansWithWork.length} plan(s) with open work` : null,
+        `${recentEvents.length} recent event(s)`,
+    ]
+        .filter(Boolean)
+        .join(' | ');
+    return {
+        project: input.project,
+        activeAgents,
+        worktrees,
+        plans,
+        recentEvents,
+        summary,
+    };
+}

package/dist/mcp/tools/tasks.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Task management MCP tools
+ * - Claim tasks to work on
+ * - Complete tasks when done
+ */
+export declare const claimTaskTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            taskId: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type ClaimTaskInput = {
+    project: string;
+    taskId: string;
+    agentId: string;
+};
+export declare function executeClaimTask(input: ClaimTaskInput): {
+    success: boolean;
+    message: string;
+};
+export declare const startTaskTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            taskId: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type StartTaskInput = {
+    project: string;
+    taskId: string;
+    agentId: string;
+};
+export declare function executeStartTask(input: StartTaskInput): {
+    success: boolean;
+    message: string;
+};
+export declare const completeTaskTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            taskId: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type CompleteTaskInput = {
+    project: string;
+    taskId: string;
+    agentId: string;
+};
+export declare function executeCompleteTask(input: CompleteTaskInput): {
+    success: boolean;
+    message: string;
+};

package/dist/mcp/tools/tasks.js

@@ -0,0 +1,143 @@
+/**
+ * Task management MCP tools
+ * - Claim tasks to work on
+ * - Complete tasks when done
+ */
+import { getConnection } from '../../db/getConnection';
+import { getTask } from '../../tasks/getTask';
+import { claimTask } from '../../tasks/claimTask';
+import { completeTask } from '../../tasks/completeTask';
+import { startTask } from '../../tasks/startTask';
+import { emit } from '../../events/emit';
+// ─────────────────────────────────────────────────────────────
+// Claim Task
+// ─────────────────────────────────────────────────────────────
+export const claimTaskTool = {
+    name: 'hivemind_claim_task',
+    description: 'Claim a task to work on. Other agents will see you own this task.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name' },
+            taskId: { type: 'string', description: 'Task ID to claim' },
+            agentId: { type: 'string', description: 'Your agent ID' },
+        },
+        required: ['project', 'taskId', 'agentId'],
+    },
+};
+export function executeClaimTask(input) {
+    const db = getConnection(input.project);
+    const task = getTask(db, input.taskId);
+    if (!task) {
+        return { success: false, message: `Task ${input.taskId} not found` };
+    }
+    if (task.status === 'done') {
+        return { success: false, message: `Task ${input.taskId} is already done` };
+    }
+    if (task.claimed_by && task.claimed_by !== input.agentId) {
+        return { success: false, message: `Task ${input.taskId} is claimed by ${task.claimed_by}` };
+    }
+    const result = claimTask(db, input.taskId, input.agentId);
+    if (!result) {
+        return { success: false, message: `Failed to claim task ${input.taskId}` };
+    }
+    emit(db, {
+        type: 'task:claim',
+        content: `${input.agentId} claimed: ${task.title}`,
+        agent_id: input.agentId,
+        task_id: input.taskId,
+        plan_id: task.plan_id,
+    });
+    return { success: true, message: `Claimed task: ${task.title}` };
+}
+// ─────────────────────────────────────────────────────────────
+// Start Task (mark in progress)
+// ─────────────────────────────────────────────────────────────
+export const startTaskTool = {
+    name: 'hivemind_start_task',
+    description: 'Mark a task as in progress. Call after claiming when you begin work.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name' },
+            taskId: { type: 'string', description: 'Task ID to start' },
+            agentId: { type: 'string', description: 'Your agent ID' },
+        },
+        required: ['project', 'taskId', 'agentId'],
+    },
+};
+export function executeStartTask(input) {
+    const db = getConnection(input.project);
+    const task = getTask(db, input.taskId);
+    if (!task) {
+        return { success: false, message: `Task ${input.taskId} not found` };
+    }
+    if (task.status === 'done') {
+        return { success: false, message: `Task ${input.taskId} is already done` };
+    }
+    startTask(db, input.taskId);
+    emit(db, {
+        type: 'task:start',
+        content: `${input.agentId} started: ${task.title}`,
+        agent_id: input.agentId,
+        task_id: input.taskId,
+        plan_id: task.plan_id,
+    });
+    return { success: true, message: `Started task: ${task.title}` };
+}
+// ─────────────────────────────────────────────────────────────
+// Complete Task
+// ─────────────────────────────────────────────────────────────
+export const completeTaskTool = {
+    name: 'hivemind_complete_task',
+    description: 'Mark a task as done.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name' },
+            taskId: { type: 'string', description: 'Task ID to complete' },
+            agentId: { type: 'string', description: 'Your agent ID' },
+        },
+        required: ['project', 'taskId', 'agentId'],
+    },
+};
+export function executeCompleteTask(input) {
+    const db = getConnection(input.project);
+    const task = getTask(db, input.taskId);
+    if (!task) {
+        return { success: false, message: `Task ${input.taskId} not found` };
+    }
+    if (task.status === 'done') {
+        return { success: false, message: `Task ${input.taskId} is already done` };
+    }
+    const result = completeTask(db, input.taskId);
+    if (!result) {
+        return { success: false, message: `Failed to complete task ${input.taskId}` };
+    }
+    emit(db, {
+        type: 'task:complete',
+        content: `${input.agentId} completed: ${task.title}`,
+        agent_id: input.agentId,
+        task_id: input.taskId,
+        plan_id: task.plan_id,
+    });
+    return { success: true, message: `Completed task: ${task.title}` };
+}

package/dist/mcp/tools/worktreeCleanup.d.ts

@@ -0,0 +1,38 @@
+/**
+ * hivemind_worktree_cleanup - Clean up stale worktrees
+ */
+export declare const worktreeCleanupTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            dryRun: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type WorktreeCleanupInput = {
+    project: string;
+    dryRun?: boolean;
+};
+export type WorktreeCleanupResult = {
+    checked: number;
+    removed: string[];
+    kept: string[];
+    dryRun: boolean;
+};
+export declare function executeWorktreeCleanup(input: WorktreeCleanupInput): WorktreeCleanupResult;

package/dist/mcp/tools/worktreeCleanup.js

@@ -0,0 +1,67 @@
+/**
+ * hivemind_worktree_cleanup - Clean up stale worktrees
+ */
+import { existsSync } from 'fs';
+import { getConnection } from '../../db/getConnection';
+import { getAllWorktrees } from '../../worktrees/getAllWorktrees';
+import { removeWorktree } from '../../worktrees/removeWorktree';
+import { emit } from '../../events/emit';
+export const worktreeCleanupTool = {
+    name: 'hivemind_worktree_cleanup',
+    description: 'Clean up stale worktrees from hivemind database',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Preview without deleting',
+            },
+        },
+        required: ['project'],
+    },
+};
+export function executeWorktreeCleanup(input) {
+    const db = getConnection(input.project);
+    const worktrees = getAllWorktrees(db);
+    const removed = [];
+    const kept = [];
+    for (const wt of worktrees) {
+        const exists = existsSync(wt.path);
+        if (!exists) {
+            if (!input.dryRun) {
+                removeWorktree(db, wt.id);
+                emit(db, {
+                    type: 'worktree:stale',
+                    worktree_id: wt.id,
+                    branch: wt.branch ?? undefined,
+                    content: `Worktree removed: ${wt.path} (path gone)`,
+                    metadata: {
+                        path: wt.path,
+                        branch: wt.branch,
+                        last_seen: wt.last_seen,
+                    },
+                });
+            }
+            removed.push(`${wt.id} (${wt.path})`);
+        }
+        else {
+            kept.push(`${wt.id} (${wt.path})`);
+        }
+    }
+    return {
+        checked: worktrees.length,
+        removed,
+        kept,
+        dryRun: input.dryRun ?? false,
+    };
+}

package/dist/plans/createPlan.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Plan, CreatePlanInput } from './types';
+/**
+ * Create a new plan
+ */
+export declare function createPlan(db: Database, input: CreatePlanInput): Plan;

package/dist/plans/createPlan.js

@@ -0,0 +1,29 @@
+import { makePlanId } from '../ids/makePlanId';
+import { sanitizeLabel } from '../ids/sanitizeLabel';
+import { now } from '../datetime/now';
+/**
+ * Create a new plan
+ */
+export function createPlan(db, input) {
+    const { id, hex } = makePlanId(input.label);
+    const label = input.label ? sanitizeLabel(input.label) : null;
+    const timestamp = now();
+    const stmt = db.prepare(`
+    INSERT INTO plans (id, hex, label, title, description, status, branch, worktree_id, claude_session_id, created_at, created_by)
+    VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, hex, label, input.title, input.description ?? null, input.branch ?? null, input.worktree_id ?? null, input.claude_session_id ?? null, timestamp, input.created_by ?? null);
+    return {
+        id,
+        hex,
+        label,
+        title: input.title,
+        description: input.description ?? null,
+        status: 'active',
+        branch: input.branch ?? null,
+        worktree_id: input.worktree_id ?? null,
+        claude_session_id: input.claude_session_id ?? null,
+        created_at: timestamp,
+        created_by: input.created_by ?? null,
+    };
+}

package/dist/plans/getActivePlans.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Plan } from './types';
+/**
+ * Get all active plans
+ */
+export declare function getActivePlans(db: Database): Plan[];

package/dist/plans/getActivePlans.js

@@ -0,0 +1,11 @@
+/**
+ * Get all active plans
+ */
+export function getActivePlans(db) {
+    const stmt = db.prepare(`
+    SELECT * FROM plans
+    WHERE status = 'active'
+    ORDER BY created_at DESC
+  `);
+    return stmt.all();
+}

package/dist/plans/getPlan.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Plan } from './types';
+/**
+ * Get a plan by ID
+ */
+export declare function getPlan(db: Database, planId: string): Plan | null;

package/dist/plans/getPlan.js

@@ -0,0 +1,7 @@
+/**
+ * Get a plan by ID
+ */
+export function getPlan(db, planId) {
+    const stmt = db.prepare('SELECT * FROM plans WHERE id = ?');
+    return stmt.get(planId) ?? null;
+}

package/dist/plans/index.d.ts

@@ -0,0 +1,5 @@
+export type { PlanStatus, Plan, CreatePlanInput } from './types';
+export { createPlan } from './createPlan';
+export { getPlan } from './getPlan';
+export { getActivePlans } from './getActivePlans';
+export { updatePlanStatus } from './updatePlanStatus';

package/dist/plans/index.js

@@ -0,0 +1,5 @@
+// CRUD
+export { createPlan } from './createPlan';
+export { getPlan } from './getPlan';
+export { getActivePlans } from './getActivePlans';
+export { updatePlanStatus } from './updatePlanStatus';

package/dist/plans/plans.test.d.ts

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