heyio 3.0.2 → 3.0.4

package/src/index.ts

@@ -1,113 +0,0 @@
-#!/usr/bin/env node
-
-import { mkdirSync } from 'node:fs';
-import { initNotifications } from './api/notifications.js';
-import { createApiServer } from './api/server.js';
-import { loadConfig } from './config.js';
-import { stopClient } from './copilot/client.js';
-import { startHealthMonitor, stopHealthMonitor } from './copilot/health-monitor.js';
-import { destroyOrchestrator, initOrchestrator } from './copilot/orchestrator.js';
-import { getLogger, initLogger } from './logging/logger.js';
-import { seedPricing } from './models/index.js';
-import { startScheduler, stopScheduler } from './scheduler/engine.js';
-import { initSkills } from './skills/index.js';
-import { getEventBus } from './squad/event-bus.js';
-import { initActivityLogger } from './store/activity.js';
-import { closeDatabase, initDatabase } from './store/db.js';
-import { initWiki } from './wiki/index.js';
-
-const config = loadConfig();
-
-// Ensure data directory exists
-mkdirSync(config.dataDir, { recursive: true });
-
-// Initialize logger first — other modules depend on it
-const logger = initLogger(config);
-
-// Initialize wiki directory structure
-initWiki(config.dataDir);
-
-// Initialize skills directory
-initSkills(config.dataDir);
-logger.info({ config: { ...config, dataDir: config.dataDir } }, 'IO daemon starting');
-
-// Create API server
-const apiServer = createApiServer(config);
-
-async function start(): Promise<void> {
-	// Initialize database
-	await initDatabase(config.dataDir);
-
-	// Seed model pricing defaults
-	await seedPricing();
-
-	// Initialize notification system (event bus → WebSocket broadcast)
-	initNotifications();
-
-	// Initialize activity logger (event bus → SQLite)
-	initActivityLogger(getEventBus());
-
-	// Initialize Copilot orchestrator
-	await initOrchestrator(config);
-
-	// Start health monitoring
-	startHealthMonitor();
-
-	// Start schedule engine (evaluates cron schedules every 60s)
-	startScheduler();
-
-	await apiServer.start();
-	logger.info('IO daemon ready');
-}
-
-// Graceful shutdown
-let shuttingDown = false;
-async function shutdown(signal: string): Promise<void> {
-	if (shuttingDown) return;
-	shuttingDown = true;
-
-	const log = getLogger();
-	log.info({ signal }, 'Shutting down...');
-
-	// Stop accepting new requests
-	stopHealthMonitor();
-	stopScheduler();
-
-	// Stop API server (closes WebSocket connections)
-	await apiServer.stop();
-
-	// Destroy orchestrator session (drains queue)
-	await destroyOrchestrator();
-
-	// Stop Copilot SDK client
-	await stopClient();
-
-	// Clear event bus
-	getEventBus().clear();
-
-	// Close database
-	closeDatabase();
-
-	log.info('Shutdown complete');
-	process.exit(0);
-}
-
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-process.on('SIGINT', () => shutdown('SIGINT'));
-
-// Handle uncaught errors gracefully
-process.on('uncaughtException', (err) => {
-	const log = getLogger();
-	log.fatal({ err }, 'Uncaught exception');
-	shutdown('uncaughtException');
-});
-
-process.on('unhandledRejection', (reason) => {
-	const log = getLogger();
-	log.error({ err: reason }, 'Unhandled rejection');
-});
-
-start().catch((err) => {
-	logger.fatal({ err }, 'Failed to start IO daemon');
-	process.exit(1);
-});

package/src/logging/logger.ts

@@ -1,26 +0,0 @@
-import pino from 'pino';
-import type { IOConfig } from '../config.js';
-
-let rootLogger: pino.Logger;
-
-export function initLogger(config: IOConfig): pino.Logger {
-	rootLogger = pino({
-		level: config.logLevel,
-		transport:
-			process.env.NODE_ENV !== 'production'
-				? { target: 'pino-pretty', options: { colorize: true } }
-				: undefined,
-	});
-	return rootLogger;
-}
-
-export function getLogger(): pino.Logger {
-	if (!rootLogger) {
-		throw new Error('Logger not initialized. Call initLogger() first.');
-	}
-	return rootLogger;
-}
-
-export function createChildLogger(name: string, meta?: Record<string, unknown>): pino.Logger {
-	return getLogger().child({ component: name, ...meta });
-}

