@inixiative/hivemind 0.1.0

package/dist/tasks/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Task status values
+ */
+export type TaskStatus = 'pending' | 'claimed' | 'in_progress' | 'blocked' | 'done';
+/**
+ * Task record as stored in DB
+ */
+export type Task = {
+    id: string;
+    plan_hex: string;
+    seq: string;
+    label: string | null;
+    plan_id: string;
+    title: string;
+    description: string | null;
+    status: TaskStatus;
+    branch: string | null;
+    worktree_id: string | null;
+    claimed_by: string | null;
+    claimed_at: string | null;
+    completed_at: string | null;
+    outcome: string | null;
+    parent_task_id: string | null;
+};
+/**
+ * Input for creating a task
+ */
+export type CreateTaskInput = {
+    plan_id: string;
+    title: string;
+    description?: string;
+    branch?: string;
+    worktree_id?: string;
+    parent_task_id?: string;
+    label?: string;
+};

package/dist/tasks/types.js

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

package/dist/tasks/unclaimTask.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Unclaim a task (release it back to pending)
+ */
+export declare function unclaimTask(db: Database, taskId: string): boolean;

package/dist/tasks/unclaimTask.js

@@ -0,0 +1,12 @@
+/**
+ * Unclaim a task (release it back to pending)
+ */
+export function unclaimTask(db, taskId) {
+    const stmt = db.prepare(`
+    UPDATE tasks
+    SET status = 'pending', claimed_by = NULL, claimed_at = NULL
+    WHERE id = ? AND status IN ('claimed', 'in_progress', 'blocked')
+  `);
+    const result = stmt.run(taskId);
+    return result.changes > 0;
+}

package/dist/test/factories/agentFactory.d.ts

@@ -0,0 +1,13 @@
+import type { Database } from 'bun:sqlite';
+import type { Agent } from '../../agents/types';
+export type AgentOverrides = {
+    label?: string;
+    context_summary?: string;
+    pid?: number;
+    session_id?: string;
+    worktree_id?: string;
+};
+export type BuildAgentResult = {
+    agent: Agent;
+};
+export declare function buildAgent(db: Database, overrides?: AgentOverrides): BuildAgentResult;

package/dist/test/factories/agentFactory.js

@@ -0,0 +1,5 @@
+import { registerAgent } from '../../agents/registerAgent';
+export function buildAgent(db, overrides = {}) {
+    const agent = registerAgent(db, overrides);
+    return { agent };
+}

package/dist/test/factories/eventFactory.d.ts

@@ -0,0 +1,20 @@
+import type { Database } from 'bun:sqlite';
+import type { Event, EventType } from '../../events/types';
+import type { Agent } from '../../agents/types';
+import type { Plan } from '../../plans/types';
+import type { Task } from '../../tasks/types';
+export type EventOverrides = {
+    type?: EventType;
+    content?: string;
+    agent?: Agent;
+    plan?: Plan;
+    task?: Task;
+    branch?: string;
+    worktree_id?: string;
+    metadata?: Record<string, unknown>;
+};
+export type BuildEventResult = {
+    event: Event;
+    agent: Agent;
+};
+export declare function buildEvent(db: Database, overrides?: EventOverrides): BuildEventResult;

package/dist/test/factories/eventFactory.js

@@ -0,0 +1,16 @@
+import { emit } from '../../events/emit';
+import { buildAgent } from './agentFactory';
+export function buildEvent(db, overrides = {}) {
+    const agent = overrides.agent ?? buildAgent(db).agent;
+    const event = emit(db, {
+        agent_id: agent.id,
+        type: overrides.type ?? 'note',
+        content: overrides.content ?? 'Test event',
+        plan_id: overrides.plan?.id,
+        task_id: overrides.task?.id,
+        worktree_id: overrides.worktree_id,
+        branch: overrides.branch,
+        metadata: overrides.metadata,
+    });
+    return { event, agent };
+}

package/dist/test/factories/factories.test.d.ts

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

