@inixiative/hivemind 0.1.0

package/dist/watcher/planWatcher.js

@@ -0,0 +1,171 @@
+/**
+ * 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.
+ */
+import { watch, existsSync, readFileSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+import { getConnection } from '../db/getConnection';
+import { createPlan } from '../plans/createPlan';
+import { getPlan } from '../plans/getPlan';
+import { updatePlanStatus } from '../plans/updatePlanStatus';
+import { emit } from '../events/emit';
+import { extractTasksFromPlan } from '../llm/extractTasks';
+import { reconcileTasks } from '../llm/reconcileTasks';
+const CLAUDE_PLANS_DIR = join(homedir(), '.claude', 'plans');
+// Track known plan files to detect deletions
+const knownFiles = new Map(); // filename -> plan_id
+// Debounce
+const lastSync = new Map();
+const DEBOUNCE_MS = 1000;
+/**
+ * Parse plan title from markdown content
+ * Looks for first # heading
+ */
+function parsePlanTitle(content) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : null;
+}
+/**
+ * Sync a single plan file to hivemind
+ * Uses LLM to extract tasks, then reconciles with DB
+ */
+export async function syncPlanFile(project, filename) {
+    if (!filename.endsWith('.md')) {
+        return { success: false, message: 'Not a markdown file' };
+    }
+    // Debounce
+    const now = Date.now();
+    const last = lastSync.get(filename) ?? 0;
+    if (now - last < DEBOUNCE_MS) {
+        return { success: false, message: 'Debounced' };
+    }
+    lastSync.set(filename, now);
+    const filePath = join(CLAUDE_PLANS_DIR, filename);
+    if (!existsSync(filePath)) {
+        // File was deleted - mark plan as complete
+        const planId = knownFiles.get(filename);
+        if (planId) {
+            const db = getConnection(project);
+            updatePlanStatus(db, planId, 'complete');
+            knownFiles.delete(filename);
+            return { success: true, planId, message: `Plan ${planId} marked complete (file deleted)` };
+        }
+        return { success: false, message: 'File not found' };
+    }
+    // Read and parse
+    const content = readFileSync(filePath, 'utf-8');
+    const title = parsePlanTitle(content) || basename(filename, '.md');
+    const db = getConnection(project);
+    // Check if plan already exists
+    let plan = getPlan(db, knownFiles.get(filename) || '');
+    const isNew = !plan;
+    if (!plan) {
+        // Create new plan
+        plan = createPlan(db, {
+            title,
+            description: content.slice(0, 500),
+            label: basename(filename, '.md'),
+        });
+        knownFiles.set(filename, plan.id);
+        emit(db, {
+            type: 'plan:create',
+            content: `New plan: ${title}`,
+            plan_id: plan.id,
+        });
+    }
+    // Extract tasks using LLM
+    let tasks;
+    try {
+        tasks = await extractTasksFromPlan(content);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, planId: plan.id, message: `LLM extraction failed: ${msg}` };
+    }
+    // Reconcile tasks with DB
+    const result = reconcileTasks(db, plan.id, tasks);
+    const summary = [
+        isNew ? 'Created plan' : 'Updated plan',
+        `: ${title}`,
+        ` (${result.created.length} new,`,
+        ` ${result.updated.length} updated,`,
+        ` ${result.removed.length} removed,`,
+        ` ${result.unchanged} unchanged)`,
+    ].join('');
+    if (result.created.length > 0 || result.updated.length > 0 || result.removed.length > 0) {
+        emit(db, {
+            type: 'plan:sync',
+            content: summary,
+            plan_id: plan.id,
+        });
+    }
+    return {
+        success: true,
+        planId: plan.id,
+        message: summary,
+    };
+}
+/**
+ * Initial sync - scan existing plan files
+ */
+export async function initialPlanSync(project) {
+    if (!existsSync(CLAUDE_PLANS_DIR)) {
+        return;
+    }
+    const files = readdirSync(CLAUDE_PLANS_DIR).filter((f) => f.endsWith('.md'));
+    for (const file of files) {
+        try {
+            const result = await syncPlanFile(project, file);
+            if (result.success && result.message !== 'Debounced') {
+                console.log(`[plan-watcher] ${result.message}`);
+            }
+        }
+        catch (err) {
+            console.error(`[plan-watcher] Error syncing ${file}:`, err);
+        }
+    }
+}
+/**
+ * Start watching the plans directory
+ */
+export function startPlanWatcher(options) {
+    const { project, verbose = false } = options;
+    if (!existsSync(CLAUDE_PLANS_DIR)) {
+        console.log(`[plan-watcher] Plans directory not found: ${CLAUDE_PLANS_DIR}`);
+        return { stop: () => { } };
+    }
+    console.log(`[plan-watcher] Watching ${CLAUDE_PLANS_DIR}`);
+    // Initial sync (async, don't block)
+    initialPlanSync(project).catch((err) => {
+        console.error('[plan-watcher] Initial sync error:', err);
+    });
+    // Start watching
+    const watcher = watch(CLAUDE_PLANS_DIR, (event, filename) => {
+        if (!filename || !filename.endsWith('.md'))
+            return;
+        // Small delay for file to finish writing, then async sync
+        setTimeout(async () => {
+            try {
+                const result = await syncPlanFile(project, filename);
+                if (verbose || (result.success && result.message !== 'Debounced')) {
+                    console.log(`[plan-watcher] ${result.message}`);
+                }
+            }
+            catch (err) {
+                console.error(`[plan-watcher] Error syncing ${filename}:`, err);
+            }
+        }, 500); // Longer delay for LLM call
+    });
+    return {
+        stop: () => {
+            watcher.close();
+            console.log('[plan-watcher] Stopped');
+        },
+    };
+}

