@inixiative/hivemind 0.1.0

package/dist/cli/init.js

@@ -0,0 +1,71 @@
+/**
+ * hivemind init - Register a project with hivemind
+ *
+ * Run from a project directory to:
+ * 1. Create database in ~/.hivemind/<project>/
+ * 2. Set up .claude/settings.json hooks
+ * 3. Add CLAUDE.md instructions
+ */
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { getGitInfo } from '../git/getGitInfo';
+import { initializeDb } from '../db/initializeDb';
+import { getProjectPaths } from '../db/getProjectPaths';
+import { initClaudeConfig } from '../init/claudeConfig';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HIVEMIND_ROOT = join(__dirname, '../..');
+export async function initCommand(options) {
+    // Determine project name
+    const gitInfo = getGitInfo();
+    let projectName = options.project;
+    if (!projectName) {
+        if (gitInfo.isRepo && gitInfo.repoName) {
+            projectName = gitInfo.repoName;
+        }
+        else {
+            projectName = process.cwd().split('/').pop() || 'default';
+        }
+    }
+    console.log(`hivemind init: ${projectName}\n`);
+    // 1. Initialize database
+    console.log('[1/2] Database');
+    const paths = getProjectPaths(projectName);
+    const db = initializeDb(projectName);
+    // Get stats
+    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;
+    db.close();
+    console.log(`  path: ${paths.dbPath}`);
+    if (agentCount > 0 || planCount > 0) {
+        console.log(`  stats: ${agentCount} agents, ${planCount} plans, ${eventCount} events`);
+    }
+    else {
+        console.log('  status: created');
+    }
+    // 2. Set up Claude config (hooks + CLAUDE.md)
+    if (options.hooks !== false) {
+        console.log('\n[2/2] Claude Config');
+        const projectRoot = gitInfo.root || process.cwd();
+        const configResult = initClaudeConfig(projectRoot, projectName, HIVEMIND_ROOT);
+        if (configResult.created.length > 0) {
+            console.log(`  created: ${configResult.created.join(', ')}`);
+        }
+        if (configResult.updated.length > 0) {
+            console.log(`  updated: ${configResult.updated.join(', ')}`);
+        }
+        if (configResult.created.length === 0 && configResult.updated.length === 0) {
+            console.log('  status: already configured');
+        }
+    }
+    else {
+        console.log('\n[2/2] Claude Config (skipped)');
+    }
+    // Success
+    console.log('\n---');
+    console.log('Project registered! Restart Claude Code to activate.');
+    console.log('\nNext session will:');
+    console.log('  - Auto-register as a hivemind agent');
+    console.log('  - Have hivemind MCP tools available');
+    console.log('  - Follow 001-style task numbering');
+}

package/dist/cli/install.d.ts

@@ -0,0 +1,8 @@
+/**
+ * hivemind install - One-time global setup
+ *
+ * Run from hivemind directory to:
+ * 1. Install dependencies
+ * 2. Register MCP server globally
+ */
+export declare function installCommand(): Promise<void>;

package/dist/cli/install.js

@@ -0,0 +1,47 @@
+/**
+ * hivemind install - One-time global setup
+ *
+ * Run from hivemind directory to:
+ * 1. Install dependencies
+ * 2. Register MCP server globally
+ */
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { $ } from 'bun';
+import { registerMcpServer, configurePermissions } from './registerMcp';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HIVEMIND_ROOT = join(__dirname, '../..');
+export async function installCommand() {
+    console.log('hivemind install\n');
+    // 1. Install dependencies
+    console.log('[1/3] Dependencies');
+    try {
+        await $ `cd ${HIVEMIND_ROOT} && bun install`.quiet();
+        console.log('  installed');
+    }
+    catch (error) {
+        console.error('  failed to install dependencies');
+        process.exit(1);
+    }
+    // 2. Register MCP server
+    console.log('\n[2/3] MCP Server');
+    const mcpResult = await registerMcpServer(HIVEMIND_ROOT);
+    console.log(`  ${mcpResult.message}`);
+    if (!mcpResult.success) {
+        process.exit(1);
+    }
+    // 3. Configure permissions (auto-approve structured tools)
+    console.log('\n[3/3] Permissions');
+    const permResult = configurePermissions();
+    console.log(`  ${permResult.message}`);
+    if (permResult.added.length > 0) {
+        console.log('  auto-approved: status, events, query, claim/start/complete task');
+        console.log('  requires approval: emit (ad-hoc messages)');
+    }
+    // Success
+    console.log('\n---');
+    console.log('Hivemind installed globally!');
+    console.log('\nNext steps:');
+    console.log('  cd <your-project>');
+    console.log('  bun run /path/to/hivemind init');
+}

package/dist/cli/join.d.ts

