@inixiative/hivemind 0.1.0

package/dist/events/events.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'bun:test';
+import { createTestDb, cleanupAllTestDbs } from '../test/setup';
+import { buildAgent, buildPlan, buildTask } from '../test/factories';
+import { emit } from './emit';
+import { getEventsSince } from './getEventsSince';
+import { getEventsByPlan } from './getEventsByPlan';
+import { getEventsByAgent } from './getEventsByAgent';
+import { getRecentEvents } from './getRecentEvents';
+describe('Events Module', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    afterAll(() => {
+        cleanupAllTestDbs();
+    });
+    describe('emit', () => {
+        it('creates a new event', () => {
+            const { agent } = buildAgent(testDb.db, { label: 'test' });
+            const event = emit(testDb.db, {
+                agent_id: agent.id,
+                type: 'note',
+                content: 'Test note',
+            });
+            expect(event.id).toMatch(/^evt_[a-f0-9]{6}_\d+$/);
+            expect(event.agent_id).toBe(agent.id);
+            expect(event.event_type).toBe('note');
+            expect(event.content).toBe('Test note');
+            expect(event.timestamp).toBeDefined();
+        });
+        it('creates event with plan and task', () => {
+            const { task, plan, agent } = buildTask(testDb.db);
+            const event = emit(testDb.db, {
+                agent_id: agent.id,
+                plan_id: plan.id,
+                task_id: task.id,
+                type: 'task:start',
+                content: 'Starting task',
+            });
+            expect(event.plan_id).toBe(plan.id);
+            expect(event.task_id).toBe(task.id);
+        });
+        it('creates event with branch and worktree', () => {
+            const { agent } = buildAgent(testDb.db);
+            const event = emit(testDb.db, {
+                agent_id: agent.id,
+                branch: 'feature/auth',
+                type: 'context',
+                content: 'Working on auth',
+            });
+            expect(event.branch).toBe('feature/auth');
+        });
+        it('stores metadata as JSON', () => {
+            const { agent } = buildAgent(testDb.db);
+            const event = emit(testDb.db, {
+                agent_id: agent.id,
+                type: 'decision',
+                content: 'Chose option A',
+                metadata: { reason: 'simpler', alternatives: ['B', 'C'] },
+            });
+            expect(event.metadata).toBe('{"reason":"simpler","alternatives":["B","C"]}');
+            expect(JSON.parse(event.metadata)).toEqual({ reason: 'simpler', alternatives: ['B', 'C'] });
+        });
+        it('increments sequence for same hex', () => {
+            const { agent } = buildAgent(testDb.db);
+            const event1 = emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'First' });
+            const event2 = emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Second' });
+            const seq1 = parseInt(event1.id.split('_')[2]);
+            const seq2 = parseInt(event2.id.split('_')[2]);
+            expect(seq2).toBe(seq1 + 1);
+        });
+    });
+    describe('getEventsSince', () => {
+        it('returns events after sequence number', () => {
+            const { agent } = buildAgent(testDb.db);
+            const event1 = emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'First' });
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Second' });
+            const events = getEventsSince(testDb.db, event1.seq);
+            expect(events).toHaveLength(1);
+            expect(events[0].content).toBe('Second');
+        });
+        it('returns events after timestamp', () => {
+            const { agent } = buildAgent(testDb.db);
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'First' });
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Second' });
+            const events = getEventsSince(testDb.db, '2020/01/01 00:00:00 UTC');
+            expect(events.length).toBeGreaterThanOrEqual(2);
+        });
+        it('returns empty array when no events after sequence', () => {
+            const { agent } = buildAgent(testDb.db);
+            const event = emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Only event' });
+            const events = getEventsSince(testDb.db, event.seq);
+            expect(events).toHaveLength(0);
+        });
+        it('returns empty array when no events after timestamp', () => {
+            const { agent } = buildAgent(testDb.db);
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Old event' });
+            const events = getEventsSince(testDb.db, '2099/01/01 00:00:00 UTC');
+            expect(events).toHaveLength(0);
+        });
+    });
+    describe('getEventsByPlan', () => {
+        it('returns events for specific plan', () => {
+            const { plan, agent } = buildPlan(testDb.db);
+            emit(testDb.db, { agent_id: agent.id, plan_id: plan.id, type: 'plan:create', content: 'Created' });
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Unrelated' });
+            const events = getEventsByPlan(testDb.db, plan.id);
+            expect(events).toHaveLength(1);
+            expect(events[0].plan_id).toBe(plan.id);
+        });
+    });
+    describe('getEventsByAgent', () => {
+        it('returns events for specific agent', () => {
+            const { agent: agent1 } = buildAgent(testDb.db, { label: 'one' });
+            const { agent: agent2 } = buildAgent(testDb.db, { label: 'two' });
+            emit(testDb.db, { agent_id: agent1.id, type: 'note', content: 'Agent 1 event' });
+            emit(testDb.db, { agent_id: agent2.id, type: 'note', content: 'Agent 2 event' });
+            const events = getEventsByAgent(testDb.db, agent1.id);
+            expect(events).toHaveLength(1);
+            expect(events[0].agent_id).toBe(agent1.id);
+        });
+    });
+    describe('getRecentEvents', () => {
+        it('returns limited recent events', () => {
+            const { agent } = buildAgent(testDb.db);
+            for (let i = 0; i < 10; i++) {
+                emit(testDb.db, { agent_id: agent.id, type: 'note', content: `Event ${i}` });
+            }
+            const events = getRecentEvents(testDb.db, 5);
+            expect(events).toHaveLength(5);
+        });
+        it('returns events in chronological order (oldest first)', () => {
+            const { agent } = buildAgent(testDb.db);
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'First' });
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Second' });
+            emit(testDb.db, { agent_id: agent.id, type: 'note', content: 'Third' });
+            const events = getRecentEvents(testDb.db, 3);
+            expect(events[0].content).toBe('First');
+            expect(events[2].content).toBe('Third');
+        });
+    });
+});

