harnery 0.35.0 → 0.36.0

package/dist/lib/web-performance.js

@@ -0,0 +1,192 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+export const WEB_PERFORMANCE_LOG = "web-performance.jsonl";
+export function parsePerformanceWindow(input) {
+    const match = /^(\d+(?:\.\d+)?)(m|h|d)$/.exec(input.trim().toLowerCase());
+    if (!match)
+        return null;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount <= 0)
+        return null;
+    const unitMs = match[2] === "m" ? 60_000 : match[2] === "h" ? 3_600_000 : 86_400_000;
+    return Math.floor(amount * unitMs);
+}
+function performanceLogPaths(root) {
+    const logsDir = path.join(root, ".harnery", "logs");
+    if (!existsSync(logsDir))
+        return [];
+    return [
+        ...rotatedLogPaths(path.join(logsDir, "web-performance"), "active.jsonl"),
+        ...rotatedLogPaths(logsDir, WEB_PERFORMANCE_LOG),
+    ];
+}
+function rotatedLogPaths(directory, activeName) {
+    if (!existsSync(directory))
+        return [];
+    const escaped = activeName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return readdirSync(directory)
+        .filter((name) => name === activeName || new RegExp(`^${escaped}\\.\\d+$`).test(name))
+        .sort((left, right) => {
+        if (left === activeName)
+            return 1;
+        if (right === activeName)
+            return -1;
+        return Number(right.split(".").at(-1)) - Number(left.split(".").at(-1));
+    })
+        .map((name) => path.join(directory, name));
+}
+function numberField(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isRequestEvent(event) {
+    return (event.event === "request_complete" &&
+        typeof event.method === "string" &&
+        typeof event.route === "string" &&
+        numberField(event.duration_ms));
+}
+function isDelayEvent(event) {
+    return (event.event === "event_loop_delay" && numberField(event.delay_ms));
+}
+function isMemoryEvent(event) {
+    return (event.event === "memory_sample" &&
+        numberField(event.rss_bytes) &&
+        numberField(event.heap_used_bytes) &&
+        numberField(event.heap_limit_bytes));
+}
+function isGcPauseEvent(event) {
+    return event.event === "gc_pause" && numberField(event.duration_ms);
+}
+function percentile(sorted, fraction) {
+    if (sorted.length === 0)
+        return 0;
+    return sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * fraction) - 1)] ?? 0;
+}
+export function readWebPerformanceReport(options) {
+    const root = path.resolve(options.root);
+    const logPath = path.join(root, ".harnery", "logs", "web-performance", "active.jsonl");
+    const windowMs = parsePerformanceWindow(options.since);
+    if (windowMs === null)
+        throw new Error(`invalid performance window: ${options.since}`);
+    const cutoffMs = (options.nowMs ?? Date.now()) - windowMs;
+    const paths = performanceLogPaths(root);
+    if (paths.length === 0) {
+        return {
+            state: "unavailable",
+            log_path: logPath,
+            since: options.since,
+            files_read: 0,
+            invalid_lines: 0,
+            requests_observed: 0,
+            streams_observed: 0,
+            slow_requests: 0,
+            event_loop_delays: 0,
+            memory: null,
+            garbage_collection: {
+                observed_collections: 0,
+                observed_duration_ms: 0,
+                recorded_pauses: 0,
+                max_pause_ms: 0,
+            },
+            routes: [],
+            slowest_requests: [],
+            largest_event_loop_delays: [],
+            largest_gc_pauses: [],
+            hint: "Start or restart `harn web`; performance diagnostics begin when the server receives its first request.",
+        };
+    }
+    const events = [];
+    const seenEvents = new Set();
+    let invalidLines = 0;
+    for (const file of paths) {
+        for (const line of readFileSync(file, "utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                const timestamp = Date.parse(event.ts);
+                if (!Number.isFinite(timestamp)) {
+                    invalidLines++;
+                    continue;
+                }
+                const identity = JSON.stringify(event);
+                if (timestamp >= cutoffMs && !seenEvents.has(identity)) {
+                    seenEvents.add(identity);
+                    events.push(event);
+                }
+            }
+            catch {
+                invalidLines++;
+            }
+        }
+    }
+    events.sort((left, right) => Date.parse(left.ts) - Date.parse(right.ts) ||
+        JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    const allRequests = events.filter(isRequestEvent);
+    const requests = allRequests.filter((event) => !event.stream);
+    const delays = events.filter(isDelayEvent);
+    const memorySamples = events.filter(isMemoryEvent);
+    const gcPauses = events.filter(isGcPauseEvent);
+    const groups = new Map();
+    for (const request of requests) {
+        const key = `${request.method}\0${request.route}`;
+        const group = groups.get(key) ?? [];
+        group.push(request);
+        groups.set(key, group);
+    }
+    const routes = [...groups.values()]
+        .map((group) => {
+        const durations = group.map((event) => event.duration_ms).sort((a, b) => a - b);
+        return {
+            method: group[0]?.method ?? "GET",
+            route: group[0]?.route ?? "/",
+            requests: group.length,
+            slow_requests: group.filter((event) => event.slow).length,
+            aborted_requests: group.filter((event) => event.outcome === "aborted").length,
+            p50_ms: percentile(durations, 0.5),
+            p95_ms: percentile(durations, 0.95),
+            max_ms: durations.at(-1) ?? 0,
+            max_event_loop_delay_ms: Math.max(...group.map((event) => event.max_event_loop_delay_ms)),
+            max_concurrent_requests: Math.max(...group.map((event) => event.max_concurrent_requests)),
+        };
+    })
+        .sort((left, right) => right.max_ms - left.max_ms || right.p95_ms - left.p95_ms);
+    return {
+        state: "ok",
+        log_path: logPath,
+        since: options.since,
+        files_read: paths.length,
+        invalid_lines: invalidLines,
+        requests_observed: requests.length,
+        streams_observed: allRequests.length - requests.length,
+        slow_requests: requests.filter((event) => event.slow).length,
+        event_loop_delays: delays.length,
+        memory: memorySamples.length > 0
+            ? {
+                samples: memorySamples.length,
+                latest: memorySamples.at(-1),
+                peak_rss_bytes: Math.max(...memorySamples.map((event) => event.rss_bytes)),
+                peak_heap_used_bytes: Math.max(...memorySamples.map((event) => event.heap_used_bytes)),
+                max_heap_used_percent: Math.max(...memorySamples.map((event) => event.heap_used_percent)),
+            }
+            : null,
+        garbage_collection: {
+            observed_collections: memorySamples.reduce((sum, event) => sum + event.gc_count, 0),
+            observed_duration_ms: Math.round(memorySamples.reduce((sum, event) => sum + event.gc_duration_ms, 0)),
+            recorded_pauses: gcPauses.length,
+            max_pause_ms: Math.max(0, ...gcPauses.map((event) => event.duration_ms)),
+        },
+        routes,
+        slowest_requests: requests
+            .slice()
+            .sort((left, right) => right.duration_ms - left.duration_ms)
+            .slice(0, options.limit),
+        largest_event_loop_delays: delays
+            .slice()
+            .sort((left, right) => right.delay_ms - left.delay_ms)
+            .slice(0, options.limit),
+        largest_gc_pauses: gcPauses
+            .slice()
+            .sort((left, right) => right.duration_ms - left.duration_ms)
+            .slice(0, options.limit),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Multi-agent coordination for AI coding agents - Claude Code, Cursor, and Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",
@@ -102,6 +102,31 @@
       "types": "./dist/core/events/v3/index.d.ts",
       "import": "./dist/core/events/v3/index.js"
     },
+    "./core/events/v3/support-storage": {
+      "bun": "./src/core/events/v3/support-storage/index.ts",
+      "types": "./dist/core/events/v3/support-storage/index.d.ts",
+      "import": "./dist/core/events/v3/support-storage/index.js"
+    },
+    "./core/events/legacy-storage": {
+      "bun": "./src/core/events/legacy-storage/index.ts",
+      "types": "./dist/core/events/legacy-storage/index.d.ts",
+      "import": "./dist/core/events/legacy-storage/index.js"
+    },
+    "./core/storage": {
+      "bun": "./src/core/storage/index.ts",
+      "types": "./dist/core/storage/index.d.ts",
+      "import": "./dist/core/storage/index.js"
+    },
+    "./core/inbox": {
+      "bun": "./src/core/inbox/index.ts",
+      "types": "./dist/core/inbox/index.d.ts",
+      "import": "./dist/core/inbox/index.js"
+    },
+    "./core/conversations": {
+      "bun": "./src/core/conversations/index.ts",
+      "types": "./dist/core/conversations/index.d.ts",
+      "import": "./dist/core/conversations/index.js"
+    },
     "./core/semantic": {
       "bun": "./src/core/semantic/index.ts",
       "types": "./dist/core/semantic/index.d.ts",
@@ -173,7 +198,7 @@
     "agent-coord": "./bin/agent-coord",
     "agent-hook": "./bin/agent-hook"
   },
-  "//files": "src ships as TS so the `bun` export condition resolves to source; negate co-located tests and their shared fixture helper so they don't ride into the tarball (a .npmignore is inert for paths already inside the files allowlist).",
+  "//files": "src ships as TS so the `bun` export condition resolves to source; negate co-located tests, fixture directories, and shared test helpers so they don't ride into the tarball (a .npmignore is inert for paths already inside the files allowlist).",
   "files": [
     "bin",
     "src",
@@ -183,6 +208,8 @@
     "LICENSE",
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
+    "!src/**/__fixtures__/**",
+    "!dist/**/__fixtures__/**",
     "!dist/**/test-helpers.*",
     "!src/**/test-helpers.ts"
   ],

package/schemas/config.schema.json

@@ -185,6 +185,37 @@
         }
       }
     },
