heyio 3.0.2 → 3.0.4

package/src/skills/index.ts

@@ -1,13 +0,0 @@
-export {
-	initSkills,
-	listInstalledSkills,
-	getSkill,
-	installSkill,
-	installSkillFromUrl,
-	removeSkill,
-	activateSkill,
-	deactivateSkill,
-	getActiveSkills,
-	getActiveSkillsContent,
-} from './store.js';
-export type { Skill, SkillActivation } from './store.js';

package/src/skills/store.ts

@@ -1,188 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createChildLogger } from '../logging/logger.js';
-import { getDatabase } from '../store/db.js';
-
-const logger = () => createChildLogger('skills');
-
-export interface Skill {
-	name: string;
-	content: string;
-	filePath: string;
-}
-
-export interface SkillActivation {
-	skillName: string;
-	targetType: 'orchestrator' | 'squad';
-	targetId: string | null;
-	activatedAt: string;
-}
-
-let skillsRoot = '';
-
-/**
- * Initialize the skills directory.
- */
-export function initSkills(dataDir: string): void {
-	skillsRoot = join(dataDir, 'skills');
-	mkdirSync(skillsRoot, { recursive: true });
-	logger().info({ skillsRoot }, 'Skills directory initialized');
-}
-
-/**
- * List all installed skills.
- */
-export function listInstalledSkills(): Skill[] {
-	if (!existsSync(skillsRoot)) return [];
-
-	const dirs = readdirSync(skillsRoot, { withFileTypes: true }).filter((d) => d.isDirectory());
-
-	const skills: Skill[] = [];
-	for (const dir of dirs) {
-		const skillPath = join(skillsRoot, dir.name, 'SKILL.md');
-		if (existsSync(skillPath)) {
-			skills.push({
-				name: dir.name,
-				content: readFileSync(skillPath, 'utf-8'),
-				filePath: skillPath,
-			});
-		}
-	}
-	return skills;
-}
-
-/**
- * Read a specific skill by name.
- */
-export function getSkill(name: string): Skill | null {
-	const skillPath = join(skillsRoot, name, 'SKILL.md');
-	if (!existsSync(skillPath)) return null;
-	return {
-		name,
-		content: readFileSync(skillPath, 'utf-8'),
-		filePath: skillPath,
-	};
-}
-
-/**
- * Install a skill from content (e.g., fetched from URL or provided directly).
- */
-export function installSkill(name: string, content: string): Skill {
-	const skillDir = join(skillsRoot, name);
-	mkdirSync(skillDir, { recursive: true });
-	const skillPath = join(skillDir, 'SKILL.md');
-	writeFileSync(skillPath, content, 'utf-8');
-	logger().info({ name }, 'Skill installed');
-	return { name, content, filePath: skillPath };
-}
-
-/**
- * Install a skill from a URL (fetches raw content).
- */
-export async function installSkillFromUrl(name: string, url: string): Promise<Skill> {
-	const res = await fetch(url);
-	if (!res.ok) {
-		throw new Error(`Failed to fetch skill from ${url}: ${res.status} ${res.statusText}`);
-	}
-	const content = await res.text();
-	return installSkill(name, content);
-}
-
-/**
- * Remove an installed skill.
- */
-export function removeSkill(name: string): void {
-	const skillDir = join(skillsRoot, name);
-	if (existsSync(skillDir)) {
-		rmSync(skillDir, { recursive: true });
-		logger().info({ name }, 'Skill removed');
-	}
-	// Also remove all activations
-	deactivateSkillAll(name);
-}
-
-/**
- * Activate a skill for a target (orchestrator or a specific squad).
- */
-export async function activateSkill(
-	skillName: string,
-	targetType: 'orchestrator' | 'squad',
-	targetId?: string,
-): Promise<void> {
-	const db = await getDatabase();
-	await db.execute({
-		sql: `INSERT OR IGNORE INTO skill_activations (skill_name, target_type, target_id, activated_at)
-		      VALUES (?, ?, ?, datetime('now'))`,
-		args: [skillName, targetType, targetId ?? null],
-	});
-	logger().info({ skillName, targetType, targetId }, 'Skill activated');
-}
-
-/**
- * Deactivate a skill for a target.
- */
-export async function deactivateSkill(
-	skillName: string,
-	targetType: 'orchestrator' | 'squad',
-	targetId?: string,
-): Promise<void> {
-	const db = await getDatabase();
-	await db.execute({
-		sql: 'DELETE FROM skill_activations WHERE skill_name = ? AND target_type = ? AND (target_id = ? OR (target_id IS NULL AND ? IS NULL))',
-		args: [skillName, targetType, targetId ?? null, targetId ?? null],
-	});
-	logger().info({ skillName, targetType, targetId }, 'Skill deactivated');
-}
-
-/**
- * Remove all activations for a skill.
- */
-async function deactivateSkillAll(skillName: string): Promise<void> {
-	const db = await getDatabase();
-	await db.execute({
-		sql: 'DELETE FROM skill_activations WHERE skill_name = ?',
-		args: [skillName],
-	});
-}
-
-/**
- * Get all activations for a target.
- */
-export async function getActiveSkills(
-	targetType: 'orchestrator' | 'squad',
-	targetId?: string,
-): Promise<SkillActivation[]> {
-	const db = await getDatabase();
-	const result = await db.execute({
-		sql: `SELECT skill_name, target_type, target_id, activated_at FROM skill_activations
-		      WHERE target_type = ? AND (target_id = ? OR (target_id IS NULL AND ? IS NULL))`,
-		args: [targetType, targetId ?? null, targetId ?? null],
-	});
-	return result.rows.map((r) => ({
-		skillName: r.skill_name as string,
-		targetType: r.target_type as 'orchestrator' | 'squad',
-		targetId: r.target_id as string | null,
-		activatedAt: r.activated_at as string,
-	}));
-}
-
-/**
- * Get the combined content of all active skills for a target (for system prompt injection).
- */
-export async function getActiveSkillsContent(
-	targetType: 'orchestrator' | 'squad',
-	targetId?: string,
-): Promise<string> {
-	const activations = await getActiveSkills(targetType, targetId);
-	if (activations.length === 0) return '';
-
-	const sections: string[] = [];
-	for (const activation of activations) {
-		const skill = getSkill(activation.skillName);
-		if (skill) {
-			sections.push(`### Skill: ${skill.name}\n${skill.content}`);
-		}
-	}
-
-	return sections.length > 0 ? `\n## Active Skills\n${sections.join('\n\n')}` : '';
-}

