aegis-bridge 0.1.0

package/dist/model-router.d.ts

@@ -0,0 +1,53 @@
+/**
+ * model-router.ts — Issue #743: Tiered Model Routing
+ *
+ * Scores task complexity from metadata (title, labels, description) and routes
+ * to the optimal model tier: fast | standard | power.
+ *
+ * Scoring (0–100):
+ *   0–30  → fast     (cheapest, e.g. Haiku-class)
+ *   31–70 → standard (balanced, e.g. Sonnet-class)
+ *   71–100 → power   (most capable, e.g. Opus-class)
+ *
+ * Concrete model names are configurable via environment variables:
+ *   MODEL_FAST, MODEL_STANDARD, MODEL_POWER
+ */
+import type { FastifyInstance } from 'fastify';
+export type ModelTier = 'fast' | 'standard' | 'power';
+export interface RoutingDecision {
+    tier: ModelTier;
+    model: string;
+    score: number;
+    reasoning: string[];
+}
+/** Default model names per tier (overridable via env vars). */
+export declare const MODEL_TIERS: Record<ModelTier, string>;
+/**
+ * Score a task 0–100 based on its metadata.
+ * Returns the score and a human-readable reasoning list.
+ */
+export declare function scoreTaskComplexity(title: string, labels: string[], description: string): {
+    score: number;
+    reasoning: string[];
+};
+/** Map a 0–100 score to a model tier. */
+export declare function scoreToTier(score: number): ModelTier;
+/**
+ * Route a task to the optimal model tier and concrete model name.
+ *
+ * @example
+ *   routeTask({ title: 'fix typo in README', labels: ['docs'] })
+ *   // → { tier: 'fast', model: 'claude-haiku-4-5', score: 15, reasoning: [...] }
+ */
+export declare function routeTask(opts: {
+    title: string;
+    labels?: string[];
+    description?: string;
+}): RoutingDecision;
+/**
+ * Register the model-routing endpoint on the Fastify app.
+ *
+ * POST /v1/dev/route-task — score a task and return model recommendation.
+ * GET  /v1/dev/model-tiers — return current model-tier configuration.
+ */
+export declare function registerModelRouterRoutes(app: FastifyInstance): void;

package/dist/model-router.js