+    "logs": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Structured-log settings. Retention overrides change only approved byte and age scalars; roots, providers, privacy, durability, writers, and record limits stay source-owned.",
+      "properties": {
+        "storage": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "Storage budgets for shared operational and debug log segments. Project values override user-global values at the same path; exact-family values are more specific than class values.",
+          "properties": {
+            "classes": {
+              "type": "object",
+              "additionalProperties": false,
+              "description": "Defaults applied to every shared log family in the named storage class.",
+              "properties": {
+                "operational-log": { "$ref": "#/$defs/logStorageOverride" },
+                "debug-log": { "$ref": "#/$defs/logStorageOverride" }
+              }
+            },
+            "families": {
+              "type": "object",
+              "description": "Overrides for exact registered shared-log family IDs.",
+              "propertyNames": {
+                "pattern": "^[a-z0-9][a-z0-9._-]{0,63}$"
+              },
+              "additionalProperties": { "$ref": "#/$defs/logStorageOverride" }
+            }
+          }
+        }
+      }
+    },
     "artifacts": {
       "type": "object",
       "additionalProperties": false,
@@ -285,6 +316,13 @@
         "hostAddendumFile": {
           "type": "string",
           "description": "Repo-relative path to a markdown file holding this project's own coordination policy. `harn init` splices its contents into a second managed region in AGENTS.md, `init --check` reports drift against it, and `deinit` (or removing this key) takes the region back out. Harnery never parses the content. Must resolve inside the project and be non-empty."
+        },
+        "promptReminder": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 500,
+          "pattern": "^[^\\r\\n]*\\S[^\\r\\n]*$",
+          "description": "One project-owned line emitted on every supported prompt for adapters that lack native reminder behavior. Project config only; user-global values are ignored. The text is not copied into coordination state."
         }
       }
     },
@@ -353,5 +391,25 @@
         }
       }
     }
+  },
+  "$defs": {
+    "logStorageOverride": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "max_bytes": {
+          "type": "integer",
+          "minimum": 10485760,
+          "maximum": 1099511627776,
+          "description": "Logical storage budget in bytes. This is an asynchronous retention budget, not a producer write quota."
+        },
+        "max_age_days": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 3650,
+          "description": "Age in whole days after which an immutable sealed segment is eligible for retention."
+        }
+      }
+    }
   }
 }