package/dist/test/factories/factories.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach, afterAll } from 'bun:test';
+import { createTestDb, cleanupAllTestDbs } from '../setup';
+import { buildAgent } from './agentFactory';
+import { buildPlan } from './planFactory';
+import { buildTask } from './taskFactory';
+import { buildEvent } from './eventFactory';
+describe('Test Factories', () => {
+    let testDb;
+    beforeEach(() => {
+        testDb = createTestDb();
+    });
+    afterEach(() => {
+        testDb.cleanup();
+    });
+    afterAll(() => {
+        cleanupAllTestDbs();
+    });
+    describe('buildAgent', () => {
+        it('creates agent with defaults', () => {
+            const { agent } = buildAgent(testDb.db);
+            expect(agent.id).toMatch(/^agt_[a-f0-9]{6}$/);
+            expect(agent.status).toBe('active');
+        });
+        it('creates agent with label', () => {
+            const { agent } = buildAgent(testDb.db, { label: 'worker' });
+            expect(agent.id).toMatch(/^agt_[a-f0-9]{6}_worker$/);
+            expect(agent.label).toBe('worker');
+        });
+    });
+    describe('buildPlan', () => {
+        it('creates plan and agent', () => {
+            const { plan, agent } = buildPlan(testDb.db);
+            expect(plan.id).toMatch(/^pln_[a-f0-9]{6}$/);
+            expect(plan.title).toBe('Test Plan');
+            expect(plan.created_by).toBe(agent.id);
+        });
+        it('uses existing agent', () => {
+            const { agent: existingAgent } = buildAgent(testDb.db, { label: 'lead' });
+            const { plan, agent } = buildPlan(testDb.db, { agent: existingAgent });
+            expect(plan.created_by).toBe(existingAgent.id);
+            expect(agent.id).toBe(existingAgent.id);
+        });
+        it('accepts custom title', () => {
+            const { plan } = buildPlan(testDb.db, { title: 'Auth Feature' });
+            expect(plan.title).toBe('Auth Feature');
+        });
+    });
+    describe('buildTask', () => {
+        it('creates task with plan and agent', () => {
+            const { task, plan, agent } = buildTask(testDb.db);
+            expect(task.id).toMatch(/^tsk_[a-f0-9]{6}_001$/);
+            expect(task.plan_id).toBe(plan.id);
+            expect(task.status).toBe('pending');
+            expect(plan.created_by).toBe(agent.id);
+        });
+        it('uses existing plan', () => {
+            const { plan: existingPlan, agent: existingAgent } = buildPlan(testDb.db, { title: 'My Plan' });
+            const { task, plan, agent } = buildTask(testDb.db, { plan: existingPlan });
+            expect(task.plan_id).toBe(existingPlan.id);
+            expect(plan.id).toBe(existingPlan.id);
+            expect(agent.id).toBe(existingAgent.id);
+        });
+        it('creates claimed task', () => {
+            const { agent: claimer } = buildAgent(testDb.db, { label: 'claimer' });
+            const { task } = buildTask(testDb.db, {
+                status: 'claimed',
+                claimed_by: claimer,
+            });
+            expect(task.status).toBe('claimed');
+            expect(task.claimed_by).toBe(claimer.id);
+        });
+    });
+    describe('buildEvent', () => {
+        it('creates event with agent', () => {
+            const { event, agent } = buildEvent(testDb.db);
+            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 event');
+        });
+        it('uses existing agent', () => {
+            const { agent: existingAgent } = buildAgent(testDb.db, { label: 'emitter' });
+            const { event, agent } = buildEvent(testDb.db, { agent: existingAgent });
+            expect(event.agent_id).toBe(existingAgent.id);
+            expect(agent.id).toBe(existingAgent.id);
+        });
+        it('creates event with plan and task', () => {
+            const { task, plan, agent } = buildTask(testDb.db);
+            const { event } = buildEvent(testDb.db, {
+                agent,
+                plan,
+                task,
+                type: 'task:start',
+                content: 'Starting work',
+            });
+            expect(event.plan_id).toBe(plan.id);
+            expect(event.task_id).toBe(task.id);
+            expect(event.event_type).toBe('task:start');
+        });
+    });
+});

package/dist/test/factories/index.d.ts

@@ -0,0 +1,4 @@
+export { buildAgent, type AgentOverrides, type BuildAgentResult } from './agentFactory';
+export { buildPlan, type PlanOverrides, type BuildPlanResult } from './planFactory';
+export { buildTask, type TaskOverrides, type BuildTaskResult } from './taskFactory';
+export { buildEvent, type EventOverrides, type BuildEventResult } from './eventFactory';

