@phi-code-admin/phi-code 0.56.3

package/extensions/phi/skill-loader.ts

@@ -0,0 +1,336 @@
+/**
+ * Skill Loader Extension - Dynamic skill loading and context injection
+ *
+ * Automatically discovers and loads skills from ~/.phi/agent/skills/ and .phi/skills/
+ * directories. Skills are folders containing SKILL.md files with specialized knowledge
+ * or procedures. When skill-related keywords are detected in user input, the skill
+ * content is automatically injected into the conversation context.
+ *
+ * Features:
+ * - Automatic skill discovery at startup
+ * - Keyword-based skill detection and loading
+ * - /skills command to list available skills
+ * - Contextual skill injection via pi.sendHookMessage
+ *
+ * Usage:
+ * 1. Copy to packages/coding-agent/extensions/phi/skill-loader.ts
+ * 2. Create skill directories with SKILL.md files
+ * 3. Skills auto-load when relevant keywords are detected
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "phi-code";
+import { readdir, readFile, access, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface Skill {
+	name: string;
+	path: string;
+	content: string;
+	keywords: string[];
+	description: string;
+	source: "global" | "local";
+}
+
+export default function skillLoaderExtension(pi: ExtensionAPI) {
+	let availableSkills: Skill[] = [];
+	const globalSkillsDir = join(homedir(), ".phi", "agent", "skills");
+	const localSkillsDir = join(process.cwd(), ".phi", "skills");
+
+	/**
+	 * Extract keywords and description from SKILL.md content
+	 */
+	function parseSkillContent(content: string): { keywords: string[]; description: string } {
+		const lines = content.split('\n');
+		const keywords: string[] = [];
+		let description = "";
+
+		// Look for keywords in frontmatter or explicit sections
+		let inFrontmatter = false;
+		let foundKeywords = false;
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+
+			// YAML frontmatter
+			if (trimmed === '---') {
+				inFrontmatter = !inFrontmatter;
+				continue;
+			}
+
+			if (inFrontmatter) {
+				if (trimmed.startsWith('keywords:') || trimmed.startsWith('tags:')) {
+					const keywordLine = trimmed.split(':')[1];
+					if (keywordLine) {
+						// Parse YAML array or comma-separated
+						const parsed = keywordLine
+							.replace(/[\[\]]/g, '')
+							.split(',')
+							.map(k => k.trim().toLowerCase())
+							.filter(k => k.length > 0);
+						keywords.push(...parsed);
+						foundKeywords = true;
+					}
+				}
+				if (trimmed.startsWith('description:')) {
+					description = trimmed.split(':', 2)[1]?.trim() || "";
+				}
+				continue;
+			}
+
+			// Look for explicit keywords section
+			if (trimmed.toLowerCase().includes('keywords:') || trimmed.toLowerCase().includes('tags:')) {
+				const keywordText = trimmed.split(':')[1];
+				if (keywordText) {
+					const parsed = keywordText
+						.split(',')
+						.map(k => k.trim().toLowerCase())
+						.filter(k => k.length > 0);
+					keywords.push(...parsed);
+					foundKeywords = true;
+				}
+				continue;
+			}
+
+			// Use first heading as description if none found
+			if (!description && trimmed.startsWith('#')) {
+				description = trimmed.replace(/^#+\s*/, '').trim();
+			}
+		}
+
+		// If no explicit keywords, derive from content
+		if (!foundKeywords) {
+			const contentLower = content.toLowerCase();
+			const commonKeywords = [
+				'docker', 'kubernetes', 'aws', 'azure', 'gcp', 'terraform',
+				'python', 'javascript', 'typescript', 'react', 'node',
+				'git', 'github', 'gitlab', 'ci/cd', 'devops',
+				'database', 'postgresql', 'mysql', 'mongodb', 'redis',
+				'api', 'rest', 'graphql', 'microservices',
+				'security', 'auth', 'oauth', 'jwt',
+				'test', 'testing', 'unit', 'integration',
+				'deploy', 'deployment', 'production'
+			];
+
+			for (const keyword of commonKeywords) {
+				if (contentLower.includes(keyword)) {
+					keywords.push(keyword);
+				}
+			}
+
+			// Also include skill directory name as keyword
+			const skillName = description.toLowerCase().replace(/\s+/g, '-');
+			if (skillName) keywords.push(skillName);
+		}
+
+		return { keywords, description };
+	}
+
+	/**
+	 * Load skills from a directory
+	 */
+	async function loadSkillsFromDirectory(directory: string, source: "global" | "local"): Promise<Skill[]> {
+		const skills: Skill[] = [];
+
+		try {
+			await access(directory);
+			const entries = await readdir(directory);
+
+			for (const entry of entries) {
+				const skillPath = join(directory, entry);
+				
+				try {
+					const skillStat = await stat(skillPath);
+					if (!skillStat.isDirectory()) continue;
+
+					const skillFilePath = join(skillPath, "SKILL.md");
+					
+					try {
+						await access(skillFilePath);
+						const content = await readFile(skillFilePath, 'utf-8');
+						const { keywords, description } = parseSkillContent(content);
+
+						skills.push({
+							name: entry,
+							path: skillPath,
+							content,
+							keywords,
+							description: description || entry,
+							source
+						});
+
+					} catch {
+						// No SKILL.md file, skip this directory
+					}
+				} catch {
+					// Can't access directory, skip
+				}
+			}
+		} catch {
+			// Directory doesn't exist, return empty array
+		}
+
+		return skills;
+	}
+
+	/**
+	 * Load all available skills
+	 */
+	async function loadAllSkills(): Promise<void> {
+		const globalSkills = await loadSkillsFromDirectory(globalSkillsDir, "global");
+		const localSkills = await loadSkillsFromDirectory(localSkillsDir, "local");
+		
+		availableSkills = [...globalSkills, ...localSkills];
+		
+		console.log(`Loaded ${availableSkills.length} skills (${globalSkills.length} global, ${localSkills.length} local)`);
+	}
+
+	/**
+	 * Find relevant skills for input text
+	 */
+	function findRelevantSkills(text: string): Skill[] {
+		const textLower = text.toLowerCase();
+		const relevantSkills: Array<{ skill: Skill; matchCount: number }> = [];
+
+		for (const skill of availableSkills) {
+			let matches = 0;
+			
+			// Check for keyword matches
+			for (const keyword of skill.keywords) {
+				if (textLower.includes(keyword)) {
+					matches++;
+				}
+			}
+
+			// Check for skill name match
+			if (textLower.includes(skill.name.toLowerCase())) {
+				matches += 2; // Name match gets higher weight
+			}
+
+			if (matches > 0) {
+				relevantSkills.push({ skill, matchCount: matches });
+			}
+		}
+
+		// Sort by match count (most relevant first) and return top 3
+		return relevantSkills
+			.sort((a, b) => b.matchCount - a.matchCount)
+			.slice(0, 3)
+			.map(item => item.skill);
+	}
+
+	/**
+	 * Input interceptor for skill detection
+	 */
+	pi.on("input", async (event, ctx) => {
+		// Skip if this is an extension-generated message
+		if (event.source === "extension") {
+			return { action: "continue" };
+		}
+
+		// Find relevant skills
+		const relevantSkills = findRelevantSkills(event.text);
+
+		if (relevantSkills.length > 0) {
+			// Inject skill content into context
+			for (const skill of relevantSkills) {
+				const skillMessage = `Skill Context: ${skill.name}
+
+${skill.content}
+
+---
+This skill was automatically loaded based on your request. Use this knowledge to assist with the task.`;
+
+				await pi.sendHookMessage({
+					role: "system",
+					content: skillMessage,
+				}, { source: "extension" });
+			}
+
+			// Notify user which skills were loaded
+			const skillNames = relevantSkills.map(s => s.name).join(", ");
+			ctx.ui.notify(`🧠 Loaded ${relevantSkills.length} skill(s): ${skillNames}`, "info");
+		}
+
+		return { action: "continue" };
+	});
+
+	/**
+	 * /skills command - List available skills
+	 */
+	pi.registerCommand("skills", {
+		description: "List available skills or show skill details",
+		getArgumentCompletions: (prefix) => {
+			const skillNames = availableSkills.map(s => s.name);
+			const filtered = skillNames.filter(name => name.toLowerCase().startsWith(prefix.toLowerCase()));
+			return filtered.length > 0 ? filtered.map(name => ({ value: name, label: name })) : null;
+		},
+		handler: async (args, ctx) => {
+			const skillName = args.trim();
+
+			if (!skillName) {
+				// List all skills
+				if (availableSkills.length === 0) {
+					ctx.ui.notify("No skills found. Create skill directories with SKILL.md files in:\n- ~/.phi/agent/skills/\n- .phi/skills/", "info");
+					return;
+				}
+
+				let message = `🧠 **Available Skills** (${availableSkills.length})\n\n`;
+
+				// Group by source
+				const globalSkills = availableSkills.filter(s => s.source === "global");
+				const localSkills = availableSkills.filter(s => s.source === "local");
+
+				if (globalSkills.length > 0) {
+					message += "**Global Skills:**\n";
+					globalSkills.forEach(skill => {
+						const keywords = skill.keywords.slice(0, 3).join(", ");
+						message += `- **${skill.name}** - ${skill.description}\n`;
+						message += `  Keywords: ${keywords}\n\n`;
+					});
+				}
+
+				if (localSkills.length > 0) {
+					message += "**Project Skills:**\n";
+					localSkills.forEach(skill => {
+						const keywords = skill.keywords.slice(0, 3).join(", ");
+						message += `- **${skill.name}** - ${skill.description}\n`;
+						message += `  Keywords: ${keywords}\n\n`;
+					});
+				}
+
+				message += "\nUse `/skills <name>` to view a specific skill.";
+
+				ctx.ui.notify(message, "info");
+
+			} else {
+				// Show specific skill
+				const skill = availableSkills.find(s => s.name.toLowerCase() === skillName.toLowerCase());
+				
+				if (!skill) {
+					ctx.ui.notify(`Skill "${skillName}" not found. Use /skills to list available skills.`, "warning");
+					return;
+				}
+
+				const message = `🧠 **Skill: ${skill.name}**
+
+**Description:** ${skill.description}
+**Source:** ${skill.source}
+**Path:** ${skill.path}
+**Keywords:** ${skill.keywords.join(", ")}
+
+**Content Preview:**
+${skill.content.slice(0, 500)}${skill.content.length > 500 ? "..." : ""}`;
+
+				ctx.ui.notify(message, "info");
+			}
+		},
+	});
+
+	/**
+	 * Load skills on session start
+	 */
+	pi.on("session_start", async (_event, _ctx) => {
+		await loadAllSkills();
+	});
+}

