aoaoe 1.3.0 → 2.0.0

package/dist/token-quota.js

@@ -0,0 +1,76 @@
+// token-quota.ts — per-model token quotas for fleet-wide rate limiting.
+// extends the USD-based rate limiter with token-level granularity per model.
+/**
+ * Manage per-model token quotas.
+ */
+export class TokenQuotaManager {
+    quotas;
+    samples = [];
+    windowMs;
+    constructor(quotas = [], windowMs = 3_600_000) {
+        this.quotas = new Map(quotas.map((q) => [q.model, q]));
+        this.windowMs = windowMs;
+    }
+    /** Set or update a quota for a model. */
+    setQuota(model, maxInput, maxOutput) {
+        this.quotas.set(model, { model, maxInputTokensPerHour: maxInput, maxOutputTokensPerHour: maxOutput });
+    }
+    /** Record token usage for a model. */
+    recordUsage(model, inputTokens, outputTokens, now = Date.now()) {
+        this.samples.push({ timestamp: now, model, inputTokens, outputTokens });
+        this.prune(now);
+    }
+    /** Check if a model is within its token quota. */
+    getStatus(model, now = Date.now()) {
+        this.prune(now);
+        const quota = this.quotas.get(model);
+        if (!quota) {
+            return { model, inputTokensUsed: 0, outputTokensUsed: 0, inputLimit: Infinity, outputLimit: Infinity, inputPercent: 0, outputPercent: 0, blocked: false, reason: "no quota set" };
+        }
+        const cutoff = now - this.windowMs;
+        const modelSamples = this.samples.filter((s) => s.model === model && s.timestamp >= cutoff);
+        const inputUsed = modelSamples.reduce((sum, s) => sum + s.inputTokens, 0);
+        const outputUsed = modelSamples.reduce((sum, s) => sum + s.outputTokens, 0);
+        const inputPct = (inputUsed / quota.maxInputTokensPerHour) * 100;
+        const outputPct = (outputUsed / quota.maxOutputTokensPerHour) * 100;
+        const blocked = inputUsed >= quota.maxInputTokensPerHour || outputUsed >= quota.maxOutputTokensPerHour;
+        return {
+            model,
+            inputTokensUsed: inputUsed,
+            outputTokensUsed: outputUsed,
+            inputLimit: quota.maxInputTokensPerHour,
+            outputLimit: quota.maxOutputTokensPerHour,
+            inputPercent: inputPct,
+            outputPercent: outputPct,
+            blocked,
+            reason: blocked
+                ? `${inputUsed >= quota.maxInputTokensPerHour ? "input" : "output"} quota exceeded`
+                : "ok",
+        };
+    }
+    /** Check if reasoning should be blocked for a model. */
+    isBlocked(model, now = Date.now()) {
+        return this.getStatus(model, now).blocked;
+    }
+    /** Get status for all models with quotas. */
+    getAllStatuses(now = Date.now()) {
+        return [...this.quotas.keys()].map((m) => this.getStatus(m, now));
+    }
+    /** Format for TUI display. */
+    formatAll(now = Date.now()) {
+        const statuses = this.getAllStatuses(now);
+        if (statuses.length === 0)
+            return ["  (no token quotas configured)"];
+        const lines = [];
+        for (const s of statuses) {
+            const icon = s.blocked ? "🔴" : s.inputPercent > 80 || s.outputPercent > 80 ? "🟡" : "🟢";
+            lines.push(`  ${icon} ${s.model}: ${s.inputTokensUsed.toLocaleString()}/${s.inputLimit.toLocaleString()} in, ${s.outputTokensUsed.toLocaleString()}/${s.outputLimit.toLocaleString()} out (${Math.round(Math.max(s.inputPercent, s.outputPercent))}%)`);
+        }
+        return lines;
+    }
+    prune(now) {
+        const cutoff = now - this.windowMs * 2;
+        this.samples = this.samples.filter((s) => s.timestamp >= cutoff);
+    }
+}
+//# sourceMappingURL=token-quota.js.map

package/dist/workflow-chain.d.ts