package/dist/worktrees/getAllWorktrees.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { WorktreeRecord } from './types';
+/**
+ * Get all registered worktrees
+ */
+export declare function getAllWorktrees(db: Database): WorktreeRecord[];

package/dist/worktrees/getAllWorktrees.js

@@ -0,0 +1,10 @@
+/**
+ * Get all registered worktrees
+ */
+export function getAllWorktrees(db) {
+    const stmt = db.prepare(`
+    SELECT * FROM worktrees
+    ORDER BY is_main DESC, last_seen DESC
+  `);
+    return stmt.all();
+}

package/dist/worktrees/getWorktreeById.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { WorktreeRecord } from './types';
+/**
+ * Get a worktree by ID
+ */
+export declare function getWorktreeById(db: Database, id: string): WorktreeRecord | null;

package/dist/worktrees/getWorktreeById.js

@@ -0,0 +1,7 @@
+/**
+ * Get a worktree by ID
+ */
+export function getWorktreeById(db, id) {
+    const stmt = db.prepare('SELECT * FROM worktrees WHERE id = ?');
+    return stmt.get(id) ?? null;
+}

package/dist/worktrees/getWorktreeByPath.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { WorktreeRecord } from './types';
+/**
+ * Get a worktree by its filesystem path
+ */
+export declare function getWorktreeByPath(db: Database, path: string): WorktreeRecord | null;

package/dist/worktrees/getWorktreeByPath.js

@@ -0,0 +1,7 @@
+/**
+ * Get a worktree by its filesystem path
+ */
+export function getWorktreeByPath(db, path) {
+    const stmt = db.prepare('SELECT * FROM worktrees WHERE path = ?');
+    return stmt.get(path) ?? null;
+}

package/dist/worktrees/index.d.ts

@@ -0,0 +1,9 @@
+export type { WorktreeStatus, WorktreeRecord, RegisterWorktreeInput } from './types';
+export { registerWorktree } from './registerWorktree';
+export { getWorktreeById } from './getWorktreeById';
+export { getWorktreeByPath } from './getWorktreeByPath';
+export { getAllWorktrees } from './getAllWorktrees';
+export { updateWorktreeSeen } from './updateWorktreeSeen';
+export { updateWorktreeCommit } from './updateWorktreeCommit';
+export { removeWorktree } from './removeWorktree';
+export { syncWorktreesFromGit } from './syncWorktreesFromGit';