package/src/squad/agent.ts

@@ -1,326 +0,0 @@
-import { type CopilotSession, approveAll, defineTool } from '@github/copilot-sdk';
-import type { AgentEvent, AgentStatus } from '@io/shared';
-import { z } from 'zod';
-import { getClient } from '../copilot/client.js';
-import { createChildLogger } from '../logging/logger.js';
-import {
-	getSquadScopes,
-	listWikiPages,
-	readWikiPage,
-	searchWiki,
-	writeWikiPage,
-} from '../wiki/index.js';
-import { getEventBus } from './event-bus.js';
-import { type SkillDefinition, compileSystemPrompt } from './skill-parser.js';
-
-export interface AgentConfig {
-	skill: SkillDefinition;
-	squadId: string;
-	squadName: string;
-	instanceId?: string;
-	model?: string;
-	identity?: { displayName: string; persona?: string; universe?: string };
-}
-
-export interface AgentMessage {
-	role: 'user' | 'system';
-	content: string;
-}
-
-type Session = Awaited<ReturnType<Awaited<ReturnType<typeof getClient>>['createSession']>>;
-
-/**
- * Base agent class. Each agent has its own Copilot session, enforces
- * tool allowlists from its SKILL.md, and emits events on the bus.
- */
-export class Agent {
-	readonly role: string;
-	readonly squadId: string;
-	readonly squadName: string;
-	readonly instanceId?: string;
-	private session: Session | null = null;
-	private skill: SkillDefinition;
-	private model: string;
-	private identity?: { displayName: string; persona?: string; universe?: string };
-	private logger;
-	private _status: AgentStatus = 'idle';
-
-	constructor(config: AgentConfig) {
-		this.skill = config.skill;
-		this.role = config.skill.role;
-		this.squadId = config.squadId;
-		this.squadName = config.squadName;
-		this.instanceId = config.instanceId;
-		this.model = config.model ?? 'claude-opus-4.6';
-		this.identity = config.identity;
-		this.logger = createChildLogger(
-			`agent:${config.squadName}:${config.identity?.displayName ?? this.role}`,
-		);
-	}
-
-	get status(): AgentStatus {
-		return this._status;
-	}
-
-	/** Initialize the agent's Copilot session */
-	async init(squadContext?: string): Promise<void> {
-		const client = await getClient();
-		const systemPrompt = await compileSystemPrompt(
-			this.skill,
-			squadContext,
-			this.squadName,
-			this.squadId,
-			this.identity,
-		);
-
-		this.session = await client.createSession({
-			model: this.model,
-			systemMessage: { mode: 'replace', content: systemPrompt },
-			onPermissionRequest: approveAll,
-			tools: this.buildTools(),
-		});
-
-		this.logger.info('Agent session initialized');
-	}
-
-	/** Send a message and get a response */
-	async send(content: string): Promise<string> {
-		if (!this.session) {
-			throw new Error(`Agent ${this.role} not initialized`);
-		}
-
-		this._status = 'working';
-		this.emitEvent('agent:task_started', { content: content.slice(0, 100) });
-
-		try {
-			const result = await this.session.sendAndWait({ prompt: content }, 300_000);
-			const response = result?.data?.content ?? '';
-			this._status = 'idle';
-			this.emitEvent('agent:task_completed', { responseLength: response.length });
-			return response;
-		} catch (err) {
-			this._status = 'error';
-			this.logger.error({ err }, 'Agent send failed');
-			this.emitEvent('agent:error', {
-				error: err instanceof Error ? err.message : String(err),
-			});
-			throw err;
-		}
-	}
-
-	/** Destroy the agent's session */
-	async destroy(): Promise<void> {
-		if (this.session) {
-			await this.session.disconnect();
-			this.session = null;
-		}
-		this.logger.info('Agent destroyed');
-	}
-
-	/** Build allowed tools for this agent based on SKILL.md */
-	private buildTools() {
-		const tools = [];
-
-		// Always allow a "report" tool so agents can communicate results
-		tools.push(
-			defineTool('report_to_team_lead', {
-				description: 'Report findings or completed work back to the team lead.',
-				parameters: z.object({
-					summary: z.string().describe('Summary of work completed or findings'),
-					status: z
-						.enum(['done', 'blocked', 'needs_review'])
-						.describe('Current status of the work'),
-				}),
-				handler: async (args: { summary: string; status: string }) => {
-					this.logger.info({ status: args.status }, 'Agent reported to team lead');
-					return {
-						textResultForLlm: JSON.stringify({
-							acknowledged: true,
-							message: 'Report received by team lead.',
-						}),
-						resultType: 'success' as const,
-					};
-				},
-			}),
-		);
-
-		// Add role-specific tools based on allowlist
-		if (this.skill.tools.includes('read_file')) {
-			tools.push(
-				defineTool('read_file', {
-					description: 'Read the contents of a file in the project.',
-					parameters: z.object({
-						path: z.string().describe('Relative path to the file'),
-					}),
-					handler: async (args: { path: string }) => {
-						// TODO: Implement actual file reading with path sandboxing
-						return {
-							textResultForLlm: `[read_file] Would read: ${args.path}`,
-							resultType: 'success' as const,
-						};
-					},
-				}),
-			);
-		}
-
-		if (this.skill.tools.includes('edit_file')) {
-			tools.push(
-				defineTool('edit_file', {
-					description: 'Edit a file in the project. Provide the full new content.',
-					parameters: z.object({
-						path: z.string().describe('Relative path to the file'),
-						content: z.string().describe('New file content'),
-					}),
-					handler: async (args: { path: string; content: string }) => {
-						// TODO: Implement actual file editing with path sandboxing
-						return {
-							textResultForLlm: `[edit_file] Would write ${args.content.length} chars to: ${args.path}`,
-							resultType: 'success' as const,
-						};
-					},
-				}),
-			);
-		}
-
-		if (this.skill.tools.includes('run_command')) {
-			tools.push(
-				defineTool('run_command', {
-					description: 'Run a shell command in the project directory.',
-					parameters: z.object({
-						command: z.string().describe('The command to execute'),
-					}),
-					handler: async (args: { command: string }) => {
-						// TODO: Implement actual command execution with sandboxing
-						return {
-							textResultForLlm: `[run_command] Would run: ${args.command}`,
-							resultType: 'success' as const,
-						};
-					},
-				}),
-			);
-		}
-
-		if (this.skill.tools.includes('search_code')) {
-			tools.push(
-				defineTool('search_code', {
-					description: 'Search for patterns in the project codebase.',
-					parameters: z.object({
-						pattern: z.string().describe('Search pattern (regex or text)'),
-						glob: z.string().optional().describe('File glob to limit search'),
-					}),
-					handler: async (args: { pattern: string; glob?: string }) => {
-						// TODO: Implement actual code search
-						return {
-							textResultForLlm: `[search_code] Would search for: ${args.pattern}`,
-							resultType: 'success' as const,
-						};
-					},
-				}),
-			);
-		}
-
-		// Wiki tools — always available to all agents
-		tools.push(
-			defineTool('read_wiki', {
-				description:
-					'Read from the wiki knowledge base. Call with no pageName to list available pages, or with a pageName to read a specific page. You can access Shared wiki and your squad wiki.',
-				parameters: z.object({
-					scope: z
-						.enum(['shared', 'squad'])
-						.describe('"shared" for cross-squad knowledge, "squad" for this squad\'s knowledge'),
-					pageName: z.string().optional().describe('Page name to read (omit to list all pages)'),
-				}),
-				handler: async (args: { scope: 'shared' | 'squad'; pageName?: string }) => {
-					const resolvedScope = args.scope === 'squad' ? this.squadName : 'shared';
-					if (!args.pageName) {
-						const pages = listWikiPages(resolvedScope);
-						return {
-							textResultForLlm: JSON.stringify({
-								scope: args.scope,
-								pages: pages.length > 0 ? pages : '(empty)',
-							}),
-							resultType: 'success' as const,
-						};
-					}
-					const page = readWikiPage(resolvedScope, args.pageName);
-					if (!page) {
-						return {
-							textResultForLlm: JSON.stringify({
-								error: `Page '${args.pageName}' not found in ${args.scope} wiki`,
-							}),
-							resultType: 'success' as const,
-						};
-					}
-					return {
-						textResultForLlm: JSON.stringify({
-							scope: args.scope,
-							name: page.name,
-							content: page.content,
-						}),
-						resultType: 'success' as const,
-					};
-				},
-			}),
-			defineTool('write_wiki', {
-				description:
-					"Write a page to your squad's wiki knowledge base. Read the existing page first and merge knowledge if updating. You can only write to your squad wiki (not shared).",
-				parameters: z.object({
-					pageName: z
-						.string()
-						.describe('Page name (no .md extension, e.g., "architecture" or "conventions")'),
-					content: z.string().describe('Full markdown content for the page'),
-				}),
-				handler: async (args: { pageName: string; content: string }) => {
-					writeWikiPage(this.squadName, args.pageName, args.content);
-					return {
-						textResultForLlm: JSON.stringify({
-							written: true,
-							scope: 'squad',
-							pageName: args.pageName,
-						}),
-						resultType: 'success' as const,
-					};
-				},
-			}),
-			defineTool('search_wiki', {
-				description:
-					'Search across all accessible wiki pages by keyword. Searches both Shared and your squad wiki.',
-				parameters: z.object({
-					keyword: z.string().describe('Keyword or phrase to search for'),
-				}),
-				handler: async (args: { keyword: string }) => {
-					const results = searchWiki(args.keyword, getSquadScopes(this.squadName));
-					if (results.length === 0) {
-						return {
-							textResultForLlm: JSON.stringify({ results: [], message: 'No matches found.' }),
-							resultType: 'success' as const,
-						};
-					}
-					return {
-						textResultForLlm: JSON.stringify({ results }),
-						resultType: 'success' as const,
-					};
-				},
-			}),
-		);
-
-		return tools;
-	}
-
-	private emitEvent(type: AgentEvent['type'], data?: Record<string, unknown>) {
-		getEventBus()
-			.emit({
-				id: crypto.randomUUID(),
-				timestamp: new Date(),
-				type,
-				squadId: this.squadId,
-				instanceId: this.instanceId,
-				agentRole: this.role,
-				model: this.model,
-				data,
-			})
-			.catch((err) => {
-				this.logger.error({ err }, 'Failed to emit agent event');
-			});
-	}
-}

