kiku-agent 1.0.0 → 1.0.4

package/server/agent/eventBus.js

@@ -1,103 +1,107 @@
-class EventBus {
-  constructor() {
-    this._listeners = new Map();
-    this._history = [];
-    this._maxHistory = 50;
-  }
-
-  on(event, fn) {
-    if (!this._listeners.has(event)) this._listeners.set(event, new Set());
-    this._listeners.get(event).add(fn);
-    return () => this.off(event, fn);
-  }
-
-  once(event, fn) {
-    const wrapper = (data, name) => {
-      this.off(event, wrapper);
-      fn(data, name);
-    };
-    return this.on(event, wrapper);
-  }
-
-  off(event, fn) {
-    const set = this._listeners.get(event);
-    if (set) set.delete(fn);
-  }
-
-  emit(event, data) {
-    this._history.push({ event, data, ts: Date.now() });
-    if (this._history.length > this._maxHistory) {
-      this._history.shift();
-    }
-
-    const exactSet = this._listeners.get(event);
-    if (exactSet) {
-      for (const fn of exactSet) {
-        try { fn(data, event); } catch { /* swallow */ }
-      }
-    }
-
-    const ns = event.split(':')[0];
-    const wildcardEvent = ns + ':*';
-    const wildcardSet = this._listeners.get(wildcardEvent);
-    if (wildcardSet) {
-      for (const fn of wildcardSet) {
-        try { fn(data, event); } catch { /* swallow */ }
-      }
-    }
-
-    const globalSet = this._listeners.get('*');
-    if (globalSet) {
-      for (const fn of globalSet) {
-        try { fn(data, event); } catch { /* swallow */ }
-      }
-    }
-  }
-
-  getHistory(limit = this._maxHistory) {
-    return this._history.slice(-limit);
-  }
-
-  clear() {
-    this._listeners.clear();
-    this._history.length = 0;
-  }
-}
-
-export const eventBus = new EventBus();
-
-export const Events = Object.freeze({
-  AGENT_QUERY_START:    'agent:query:start',
-  AGENT_QUERY_END:      'agent:query:end',
-  AGENT_QUERY_ERROR:    'agent:query:error',
-  AGENT_STATE_CHANGE:   'agent:state:change',
-
-  AGENT_REASONING_START: 'agent:reasoning:start',
-  AGENT_REASONING_DELTA: 'agent:reasoning:delta',
-  AGENT_REASONING_END:   'agent:reasoning:end',
-  AGENT_TOKEN_START:     'agent:token:start',
-  AGENT_TOKEN_DELTA:     'agent:token:delta',
-  AGENT_TOKEN_END:       'agent:token:end',
-  AGENT_FINAL_ANSWER:    'agent:final:answer',
-
-  AGENT_TOOL_START:    'agent:tool:start',
-  AGENT_TOOL_RESULT:   'agent:tool:result',
-  AGENT_TOOL_ERROR:    'agent:tool:error',
-
-  MUSIC_PLAY:          'music:play',
-  MUSIC_STOP:          'music:stop',
-  MUSIC_QUEUE_CHANGE:  'music:queue:change',
-  MUSIC_STATE_CHANGE:  'music:state:change',
-
-  SESSION_SAVED:       'session:saved',
-  SESSION_ARCHIVED:    'session:archived',
-  MEMORY_FACT_ADDED:   'memory:fact:added',
-
-  UI_RENDER:           'ui:render',
-  UI_CLEAR:            'ui:clear',
-  UI_MESSAGE:          'ui:message',
-
-  QUEUE_ITEM_ADDED:    'queue:item:added',
-  QUEUE_ITEM_CONSUMED: 'queue:item:consumed',
-  QUEUE_CLEARED:       'queue:cleared',
-});
+class EventBus {
+  constructor() {
+    this._listeners = new Map();
+    this._history = [];
+    this._maxHistory = 50;
+  }
+
+  on(event, fn) {
+    if (!this._listeners.has(event)) this._listeners.set(event, new Set());
+    this._listeners.get(event).add(fn);
+    return () => this.off(event, fn);
+  }
+
+  once(event, fn) {
+    const wrapper = (data, name) => {
+      this.off(event, wrapper);
+      fn(data, name);
+    };
+    return this.on(event, wrapper);
+  }
+
+  off(event, fn) {
+    const set = this._listeners.get(event);
+    if (set) set.delete(fn);
+  }
+
+  emit(event, data) {
+    this._history.push({ event, data, ts: Date.now() });
+    if (this._history.length > this._maxHistory) {
+      this._history.shift();
+    }
+
+    const exactSet = this._listeners.get(event);
+    if (exactSet) {
+      for (const fn of exactSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+
+    const ns = event.split(':')[0];
+    const wildcardEvent = ns + ':*';
+    const wildcardSet = this._listeners.get(wildcardEvent);
+    if (wildcardSet) {
+      for (const fn of wildcardSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+
+    const globalSet = this._listeners.get('*');
+    if (globalSet) {
+      for (const fn of globalSet) {
+        try { fn(data, event); } catch { /* swallow */ }
+      }
+    }
+  }
+
+  getHistory(limit = this._maxHistory) {
+    return this._history.slice(-limit);
+  }
+
+  clear() {
+    this._listeners.clear();
+    this._history.length = 0;
+  }
+}
+
+export const eventBus = new EventBus();
+
+export const Events = Object.freeze({
+  AGENT_QUERY_START:    'agent:query:start',
+  AGENT_QUERY_END:      'agent:query:end',
+  AGENT_QUERY_ERROR:    'agent:query:error',
+  AGENT_STATE_CHANGE:   'agent:state:change',
+
+  AGENT_REASONING_START: 'agent:reasoning:start',
+  AGENT_REASONING_DELTA: 'agent:reasoning:delta',
+  AGENT_REASONING_END:   'agent:reasoning:end',
+  AGENT_TOKEN_START:     'agent:token:start',
+  AGENT_TOKEN_DELTA:     'agent:token:delta',
+  AGENT_TOKEN_END:       'agent:token:end',
+  AGENT_FINAL_ANSWER:    'agent:final:answer',
+
+  AGENT_TOOL_START:    'agent:tool:start',
+  AGENT_TOOL_RESULT:   'agent:tool:result',
+  AGENT_TOOL_ERROR:    'agent:tool:error',
+
+  AGENT_PLAN_START:       'agent:plan:start',
+  AGENT_PLAN_STEP_UPDATE: 'agent:plan:step:update',
+  AGENT_PLAN_COMPLETE:    'agent:plan:complete',
+
+  MUSIC_PLAY:          'music:play',
+  MUSIC_STOP:          'music:stop',
+  MUSIC_QUEUE_CHANGE:  'music:queue:change',
+  MUSIC_STATE_CHANGE:  'music:state:change',
+
+  SESSION_SAVED:       'session:saved',
+  SESSION_ARCHIVED:    'session:archived',
+  MEMORY_FACT_ADDED:   'memory:fact:added',
+
+  UI_RENDER:           'ui:render',
+  UI_CLEAR:            'ui:clear',
+  UI_MESSAGE:          'ui:message',
+
+  QUEUE_ITEM_ADDED:    'queue:item:added',
+  QUEUE_ITEM_CONSUMED: 'queue:item:consumed',
+  QUEUE_CLEARED:       'queue:cleared',
+});

package/server/agent/gpuMetrics.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { C } from './ui.js';
+
+function runProcessCapture(cmd, args, timeoutMs = 2500) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch {}
+      finish({ ok: false, stdout: '', stderr: 'timeout' });
+    }, timeoutMs);
+
+    child.stdout?.on('data', d => { stdout += d.toString(); });
+    child.stderr?.on('data', d => { stderr += d.toString(); });
+
+    child.on('error', (err) => finish({ ok: false, stdout: '', stderr: err.message }));
+    child.on('close', (code) => finish({ ok: code === 0, stdout: stdout.trim(), stderr: stderr.trim() }));
+  });
+}
+
+export async function getGpuMetrics() {
+
+  const nv = await runProcessCapture('nvidia-smi', [
+    '--query-gpu=name,memory.total,memory.used,memory.free,utilization.gpu,temperature.gpu,driver_version',
+    '--format=csv,noheader,nounits'
+  ]);
+
+  if (nv.ok && nv.stdout) {
+    const lines = nv.stdout.split('\n').map(l => l.trim()).filter(Boolean);
+    const gpus = lines.map((line, idx) => {
+      const [name, total, used, free, util, temp, driver] = line.split(',').map(s => s?.trim());
+      const totalMb = parseFloat(total) || 0;
+      const usedMb = parseFloat(used) || 0;
+      const freeMb = parseFloat(free) || 0;
+      const utilPercent = parseFloat(util) || 0;
+      const tempC = parseFloat(temp) || 0;
+      const usedPct = totalMb > 0 ? Number(((usedMb / totalMb) * 100).toFixed(1)) : 0;
+
+      return {
+        index: idx,
+        name: name || 'NVIDIA GPU',
+        vendor: 'NVIDIA',
+        totalMb,
+        usedMb,
+        freeMb,
+        totalGb: (totalMb / 1024).toFixed(1),
+        usedGb: (usedMb / 1024).toFixed(1),
+        freeGb: (freeMb / 1024).toFixed(1),
+        usedPercent: usedPct,
+        utilizationGpu: utilPercent,
+        temperatureC: tempC,
+        driverVersion: driver || 'N/A',
+      };
+    });
+
+    if (gpus.length > 0) {
+      return {
+        available: true,
+        vendor: 'NVIDIA',
+        count: gpus.length,
+        primary: gpus[0],
+        gpus,
+      };
+    }
+  }
+
+ 
+  if (process.platform === 'win32') {
+    const ps = await runProcessCapture('powershell', [
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      'Get-CimInstance Win32_VideoController | Select-Object Name, AdapterRAM | ConvertTo-Json'
+    ]);
+
+    if (ps.ok && ps.stdout) {
+      try {
+        let data = JSON.parse(ps.stdout);
+        if (!Array.isArray(data)) data = [data];
+        const gpus = data.filter(item => item?.Name).map((item, idx) => {
+          const ramBytes = item.AdapterRAM || 0;
+          const totalMb = Math.round(ramBytes / (1024 * 1024));
+          const name = String(item.Name);
+          const vendor = name.includes('NVIDIA')
+            ? 'NVIDIA'
+            : name.includes('AMD') || name.includes('Radeon')
+            ? 'AMD'
+            : name.includes('Intel')
+            ? 'Intel'
+            : 'Generic';
+
+          return {
+            index: idx,
+            name,
+            vendor,
+            totalMb,
+            usedMb: null,
+            freeMb: null,
+            totalGb: (totalMb / 1024).toFixed(1),
+            usedGb: null,
+            freeGb: null,
+            usedPercent: null,
+            utilizationGpu: null,
+            temperatureC: null,
+            driverVersion: 'N/A',
+          };
+        });
+
+        if (gpus.length > 0) {
+          return {
+            available: true,
+            vendor: gpus[0].vendor,
+            count: gpus.length,
+            primary: gpus[0],
+            gpus,
+          };
+        }
+      } catch {}
+    }
+  }
+
+
+  if (process.platform === 'darwin') {
+    const mac = await runProcessCapture('system_profiler', ['SPDisplaysDataType', '-json']);
+    if (mac.ok && mac.stdout) {
+      try {
+        const data = JSON.parse(mac.stdout);
+        const displays = data.SPDisplaysDataType || [];
+        if (displays.length > 0) {
+          const first = displays[0];
+          return {
+            available: true,
+            vendor: 'Apple',
+            count: displays.length,
+            primary: {
+              index: 0,
+              name: first.sppci_model || first._name || 'Apple GPU',
+              vendor: 'Apple',
+              totalMb: 0,
+              usedMb: null,
+              freeMb: null,
+              totalGb: 'Unified',
+              usedGb: null,
+              freeGb: null,
+              usedPercent: null,
+              utilizationGpu: null,
+              temperatureC: null,
+              driverVersion: 'Metal',
+            },
+            gpus: displays.map((d, i) => ({
+              index: i,
+              name: d.sppci_model || d._name || 'Apple GPU',
+              vendor: 'Apple',
+            })),
+          };
+        }
+      } catch {}
+    }
+  }
+
+  return {
+    available: false,
+    message: 'No GPU hardware acceleration metrics available',
+  };
+}
+
+export function formatProgressBar(percent = 0, width = 16) {
+  const safePct = Math.max(0, Math.min(100, Number(percent) || 0));
+  const filled = Math.round((safePct / 100) * width);
+  const empty = Math.max(0, width - filled);
+
+  let barColor = C.emerald;
+  if (safePct >= 85) barColor = C.roseGlow;
+  else if (safePct >= 60) barColor = C.gold;
+
+  const bar = `${barColor}${'█'.repeat(filled)}${C.dim}${'░'.repeat(empty)}${C.reset}`;
+  return `[${bar}] ${barColor}${safePct.toFixed(1)}%${C.reset}`;
+}