@agentuity/opencode 0.1.39 → 0.1.41

package/src/skills/loader.ts

@@ -0,0 +1,185 @@
+import { homedir } from 'node:os';
+import { basename, join, resolve, sep } from 'node:path';
+import { readdir, realpath } from 'node:fs/promises';
+import type { LoadedSkill, SkillMetadata, SkillScope, SkillsConfig } from './types';
+import { parseFrontmatter } from './frontmatter';
+
+const SKILL_FILENAME = 'SKILL.md';
+
+interface SkillDirConfig {
+	dir: string;
+	scope: SkillScope;
+}
+
+/**
+ * Load skills from standard directories.
+ * Priority order (later overrides earlier):
+ * 1. User OpenCode: ~/.config/opencode/skills/
+ * 2. User Agentuity: ~/.config/agentuity/opencode/skills/
+ * 3. User Claude Code compat: ~/.claude/skills/
+ * 4. Project OpenCode: ./.opencode/skills/
+ * 5. Project Claude Code compat: ./.claude/skills/
+ */
+export async function loadAllSkills(config?: SkillsConfig): Promise<LoadedSkill[]> {
+	if (config?.enabled === false) {
+		return [];
+	}
+
+	const skillDirs: SkillDirConfig[] = [
+		{ dir: join(homedir(), '.config', 'opencode', 'skills'), scope: 'user' },
+		{ dir: join(homedir(), '.config', 'agentuity', 'opencode', 'skills'), scope: 'user' },
+		{ dir: join(homedir(), '.claude', 'skills'), scope: 'user' },
+		{ dir: join(process.cwd(), '.opencode', 'skills'), scope: 'project' },
+		{ dir: join(process.cwd(), '.claude', 'skills'), scope: 'project' },
+	];
+
+	if (config?.paths?.length) {
+		for (const skillPath of config.paths) {
+			const resolvedPath = resolve(skillPath);
+			skillDirs.push({ dir: resolvedPath, scope: inferScope(resolvedPath) });
+		}
+	}
+
+	const disabled = new Set(config?.disabled ?? []);
+	const skillsByName = new Map<string, LoadedSkill>();
+
+	for (const { dir, scope } of skillDirs) {
+		const skills = await loadSkillsFromDir(dir, scope);
+		for (const skill of skills) {
+			if (disabled.has(skill.name)) {
+				continue;
+			}
+			skillsByName.set(skill.name, skill);
+		}
+	}
+
+	return Array.from(skillsByName.values());
+}
+
+/**
+ * Load skills from a single directory
+ */
+export async function loadSkillsFromDir(dir: string, scope: SkillScope): Promise<LoadedSkill[]> {
+	const results: LoadedSkill[] = [];
+	const resolvedDir = await safeRealpath(dir);
+
+	let entries: Array<{ name: string; isFile: () => boolean; isDirectory: () => boolean }>;
+	try {
+		entries = await readdir(resolvedDir, { withFileTypes: true });
+	} catch {
+		return results;
+	}
+
+	for (const entry of entries) {
+		if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+			const skillPath = join(dir, entry.name);
+			const skill = await loadSkillFromPath(
+				skillPath,
+				resolvedDir,
+				basename(entry.name, '.md'),
+				scope
+			);
+			if (skill) {
+				results.push(skill);
+			}
+			continue;
+		}
+
+		if (entry.isDirectory()) {
+			const subdirPath = join(dir, entry.name);
+			const resolvedSubdir = await safeRealpath(subdirPath);
+			const candidates = [
+				join(subdirPath, SKILL_FILENAME),
+				join(subdirPath, `${entry.name}.md`),
+			];
+
+			for (const candidate of candidates) {
+				const skill = await loadSkillFromPath(candidate, resolvedSubdir, entry.name, scope);
+				if (skill) {
+					results.push(skill);
+					break;
+				}
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Load a single skill file (supports both .md files and SKILL.md in directories)
+ */
+async function loadSkillFromPath(
+	skillPath: string,
+	resolvedPath: string,
+	defaultName: string,
+	scope: SkillScope
+): Promise<LoadedSkill | null> {
+	const file = Bun.file(skillPath);
+	if (!(await file.exists())) {
+		return null;
+	}
+
+	const content = await file.text();
+	const parsed = parseFrontmatter<SkillMetadata>(content);
+	const metadata = parsed.data ?? {};
+	const name = metadata.name?.trim() || defaultName;
+	if (!name) {
+		return null;
+	}
+
+	const allowedTools = normalizeAllowedTools(metadata['allowed-tools']);
+
+	return {
+		name,
+		path: skillPath,
+		resolvedPath,
+		content: parsed.body,
+		metadata,
+		scope,
+		...(allowedTools ? { allowedTools } : {}),
+	};
+}
+
+/**
+ * Get skill by name from loaded skills
+ */
+export function getSkillByName(skills: LoadedSkill[], name: string): LoadedSkill | undefined {
+	return skills.find((skill) => skill.name === name);
+}
+
+function normalizeAllowedTools(value?: string | string[]): string[] | undefined {
+	if (!value) return undefined;
+	if (Array.isArray(value)) {
+		const tools = value.filter((tool) => typeof tool === 'string');
+		return tools.length > 0 ? tools : undefined;
+	}
+	if (typeof value === 'string') {
+		const tool = value.trim();
+		return tool ? [tool] : undefined;
+	}
+	return undefined;
+}
+
+function inferScope(skillPath: string): SkillScope {
+	const resolved = resolve(skillPath);
+	const cwd = resolve(process.cwd());
+	const home = resolve(homedir());
+
+	if (isWithin(cwd, resolved)) return 'project';
+	if (isWithin(home, resolved)) return 'user';
+	return 'opencode';
+}
+
+function isWithin(base: string, target: string): boolean {
+	const baseWithSep = base.endsWith(sep) ? base : `${base}${sep}`;
+	return target === base || target.startsWith(baseWithSep);
+}
+
+async function safeRealpath(path: string): Promise<string> {
+	try {
+		return await realpath(path);
+	} catch {
+		return path;
+	}
+}

package/src/skills/types.ts

@@ -0,0 +1,43 @@
+/**
+ * Skill scope determines where the skill was loaded from
+ * Priority order: project > user > opencode
+ */
+export type SkillScope = 'project' | 'user' | 'opencode';
+
+/**
+ * Frontmatter metadata parsed from skill files
+ */
+export interface SkillMetadata {
+	name?: string;
+	description?: string;
+	model?: string;
+	agent?: string;
+	subtask?: boolean;
+	'argument-hint'?: string;
+	'allowed-tools'?: string | string[];
+	license?: string;
+	compatibility?: string;
+	metadata?: Record<string, string>;
+}
+
+/**
+ * A loaded skill ready for use
+ */
+export interface LoadedSkill {
+	name: string;
+	path: string;
+	resolvedPath: string;
+	content: string;
+	metadata: SkillMetadata;
+	scope: SkillScope;
+	allowedTools?: string[];
+}
+
+/**
+ * Configuration for skills loading
+ */
+export interface SkillsConfig {
+	enabled: boolean;
+	paths?: string[];
+	disabled?: string[];
+}

package/src/tmux/decision-engine.ts

@@ -0,0 +1,246 @@
+import type {
+	CapacityConfig,
+	PaneAction,
+	SessionMapping,
+	SpawnDecision,
+	WindowState,
+} from './types';
+import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from './types';
+
+/**
+ * Extended capacity config that includes maxPanes limit
+ */
+export interface ExtendedCapacityConfig extends CapacityConfig {
+	maxPanes?: number;
+}
+
+/**
+ * Decide what actions to take to spawn a new agent pane
+ *
+ * Respects maxPanes limit with LRU rotation:
+ * - If current agent panes >= maxPanes, close oldest pane before spawning new one
+ * - This implements LRU (Least Recently Used) rotation
+ */
+export function decideSpawnActions(
+	state: WindowState,
+	sessionId: string,
+	description: string,
+	config: ExtendedCapacityConfig,
+	sessionMappings: SessionMapping[]
+): SpawnDecision {
+	if (!state.mainPane) {
+		return { canSpawn: false, actions: [], reason: 'Main pane not found.' };
+	}
+
+	if (state.windowWidth < config.mainPaneMinWidth + config.agentPaneMinWidth) {
+		return { canSpawn: false, actions: [], reason: 'Window too small for split.' };
+	}
+
+	const capacity = calculateCapacity(state.windowWidth, state.windowHeight);
+	if (capacity.total <= 0) {
+		return { canSpawn: false, actions: [], reason: 'Window too small for agent panes.' };
+	}
+
+	// Determine effective max panes (user config or calculated capacity)
+	const effectiveMaxPanes = config.maxPanes ?? capacity.total;
+	const currentPaneCount = state.agentPanes.length;
+
+	// Check if we need LRU rotation (at or over maxPanes limit)
+	if (currentPaneCount >= effectiveMaxPanes) {
+		// Find oldest pane to close (LRU rotation)
+		const oldestMapping = pickOldestPane(sessionMappings);
+		if (!oldestMapping) {
+			// No tracked sessions, try replacement instead
+			const replacement = pickReplacementPane(state, sessionMappings);
+			if (!replacement) {
+				return { canSpawn: false, actions: [], reason: 'No pane available to replace.' };
+			}
+			return {
+				canSpawn: true,
+				actions: [
+					{
+						type: 'replace',
+						paneId: replacement.paneId,
+						oldSessionId: replacement.sessionId,
+						newSessionId: sessionId,
+						description,
+					},
+				],
+			};
+		}
+
+		// Close oldest pane, then spawn new one
+		const actions: PaneAction[] = [
+			{
+				type: 'close',
+				paneId: oldestMapping.paneId,
+				sessionId: oldestMapping.sessionId,
+			},
+		];
+
+		// After closing, we'll have room to spawn
+		// Determine where to spawn the new pane
+		if (currentPaneCount === 1) {
+			// After closing the only agent pane, split from main
+			actions.push({
+				type: 'spawn',
+				sessionId,
+				description,
+				targetPaneId: state.mainPane.paneId,
+				splitDirection: '-h',
+			});
+		} else {
+			// Find a remaining pane to split (not the one being closed)
+			const remainingPanes = state.agentPanes.filter((p) => p.paneId !== oldestMapping.paneId);
+			const targetPane = pickBestSplitPane(remainingPanes);
+			if (targetPane) {
+				const splitDirection = chooseSplitDirection(targetPane, config.agentPaneMinWidth);
+				actions.push({
+					type: 'spawn',
+					sessionId,
+					description,
+					targetPaneId: targetPane.paneId,
+					splitDirection,
+				});
+			} else {
+				// Fallback: split from main pane
+				actions.push({
+					type: 'spawn',
+					sessionId,
+					description,
+					targetPaneId: state.mainPane.paneId,
+					splitDirection: '-h',
+				});
+			}
+		}
+
+		return { canSpawn: true, actions };
+	}
+
+	// Under maxPanes limit - normal spawn logic
+	if (state.agentPanes.length === 0) {
+		if (!canSplitHorizontally(state.mainPane, config.agentPaneMinWidth)) {
+			return { canSpawn: false, actions: [], reason: 'Main pane too narrow to split.' };
+		}
+		return {
+			canSpawn: true,
+			actions: [
+				{
+					type: 'spawn',
+					sessionId,
+					description,
+					targetPaneId: state.mainPane.paneId,
+					splitDirection: '-h',
+				},
+			],
+		};
+	}
+
+	const targetPane = pickBestSplitPane(state.agentPanes);
+	if (!targetPane) {
+		return { canSpawn: false, actions: [], reason: 'No suitable pane to split.' };
+	}
+	const splitDirection = chooseSplitDirection(targetPane, config.agentPaneMinWidth);
+	if (!canSplitPane(targetPane, splitDirection, config.agentPaneMinWidth)) {
+		return { canSpawn: false, actions: [], reason: 'No suitable pane to split.' };
+	}
+
+	return {
+		canSpawn: true,
+		actions: [
+			{
+				type: 'spawn',
+				sessionId,
+				description,
+				targetPaneId: targetPane.paneId,
+				splitDirection,
+			},
+		],
+	};
+}
+
+/**
+ * Calculate grid capacity based on window size
+ */
+export function calculateCapacity(
+	windowWidth: number,
+	windowHeight: number
+): { cols: number; rows: number; total: number } {
+	const reservedWidth = Math.floor(windowWidth * 0.5);
+	const agentWidth = Math.max(0, windowWidth - reservedWidth);
+	const cols = Math.floor(agentWidth / MIN_PANE_WIDTH);
+	const rows = Math.floor(windowHeight / MIN_PANE_HEIGHT);
+	return {
+		cols: Math.max(0, cols),
+		rows: Math.max(0, rows),
+		total: Math.max(0, cols * rows),
+	};
+}
+
+function pickBestSplitPane(
+	panes: WindowState['agentPanes']
+): WindowState['agentPanes'][number] | undefined {
+	if (panes.length === 0) {
+		return undefined;
+	}
+	return panes.reduce((best, pane) => {
+		const bestArea = best.width * best.height;
+		const area = pane.width * pane.height;
+		return area > bestArea ? pane : best;
+	});
+}
+
+function chooseSplitDirection(
+	pane: WindowState['agentPanes'][number],
+	minAgentWidth: number
+): '-h' | '-v' {
+	const canSplitHorizontally = pane.width >= minAgentWidth * 2;
+	const canSplitVertically = pane.height >= MIN_PANE_HEIGHT * 2;
+	if (canSplitHorizontally && canSplitVertically) {
+		return pane.width >= pane.height ? '-h' : '-v';
+	}
+	if (canSplitHorizontally) return '-h';
+	if (canSplitVertically) return '-v';
+	return '-h';
+}
+
+function canSplitPane(
+	pane: WindowState['agentPanes'][number],
+	direction: '-h' | '-v',
+	minAgentWidth: number
+): boolean {
+	if (direction === '-h') {
+		return canSplitHorizontally(pane, minAgentWidth);
+	}
+	return pane.height >= MIN_PANE_HEIGHT * 2;
+}
+
+function canSplitHorizontally(
+	pane: WindowState['agentPanes'][number],
+	minAgentWidth: number
+): boolean {
+	return pane.width >= minAgentWidth * 2;
+}
+
+function pickReplacementPane(
+	state: WindowState,
+	sessionMappings: SessionMapping[]
+): SessionMapping | null {
+	const panesById = new Set(state.agentPanes.map((pane) => pane.paneId));
+	const candidates = sessionMappings.filter((mapping) => panesById.has(mapping.paneId));
+	if (candidates.length === 0) return null;
+	return candidates.reduce((oldest, entry) =>
+		entry.createdAt.getTime() < oldest.createdAt.getTime() ? entry : oldest
+	);
+}
+
+/**
+ * Pick the oldest pane from session mappings (LRU - Least Recently Used)
+ * Used for rotation when maxPanes limit is reached
+ */
+function pickOldestPane(sessionMappings: SessionMapping[]): SessionMapping | null {
+	if (sessionMappings.length === 0) return null;
+	return sessionMappings.reduce((oldest, entry) =>
+		entry.createdAt.getTime() < oldest.createdAt.getTime() ? entry : oldest
+	);
+}