package/src/models/index.ts

@@ -1,11 +0,0 @@
-export {
-	MODEL_REGISTRY,
-	DEFAULT_MODELS,
-	getModel,
-	getModelsByTier,
-	selectModelForTask,
-} from './registry.js';
-export type { ModelInfo, ModelTier } from './registry.js';
-export { recordTokenUsage, queryUsage } from './token-tracker.js';
-export type { TokenUsageRecord } from './token-tracker.js';
-export { seedPricing, updatePricing, getAllPricing, refreshPricing } from './pricing.js';

package/src/models/pricing.ts

@@ -1,121 +0,0 @@
-import { createChildLogger } from '../logging/logger.js';
-import { getDatabase } from '../store/db.js';
-import { MODEL_REGISTRY, type ModelInfo } from './registry.js';
-
-const logger = () => createChildLogger('pricing');
-
-/**
- * Default pricing estimates (USD per 1M tokens) when GitHub pricing is unavailable.
- * These are rough estimates based on publicly available pricing.
- */
-const DEFAULT_PRICING: Record<string, { input: number; output: number }> = {
-	'claude-haiku-4.5': { input: 0.8, output: 4.0 },
-	'gpt-5-mini': { input: 1.5, output: 6.0 },
-	'gpt-5.4-mini': { input: 1.5, output: 6.0 },
-	'claude-sonnet-4.5': { input: 3.0, output: 15.0 },
-	'claude-sonnet-4.6': { input: 3.0, output: 15.0 },
-	'gpt-5.2': { input: 5.0, output: 15.0 },
-	'gpt-5.4': { input: 5.0, output: 15.0 },
-	'gpt-5.5': { input: 5.0, output: 15.0 },
-	'gpt-4.1': { input: 2.0, output: 8.0 },
-	'claude-opus-4.5': { input: 15.0, output: 75.0 },
-	'claude-opus-4.6': { input: 15.0, output: 75.0 },
-	'claude-opus-4.7': { input: 15.0, output: 75.0 },
-	'claude-opus-4.8': { input: 15.0, output: 75.0 },
-	'gpt-5.2-codex': { input: 10.0, output: 30.0 },
-	'gpt-5.3-codex': { input: 10.0, output: 30.0 },
-};
-
-/**
- * Seed the model_pricing table with default values.
- * Only inserts if the table is empty.
- */
-export async function seedPricing(): Promise<void> {
-	const log = logger();
-	const db = getDatabase();
-
-	const existing = await db.execute('SELECT COUNT(*) as cnt FROM model_pricing');
-	if ((existing.rows[0]?.cnt as number) > 0) {
-		return; // Already seeded
-	}
-
-	for (const [model, prices] of Object.entries(DEFAULT_PRICING)) {
-		const info = MODEL_REGISTRY.find((m) => m.id === model);
-		await db.execute({
-			sql: `INSERT OR REPLACE INTO model_pricing (model, input_cost_per_1m, output_cost_per_1m, tier, last_updated)
-			      VALUES (?, ?, ?, ?, datetime('now'))`,
-			args: [model, prices.input, prices.output, info?.tier ?? 'standard'],
-		});
-	}
-
-	log.info('Model pricing seeded with defaults');
-}
-
-/**
- * Update pricing for a specific model.
- */
-export async function updatePricing(
-	model: string,
-	inputCostPer1M: number,
-	outputCostPer1M: number,
-): Promise<void> {
-	const db = getDatabase();
-	const info = MODEL_REGISTRY.find((m) => m.id === model);
-
-	await db.execute({
-		sql: `INSERT OR REPLACE INTO model_pricing (model, input_cost_per_1m, output_cost_per_1m, tier, last_updated)
-		      VALUES (?, ?, ?, ?, datetime('now'))`,
-		args: [model, inputCostPer1M, outputCostPer1M, info?.tier ?? 'standard'],
-	});
-}
-
-/**
- * Get all current pricing.
- */
-export async function getAllPricing(): Promise<
-	Array<{
-		model: string;
-		inputCostPer1M: number;
-		outputCostPer1M: number;
-		tier: string;
-		lastUpdated: string;
-	}>
-> {
-	const db = getDatabase();
-	const result = await db.execute('SELECT * FROM model_pricing ORDER BY model');
-
-	return result.rows.map((row) => ({
-		model: row.model as string,
-		inputCostPer1M: row.input_cost_per_1m as number,
-		outputCostPer1M: row.output_cost_per_1m as number,
-		tier: (row.tier as string) ?? 'standard',
-		lastUpdated: row.last_updated as string,
-	}));
-}
-
-/**
- * Refresh pricing — in future this could fetch from GitHub docs.
- * For now, re-seeds defaults for any missing models.
- */
-export async function refreshPricing(): Promise<void> {
-	const log = logger();
-	const db = getDatabase();
-
-	for (const [model, prices] of Object.entries(DEFAULT_PRICING)) {
-		const existing = await db.execute({
-			sql: 'SELECT model FROM model_pricing WHERE model = ?',
-			args: [model],
-		});
-
-		if (existing.rows.length === 0) {
-			const info = MODEL_REGISTRY.find((m) => m.id === model);
-			await db.execute({
-				sql: `INSERT INTO model_pricing (model, input_cost_per_1m, output_cost_per_1m, tier, last_updated)
-				      VALUES (?, ?, ?, ?, datetime('now'))`,
-				args: [model, prices.input, prices.output, info?.tier ?? 'standard'],
-			});
-		}
-	}
-
-	log.info('Pricing refreshed');
-}

