gru-ai 0.1.0

package/dist-server/server/config.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const CONFIG_DIR = path.join(os.homedir(), '.conductor');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+function resolveHome(filePath) {
+    if (filePath.startsWith('~/') || filePath === '~') {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+/**
+ * Decode a ~/.claude/projects/ directory name back to a real filesystem path.
+ *
+ * Directory names encode paths by replacing `/` with `-`, e.g.:
+ *   `-Users-yangyang-Repos-gruai` -> `/Users/yangyang/Repos/gruai`
+ *
+ * The challenge: path components can contain hyphens (e.g. `gruai`).
+ * We solve this by trying all possible hyphen->slash splits and checking which
+ * decoded path actually exists on disk.
+ */
+function decodeProjectDirName(dirName) {
+    // Must start with `-` (represents leading `/`)
+    if (!dirName.startsWith('-'))
+        return null;
+    const stripped = dirName.slice(1); // remove leading `-`
+    const parts = stripped.split('-');
+    // Use dynamic programming / recursive backtracking to find valid path
+    // Try combining adjacent parts with hyphens to form directory names
+    const result = findValidPath(parts, 0, '/');
+    return result;
+}
+/**
+ * Recursively try combining parts to find a path that exists on disk.
+ * parts: array of hyphen-split segments
+ * index: current position in parts
+ * currentPath: path built so far
+ */
+function findValidPath(parts, index, currentPath) {
+    if (index >= parts.length) {
+        // We've consumed all parts. Check if the full path exists
+        return fs.existsSync(currentPath) ? currentPath : null;
+    }
+    // Try progressively longer component names (joining with hyphens)
+    for (let end = index + 1; end <= parts.length; end++) {
+        const component = parts.slice(index, end).join('-');
+        const candidatePath = path.join(currentPath, component);
+        // For intermediate components, check if this directory exists before recursing
+        if (end < parts.length) {
+            if (fs.existsSync(candidatePath)) {
+                const result = findValidPath(parts, end, candidatePath);
+                if (result)
+                    return result;
+            }
+        }
+        else {
+            // Last component: check if the full path exists
+            if (fs.existsSync(candidatePath)) {
+                return candidatePath;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Derive a human-friendly project name from a filesystem path.
+ * Uses the last directory component, title-cased.
+ * e.g. `/Users/yangyang/Repos/gruai` -> `Agent Conductor`
+ */
+function deriveProjectName(projectPath) {
+    const basename = path.basename(projectPath);
+    return basename
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Discover conductor-enabled projects from ~/.claude/projects/.
+ * Scans subdirectories, decodes their names to real paths, and checks
+ * for `.context/` to identify conductor-enabled repos.
+ */
+export function discoverProjects(claudeHome) {
+    const projectsDir = path.join(claudeHome, 'projects');
+    if (!fs.existsSync(projectsDir)) {
+        return [];
+    }
+    const discovered = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(projectsDir).filter((name) => {
+            if (name.startsWith('.'))
+                return false;
+            try {
+                return fs.statSync(path.join(projectsDir, name)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        const decodedPath = decodeProjectDirName(entry);
+        if (!decodedPath)
+            continue;
+        // Only include projects that have .context/ (conductor-enabled)
+        const contextDir = path.join(decodedPath, '.context');
+        if (!fs.existsSync(contextDir))
+            continue;
+        discovered.push({
+            name: deriveProjectName(decodedPath),
+            path: decodedPath,
+            source: 'discovered',
+        });
+    }
+    console.log(`[config] Discovered ${discovered.length} conductor-enabled project(s) from ${projectsDir}`);
+    for (const p of discovered) {
+        console.log(`[config]   - ${p.name}: ${p.path}`);
+    }
+    return discovered;
+}
+function defaultConfig() {
+    return {
+        projects: [],
+        claudeHome: '~/.claude',
+        server: {
+            port: 4444,
+        },
+        notifications: {
+            macOS: true,
+            browser: true,
+        },
+    };
+}
+export function loadConfig() {
+    try {
+        let configProjects = [];
+        let claudeHome = '~/.claude';
+        let serverPort = 4444;
+        let notifications = { macOS: true, browser: true };
+        if (fs.existsSync(CONFIG_PATH)) {
+            const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+            const parsed = JSON.parse(raw);
+            configProjects = (parsed.projects ?? []).map((p) => ({
+                ...p,
+                source: 'config',
+            }));
+            claudeHome = parsed.claudeHome ?? claudeHome;
+            serverPort = parsed.server?.port ?? serverPort;
+            notifications = {
+                macOS: parsed.notifications?.macOS ?? notifications.macOS,
+                browser: parsed.notifications?.browser ?? notifications.browser,
+            };
+        }
+        else {
+            // Create default config file
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+            const defaults = defaultConfig();
+            fs.writeFileSync(CONFIG_PATH, JSON.stringify(defaults, null, 2), 'utf-8');
+            console.log(`[config] Created default config at ${CONFIG_PATH}`);
+        }
+        const resolvedClaudeHome = resolveHome(claudeHome);
+        // Discover projects from ~/.claude/projects/
+        const discoveredProjects = discoverProjects(resolvedClaudeHome);
+        // Merge: discovered projects are primary, config.json projects fill gaps
+        // Deduplicate by resolved path
+        const seenPaths = new Set();
+        const mergedProjects = [];
+        // Add discovered projects first (they take priority)
+        for (const dp of discoveredProjects) {
+            const resolved = path.resolve(dp.path);
+            if (!seenPaths.has(resolved)) {
+                seenPaths.add(resolved);
+                mergedProjects.push(dp);
+            }
+        }
+        // Add config.json projects that weren't already discovered
+        for (const cp of configProjects) {
+            const resolved = path.resolve(resolveHome(cp.path));
+            if (!seenPaths.has(resolved)) {
+                seenPaths.add(resolved);
+                mergedProjects.push({
+                    ...cp,
+                    path: resolveHome(cp.path),
+                });
+            }
+            else {
+                // Config entry exists for a discovered project — use config's name if provided
+                const existing = mergedProjects.find((p) => path.resolve(p.path) === resolved);
+                if (existing && cp.name) {
+                    existing.name = cp.name;
+                }
+            }
+        }
+        const config = {
+            projects: mergedProjects,
+            claudeHome: resolvedClaudeHome,
+            server: { port: serverPort },
+            notifications,
+        };
+        return config;
+    }
+    catch (err) {
+        console.error(`[config] Error loading config from ${CONFIG_PATH}, using defaults:`, err);
+        const defaults = defaultConfig();
+        return {
+            ...defaults,
+            claudeHome: resolveHome(defaults.claudeHome),
+        };
+    }
+}
+export function saveConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}

package/dist-server/server/db.d.ts

@@ -0,0 +1,7 @@
+import Database from 'better-sqlite3';
+import type { HookEvent } from './types.js';
+export declare function getDb(): Database.Database;
+export declare function insertEvent(event: HookEvent): void;
+export declare function getRecentEvents(limit?: number): HookEvent[];
+export declare function getEventsBySession(sessionId: string, limit?: number): HookEvent[];
+export declare function closeDb(): void;

package/dist-server/server/db.js

@@ -0,0 +1,79 @@
+import Database from 'better-sqlite3';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+const DB_DIR = path.join(os.homedir(), '.conductor');
+const DB_PATH = path.join(DB_DIR, 'conductor.db');
+let db = null;
+export function getDb() {
+    if (db)
+        return db;
+    fs.mkdirSync(DB_DIR, { recursive: true });
+    db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      message TEXT NOT NULL DEFAULT '',
+      project TEXT,
+      metadata_json TEXT
+    )
+  `);
+    // Index for querying by session and time
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
+  `);
+    db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp DESC);
+  `);
+    console.log(`[db] SQLite database initialized at ${DB_PATH}`);
+    return db;
+}
+export function insertEvent(event) {
+    const database = getDb();
+    const stmt = database.prepare(`
+    INSERT OR REPLACE INTO events (id, type, session_id, timestamp, message, project, metadata_json)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(event.id, event.type, event.sessionId, event.timestamp, event.message, event.project ?? null, event.metadata ? JSON.stringify(event.metadata) : null);
+}
+export function getRecentEvents(limit = 100) {
+    const database = getDb();
+    const rows = database
+        .prepare(`SELECT * FROM events ORDER BY timestamp DESC LIMIT ?`)
+        .all(limit);
+    return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        sessionId: row.session_id,
+        timestamp: row.timestamp,
+        message: row.message,
+        project: row.project ?? undefined,
+        metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+    }));
+}
+export function getEventsBySession(sessionId, limit = 50) {
+    const database = getDb();
+    const rows = database
+        .prepare(`SELECT * FROM events WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?`)
+        .all(sessionId, limit);
+    return rows.map((row) => ({
+        id: row.id,
+        type: row.type,
+        sessionId: row.session_id,
+        timestamp: row.timestamp,
+        message: row.message,
+        project: row.project ?? undefined,
+        metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+    }));
+}
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist-server/server/hooks/event-receiver.d.ts

@@ -0,0 +1,11 @@
+import type { HookEvent } from '../types.js';
+interface RawEventBody {
+    type?: string;
+    sessionId?: string;
+    timestamp?: string;
+    message?: string;
+    project?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function processEvent(body: RawEventBody): HookEvent;
+export {};

package/dist-server/server/hooks/event-receiver.js

@@ -0,0 +1,36 @@
+import crypto from 'node:crypto';
+import { insertEvent } from '../db.js';
+export function processEvent(body) {
+    const event = {
+        id: crypto.randomUUID(),
+        type: body.type ?? 'unknown',
+        sessionId: body.sessionId ?? 'unknown',
+        timestamp: body.timestamp ?? new Date().toISOString(),
+        message: body.message ?? formatDefaultMessage(body.type),
+        project: body.project,
+        metadata: body.metadata,
+    };
+    // Persist to SQLite
+    insertEvent(event);
+    return event;
+}
+function formatDefaultMessage(type) {
+    switch (type) {
+        case 'stop':
+            return 'Agent session stopped';
+        case 'task_completed':
+            return 'Task completed';
+        case 'teammate_idle':
+            return 'Teammate is idle';
+        case 'permission_prompt':
+            return 'Agent needs permission';
+        case 'idle_prompt':
+            return 'Agent needs input';
+        case 'elicitation_dialog':
+            return 'Agent needs input';
+        case 'error':
+            return 'Agent encountered an error';
+        default:
+            return `Event: ${type ?? 'unknown'}`;
+    }
+}

package/dist-server/server/index.d.ts

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