@@ -0,0 +1,33 @@
+import type { WorkflowState } from "./workflow-engine.js";
+export interface WorkflowChainEntry {
+    workflowName: string;
+    dependsOn: string[];
+    status: "pending" | "active" | "completed" | "failed";
+}
+export interface WorkflowChain {
+    name: string;
+    entries: WorkflowChainEntry[];
+    startedAt: number;
+    completedAt?: number;
+}
+/**
+ * Create a workflow chain from a list of entries.
+ */
+export declare function createWorkflowChain(name: string, entries: Array<{
+    workflowName: string;
+    dependsOn?: string[];
+}>, now?: number): WorkflowChain;
+/**
+ * Advance the chain: activate workflows whose dependencies are met.
+ * Returns workflow names that should be started.
+ */
+export declare function advanceChain(chain: WorkflowChain, workflowStates: ReadonlyMap<string, WorkflowState>): {
+    activate: string[];
+    completed: boolean;
+    failed: boolean;
+};
+/**
+ * Format workflow chain for TUI display.
+ */
+export declare function formatWorkflowChain(chain: WorkflowChain): string[];
+//# sourceMappingURL=workflow-chain.d.ts.map

package/dist/workflow-chain.js

@@ -0,0 +1,69 @@
+// workflow-chain.ts — chain workflows together with dependencies.
+// a workflow chain is a sequence of workflows where each can depend on
+// the completion of previous workflows before starting.
+/**
+ * Create a workflow chain from a list of entries.
+ */
+export function createWorkflowChain(name, entries, now = Date.now()) {
+    return {
+        name,
+        entries: entries.map((e) => ({
+            workflowName: e.workflowName,
+            dependsOn: e.dependsOn ?? [],
+            status: "pending",
+        })),
+        startedAt: now,
+    };
+}
+/**
+ * Advance the chain: activate workflows whose dependencies are met.
+ * Returns workflow names that should be started.
+ */
+export function advanceChain(chain, workflowStates) {
+    const completedSet = new Set();
+    const failedSet = new Set();
+    for (const entry of chain.entries) {
+        const wfState = workflowStates.get(entry.workflowName);
+        if (entry.status === "completed" || wfState?.completedAt) {
+            entry.status = "completed";
+            completedSet.add(entry.workflowName);
+        }
+        if (entry.status === "failed") {
+            failedSet.add(entry.workflowName);
+        }
+    }
+    // check for failed chains
+    if (failedSet.size > 0) {
+        return { activate: [], completed: false, failed: true };
+    }
+    const activate = [];
+    for (const entry of chain.entries) {
+        if (entry.status !== "pending")
+            continue;
+        const depsmet = entry.dependsOn.every((dep) => completedSet.has(dep));
+        if (depsmet) {
+            entry.status = "active";
+            activate.push(entry.workflowName);
+        }
+    }
+    const allDone = chain.entries.every((e) => e.status === "completed");
+    if (allDone)
+        chain.completedAt = Date.now();
+    return { activate, completed: allDone, failed: false };
+}
+/**
+ * Format workflow chain for TUI display.
+ */
+export function formatWorkflowChain(chain) {
+    const lines = [];
+    const elapsed = chain.completedAt ? chain.completedAt - chain.startedAt : Date.now() - chain.startedAt;
+    const dur = elapsed < 60_000 ? `${Math.round(elapsed / 1000)}s` : `${Math.round(elapsed / 60_000)}m`;
+    lines.push(`  Workflow chain: ${chain.name} (${dur})`);
+    for (const e of chain.entries) {
+        const icon = e.status === "completed" ? "✓" : e.status === "active" ? "▶" : e.status === "failed" ? "✗" : "○";
+        const deps = e.dependsOn.length > 0 ? ` ← [${e.dependsOn.join(", ")}]` : "";
+        lines.push(`  ${icon} ${e.workflowName} (${e.status})${deps}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-chain.js.map

package/dist/workflow-cost-forecast.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowDefinition } from "./workflow-engine.js";
+export interface WorkflowCostForecast {
+    workflowName: string;
+    totalEstimatedCostUsd: number;
+    totalEstimatedHours: number;
+    stages: Array<{
+        name: string;
+        taskCount: number;
+        estimatedCostUsd: number;
+        estimatedHours: number;
+    }>;
+    confidence: "low" | "medium" | "high";
+}
+/**
+ * Estimate the total cost of running a workflow.
+ */
+export declare function forecastWorkflowCost(workflow: WorkflowDefinition, historicalCostPerHour?: number): WorkflowCostForecast;
+/**
+ * Format workflow cost forecast for TUI display.
+ */
+export declare function formatWorkflowCostForecast(forecast: WorkflowCostForecast): string[];
+//# sourceMappingURL=workflow-cost-forecast.d.ts.map

package/dist/workflow-cost-forecast.js

@@ -0,0 +1,55 @@
+// workflow-cost-forecast.ts — estimate total workflow cost before starting.
+// uses per-stage task difficulty + historical cost patterns to project spend.
+import { scoreDifficulty } from "./difficulty-scorer.js";
+// rough cost per difficulty point per hour (based on typical LLM usage)
+const COST_PER_DIFFICULTY_HOUR = 0.50; // $0.50/difficulty-point/hour
+/**
+ * Estimate the total cost of running a workflow.
+ */
+export function forecastWorkflowCost(workflow, historicalCostPerHour) {
+    const costRate = historicalCostPerHour ?? COST_PER_DIFFICULTY_HOUR;
+    let totalCost = 0;
+    let totalHours = 0;
+    const stages = workflow.stages.map((stage) => {
+        let stageCost = 0;
+        let stageHours = 0;
+        for (const task of stage.tasks) {
+            const difficulty = scoreDifficulty(task.sessionTitle, task.goal);
+            const hours = difficulty.estimatedHours;
+            const cost = hours * costRate * (difficulty.score / 5); // scale by difficulty
+            stageCost += cost;
+            stageHours = Math.max(stageHours, hours); // parallel tasks: max duration
+        }
+        totalCost += stageCost;
+        totalHours += stageHours; // sequential stages: sum durations
+        return {
+            name: stage.name,
+            taskCount: stage.tasks.length,
+            estimatedCostUsd: Math.round(stageCost * 100) / 100,
+            estimatedHours: Math.round(stageHours * 10) / 10,
+        };
+    });
+    const confidence = historicalCostPerHour ? "medium" : "low";
+    return {
+        workflowName: workflow.name,
+        totalEstimatedCostUsd: Math.round(totalCost * 100) / 100,
+        totalEstimatedHours: Math.round(totalHours * 10) / 10,
+        stages,
+        confidence,
+    };
+}
+/**
+ * Format workflow cost forecast for TUI display.
+ */
+export function formatWorkflowCostForecast(forecast) {
+    const conf = forecast.confidence === "high" ? "●" : forecast.confidence === "medium" ? "◐" : "○";
+    const lines = [];
+    lines.push(`  ${conf} Workflow cost forecast: "${forecast.workflowName}"`);
+    lines.push(`  Total: ~$${forecast.totalEstimatedCostUsd.toFixed(2)} over ~${forecast.totalEstimatedHours}h`);
+    lines.push("");
+    for (const s of forecast.stages) {
+        lines.push(`  ${s.name}: ${s.taskCount} task${s.taskCount !== 1 ? "s" : ""}, ~$${s.estimatedCostUsd.toFixed(2)}, ~${s.estimatedHours}h`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-cost-forecast.js.map

package/dist/workflow-templates.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowDefinition } from "./workflow-engine.js";
+export interface WorkflowTemplate {
+    name: string;
+    description: string;
+    stages: Array<{
+        name: string;
+        taskGoals: string[];
+    }>;
+    tags: string[];
+}
+export declare const BUILTIN_WORKFLOW_TEMPLATES: WorkflowTemplate[];
+/**
+ * Find a workflow template by name.
+ */
+export declare function findWorkflowTemplate(name: string): WorkflowTemplate | undefined;
+/**
+ * Instantiate a workflow definition from a template.
+ * sessionPrefix is used to generate session titles for each task.
+ */
+export declare function instantiateWorkflow(template: WorkflowTemplate, sessionPrefix: string): WorkflowDefinition;
+/**
+ * Format workflow template list for TUI display.
+ */
+export declare function formatWorkflowTemplateList(): string[];
+//# sourceMappingURL=workflow-templates.d.ts.map

package/dist/workflow-templates.js

@@ -0,0 +1,92 @@
+// workflow-templates.ts — pre-built workflow definitions for common patterns.
+// each template produces a WorkflowDefinition ready to instantiate.
+export const BUILTIN_WORKFLOW_TEMPLATES = [
+    {
+        name: "ci-cd",
+        description: "Build → Test → Deploy pipeline",
+        stages: [
+            { name: "build", taskGoals: ["Build the project and fix any compilation errors"] },
+            { name: "test", taskGoals: ["Run the full test suite and fix any failures"] },
+            { name: "deploy", taskGoals: ["Deploy to staging/production and verify health checks"] },
+        ],
+        tags: ["ci", "cd", "deploy"],
+    },
+    {
+        name: "feature-dev",
+        description: "Implement → Test → Review → Merge",
+        stages: [
+            { name: "implement", taskGoals: ["Implement the feature according to the spec"] },
+            { name: "test", taskGoals: ["Write unit and integration tests for the new feature", "Run existing tests to verify no regressions"] },
+            { name: "review", taskGoals: ["Self-review: check for code quality, security, and documentation"] },
+            { name: "merge", taskGoals: ["Create PR, address feedback, merge to main"] },
+        ],
+        tags: ["feature", "development"],
+    },
+    {
+        name: "refactor",
+        description: "Analyze → Refactor → Test → Cleanup",
+        stages: [
+            { name: "analyze", taskGoals: ["Identify code smells, duplications, and improvement opportunities"] },
+            { name: "refactor", taskGoals: ["Apply refactoring changes incrementally with tests passing at each step"] },
+            { name: "test", taskGoals: ["Run full test suite, fix any regressions from refactoring"] },
+            { name: "cleanup", taskGoals: ["Remove dead code, update documentation, commit with clear message"] },
+        ],
+        tags: ["refactor", "cleanup"],
+    },
+    {
+        name: "incident-response",
+        description: "Triage → Fix → Test → Postmortem",
+        stages: [
+            { name: "triage", taskGoals: ["Identify root cause from logs and error output"] },
+            { name: "fix", taskGoals: ["Implement the fix with minimal blast radius"] },
+            { name: "test", taskGoals: ["Verify fix resolves the issue, run regression tests"] },
+            { name: "postmortem", taskGoals: ["Document what happened, why, and how to prevent recurrence"] },
+        ],
+        tags: ["incident", "hotfix", "production"],
+    },
+    {
+        name: "multi-repo",
+        description: "Parallel work across multiple repositories",
+        stages: [
+            { name: "parallel-work", taskGoals: ["Complete assigned work in each repository"] },
+            { name: "integration", taskGoals: ["Verify cross-repo integration works correctly"] },
+            { name: "release", taskGoals: ["Tag releases and update dependency references"] },
+        ],
+        tags: ["multi-repo", "monorepo"],
+    },
+];
+/**
+ * Find a workflow template by name.
+ */
+export function findWorkflowTemplate(name) {
+    return BUILTIN_WORKFLOW_TEMPLATES.find((t) => t.name.toLowerCase() === name.toLowerCase());
+}
+/**
+ * Instantiate a workflow definition from a template.
+ * sessionPrefix is used to generate session titles for each task.
+ */
+export function instantiateWorkflow(template, sessionPrefix) {
+    let taskCounter = 0;
+    const stages = template.stages.map((s) => ({
+        name: s.name,
+        tasks: s.taskGoals.map((goal) => {
+            taskCounter++;
+            return { sessionTitle: `${sessionPrefix}-${s.name}-${taskCounter}`, goal };
+        }),
+    }));
+    return { name: `${sessionPrefix}-${template.name}`, stages };
+}
+/**
+ * Format workflow template list for TUI display.
+ */
+export function formatWorkflowTemplateList() {
+    const lines = [];
+    lines.push(`  Workflow templates (${BUILTIN_WORKFLOW_TEMPLATES.length} built-in):`);
+    for (const t of BUILTIN_WORKFLOW_TEMPLATES) {
+        const stageNames = t.stages.map((s) => s.name).join(" → ");
+        lines.push(`  ${t.name.padEnd(18)} ${stageNames}  [${t.tags.join(", ")}]`);
+        lines.push(`    ${t.description}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-templates.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aoaoe",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",