aoaoe 2.0.0 → 3.0.0

package/README.md

@@ -4,7 +4,7 @@
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml"><img src="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
     <a href="https://www.npmjs.com/package/aoaoe"><img src="https://img.shields.io/npm/v/aoaoe" alt="npm version"></a>
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/releases"><img src="https://img.shields.io/github/v/release/Talador12/agent-of-agent-of-empires" alt="GitHub release"></a>
-    <img src="https://img.shields.io/badge/tests-3332-brightgreen" alt="tests">
+    <img src="https://img.shields.io/badge/tests-3491-brightgreen" alt="tests">
     <img src="https://img.shields.io/badge/node-%3E%3D20-blue" alt="Node.js >= 20">
     <img src="https://img.shields.io/badge/runtime%20deps-0-brightgreen" alt="zero runtime dependencies">
     <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>

package/dist/alert-composer.d.ts

@@ -0,0 +1,32 @@
+import type { AlertContext } from "./alert-rules.js";
+export type ComposedCondition = (ctx: AlertContext) => boolean;
+/**
+ * Compose multiple condition strings with AND logic.
+ * All conditions must be true for the composed condition to fire.
+ */
+export declare function composeAnd(expressions: string[]): ComposedCondition | null;
+/**
+ * Compose multiple condition strings with OR logic.
+ * Any condition being true fires the composed condition.
+ */
+export declare function composeOr(expressions: string[]): ComposedCondition | null;
+/**
+ * Parse a composed condition from config.
+ * Format: { "and": ["fleetHealth < 40", "errorSessions > 2"] }
+ *      or { "or": ["fleetHealth < 20", "stuckSessions >= 3"] }
+ *      or plain string "fleetHealth < 50"
+ */
+export declare function parseComposedCondition(spec: string | {
+    and: string[];
+} | {
+    or: string[];
+}): ComposedCondition | null;
+/**
+ * Format a composed condition for display.
+ */
+export declare function formatComposedCondition(spec: string | {
+    and: string[];
+} | {
+    or: string[];
+}): string;
+//# sourceMappingURL=alert-composer.d.ts.map

package/dist/alert-composer.js

@@ -0,0 +1,51 @@
+// alert-composer.ts — AND/OR composition of alert conditions.
+// extends alert-rule-dsl.ts with logical operators for complex rules.
+import { parseCondition } from "./alert-rule-dsl.js";
+/**
+ * Compose multiple condition strings with AND logic.
+ * All conditions must be true for the composed condition to fire.
+ */
+export function composeAnd(expressions) {
+    const fns = expressions.map(parseCondition);
+    if (fns.some((f) => f === null))
+        return null;
+    return (ctx) => fns.every((f) => f(ctx));
+}
+/**
+ * Compose multiple condition strings with OR logic.
+ * Any condition being true fires the composed condition.
+ */
+export function composeOr(expressions) {
+    const fns = expressions.map(parseCondition);
+    if (fns.some((f) => f === null))
+        return null;
+    return (ctx) => fns.some((f) => f(ctx));
+}
+/**
+ * Parse a composed condition from config.
+ * Format: { "and": ["fleetHealth < 40", "errorSessions > 2"] }
+ *      or { "or": ["fleetHealth < 20", "stuckSessions >= 3"] }
+ *      or plain string "fleetHealth < 50"
+ */
+export function parseComposedCondition(spec) {
+    if (typeof spec === "string")
+        return parseCondition(spec);
+    if ("and" in spec)
+        return composeAnd(spec.and);
+    if ("or" in spec)
+        return composeOr(spec.or);
+    return null;
+}
+/**
+ * Format a composed condition for display.
+ */
+export function formatComposedCondition(spec) {
+    if (typeof spec === "string")
+        return spec;
+    if ("and" in spec)
+        return spec.and.join(" AND ");
+    if ("or" in spec)
+        return spec.or.join(" OR ");
+    return "unknown";
+}
+//# sourceMappingURL=alert-composer.js.map

package/dist/alert-rule-dsl.d.ts

@@ -0,0 +1,32 @@
+import type { AlertContext, AlertRule, AlertSeverity } from "./alert-rules.js";
+export interface AlertRuleConfig {
+    name: string;
+    severity: AlertSeverity;
+    condition: string;
+    cooldownMin: number;
+    description?: string;
+}
+/**
+ * Parse a DSL condition string into a function.
+ * Format: "<field> <op> <value>" — e.g., "fleetHealth < 40"
+ */
+export declare function parseCondition(expr: string): ((ctx: AlertContext) => boolean) | null;
+/**
+ * Convert user-defined rule configs into AlertRule objects.
+ */
+export declare function parseAlertRuleConfigs(configs: AlertRuleConfig[]): {
+    rules: AlertRule[];
+    errors: string[];
+};
+/**
+ * Validate a DSL condition string without executing it.
+ */
+export declare function validateCondition(expr: string): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Format available DSL fields for help display.
+ */
+export declare function formatDslHelp(): string[];
+//# sourceMappingURL=alert-rule-dsl.d.ts.map

