profclaw 0.0.1-beta.1

package/dist/costs/persistence.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Cost History Persistence
+ *
+ * Flushes in-memory usage data to SQLite for long-term tracking.
+ * Provides aggregation queries for analytics dashboards.
+ */
+interface CostEntry {
+    model: string;
+    provider?: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cost: number;
+    source: string;
+    agentId?: string;
+    sessionId?: string;
+}
+interface CostAggregation {
+    period: string;
+    totalCost: number;
+    totalTokens: number;
+    byModel: Record<string, {
+        cost: number;
+        tokens: number;
+        count: number;
+    }>;
+    bySource: Record<string, {
+        cost: number;
+        tokens: number;
+        count: number;
+    }>;
+    entryCount: number;
+}
+type DbClient = {
+    execute: (sql: string, params?: unknown[]) => Promise<unknown>;
+};
+/**
+ * Initialize cost persistence with database connection
+ */
+export declare function initCostPersistence(getDb: () => DbClient): void;
+/**
+ * Record a cost entry (buffered, flushed periodically)
+ */
+export declare function recordCost(entry: CostEntry): void;
+/**
+ * Flush buffered entries to database
+ */
+export declare function flushPending(): Promise<number>;
+/**
+ * Query cost history with aggregation
+ */
+export declare function getCostHistory(options?: {
+    since?: Date;
+    until?: Date;
+    model?: string;
+    source?: string;
+    limit?: number;
+}): Promise<CostAggregation>;
+/**
+ * Get daily cost breakdown for the last N days
+ */
+export declare function getDailyCosts(days?: number): Promise<Array<{
+    date: string;
+    cost: number;
+    tokens: number;
+    requests: number;
+}>>;
+/**
+ * Cleanup old cost history entries
+ */
+export declare function pruneCostHistory(retainDays?: number): Promise<number>;
+/**
+ * Stop cost persistence (flush remaining, clear interval)
+ */
+export declare function stopCostPersistence(): Promise<void>;
+export {};
+//# sourceMappingURL=persistence.d.ts.map

package/dist/costs/persistence.js

