@inixiative/hivemind 0.1.0

package/dist/db/constants.js

@@ -0,0 +1,6 @@
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Base hivemind directory: ~/.hivemind
+ */
+export const HIVEMIND_BASE = process.env.HIVEMIND_BASE || join(homedir(), '.hivemind');

package/dist/db/db.test.d.ts

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

package/dist/db/db.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'bun:test';
+import { createTestDb, cleanupAllTestDbs } from '../test/setup';
+import { buildAgent, buildPlan, buildTask } from '../test/factories';
+import { nextEventSeq } from './nextEventSeq';
+import { nextTaskSeq } from './nextTaskSeq';
+describe('SQLite Database', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    afterAll(() => {
+        cleanupAllTestDbs();
+    });
+    describe('schema initialization', () => {
+        it('creates all required tables', () => {
+            const tables = testDb.db
+                .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`)
+                .all();
+            const tableNames = tables.map((t) => t.name);
+            expect(tableNames).toContain('agents');
+            expect(tableNames).toContain('worktrees');
+            expect(tableNames).toContain('plans');
+            expect(tableNames).toContain('tasks');
+            expect(tableNames).toContain('events');
+        });
+        it('creates indexes', () => {
+            const indexes = testDb.db
+                .prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'`)
+                .all();
+            expect(indexes.length).toBeGreaterThan(0);
+        });
+    });
+    describe('WAL mode', () => {
+        it('uses WAL journal mode', () => {
+            const result = testDb.db.query('PRAGMA journal_mode').get();
+            expect(result.journal_mode).toBe('wal');
+        });
+    });
+    describe('basic CRUD operations', () => {
+        it('can insert and select agents', () => {
+            const { agent } = buildAgent(testDb.db, { label: 'test' });
+            const retrieved = testDb.db.prepare(`SELECT * FROM agents WHERE id = ?`).get(agent.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe(agent.id);
+            expect(retrieved.status).toBe('active');
+        });
+        it('can insert and select plans', () => {
+            const { plan } = buildPlan(testDb.db, { title: 'Test Plan' });
+            const retrieved = testDb.db.prepare(`SELECT * FROM plans WHERE id = ?`).get(plan.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.title).toBe('Test Plan');
+        });
+        it('can insert and select tasks', () => {
+            const { task } = buildTask(testDb.db, { title: 'Test Task' });
+            const retrieved = testDb.db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(task.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved.title).toBe('Test Task');
+            expect(retrieved.status).toBe('pending');
+        });
+        it('can insert and select events', () => {
+            const { agent } = buildAgent(testDb.db);
+            const eventId = 'evt_abc123_1';
+            testDb.db
+                .prepare(`INSERT INTO events (id, hex, seq, timestamp, agent_id, event_type, content)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .run(eventId, 'abc123', 1, '2024/01/01 00:00:00 UTC', agent.id, 'note', 'Test event');
+            const event = testDb.db.prepare(`SELECT * FROM events WHERE id = ?`).get(eventId);
+            expect(event).toBeDefined();
+            expect(event.event_type).toBe('note');
+            expect(event.content).toBe('Test event');
+        });
+    });
+    describe('foreign key constraints', () => {
+        it('enforces task->plan foreign key', () => {
+            expect(() => {
+                testDb.db
+                    .prepare(`INSERT INTO tasks (id, plan_hex, seq, plan_id, title, status)
+             VALUES (?, ?, ?, ?, ?, ?)`)
+                    .run('tsk_test01_01', 'test01', '01', 'nonexistent_plan', 'Test Task', 'pending');
+            }).toThrow();
+        });
+    });
+});
+describe('nextEventSeq', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    it('returns 1 for first event', () => {
+        const seq = nextEventSeq(testDb.db);
+        expect(seq).toBe(1);
+    });
+    it('increments sequence atomically', () => {
+        const seq1 = nextEventSeq(testDb.db);
+        const seq2 = nextEventSeq(testDb.db);
+        const seq3 = nextEventSeq(testDb.db);
+        expect(seq1).toBe(1);
+        expect(seq2).toBe(2);
+        expect(seq3).toBe(3);
+    });
+});
+describe('nextTaskSeq', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    it('returns 1 for first task in plan', () => {
+        const { plan } = buildPlan(testDb.db);
+        const seq = nextTaskSeq(testDb.db, plan.id);
+        expect(seq).toBe(1);
+    });
+    it('increments sequence as tasks are added', () => {
+        const { plan } = buildPlan(testDb.db);
+        // Insert first task using factory
+        buildTask(testDb.db, { plan, title: 'Task 1' });
+        const seq = nextTaskSeq(testDb.db, plan.id);
+        expect(seq).toBe(2);
+    });
+    it('only counts top-level tasks (not subtasks)', () => {
+        const { plan } = buildPlan(testDb.db);
+        const { task: parentTask } = buildTask(testDb.db, { plan, title: 'Task 1' });
+        // Insert a subtask manually (factories don't support this yet)
+        const planHex = parentTask.id.split('_')[1];
+        testDb.db
+            .prepare(`INSERT INTO tasks (id, plan_hex, seq, plan_id, title, status, parent_task_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(`tsk_${planHex}_001.1`, planHex, '001.1', plan.id, 'Subtask 1', 'pending', parentTask.id);
+        // Should still be 2 (subtask doesn't count)
+        const seq = nextTaskSeq(testDb.db, plan.id);
+        expect(seq).toBe(2);
+    });
+});

package/dist/db/ensureProjectDirs.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Ensure all project directories exist
+ */
+export declare function ensureProjectDirs(projectName: string): void;

package/dist/db/ensureProjectDirs.js

@@ -0,0 +1,12 @@
+import { mkdirSync } from 'fs';
+import { getProjectPaths } from './getProjectPaths';
+/**
+ * Ensure all project directories exist
+ */
+export function ensureProjectDirs(projectName) {
+    const paths = getProjectPaths(projectName);
+    mkdirSync(paths.projectDir, { recursive: true });
+    mkdirSync(paths.journalDir, { recursive: true });
+    mkdirSync(paths.plansDir, { recursive: true });
+    mkdirSync(paths.agentsDir, { recursive: true });
+}

package/dist/db/getConnection.d.ts

@@ -0,0 +1,19 @@
+import { Database } from 'bun:sqlite';
+/**
+ * Get database connection for a project
+ *
+ * Caches connections and initializes if needed
+ */
+export declare function getConnection(projectName: string): Database;
+/**
+ * Close and clear a cached connection
+ *
+ * Call this before deleting/resetting the database
+ */
+export declare function closeConnection(projectName: string): void;
+/**
+ * Set a connection in the cache
+ *
+ * Used after reset to cache the new connection
+ */
+export declare function setConnection(projectName: string, db: Database): void;

package/dist/db/getConnection.js

@@ -0,0 +1,51 @@
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'fs';
+import { getProjectPaths } from './getProjectPaths';
+import { initializeDb } from './initializeDb';
+const connections = new Map();
+/**
+ * Get database connection for a project
+ *
+ * Caches connections and initializes if needed
+ */
+export function getConnection(projectName) {
+    if (connections.has(projectName)) {
+        return connections.get(projectName);
+    }
+    const paths = getProjectPaths(projectName);
+    let db;
+    if (existsSync(paths.dbPath)) {
+        db = new Database(paths.dbPath);
+        db.exec('PRAGMA journal_mode = WAL');
+    }
+    else {
+        db = initializeDb(projectName);
+    }
+    connections.set(projectName, db);
+    return db;
+}
+/**
+ * Close and clear a cached connection
+ *
+ * Call this before deleting/resetting the database
+ */
+export function closeConnection(projectName) {
+    const conn = connections.get(projectName);
+    if (conn) {
+        try {
+            conn.close();
+        }
+        catch {
+            // Ignore close errors
+        }
+        connections.delete(projectName);
+    }
+}
+/**
+ * Set a connection in the cache
+ *
+ * Used after reset to cache the new connection
+ */
+export function setConnection(projectName, db) {
+    connections.set(projectName, db);
+}

package/dist/db/getCurrentProject.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get current project name
+ *
+ * Priority:
+ *   1. HIVEMIND_PROJECT env var
+ *   2. Current directory name
+ */
+export declare function getCurrentProject(): string;

package/dist/db/getCurrentProject.js

@@ -0,0 +1,14 @@
+/**
+ * Get current project name
+ *
+ * Priority:
+ *   1. HIVEMIND_PROJECT env var
+ *   2. Current directory name
+ */
+export function getCurrentProject() {
+    if (process.env.HIVEMIND_PROJECT) {
+        return process.env.HIVEMIND_PROJECT;
+    }
+    const cwd = process.cwd();
+    return cwd.split('/').pop() || 'default';
+}

package/dist/db/getProjectPaths.d.ts

@@ -0,0 +1,21 @@
+export type ProjectPaths = {
+    projectDir: string;
+    dbPath: string;
+    streamPath: string;
+    journalDir: string;
+    plansDir: string;
+    agentsDir: string;
+};
+/**
+ * Get project-specific paths
+ *
+ * Structure:
+ *   ~/.hivemind/
+ *     └── claude_hivemind_<project>/
+ *         ├── hivemind.db
+ *         ├── stream.jsonl
+ *         ├── journal/
+ *         ├── plans/
+ *         └── agents/
+ */
+export declare function getProjectPaths(projectName: string): ProjectPaths;

package/dist/db/getProjectPaths.js

@@ -0,0 +1,26 @@
+import { join } from 'path';
+import { HIVEMIND_BASE } from './constants';
+/**
+ * Get project-specific paths
+ *
+ * Structure:
+ *   ~/.hivemind/
+ *     └── claude_hivemind_<project>/
+ *         ├── hivemind.db
+ *         ├── stream.jsonl
+ *         ├── journal/
+ *         ├── plans/
+ *         └── agents/
+ */
+export function getProjectPaths(projectName) {
+    const sanitized = projectName.toLowerCase().replace(/[^a-z0-9]/g, '_');
+    const projectDir = join(HIVEMIND_BASE, `claude_hivemind_${sanitized}`);
+    return {
+        projectDir,
+        dbPath: join(projectDir, 'hivemind.db'),
+        streamPath: join(projectDir, 'stream.jsonl'),
+        journalDir: join(projectDir, 'journal'),
+        plansDir: join(projectDir, 'plans'),
+        agentsDir: join(projectDir, 'agents'),
+    };
+}

package/dist/db/index.d.ts

@@ -0,0 +1,10 @@
+export { HIVEMIND_BASE } from './constants';
+export { getProjectPaths } from './getProjectPaths';
+export type { ProjectPaths } from './getProjectPaths';
+export { getCurrentProject } from './getCurrentProject';
+export { ensureProjectDirs } from './ensureProjectDirs';
+export { initializeDb } from './initializeDb';
+export { getConnection } from './getConnection';
+export { nextEventSeq } from './nextEventSeq';
+export { nextTaskSeq } from './nextTaskSeq';
+export { nextSubtaskSeq } from './nextSubtaskSeq';

package/dist/db/index.js

@@ -0,0 +1,13 @@
+// Constants
+export { HIVEMIND_BASE } from './constants';
+// Paths
+export { getProjectPaths } from './getProjectPaths';
+export { getCurrentProject } from './getCurrentProject';
+export { ensureProjectDirs } from './ensureProjectDirs';
+// Database
+export { initializeDb } from './initializeDb';
+export { getConnection } from './getConnection';
+// Sequences
+export { nextEventSeq } from './nextEventSeq';
+export { nextTaskSeq } from './nextTaskSeq';
+export { nextSubtaskSeq } from './nextSubtaskSeq';

package/dist/db/initializeDb.d.ts

@@ -0,0 +1,7 @@
+import { Database } from 'bun:sqlite';
+/**
+ * Initialize the database for a project
+ *
+ * Creates directories and runs schema
+ */
+export declare function initializeDb(projectName: string): Database;

package/dist/db/initializeDb.js

@@ -0,0 +1,23 @@
+import { Database } from 'bun:sqlite';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { getProjectPaths } from './getProjectPaths';
+import { ensureProjectDirs } from './ensureProjectDirs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Initialize the database for a project
+ *
+ * Creates directories and runs schema
+ */
+export function initializeDb(projectName) {
+    ensureProjectDirs(projectName);
+    const paths = getProjectPaths(projectName);
+    const db = new Database(paths.dbPath);
+    // Enable WAL mode for better concurrent access
+    db.exec('PRAGMA journal_mode = WAL');
+    // Run schema
+    const schema = readFileSync(join(__dirname, 'schema.sql'), 'utf-8');
+    db.exec(schema);
+    return db;
+}

package/dist/db/nextEventSeq.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Get next event sequence number (atomic increment)
+ */
+export declare function nextEventSeq(db: Database): number;

package/dist/db/nextEventSeq.js

@@ -0,0 +1,13 @@
+/**
+ * Get next event sequence number (atomic increment)
+ */
+export function nextEventSeq(db) {
+    const stmt = db.prepare(`
+    UPDATE sequences
+    SET value = value + 1
+    WHERE name = 'events'
+    RETURNING value
+  `);
+    const result = stmt.get();
+    return result.value;
+}

package/dist/db/nextSubtaskSeq.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Get next subtask sequence number for a parent task
+ */
+export declare function nextSubtaskSeq(db: Database, parentTaskId: string): number;

package/dist/db/nextSubtaskSeq.js

@@ -0,0 +1,12 @@
+/**
+ * Get next subtask sequence number for a parent task
+ */
+export function nextSubtaskSeq(db, parentTaskId) {
+    const stmt = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM tasks
+    WHERE parent_task_id = ?
+  `);
+    const result = stmt.get(parentTaskId);
+    return result.count + 1;
+}

package/dist/db/nextTaskSeq.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Get next task sequence number for a plan
+ */
+export declare function nextTaskSeq(db: Database, planId: string): number;

package/dist/db/nextTaskSeq.js

@@ -0,0 +1,13 @@
+/**
+ * Get next task sequence number for a plan
+ */
+export function nextTaskSeq(db, planId) {
+    const stmt = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM tasks
+    WHERE plan_id = ?
+    AND seq NOT LIKE '%.%'
+  `);
+    const result = stmt.get(planId);
+    return result.count + 1;
+}

package/dist/db/resetDb.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reset the database for a project
+ *
+ * Deletes the database files and recreates with fresh schema.
+ * Use this when schema changes require a clean slate.
+ */
+export declare function resetDb(projectName: string): {
+    deleted: string[];
+    created: string;
+};

package/dist/db/resetDb.js

@@ -0,0 +1,36 @@
+import { existsSync, unlinkSync } from 'fs';
+import { getProjectPaths } from './getProjectPaths';
+import { initializeDb } from './initializeDb';
+import { closeConnection, setConnection } from './getConnection';
+/**
+ * Reset the database for a project
+ *
+ * Deletes the database files and recreates with fresh schema.
+ * Use this when schema changes require a clean slate.
+ */
+export function resetDb(projectName) {
+    const paths = getProjectPaths(projectName);
+    const deleted = [];
+    // Close any existing connection first
+    closeConnection(projectName);
+    // Delete database files (main + WAL files)
+    const filesToDelete = [
+        paths.dbPath,
+        `${paths.dbPath}-wal`,
+        `${paths.dbPath}-shm`,
+    ];
+    for (const file of filesToDelete) {
+        if (existsSync(file)) {
+            unlinkSync(file);
+            deleted.push(file);
+        }
+    }
+    // Reinitialize with fresh schema
+    const db = initializeDb(projectName);
+    // Cache the new connection
+    setConnection(projectName, db);
+    return {
+        deleted,
+        created: paths.dbPath,
+    };
+}

package/dist/events/emit.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { EventInput, Event } from './types';
+/**
+ * Emit an event to the hivemind log
+ */
+export declare function emit(db: Database, input: EventInput): Event;

package/dist/events/emit.js

@@ -0,0 +1,31 @@
+import { makeEventId } from '../ids/makeEventId';
+import { now } from '../datetime/now';
+import { nextEventSeq } from '../db/nextEventSeq';
+/**
+ * Emit an event to the hivemind log
+ */
+export function emit(db, input) {
+    const seq = nextEventSeq(db);
+    const { id, hex } = makeEventId(seq);
+    const timestamp = now();
+    const stmt = db.prepare(`
+    INSERT INTO events (id, hex, seq, timestamp, agent_id, plan_id, task_id, worktree_id, branch, event_type, content, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const agentId = input.agent_id ?? 'system';
+    stmt.run(id, hex, seq, timestamp, agentId, input.plan_id ?? null, input.task_id ?? null, input.worktree_id ?? null, input.branch ?? null, input.type, input.content ?? null, input.metadata ? JSON.stringify(input.metadata) : null);
+    return {
+        id,
+        hex,
+        seq,
+        timestamp,
+        agent_id: agentId,
+        plan_id: input.plan_id ?? null,
+        task_id: input.task_id ?? null,
+        worktree_id: input.worktree_id ?? null,
+        branch: input.branch ?? null,
+        event_type: input.type,
+        content: input.content ?? null,
+        metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+    };
+}

package/dist/events/events.test.d.ts

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