package/dist/events/getEventsByAgent.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get all events for a specific agent
+ */
+export declare function getEventsByAgent(db: Database, agentId: string, limit?: number): Event[];

package/dist/events/getEventsByAgent.js

@@ -0,0 +1,14 @@
+/**
+ * Get all events for a specific agent
+ */
+export function getEventsByAgent(db, agentId, limit) {
+    const sql = limit
+        ? `SELECT * FROM events WHERE agent_id = ? ORDER BY seq DESC LIMIT ?`
+        : `SELECT * FROM events WHERE agent_id = ? ORDER BY seq ASC`;
+    const stmt = db.prepare(sql);
+    if (limit) {
+        const results = stmt.all(agentId, limit);
+        return results.reverse();
+    }
+    return stmt.all(agentId);
+}

package/dist/events/getEventsByBranch.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get events for a specific branch
+ */
+export declare function getEventsByBranch(db: Database, branch: string, limit?: number): Event[];

package/dist/events/getEventsByBranch.js

@@ -0,0 +1,12 @@
+/**
+ * Get events for a specific branch
+ */
+export function getEventsByBranch(db, branch, limit = 100) {
+    const stmt = db.prepare(`
+    SELECT * FROM events
+    WHERE branch = ?
+    ORDER BY seq DESC
+    LIMIT ?
+  `);
+    return stmt.all(branch, limit);
+}

package/dist/events/getEventsByPlan.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get all events for a specific plan
+ */
+export declare function getEventsByPlan(db: Database, planId: string, limit?: number): Event[];

package/dist/events/getEventsByPlan.js

@@ -0,0 +1,14 @@
+/**
+ * Get all events for a specific plan
+ */
+export function getEventsByPlan(db, planId, limit) {
+    const sql = limit
+        ? `SELECT * FROM events WHERE plan_id = ? ORDER BY seq DESC LIMIT ?`
+        : `SELECT * FROM events WHERE plan_id = ? ORDER BY seq ASC`;
+    const stmt = db.prepare(sql);
+    if (limit) {
+        const results = stmt.all(planId, limit);
+        return results.reverse(); // Return in chronological order
+    }
+    return stmt.all(planId);
+}