@@ -0,0 +1,210 @@
+/**
+ * Cost History Persistence
+ *
+ * Flushes in-memory usage data to SQLite for long-term tracking.
+ * Provides aggregation queries for analytics dashboards.
+ */
+import { randomUUID } from 'crypto';
+import { logger } from '../utils/logger.js';
+// Buffer for batch writes
+const pendingEntries = [];
+let flushInterval = null;
+let getDbFn = null;
+/**
+ * Initialize cost persistence with database connection
+ */
+export function initCostPersistence(getDb) {
+    getDbFn = getDb;
+    // Create table if not exists
+    ensureTable().catch((err) => {
+        logger.warn('[CostPersistence] Failed to create table', { error: err.message });
+    });
+    // Flush every 30 seconds
+    flushInterval = setInterval(() => {
+        flushPending().catch((err) => {
+            logger.warn('[CostPersistence] Flush failed', { error: err.message });
+        });
+    }, 30_000);
+    logger.info('[CostPersistence] Initialized');
+}
+async function ensureTable() {
+    if (!getDbFn)
+        return;
+    const db = getDbFn();
+    await db.execute(`
+    CREATE TABLE IF NOT EXISTS cost_history (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      model TEXT NOT NULL,
+      provider TEXT,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      cost INTEGER NOT NULL DEFAULT 0,
+      source TEXT NOT NULL DEFAULT 'chat',
+      agent_id TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL DEFAULT (unixepoch())
+    )
+  `);
+    // Index for time-range queries
+    await db.execute(`
+    CREATE INDEX IF NOT EXISTS idx_cost_history_created
+    ON cost_history(created_at)
+  `);
+    await db.execute(`
+    CREATE INDEX IF NOT EXISTS idx_cost_history_model
+    ON cost_history(model)
+  `);
+}
+/**
+ * Record a cost entry (buffered, flushed periodically)
+ */
+export function recordCost(entry) {
+    pendingEntries.push(entry);
+    // Flush immediately if buffer is large
+    if (pendingEntries.length >= 50) {
+        flushPending().catch(() => { });
+    }
+}
+/**
+ * Flush buffered entries to database
+ */
+export async function flushPending() {
+    if (pendingEntries.length === 0 || !getDbFn)
+        return 0;
+    const entries = pendingEntries.splice(0, pendingEntries.length);
+    const db = getDbFn();
+    let written = 0;
+    for (const entry of entries) {
+        try {
+            const id = randomUUID();
+            // Store cost as microdollars (integer) for precision
+            const costMicro = Math.round(entry.cost * 1_000_000);
+            await db.execute(`INSERT INTO cost_history (id, session_id, model, provider, input_tokens, output_tokens, total_tokens, cost, source, agent_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, unixepoch())`, [id, entry.sessionId ?? null, entry.model, entry.provider ?? null,
+                entry.inputTokens, entry.outputTokens, entry.totalTokens,
+                costMicro, entry.source, entry.agentId ?? null]);
+            written++;
+        }
+        catch (err) {
+            logger.warn('[CostPersistence] Failed to write entry', {
+                model: entry.model,
+                error: err.message,
+            });
+        }
+    }
+    if (written > 0) {
+        logger.debug('[CostPersistence] Flushed entries', { count: written });
+    }
+    return written;
+}
+/**
+ * Query cost history with aggregation
+ */
+export async function getCostHistory(options = {}) {
+    if (!getDbFn) {
+        return { period: 'all', totalCost: 0, totalTokens: 0, byModel: {}, bySource: {}, entryCount: 0 };
+    }
+    const db = getDbFn();
+    const conditions = [];
+    const params = [];
+    if (options.since) {
+        conditions.push('created_at >= ?');
+        params.push(Math.floor(options.since.getTime() / 1000));
+    }
+    if (options.until) {
+        conditions.push('created_at <= ?');
+        params.push(Math.floor(options.until.getTime() / 1000));
+    }
+    if (options.model) {
+        conditions.push('model = ?');
+        params.push(options.model);
+    }
+    if (options.source) {
+        conditions.push('source = ?');
+        params.push(options.source);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = options.limit ?? 10000;
+    const result = await db.execute(`SELECT model, source, agent_id, input_tokens, output_tokens, total_tokens, cost
+     FROM cost_history ${where} ORDER BY created_at DESC LIMIT ?`, [...params, limit]);
+    const rows = result.rows ?? [];
+    const byModel = {};
+    const bySource = {};
+    let totalCost = 0;
+    let totalTokens = 0;
+    for (const row of rows) {
+        const model = String(row['model'] ?? 'unknown');
+        const source = String(row['source'] ?? 'unknown');
+        const costUsd = Number(row['cost'] ?? 0) / 1_000_000;
+        const tokens = Number(row['total_tokens'] ?? 0);
+        totalCost += costUsd;
+        totalTokens += tokens;
+        if (!byModel[model])
+            byModel[model] = { cost: 0, tokens: 0, count: 0 };
+        byModel[model].cost += costUsd;
+        byModel[model].tokens += tokens;
+        byModel[model].count += 1;
+        if (!bySource[source])
+            bySource[source] = { cost: 0, tokens: 0, count: 0 };
+        bySource[source].cost += costUsd;
+        bySource[source].tokens += tokens;
+        bySource[source].count += 1;
+    }
+    const period = options.since
+        ? `${options.since.toISOString()} - ${options.until?.toISOString() ?? 'now'}`
+        : 'all';
+    return { period, totalCost, totalTokens, byModel, bySource, entryCount: rows.length };
+}
+/**
+ * Get daily cost breakdown for the last N days
+ */
+export async function getDailyCosts(days = 30) {
+    if (!getDbFn)
+        return [];
+    const db = getDbFn();
+    const since = Math.floor(Date.now() / 1000) - (days * 86400);
+    const result = await db.execute(`SELECT date(created_at, 'unixepoch') as day,
+            SUM(cost) as total_cost,
+            SUM(total_tokens) as total_tokens,
+            COUNT(*) as request_count
+     FROM cost_history
+     WHERE created_at >= ?
+     GROUP BY day
+     ORDER BY day DESC`, [since]);
+    return (result.rows ?? []).map(row => ({
+        date: String(row['day']),
+        cost: Number(row['total_cost'] ?? 0) / 1_000_000,
+        tokens: Number(row['total_tokens'] ?? 0),
+        requests: Number(row['request_count'] ?? 0),
+    }));
+}
+/**
+ * Cleanup old cost history entries
+ */
+export async function pruneCostHistory(retainDays = 90) {
+    if (!getDbFn)
+        return 0;
+    const db = getDbFn();
+    const cutoff = Math.floor(Date.now() / 1000) - (retainDays * 86400);
+    const result = await db.execute('DELETE FROM cost_history WHERE created_at < ?', [cutoff]);
+    const pruned = result.rowsAffected ?? 0;
+    if (pruned > 0) {
+        logger.info('[CostPersistence] Pruned old entries', { pruned, retainDays });
+    }
+    return pruned;
+}
+/**
+ * Stop cost persistence (flush remaining, clear interval)
+ */
+export async function stopCostPersistence() {
+    if (flushInterval) {
+        clearInterval(flushInterval);
+        flushInterval = null;
+    }
+    // Final flush
+    await flushPending();
+    logger.info('[CostPersistence] Stopped');
+}
+//# sourceMappingURL=persistence.js.map

package/dist/costs/pricing.d.ts

@@ -0,0 +1,16 @@
+export interface ModelPricing {
+    model: string;
+    provider: 'anthropic' | 'openai' | 'google' | 'meta' | 'other';
+    inputRate: number;
+    outputRate: number;
+}
+/**
+ * Get pricing for a given model
+ * Fallback to a default if not found
+ */
+export declare function getModelPricing(model: string): ModelPricing;
+/**
+ * Calculate cost for token usage
+ */
+export declare function calculateCost(model: string, inputTokens: number, outputTokens: number): number;
+//# sourceMappingURL=pricing.d.ts.map

package/dist/costs/pricing.js

@@ -0,0 +1,39 @@
+import { loadConfig } from '../utils/config-loader.js';
+// Load dynamic config
+const pricingConfig = loadConfig('pricing.yml');
+/**
+ * Get pricing for a given model
+ * Fallback to a default if not found
+ */
+export function getModelPricing(model) {
+    const models = pricingConfig.pricing || {};
+    // Try exact match
+    if (models[model]) {
+        return { ...models[model], model };
+    }
+    // Try partial match (e.g., if model has version suffix)
+    const key = Object.keys(models).find(k => model.startsWith(k));
+    if (key) {
+        return { ...models[key], model: key };
+    }
+    // Fallback
+    return {
+        ...(pricingConfig.defaultPricing || {
+            provider: 'other',
+            inputRate: 5.00,
+            outputRate: 15.00,
+        }),
+        model: 'default',
+    };
+}
+/**
+ * Calculate cost for token usage
+ */
+export function calculateCost(model, inputTokens, outputTokens) {
+    const pricing = getModelPricing(model);
+    const inputCost = (inputTokens / 1_000_000) * pricing.inputRate;
+    const outputCost = (outputTokens / 1_000_000) * pricing.outputRate;
+    // Return rounded to 6 decimal places
+    return Math.round((inputCost + outputCost) * 1_000_000) / 1_000_000;
+}
+//# sourceMappingURL=pricing.js.map

package/dist/costs/token-tracker.d.ts

@@ -0,0 +1,34 @@
+export interface UsageSummary {
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    totalCost: number;
+    taskCount: number;
+    byModel: Record<string, {
+        tokens: number;
+        cost: number;
+        tasks: number;
+    }>;
+    byAgent: Record<string, {
+        tokens: number;
+        cost: number;
+        tasks: number;
+    }>;
+}
+/**
+ * Initialize the token tracker
+ */
+export declare function initTokenTracker(): void;
+/**
+ * Track usage from a chat/agentic session (not queue tasks)
+ */
+export declare function trackChatUsage(model: string, totalTokens: number, inputTokens?: number, outputTokens?: number): void;
+/**
+ * Get current usage summary
+ */
+export declare function getUsageSummary(): UsageSummary;
+/**
+ * Reset usage (for testing or billing cycles)
+ */
+export declare function resetUsage(): void;
+//# sourceMappingURL=token-tracker.d.ts.map

package/dist/costs/token-tracker.js

@@ -0,0 +1,141 @@
+import { onTaskEvent } from '../queue/index.js';
+import { calculateCost } from './pricing.js';
+import { logger } from '../utils/logger.js';
+import { recordCost } from './persistence.js';
+// In-memory usage store
+let globalUsage = {
+    totalTokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalCost: 0,
+    taskCount: 0,
+    byModel: {},
+    byAgent: {},
+};
+/**
+ * Initialize the token tracker
+ */
+export function initTokenTracker() {
+    logger.info('Initializing token tracker...');
+    // Subscribe to task events
+    onTaskEvent((event) => {
+        if (isCompletedTaskEvent(event)) {
+            trackTaskUsage(event.task, event.result);
+        }
+    });
+}
+function isCompletedTaskEvent(event) {
+    return event.type === 'completed' && typeof event.task === 'object' && event.task !== null
+        && typeof event.result === 'object' && event.result !== null;
+}
+/**
+ * Track usage for a single task
+ */
+function trackTaskUsage(task, result) {
+    if (!result.tokensUsed)
+        return;
+    const { input, output, total } = result.tokensUsed;
+    // Get model from task metadata or default
+    const model = typeof task.metadata?.model === 'string'
+        ? task.metadata.model
+        : 'claude-3-5-sonnet';
+    const agentId = task.assignedAgentId || 'unknown';
+    // Calculate cost
+    const cost = result.cost?.amount !== undefined
+        ? result.cost.amount
+        : calculateCost(model, input, output);
+    // Update global stats
+    globalUsage.totalTokens += total;
+    globalUsage.inputTokens += input;
+    globalUsage.outputTokens += output;
+    globalUsage.totalCost += cost;
+    globalUsage.taskCount += 1;
+    // Update per-model stats
+    if (!globalUsage.byModel[model]) {
+        globalUsage.byModel[model] = { tokens: 0, cost: 0, tasks: 0 };
+    }
+    globalUsage.byModel[model].tokens += total;
+    globalUsage.byModel[model].cost += cost;
+    globalUsage.byModel[model].tasks += 1;
+    // Update per-agent stats
+    if (!globalUsage.byAgent[agentId]) {
+        globalUsage.byAgent[agentId] = { tokens: 0, cost: 0, tasks: 0 };
+    }
+    globalUsage.byAgent[agentId].tokens += total;
+    globalUsage.byAgent[agentId].cost += cost;
+    globalUsage.byAgent[agentId].tasks += 1;
+    // Persist to database
+    recordCost({
+        model,
+        inputTokens: input,
+        outputTokens: output,
+        totalTokens: total,
+        cost,
+        source: 'task',
+        agentId,
+    });
+    logger.debug('Usage tracked for task', {
+        taskId: task.id,
+        model,
+        tokens: total,
+        cost,
+    });
+}
+/**
+ * Track usage from a chat/agentic session (not queue tasks)
+ */
+export function trackChatUsage(model, totalTokens, inputTokens, outputTokens) {
+    const input = inputTokens ?? Math.floor(totalTokens * 0.7);
+    const output = outputTokens ?? totalTokens - input;
+    const cost = calculateCost(model, input, output);
+    globalUsage.totalTokens += totalTokens;
+    globalUsage.inputTokens += input;
+    globalUsage.outputTokens += output;
+    globalUsage.totalCost += cost;
+    globalUsage.taskCount += 1;
+    const agentId = 'chat';
+    if (!globalUsage.byModel[model]) {
+        globalUsage.byModel[model] = { tokens: 0, cost: 0, tasks: 0 };
+    }
+    globalUsage.byModel[model].tokens += totalTokens;
+    globalUsage.byModel[model].cost += cost;
+    globalUsage.byModel[model].tasks += 1;
+    if (!globalUsage.byAgent[agentId]) {
+        globalUsage.byAgent[agentId] = { tokens: 0, cost: 0, tasks: 0 };
+    }
+    globalUsage.byAgent[agentId].tokens += totalTokens;
+    globalUsage.byAgent[agentId].cost += cost;
+    globalUsage.byAgent[agentId].tasks += 1;
+    // Persist to database
+    recordCost({
+        model,
+        inputTokens: input,
+        outputTokens: output,
+        totalTokens: totalTokens,
+        cost,
+        source: 'chat',
+        agentId: 'chat',
+    });
+    logger.debug('Chat usage tracked', { model, tokens: totalTokens, cost });
+}
+/**
+ * Get current usage summary
+ */
+export function getUsageSummary() {
+    return { ...globalUsage };
+}
+/**
+ * Reset usage (for testing or billing cycles)
+ */
+export function resetUsage() {
+    globalUsage = {
+        totalTokens: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalCost: 0,
+        taskCount: 0,
+        byModel: {},
+        byAgent: {},
+    };
+}
+//# sourceMappingURL=token-tracker.js.map

package/dist/cron/heartbeat.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Heartbeat Monitor
+ *
+ * Monitors the health of all registered agents and pauses/resumes
+ * task processing based on agent availability.
+ * Configurable via POLL_INTERVAL_HEARTBEAT env var (default: 30s).
+ */
+/**
+ * Start the heartbeat monitor
+ */
+export declare function startHeartbeat(): void;
+/**
+ * Stop the heartbeat monitor
+ */
+export declare function stopHeartbeat(): void;
+/**
+ * Get current health status of all agents
+ */
+export declare function getHealthStatus(): Record<string, {
+    healthy: boolean;
+    failureCount: number;
+}>;
+//# sourceMappingURL=heartbeat.d.ts.map

package/dist/cron/heartbeat.js

@@ -0,0 +1,109 @@
+/**
+ * Heartbeat Monitor
+ *
+ * Monitors the health of all registered agents and pauses/resumes
+ * task processing based on agent availability.
+ * Configurable via POLL_INTERVAL_HEARTBEAT env var (default: 30s).
+ */
+import { getAgentRegistry } from '../adapters/registry.js';
+import { sendSlackNotification } from '../notifications/slack.js';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('Heartbeat');
+// Configurable interval (default: 30 seconds)
+const HEARTBEAT_INTERVAL = parseInt(process.env.POLL_INTERVAL_HEARTBEAT || '30000', 10);
+const UNHEALTHY_THRESHOLD = 3; // Consecutive failures before alerting
+let heartbeatInterval = null;
+const unhealthyCounts = new Map();
+const alertedAgents = new Set();
+/**
+ * Check health of all agents
+ */
+async function checkAgentHealth() {
+    const registry = getAgentRegistry();
+    const adapters = registry.getActiveAdapters();
+    for (const adapter of adapters) {
+        try {
+            const health = await adapter.healthCheck();
+            if (health.healthy) {
+                // Reset unhealthy count
+                const prevCount = unhealthyCounts.get(adapter.type) || 0;
+                unhealthyCounts.set(adapter.type, 0);
+                // If was alerted, send recovery notification
+                if (alertedAgents.has(adapter.type)) {
+                    alertedAgents.delete(adapter.type);
+                    log.info(`${adapter.name} recovered`, { latencyMs: health.latencyMs });
+                    await sendSlackNotification({
+                        type: 'agent_recovered',
+                        title: `✅ Agent Recovered: ${adapter.name}`,
+                        message: `${adapter.name} is healthy again. Latency: ${health.latencyMs}ms`,
+                        agent: adapter.type,
+                    }).catch((e) => log.error('Slack notification failed', e instanceof Error ? e : undefined));
+                }
+                else if (prevCount > 0) {
+                    log.debug(`${adapter.name} healthy again after ${prevCount} failures`);
+                }
+            }
+            else {
+                // Increment unhealthy count
+                const count = (unhealthyCounts.get(adapter.type) || 0) + 1;
+                unhealthyCounts.set(adapter.type, count);
+                log.warn(`${adapter.name} unhealthy`, { count, threshold: UNHEALTHY_THRESHOLD, message: health.message });
+                // Alert after threshold
+                if (count >= UNHEALTHY_THRESHOLD && !alertedAgents.has(adapter.type)) {
+                    alertedAgents.add(adapter.type);
+                    await sendSlackNotification({
+                        type: 'agent_unhealthy',
+                        title: `⚠️ Agent Unhealthy: ${adapter.name}`,
+                        message: `${adapter.name} has been unhealthy for ${count} consecutive checks.\nLast error: ${health.message}`,
+                        agent: adapter.type,
+                        severity: 'warning',
+                    }).catch((e) => log.error('Slack notification failed', e instanceof Error ? e : undefined));
+                }
+            }
+        }
+        catch (error) {
+            const count = (unhealthyCounts.get(adapter.type) || 0) + 1;
+            unhealthyCounts.set(adapter.type, count);
+            log.error(`Error checking ${adapter.name}`, error instanceof Error ? error : undefined);
+        }
+    }
+}
+/**
+ * Start the heartbeat monitor
+ */
+export function startHeartbeat() {
+    if (heartbeatInterval) {
+        return; // Already running
+    }
+    log.info('Starting agent health monitor', { intervalMs: HEARTBEAT_INTERVAL });
+    // Run immediately
+    checkAgentHealth().catch((e) => log.error('Health check failed', e instanceof Error ? e : undefined));
+    // Then run at configured interval
+    heartbeatInterval = setInterval(() => {
+        checkAgentHealth().catch((e) => log.error('Health check failed', e instanceof Error ? e : undefined));
+    }, HEARTBEAT_INTERVAL);
+}
+/**
+ * Stop the heartbeat monitor
+ */
+export function stopHeartbeat() {
+    if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+        log.debug('Stopped');
+    }
+}
+/**
+ * Get current health status of all agents
+ */
+export function getHealthStatus() {
+    const status = {};
+    for (const [agent, count] of unhealthyCounts) {
+        status[agent] = {
+            healthy: count === 0,
+            failureCount: count,
+        };
+    }
+    return status;
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/cron/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cron Jobs Index
+ *
+ * Starts and stops all background cron jobs.
+ *
+ * Configurable intervals via environment variables:
+ * - POLL_INTERVAL_HEARTBEAT: Agent health check (default: 30s)
+ * - POLL_INTERVAL_ISSUES: GitHub issue polling (default: 2m)
+ * - POLL_INTERVAL_STALE: Stale task check (default: 1m)
+ */
+/**
+ * Start all cron jobs
+ */
+export declare function startAllCronJobs(): void;
+/**
+ * Stop all cron jobs
+ */
+export declare function stopAllCronJobs(): void;
+export { startIssuePoller, stopIssuePoller } from './issue-poller.js';
+export { startHeartbeat, stopHeartbeat, getHealthStatus } from './heartbeat.js';
+export { startStaleChecker, stopStaleChecker } from './stale-checker.js';
+//# sourceMappingURL=index.d.ts.map