package/src/squad/autonomy.ts

@@ -1,78 +0,0 @@
-import type { AutonomyConfig } from '@io/shared';
-import { createChildLogger } from '../logging/logger.js';
-
-const logger = () => createChildLogger('autonomy');
-
-export type PermissionAction = 'merge' | 'release' | 'close' | 'review';
-
-export interface PermissionCheck {
-	allowed: boolean;
-	requiresApproval: boolean;
-	reason?: string;
-}
-
-/**
- * Check if a squad has permission to perform an action based on its autonomy tier.
- */
-export function checkPermission(config: AutonomyConfig, action: PermissionAction): PermissionCheck {
-	switch (action) {
-		case 'merge':
-			if (config.canMergePrs) return { allowed: true, requiresApproval: false };
-			if (config.requiresUserApprovalFor.includes('merge'))
-				return {
-					allowed: false,
-					requiresApproval: true,
-					reason: 'User approval required for merging PRs',
-				};
-			return { allowed: false, requiresApproval: false, reason: 'Merging PRs not allowed' };
-
-		case 'release':
-			if (config.canCreateReleases) return { allowed: true, requiresApproval: false };
-			if (config.requiresUserApprovalFor.includes('release'))
-				return {
-					allowed: false,
-					requiresApproval: true,
-					reason: 'User approval required for releases',
-				};
-			return { allowed: false, requiresApproval: false, reason: 'Creating releases not allowed' };
-
-		case 'close':
-			if (config.canCloseIssues) return { allowed: true, requiresApproval: false };
-			if (config.requiresUserApprovalFor.includes('close'))
-				return {
-					allowed: false,
-					requiresApproval: true,
-					reason: 'User approval required for closing issues',
-				};
-			return { allowed: false, requiresApproval: false, reason: 'Closing issues not allowed' };
-
-		case 'review':
-			if (config.canSelfReview) return { allowed: true, requiresApproval: false };
-			if (config.requiresUserApprovalFor.includes('review'))
-				return {
-					allowed: false,
-					requiresApproval: true,
-					reason: 'User approval required for self-review',
-				};
-			return { allowed: false, requiresApproval: false, reason: 'Self-review not allowed' };
-
-		default:
-			return { allowed: false, requiresApproval: false, reason: `Unknown action: ${action}` };
-	}
-}
-
-/**
- * Enforce a permission — logs and throws if not allowed.
- */
-export function enforcePermission(
-	config: AutonomyConfig,
-	action: PermissionAction,
-	squadName: string,
-): void {
-	const check = checkPermission(config, action);
-	if (!check.allowed && !check.requiresApproval) {
-		const msg = `Squad '${squadName}' is not permitted to ${action}: ${check.reason}`;
-		logger().warn({ squadName, action }, msg);
-		throw new Error(msg);
-	}
-}

