claudeye 0.2.2 → 0.3.0

package/.next/standalone/lib/evals/enrich-runner.ts

@@ -3,41 +3,95 @@
  * Each enricher is individually try/caught so one failure doesn't block others.
  */
 import { getRegisteredEnrichers } from "./enrich-registry";
-import type { EvalLogEntry, EvalLogStats } from "./types";
-import type { EnrichRunResult, EnrichRunSummary } from "./enrich-types";
+import { getGlobalCondition } from "./condition-registry";
+import type { EvalContext, EvalLogEntry, EvalLogStats } from "./types";
+import type { EnrichRunResult, EnrichRunSummary, RegisteredEnricher } from "./enrich-types";
 
 export async function runAllEnrichers(
   entries: EvalLogEntry[],
   stats: EvalLogStats,
   projectName: string,
   sessionId: string,
+  enrichersToRun?: RegisteredEnricher[],
+  contextOverrides?: Partial<EvalContext>,
 ): Promise<EnrichRunSummary> {
-  const registeredEnrichers = getRegisteredEnrichers();
+  const registeredEnrichers = enrichersToRun ?? getRegisteredEnrichers();
   const results: EnrichRunResult[] = [];
   const overallStart = performance.now();
+  const context: EvalContext = { entries, stats, projectName, sessionId, scope: 'session', ...contextOverrides };
 
-  for (const { name, fn } of registeredEnrichers) {
-    const start = performance.now();
+  // Check global condition first
+  const globalCondition = 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 });
-    } catch (err) {
-      const durationMs = Math.round(performance.now() - start);
+      const result = await globalCondition(context);
+      if (!result) globalSkip = true;
+    } catch {
+      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) errorCount++;
+    if (r.skipped) skippedCount++;
+    else if (r.error) errorCount++;
   }
 
-  return { results, totalDurationMs, errorCount };
+  return { results, totalDurationMs, errorCount, skippedCount };
 }

package/.next/standalone/lib/evals/enrich-types.ts

@@ -3,7 +3,7 @@
  * Enrichers return key-value metadata for sessions (as opposed to evals which grade them).
  * Reuses EvalContext from types.ts — no duplication.
  */
-import type { EvalContext } from "./types";
+import type { EvalContext, ConditionFunction, EvalScope } from "./types";
 
 /** Allowed value types for enrichment results. */
 export type EnrichmentValue = string | number | boolean;
@@ -20,6 +20,9 @@ export type EnrichFunction = (
 export interface RegisteredEnricher {
   name: string;
   fn: EnrichFunction;
+  condition?: ConditionFunction;
+  scope: EvalScope;
+  subagentType?: string;
 }
 
 /** Result of running a single enricher. */
@@ -28,6 +31,7 @@ export interface EnrichRunResult {
   data: EnrichmentResult;
   durationMs: number;
   error?: string;
+  skipped?: boolean;
 }
 
 /** Summary of running all registered enrichers. */
@@ -35,4 +39,5 @@ export interface EnrichRunSummary {
   results: EnrichRunResult[];
   totalDurationMs: number;
   errorCount: number;
+  skippedCount: number;
 }

package/.next/standalone/lib/evals/index.ts

@@ -3,8 +3,9 @@
  * This is the public API surface published via `dist/`.
  */
 export { createApp } from "./app";
-export type { ClaudeyeApp, ClaudeyeAppOptions } from "./app";
+export type { ClaudeyeApp, ClaudeyeAppOptions, EvalOptions, EnrichOptions } from "./app";
 export type {
+  EvalScope,
   EvalContext,
   EvalResult,
   EvalFunction,
@@ -14,6 +15,7 @@ export type {
   RegisteredEval,
   EvalRunResult,
   EvalRunSummary,
+  ConditionFunction,
 } from "./types";
 export type {
   EnrichmentValue,

package/.next/standalone/lib/evals/registry.ts

@@ -3,7 +3,7 @@
  * Using globalThis ensures the registry survives webpack chunk splitting
  * and remains a true singleton across dynamic imports.
  */
-import type { EvalFunction, RegisteredEval } from "./types";
+import type { ConditionFunction, EvalFunction, EvalScope, RegisteredEval } from "./types";
 
 const REGISTRY_KEY = "__CLAUDEYE_EVAL_REGISTRY__";
 
@@ -19,14 +19,23 @@ function getRegistry(): RegisteredEval[] {
   return g[REGISTRY_KEY];
 }
 
-export function registerEval(name: string, fn: EvalFunction): void {
+export function registerEval(
+  name: string,
+  fn: EvalFunction,
+  condition?: ConditionFunction,
+  scope: EvalScope = 'session',
+  subagentType?: string,
+): void {
   const registry = getRegistry();
+  const entry: RegisteredEval = { 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);
   }
 }
 
@@ -34,6 +43,22 @@ export function getRegisteredEvals(): RegisteredEval[] {
   return getRegistry();
 }
 
+export function getSessionScopedEvals(): RegisteredEval[] {
+  return getRegistry().filter((e) => e.scope === 'session' || e.scope === 'both');
+}
+
+export function getSubagentScopedEvals(subagentType?: string): RegisteredEval[] {
+  return getRegistry().filter((e) => {
+    if (e.scope !== 'subagent' && e.scope !== 'both') return false;
+    if (e.subagentType && subagentType && e.subagentType !== subagentType) return false;
+    return true;
+  });
+}
+
+export function hasSubagentEvals(): boolean {
+  return getRegistry().some((e) => e.scope === 'subagent' || e.scope === 'both');
+}
+
 export function hasEvals(): boolean {
   return getRegistry().length > 0;
 }

package/.next/standalone/lib/evals/runner.ts

@@ -3,7 +3,8 @@
  * Each eval is individually try/caught so one failure doesn't block others.
  */
 import { getRegisteredEvals } from "./registry";
-import type { EvalLogEntry, EvalLogStats, EvalRunResult, EvalRunSummary } from "./types";
+import { getGlobalCondition } from "./condition-registry";
+import type { EvalContext, EvalLogEntry, EvalLogStats, EvalRunResult, EvalRunSummary, RegisteredEval } from "./types";
 
 function clampScore(score: number | undefined): number {
   if (score === undefined || score === null) return 1;
@@ -15,45 +16,101 @@ export async function runAllEvals(
   stats: EvalLogStats,
   projectName: string,
   sessionId: string,
+  evalsToRun?: RegisteredEval[],
+  contextOverrides?: Partial<EvalContext>,
 ): Promise<EvalRunSummary> {
-  const registeredEvals = getRegisteredEvals();
+  const registeredEvals = evalsToRun ?? getRegisteredEvals();
   const results: EvalRunResult[] = [];
   const overallStart = performance.now();
+  const context: EvalContext = { entries, stats, projectName, sessionId, scope: 'session', ...contextOverrides };
 
-  for (const { name, fn } of registeredEvals) {
-    const start = performance.now();
+  // Check global condition first
+  const globalCondition = 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,
-      });
-    } catch (err) {
-      const durationMs = Math.round(performance.now() - start);
+      const result = await globalCondition(context);
+      if (!result) globalSkip = true;
+    } catch {
+      globalSkip = true;
+    }
+  }
+
+  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) errorCount++;
+    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 };
 }