package/dist/events/getEventsByWorktree.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get events for a specific worktree
+ */
+export declare function getEventsByWorktree(db: Database, worktreeId: string, limit?: number): Event[];

package/dist/events/getEventsByWorktree.js

@@ -0,0 +1,12 @@
+/**
+ * Get events for a specific worktree
+ */
+export function getEventsByWorktree(db, worktreeId, limit = 100) {
+    const stmt = db.prepare(`
+    SELECT * FROM events
+    WHERE worktree_id = ?
+    ORDER BY seq DESC
+    LIMIT ?
+  `);
+    return stmt.all(worktreeId, limit);
+}

package/dist/events/getEventsSince.d.ts

@@ -0,0 +1,12 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get all events since a given point
+ *
+ * @param since - Either a sequence number (number) or timestamp (string)
+ *   - number: Get events with seq > since (exclusive, efficient for polling)
+ *   - string: Get events with timestamp > since (for time-based queries)
+ *
+ * Used for polling: "What happened since I last checked?"
+ */
+export declare function getEventsSince(db: Database, since: number | string, limit?: number): Event[];

package/dist/events/getEventsSince.js

@@ -0,0 +1,47 @@
+/**
+ * Get all events since a given point
+ *
+ * @param since - Either a sequence number (number) or timestamp (string)
+ *   - number: Get events with seq > since (exclusive, efficient for polling)
+ *   - string: Get events with timestamp > since (for time-based queries)
+ *
+ * Used for polling: "What happened since I last checked?"
+ */
+export function getEventsSince(db, since, limit) {
+    if (typeof since === 'number') {
+        // Sequence-based query (most efficient for polling)
+        if (limit) {
+            const stmt = db.prepare(`
+        SELECT * FROM events
+        WHERE seq > ?
+        ORDER BY seq ASC
+        LIMIT ?
+      `);
+            return stmt.all(since, limit);
+        }
+        const stmt = db.prepare(`
+      SELECT * FROM events
+      WHERE seq > ?
+      ORDER BY seq ASC
+    `);
+        return stmt.all(since);
+    }
+    else {
+        // Timestamp-based query
+        if (limit) {
+            const stmt = db.prepare(`
+        SELECT * FROM events
+        WHERE timestamp > ?
+        ORDER BY seq ASC
+        LIMIT ?
+      `);
+            return stmt.all(since, limit);
+        }
+        const stmt = db.prepare(`
+      SELECT * FROM events
+      WHERE timestamp > ?
+      ORDER BY seq ASC
+    `);
+        return stmt.all(since);
+    }
+}

package/dist/events/getRecentEvents.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { Event } from './types';
+/**
+ * Get the most recent events
+ */
+export declare function getRecentEvents(db: Database, limit?: number): Event[];

package/dist/events/getRecentEvents.js

@@ -0,0 +1,12 @@
+/**
+ * Get the most recent events
+ */
+export function getRecentEvents(db, limit = 50) {
+    const stmt = db.prepare(`
+    SELECT * FROM events
+    ORDER BY seq DESC
+    LIMIT ?
+  `);
+    const results = stmt.all(limit);
+    return results.reverse(); // Chronological order
+}

package/dist/events/index.d.ts

@@ -0,0 +1,8 @@
+export type { EventType, Event, EventInput } from './types';
+export { emit } from './emit';
+export { getEventsSince } from './getEventsSince';
+export { getEventsByPlan } from './getEventsByPlan';
+export { getEventsByAgent } from './getEventsByAgent';
+export { getEventsByWorktree } from './getEventsByWorktree';
+export { getEventsByBranch } from './getEventsByBranch';
+export { getRecentEvents } from './getRecentEvents';

package/dist/events/index.js

@@ -0,0 +1,9 @@
+// Emit
+export { emit } from './emit';
+// Query
+export { getEventsSince } from './getEventsSince';
+export { getEventsByPlan } from './getEventsByPlan';
+export { getEventsByAgent } from './getEventsByAgent';
+export { getEventsByWorktree } from './getEventsByWorktree';
+export { getEventsByBranch } from './getEventsByBranch';
+export { getRecentEvents } from './getRecentEvents';