package/src/squad/event-bus.ts

@@ -1,71 +0,0 @@
-import type { IOEvent } from '@io/shared';
-import { createChildLogger } from '../logging/logger.js';
-
-type EventHandler<T extends IOEvent = IOEvent> = (event: T) => void | Promise<void>;
-
-/**
- * Typed pub/sub event bus with error-isolated handlers.
- * Handlers that throw are logged but don't crash the bus or other handlers.
- */
-export class EventBus {
-	private handlers = new Map<string, Set<EventHandler>>();
-	private globalHandlers = new Set<EventHandler>();
-	private logger = createChildLogger('event-bus');
-
-	/** Subscribe to a specific event type */
-	on<T extends IOEvent>(type: T['type'], handler: EventHandler<T>): () => void {
-		if (!this.handlers.has(type)) {
-			this.handlers.set(type, new Set());
-		}
-		const set = this.handlers.get(type)!;
-		set.add(handler as EventHandler);
-		return () => set.delete(handler as EventHandler);
-	}
-
-	/** Subscribe to all events */
-	onAny(handler: EventHandler): () => void {
-		this.globalHandlers.add(handler);
-		return () => this.globalHandlers.delete(handler);
-	}
-
-	/** Emit an event to all matching handlers */
-	async emit(event: IOEvent): Promise<void> {
-		const typeHandlers = this.handlers.get(event.type) ?? new Set();
-		const allHandlers = [...typeHandlers, ...this.globalHandlers];
-
-		const results = await Promise.allSettled(
-			allHandlers.map((handler) => {
-				try {
-					return Promise.resolve(handler(event));
-				} catch (err) {
-					return Promise.reject(err);
-				}
-			}),
-		);
-
-		for (const result of results) {
-			if (result.status === 'rejected') {
-				this.logger.error(
-					{ err: result.reason, eventType: event.type },
-					'Event handler threw an error',
-				);
-			}
-		}
-	}
-
-	/** Remove all handlers */
-	clear(): void {
-		this.handlers.clear();
-		this.globalHandlers.clear();
-	}
-}
-
-// Singleton instance
-let busInstance: EventBus | null = null;
-
-export function getEventBus(): EventBus {
-	if (!busInstance) {
-		busInstance = new EventBus();
-	}
-	return busInstance;
-}

package/src/squad/execution/index.ts

@@ -1,17 +0,0 @@
-export { createWorktree, removeWorktree, listWorktrees } from './worktree.js';
-export type { WorktreeInfo } from './worktree.js';
-export {
-	createInstance,
-	transitionInstance,
-	cleanupInstance,
-	getInstance,
-	getSquadInstances,
-} from './instance.js';
-export type { Instance, InstanceTask } from './instance.js';
-export { runMeeting } from './meeting.js';
-export type { MeetingResult } from './meeting.js';
-export { executeTasks } from './tasks.js';
-export { createPullRequest } from './pr.js';
-export type { PrResult } from './pr.js';
-export { runInstance } from './runner.js';
-export type { RunResult } from './runner.js';