package/src/models/registry.ts

@@ -1,131 +0,0 @@
-/**
- * Model registry — defines available models, tiers, and selection logic.
- * Models are sourced from the GitHub Copilot SDK's available model list.
- */
-
-export type ModelTier = 'fast' | 'standard' | 'reasoning';
-
-export interface ModelInfo {
-	id: string;
-	tier: ModelTier;
-	description: string;
-	maxContext: number; // approximate token window
-	inputCostPer1M?: number; // USD per 1M input tokens
-	outputCostPer1M?: number; // USD per 1M output tokens
-}
-
-/**
- * Known models available via GitHub Copilot SDK (as of 2026-05).
- */
-export const MODEL_REGISTRY: ModelInfo[] = [
-	// Fast tier — low-latency, cost-effective
-	{
-		id: 'claude-haiku-4.5',
-		tier: 'fast',
-		description: 'Claude Haiku 4.5 — fast, cheap',
-		maxContext: 200_000,
-	},
-	{
-		id: 'gpt-5-mini',
-		tier: 'fast',
-		description: 'GPT-5 Mini — fast responses',
-		maxContext: 128_000,
-	},
-	{
-		id: 'gpt-5.4-mini',
-		tier: 'fast',
-		description: 'GPT-5.4 Mini — fast, latest',
-		maxContext: 128_000,
-	},
-
-	// Standard tier — balanced capability/cost
-	{
-		id: 'claude-sonnet-4.5',
-		tier: 'standard',
-		description: 'Claude Sonnet 4.5',
-		maxContext: 200_000,
-	},
-	{
-		id: 'claude-sonnet-4.6',
-		tier: 'standard',
-		description: 'Claude Sonnet 4.6',
-		maxContext: 200_000,
-	},
-	{ id: 'gpt-5.2', tier: 'standard', description: 'GPT-5.2', maxContext: 128_000 },
-	{ id: 'gpt-5.4', tier: 'standard', description: 'GPT-5.4', maxContext: 128_000 },
-	{
-		id: 'gpt-5.5',
-		tier: 'standard',
-		description: 'GPT-5.5 — latest standard',
-		maxContext: 128_000,
-	},
-	{
-		id: 'gpt-4.1',
-		tier: 'standard',
-		description: 'GPT-4.1 — legacy standard',
-		maxContext: 128_000,
-	},
-
-	// Reasoning tier — highest capability, most expensive
-	{ id: 'claude-opus-4.5', tier: 'reasoning', description: 'Claude Opus 4.5', maxContext: 200_000 },
-	{ id: 'claude-opus-4.6', tier: 'reasoning', description: 'Claude Opus 4.6', maxContext: 200_000 },
-	{ id: 'claude-opus-4.7', tier: 'reasoning', description: 'Claude Opus 4.7', maxContext: 200_000 },
-	{
-		id: 'claude-opus-4.8',
-		tier: 'reasoning',
-		description: 'Claude Opus 4.8 — latest',
-		maxContext: 200_000,
-	},
-	{
-		id: 'gpt-5.2-codex',
-		tier: 'reasoning',
-		description: 'GPT-5.2 Codex — code-focused reasoning',
-		maxContext: 128_000,
-	},
-	{
-		id: 'gpt-5.3-codex',
-		tier: 'reasoning',
-		description: 'GPT-5.3 Codex — code reasoning',
-		maxContext: 128_000,
-	},
-];
-
-/** Get all models in a tier */
-export function getModelsByTier(tier: ModelTier): ModelInfo[] {
-	return MODEL_REGISTRY.filter((m) => m.tier === tier);
-}
-
-/** Get a specific model by ID */
-export function getModel(modelId: string): ModelInfo | undefined {
-	return MODEL_REGISTRY.find((m) => m.id === modelId);
-}
-
-/** Default model per tier */
-export const DEFAULT_MODELS: Record<ModelTier, string> = {
-	fast: 'gpt-5.4-mini',
-	standard: 'claude-sonnet-4.6',
-	reasoning: 'claude-opus-4.6',
-};
-
-/**
- * Select the appropriate model tier for a task based on complexity.
- * Used by team leads to choose models for agent task execution.
- */
-export function selectModelForTask(params: {
-	taskDescription: string;
-	isCodeGeneration?: boolean;
-	requiresReasoning?: boolean;
-	preferFast?: boolean;
-}): string {
-	if (params.preferFast) {
-		return DEFAULT_MODELS.fast;
-	}
-	if (params.requiresReasoning) {
-		return params.isCodeGeneration ? 'gpt-5.3-codex' : DEFAULT_MODELS.reasoning;
-	}
-	if (params.isCodeGeneration) {
-		return DEFAULT_MODELS.standard;
-	}
-	// Default: standard tier
-	return DEFAULT_MODELS.standard;
-}

