heyio 3.0.2 → 3.0.3

package/src/squad/source-resolver.ts

@@ -1,57 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { loadConfig } from '@io/shared';
-import { createChildLogger } from '../logging/logger.js';
-
-const logger = () => createChildLogger('source-resolver');
-
-/**
- * Parse a GitHub URL into owner/repo parts.
- * Supports https://github.com/owner/repo and https://github.com/owner/repo.git
- */
-export function parseGitHubUrl(url: string): { owner: string; repo: string } | null {
-	const match = url.match(/github\.com\/([^/]+)\/([^/.]+)/);
-	if (!match) return null;
-	return { owner: match[1], repo: match[2] };
-}
-
-/**
- * Get the local source directory for a given GitHub repo URL.
- * Convention: ~/.io/source/{owner}/{repo}
- */
-export function getSourcePath(repoUrl: string): string | null {
-	const parsed = parseGitHubUrl(repoUrl);
-	if (!parsed) return null;
-	const config = loadConfig();
-	return join(config.dataDir, 'source', parsed.owner, parsed.repo);
-}
-
-/**
- * Ensure a repo is cloned locally. If the directory already exists and contains
- * a .git folder, it is assumed valid and left alone. Otherwise, it clones the repo.
- * Returns the absolute path to the local clone.
- */
-export function ensureCloned(repoUrl: string): string {
-	const log = logger();
-	const sourcePath = getSourcePath(repoUrl);
-	if (!sourcePath) {
-		throw new Error(`Cannot parse GitHub URL: ${repoUrl}`);
-	}
-
-	if (existsSync(join(sourcePath, '.git'))) {
-		log.debug({ sourcePath }, 'Repo already cloned');
-		return sourcePath;
-	}
-
-	log.info({ repoUrl, sourcePath }, 'Cloning repository');
-	mkdirSync(sourcePath, { recursive: true });
-
-	execSync(`git clone "${repoUrl}" "${sourcePath}"`, {
-		stdio: 'pipe',
-		timeout: 120_000,
-	});
-
-	log.info({ sourcePath }, 'Clone complete');
-	return sourcePath;
-}

package/src/store/activity.ts