package/dist/test/factories/index.js

@@ -0,0 +1,4 @@
+export { buildAgent } from './agentFactory';
+export { buildPlan } from './planFactory';
+export { buildTask } from './taskFactory';
+export { buildEvent } from './eventFactory';

package/dist/test/factories/planFactory.d.ts

@@ -0,0 +1,15 @@
+import type { Database } from 'bun:sqlite';
+import type { Plan } from '../../plans/types';
+import type { Agent } from '../../agents/types';
+export type PlanOverrides = {
+    title?: string;
+    label?: string;
+    description?: string;
+    branch?: string;
+    agent?: Agent;
+};
+export type BuildPlanResult = {
+    plan: Plan;
+    agent: Agent;
+};
+export declare function buildPlan(db: Database, overrides?: PlanOverrides): BuildPlanResult;

package/dist/test/factories/planFactory.js

@@ -0,0 +1,14 @@
+import { createPlan } from '../../plans/createPlan';
+import { buildAgent } from './agentFactory';
+export function buildPlan(db, overrides = {}) {
+    const { agent: existingAgent, ...planOverrides } = overrides;
+    const agent = existingAgent ?? buildAgent(db).agent;
+    const plan = createPlan(db, {
+        title: planOverrides.title ?? 'Test Plan',
+        label: planOverrides.label,
+        description: planOverrides.description,
+        branch: planOverrides.branch,
+        created_by: agent.id,
+    });
+    return { plan, agent };
+}

package/dist/test/factories/taskFactory.d.ts

@@ -0,0 +1,22 @@
+import type { Database } from 'bun:sqlite';
+import type { Task, TaskStatus } from '../../tasks/types';
+import type { Plan } from '../../plans/types';
+import type { Agent } from '../../agents/types';
+export type TaskOverrides = {
+    title?: string;
+    description?: string;
+    status?: TaskStatus;
+    claimed_by?: Agent;
+    plan?: Plan;
+    agent?: Agent;
+    branch?: string;
+    worktree_id?: string;
+    parent_task_id?: string;
+    label?: string;
+};
+export type BuildTaskResult = {
+    task: Task;
+    plan: Plan;
+    agent: Agent;
+};
+export declare function buildTask(db: Database, overrides?: TaskOverrides): BuildTaskResult;

package/dist/test/factories/taskFactory.js