@@ -0,0 +1,150 @@
+/**
+ * model-router.ts — Issue #743: Tiered Model Routing
+ *
+ * Scores task complexity from metadata (title, labels, description) and routes
+ * to the optimal model tier: fast | standard | power.
+ *
+ * Scoring (0–100):
+ *   0–30  → fast     (cheapest, e.g. Haiku-class)
+ *   31–70 → standard (balanced, e.g. Sonnet-class)
+ *   71–100 → power   (most capable, e.g. Opus-class)
+ *
+ * Concrete model names are configurable via environment variables:
+ *   MODEL_FAST, MODEL_STANDARD, MODEL_POWER
+ */
+import { z } from 'zod';
+/** Keyword signals mapped to model tier. First match in each tier wins. */
+const ROUTING_KEYWORDS = {
+    power: [
+        'security', 'auth', 'authentication', 'authorization',
+        'architecture', 'redesign', 'migration', 'critical',
+        'vulnerability', 'injection', 'cryptography', 'encryption',
+        'race condition', 'concurrency', 'breaking change',
+        'permission', 'privilege', 'escalation',
+    ],
+    standard: [
+        'feature', 'enhancement', 'refactor', 'type-safety',
+        'integration', 'api', 'endpoint', 'validation',
+        'test', 'coverage', 'hook', 'pipeline', 'routing',
+        'module', 'performance', 'optimization',
+    ],
+    fast: [
+        'typo', 'docs', 'documentation', 'label', 'rename',
+        'bump', 'chore', 'formatting', 'comment', 'readme',
+        'changelog', 'version', 'lint', 'whitespace',
+    ],
+};
+/** Default model names per tier (overridable via env vars). */
+export const MODEL_TIERS = {
+    fast: process.env.MODEL_FAST ?? 'claude-haiku-4-5',
+    standard: process.env.MODEL_STANDARD ?? 'claude-sonnet-4-6',
+    power: process.env.MODEL_POWER ?? 'claude-opus-4-6',
+};
+/**
+ * Score a task 0–100 based on its metadata.
+ * Returns the score and a human-readable reasoning list.
+ */
+export function scoreTaskComplexity(title, labels, description) {
+    const reasoning = [];
+    let score = 35; // baseline: low-standard
+    const text = `${title} ${description}`.toLowerCase();
+    // Power keywords → raise score to at least power tier threshold
+    for (const kw of ROUTING_KEYWORDS.power) {
+        if (text.includes(kw)) {
+            score = Math.max(score, 75);
+            reasoning.push(`power keyword: "${kw}"`);
+            break;
+        }
+    }
+    // Fast keywords → lower score to at most fast tier threshold
+    for (const kw of ROUTING_KEYWORDS.fast) {
+        if (text.includes(kw)) {
+            score = Math.min(score, 20);
+            reasoning.push(`fast keyword: "${kw}"`);
+            break;
+        }
+    }
+    // Standard keywords → minor boost (avoid staying at baseline)
+    if (reasoning.length === 0) {
+        for (const kw of ROUTING_KEYWORDS.standard) {
+            if (text.includes(kw)) {
+                score += 5;
+                reasoning.push(`standard keyword: "${kw}"`);
+                break;
+            }
+        }
+    }
+    // Label overrides — applied after keyword signals
+    for (const label of labels) {
+        const l = label.toLowerCase();
+        if (l === 'security' || l === 'critical' || l === 'breaking-change') {
+            score = Math.max(score, 80);
+            reasoning.push(`label override: "${l}" → power tier`);
+        }
+        else if (l === 'docs' || l === 'documentation' || l === 'chore') {
+            score = Math.min(score, 20);
+            reasoning.push(`label override: "${l}" → fast tier`);
+        }
+    }
+    // Priority labels
+    for (const label of labels) {
+        if (label === 'P0' || label === 'P1') {
+            score = Math.max(score, 72);
+            reasoning.push(`priority label: "${label}" → elevate to power`);
+        }
+        else if (label === 'P3') {
+            score = Math.min(score, 55);
+            reasoning.push(`priority label: "P3" → cap at standard`);
+        }
+    }
+    if (reasoning.length === 0)
+        reasoning.push('baseline score — no keyword or label signals');
+    return { score: Math.max(0, Math.min(100, score)), reasoning };
+}
+/** Map a 0–100 score to a model tier. */
+export function scoreToTier(score) {
+    if (score <= 30)
+        return 'fast';
+    if (score <= 70)
+        return 'standard';
+    return 'power';
+}
+/**
+ * Route a task to the optimal model tier and concrete model name.
+ *
+ * @example
+ *   routeTask({ title: 'fix typo in README', labels: ['docs'] })
+ *   // → { tier: 'fast', model: 'claude-haiku-4-5', score: 15, reasoning: [...] }
+ */
+export function routeTask(opts) {
+    const { title, labels = [], description = '' } = opts;
+    const { score, reasoning } = scoreTaskComplexity(title, labels, description);
+    const tier = scoreToTier(score);
+    const model = MODEL_TIERS[tier];
+    return { tier, model, score, reasoning };
+}
+/** Zod schema for POST /v1/dev/route-task request body. */
+const routeTaskSchema = z.object({
+    title: z.string().min(1).max(500),
+    labels: z.array(z.string().max(100)).max(50).optional(),
+    description: z.string().max(10_000).optional(),
+});
+/**
+ * Register the model-routing endpoint on the Fastify app.
+ *
+ * POST /v1/dev/route-task — score a task and return model recommendation.
+ * GET  /v1/dev/model-tiers — return current model-tier configuration.
+ */
+export function registerModelRouterRoutes(app) {
+    app.post('/v1/dev/route-task', async (req, reply) => {
+        const parsed = routeTaskSchema.safeParse(req.body ?? {});
+        if (!parsed.success) {
+            return reply.status(400).send({ error: 'Invalid body', details: parsed.error.issues });
+        }
+        const { title, labels, description } = parsed.data;
+        return routeTask({ title, labels, description });
+    });
+    app.get('/v1/dev/model-tiers', async () => {
+        return { tiers: MODEL_TIERS };
+    });
+}

package/dist/monitor.d.ts

