@inixiative/hivemind 0.1.0

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

@@ -0,0 +1,62 @@
+import type { EventType } from '../../events/types';
+export declare const emitEventTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            planId: {
+                type: string;
+                description: string;
+            };
+            taskId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type EmitEventInput = {
+    project: string;
+    agentId?: string;
+    sessionId?: string;
+    type: EventType;
+    content: string;
+    planId?: string;
+    taskId?: string;
+};
+export type EmitEventResult = {
+    success: boolean;
+    eventId?: string;
+    agentId?: string;
+    timestamp?: string;
+    message: string;
+};
+export declare function executeEmitEvent(input: EmitEventInput): EmitEventResult;

package/dist/mcp/tools/emitEvent.js

@@ -0,0 +1,84 @@
+import { getConnection } from '../../db/getConnection';
+import { getProjectPaths } from '../../db/getProjectPaths';
+import { emit } from '../../events/emit';
+import { getAgentBySessionId } from '../../agents/getAgentBySessionId';
+import { ensureCoordinator } from '../../coordinator/spawn';
+import { getBranch } from '../../git/getBranch';
+export const emitEventTool = {
+    name: 'hivemind_emit',
+    description: 'Emit an event to the hivemind log for other agents to see. ' +
+        'Can use either agentId directly or sessionId to look up the agent.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name',
+            },
+            agentId: {
+                type: 'string',
+                description: "This agent's ID (optional if sessionId provided)",
+            },
+            sessionId: {
+                type: 'string',
+                description: 'Claude session ID to look up agent (alternative to agentId)',
+            },
+            type: {
+                type: 'string',
+                description: 'Event type (decision, question, answer, context, note, etc.)',
+            },
+            content: {
+                type: 'string',
+                description: 'Event content/message',
+            },
+            planId: {
+                type: 'string',
+                description: 'Optional plan ID this event relates to',
+            },
+            taskId: {
+                type: 'string',
+                description: 'Optional task ID this event relates to',
+            },
+        },
+        required: ['project', 'type', 'content'],
+    },
+};
+export function executeEmitEvent(input) {
+    const db = getConnection(input.project);
+    const paths = getProjectPaths(input.project);
+    // Ensure coordinator is running
+    ensureCoordinator({ project: input.project, dataDir: paths.projectDir });
+    // Resolve agent ID - either directly provided or looked up by session
+    let agentId = input.agentId;
+    if (!agentId && input.sessionId) {
+        const agent = getAgentBySessionId(db, input.sessionId);
+        agentId = agent?.id;
+    }
+    if (!agentId) {
+        return {
+            success: false,
+            message: 'No agent found - provide agentId or valid sessionId',
+        };
+    }
+    const event = emit(db, {
+        agent_id: agentId,
+        plan_id: input.planId,
+        task_id: input.taskId,
+        branch: getBranch() ?? undefined,
+        type: input.type,
+        content: input.content,
+    });
+    return {
+        success: true,
+        eventId: event.id,
+        agentId,
+        timestamp: event.timestamp,
+        message: `Event ${event.id} emitted`,
+    };
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Events MCP tool - simple event tailing
+ */
+export declare const eventsTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            since: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type EventsInput = {
+    project: string;
+    limit?: number;
+    since?: string;
+    type?: string;
+};
+export type EventsResult = {
+    events: Array<{
+        id: string;
+        type: string;
+        content: string;
+        agent_id?: string;
+        plan_id?: string;
+        task_id?: string;
+        created_at: string;
+    }>;
+    count: number;
+    latest_timestamp?: string;
+};
+export declare function executeEvents(input: EventsInput): EventsResult;

package/dist/mcp/tools/events.js

@@ -0,0 +1,56 @@
+/**
+ * Events MCP tool - simple event tailing
+ */
+import { getConnection } from '../../db/getConnection';
+import { getRecentEvents } from '../../events/getRecentEvents';
+import { getEventsSince } from '../../events/getEventsSince';
+export const eventsTool = {
+    name: 'hivemind_events',
+    description: 'Get recent events from the hivemind. Use to see what other agents are doing.',
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: { type: 'string', description: 'Project name' },
+            limit: { type: 'number', description: 'Max events to return (default 20)' },
+            since: { type: 'string', description: 'ISO timestamp - get events after this time' },
+            type: { type: 'string', description: 'Filter by event type (e.g., "task:claim", "decision")' },
+        },
+        required: ['project'],
+    },
+};
+export function executeEvents(input) {
+    const db = getConnection(input.project);
+    const limit = input.limit ?? 20;
+    let events;
+    if (input.since) {
+        events = getEventsSince(db, input.since, limit);
+    }
+    else {
+        events = getRecentEvents(db, limit);
+    }
+    // Filter by type if specified
+    if (input.type) {
+        events = events.filter((e) => e.event_type === input.type);
+    }
+    // Format for output
+    const formatted = events.map((e) => ({
+        id: e.id,
+        type: e.event_type,
+        content: e.content ?? '',
+        agent_id: e.agent_id ?? undefined,
+        plan_id: e.plan_id ?? undefined,
+        task_id: e.task_id ?? undefined,
+        created_at: e.timestamp,
+    }));
+    return {
+        events: formatted,
+        count: formatted.length,
+        latest_timestamp: formatted[0]?.created_at,
+    };
+}

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

