@mauribadnights/clooks 0.3.2 → 0.4.0

package/dist/tui.js

@@ -0,0 +1,560 @@
+"use strict";
+// clooks interactive TUI dashboard for `clooks stats -i`
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchDashboard = launchDashboard;
+const blessed_1 = __importDefault(require("blessed"));
+const fs_1 = require("fs");
+const constants_js_1 = require("./constants.js");
+// --- Data loading ---
+function loadAllMetricEntries() {
+    if (!(0, fs_1.existsSync)(constants_js_1.METRICS_FILE))
+        return [];
+    try {
+        const raw = (0, fs_1.readFileSync)(constants_js_1.METRICS_FILE, 'utf-8');
+        const lines = raw.trim().split('\n').filter(Boolean);
+        return lines.map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+function aggregateByEvent(entries) {
+    const byEvent = new Map();
+    for (const e of entries) {
+        const arr = byEvent.get(e.event) ?? [];
+        arr.push(e);
+        byEvent.set(e.event, arr);
+    }
+    const result = [];
+    for (const [event, evEntries] of byEvent) {
+        const durations = evEntries.map((e) => e.duration_ms);
+        const byHandler = new Map();
+        for (const e of evEntries) {
+            const arr = byHandler.get(e.handler) ?? [];
+            arr.push(e);
+            byHandler.set(e.handler, arr);
+        }
+        const handlers = [];
+        for (const [handler, hEntries] of byHandler) {
+            const hDurations = hEntries.map((e) => e.duration_ms);
+            handlers.push({
+                handler,
+                event,
+                fires: hEntries.length,
+                errors: hEntries.filter((e) => !e.ok).length,
+                avgMs: hDurations.reduce((a, b) => a + b, 0) / hDurations.length,
+                maxMs: Math.max(...hDurations),
+            });
+        }
+        handlers.sort((a, b) => b.avgMs - a.avgMs);
+        result.push({
+            event,
+            fires: evEntries.length,
+            errors: evEntries.filter((e) => !e.ok).length,
+            avgMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+            maxMs: Math.max(...durations),
+            handlers,
+        });
+    }
+    return result.sort((a, b) => b.fires - a.fires);
+}
+function aggregateAllHandlers(entries) {
+    const byHandler = new Map();
+    for (const e of entries) {
+        const arr = byHandler.get(e.handler) ?? [];
+        arr.push(e);
+        byHandler.set(e.handler, arr);
+    }
+    const result = [];
+    for (const [handler, hEntries] of byHandler) {
+        const durations = hEntries.map((e) => e.duration_ms);
+        result.push({
+            handler,
+            event: hEntries[0].event,
+            fires: hEntries.length,
+            errors: hEntries.filter((e) => !e.ok).length,
+            avgMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+            maxMs: Math.max(...durations),
+        });
+    }
+    return result.sort((a, b) => b.avgMs - a.avgMs);
+}
+function aggregateByAgent(entries) {
+    // Group by session_id first, then infer agent from handler patterns
+    // Since MetricEntry doesn't have agent_type, we group by session_id
+    // and label sessions by the set of handlers that fired
+    const bySid = new Map();
+    for (const e of entries) {
+        const sid = e.session_id ?? 'unknown';
+        const arr = bySid.get(sid) ?? [];
+        arr.push(e);
+        bySid.set(sid, arr);
+    }
+    // Derive agent name from handler prefixes (e.g., "gsd-*" => "gsd", "cq-*" => "cq")
+    const agentMap = new Map();
+    for (const [_sid, sEntries] of bySid) {
+        // Use the most common handler prefix as agent name
+        const prefixes = new Map();
+        for (const e of sEntries) {
+            const prefix = e.handler.split('-')[0] || e.handler;
+            prefixes.set(prefix, (prefixes.get(prefix) ?? 0) + 1);
+        }
+        let agent = 'unknown';
+        let maxCount = 0;
+        for (const [p, c] of prefixes) {
+            if (c > maxCount) {
+                agent = p;
+                maxCount = c;
+            }
+        }
+        const arr = agentMap.get(agent) ?? [];
+        arr.push(...sEntries);
+        agentMap.set(agent, arr);
+    }
+    const result = [];
+    for (const [agent, aEntries] of agentMap) {
+        const handlers = aggregateHandlersFrom(aEntries);
+        result.push({
+            agent,
+            fires: aEntries.length,
+            errors: aEntries.filter((e) => !e.ok).length,
+            handlers,
+        });
+    }
+    return result.sort((a, b) => b.fires - a.fires);
+}
+function aggregateByProject(entries) {
+    // MetricEntry doesn't have cwd, so we group by session_id and use 'unknown' for project
+    // If entries had cwd, we'd group by that. For now, group by session_id as proxy.
+    // Actually, let's check if there's a cwd-like field or group by session
+    const bySid = new Map();
+    for (const e of entries) {
+        const key = e.session_id ?? 'unknown';
+        const arr = bySid.get(key) ?? [];
+        arr.push(e);
+        bySid.set(key, arr);
+    }
+    const result = [];
+    for (const [sid, pEntries] of bySid) {
+        const durations = pEntries.map((e) => e.duration_ms);
+        const handlers = aggregateHandlersFrom(pEntries);
+        const label = sid.length > 16 ? sid.slice(0, 8) + '...' + sid.slice(-8) : sid;
+        result.push({
+            project: label,
+            fires: pEntries.length,
+            errors: pEntries.filter((e) => !e.ok).length,
+            avgMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+            handlers,
+        });
+    }
+    return result.sort((a, b) => b.fires - a.fires);
+}
+function aggregateHandlersFrom(entries) {
+    const byHandler = new Map();
+    for (const e of entries) {
+        const arr = byHandler.get(e.handler) ?? [];
+        arr.push(e);
+        byHandler.set(e.handler, arr);
+    }
+    const result = [];
+    for (const [handler, hEntries] of byHandler) {
+        const durations = hEntries.map((e) => e.duration_ms);
+        result.push({
+            handler,
+            event: hEntries[0].event,
+            fires: hEntries.length,
+            errors: hEntries.filter((e) => !e.ok).length,
+            avgMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+            maxMs: Math.max(...durations),
+        });
+    }
+    return result.sort((a, b) => b.avgMs - a.avgMs);
+}
+// --- Fuzzy search ---
+function fuzzyMatch(query, target) {
+    const q = query.toLowerCase();
+    const t = target.toLowerCase();
+    let qi = 0;
+    for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+        if (t[ti] === q[qi])
+            qi++;
+    }
+    return qi === q.length;
+}
+// --- Color coding ---
+function colorize(avgMs, text) {
+    if (avgMs < 5)
+        return `{green-fg}${text}{/green-fg}`;
+    if (avgMs <= 50)
+        return `{yellow-fg}${text}{/yellow-fg}`;
+    return `{red-fg}${text}{/red-fg}`;
+}
+function colorizeErrors(errors, text) {
+    if (errors === 0)
+        return `{green-fg}${text}{/green-fg}`;
+    return `{red-fg}${text}{/red-fg}`;
+}
+const VIEW_ORDER = ['events', 'handlers', 'agents', 'projects'];
+const VIEW_LABELS = {
+    events: 'Events',
+    handlers: 'Handlers',
+    agents: 'Agents',
+    projects: 'Projects',
+    search: 'Search',
+};
+function launchDashboard() {
+    const entries = loadAllMetricEntries();
+    const eventAggs = aggregateByEvent(entries);
+    const handlerAggs = aggregateAllHandlers(entries);
+    const agentAggs = aggregateByAgent(entries);
+    const projectAggs = aggregateByProject(entries);
+    const totalFires = entries.length;
+    const totalErrors = entries.filter((e) => !e.ok).length;
+    const totalEvents = eventAggs.length;
+    const totalHandlers = handlerAggs.length;
+    // --- Screen setup ---
+    const scr = blessed_1.default.screen({
+        smartCSR: true,
+        title: 'clooks stats',
+        fullUnicode: true,
+    });
+    let currentView = 'events';
+    let drillDown = null;
+    let searchMode = false;
+    let searchQuery = '';
+    // --- Header (tab bar) ---
+    const header = blessed_1.default.box({
+        top: 0,
+        left: 0,
+        width: '100%',
+        height: 3,
+        tags: true,
+        border: { type: 'line' },
+        style: {
+            border: { fg: 'cyan' },
+        },
+    });
+    scr.append(header);
+    // --- Main list ---
+    const mainList = blessed_1.default.list({
+        top: 3,
+        left: 0,
+        width: '100%',
+        height: '100%-6',
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        scrollable: true,
+        border: { type: 'line' },
+        style: {
+            border: { fg: 'blue' },
+            selected: { bg: 'blue', fg: 'white', bold: true },
+            item: { fg: 'white' },
+        },
+        scrollbar: {
+            ch: ' ',
+            style: { bg: 'blue' },
+        },
+    });
+    scr.append(mainList);
+    // --- Footer (status bar) ---
+    const footer = blessed_1.default.box({
+        bottom: 0,
+        left: 0,
+        width: '100%',
+        height: 3,
+        tags: true,
+        border: { type: 'line' },
+        style: {
+            border: { fg: 'cyan' },
+        },
+    });
+    scr.append(footer);
+    // --- Search input (hidden by default) ---
+    const searchBox = blessed_1.default.textbox({
+        bottom: 3,
+        left: 0,
+        width: '100%',
+        height: 3,
+        tags: true,
+        border: { type: 'line' },
+        style: {
+            border: { fg: 'yellow' },
+            fg: 'white',
+        },
+        label: ' Search (Esc to cancel) ',
+        hidden: true,
+        inputOnFocus: true,
+    });
+    scr.append(searchBox);
+    // --- Rendering functions ---
+    function renderHeader() {
+        const tabs = VIEW_ORDER.map((v) => {
+            if (v === currentView)
+                return `{cyan-fg}{bold}[${VIEW_LABELS[v]}]{/bold}{/cyan-fg}`;
+            return ` ${VIEW_LABELS[v]} `;
+        });
+        if (searchMode)
+            tabs.push(`{yellow-fg}{bold}[Search]{/bold}{/yellow-fg}`);
+        header.setContent(` ${tabs.join('  ')}`);
+    }
+    function renderFooter() {
+        const statusLine = `Total: ${totalEvents} events | ${totalHandlers} handlers | ${totalFires} fires | ${totalErrors} errors`;
+        const helpLine = 'Tab=switch view  /=search  Enter=drill in  Esc=back  q=quit';
+        footer.setContent(` ${statusLine}\n ${helpLine}`);
+    }
+    function formatHandlerRow(h) {
+        const name = h.handler.padEnd(28);
+        const ev = h.event.padEnd(18);
+        const fires = String(h.fires).padStart(6);
+        const errs = colorizeErrors(h.errors, String(h.errors).padStart(6));
+        const avg = colorize(h.avgMs, h.avgMs.toFixed(1).padStart(8));
+        const max = colorize(h.maxMs, h.maxMs.toFixed(1).padStart(8));
+        return ` ${name} ${ev} ${fires} ${errs} ${avg} ${max}`;
+    }
+    function handlerTableHeader() {
+        const name = 'Handler'.padEnd(28);
+        const ev = 'Event'.padEnd(18);
+        const fires = 'Fires'.padStart(6);
+        const errs = 'Errors'.padStart(6);
+        const avg = 'Avg ms'.padStart(8);
+        const max = 'Max ms'.padStart(8);
+        return `{bold} ${name} ${ev} ${fires} ${errs} ${avg} ${max}{/bold}`;
+    }
+    function renderEventsView() {
+        if (drillDown && 'event' in drillDown && 'handlers' in drillDown) {
+            const ev = drillDown;
+            mainList.setLabel(` Event: ${ev.event} `);
+            const items = [handlerTableHeader()];
+            for (const h of ev.handlers) {
+                items.push(formatHandlerRow(h));
+            }
+            mainList.setItems(items);
+        }
+        else {
+            mainList.setLabel(' Events ');
+            const items = [];
+            for (const ev of eventAggs) {
+                const name = ev.event.padEnd(22);
+                const fires = String(ev.fires).padStart(6);
+                const errs = colorizeErrors(ev.errors, String(ev.errors).padStart(6));
+                const avg = colorize(ev.avgMs, ev.avgMs.toFixed(1).padStart(8));
+                const max = colorize(ev.maxMs, ev.maxMs.toFixed(1).padStart(8));
+                const hCount = `(${ev.handlers.length} handlers)`.padStart(14);
+                items.push(` ${name} ${fires} fires ${errs} errs ${avg} avg ${max} max ${hCount}`);
+            }
+            mainList.setItems(items);
+        }
+    }
+    function renderHandlersView() {
+        mainList.setLabel(' Handlers (sorted by avg latency) ');
+        const items = [handlerTableHeader()];
+        for (const h of handlerAggs) {
+            items.push(formatHandlerRow(h));
+        }
+        mainList.setItems(items);
+    }
+    function renderAgentsView() {
+        if (drillDown && 'agent' in drillDown) {
+            const ag = drillDown;
+            mainList.setLabel(` Agent: ${ag.agent} `);
+            const items = [handlerTableHeader()];
+            for (const h of ag.handlers) {
+                items.push(formatHandlerRow(h));
+            }
+            mainList.setItems(items);
+        }
+        else {
+            mainList.setLabel(' Agents ');
+            const items = [];
+            for (const ag of agentAggs) {
+                const name = ag.agent.padEnd(22);
+                const fires = String(ag.fires).padStart(6);
+                const errs = colorizeErrors(ag.errors, String(ag.errors).padStart(6));
+                const hCount = `(${ag.handlers.length} handlers)`.padStart(14);
+                items.push(` ${name} ${fires} fires ${errs} errs ${hCount}`);
+            }
+            mainList.setItems(items);
+        }
+    }
+    function renderProjectsView() {
+        if (drillDown && 'project' in drillDown) {
+            const pr = drillDown;
+            mainList.setLabel(` Session: ${pr.project} `);
+            const items = [handlerTableHeader()];
+            for (const h of pr.handlers) {
+                items.push(formatHandlerRow(h));
+            }
+            mainList.setItems(items);
+        }
+        else {
+            mainList.setLabel(' Projects / Sessions ');
+            const items = [];
+            for (const pr of projectAggs) {
+                const name = pr.project.padEnd(22);
+                const fires = String(pr.fires).padStart(6);
+                const errs = colorizeErrors(pr.errors, String(pr.errors).padStart(6));
+                const avg = colorize(pr.avgMs, pr.avgMs.toFixed(1).padStart(8));
+                items.push(` ${name} ${fires} fires ${errs} errs ${avg} avg`);
+            }
+            mainList.setItems(items);
+        }
+    }
+    function renderSearchView() {
+        mainList.setLabel(` Search: "${searchQuery}" `);
+        if (!searchQuery) {
+            mainList.setItems([' Type to search handlers, events, agents...']);
+            return;
+        }
+        const results = [handlerTableHeader()];
+        // Search handlers
+        for (const h of handlerAggs) {
+            if (fuzzyMatch(searchQuery, h.handler) || fuzzyMatch(searchQuery, h.event)) {
+                results.push(formatHandlerRow(h));
+            }
+        }
+        // Search events
+        for (const ev of eventAggs) {
+            if (fuzzyMatch(searchQuery, ev.event) && !results.some((r) => r.includes(ev.event))) {
+                const name = ev.event.padEnd(22);
+                results.push(` {cyan-fg}[event]{/cyan-fg} ${name} ${ev.fires} fires`);
+            }
+        }
+        // Search agents
+        for (const ag of agentAggs) {
+            if (fuzzyMatch(searchQuery, ag.agent)) {
+                const name = ag.agent.padEnd(22);
+                results.push(` {magenta-fg}[agent]{/magenta-fg} ${name} ${ag.fires} fires`);
+            }
+        }
+        if (results.length === 1) {
+            results.push(' No matches found.');
+        }
+        mainList.setItems(results);
+    }
+    function renderCurrentView() {
+        renderHeader();
+        renderFooter();
+        switch (currentView) {
+            case 'events':
+                renderEventsView();
+                break;
+            case 'handlers':
+                renderHandlersView();
+                break;
+            case 'agents':
+                renderAgentsView();
+                break;
+            case 'projects':
+                renderProjectsView();
+                break;
+            case 'search':
+                renderSearchView();
+                break;
+        }
+        mainList.select(0);
+        mainList.focus();
+        scr.render();
+    }
+    function switchView(direction) {
+        if (searchMode) {
+            searchMode = false;
+            searchBox.hide();
+        }
+        drillDown = null;
+        const idx = VIEW_ORDER.indexOf(currentView);
+        const next = (idx + direction + VIEW_ORDER.length) % VIEW_ORDER.length;
+        currentView = VIEW_ORDER[next];
+        renderCurrentView();
+    }
+    function drillInto() {
+        // @ts-ignore — blessed ListElement exposes .selected at runtime
+        const selected = mainList.selected ?? 0;
+        if (currentView === 'events' && !drillDown) {
+            const ev = eventAggs[selected];
+            if (ev) {
+                drillDown = ev;
+                renderCurrentView();
+            }
+        }
+        else if (currentView === 'agents' && !drillDown) {
+            const ag = agentAggs[selected];
+            if (ag) {
+                drillDown = ag;
+                renderCurrentView();
+            }
+        }
+        else if (currentView === 'projects' && !drillDown) {
+            const pr = projectAggs[selected];
+            if (pr) {
+                drillDown = pr;
+                renderCurrentView();
+            }
+        }
+    }
+    function goBack() {
+        if (searchMode) {
+            searchMode = false;
+            searchBox.hide();
+            currentView = 'events';
+            renderCurrentView();
+            return;
+        }
+        if (drillDown) {
+            drillDown = null;
+            renderCurrentView();
+        }
+    }
+    // --- Key bindings ---
+    scr.key(['q', 'C-c'], () => process.exit(0));
+    scr.key(['tab'], () => switchView(1));
+    scr.key(['S-tab'], () => switchView(-1));
+    scr.key(['enter'], () => drillInto());
+    scr.key(['escape', 'backspace'], () => goBack());
+    scr.key(['/'], () => {
+        searchMode = true;
+        currentView = 'search';
+        searchQuery = '';
+        searchBox.show();
+        searchBox.setValue('');
+        renderCurrentView();
+        searchBox.focus();
+        searchBox.readInput(() => {
+            // Input submitted
+            searchQuery = searchBox.getValue();
+            searchBox.hide();
+            mainList.focus();
+            renderCurrentView();
+        });
+        scr.render();
+    });
+    // Live search: update on each keypress in the search box
+    searchBox.on('keypress', (_ch, _key) => {
+        // Small delay to let blessed update the value
+        setTimeout(() => {
+            searchQuery = searchBox.getValue();
+            renderSearchView();
+            scr.render();
+        }, 10);
+    });
+    // --- No data state ---
+    if (entries.length === 0) {
+        mainList.setItems([
+            ' No metrics recorded yet.',
+            '',
+            ' Start the clooks daemon and run some Claude Code sessions',
+            ' to see hook execution statistics here.',
+        ]);
+        mainList.setLabel(' clooks stats ');
+        renderHeader();
+        renderFooter();
+        scr.render();
+    }
+    else {
+        renderCurrentView();
+    }
+}

package/dist/types.d.ts

@@ -11,6 +11,7 @@ export interface HookInput {
     tool_name?: string;
     tool_input?: Record<string, unknown>;
     source?: string;
+    agent_type?: string;
     stop_hook_active?: boolean;
     [key: string]: unknown;
 }
@@ -32,6 +33,9 @@ export interface LLMHandlerConfig {
     enabled?: boolean;
     sessionIsolation?: boolean;
     depends?: string[];
+    async?: boolean;
+    agent?: string;
+    project?: string;
 }
 /** Script handler config */
 export interface ScriptHandlerConfig {
@@ -43,6 +47,9 @@ export interface ScriptHandlerConfig {
     enabled?: boolean;
     sessionIsolation?: boolean;
     depends?: string[];
+    async?: boolean;
+    agent?: string;
+    project?: string;
 }
 /** Inline handler config */
 export interface InlineHandlerConfig {
@@ -54,6 +61,9 @@ export interface InlineHandlerConfig {
     enabled?: boolean;
     sessionIsolation?: boolean;
     depends?: string[];
+    async?: boolean;
+    agent?: string;
+    project?: string;
 }
 /** Union of all handler configs */
 export type HandlerConfig = ScriptHandlerConfig | InlineHandlerConfig | LLMHandlerConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mauribadnights/clooks",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Persistent hook runtime for Claude Code — eliminates process spawning overhead and gives you observability",
   "bin": {
     "clooks": "./dist/cli.js"
@@ -33,10 +33,12 @@
   "files": [
     "dist",
     "hooks",
+    "agents",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
+    "blessed": "^0.1.81",
     "commander": "^14.0.3",
     "yaml": "^2.8.3"
   },
@@ -49,6 +51,7 @@
     }
   },
   "devDependencies": {
+    "@types/blessed": "^0.1.27",
     "@types/node": "^25.5.0",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",