package/dist/alert-rule-dsl.js

@@ -0,0 +1,87 @@
+// alert-rule-dsl.ts — user-defined alert rules via config file.
+// parses a simple DSL for defining custom alert conditions:
+//   { "name": "my-rule", "severity": "warning", "condition": "fleetHealth < 40", "cooldownMin": 10 }
+// supported operators and fields
+const VALID_FIELDS = new Set(["fleetHealth", "activeSessions", "errorSessions", "totalCostUsd", "hourlyCostRate", "stuckSessions"]);
+const VALID_OPS = new Set(["<", ">", "<=", ">=", "==", "!="]);
+/**
+ * Parse a DSL condition string into a function.
+ * Format: "<field> <op> <value>" — e.g., "fleetHealth < 40"
+ */
+export function parseCondition(expr) {
+    const match = expr.trim().match(/^(\w+)\s*(<=?|>=?|[!=]=)\s*(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return null;
+    const [, field, op, valueStr] = match;
+    if (!VALID_FIELDS.has(field))
+        return null;
+    if (!VALID_OPS.has(op))
+        return null;
+    const value = parseFloat(valueStr);
+    if (!isFinite(value))
+        return null;
+    return (ctx) => {
+        const actual = ctx[field];
+        if (typeof actual !== "number")
+            return false;
+        switch (op) {
+            case "<": return actual < value;
+            case ">": return actual > value;
+            case "<=": return actual <= value;
+            case ">=": return actual >= value;
+            case "==": return actual === value;
+            case "!=": return actual !== value;
+            default: return false;
+        }
+    };
+}
+/**
+ * Convert user-defined rule configs into AlertRule objects.
+ */
+export function parseAlertRuleConfigs(configs) {
+    const rules = [];
+    const errors = [];
+    for (const cfg of configs) {
+        const condition = parseCondition(cfg.condition);
+        if (!condition) {
+            errors.push(`invalid condition in rule "${cfg.name}": "${cfg.condition}"`);
+            continue;
+        }
+        rules.push({
+            name: cfg.name,
+            description: cfg.description ?? cfg.condition,
+            severity: cfg.severity,
+            condition,
+            cooldownMs: cfg.cooldownMin * 60_000,
+            lastFiredAt: 0,
+        });
+    }
+    return { rules, errors };
+}
+/**
+ * Validate a DSL condition string without executing it.
+ */
+export function validateCondition(expr) {
+    const match = expr.trim().match(/^(\w+)\s*(<=?|>=?|[!=]=)\s*(\d+(?:\.\d+)?)$/);
+    if (!match)
+        return { valid: false, error: `invalid format: expected "<field> <op> <value>", got "${expr}"` };
+    const [, field, op] = match;
+    if (!VALID_FIELDS.has(field))
+        return { valid: false, error: `unknown field "${field}". valid: ${[...VALID_FIELDS].join(", ")}` };
+    if (!VALID_OPS.has(op))
+        return { valid: false, error: `unknown operator "${op}". valid: ${[...VALID_OPS].join(", ")}` };
+    return { valid: true };
+}
+/**
+ * Format available DSL fields for help display.
+ */
+export function formatDslHelp() {
+    return [
+        "  Alert rule DSL:",
+        "  Format: <field> <op> <value>",
+        `  Fields: ${[...VALID_FIELDS].join(", ")}`,
+        `  Operators: ${[...VALID_OPS].join(", ")}`,
+        '  Example: { "name": "low-health", "severity": "warning", "condition": "fleetHealth < 50", "cooldownMin": 10 }',
+    ];
+}
+//# sourceMappingURL=alert-rule-dsl.js.map

package/dist/cost-allocation-tags.d.ts

@@ -0,0 +1,30 @@
+export interface CostTag {
+    key: string;
+    value: string;
+}
+export interface TaggedSession {
+    sessionTitle: string;
+    tags: CostTag[];
+    costUsd: number;
+}
+export interface TagReport {
+    tagKey: string;
+    groups: Array<{
+        value: string;
+        sessions: number;
+        totalCostUsd: number;
+    }>;
+}
+/**
+ * Group sessions by a tag key and sum costs.
+ */
+export declare function groupByTag(sessions: TaggedSession[], tagKey: string): TagReport;
+/**
+ * Format tag report for TUI display.
+ */
+export declare function formatTagReport(report: TagReport): string[];
+/**
+ * Parse tags from a config string: "team=platform,project=aoaoe"
+ */
+export declare function parseTags(tagStr: string): CostTag[];
+//# sourceMappingURL=cost-allocation-tags.d.ts.map

package/dist/cost-allocation-tags.js

@@ -0,0 +1,47 @@
+// cost-allocation-tags.ts — label sessions by team/project for cost attribution.
+// tags are key-value pairs attached to sessions, used to group costs in reports.
+/**
+ * Group sessions by a tag key and sum costs.
+ */
+export function groupByTag(sessions, tagKey) {
+    const groups = new Map();
+    for (const s of sessions) {
+        const tag = s.tags.find((t) => t.key === tagKey);
+        const value = tag?.value ?? "(untagged)";
+        const group = groups.get(value) ?? { sessions: 0, totalCostUsd: 0 };
+        group.sessions++;
+        group.totalCostUsd += s.costUsd;
+        groups.set(value, group);
+    }
+    return {
+        tagKey,
+        groups: [...groups.entries()]
+            .map(([value, g]) => ({ value, ...g }))
+            .sort((a, b) => b.totalCostUsd - a.totalCostUsd),
+    };
+}
+/**
+ * Format tag report for TUI display.
+ */
+export function formatTagReport(report) {
+    if (report.groups.length === 0)
+        return [`  (no sessions tagged with "${report.tagKey}")`];
+    const lines = [];
+    lines.push(`  Cost by ${report.tagKey}:`);
+    for (const g of report.groups) {
+        lines.push(`  ${g.value.padEnd(20)} ${g.sessions} session${g.sessions !== 1 ? "s" : ""}  $${g.totalCostUsd.toFixed(2)}`);
+    }
+    return lines;
+}
+/**
+ * Parse tags from a config string: "team=platform,project=aoaoe"
+ */
+export function parseTags(tagStr) {
+    if (!tagStr)
+        return [];
+    return tagStr.split(",").map((pair) => {
+        const [key, ...rest] = pair.split("=");
+        return { key: key.trim(), value: rest.join("=").trim() };
+    }).filter((t) => t.key && t.value);
+}
+//# sourceMappingURL=cost-allocation-tags.js.map

package/dist/fleet-grep.d.ts

@@ -0,0 +1,22 @@
+export interface GrepHit {
+    archive: string;
+    lineNumber: number;
+    line: string;
+    matchStart: number;
+    matchEnd: number;
+}
+export interface GrepResult {
+    pattern: string;
+    totalHits: number;
+    filesSearched: number;
+    hits: GrepHit[];
+}
+/**
+ * Search across all archived outputs for a regex pattern.
+ */
+export declare function grepArchives(pattern: string, maxResults?: number, maxFiles?: number): GrepResult;
+/**
+ * Format grep results for TUI display.
+ */
+export declare function formatGrepResult(result: GrepResult): string[];
+//# sourceMappingURL=fleet-grep.d.ts.map

package/dist/fleet-grep.js

@@ -0,0 +1,70 @@
+// fleet-grep.ts — regex search across archived session outputs.
+// searches gzipped archive files for matches, returning results with context.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { gunzipSync } from "node:zlib";
+const ARCHIVE_DIR = join(homedir(), ".aoaoe", "output-archive");
+/**
+ * Search across all archived outputs for a regex pattern.
+ */
+export function grepArchives(pattern, maxResults = 50, maxFiles = 20) {
+    if (!existsSync(ARCHIVE_DIR))
+        return { pattern, totalHits: 0, filesSearched: 0, hits: [] };
+    let regex;
+    try {
+        regex = new RegExp(pattern, "gi");
+    }
+    catch {
+        return { pattern, totalHits: 0, filesSearched: 0, hits: [] };
+    }
+    const files = readdirSync(ARCHIVE_DIR)
+        .filter((f) => f.endsWith(".txt.gz"))
+        .sort()
+        .reverse()
+        .slice(0, maxFiles);
+    const hits = [];
+    let totalHits = 0;
+    for (const file of files) {
+        try {
+            const compressed = readFileSync(join(ARCHIVE_DIR, file));
+            const content = gunzipSync(compressed).toString("utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                regex.lastIndex = 0;
+                const match = regex.exec(lines[i]);
+                if (match) {
+                    totalHits++;
+                    if (hits.length < maxResults) {
+                        hits.push({
+                            archive: file,
+                            lineNumber: i + 1,
+                            line: lines[i].slice(0, 200),
+                            matchStart: match.index,
+                            matchEnd: match.index + match[0].length,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* skip unreadable archives */ }
+    }
+    return { pattern, totalHits, filesSearched: files.length, hits };
+}
+/**
+ * Format grep results for TUI display.
+ */
+export function formatGrepResult(result) {
+    if (result.totalHits === 0)
+        return [`  fleet-grep: no matches for "${result.pattern}" in ${result.filesSearched} archives`];
+    const lines = [];
+    lines.push(`  fleet-grep: ${result.totalHits} match${result.totalHits !== 1 ? "es" : ""} for "${result.pattern}" in ${result.filesSearched} archives:`);
+    for (const h of result.hits.slice(0, 15)) {
+        const preview = h.line.length > 80 ? h.line.slice(0, 77) + "..." : h.line;
+        lines.push(`  [${h.archive.slice(0, 30)}:${h.lineNumber}] ${preview}`);
+    }
+    if (result.hits.length > 15)
+        lines.push(`  ... and ${result.hits.length - 15} more`);
+    return lines;
+}
+//# sourceMappingURL=fleet-grep.js.map

package/dist/goal-similarity.d.ts

@@ -0,0 +1,20 @@
+import type { TaskState } from "./types.js";
+export interface SimilarityPair {
+    titleA: string;
+    titleB: string;
+    similarity: number;
+    sharedKeywords: string[];
+}
+/**
+ * Compute Jaccard similarity between two keyword sets.
+ */
+export declare function jaccardSimilarity(setA: Set<string>, setB: Set<string>): number;
+/**
+ * Find pairs of tasks with similar goals.
+ */
+export declare function findSimilarGoals(tasks: readonly TaskState[], threshold?: number): SimilarityPair[];
+/**
+ * Format similarity pairs for TUI display.
+ */
+export declare function formatSimilarGoals(pairs: SimilarityPair[]): string[];
+//# sourceMappingURL=goal-similarity.d.ts.map

package/dist/goal-similarity.js

@@ -0,0 +1,55 @@
+// goal-similarity.ts — detect sessions with overlapping goals for coordination.
+// uses Jaccard similarity on keyword sets to find related tasks.
+import { extractKeywords } from "./drift-detector.js";
+/**
+ * Compute Jaccard similarity between two keyword sets.
+ */
+export function jaccardSimilarity(setA, setB) {
+    if (setA.size === 0 && setB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of setA)
+        if (setB.has(w))
+            intersection++;
+    const union = setA.size + setB.size - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Find pairs of tasks with similar goals.
+ */
+export function findSimilarGoals(tasks, threshold = 0.3) {
+    const keywordSets = tasks.map((t) => ({
+        title: t.sessionTitle,
+        keywords: new Set(extractKeywords(t.goal)),
+    }));
+    const pairs = [];
+    for (let i = 0; i < keywordSets.length; i++) {
+        for (let j = i + 1; j < keywordSets.length; j++) {
+            const sim = jaccardSimilarity(keywordSets[i].keywords, keywordSets[j].keywords);
+            if (sim >= threshold) {
+                const shared = [...keywordSets[i].keywords].filter((w) => keywordSets[j].keywords.has(w));
+                pairs.push({
+                    titleA: keywordSets[i].title,
+                    titleB: keywordSets[j].title,
+                    similarity: Math.round(sim * 100) / 100,
+                    sharedKeywords: shared,
+                });
+            }
+        }
+    }
+    return pairs.sort((a, b) => b.similarity - a.similarity);
+}
+/**
+ * Format similarity pairs for TUI display.
+ */
+export function formatSimilarGoals(pairs) {
+    if (pairs.length === 0)
+        return ["  (no similar goals detected)"];
+    const lines = [];
+    lines.push(`  Similar goals (${pairs.length} pair${pairs.length !== 1 ? "s" : ""}):`);
+    for (const p of pairs) {
+        lines.push(`  ${Math.round(p.similarity * 100)}% — "${p.titleA}" ↔ "${p.titleB}" [${p.sharedKeywords.join(", ")}]`);
+    }
+    return lines;
+}
+//# sourceMappingURL=goal-similarity.js.map

package/dist/health-forecast.d.ts

@@ -0,0 +1,23 @@
+export interface HealthForecast {
+    currentHealth: number;
+    trendPerHour: number;
+    projectedHealth1h: number;
+    projectedHealth4h: number;
+    projectedHealth24h: number;
+    slaBreachInMs: number;
+    slaBreachLabel: string;
+    trend: "improving" | "stable" | "declining";
+}
+/**
+ * Forecast fleet health from a time series of samples.
+ * Each sample is { timestamp, health }.
+ */
+export declare function forecastHealth(samples: Array<{
+    timestamp: number;
+    health: number;
+}>, slaThreshold?: number, now?: number): HealthForecast | null;
+/**
+ * Format health forecast for TUI display.
+ */
+export declare function formatHealthForecast(forecast: HealthForecast): string[];
+//# sourceMappingURL=health-forecast.d.ts.map

package/dist/health-forecast.js

@@ -0,0 +1,101 @@
+// health-forecast.ts — predict fleet health trends from historical data.
+// uses linear regression on recent health samples to project future health
+// and estimate when an SLA breach might occur.
+/**
+ * Forecast fleet health from a time series of samples.
+ * Each sample is { timestamp, health }.
+ */
+export function forecastHealth(samples, slaThreshold = 50, now = Date.now()) {
+    if (samples.length < 3)
+        return null;
+    // simple linear regression: health = slope * time + intercept
+    const n = samples.length;
+    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
+    const t0 = samples[0].timestamp;
+    for (const s of samples) {
+        const x = (s.timestamp - t0) / 3_600_000; // hours since first sample
+        const y = s.health;
+        sumX += x;
+        sumY += y;
+        sumXY += x * y;
+        sumX2 += x * x;
+    }
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 0.001) {
+        // all samples at same time — can't compute trend
+        const current = samples[samples.length - 1].health;
+        return {
+            currentHealth: current,
+            trendPerHour: 0,
+            projectedHealth1h: current,
+            projectedHealth4h: current,
+            projectedHealth24h: current,
+            slaBreachInMs: current < slaThreshold ? 0 : -1,
+            slaBreachLabel: current < slaThreshold ? "now" : "never",
+            trend: "stable",
+        };
+    }
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    const currentHours = (now - t0) / 3_600_000;
+    const current = Math.round(intercept + slope * currentHours);
+    const h1 = Math.round(intercept + slope * (currentHours + 1));
+    const h4 = Math.round(intercept + slope * (currentHours + 4));
+    const h24 = Math.round(intercept + slope * (currentHours + 24));
+    // clamp projections to 0-100
+    const clamp = (v) => Math.max(0, Math.min(100, v));
+    let slaBreachMs = -1;
+    let slaBreachLabel = "never";
+    if (slope < -0.1 && current > slaThreshold) {
+        // health is declining — estimate when it crosses threshold
+        const hoursToBreak = (slaThreshold - current) / slope; // negative slope, so hoursToBreak > 0 when current > threshold
+        if (hoursToBreak > 0) {
+            slaBreachMs = Math.round(hoursToBreak * 3_600_000);
+            slaBreachLabel = formatDuration(slaBreachMs);
+        }
+    }
+    else if (current <= slaThreshold) {
+        slaBreachMs = 0;
+        slaBreachLabel = "now";
+    }
+    const trend = slope > 0.5 ? "improving" : slope < -0.5 ? "declining" : "stable";
+    return {
+        currentHealth: clamp(current),
+        trendPerHour: Math.round(slope * 10) / 10,
+        projectedHealth1h: clamp(h1),
+        projectedHealth4h: clamp(h4),
+        projectedHealth24h: clamp(h24),
+        slaBreachInMs: slaBreachMs,
+        slaBreachLabel,
+        trend,
+    };
+}
+/**
+ * Format health forecast for TUI display.
+ */
+export function formatHealthForecast(forecast) {
+    const trendIcon = forecast.trend === "improving" ? "📈" : forecast.trend === "declining" ? "📉" : "➡";
+    const lines = [];
+    lines.push(`  ${trendIcon} Fleet health forecast (${forecast.trend}, ${forecast.trendPerHour > 0 ? "+" : ""}${forecast.trendPerHour}/hr):`);
+    lines.push(`  Now: ${forecast.currentHealth}/100  →  1h: ${forecast.projectedHealth1h}  4h: ${forecast.projectedHealth4h}  24h: ${forecast.projectedHealth24h}`);
+    if (forecast.slaBreachInMs === 0) {
+        lines.push(`  🔴 SLA breach: NOW`);
+    }
+    else if (forecast.slaBreachInMs > 0) {
+        lines.push(`  ⚠ SLA breach in: ${forecast.slaBreachLabel}`);
+    }
+    else {
+        lines.push(`  ✅ No SLA breach projected`);
+    }
+    return lines;
+}
+function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    const h = Math.floor(ms / 3_600_000);
+    const m = Math.round((ms % 3_600_000) / 60_000);
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+//# sourceMappingURL=health-forecast.js.map