claudeye 0.2.2 → 0.3.0

package/.next/standalone/bin/claudeye.mjs

@@ -7,8 +7,8 @@ import { spawn, execSync } from "node:child_process";
 import { createServer } from "node:net";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync } from "node:fs";
-import { homedir, platform } from "node:os";
+import { existsSync, rmSync } from "node:fs";
+import { homedir, platform, networkInterfaces } from "node:os";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -27,7 +27,13 @@ Options:
   --projects-path, -p <path>  Path to Claude projects directory
                               (default: ~/.claude/projects)
   --port <number>             Preferred port (default: 8020)
+  --host <address>            Host to bind to (default: localhost)
+                              Use 0.0.0.0 for LAN access
   --evals <path>              Path to evals/enrichments file (JS/TS module)
+  --cache <on|off>            Enable/disable caching (default: on)
+  --cache-path <path>         Custom cache directory
+                              (default: ~/.claudeye/cache)
+  --cache-clear               Clear all cached results and exit
   --no-open                   Don't auto-open the browser
   -h, --help                  Show this help message
 `.trim();
@@ -36,8 +42,12 @@ Options:
 const args = process.argv.slice(2);
 let projectsPath = resolve(homedir(), ".claude", "projects");
 let preferredPort = 8020;
+let preferredHost = "localhost";
 let autoOpen = true;
 let evalsPath = "";
+let cacheMode = "on";
+let cachePath = "";
+let cacheClear = false;
 
 /** Read the next value for a flag, supporting both `--flag value` and `--flag=value`. */
 function readFlagValue(flag, idx) {
@@ -74,10 +84,30 @@ for (let i = 0; i < args.length; i++) {
       preferredPort = parseInt(inlineValue ?? readFlagValue(flag, i), 10) || 8020;
       if (inlineValue === null) i++;
       break;
+    case "--host":
+      preferredHost = inlineValue ?? readFlagValue(flag, i);
+      if (inlineValue === null) i++;
+      break;
     case "--evals":
       evalsPath = resolve(inlineValue ?? readFlagValue(flag, i));
       if (inlineValue === null) i++;
       break;
+    case "--cache":
+      cacheMode = inlineValue ?? readFlagValue(flag, i);
+      if (inlineValue === null) i++;
+      if (cacheMode !== "on" && cacheMode !== "off") {
+        console.error(`Error: --cache must be "on" or "off"\n`);
+        console.log(HELP);
+        process.exit(1);
+      }
+      break;
+    case "--cache-path":
+      cachePath = resolve(inlineValue ?? readFlagValue(flag, i));
+      if (inlineValue === null) i++;
+      break;
+    case "--cache-clear":
+      cacheClear = true;
+      break;
     case "--no-open":
       autoOpen = false;
       break;
@@ -88,6 +118,19 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
+// ── Cache clear (standalone action) ──────────────────────────────────────────
+if (cacheClear) {
+  const clearPath = cachePath || resolve(homedir(), ".claudeye", "cache");
+  try {
+    rmSync(clearPath, { recursive: true, force: true });
+    console.log(`Cache cleared: ${clearPath}`);
+  } catch (err) {
+    console.error(`Failed to clear cache: ${err.message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
 // ── Validate ────────────────────────────────────────────────────────────────
 if (!existsSync(serverScript)) {
   console.error(
@@ -104,21 +147,37 @@ if (!existsSync(projectsPath)) {
   );
 }
 
+// ── Network address detection ────────────────────────────────────────────────
+function getNetworkAddress() {
+  for (const addrs of Object.values(networkInterfaces())) {
+    for (const iface of addrs) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "0.0.0.0";
+}
+
 // ── Port selection ──────────────────────────────────────────────────────────
-function findAvailablePort(preferred) {
+function resolveBindAddress(host) {
+  return host === "localhost" ? "127.0.0.1" : host;
+}
+
+function findAvailablePort(preferred, host) {
+  const bindAddr = resolveBindAddress(host);
   return new Promise((resolve, reject) => {
     const srv = createServer();
-    srv.listen(preferred, "127.0.0.1", () => {
+    srv.listen(preferred, bindAddr, () => {
       srv.close(() => resolve(preferred));
     });
     srv.on("error", () => {
-      // Preferred port busy — let the OS pick one
-      const srv2 = createServer();
-      srv2.listen(0, "127.0.0.1", () => {
-        const port = srv2.address().port;
-        srv2.close(() => resolve(port));
+      const fallback = createServer();
+      fallback.listen(0, bindAddr, () => {
+        const port = fallback.address().port;
+        fallback.close(() => resolve(port));
       });
-      srv2.on("error", reject);
+      fallback.on("error", reject);
     });
   });
 }
@@ -153,34 +212,62 @@ async function waitForServer(url, timeoutMs = 15_000, intervalMs = 150) {
   throw new Error("Server readiness timeout");
 }
 
+// ── Startup logging ─────────────────────────────────────────────────────────
+function logServerInfo(port, localUrl) {
+  console.log(`Starting Claudeye dashboard...`);
+  console.log(`  Projects: ${projectsPath}`);
+  if (evalsPath) console.log(`  Evals:    ${evalsPath}`);
+  if (cacheMode === "off") {
+    console.log(`  Cache:    disabled`);
+  } else {
+    const displayPath = cachePath || resolve(homedir(), ".claudeye", "cache");
+    console.log(`  Cache:    local (${displayPath})`);
+  }
+  if (preferredHost === "0.0.0.0") {
+    console.log(`  Local:    ${localUrl}`);
+    console.log(`  Network:  http://${getNetworkAddress()}:${port}`);
+  } else {
+    console.log(`  URL:      http://${preferredHost}:${port}`);
+  }
+  console.log();
+}
+
 // ── Main ────────────────────────────────────────────────────────────────────
 async function main() {
-  const port = await findAvailablePort(preferredPort);
+  const port = await findAvailablePort(preferredPort, preferredHost);
   if (port !== preferredPort) {
     console.log(`Port ${preferredPort} is busy, using port ${port} instead.`);
   }
 
-  const url = `http://localhost:${port}`;
-  console.log(`Starting Claudeye dashboard...`);
-  console.log(`  Projects: ${projectsPath}`);
-  if (evalsPath) console.log(`  Evals:    ${evalsPath}`);
-  console.log(`  URL:      ${url}\n`);
+  const localUrl = `http://localhost:${port}`;
+  logServerInfo(port, localUrl);
+
+  const env = {
+    ...process.env,
+    PORT: String(port),
+    HOSTNAME: preferredHost,
+    CLAUDE_PROJECTS_PATH: projectsPath,
+  };
+  if (evalsPath) {
+    env.CLAUDEYE_EVALS_MODULE = evalsPath;
+    env.CLAUDEYE_DIST_PATH = resolve(packageRoot, "dist");
+  }
+  if (cacheMode === "off") {
+    env.CLAUDEYE_CACHE = "off";
+  }
+  if (cachePath) {
+    env.CLAUDEYE_CACHE_PATH = cachePath;
+  }
 
   const child = spawn(process.execPath, [serverScript], {
     cwd: standaloneDir,
     stdio: "inherit",
-    env: {
-      ...process.env,
-      PORT: String(port),
-      HOSTNAME: "localhost",
-      CLAUDE_PROJECTS_PATH: projectsPath,
-      ...(evalsPath ? { CLAUDEYE_EVALS_MODULE: evalsPath, CLAUDEYE_DIST_PATH: resolve(packageRoot, "dist") } : {}),
-    },
+    env,
   });
 
   if (autoOpen) {
-    waitForServer(url).then(() => openBrowser(url)).catch(() => {
-      console.warn(`\nServer did not respond within 15 s.\nOpen manually: ${url}\n`);
+    waitForServer(localUrl).then(() => openBrowser(localUrl)).catch(() => {
+      console.warn(`\nServer did not respond within 15 s.\nOpen manually: ${localUrl}\n`);
     });
   }
 

package/.next/standalone/components/navbar.tsx

@@ -5,6 +5,7 @@ import React from "react";
 import { Logo } from "@/components/logo";
 import { ThemeToggle } from "@/components/theme-toggle";
 import { ReachDevelopers } from "@/components/reach-developers";
+import { RefreshButton } from "@/app/components/refresh-button";
 
 export const Navbar: React.FC = () => {
   return (
@@ -31,6 +32,7 @@ export const Navbar: React.FC = () => {
             </div>
           </div>
           <div className="flex items-center gap-2">
+            <RefreshButton />
             <ReachDevelopers />
             <ThemeToggle />
           </div>

package/.next/standalone/dist/app.js

@@ -45,15 +45,20 @@ exports.createApp = createApp;
  */
 const registry_1 = require("./registry");
 const enrich_registry_1 = require("./enrich-registry");
+const condition_registry_1 = require("./condition-registry");
 const LOADING_KEY = "__CLAUDEYE_LOADING_EVALS__";
 function createApp() {
     const app = {
-        eval(name, fn) {
-            (0, registry_1.registerEval)(name, fn);
+        condition(fn) {
+            (0, condition_registry_1.setGlobalCondition)(fn);
             return app;
         },
-        enrich(name, fn) {
-            (0, enrich_registry_1.registerEnricher)(name, fn);
+        eval(name, fn, options) {
+            (0, registry_1.registerEval)(name, fn, options === null || options === void 0 ? void 0 : options.condition, options === null || options === void 0 ? void 0 : options.scope, options === null || options === void 0 ? void 0 : options.subagentType);
+            return app;
+        },
+        enrich(name, fn, options) {
+            (0, enrich_registry_1.registerEnricher)(name, fn, options === null || options === void 0 ? void 0 : options.condition, options === null || options === void 0 ? void 0 : options.scope, options === null || options === void 0 ? void 0 : options.subagentType);
             return app;
         },
         async listen(port, options) {
@@ -69,6 +74,7 @@ function createApp() {
             const { spawnServer } = await Promise.resolve().then(() => __importStar(require("./server-spawn")));
             await spawnServer((_a = port !== null && port !== void 0 ? port : options === null || options === void 0 ? void 0 : options.port) !== null && _a !== void 0 ? _a : 8020, {
                 open: (_b = options === null || options === void 0 ? void 0 : options.open) !== null && _b !== void 0 ? _b : true,
+                host: options === null || options === void 0 ? void 0 : options.host,
             });
         },
     };

package/.next/standalone/dist/condition-registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setGlobalCondition = setGlobalCondition;
+exports.getGlobalCondition = getGlobalCondition;
+exports.clearGlobalCondition = clearGlobalCondition;
+const REGISTRY_KEY = "__CLAUDEYE_CONDITION_REGISTRY__";
+function setGlobalCondition(fn) {
+    const g = globalThis;
+    g[REGISTRY_KEY] = fn;
+}
+function getGlobalCondition() {
+    var _a;
+    const g = globalThis;
+    return (_a = g[REGISTRY_KEY]) !== null && _a !== void 0 ? _a : null;
+}
+function clearGlobalCondition() {
+    const g = globalThis;
+    g[REGISTRY_KEY] = null;
+}
+//# sourceMappingURL=condition-registry.js.map

package/.next/standalone/dist/enrich-registry.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerEnricher = registerEnricher;
 exports.getRegisteredEnrichers = getRegisteredEnrichers;
+exports.getSessionScopedEnrichers = getSessionScopedEnrichers;
+exports.getSubagentScopedEnrichers = getSubagentScopedEnrichers;
+exports.hasSubagentEnrichers = hasSubagentEnrichers;
 exports.hasEnrichers = hasEnrichers;
 exports.clearEnrichers = clearEnrichers;
 const REGISTRY_KEY = "__CLAUDEYE_ENRICHER_REGISTRY__";
@@ -12,20 +15,40 @@ function getRegistry() {
     }
     return g[REGISTRY_KEY];
 }
-function registerEnricher(name, fn) {
+function registerEnricher(name, fn, condition, scope = 'session', subagentType) {
     const registry = getRegistry();
+    const entry = { name, fn, scope };
+    if (condition)
+        entry.condition = condition;
+    if (subagentType)
+        entry.subagentType = subagentType;
     // Replace if an enricher with the same name already exists
     const idx = registry.findIndex((e) => e.name === name);
     if (idx >= 0) {
-        registry[idx] = { name, fn };
+        registry[idx] = entry;
     }
     else {
-        registry.push({ name, fn });
+        registry.push(entry);
     }
 }
 function getRegisteredEnrichers() {
     return getRegistry();
 }
+function getSessionScopedEnrichers() {
+    return getRegistry().filter((e) => e.scope === 'session' || e.scope === 'both');
+}
+function getSubagentScopedEnrichers(subagentType) {
+    return getRegistry().filter((e) => {
+        if (e.scope !== 'subagent' && e.scope !== 'both')
+            return false;
+        if (e.subagentType && subagentType && e.subagentType !== subagentType)
+            return false;
+        return true;
+    });
+}
+function hasSubagentEnrichers() {
+    return getRegistry().some((e) => e.scope === 'subagent' || e.scope === 'both');
+}
 function hasEnrichers() {
     return getRegistry().length > 0;
 }

package/.next/standalone/dist/enrich-runner.js

@@ -6,33 +6,88 @@ exports.runAllEnrichers = runAllEnrichers;
  * Each enricher is individually try/caught so one failure doesn't block others.
  */
 const enrich_registry_1 = require("./enrich-registry");
-async function runAllEnrichers(entries, stats, projectName, sessionId) {
-    const registeredEnrichers = (0, enrich_registry_1.getRegisteredEnrichers)();
+const condition_registry_1 = require("./condition-registry");
+async function runAllEnrichers(entries, stats, projectName, sessionId, enrichersToRun, contextOverrides) {
+    const registeredEnrichers = enrichersToRun !== null && enrichersToRun !== void 0 ? enrichersToRun : (0, enrich_registry_1.getRegisteredEnrichers)();
     const results = [];
     const overallStart = performance.now();
-    for (const { name, fn } of registeredEnrichers) {
-        const start = performance.now();
+    const context = Object.assign({ entries, stats, projectName, sessionId, scope: 'session' }, contextOverrides);
+    // Check global condition first
+    const globalCondition = (0, condition_registry_1.getGlobalCondition)();
+    let globalSkip = false;
+    if (globalCondition) {
         try {
-            const data = await fn({ entries, stats, projectName, sessionId });
-            const durationMs = Math.round(performance.now() - start);
-            results.push({ name, data, durationMs });
+            const result = await globalCondition(context);
+            if (!result)
+                globalSkip = true;
         }
-        catch (err) {
-            const durationMs = Math.round(performance.now() - start);
+        catch (_a) {
+            globalSkip = true;
+        }
+    }
+    if (globalSkip) {
+        // All enrichers skipped due to global condition
+        for (const { name } of registeredEnrichers) {
             results.push({
                 name,
                 data: {},
-                durationMs,
-                error: err instanceof Error ? err.message : String(err),
+                durationMs: 0,
+                skipped: true,
             });
         }
     }
+    else {
+        for (const { name, fn, condition } of registeredEnrichers) {
+            // Check per-enrichment condition
+            if (condition) {
+                try {
+                    const shouldRun = await condition(context);
+                    if (!shouldRun) {
+                        results.push({
+                            name,
+                            data: {},
+                            durationMs: 0,
+                            skipped: true,
+                        });
+                        continue;
+                    }
+                }
+                catch (err) {
+                    results.push({
+                        name,
+                        data: {},
+                        durationMs: 0,
+                        error: `Condition error: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            const start = performance.now();
+            try {
+                const data = await fn(context);
+                const durationMs = Math.round(performance.now() - start);
+                results.push({ name, data, durationMs });
+            }
+            catch (err) {
+                const durationMs = Math.round(performance.now() - start);
+                results.push({
+                    name,
+                    data: {},
+                    durationMs,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
     const totalDurationMs = Math.round(performance.now() - overallStart);
     let errorCount = 0;
+    let skippedCount = 0;
     for (const r of results) {
-        if (r.error)
+        if (r.skipped)
+            skippedCount++;
+        else if (r.error)
             errorCount++;
     }
-    return { results, totalDurationMs, errorCount };
+    return { results, totalDurationMs, errorCount, skippedCount };
 }
 //# sourceMappingURL=enrich-runner.js.map

package/.next/standalone/dist/registry.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerEval = registerEval;
 exports.getRegisteredEvals = getRegisteredEvals;
+exports.getSessionScopedEvals = getSessionScopedEvals;
+exports.getSubagentScopedEvals = getSubagentScopedEvals;
+exports.hasSubagentEvals = hasSubagentEvals;
 exports.hasEvals = hasEvals;
 exports.clearEvals = clearEvals;
 const REGISTRY_KEY = "__CLAUDEYE_EVAL_REGISTRY__";
@@ -12,20 +15,40 @@ function getRegistry() {
     }
     return g[REGISTRY_KEY];
 }
-function registerEval(name, fn) {
+function registerEval(name, fn, condition, scope = 'session', subagentType) {
     const registry = getRegistry();
+    const entry = { name, fn, scope };
+    if (condition)
+        entry.condition = condition;
+    if (subagentType)
+        entry.subagentType = subagentType;
     // Replace if an eval with the same name already exists
     const idx = registry.findIndex((e) => e.name === name);
     if (idx >= 0) {
-        registry[idx] = { name, fn };
+        registry[idx] = entry;
     }
     else {
-        registry.push({ name, fn });
+        registry.push(entry);
     }
 }
 function getRegisteredEvals() {
     return getRegistry();
 }
+function getSessionScopedEvals() {
+    return getRegistry().filter((e) => e.scope === 'session' || e.scope === 'both');
+}
+function getSubagentScopedEvals(subagentType) {
+    return getRegistry().filter((e) => {
+        if (e.scope !== 'subagent' && e.scope !== 'both')
+            return false;
+        if (e.subagentType && subagentType && e.subagentType !== subagentType)
+            return false;
+        return true;
+    });
+}
+function hasSubagentEvals() {
+    return getRegistry().some((e) => e.scope === 'subagent' || e.scope === 'both');
+}
 function hasEvals() {
     return getRegistry().length > 0;
 }

package/.next/standalone/dist/runner.js

@@ -6,52 +6,110 @@ exports.runAllEvals = runAllEvals;
  * Each eval is individually try/caught so one failure doesn't block others.
  */
 const registry_1 = require("./registry");
+const condition_registry_1 = require("./condition-registry");
 function clampScore(score) {
     if (score === undefined || score === null)
         return 1;
     return Math.max(0, Math.min(1, score));
 }
-async function runAllEvals(entries, stats, projectName, sessionId) {
-    const registeredEvals = (0, registry_1.getRegisteredEvals)();
+async function runAllEvals(entries, stats, projectName, sessionId, evalsToRun, contextOverrides) {
+    const registeredEvals = evalsToRun !== null && evalsToRun !== void 0 ? evalsToRun : (0, registry_1.getRegisteredEvals)();
     const results = [];
     const overallStart = performance.now();
-    for (const { name, fn } of registeredEvals) {
-        const start = performance.now();
+    const context = Object.assign({ entries, stats, projectName, sessionId, scope: 'session' }, contextOverrides);
+    // Check global condition first
+    const globalCondition = (0, condition_registry_1.getGlobalCondition)();
+    let globalSkip = false;
+    if (globalCondition) {
         try {
-            const result = await fn({ entries, stats, projectName, sessionId });
-            const durationMs = Math.round(performance.now() - start);
-            results.push({
-                name,
-                pass: result.pass,
-                score: clampScore(result.score),
-                message: result.message,
-                metadata: result.metadata,
-                durationMs,
-            });
+            const result = await globalCondition(context);
+            if (!result)
+                globalSkip = true;
+        }
+        catch (_a) {
+            globalSkip = true;
         }
-        catch (err) {
-            const durationMs = Math.round(performance.now() - start);
+    }
+    if (globalSkip) {
+        // All evals skipped due to global condition
+        for (const { name } of registeredEvals) {
             results.push({
                 name,
                 pass: false,
                 score: 0,
-                durationMs,
-                error: err instanceof Error ? err.message : String(err),
+                durationMs: 0,
+                skipped: true,
             });
         }
     }
+    else {
+        for (const { name, fn, condition } of registeredEvals) {
+            // Check per-eval condition
+            if (condition) {
+                try {
+                    const shouldRun = await condition(context);
+                    if (!shouldRun) {
+                        results.push({
+                            name,
+                            pass: false,
+                            score: 0,
+                            durationMs: 0,
+                            skipped: true,
+                        });
+                        continue;
+                    }
+                }
+                catch (err) {
+                    results.push({
+                        name,
+                        pass: false,
+                        score: 0,
+                        durationMs: 0,
+                        error: `Condition error: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            const start = performance.now();
+            try {
+                const result = await fn(context);
+                const durationMs = Math.round(performance.now() - start);
+                results.push({
+                    name,
+                    pass: result.pass,
+                    score: clampScore(result.score),
+                    message: result.message,
+                    metadata: result.metadata,
+                    durationMs,
+                });
+            }
+            catch (err) {
+                const durationMs = Math.round(performance.now() - start);
+                results.push({
+                    name,
+                    pass: false,
+                    score: 0,
+                    durationMs,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
     const totalDurationMs = Math.round(performance.now() - overallStart);
     let passCount = 0;
     let failCount = 0;
     let errorCount = 0;
+    let skippedCount = 0;
     for (const r of results) {
-        if (r.error)
+        if (r.skipped)
+            skippedCount++;
+        else if (r.error)
             errorCount++;
         else if (r.pass)
             passCount++;
         else
             failCount++;
     }
-    return { results, totalDurationMs, passCount, failCount, errorCount };
+    return { results, totalDurationMs, passCount, failCount, errorCount, skippedCount };
 }
 //# sourceMappingURL=runner.js.map