@@ -0,0 +1,18 @@
+export { setupTool, executeSetup } from './setup';
+export type { SetupInput, SetupResult } from './setup';
+export { registerTool, executeRegister } from './register';
+export type { RegisterInput, RegisterResult } from './register';
+export { emitEventTool, executeEmitEvent } from './emitEvent';
+export type { EmitEventInput, EmitEventResult } from './emitEvent';
+export { queryTool, executeQuery } from './query';
+export type { QueryInput, QueryResult } from './query';
+export { statusTool, executeStatus } from './status';
+export type { StatusInput, StatusResult } from './status';
+export { resetTool, executeReset } from './reset';
+export type { ResetInput, ResetResult } from './reset';
+export { claimTaskTool, executeClaimTask, startTaskTool, executeStartTask, completeTaskTool, executeCompleteTask, } from './tasks';
+export type { ClaimTaskInput, StartTaskInput, CompleteTaskInput } from './tasks';
+export { eventsTool, executeEvents } from './events';
+export type { EventsInput, EventsResult } from './events';
+export { worktreeCleanupTool, executeWorktreeCleanup } from './worktreeCleanup';
+export type { WorktreeCleanupInput, WorktreeCleanupResult } from './worktreeCleanup';

package/dist/mcp/tools/index.js

@@ -0,0 +1,13 @@
+// Tool definitions
+export { setupTool, executeSetup } from './setup';
+export { registerTool, executeRegister } from './register';
+export { emitEventTool, executeEmitEvent } from './emitEvent';
+export { queryTool, executeQuery } from './query';
+export { statusTool, executeStatus } from './status';
+export { resetTool, executeReset } from './reset';
+// Task management
+export { claimTaskTool, executeClaimTask, startTaskTool, executeStartTask, completeTaskTool, executeCompleteTask, } from './tasks';
+// Events tailing
+export { eventsTool, executeEvents } from './events';
+// Worktree management
+export { worktreeCleanupTool, executeWorktreeCleanup } from './worktreeCleanup';

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

@@ -0,0 +1,54 @@
+import type { Event } from '../../events/types';
+export declare const queryTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            planId: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+            branch: {
+                type: string;
+                description: string;
+            };
+            since: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type QueryInput = {
+    project: string;
+    planId?: string;
+    agentId?: string;
+    branch?: string;
+    since?: string;
+    limit?: number;
+};
+export type QueryResult = {
+    events: Event[];
+    count: number;
+};
+export declare function executeQuery(input: QueryInput): QueryResult;

package/dist/mcp/tools/query.js

@@ -0,0 +1,70 @@
+import { getConnection } from '../../db/getConnection';
+import { getRecentEvents } from '../../events/getRecentEvents';
+import { getEventsByPlan } from '../../events/getEventsByPlan';
+import { getEventsByAgent } from '../../events/getEventsByAgent';
+import { getEventsByBranch } from '../../events/getEventsByBranch';
+import { getEventsSince } from '../../events/getEventsSince';
+export const queryTool = {
+    name: 'hivemind_query',
+    description: 'Query events from the hivemind log.',
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name',
+            },
+            planId: {
+                type: 'string',
+                description: 'Filter by plan ID',
+            },
+            agentId: {
+                type: 'string',
+                description: 'Filter by agent ID',
+            },
+            branch: {
+                type: 'string',
+                description: 'Filter by branch name',
+            },
+            since: {
+                type: 'string',
+                description: 'Get events since this timestamp (yyyy/mm/dd hh:mm:ss TZ)',
+            },
+            limit: {
+                type: 'number',
+                description: 'Max events to return (default 50)',
+            },
+        },
+        required: ['project'],
+    },
+};
+export function executeQuery(input) {
+    const db = getConnection(input.project);
+    const limit = input.limit ?? 50;
+    let events;
+    if (input.since) {
+        events = getEventsSince(db, input.since, limit);
+    }
+    else if (input.planId) {
+        events = getEventsByPlan(db, input.planId, limit);
+    }
+    else if (input.agentId) {
+        events = getEventsByAgent(db, input.agentId, limit);
+    }
+    else if (input.branch) {
+        events = getEventsByBranch(db, input.branch, limit);
+    }
+    else {
+        events = getRecentEvents(db, limit);
+    }
+    return {
+        events,
+        count: events.length,
+    };
+}

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

@@ -0,0 +1,47 @@
+export declare const registerTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            label: {
+                type: string;
+                description: string;
+            };
+            sessionId: {
+                type: string;
+                description: string;
+            };
+            contextSummary: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type RegisterInput = {
+    project: string;
+    label?: string;
+    sessionId?: string;
+    pid?: number;
+    contextSummary?: string;
+};
+export type RegisterResult = {
+    agentId: string;
+    project: string;
+    worktreeId?: string;
+    branch?: string;
+    message: string;
+};
+export declare function executeRegister(input: RegisterInput): RegisterResult;