package/dist/worktrees/index.js

@@ -0,0 +1,13 @@
+// Registration
+export { registerWorktree } from './registerWorktree';
+// Query
+export { getWorktreeById } from './getWorktreeById';
+export { getWorktreeByPath } from './getWorktreeByPath';
+export { getAllWorktrees } from './getAllWorktrees';
+// Updates
+export { updateWorktreeSeen } from './updateWorktreeSeen';
+export { updateWorktreeCommit } from './updateWorktreeCommit';
+// Removal
+export { removeWorktree } from './removeWorktree';
+// Sync
+export { syncWorktreesFromGit } from './syncWorktreesFromGit';

package/dist/worktrees/registerWorktree.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+import type { WorktreeRecord, RegisterWorktreeInput } from './types';
+/**
+ * Register a worktree in the hivemind
+ */
+export declare function registerWorktree(db: Database, input: RegisterWorktreeInput): WorktreeRecord;

package/dist/worktrees/registerWorktree.js

@@ -0,0 +1,28 @@
+import { makeWorktreeId } from '../ids/makeWorktreeId';
+import { parseId } from '../ids/parseId';
+import { now } from '../datetime/now';
+/**
+ * Register a worktree in the hivemind
+ */
+export function registerWorktree(db, input) {
+    const id = makeWorktreeId(input.label);
+    const parsed = parseId(id);
+    const timestamp = now();
+    const stmt = db.prepare(`
+    INSERT INTO worktrees (id, hex, label, path, branch, commit_hash, is_main, status, created_at, last_seen)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)
+  `);
+    stmt.run(id, parsed.hex, parsed.label ?? null, input.path, input.branch ?? null, input.commit_hash ?? null, input.is_main ? 1 : 0, timestamp, timestamp);
+    return {
+        id,
+        hex: parsed.hex,
+        label: parsed.label ?? null,
+        path: input.path,
+        branch: input.branch ?? null,
+        commit_hash: input.commit_hash ?? null,
+        is_main: input.is_main ? 1 : 0,
+        status: 'active',
+        created_at: timestamp,
+        last_seen: timestamp,
+    };
+}

package/dist/worktrees/removeWorktree.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Remove a worktree from the database
+ * Does NOT delete the actual git worktree - just the DB record
+ */
+export declare function removeWorktree(db: Database, worktreeId: string): boolean;

package/dist/worktrees/removeWorktree.js

@@ -0,0 +1,9 @@
+/**
+ * Remove a worktree from the database
+ * Does NOT delete the actual git worktree - just the DB record
+ */
+export function removeWorktree(db, worktreeId) {
+    const stmt = db.prepare('DELETE FROM worktrees WHERE id = ?');
+    const result = stmt.run(worktreeId);
+    return result.changes > 0;
+}

package/dist/worktrees/syncWorktreesFromGit.d.ts

@@ -0,0 +1,7 @@
+import type { Database } from 'bun:sqlite';
+import type { WorktreeRecord } from './types';
+/**
+ * Sync worktrees from git into the database
+ * Returns list of all worktrees after sync
+ */
+export declare function syncWorktreesFromGit(db: Database): WorktreeRecord[];

package/dist/worktrees/syncWorktreesFromGit.js