@@ -1,176 +0,0 @@
-import type { IOEvent } from '@io/shared';
-import { createChildLogger } from '../logging/logger.js';
-import { getDatabase } from './db.js';
-
-const logger = () => createChildLogger('activity-log');
-
-export type ActivityType =
-	| 'tool_call'
-	| 'message'
-	| 'meeting_contribution'
-	| 'task_start'
-	| 'task_complete'
-	| 'error';
-
-export interface ActivityEntry {
-	id: number;
-	squadId: string | null;
-	instanceId: string | null;
-	agentRole: string;
-	activityType: ActivityType;
-	modelUsed: string | null;
-	content: string | null;
-	tokensUsed: number | null;
-	timestamp: string;
-}
-
-/**
- * Log an activity to the agent_activity table.
- */
-export async function logActivity(entry: {
-	squadId?: string;
-	instanceId?: string;
-	agentRole: string;
-	activityType: ActivityType;
-	modelUsed?: string;
-	content?: unknown;
-	tokensUsed?: number;
-}): Promise<void> {
-	const db = getDatabase();
-	try {
-		await db.execute({
-			sql: `INSERT INTO agent_activity (squad_id, instance_id, agent_role, activity_type, model_used, content, tokens_used)
-			      VALUES (?, ?, ?, ?, ?, ?, ?)`,
-			args: [
-				entry.squadId ?? null,
-				entry.instanceId ?? null,
-				entry.agentRole,
-				entry.activityType,
-				entry.modelUsed ?? null,
-				entry.content ? JSON.stringify(entry.content) : null,
-				entry.tokensUsed ?? null,
-			],
-		});
-	} catch (err) {
-		logger().error({ err }, 'Failed to log activity');
-	}
-}
-
-/**
- * Query activity entries with optional filters.
- */
-export async function queryActivity(filters: {
-	squadId?: string;
-	instanceId?: string;
-	agentRole?: string;
-	activityType?: ActivityType;
-	limit?: number;
-	offset?: number;
-}): Promise<ActivityEntry[]> {
-	const db = getDatabase();
-	const conditions: string[] = [];
-	const args: (string | number)[] = [];
-
-	if (filters.squadId) {
-		conditions.push('squad_id = ?');
-		args.push(filters.squadId);
-	}
-	if (filters.instanceId) {
-		conditions.push('instance_id = ?');
-		args.push(filters.instanceId);
-	}
-	if (filters.agentRole) {
-		conditions.push('agent_role = ?');
-		args.push(filters.agentRole);
-	}
-	if (filters.activityType) {
-		conditions.push('activity_type = ?');
-		args.push(filters.activityType);
-	}
-
-	const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-	const limit = filters.limit ?? 50;
-	const offset = filters.offset ?? 0;
-
-	const result = await db.execute({
-		sql: `SELECT id, squad_id, instance_id, agent_role, activity_type, model_used, content, tokens_used, timestamp
-		      FROM agent_activity ${where}
-		      ORDER BY timestamp DESC
-		      LIMIT ? OFFSET ?`,
-		args: [...args, limit, offset],
-	});
-
-	return result.rows.map((row) => ({
-		id: row.id as number,
-		squadId: row.squad_id as string | null,
-		instanceId: row.instance_id as string | null,
-		agentRole: row.agent_role as string,
-		activityType: row.activity_type as ActivityType,
-		modelUsed: row.model_used as string | null,
-		content: row.content as string | null,
-		tokensUsed: row.tokens_used as number | null,
-		timestamp: row.timestamp as string,
-	}));
-}
-
-/**
- * Subscribe to the event bus and auto-log relevant events.
- */
-export function initActivityLogger(eventBus: {
-	onAny: (handler: (event: IOEvent) => void) => () => void;
-}): () => void {
-	return eventBus.onAny((event: IOEvent) => {
-		const entry = mapEventToActivity(event);
-		if (entry) {
-			logActivity(entry);
-		}
-	});
-}
-
-function mapEventToActivity(event: IOEvent): Parameters<typeof logActivity>[0] | null {
-	switch (event.type) {
-		case 'agent:task_started':
-			return {
-				squadId: event.squadId,
-				instanceId: event.instanceId,
-				agentRole: event.agentRole,
-				activityType: 'task_start',
-				content: event.data,
-			};
-		case 'agent:task_completed':
-			return {
-				squadId: event.squadId,
-				instanceId: event.instanceId,
-				agentRole: event.agentRole,
-				activityType: 'task_complete',
-				content: event.data,
-			};
-		case 'agent:tool_call':
-			return {
-				squadId: event.squadId,
-				instanceId: event.instanceId,
-				agentRole: event.agentRole,
-				activityType: 'tool_call',
-				modelUsed: event.model,
-				content: event.data,
-			};
-		case 'agent:error':
-			return {
-				squadId: event.squadId,
-				instanceId: event.instanceId,
-				agentRole: event.agentRole,
-				activityType: 'error',
-				content: event.data,
-			};
-		case 'meeting:contribution':
-			return {
-				squadId: event.squadId,
-				instanceId: event.instanceId,
-				agentRole: event.agentRole,
-				activityType: 'meeting_contribution',
-				content: { message: event.content },
-			};
-		default:
-			return null;
-	}
-}

package/src/store/db.ts