@@ -0,0 +1,9 @@
+/**
+ * hivemind join - Join the hivemind as an agent
+ */
+type JoinOptions = {
+    label?: string;
+    context?: string;
+};
+export declare function joinCommand(options: JoinOptions): Promise<void>;
+export {};

package/dist/cli/join.js

@@ -0,0 +1,38 @@
+/**
+ * hivemind join - Join the hivemind as an agent
+ */
+import { executeRegister } from '../mcp/tools/register';
+import { executeStatus } from '../mcp/tools/status';
+import { getGitInfo } from '../git/getGitInfo';
+export async function joinCommand(options) {
+    const gitInfo = getGitInfo();
+    if (!gitInfo.isRepo || !gitInfo.repoName) {
+        console.log('Not in a git repository. Run from a git project directory.');
+        return;
+    }
+    console.log(`hivemind join: ${gitInfo.repoName}\n`);
+    try {
+        const result = executeRegister({
+            project: gitInfo.repoName,
+            label: options.label,
+            contextSummary: options.context,
+        });
+        console.log(`Agent: ${result.agentId}`);
+        if (result.branch) {
+            console.log(`Branch: ${result.branch}`);
+        }
+        // Show other active agents
+        const status = executeStatus({ project: gitInfo.repoName });
+        const otherAgents = status.activeAgents?.filter((a) => a.id !== result.agentId) || [];
+        if (otherAgents.length > 0) {
+            console.log('\nOther active agents:');
+            for (const agent of otherAgents) {
+                console.log(`  ${agent.id}`);
+            }
+        }
+        console.log('\nJoined successfully!');
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/cli/registerMcp.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Register hivemind MCP server with Claude Code
+ */
+type RegisterResult = {
+    success: boolean;
+    message: string;
+    alreadyRegistered?: boolean;
+};
+/**
+ * Register the hivemind MCP server using `claude mcp add`
+ */
+export declare function registerMcpServer(hivemindRoot: string): Promise<RegisterResult>;
+/**
+ * Check if hivemind MCP server is registered
+ */
+export declare function isMcpRegistered(): Promise<boolean>;
+type PermissionResult = {
+    success: boolean;
+    message: string;
+    added: string[];
+    alreadyPresent: string[];
+};
+/**
+ * Configure auto-approve permissions for hivemind tools
+ * Adds structured tools to ~/.claude/settings.json permissions.allow
+ */
+export declare function configurePermissions(): PermissionResult;
+export {};

package/dist/cli/registerMcp.js

@@ -0,0 +1,138 @@
+/**
+ * Register hivemind MCP server with Claude Code
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { $ } from 'bun';
+/**
+ * Hivemind tools that should be auto-approved (structured operations)
+ * These have predictable semantics and don't require human oversight
+ */
+const AUTO_APPROVED_TOOLS = [
+    // Lifecycle
+    'mcp__hivemind__hivemind_setup',
+    'mcp__hivemind__hivemind_register',
+    // Read-only queries
+    'mcp__hivemind__hivemind_status',
+    'mcp__hivemind__hivemind_events',
+    'mcp__hivemind__hivemind_query',
+    // Task management (structured operations)
+    'mcp__hivemind__hivemind_claim_task',
+    'mcp__hivemind__hivemind_start_task',
+    'mcp__hivemind__hivemind_complete_task',
+    // Maintenance
+    'mcp__hivemind__hivemind_worktree_cleanup',
+];
+// NOT auto-approved (require human oversight):
+// - hivemind_emit: allows arbitrary messages to other agents
+// - hivemind_reset: destructive operation that wipes the database
+/**
+ * Register the hivemind MCP server using `claude mcp add`
+ */
+export async function registerMcpServer(hivemindRoot) {
+    const serverPath = join(hivemindRoot, 'src/mcp/server.ts');
+    const command = `bun run ${serverPath}`;
+    try {
+        // Check if already registered
+        const listResult = await $ `claude mcp list 2>/dev/null`.text();
+        if (listResult.includes('hivemind')) {
+            return {
+                success: true,
+                message: 'already registered',
+                alreadyRegistered: true,
+            };
+        }
+        // Register the MCP server
+        await $ `claude mcp add --transport stdio hivemind -- ${command}`.quiet();
+        return {
+            success: true,
+            message: `registered: hivemind -> ${command}`,
+        };
+    }
+    catch (error) {
+        // Check if claude CLI is available
+        try {
+            await $ `which claude`.quiet();
+        }
+        catch {
+            return {
+                success: false,
+                message: 'claude CLI not found. Install Claude Code first.',
+            };
+        }
+        // Some other error
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            message: `failed: ${msg}`,
+        };
+    }
+}
+/**
+ * Check if hivemind MCP server is registered
+ */
+export async function isMcpRegistered() {
+    try {
+        const result = await $ `claude mcp list 2>/dev/null`.text();
+        return result.includes('hivemind');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Configure auto-approve permissions for hivemind tools
+ * Adds structured tools to ~/.claude/settings.json permissions.allow
+ */
+export function configurePermissions() {
+    const claudeDir = join(homedir(), '.claude');
+    const settingsPath = join(claudeDir, 'settings.json');
+    // Ensure ~/.claude exists
+    if (!existsSync(claudeDir)) {
+        mkdirSync(claudeDir, { recursive: true });
+    }
+    // Load existing settings
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            // Invalid JSON, start fresh
+        }
+    }
+    // Ensure permissions.allow exists
+    if (!settings.permissions) {
+        settings.permissions = {};
+    }
+    const permissions = settings.permissions;
+    if (!Array.isArray(permissions.allow)) {
+        permissions.allow = [];
+    }
+    const allowList = permissions.allow;
+    // Track what we add
+    const added = [];
+    const alreadyPresent = [];
+    for (const tool of AUTO_APPROVED_TOOLS) {
+        if (allowList.includes(tool)) {
+            alreadyPresent.push(tool);
+        }
+        else {
+            allowList.push(tool);
+            added.push(tool);
+        }
+    }
+    // Write back if we added anything
+    if (added.length > 0) {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+    }
+    return {
+        success: true,
+        message: added.length > 0
+            ? `added ${added.length} permission rules`
+            : 'permissions already configured',
+        added,
+        alreadyPresent,
+    };
+}

package/dist/cli/status.d.ts

@@ -0,0 +1,8 @@
+/**
+ * hivemind status - Show hivemind status for a project
+ */
+type StatusOptions = {
+    project?: string;
+};
+export declare function statusCommand(options: StatusOptions): Promise<void>;
+export {};

package/dist/cli/status.js

@@ -0,0 +1,82 @@
+/**
+ * hivemind status - Show hivemind status for a project
+ */
+import { existsSync } from 'fs';
+import { getGitInfo } from '../git/getGitInfo';
+import { getProjectPaths } from '../db/getProjectPaths';
+import { getConnection } from '../db/getConnection';
+import { getActiveAgents } from '../agents/getActiveAgents';
+import { getActivePlans } from '../plans/getActivePlans';
+import { getRecentEvents } from '../events/getRecentEvents';
+import { isMcpRegistered } from './registerMcp';
+import { formatDatetime } from '../datetime/formatDatetime';
+export async function statusCommand(options) {
+    // Determine project
+    const gitInfo = getGitInfo();
+    let projectName = options.project;
+    if (!projectName) {
+        if (gitInfo.isRepo && gitInfo.repoName) {
+            projectName = gitInfo.repoName;
+        }
+        else {
+            projectName = process.cwd().split('/').pop() || 'default';
+        }
+    }
+    console.log(`hivemind status: ${projectName}\n`);
+    // Check if database exists
+    const paths = getProjectPaths(projectName);
+    if (!existsSync(paths.dbPath)) {
+        console.log('  not initialized');
+        console.log('  run: hivemind init');
+        return;
+    }
+    // Database stats
+    const db = getConnection(projectName);
+    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;
+    console.log('Database');
+    console.log(`  path: ${paths.dbPath}`);
+    console.log(`  agents: ${agentCount}, plans: ${planCount}, events: ${eventCount}`);
+    // Active agents
+    const activeAgents = getActiveAgents(db);
+    console.log('\nActive Agents');
+    if (activeAgents.length === 0) {
+        console.log('  none');
+    }
+    else {
+        for (const agent of activeAgents) {
+            const context = agent.context_summary ? ` - ${agent.context_summary}` : '';
+            console.log(`  ${agent.id}${context}`);
+        }
+    }
+    // Active plans
+    const activePlans = getActivePlans(db);
+    console.log('\nActive Plans');
+    if (activePlans.length === 0) {
+        console.log('  none');
+    }
+    else {
+        for (const plan of activePlans) {
+            console.log(`  ${plan.id}: ${plan.title}`);
+        }
+    }
+    // Recent events
+    const recentEvents = getRecentEvents(db, 5);
+    console.log('\nRecent Events');
+    if (recentEvents.length === 0) {
+        console.log('  none');
+    }
+    else {
+        for (const event of recentEvents) {
+            const time = formatDatetime(new Date(event.timestamp));
+            const content = event.content?.slice(0, 50) || '';
+            console.log(`  [${time}] ${event.event_type}: ${content}`);
+        }
+    }
+    db.close();
+    // MCP status
+    console.log('\nMCP Server');
+    const mcpRegistered = await isMcpRegistered();
+    console.log(`  registered: ${mcpRegistered ? 'yes' : 'no'}`);
+}

package/dist/cli/watch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * hivemind watch - Live tail of events
+ */
+export declare function watchCommand(options: {
+    project?: string;
+}): Promise<void>;

package/dist/cli/watch.js

@@ -0,0 +1,68 @@
+/**
+ * hivemind watch - Live tail of events
+ */
+import { getConnection } from '../db/getConnection';
+import { getRecentEvents } from '../events/getRecentEvents';
+import { getGitInfo } from '../git/getGitInfo';
+const EVENT_ICONS = {
+    'task:claim': '🎯',
+    'task:start': '▶️',
+    'task:complete': '✅',
+    'task:block': '🚫',
+    'decision': '💡',
+    'question': '❓',
+    'answer': '💬',
+    'note': '📝',
+    'context': '📋',
+    'agent:register': '👋',
+    'agent:unregister': '👋',
+    'plan:create': '📊',
+    'plan:sync': '🔄',
+};
+function formatEvent(event) {
+    const icon = EVENT_ICONS[event.event_type] || '•';
+    const time = event.timestamp.split(' ')[1]; // Just the time part
+    const agent = event.agent_id?.replace('agt_', '') || 'system';
+    const content = event.content ? ` ${event.content}` : '';
+    return `${icon} [${time}] ${agent} ${event.event_type}${content}`;
+}
+export async function watchCommand(options) {
+    let project = options.project;
+    if (!project) {
+        const gitInfo = getGitInfo();
+        if (!gitInfo.isRepo || !gitInfo.repoName) {
+            console.error('Not in a git repository. Use --project <name>');
+            process.exit(1);
+        }
+        project = gitInfo.repoName;
+    }
+    const db = getConnection(project);
+    let lastSeq = 0;
+    // Get initial last seq
+    const initial = getRecentEvents(db, 1);
+    if (initial.length > 0) {
+        lastSeq = initial[0].seq;
+    }
+    console.log(`👁️  Watching hivemind events for: ${project}`);
+    console.log(`   Press Ctrl+C to stop\n`);
+    // Poll loop
+    const POLL_INTERVAL = 1000; // 1 second
+    while (true) {
+        try {
+            const stmt = db.prepare(`
+        SELECT * FROM events
+        WHERE seq > ?
+        ORDER BY seq ASC
+      `);
+            const newEvents = stmt.all(lastSeq);
+            for (const event of newEvents) {
+                console.log(formatEvent(event));
+                lastSeq = event.seq;
+            }
+        }
+        catch {
+            // DB might be locked, just retry
+        }
+        await Bun.sleep(POLL_INTERVAL);
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env bun
+/**
+ * Hivemind CLI
+ *
+ * Usage:
+ *   bun run src/cli.ts install           # One-time global setup
+ *   bun run src/cli.ts init              # Register current project
+ *   bun run src/cli.ts status            # Show project status
+ *   bun run src/cli.ts join              # Join as an agent
+ *   bun run src/cli.ts watch             # Live tail of events
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+/**
+ * Hivemind CLI
+ *
+ * Usage:
+ *   bun run src/cli.ts install           # One-time global setup
+ *   bun run src/cli.ts init              # Register current project
+ *   bun run src/cli.ts status            # Show project status
+ *   bun run src/cli.ts join              # Join as an agent
+ *   bun run src/cli.ts watch             # Live tail of events
+ */
+import { Command } from 'commander';
+import { installCommand } from './cli/install';
+import { initCommand } from './cli/init';
+import { statusCommand } from './cli/status';
+import { joinCommand } from './cli/join';
+import { watchCommand } from './cli/watch';
+const program = new Command();
+program
+    .name('hivemind')
+    .description('Multi-agent coordination system for Claude Code')
+    .version('0.1.0');
+program
+    .command('install')
+    .description('One-time setup: install dependencies and register MCP server')
+    .action(installCommand);
+program
+    .command('init')
+    .description('Register current project with hivemind')
+    .option('-p, --project <name>', 'Project name (defaults to git repo name)')
+    .option('--no-hooks', 'Skip session hook setup')
+    .action(initCommand);
+program
+    .command('status')
+    .description('Show hivemind status for the current project')
+    .option('-p, --project <name>', 'Project name')
+    .action(statusCommand);
+program
+    .command('join')
+    .description('Join the hivemind as an agent')
+    .option('-l, --label <label>', 'Agent label')
+    .option('-c, --context <summary>', 'Context summary')
+    .action(joinCommand);
+program
+    .command('watch')
+    .description('Live tail of hivemind events')
+    .option('-p, --project <name>', 'Project name')
+    .action(watchCommand);
+program.parse();

package/dist/coordinator/coordinator.test.d.ts

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