@@ -0,0 +1,44 @@
+import { createTask } from '../../tasks/createTask';
+import { buildPlan } from './planFactory';
+export function buildTask(db, overrides = {}) {
+    let plan;
+    let agent;
+    if (overrides.plan) {
+        plan = overrides.plan;
+        const agentRow = db.prepare(`SELECT * FROM agents WHERE id = ?`).get(plan.created_by);
+        agent = overrides.agent ?? agentRow ?? buildPlan(db).agent;
+    }
+    else {
+        const result = buildPlan(db, { agent: overrides.agent });
+        plan = result.plan;
+        agent = result.agent;
+    }
+    const task = createTask(db, {
+        plan_id: plan.id,
+        title: overrides.title ?? 'Test Task',
+        description: overrides.description,
+        branch: overrides.branch,
+        worktree_id: overrides.worktree_id,
+        parent_task_id: overrides.parent_task_id,
+        label: overrides.label,
+    });
+    // Handle status and claimed_by if provided
+    if (overrides.status || overrides.claimed_by) {
+        const updates = [];
+        const values = [];
+        if (overrides.status) {
+            updates.push('status = ?');
+            values.push(overrides.status);
+        }
+        if (overrides.claimed_by) {
+            updates.push('claimed_by = ?', 'claimed_at = ?');
+            values.push(overrides.claimed_by.id, new Date().toISOString());
+        }
+        if (updates.length > 0) {
+            values.push(task.id);
+            db.prepare(`UPDATE tasks SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+        }
+    }
+    const finalTask = db.prepare(`SELECT * FROM tasks WHERE id = ?`).get(task.id);
+    return { task: finalTask, plan, agent };
+}

package/dist/test/multiAgentDemo.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Multi-agent coordination demo
+ *
+ * Task 001 (agt_c88d5b): greeting function
+ * Task 002 (agt_4564e7): farewell function
+ */
+/**
+ * Returns a greeting message from Agent 1
+ * @returns A friendly hello message
+ */
+export declare function greeting(): string;
+/**
+ * Returns a farewell message from Agent 2
+ * @returns A friendly goodbye message
+ */
+export declare function farewell(): string;

package/dist/test/multiAgentDemo.js

@@ -0,0 +1,20 @@
+/**
+ * Multi-agent coordination demo
+ *
+ * Task 001 (agt_c88d5b): greeting function
+ * Task 002 (agt_4564e7): farewell function
+ */
+/**
+ * Returns a greeting message from Agent 1
+ * @returns A friendly hello message
+ */
+export function greeting() {
+    return "Hello from Agent 1";
+}
+/**
+ * Returns a farewell message from Agent 2
+ * @returns A friendly goodbye message
+ */
+export function farewell() {
+    return "Goodbye from Agent 2";
+}

package/dist/test/multiAgentDemo.test.d.ts

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

package/dist/test/multiAgentDemo.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'bun:test';
+import { greeting, farewell } from './multiAgentDemo';
+describe('Multi-Agent Demo', () => {
+    it('greeting returns correct message', () => {
+        expect(greeting()).toBe('Hello from Agent 1');
+    });
+    it('farewell returns correct message', () => {
+        expect(farewell()).toBe('Goodbye from Agent 2');
+    });
+    it('both functions work together', () => {
+        const conversation = `${greeting()} ... ${farewell()}`;
+        expect(conversation).toBe('Hello from Agent 1 ... Goodbye from Agent 2');
+    });
+});

package/dist/test/setup.d.ts

@@ -0,0 +1,9 @@
+import { Database } from 'bun:sqlite';
+export type TestDb = {
+    db: Database;
+    path: string;
+    cleanup: () => void;
+    clearAllTables: () => void;
+};
+export declare function createTestDb(): TestDb;
+export declare function cleanupAllTestDbs(): void;

package/dist/test/setup.js

@@ -0,0 +1,50 @@
+import { Database } from 'bun:sqlite';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { mkdirSync, rmSync, existsSync } from 'fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEST_DB_DIR = join(__dirname, '../../.test-db');
+let testDbCounter = 0;
+export function createTestDb() {
+    testDbCounter++;
+    const dbPath = join(TEST_DB_DIR, `test-${Date.now()}-${testDbCounter}.sqlite`);
+    if (!existsSync(TEST_DB_DIR)) {
+        mkdirSync(TEST_DB_DIR, { recursive: true });
+    }
+    const db = new Database(dbPath);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 5000');
+    db.exec('PRAGMA foreign_keys = ON');
+    const schemaPath = join(__dirname, '../db/schema.sql');
+    const schema = readFileSync(schemaPath, 'utf-8');
+    db.exec(schema);
+    const clearAllTables = () => {
+        // Order matters due to FK constraints - delete children first
+        db.exec('DELETE FROM events');
+        db.exec('DELETE FROM tasks');
+        db.exec('DELETE FROM plans');
+        db.exec('DELETE FROM agents');
+        db.exec('DELETE FROM worktrees');
+        // Reset sequence counter
+        db.exec("UPDATE sequences SET value = 0 WHERE name = 'events'");
+    };
+    const cleanup = () => {
+        db.close();
+        if (existsSync(dbPath)) {
+            rmSync(dbPath, { force: true });
+        }
+        if (existsSync(`${dbPath}-wal`)) {
+            rmSync(`${dbPath}-wal`, { force: true });
+        }
+        if (existsSync(`${dbPath}-shm`)) {
+            rmSync(`${dbPath}-shm`, { force: true });
+        }
+    };
+    return { db, path: dbPath, cleanup, clearAllTables };
+}
+export function cleanupAllTestDbs() {
+    if (existsSync(TEST_DB_DIR)) {
+        rmSync(TEST_DB_DIR, { recursive: true, force: true });
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility exports - multi-agent coordination test
+ */
+export { add, subtract } from "./math";
+export { capitalize, reverse } from "./string";

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+/**
+ * Utility exports - multi-agent coordination test
+ */
+export { add, subtract } from "./math";
+export { capitalize, reverse } from "./string";

package/dist/utils/math.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Math utilities for hivemind multi-agent test
+ * Created by Agent 1 (agt_b6aca9)
+ */
+export declare function add(a: number, b: number): number;
+export declare function subtract(a: number, b: number): number;

package/dist/utils/math.js

@@ -0,0 +1,10 @@
+/**
+ * Math utilities for hivemind multi-agent test
+ * Created by Agent 1 (agt_b6aca9)
+ */
+export function add(a, b) {
+    return a + b;
+}
+export function subtract(a, b) {
+    return a - b;
+}

package/dist/utils/math.test.d.ts

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

package/dist/utils/math.test.js

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { add, subtract } from "./math";
+describe("math utilities", () => {
+    describe("add", () => {
+        test("adds two positive numbers", () => {
+            expect(add(2, 3)).toBe(5);
+        });
+        test("adds negative numbers", () => {
+            expect(add(-1, -2)).toBe(-3);
+        });
+        test("adds zero", () => {
+            expect(add(5, 0)).toBe(5);
+        });
+    });
+    describe("subtract", () => {
+        test("subtracts two positive numbers", () => {
+            expect(subtract(5, 3)).toBe(2);
+        });
+        test("subtracts resulting in negative", () => {
+            expect(subtract(3, 5)).toBe(-2);
+        });
+        test("subtracts zero", () => {
+            expect(subtract(5, 0)).toBe(5);
+        });
+    });
+});

package/dist/utils/string.d.ts

@@ -0,0 +1,11 @@
+/**
+ * String utility functions
+ */
+/**
+ * Capitalizes the first letter of a string
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Reverses a string
+ */
+export declare function reverse(str: string): string;

package/dist/utils/string.js

@@ -0,0 +1,17 @@
+/**
+ * String utility functions
+ */
+/**
+ * Capitalizes the first letter of a string
+ */
+export function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Reverses a string
+ */
+export function reverse(str) {
+    return str.split("").reverse().join("");
+}

package/dist/utils/string.test.d.ts

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

package/dist/utils/string.test.js

@@ -0,0 +1,30 @@
+import { describe, test, expect } from "bun:test";
+import { capitalize, reverse } from "./string";
+describe("capitalize", () => {
+    test("capitalizes first letter", () => {
+        expect(capitalize("hello")).toBe("Hello");
+    });
+    test("handles already capitalized", () => {
+        expect(capitalize("Hello")).toBe("Hello");
+    });
+    test("handles empty string", () => {
+        expect(capitalize("")).toBe("");
+    });
+    test("handles single character", () => {
+        expect(capitalize("a")).toBe("A");
+    });
+});
+describe("reverse", () => {
+    test("reverses a string", () => {
+        expect(reverse("hello")).toBe("olleh");
+    });
+    test("handles empty string", () => {
+        expect(reverse("")).toBe("");
+    });
+    test("handles palindrome", () => {
+        expect(reverse("radar")).toBe("radar");
+    });
+    test("handles single character", () => {
+        expect(reverse("x")).toBe("x");
+    });
+});

package/dist/watcher/index.d.ts

@@ -0,0 +1 @@
+export { startPlanWatcher, syncPlanFile, initialPlanSync } from './planWatcher';

package/dist/watcher/index.js

@@ -0,0 +1 @@
+export { startPlanWatcher, syncPlanFile, initialPlanSync } from './planWatcher';

package/dist/watcher/planWatcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Plan Watcher - watches ~/.claude/plans/ for plan mode files
+ *
+ * When Claude enters plan mode, it creates markdown files like:
+ *   ~/.claude/plans/purrfect-watching-lamport.md
+ *
+ * This watcher detects new/changed plans and syncs them to hivemind.
+ * Uses LLM (Claude CLI) to extract tasks from markdown.
+ */
+/**
+ * Sync a single plan file to hivemind
+ * Uses LLM to extract tasks, then reconciles with DB
+ */
+export declare function syncPlanFile(project: string, filename: string): Promise<{
+    success: boolean;
+    planId?: string;
+    message: string;
+}>;
+/**
+ * Initial sync - scan existing plan files
+ */
+export declare function initialPlanSync(project: string): Promise<void>;
+/**
+ * Start watching the plans directory
+ */
+export declare function startPlanWatcher(options: {
+    project: string;
+    verbose?: boolean;
+}): {
+    stop: () => void;
+};