@@ -1,237 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { type Client, createClient } from '@libsql/client';
-import type { Logger } from 'pino';
-import { createChildLogger } from '../logging/logger.js';
-
-let db: Client;
-let logger: Logger;
-
-const MIGRATIONS: { version: number; statements: string[] }[] = [
-	{
-		version: 1,
-		statements: [
-			`CREATE TABLE IF NOT EXISTS conversations (
-				id TEXT PRIMARY KEY,
-				role TEXT NOT NULL,
-				content TEXT NOT NULL,
-				source TEXT,
-				attachments TEXT,
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS squads (
-				id TEXT PRIMARY KEY,
-				name TEXT NOT NULL UNIQUE,
-				project_path TEXT NOT NULL,
-				repo_url TEXT,
-				autonomy_tier TEXT NOT NULL DEFAULT 'medium',
-				autonomy_config TEXT,
-				status TEXT DEFAULT 'active',
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS squad_members (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id),
-				role_name TEXT NOT NULL,
-				skill_file_path TEXT,
-				tools_allowed TEXT,
-				is_veto_member INTEGER DEFAULT 0,
-				status TEXT DEFAULT 'active',
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS squad_instances (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id),
-				issue_ref TEXT,
-				worktree_path TEXT,
-				branch_name TEXT,
-				status TEXT DEFAULT 'planning',
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-				completed_at DATETIME
-			)`,
-			`CREATE TABLE IF NOT EXISTS decisions (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id),
-				instance_id TEXT REFERENCES squad_instances(id),
-				agent_role TEXT NOT NULL,
-				decision_type TEXT,
-				content TEXT NOT NULL,
-				rationale TEXT,
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS token_usage (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				squad_id TEXT REFERENCES squads(id),
-				instance_id TEXT REFERENCES squad_instances(id),
-				agent_role TEXT,
-				model TEXT NOT NULL,
-				input_tokens INTEGER NOT NULL,
-				output_tokens INTEGER NOT NULL,
-				estimated_cost_usd REAL,
-				timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS model_pricing (
-				model TEXT PRIMARY KEY,
-				input_cost_per_1m REAL NOT NULL,
-				output_cost_per_1m REAL NOT NULL,
-				tier TEXT,
-				last_updated DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS attachments (
-				id TEXT PRIMARY KEY,
-				message_id TEXT,
-				filename TEXT NOT NULL,
-				mime_type TEXT,
-				size_bytes INTEGER,
-				disk_path TEXT NOT NULL,
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS agent_activity (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				squad_id TEXT REFERENCES squads(id),
-				instance_id TEXT REFERENCES squad_instances(id),
-				agent_role TEXT NOT NULL,
-				activity_type TEXT NOT NULL,
-				model_used TEXT,
-				content TEXT,
-				tokens_used INTEGER,
-				timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			`CREATE TABLE IF NOT EXISTS schema_version (
-				version INTEGER PRIMARY KEY
-			)`,
-			`CREATE TABLE IF NOT EXISTS io_state (
-				key TEXT PRIMARY KEY,
-				value TEXT NOT NULL
-			)`,
-			'INSERT INTO schema_version (version) VALUES (1)',
-		],
-	},
-	{
-		version: 2,
-		statements: [
-			`CREATE TABLE IF NOT EXISTS inbox_entries (
-				id TEXT PRIMARY KEY,
-				squad_id TEXT NOT NULL REFERENCES squads(id),
-				instance_id TEXT REFERENCES squad_instances(id),
-				kind TEXT NOT NULL,
-				title TEXT NOT NULL,
-				content TEXT NOT NULL,
-				status TEXT DEFAULT 'unread',
-				response TEXT,
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-				resolved_at DATETIME
-			)`,
-			'CREATE INDEX IF NOT EXISTS idx_inbox_status ON inbox_entries(status)',
-			'CREATE INDEX IF NOT EXISTS idx_inbox_squad ON inbox_entries(squad_id)',
-			'INSERT OR REPLACE INTO schema_version (version) VALUES (2)',
-		],
-	},
-	{
-		version: 3,
-		statements: [
-			`CREATE TABLE IF NOT EXISTS schedules (
-				id TEXT PRIMARY KEY,
-				name TEXT NOT NULL,
-				target_type TEXT NOT NULL,
-				target_id TEXT,
-				cron TEXT NOT NULL,
-				prompt TEXT NOT NULL,
-				enabled INTEGER DEFAULT 1,
-				last_run DATETIME,
-				next_run DATETIME,
-				created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-			)`,
-			'CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled)',
-			'CREATE INDEX IF NOT EXISTS idx_schedules_next_run ON schedules(next_run)',
-			'INSERT OR REPLACE INTO schema_version (version) VALUES (3)',
-		],
-	},
-	{
-		version: 4,
-		statements: [
-			`CREATE TABLE IF NOT EXISTS skill_activations (
-				skill_name TEXT NOT NULL,
-				target_type TEXT NOT NULL,
-				target_id TEXT,
-				activated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-				PRIMARY KEY (skill_name, target_type, target_id)
-			)`,
-			'CREATE INDEX IF NOT EXISTS idx_skill_activations_target ON skill_activations(target_type, target_id)',
-			'INSERT OR REPLACE INTO schema_version (version) VALUES (4)',
-		],
-	},
-	{
-		version: 5,
-		statements: [
-			'ALTER TABLE squads ADD COLUMN universe TEXT',
-			'ALTER TABLE squad_members ADD COLUMN display_name TEXT',
-			'INSERT OR REPLACE INTO schema_version (version) VALUES (5)',
-		],
-	},
-	{
-		version: 6,
-		statements: [
-			'ALTER TABLE squad_members ADD COLUMN persona TEXT',
-			'INSERT OR REPLACE INTO schema_version (version) VALUES (6)',
-		],
-	},
-];
-
-export async function initDatabase(dataDir: string): Promise<Client> {
-	logger = createChildLogger('store');
-	mkdirSync(dataDir, { recursive: true });
-	const dbPath = join(dataDir, 'io.db');
-
-	db = createClient({
-		url: `file:${dbPath}`,
-	});
-
-	await db.execute('PRAGMA journal_mode = WAL');
-	await db.execute('PRAGMA foreign_keys = ON');
-
-	await runMigrations();
-
-	logger.info({ path: dbPath }, 'Database initialized');
-	return db;
-}
-
-async function runMigrations(): Promise<void> {
-	const currentVersion = await getCurrentVersion();
-
-	for (const migration of MIGRATIONS) {
-		if (migration.version > currentVersion) {
-			logger.info({ version: migration.version }, 'Running migration');
-			for (const statement of migration.statements) {
-				await db.execute(statement);
-			}
-		}
-	}
-}
-
-async function getCurrentVersion(): Promise<number> {
-	try {
-		const result = await db.execute(
-			'SELECT version FROM schema_version ORDER BY version DESC LIMIT 1',
-		);
-		if (result.rows.length > 0) {
-			return result.rows[0].version as number;
-		}
-		return 0;
-	} catch {
-		return 0;
-	}
-}
-
-export function getDatabase(): Client {
-	if (!db) {
-		throw new Error('Database not initialized. Call initDatabase() first.');
-	}
-	return db;
-}
-
-export function closeDatabase(): void {
-	if (db) {
-		db.close();
-	}
-}

package/src/store/inbox.ts

@@ -1,199 +0,0 @@
-import { createChildLogger } from '../logging/logger.js';
-import { getEventBus } from '../squad/event-bus.js';
-import { getDatabase } from './db.js';
-
-const logger = () => createChildLogger('inbox');
-
-export type InboxKind = 'deliverable' | 'question';
-export type InboxStatus = 'unread' | 'read' | 'resolved';
-
-export interface InboxEntry {
-	id: string;
-	squadId: string;
-	instanceId: string | null;
-	kind: InboxKind;
-	title: string;
-	content: string;
-	status: InboxStatus;
-	response: string | null;
-	createdAt: string;
-	resolvedAt: string | null;
-}
-
-// Pending question resolvers — keyed by entry ID
-const pendingQuestions = new Map<string, (response: string) => void>();
-
-/**
- * Add a new inbox entry. For questions, returns a promise that resolves when the user responds.
- */
-export async function addInboxEntry(params: {
-	squadId: string;
-	instanceId?: string;
-	kind: InboxKind;
-	title: string;
-	content: string;
-}): Promise<{ entry: InboxEntry; waitForResponse?: Promise<string> }> {
-	const db = getDatabase();
-	const id = crypto.randomUUID();
-
-	await db.execute({
-		sql: `INSERT INTO inbox_entries (id, squad_id, instance_id, kind, title, content)
-		      VALUES (?, ?, ?, ?, ?, ?)`,
-		args: [
-			id,
-			params.squadId,
-			params.instanceId ?? null,
-			params.kind,
-			params.title,
-			params.content,
-		],
-	});
-
-	const entry: InboxEntry = {
-		id,
-		squadId: params.squadId,
-		instanceId: params.instanceId ?? null,
-		kind: params.kind,
-		title: params.title,
-		content: params.content,
-		status: 'unread',
-		response: null,
-		createdAt: new Date().toISOString(),
-		resolvedAt: null,
-	};
-
-	let waitForResponse: Promise<string> | undefined;
-
-	if (params.kind === 'question') {
-		waitForResponse = new Promise<string>((resolve) => {
-			pendingQuestions.set(id, resolve);
-		});
-	}
-
-	// Emit event for WebSocket broadcast
-	getEventBus().emit({
-		type: 'inbox:new',
-		id: crypto.randomUUID(),
-		timestamp: new Date(),
-		squadId: params.squadId,
-		instanceId: params.instanceId,
-		kind: params.kind,
-		title: params.title,
-		entryId: id,
-	});
-
-	logger().info({ id, kind: params.kind, title: params.title }, 'Inbox entry created');
-	return { entry, waitForResponse };
-}
-
-/**
- * List inbox entries with optional filters.
- */
-export async function listInboxEntries(filters?: {
-	status?: InboxStatus;
-	squadId?: string;
-	kind?: InboxKind;
-	limit?: number;
-}): Promise<InboxEntry[]> {
-	const db = getDatabase();
-	const conditions: string[] = [];
-	const args: (string | number)[] = [];
-
-	if (filters?.status) {
-		conditions.push('status = ?');
-		args.push(filters.status);
-	}
-	if (filters?.squadId) {
-		conditions.push('squad_id = ?');
-		args.push(filters.squadId);
-	}
-	if (filters?.kind) {
-		conditions.push('kind = ?');
-		args.push(filters.kind);
-	}
-
-	const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-	const limit = filters?.limit ?? 50;
-
-	const result = await db.execute({
-		sql: `SELECT id, squad_id, instance_id, kind, title, content, status, response, created_at, resolved_at
-		      FROM inbox_entries ${where}
-		      ORDER BY created_at DESC
-		      LIMIT ?`,
-		args: [...args, limit],
-	});
-
-	return result.rows.map(rowToEntry);
-}
-
-/**
- * Get a single inbox entry by ID.
- */
-export async function getInboxEntry(id: string): Promise<InboxEntry | null> {
-	const db = getDatabase();
-	const result = await db.execute({
-		sql: 'SELECT id, squad_id, instance_id, kind, title, content, status, response, created_at, resolved_at FROM inbox_entries WHERE id = ?',
-		args: [id],
-	});
-	if (result.rows.length === 0) return null;
-	return rowToEntry(result.rows[0]);
-}
-
-/**
- * Mark an entry as read.
- */
-export async function markInboxRead(id: string): Promise<void> {
-	const db = getDatabase();
-	await db.execute({
-		sql: "UPDATE inbox_entries SET status = 'read' WHERE id = ? AND status = 'unread'",
-		args: [id],
-	});
-}
-
-/**
- * Respond to an inbox question. Resolves the blocking promise if the squad is waiting.
- */
-export async function resolveInboxEntry(id: string, response: string): Promise<boolean> {
-	const db = getDatabase();
-	await db.execute({
-		sql: "UPDATE inbox_entries SET status = 'resolved', response = ?, resolved_at = CURRENT_TIMESTAMP WHERE id = ?",
-		args: [response, id],
-	});
-
-	// Resolve the pending promise if squad is waiting
-	const resolver = pendingQuestions.get(id);
-	if (resolver) {
-		resolver(response);
-		pendingQuestions.delete(id);
-		logger().info({ id }, 'Inbox question resolved — squad unblocked');
-		return true;
-	}
-
-	return false;
-}
-
-/**
- * Get count of unread entries.
- */
-export async function getUnreadCount(): Promise<number> {
-	const db = getDatabase();
-	const result = await db.execute(
-		"SELECT COUNT(*) as count FROM inbox_entries WHERE status = 'unread'",
-	);
-	return (result.rows[0]?.count as number) ?? 0;
-}
-
-function rowToEntry(row: Record<string, unknown>): InboxEntry {
-	return {
-		id: row.id as string,
-		squadId: row.squad_id as string,
-		instanceId: row.instance_id as string | null,
-		kind: row.kind as InboxKind,
-		title: row.title as string,
-		content: row.content as string,
-		status: row.status as InboxStatus,
-		response: row.response as string | null,
-		createdAt: row.created_at as string,
-		resolvedAt: row.resolved_at as string | null,
-	};
-}