package/dist/events/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Event types in the hivemind system
+ */
+export type EventType = 'agent:register' | 'agent:unregister' | 'agent:dead' | 'worktree:register' | 'worktree:switch' | 'worktree:stale' | 'plan:create' | 'plan:sync' | 'plan:join' | 'plan:leave' | 'plan:complete' | 'task:create' | 'task:claim' | 'task:unclaim' | 'task:start' | 'task:block' | 'task:unblock' | 'task:complete' | 'decision' | 'question' | 'answer' | 'context' | 'note';
+/**
+ * Event record as stored in DB
+ */
+export type Event = {
+    id: string;
+    hex: string;
+    seq: number;
+    timestamp: string;
+    agent_id: string;
+    plan_id: string | null;
+    task_id: string | null;
+    worktree_id: string | null;
+    branch: string | null;
+    event_type: EventType;
+    content: string | null;
+    metadata: string | null;
+};
+/**
+ * Input for creating an event
+ */
+export type EventInput = {
+    agent_id?: string;
+    plan_id?: string;
+    task_id?: string;
+    worktree_id?: string;
+    branch?: string;
+    type: EventType;
+    content?: string;
+    metadata?: Record<string, unknown>;
+};

package/dist/events/types.js

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

package/dist/git/getBranch.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get current git branch name
+ */
+export declare function getBranch(): string | null;

package/dist/git/getBranch.js