@@ -0,0 +1,51 @@
+import { getWorktrees as getGitWorktrees } from '../git/getWorktrees';
+import { getWorktreeByPath } from './getWorktreeByPath';
+import { registerWorktree } from './registerWorktree';
+import { updateWorktreeSeen } from './updateWorktreeSeen';
+import { updateWorktreeCommit } from './updateWorktreeCommit';
+import { emit } from '../events/emit';
+/**
+ * Sync worktrees from git into the database
+ * Returns list of all worktrees after sync
+ */
+export function syncWorktreesFromGit(db) {
+    const gitWorktrees = getGitWorktrees();
+    const results = [];
+    for (const wt of gitWorktrees) {
+        const existing = getWorktreeByPath(db, wt.path);
+        if (existing) {
+            // Update existing worktree
+            updateWorktreeSeen(db, existing.id);
+            if (wt.commit && wt.commit !== existing.commit_hash) {
+                updateWorktreeCommit(db, existing.id, wt.commit);
+            }
+            results.push({
+                ...existing,
+                commit_hash: wt.commit ?? existing.commit_hash,
+            });
+        }
+        else {
+            // Register new worktree
+            const record = registerWorktree(db, {
+                path: wt.path,
+                branch: wt.branch ?? undefined,
+                commit_hash: wt.commit,
+                is_main: wt.isMain,
+            });
+            // Emit worktree:register system event
+            emit(db, {
+                type: 'worktree:register',
+                worktree_id: record.id,
+                branch: wt.branch ?? undefined,
+                content: `Worktree registered: ${wt.path}${wt.branch ? ` (${wt.branch})` : ''}`,
+                metadata: {
+                    path: wt.path,
+                    commit_hash: wt.commit,
+                    is_main: wt.isMain,
+                },
+            });
+            results.push(record);
+        }
+    }
+    return results;
+}

package/dist/worktrees/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Worktree status values
+ */
+export type WorktreeStatus = 'active' | 'stale';
+/**
+ * Worktree record as stored in DB
+ */
+export type WorktreeRecord = {
+    id: string;
+    hex: string;
+    label: string | null;
+    path: string;
+    branch: string | null;
+    commit_hash: string | null;
+    is_main: number;
+    status: WorktreeStatus;
+    created_at: string;
+    last_seen: string | null;
+};
+/**
+ * Input for registering a worktree
+ */
+export type RegisterWorktreeInput = {
+    path: string;
+    branch?: string;
+    commit_hash?: string;
+    is_main?: boolean;
+    label?: string;
+};

package/dist/worktrees/types.js

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

package/dist/worktrees/updateWorktreeCommit.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Update a worktree's current commit
+ */
+export declare function updateWorktreeCommit(db: Database, id: string, commitHash: string): boolean;

package/dist/worktrees/updateWorktreeCommit.js

@@ -0,0 +1,13 @@
+import { now } from '../datetime/now';
+/**
+ * Update a worktree's current commit
+ */
+export function updateWorktreeCommit(db, id, commitHash) {
+    const stmt = db.prepare(`
+    UPDATE worktrees
+    SET commit_hash = ?, last_seen = ?
+    WHERE id = ?
+  `);
+    const result = stmt.run(commitHash, now(), id);
+    return result.changes > 0;
+}

package/dist/worktrees/updateWorktreeSeen.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from 'bun:sqlite';
+/**
+ * Update a worktree's last_seen timestamp
+ */
+export declare function updateWorktreeSeen(db: Database, id: string): boolean;

package/dist/worktrees/updateWorktreeSeen.js

@@ -0,0 +1,13 @@
+import { now } from '../datetime/now';
+/**
+ * Update a worktree's last_seen timestamp
+ */
+export function updateWorktreeSeen(db, id) {
+    const stmt = db.prepare(`
+    UPDATE worktrees
+    SET last_seen = ?, status = 'active'
+    WHERE id = ?
+  `);
+    const result = stmt.run(now(), id);
+    return result.changes > 0;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@inixiative/hivemind",
+  "version": "0.1.0",
+  "description": "Multi-agent coordination system for Claude Code - shared event log, plans, and tasks across multiple Claude sessions",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "hivemind": "./dist/cli.js",
+    "hivemind-mcp": "./dist/mcp/server.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/inixiative/hivemind.git"
+  },
+  "homepage": "https://github.com/inixiative/hivemind#readme",
+  "bugs": {
+    "url": "https://github.com/inixiative/hivemind/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Aron Greenspan",
+    "url": "https://github.com/inixiative"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "multi-agent",
+    "coordination",
+    "ai-agents"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "bun test",
+    "mcp": "bun run src/mcp/server.ts",
+    "cli": "bun run src/cli.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/bun": "latest",
+    "typescript": "^5.3.0"
+  }
+}