package/.next/standalone/lib/evals/server-spawn.ts

@@ -7,26 +7,43 @@ import { spawn, execSync } from "node:child_process";
 import { createServer } from "node:net";
 import { resolve, dirname } from "node:path";
 import { existsSync } from "node:fs";
-import { platform } from "node:os";
+import { platform, networkInterfaces } from "node:os";
 
 interface SpawnOptions {
   open?: boolean;
+  host?: string;
 }
 
-export function findAvailablePort(preferred: number): Promise<number> {
-  return new Promise((res, rej) => {
+function getNetworkAddress(): string {
+  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";
+}
+
+function resolveBindAddress(host: string): string {
+  return host === "localhost" ? "127.0.0.1" : host;
+}
+
+export function findAvailablePort(preferred: number, host = "localhost"): Promise<number> {
+  const bindAddr = resolveBindAddress(host);
+  return new Promise((resolve, reject) => {
     const srv = createServer();
-    srv.listen(preferred, "127.0.0.1", () => {
-      srv.close(() => res(preferred));
+    srv.listen(preferred, bindAddr, () => {
+      srv.close(() => resolve(preferred));
     });
     srv.on("error", () => {
-      const srv2 = createServer();
-      srv2.listen(0, "127.0.0.1", () => {
-        const addr = srv2.address();
+      const fallback = createServer();
+      fallback.listen(0, bindAddr, () => {
+        const addr = fallback.address();
         const port = typeof addr === "object" && addr ? addr.port : 0;
-        srv2.close(() => res(port));
+        fallback.close(() => resolve(port));
       });
-      srv2.on("error", rej);
+      fallback.on("error", reject);
     });
   });
 }
@@ -81,66 +98,75 @@ function resolveServerInfo(): { mode: "standalone"; script: string; cwd: string
   return { mode: "dev" };
 }
 
+function logServerInfo(host: string, port: number, localUrl: string, evalsModule?: string): void {
+  console.log(`Starting Claudeye dashboard...`);
+  if (evalsModule) {
+    console.log(`  Evals:    ${evalsModule}`);
+  }
+  if (host === "0.0.0.0") {
+    console.log(`  Local:    ${localUrl}`);
+    console.log(`  Network:  http://${getNetworkAddress()}:${port}`);
+  } else {
+    console.log(`  URL:      http://${host}:${port}`);
+  }
+  console.log();
+}
+
+function spawnChildProcess(serverInfo: ReturnType<typeof resolveServerInfo>, env: NodeJS.ProcessEnv, port: number): ReturnType<typeof spawn> {
+  if (serverInfo.mode === "standalone") {
+    return spawn(process.execPath, [serverInfo.script], {
+      cwd: serverInfo.cwd,
+      stdio: "inherit",
+      env,
+    });
+  }
+  return spawn("npx", ["next", "dev", "--port", String(port)], {
+    stdio: "inherit",
+    shell: true,
+    env,
+  });
+}
+
 export async function spawnServer(preferredPort: number, options: SpawnOptions): Promise<void> {
-  const port = await findAvailablePort(preferredPort);
+  const host = options.host ?? "localhost";
+  const port = await findAvailablePort(preferredPort, host);
   if (port !== preferredPort) {
     console.log(`Port ${preferredPort} is busy, using port ${port} instead.`);
   }
 
-  const url = `http://localhost:${port}`;
+  const localUrl = `http://localhost:${port}`;
   const evalsModule = process.argv[1] ? resolve(process.argv[1]) : undefined;
-
-  console.log(`Starting Claudeye dashboard...`);
-  if (evalsModule) {
-    console.log(`  Evals:    ${evalsModule}`);
-  }
-  console.log(`  URL:      ${url}\n`);
+  logServerInfo(host, port, localUrl, evalsModule);
 
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     PORT: String(port),
-    HOSTNAME: "localhost",
+    HOSTNAME: host,
   };
   if (evalsModule) {
     env.CLAUDEYE_EVALS_MODULE = evalsModule;
   }
 
-  const serverInfo = resolveServerInfo();
-
-  let child: ReturnType<typeof spawn>;
-  if (serverInfo.mode === "standalone") {
-    child = spawn(process.execPath, [serverInfo.script], {
-      cwd: serverInfo.cwd,
-      stdio: "inherit",
-      env,
-    });
-  } else {
-    child = spawn("npx", ["next", "dev", "--port", String(port)], {
-      stdio: "inherit",
-      shell: true,
-      env,
-    });
-  }
+  const child = spawnChildProcess(resolveServerInfo(), env, port);
 
   if (options.open) {
-    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`);
     });
   }
 
   // Forward signals for clean shutdown
-  const shutdown = (signal: NodeJS.Signals) => {
+  const shutdown = (signal: NodeJS.Signals): void => {
     child.kill(signal);
     setTimeout(() => process.exit(0), 2000).unref();
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
 
-  return new Promise<void>((res) => {
+  // Block until the child exits — server runs until killed
+  await new Promise<never>(() => {
     child.on("exit", (code) => {
       process.exit(code ?? 0);
     });
-    // Never resolves — server runs until killed
-    void res;
   });
 }

package/.next/standalone/lib/evals/types.ts

@@ -38,12 +38,20 @@ export interface EvalLogStats {
   models: string[];
 }
 
+/** Scope for eval/enrichment registration. */
+export type EvalScope = 'session' | 'subagent' | 'both';
+
 /** Context passed to each eval function. */
 export interface EvalContext {
   entries: EvalLogEntry[];
   stats: EvalLogStats;
   projectName: string;
   sessionId: string;
+  scope: 'session' | 'subagent';
+  subagentId?: string;
+  subagentType?: string;
+  subagentDescription?: string;
+  parentSessionId?: string;
 }
 
 /** Result returned by an eval function. */
@@ -57,10 +65,16 @@ export interface EvalResult {
 /** An eval function signature. */
 export type EvalFunction = (context: EvalContext) => EvalResult | Promise<EvalResult>;
 
+/** A condition function that gates eval/enrichment execution. */
+export type ConditionFunction = (context: EvalContext) => boolean | Promise<boolean>;
+
 /** An eval function stored in the registry. */
 export interface RegisteredEval {
   name: string;
   fn: EvalFunction;
+  condition?: ConditionFunction;
+  scope: EvalScope;
+  subagentType?: string;
 }
 
 /** Result of running a single eval. */
@@ -72,6 +86,7 @@ export interface EvalRunResult {
   metadata?: Record<string, unknown>;
   durationMs: number;
   error?: string;
+  skipped?: boolean;
 }
 
 /** Summary of running all registered evals. */
@@ -81,4 +96,5 @@ export interface EvalRunSummary {
   passCount: number;
   failCount: number;
   errorCount: number;
+  skippedCount: number;
 }

package/.next/standalone/lib/log-format.ts

@@ -3,7 +3,7 @@
  * Separated from log-entries.ts to avoid pulling in Node.js fs modules
  * when imported from "use client" components.
  */
-import type { ToolUseBlock, GenericEntry } from "./log-entries";
+import type { LogEntry, ToolUseBlock, GenericEntry } from "./log-entries";
 
 export function formatInput(block: ToolUseBlock): string {
   return JSON.stringify(block.input, null, 2);
@@ -13,6 +13,27 @@ export function formatRaw(entry: GenericEntry): string {
   return JSON.stringify(entry.raw, null, 2);
 }
 
+/**
+ * Extracts a copyable plain-text representation from any log entry type.
+ */
+export function getEntryTextContent(entry: LogEntry): string {
+  switch (entry.type) {
+    case "user":
+      return entry.message.content;
+    case "assistant":
+      return entry.message.content
+        .filter((b): b is { type: "text"; text: string } => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+    case "file-history-snapshot":
+    case "progress":
+    case "system":
+      return formatRaw(entry);
+    case "queue-operation":
+      return entry.label;
+  }
+}
+
 const tsFormatter = new Intl.DateTimeFormat("en-US", {
   month: "short",
   day: "numeric",