package/src/models/token-tracker.ts

@@ -1,151 +0,0 @@
-import { createChildLogger } from '../logging/logger.js';
-import { getDatabase } from '../store/db.js';
-
-const logger = () => createChildLogger('token-tracker');
-
-export interface TokenUsageRecord {
-	squadId?: string;
-	instanceId?: string;
-	agentRole?: string;
-	model: string;
-	inputTokens: number;
-	outputTokens: number;
-	estimatedCostUsd?: number;
-}
-
-/**
- * Record token usage from an LLM call.
- */
-export async function recordTokenUsage(record: TokenUsageRecord): Promise<void> {
-	const db = getDatabase();
-
-	// Estimate cost if pricing is available
-	let cost = record.estimatedCostUsd;
-	if (cost === undefined) {
-		cost = await estimateCost(record.model, record.inputTokens, record.outputTokens);
-	}
-
-	await db.execute({
-		sql: `INSERT INTO token_usage (squad_id, instance_id, agent_role, model, input_tokens, output_tokens, estimated_cost_usd)
-		      VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		args: [
-			record.squadId ?? null,
-			record.instanceId ?? null,
-			record.agentRole ?? null,
-			record.model,
-			record.inputTokens,
-			record.outputTokens,
-			cost ?? null,
-		],
-	});
-}
-
-/**
- * Estimate cost for a call based on stored pricing.
- */
-async function estimateCost(
-	model: string,
-	inputTokens: number,
-	outputTokens: number,
-): Promise<number | undefined> {
-	const db = getDatabase();
-	const result = await db.execute({
-		sql: 'SELECT input_cost_per_1m, output_cost_per_1m FROM model_pricing WHERE model = ?',
-		args: [model],
-	});
-
-	if (result.rows.length === 0) return undefined;
-
-	const row = result.rows[0];
-	const inputCost = ((row.input_cost_per_1m as number) / 1_000_000) * inputTokens;
-	const outputCost = ((row.output_cost_per_1m as number) / 1_000_000) * outputTokens;
-	return inputCost + outputCost;
-}
-
-/**
- * Query token usage with filters.
- */
-export async function queryUsage(filters?: {
-	squadId?: string;
-	agentRole?: string;
-	model?: string;
-	since?: string; // ISO date
-	until?: string; // ISO date
-}): Promise<{
-	records: Array<{
-		model: string;
-		inputTokens: number;
-		outputTokens: number;
-		estimatedCostUsd: number | null;
-		timestamp: string;
-		squadId: string | null;
-		agentRole: string | null;
-	}>;
-	totals: {
-		totalInputTokens: number;
-		totalOutputTokens: number;
-		totalCostUsd: number;
-		callCount: number;
-	};
-}> {
-	const db = getDatabase();
-	const conditions: string[] = [];
-	const args: (string | null)[] = [];
-
-	if (filters?.squadId) {
-		conditions.push('squad_id = ?');
-		args.push(filters.squadId);
-	}
-	if (filters?.agentRole) {
-		conditions.push('agent_role = ?');
-		args.push(filters.agentRole);
-	}
-	if (filters?.model) {
-		conditions.push('model = ?');
-		args.push(filters.model);
-	}
-	if (filters?.since) {
-		conditions.push('timestamp >= ?');
-		args.push(filters.since);
-	}
-	if (filters?.until) {
-		conditions.push('timestamp <= ?');
-		args.push(filters.until);
-	}
-
-	const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-	const result = await db.execute({
-		sql: `SELECT model, input_tokens, output_tokens, estimated_cost_usd, timestamp, squad_id, agent_role
-		      FROM token_usage ${where} ORDER BY timestamp DESC LIMIT 500`,
-		args,
-	});
-
-	const records = result.rows.map((row) => ({
-		model: row.model as string,
-		inputTokens: row.input_tokens as number,
-		outputTokens: row.output_tokens as number,
-		estimatedCostUsd: row.estimated_cost_usd as number | null,
-		timestamp: row.timestamp as string,
-		squadId: row.squad_id as string | null,
-		agentRole: row.agent_role as string | null,
-	}));
-
-	// Totals
-	const totalsResult = await db.execute({
-		sql: `SELECT COUNT(*) as cnt, COALESCE(SUM(input_tokens), 0) as total_in,
-		      COALESCE(SUM(output_tokens), 0) as total_out, COALESCE(SUM(estimated_cost_usd), 0) as total_cost
-		      FROM token_usage ${where}`,
-		args,
-	});
-
-	const totalsRow = totalsResult.rows[0];
-	const totals = {
-		callCount: (totalsRow?.cnt as number) ?? 0,
-		totalInputTokens: (totalsRow?.total_in as number) ?? 0,
-		totalOutputTokens: (totalsRow?.total_out as number) ?? 0,
-		totalCostUsd: (totalsRow?.total_cost as number) ?? 0,
-	};
-
-	return { records, totals };
-}

package/src/scheduler/engine.ts

@@ -1,146 +0,0 @@
-import { sendMessage } from '../copilot/orchestrator.js';
-import { createChildLogger } from '../logging/logger.js';
-import { getEventBus } from '../squad/event-bus.js';
-import { runInstance } from '../squad/execution/runner.js';
-import { getSquadByName, listSquads } from '../squad/manager.js';
-import { addInboxEntry } from '../store/inbox.js';
-import { type Schedule, getDueSchedules, markScheduleFired } from '../store/schedules.js';
-
-const logger = () => createChildLogger('scheduler');
-
-let intervalHandle: ReturnType<typeof setInterval> | null = null;
-let running = false;
-
-const TICK_INTERVAL_MS = 60_000; // Check every minute
-
-/**
- * Start the schedule engine. Evaluates due schedules every 60 seconds.
- */
-export function startScheduler(): void {
-	const log = logger();
-	log.info('Scheduler started');
-
-	// Initial tick
-	tick();
-
-	intervalHandle = setInterval(() => {
-		tick();
-	}, TICK_INTERVAL_MS);
-}
-
-/**
- * Stop the schedule engine.
- */
-export function stopScheduler(): void {
-	if (intervalHandle) {
-		clearInterval(intervalHandle);
-		intervalHandle = null;
-	}
-}
-
-async function tick(): Promise<void> {
-	if (running) return; // Prevent overlapping ticks
-	running = true;
-
-	try {
-		const due = await getDueSchedules();
-		if (due.length === 0) {
-			running = false;
-			return;
-		}
-
-		const log = logger();
-		log.info({ count: due.length }, 'Firing due schedules');
-
-		for (const schedule of due) {
-			await fireSchedule(schedule);
-		}
-	} catch (err) {
-		logger().error({ err }, 'Scheduler tick error');
-	} finally {
-		running = false;
-	}
-}
-
-async function fireSchedule(schedule: Schedule): Promise<void> {
-	const log = logger();
-	const bus = getEventBus();
-
-	// Emit fired event
-	bus.emit({
-		type: 'schedule:fired',
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		data: { scheduleId: schedule.id, name: schedule.name },
-	});
-
-	log.info({ scheduleId: schedule.id, name: schedule.name }, 'Firing schedule');
-
-	// Mark as fired immediately (update next_run)
-	await markScheduleFired(schedule.id, schedule.cron);
-
-	try {
-		let result: string;
-
-		if (schedule.targetType === 'orchestrator') {
-			// Send as if user typed it
-			result = await sendMessage(schedule.prompt, 'web', () => {});
-		} else {
-			// Squad target — run instance
-			const squads = await listSquads();
-			const squad = squads.find((s) => s.id === schedule.targetId || s.name === schedule.targetId);
-
-			if (!squad) {
-				throw new Error(`Target squad not found: ${schedule.targetId}`);
-			}
-
-			const runResult = await runInstance({
-				squad,
-				objective: schedule.prompt,
-			});
-
-			if (runResult.success) {
-				result = runResult.pr
-					? `Completed successfully. PR: ${runResult.pr.url}`
-					: 'Completed successfully (no PR created).';
-			} else {
-				result = `Failed: ${runResult.error ?? 'unknown error'}`;
-			}
-		}
-
-		// Post result to inbox as deliverable
-		const squadId =
-			schedule.targetType === 'squad' && schedule.targetId ? schedule.targetId : 'orchestrator';
-
-		// Only post to inbox if we have a real squad target
-		if (schedule.targetType === 'squad' && schedule.targetId) {
-			await addInboxEntry({
-				squadId: schedule.targetId,
-				kind: 'deliverable',
-				title: `Schedule: ${schedule.name}`,
-				content: result,
-			});
-		}
-
-		// Emit completed event
-		bus.emit({
-			type: 'schedule:completed',
-			id: crypto.randomUUID(),
-			timestamp: new Date(),
-			data: { scheduleId: schedule.id, name: schedule.name, result: result.slice(0, 200) },
-		});
-
-		log.info({ scheduleId: schedule.id }, 'Schedule completed');
-	} catch (err) {
-		const errorMsg = err instanceof Error ? err.message : String(err);
-		log.error({ err, scheduleId: schedule.id }, 'Schedule execution failed');
-
-		// Emit failed event
-		bus.emit({
-			type: 'schedule:failed',
-			id: crypto.randomUUID(),
-			timestamp: new Date(),
-			data: { scheduleId: schedule.id, name: schedule.name, error: errorMsg },
-		});
-	}
-}