package/dist/mcp/tools/register.js

@@ -0,0 +1,79 @@
+import { getConnection } from '../../db/getConnection';
+import { registerAgent } from '../../agents/registerAgent';
+import { emit } from '../../events/emit';
+import { syncWorktreesFromGit } from '../../worktrees/syncWorktreesFromGit';
+import { getWorktreeByPath } from '../../worktrees/getWorktreeByPath';
+import { getCurrentWorktree } from '../../git/getCurrentWorktree';
+import { getBranch } from '../../git/getBranch';
+export const registerTool = {
+    name: 'hivemind_register',
+    description: 'Register this Claude agent with the hivemind. Call this at the start of a session.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name (required)',
+            },
+            label: {
+                type: 'string',
+                description: 'Optional label for this agent (e.g., "alice", "backend")',
+            },
+            sessionId: {
+                type: 'string',
+                description: 'Claude session ID for --resume support',
+            },
+            contextSummary: {
+                type: 'string',
+                description: 'Brief description of what this agent knows/is working on',
+            },
+        },
+        required: ['project'],
+    },
+};
+export function executeRegister(input) {
+    const db = getConnection(input.project);
+    // Sync worktrees from git
+    syncWorktreesFromGit(db);
+    // Find current worktree
+    const gitWorktree = getCurrentWorktree();
+    let worktreeId;
+    if (gitWorktree) {
+        const dbWorktree = getWorktreeByPath(db, gitWorktree.path);
+        worktreeId = dbWorktree?.id;
+    }
+    const branch = getBranch() ?? undefined;
+    // Register the agent
+    const agent = registerAgent(db, {
+        label: input.label,
+        pid: input.pid,
+        session_id: input.sessionId,
+        worktree_id: worktreeId,
+        context_summary: input.contextSummary,
+    });
+    // Emit registration event
+    emit(db, {
+        agent_id: agent.id,
+        worktree_id: worktreeId,
+        branch,
+        type: 'agent:register',
+        content: input.contextSummary,
+        metadata: {
+            sessionId: input.sessionId,
+            label: input.label,
+        },
+    });
+    return {
+        agentId: agent.id,
+        project: input.project,
+        worktreeId,
+        branch,
+        message: `Agent ${agent.id} registered to hivemind:${input.project}${branch ? ` on branch ${branch}` : ''}`,
+    };
+}

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

@@ -0,0 +1,38 @@
+export declare const resetTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            confirm: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export type ResetInput = {
+    project: string;
+    confirm: boolean;
+};
+export type ResetResult = {
+    success: boolean;
+    message: string;
+    deleted?: string[];
+    created?: string;
+};
+/**
+ * Execute reset - deletes database and recreates with fresh schema
+ */
+export declare function executeReset(input: ResetInput): ResetResult;

package/dist/mcp/tools/reset.js

@@ -0,0 +1,56 @@
+import { existsSync } from 'fs';
+import { getProjectPaths } from '../../db/getProjectPaths';
+import { resetDb } from '../../db/resetDb';
+import { formatDatetime } from '../../datetime/formatDatetime';
+export const resetTool = {
+    name: 'hivemind_reset',
+    description: 'Reset the hivemind database. Deletes all data and recreates with fresh schema. Use for schema migrations.',
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+    inputSchema: {
+        type: 'object',
+        properties: {
+            project: {
+                type: 'string',
+                description: 'Project name (required)',
+            },
+            confirm: {
+                type: 'boolean',
+                description: 'Must be true to confirm reset. This is destructive!',
+            },
+        },
+        required: ['project', 'confirm'],
+    },
+};
+/**
+ * Execute reset - deletes database and recreates with fresh schema
+ */
+export function executeReset(input) {
+    // Safety check
+    if (!input.confirm) {
+        return {
+            success: false,
+            message: 'Reset not confirmed. Set confirm: true to proceed. WARNING: This deletes all data!',
+        };
+    }
+    const paths = getProjectPaths(input.project);
+    // Check if database exists
+    if (!existsSync(paths.dbPath)) {
+        return {
+            success: false,
+            message: `No database found for project "${input.project}" at ${paths.dbPath}`,
+        };
+    }
+    // Perform reset
+    const result = resetDb(input.project);
+    return {
+        success: true,
+        message: `hivemind reset: ${input.project}\ndeleted: ${result.deleted.length} files\ncreated: ${result.created}\ntimestamp: ${formatDatetime()}`,
+        deleted: result.deleted,
+        created: result.created,
+    };
+}

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

@@ -0,0 +1,42 @@
+export declare const setupTool: {
+    name: string;
+    description: string;
+    annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    inputSchema: {
+        type: string;
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            useGit: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export type SetupInput = {
+    project?: string;
+    useGit?: boolean;
+};
+export type SetupResult = {
+    needsInput: boolean;
+    gitInfo?: {
+        repoName: string | null;
+        branch: string | null;
+        root: string | null;
+    };
+    message?: string;
+    project?: string;
+    dbPath?: string;
+};
+/**
+ * Execute setup - may return prompt for user input
+ */
+export declare function executeSetup(input: SetupInput): SetupResult;