@lotargo/memory_plugin 1.1.5 → 1.1.6

package/mcp-server/memory.js

@@ -1,72 +1,72 @@
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { join, basename } from "path";
-import { homedir } from "os";
-
-function resolveMemoryDir() {
-  if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
-  if (process.env.OPENCODE_CONFIG_DIR) return join(process.env.OPENCODE_CONFIG_DIR, "memory");
-
-  const legacyDir = join(homedir(), ".config", "opencode", "memory");
-  if (existsSync(legacyDir)) {
-    return legacyDir;
-  }
-
-  if (process.platform === "win32") {
-    const appData = process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), "AppData", "Local");
-    return join(appData, "opencode", "memory");
-  }
-
-  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(configHome, "opencode", "memory");
-}
-
-export const MEMORY_DIR = resolveMemoryDir();
-export const GLOBAL_KEY = "global";
-
-export async function ensureDir() {
-  if (!existsSync(MEMORY_DIR)) await mkdir(MEMORY_DIR, { recursive: true });
-  const storageDir = join(MEMORY_DIR, "storage");
-  const blobsDir = join(storageDir, "blobs");
-  const modelsDir = join(storageDir, "models");
-  const exportsDir = join(MEMORY_DIR, "exports");
-  if (!existsSync(blobsDir)) await mkdir(blobsDir, { recursive: true });
-  if (!existsSync(modelsDir)) await mkdir(modelsDir, { recursive: true });
-  if (!existsSync(exportsDir)) await mkdir(exportsDir, { recursive: true });
-}
-
-export function projectName(worktree, directory) {
-  const dir = worktree || directory || process.cwd();
-  return dir ? basename(dir) : "default";
-}
-
-export function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectName(worktree, directory);
-}
-
-function memoryPath(key) {
-  return join(MEMORY_DIR, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
-}
-
-export async function readMemory(key) {
-  const fp = memoryPath(key);
-  if (!existsSync(fp)) return [];
-  const content = await readFile(fp, "utf-8");
-  return content.split("\n").filter((l) => l.startsWith("- ["));
-}
-
-export async function readMemoryRaw(key) {
-  return (await readMemory(key)).map((e) => e.slice(2));
-}
-
-export async function writeMemory(key, entries) {
-  const header = `# ${key === GLOBAL_KEY ? "Global Memory" : `Memory: ${key}`}\n\n`;
-  await writeFile(memoryPath(key), header + entries.join("\n") + "\n");
-}
-
-export function today() {
-  const d = new Date();
-  const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-  const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
-  return `${date} ${time}`;
-}
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+
+function resolveMemoryDir() {
+  if (process.env.MEMORY_DIR) return process.env.MEMORY_DIR;
+  if (process.env.OPENCODE_CONFIG_DIR) return join(process.env.OPENCODE_CONFIG_DIR, "memory");
+
+  const legacyDir = join(homedir(), ".config", "opencode", "memory");
+  if (existsSync(legacyDir)) {
+    return legacyDir;
+  }
+
+  if (process.platform === "win32") {
+    const appData = process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), "AppData", "Local");
+    return join(appData, "opencode", "memory");
+  }
+
+  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(configHome, "opencode", "memory");
+}
+
+export const MEMORY_DIR = resolveMemoryDir();
+export const GLOBAL_KEY = "global";
+
+export async function ensureDir() {
+  if (!existsSync(MEMORY_DIR)) await mkdir(MEMORY_DIR, { recursive: true });
+  const storageDir = join(MEMORY_DIR, "storage");
+  const blobsDir = join(storageDir, "blobs");
+  const modelsDir = join(storageDir, "models");
+  const exportsDir = join(MEMORY_DIR, "exports");
+  if (!existsSync(blobsDir)) await mkdir(blobsDir, { recursive: true });
+  if (!existsSync(modelsDir)) await mkdir(modelsDir, { recursive: true });
+  if (!existsSync(exportsDir)) await mkdir(exportsDir, { recursive: true });
+}
+
+export function projectName(worktree, directory) {
+  const dir = worktree || directory || process.cwd();
+  return dir ? basename(dir) : "default";
+}
+
+export function scopeKey(scope, worktree, directory) {
+  return scope === "global" ? GLOBAL_KEY : projectName(worktree, directory);
+}
+
+function memoryPath(key) {
+  return join(MEMORY_DIR, `${key.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
+}
+
+export async function readMemory(key) {
+  const fp = memoryPath(key);
+  if (!existsSync(fp)) return [];
+  const content = await readFile(fp, "utf-8");
+  return content.split("\n").filter((l) => l.startsWith("- ["));
+}
+
+export async function readMemoryRaw(key) {
+  return (await readMemory(key)).map((e) => e.slice(2));
+}
+
+export async function writeMemory(key, entries) {
+  const header = `# ${key === GLOBAL_KEY ? "Global Memory" : `Memory: ${key}`}\n\n`;
+  await writeFile(memoryPath(key), header + entries.join("\n") + "\n");
+}
+
+export function today() {
+  const d = new Date();
+  const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  return `${date} ${time}`;
+}

package/mcp-server/ml/gpu_monitor.js

@@ -0,0 +1,166 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+export async function getGpuUtilizationAsync() {
+  try {
+    const { stdout } = await execFileAsync("nvidia-smi", 
+      ["--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
+      { timeout: 1000 }
+    );
+    const val = parseInt(stdout.trim(), 10);
+    if (!isNaN(val)) return val;
+  } catch {}
+
+  if (process.platform === "win32") {
+    try {
+      const { stdout } = await execFileAsync("powershell", 
+        ["-NoProfile", "-Command", "(Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine | Measure-Object -Property UtilizationPercentage -Sum).Sum"],
+        { timeout: 1500 }
+      );
+      const val = parseInt(stdout.trim(), 10);
+      if (!isNaN(val)) return Math.min(100, val);
+    } catch {}
+  }
+
+  return null;
+}
+
+export class GpuMonitor {
+  constructor(sampleIntervalMs = 100) {
+    this.intervalMs = sampleIntervalMs;
+    this.samples = [];
+    this.timer = null;
+    this.isMonitoring = false;
+  }
+
+  start() {
+    this.samples = [];
+    this.isMonitoring = true;
+    this.sample();
+
+    this.timer = setInterval(() => {
+      if (this.isMonitoring) {
+        this.sample();
+      }
+    }, this.intervalMs);
+  }
+
+  async sample() {
+    const util = await getGpuUtilizationAsync();
+    if (util !== null) {
+      this.samples.push(util);
+    }
+  }
+
+  stop() {
+    this.isMonitoring = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (this.samples.length === 0) {
+      return { avg: null, peak: null, samplesCount: 0 };
+    }
+
+    const max = Math.max(...this.samples);
+    const sum = this.samples.reduce((a, b) => a + b, 0);
+    const avg = Math.round(sum / this.samples.length);
+
+    return {
+      avg,
+      peak: max,
+      samplesCount: this.samples.length,
+      samples: this.samples,
+    };
+  }
+}
+
+export class ExecutionTracer {
+  constructor(name = "Batch Inference") {
+    this.name = name;
+    this.stages = [];
+    this.currentStage = null;
+    this.startTime = Date.now();
+  }
+
+  startStage(stageName, category = "CPU") {
+    const now = performance.now();
+    if (this.currentStage) {
+      this.currentStage.duration = now - this.currentStage.startTime;
+      this.stages.push(this.currentStage);
+    }
+    this.currentStage = {
+      name: stageName,
+      category, // "CPU" or "GPU"
+      startTime: now,
+      duration: 0,
+    };
+  }
+
+  endStage() {
+    const now = performance.now();
+    if (this.currentStage) {
+      this.currentStage.duration = now - this.currentStage.startTime;
+      this.stages.push(this.currentStage);
+      this.currentStage = null;
+    }
+  }
+
+  getSummary(gpuStats = null) {
+    this.endStage();
+    const totalMs = this.stages.reduce((sum, s) => sum + s.duration, 0);
+
+    const breakdown = this.stages.map((s) => ({
+      name: s.name,
+      category: s.category,
+      durationMs: parseFloat(s.duration.toFixed(2)),
+      pct: totalMs > 0 ? parseFloat(((s.duration / totalMs) * 100).toFixed(1)) : 0,
+    }));
+
+    const cpuTime = this.stages.filter((s) => s.category === "CPU").reduce((sum, s) => sum + s.duration, 0);
+    const gpuTime = this.stages.filter((s) => s.category === "GPU").reduce((sum, s) => sum + s.duration, 0);
+
+    return {
+      name: this.name,
+      totalMs: parseFloat(totalMs.toFixed(2)),
+      cpuMs: parseFloat(cpuTime.toFixed(2)),
+      gpuMs: parseFloat(gpuTime.toFixed(2)),
+      cpuPct: totalMs > 0 ? parseFloat(((cpuTime / totalMs) * 100).toFixed(1)) : 0,
+      gpuPct: totalMs > 0 ? parseFloat(((gpuTime / totalMs) * 100).toFixed(1)) : 0,
+      breakdown,
+      gpuStats,
+    };
+  }
+
+  printTraceReport(gpuStats = null, minGpuThreshold = 0) {
+    const summary = this.getSummary(gpuStats);
+    const line = "─".repeat(65);
+
+    console.log(`\n┌${line}┐`);
+    console.log(`│ CPU/GPU OPERATION TRACE & BOTTLENECK PROFILE: ${summary.name.padEnd(16)} │`);
+    console.log(`├${line}┤`);
+
+    for (const b of summary.breakdown) {
+      const icon = b.category === "GPU" ? "⚡ [GPU]" : "💻 [CPU]";
+      const label = `${icon} ${b.name}`.padEnd(42);
+      const timeStr = `${b.durationMs.toFixed(1)}ms (${b.pct.toFixed(1)}%)`.padStart(18);
+      console.log(`│ ${label}${timeStr} │`);
+    }
+
+    console.log(`├${line}┤`);
+    console.log(`│ Total Batch Time: ${summary.totalMs.toFixed(1)}ms | CPU Time: ${summary.cpuMs.toFixed(1)}ms (${summary.cpuPct}%) | GPU Engine Time: ${summary.gpuMs.toFixed(1)}ms (${summary.gpuPct}%) │`);
+
+    if (gpuStats && gpuStats.peak !== null) {
+      const statsBadge = `Peak: ${gpuStats.peak}%, Avg: ${gpuStats.avg}%`;
+      console.log(`│ GPU Hardware Load: ${statsBadge.padEnd(44)} │`);
+      console.log(`└${line}┘\n`);
+    } else {
+      console.log(`└${line}┘\n`);
+    }
+
+    return summary;
+  }
+}