@@ -0,0 +1,14 @@
+import { execSync } from 'child_process';
+/**
+ * Get current git branch name
+ */
+export function getBranch() {
+    try {
+        return execSync('git branch --show-current', { stdio: 'pipe' })
+            .toString()
+            .trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/git/getCurrentWorktree.d.ts

@@ -0,0 +1,5 @@
+import { type Worktree } from './getWorktrees';
+/**
+ * Get the worktree for current directory
+ */
+export declare function getCurrentWorktree(): Worktree | null;

package/dist/git/getCurrentWorktree.js

@@ -0,0 +1,15 @@
+import { getWorktrees } from './getWorktrees';
+/**
+ * Get the worktree for current directory
+ */
+export function getCurrentWorktree() {
+    const cwd = process.cwd();
+    const worktrees = getWorktrees();
+    // Find worktree that contains current directory
+    for (const wt of worktrees) {
+        if (cwd.startsWith(wt.path)) {
+            return wt;
+        }
+    }
+    return null;
+}

package/dist/git/getGitInfo.d.ts

@@ -0,0 +1,10 @@
+export type GitInfo = {
+    isRepo: boolean;
+    repoName: string | null;
+    branch: string | null;
+    root: string | null;
+};
+/**
+ * Get all git info for current directory
+ */
+export declare function getGitInfo(): GitInfo;

package/dist/git/getGitInfo.js

@@ -0,0 +1,23 @@
+import { isGitRepo } from './isGitRepo';
+import { getRepoName } from './getRepoName';
+import { getBranch } from './getBranch';
+import { getRepoRoot } from './getRepoRoot';
+/**
+ * Get all git info for current directory
+ */
+export function getGitInfo() {
+    if (!isGitRepo()) {
+        return {
+            isRepo: false,
+            repoName: null,
+            branch: null,
+            root: null,
+        };
+    }
+    return {
+        isRepo: true,
+        repoName: getRepoName(),
+        branch: getBranch(),
+        root: getRepoRoot(),
+    };
+}

package/dist/git/getRepoName.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get repository name from git remote or directory
+ */
+export declare function getRepoName(): string | null;

package/dist/git/getRepoName.js

@@ -0,0 +1,32 @@
+import { execSync } from 'child_process';
+/**
+ * Get repository name from git remote or directory
+ */
+export function getRepoName() {
+    try {
+        // Try to get from remote origin
+        const remote = execSync('git remote get-url origin', { stdio: 'pipe' })
+            .toString()
+            .trim();
+        // Extract repo name from URL
+        // git@github.com:user/repo.git -> repo
+        // https://github.com/user/repo.git -> repo
+        const match = remote.match(/\/([^/]+?)(\.git)?$/);
+        if (match) {
+            return match[1];
+        }
+    }
+    catch {
+        // No remote, try repo root directory name
+        try {
+            const root = execSync('git rev-parse --show-toplevel', { stdio: 'pipe' })
+                .toString()
+                .trim();
+            return root.split('/').pop() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/git/getRepoRoot.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get git repository root path
+ */
+export declare function getRepoRoot(): string | null;

package/dist/git/getRepoRoot.js

@@ -0,0 +1,14 @@
+import { execSync } from 'child_process';
+/**
+ * Get git repository root path
+ */
+export function getRepoRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', { stdio: 'pipe' })
+            .toString()
+            .trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/git/getWorktrees.d.ts

@@ -0,0 +1,10 @@
+export type Worktree = {
+    path: string;
+    branch: string | null;
+    commit: string;
+    isMain: boolean;
+};
+/**
+ * Get all git worktrees for the repository
+ */
+export declare function getWorktrees(): Worktree[];

package/dist/git/getWorktrees.js

@@ -0,0 +1,39 @@
+import { execSync } from 'child_process';
+/**
+ * Get all git worktrees for the repository
+ */
+export function getWorktrees() {
+    try {
+        const output = execSync('git worktree list --porcelain', { stdio: 'pipe' })
+            .toString()
+            .trim();
+        if (!output)
+            return [];
+        const worktrees = [];
+        let current = {};
+        for (const line of output.split('\n')) {
+            if (line.startsWith('worktree ')) {
+                if (current.path) {
+                    worktrees.push(current);
+                }
+                current = { path: line.slice(9), isMain: worktrees.length === 0 };
+            }
+            else if (line.startsWith('HEAD ')) {
+                current.commit = line.slice(5);
+            }
+            else if (line.startsWith('branch ')) {
+                current.branch = line.slice(7).replace('refs/heads/', '');
+            }
+            else if (line === 'detached') {
+                current.branch = null;
+            }
+        }
+        if (current.path) {
+            worktrees.push(current);
+        }
+        return worktrees;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/git/index.d.ts

@@ -0,0 +1,9 @@
+export { isGitRepo } from './isGitRepo';
+export { getRepoName } from './getRepoName';
+export { getBranch } from './getBranch';
+export { getRepoRoot } from './getRepoRoot';
+export { getGitInfo } from './getGitInfo';
+export type { GitInfo } from './getGitInfo';
+export { getWorktrees } from './getWorktrees';
+export type { Worktree } from './getWorktrees';
+export { getCurrentWorktree } from './getCurrentWorktree';

package/dist/git/index.js

@@ -0,0 +1,7 @@
+export { isGitRepo } from './isGitRepo';
+export { getRepoName } from './getRepoName';
+export { getBranch } from './getBranch';
+export { getRepoRoot } from './getRepoRoot';
+export { getGitInfo } from './getGitInfo';
+export { getWorktrees } from './getWorktrees';
+export { getCurrentWorktree } from './getCurrentWorktree';

package/dist/git/isGitRepo.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if current directory is inside a git repo
+ */
+export declare function isGitRepo(): boolean;

package/dist/git/isGitRepo.js

@@ -0,0 +1,13 @@
+import { execSync } from 'child_process';
+/**
+ * Check if current directory is inside a git repo
+ */
+export function isGitRepo() {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { runSessionStartHook } from './sessionStart';

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export { runSessionStartHook } from './sessionStart';

package/dist/hooks/sessionStart.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Session start hook - auto-join hivemind when starting a Claude session
+ *
+ * Installation: Add to .claude/settings.json:
+ *   "hooks": {
+ *     "SessionStart": [{
+ *       "matcher": "startup",
+ *       "hooks": [{ "type": "command", "command": "bun run /path/to/hivemind/src/hooks/sessionStart.ts" }]
+ *     }]
+ *   }
+ *
+ * Claude Code passes JSON via stdin with session_id, transcript_path, cwd, etc.
+ */
+type HookInput = {
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    permission_mode?: string;
+};
+export declare function runSessionStartHook(input?: HookInput): void;
+export {};