@@ -0,0 +1,103 @@
+/**
+ * monitor.ts — Background monitor that polls sessions and routes events to channels.
+ *
+ * Runs a polling loop that:
+ * 1. Checks each active session for new JSONL entries
+ * 2. Detects status changes (working → idle, permission prompts, etc.)
+ * 3. Routes events to the ChannelManager (which fans out to Telegram, webhooks, etc.)
+ */
+import { type SessionManager } from './session.js';
+import { type TmuxManager } from './tmux.js';
+import { type ChannelManager } from './channels/index.js';
+import { type SessionEventBus } from './events.js';
+import { type JsonlWatcher } from './jsonl-watcher.js';
+export interface MonitorConfig {
+    pollIntervalMs: number;
+    fastPollIntervalMs: number;
+    hookQuietMs: number;
+    stallThresholdMs: number;
+    stallCheckIntervalMs: number;
+    deadCheckIntervalMs: number;
+    permissionStallMs: number;
+    unknownStallMs: number;
+    permissionTimeoutMs: number;
+}
+export declare const DEFAULT_MONITOR_CONFIG: MonitorConfig;
+export declare class SessionMonitor {
+    private sessions;
+    private channels;
+    private config;
+    private running;
+    private lastStatus;
+    private lastBytesSeen;
+    private stallNotified;
+    /** Issue #663: O(1) stall notification check. */
+    private stallHas;
+    /** Issue #663: O(1) stall notification add. */
+    private stallAdd;
+    /** Issue #663: O(1) stall notification delete. */
+    private stallDelete;
+    /** Issue #663: Delete all stall notifications for a session. */
+    private stallDeleteAll;
+    /** Issue #663: Delete specific stall types for a session. */
+    private stallDeleteTypes;
+    private lastStallCheck;
+    private lastDeadCheck;
+    private idleNotified;
+    private idleSince;
+    private processedStopSignals;
+    private static readonly MAX_PROCESSED_STOP_SIGNALS;
+    private stateSince;
+    private deadNotified;
+    private prevStatusForStall;
+    private rateLimitedSessions;
+    private tmuxWasDown;
+    private lastTmuxHealthCheck;
+    private static readonly TMUX_HEALTH_CHECK_INTERVAL_MS;
+    /** Issue #89 L4: Debounce status change broadcasts per session.
+     *  If multiple status changes happen within 500ms, only emit the last one.
+     *  Prevents rapid-fire notifications during state transitions. */
+    private statusChangeDebounce;
+    /** Issue #32: Optional SSE event bus for real-time streaming. */
+    private eventBus?;
+    /** Issue #84: fs.watch-based JSONL watcher for near-instant message detection. */
+    private jsonlWatcher?;
+    constructor(sessions: SessionManager, channels: ChannelManager, config?: MonitorConfig);
+    /** Issue #32: Set the event bus for SSE streaming. */
+    setEventBus(bus: SessionEventBus): void;
+    /** Issue #397: Set the TmuxManager reference for tmux health checks. */
+    private tmux?;
+    setTmuxManager(tmuxManager: TmuxManager): void;
+    /** Issue #84: Set the JSONL watcher for fs.watch-based message detection. */
+    setJsonlWatcher(watcher: JsonlWatcher): void;
+    start(): void;
+    stop(): void;
+    private loop;
+    /** Check if any active session hasn't received a hook recently. */
+    private needsFastPolling;
+    private poll;
+    /** Smart stall detection: multiple stall types with graduated thresholds.
+     *
+     * Detects 4 types of stalls:
+     * 1. JSONL stall: "working" but no new JSONL bytes for stallThresholdMs
+     * 2. Permission stall: permission_prompt/bash_approval for permissionStallMs
+     * 3. Unknown stall: unknown state for unknownStallMs (CC stuck in transition)
+     * 4. State duration stall: any non-idle state for 2x its threshold
+     */
+    private checkForStalls;
+    /** Issue #15: Check for Stop/StopFailure signals written by hook.ts. */
+    private checkStopSignals;
+    /** Issue #84: Handle new entries from the fs.watch-based JSONL watcher.
+     *  Forwards messages to channels and updates stall tracking. */
+    private handleWatcherEvent;
+    private checkSession;
+    private forwardMessage;
+    private broadcastStatusChange;
+    private makePayload;
+    /** Check for dead tmux windows and notify via channels. */
+    private checkDeadSessions;
+    /** Issue #397: Check tmux server health. Detect crashes and trigger reconciliation. */
+    private checkTmuxHealth;
+    /** Clean up tracking for a killed session. */
+    removeSession(sessionId: string): void;
+}