package/extensions/phi/smart-router.ts

@@ -0,0 +1,290 @@
+/**
+ * Smart Router Extension - Intelligent model routing for different task types
+ *
+ * Analyzes user input to suggest the most appropriate model for the task:
+ * - Code tasks (implement, create, refactor, build) → coder model
+ * - Debug tasks (fix, bug, error, debug) → reasoning model  
+ * - Exploration tasks (read, analyze, explain, understand) → fast model
+ * - Planning tasks (plan, design, architect, spec) → reasoning model
+ *
+ * Reads configuration from ~/.phi/agent/routing.json if available.
+ * Currently only notifies user of recommendations - automatic switching to be added later.
+ *
+ * Features:
+ * - Input analysis and model recommendations
+ * - Configurable routing rules
+ * - User notifications via ctx.ui.notify
+ *
+ * Usage:
+ * 1. Copy to packages/coding-agent/extensions/phi/smart-router.ts
+ * 2. Optionally configure via ~/.phi/agent/routing.json
+ */
+
+import type { ExtensionAPI } from "phi-code";
+import { readFile, mkdir, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface RoutingConfig {
+	patterns: {
+		code: string[];
+		debug: string[];
+		exploration: string[];
+		planning: string[];
+	};
+	models: {
+		coder: string;
+		reasoning: string;
+		fast: string;
+	};
+	enabled: boolean;
+	notifyOnRecommendation: boolean;
+}
+
+const DEFAULT_CONFIG: RoutingConfig = {
+	patterns: {
+		code: ["implement", "create", "build", "refactor", "code", "write", "develop", "generate"],
+		debug: ["fix", "bug", "error", "debug", "troubleshoot", "repair", "solve", "issue"],
+		exploration: ["read", "analyze", "explain", "understand", "explore", "examine", "review", "what is"],
+		planning: ["plan", "design", "architect", "spec", "strategy", "approach", "organize", "structure"]
+	},
+	models: {
+		coder: "anthropic/claude-sonnet-3.5",
+		reasoning: "anthropic/claude-opus",  
+		fast: "anthropic/claude-haiku"
+	},
+	enabled: true,
+	notifyOnRecommendation: true
+};
+
+export default function smartRouterExtension(pi: ExtensionAPI) {
+	let config: RoutingConfig = DEFAULT_CONFIG;
+	const configDir = join(homedir(), ".phi", "agent");
+	const configPath = join(configDir, "routing.json");
+
+	/**
+	 * Load routing configuration
+	 */
+	async function loadConfig() {
+		try {
+			await access(configPath);
+			const configText = await readFile(configPath, 'utf-8');
+			const userConfig = JSON.parse(configText) as Partial<RoutingConfig>;
+			
+			// Merge with defaults
+			config = {
+				...DEFAULT_CONFIG,
+				...userConfig,
+				patterns: { ...DEFAULT_CONFIG.patterns, ...userConfig.patterns },
+				models: { ...DEFAULT_CONFIG.models, ...userConfig.models }
+			};
+		} catch (error) {
+			// Config doesn't exist or is invalid, use defaults
+			console.log("Using default routing configuration");
+			await saveDefaultConfig();
+		}
+	}
+
+	/**
+	 * Save default configuration file
+	 */
+	async function saveDefaultConfig() {
+		try {
+			await mkdir(configDir, { recursive: true });
+			await writeFile(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), 'utf-8');
+			console.log(`Created default routing config at ${configPath}`);
+		} catch (error) {
+			console.warn("Failed to save default routing config:", error);
+		}
+	}
+
+	/**
+	 * Analyze input text to determine task type
+	 */
+	function analyzeTaskType(text: string): { type: keyof RoutingConfig['patterns'] | null; confidence: number; matches: string[] } {
+		const normalizedText = text.toLowerCase();
+		const results: Array<{ type: keyof RoutingConfig['patterns']; confidence: number; matches: string[] }> = [];
+
+		// Check each pattern category
+		for (const [category, patterns] of Object.entries(config.patterns)) {
+			const matches: string[] = [];
+			let matchCount = 0;
+
+			for (const pattern of patterns) {
+				if (normalizedText.includes(pattern.toLowerCase())) {
+					matches.push(pattern);
+					matchCount++;
+				}
+			}
+
+			if (matchCount > 0) {
+				// Calculate confidence based on match count and pattern length
+				const confidence = (matchCount / patterns.length) * 100;
+				results.push({ 
+					type: category as keyof RoutingConfig['patterns'], 
+					confidence, 
+					matches 
+				});
+			}
+		}
+
+		// Return the highest confidence match
+		if (results.length === 0) {
+			return { type: null, confidence: 0, matches: [] };
+		}
+
+		results.sort((a, b) => b.confidence - a.confidence);
+		return results[0];
+	}
+
+	/**
+	 * Get recommended model for task type
+	 */
+	function getRecommendedModel(taskType: keyof RoutingConfig['patterns'] | null): string | null {
+		if (!taskType) return null;
+
+		switch (taskType) {
+			case 'code':
+				return config.models.coder;
+			case 'debug':
+			case 'planning':
+				return config.models.reasoning;
+			case 'exploration':
+				return config.models.fast;
+			default:
+				return null;
+		}
+	}
+
+	/**
+	 * Get task type description
+	 */
+	function getTaskDescription(taskType: keyof RoutingConfig['patterns'] | null): string {
+		switch (taskType) {
+			case 'code':
+				return 'Code Implementation';
+			case 'debug':
+				return 'Debugging & Problem Solving';
+			case 'exploration':
+				return 'Analysis & Understanding';
+			case 'planning':
+				return 'Planning & Design';
+			default:
+				return 'General Task';
+		}
+	}
+
+	/**
+	 * Input interceptor for smart routing
+	 */
+	pi.on("input", async (event, ctx) => {
+		// Skip if routing is disabled or this is an extension-generated message
+		if (!config.enabled || event.source === "extension") {
+			return { action: "continue" };
+		}
+
+		// Analyze the input
+		const analysis = analyzeTaskType(event.text);
+		
+		// Only recommend if we have good confidence (>= 30%)
+		if (analysis.type && analysis.confidence >= 30) {
+			const recommendedModel = getRecommendedModel(analysis.type);
+			const taskDescription = getTaskDescription(analysis.type);
+
+			if (recommendedModel && config.notifyOnRecommendation) {
+				const message = `💡 Detected: ${taskDescription} (${analysis.confidence.toFixed(0)}% confidence)
+Recommended model: ${recommendedModel}
+Matched patterns: ${analysis.matches.join(", ")}`;
+
+				ctx.ui.notify(message, "info");
+			}
+		}
+
+		return { action: "continue" };
+	});
+
+	/**
+	 * Register routing configuration command
+	 */
+	pi.registerCommand("routing", {
+		description: "Show or configure smart routing settings",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				// Show current configuration
+				const statusMessage = `Smart Router Configuration:
+
+**Status:** ${config.enabled ? "Enabled" : "Disabled"}
+**Notifications:** ${config.notifyOnRecommendation ? "Enabled" : "Disabled"}
+
+**Model Assignments:**
+- Code tasks: ${config.models.coder}
+- Debug tasks: ${config.models.reasoning}
+- Exploration: ${config.models.fast}  
+- Planning: ${config.models.reasoning}
+
+**Pattern Matching:**
+- Code: ${config.patterns.code.join(", ")}
+- Debug: ${config.patterns.debug.join(", ")}
+- Exploration: ${config.patterns.exploration.join(", ")}
+- Planning: ${config.patterns.planning.join(", ")}
+
+Config file: ${configPath}`;
+
+				ctx.ui.notify(statusMessage, "info");
+				return;
+			}
+
+			const arg = args.trim().toLowerCase();
+
+			switch (arg) {
+				case "enable":
+					config.enabled = true;
+					ctx.ui.notify("Smart routing enabled", "info");
+					break;
+				case "disable":
+					config.enabled = false;
+					ctx.ui.notify("Smart routing disabled", "info");
+					break;
+				case "notify-on":
+					config.notifyOnRecommendation = true;
+					ctx.ui.notify("Routing notifications enabled", "info");
+					break;
+				case "notify-off":
+					config.notifyOnRecommendation = false;
+					ctx.ui.notify("Routing notifications disabled", "info");
+					break;
+				case "reload":
+					await loadConfig();
+					ctx.ui.notify("Routing configuration reloaded", "info");
+					break;
+				case "test":
+					// Test mode - show what would be recommended for different inputs
+					const testInputs = [
+						"implement a new feature",
+						"fix this bug", 
+						"explain how this works",
+						"plan the system architecture"
+					];
+					
+					let testResults = "**Routing Test Results:**\n\n";
+					for (const input of testInputs) {
+						const analysis = analyzeTaskType(input);
+						const model = getRecommendedModel(analysis.type);
+						testResults += `"${input}" → ${analysis.type || 'none'} (${analysis.confidence.toFixed(0)}%) → ${model || 'default'}\n`;
+					}
+					
+					ctx.ui.notify(testResults, "info");
+					break;
+				default:
+					ctx.ui.notify("Usage: /routing [enable|disable|notify-on|notify-off|reload|test]", "warning");
+			}
+		},
+	});
+
+	/**
+	 * Load configuration on session start
+	 */
+	pi.on("session_start", async (_event, _ctx) => {
+		await loadConfig();
+	});
+}