agentuity-vscode 0.0.95 → 0.0.96

package/src/features/chat/contextProvider.ts

@@ -0,0 +1,374 @@
+import * as vscode from 'vscode';
+import { getCliClient } from '../../core/cliClient';
+import { getAuthStatus } from '../../core/auth';
+import { hasProject, getCurrentProject } from '../../core/project';
+import { getDevServerManager } from '../devServer';
+
+interface AgentuityContextItem extends vscode.ChatContextItem {
+	contextType: 'workspace' | 'agents' | 'deployments' | 'devServer' | 'agent-detail';
+	agentId?: string;
+}
+
+const CONTEXT_PROVIDER_ID = 'agentuity.context';
+
+export function registerChatContextProvider(context: vscode.ExtensionContext): void {
+	if (!vscode.chat?.registerChatContextProvider) {
+		return;
+	}
+
+	try {
+		const provider = new AgentuityContextProvider();
+
+		const disposable = vscode.chat.registerChatContextProvider(
+			[
+				{ language: 'typescript' },
+				{ language: 'javascript' },
+				{ pattern: '**/agentuity*.json' },
+			],
+			CONTEXT_PROVIDER_ID,
+			provider
+		);
+
+		context.subscriptions.push(disposable);
+		context.subscriptions.push(provider);
+	} catch {
+		// Chat context provider API not available
+	}
+}
+
+class AgentuityContextProvider implements vscode.ChatContextProvider<AgentuityContextItem> {
+	private readonly _onDidChangeWorkspaceChatContext = new vscode.EventEmitter<void>();
+	readonly onDidChangeWorkspaceChatContext = this._onDidChangeWorkspaceChatContext.event;
+
+	private _disposables: vscode.Disposable[] = [];
+
+	constructor() {
+		const devServer = getDevServerManager();
+		this._disposables.push(
+			devServer.onStateChanged(() => {
+				this._onDidChangeWorkspaceChatContext.fire();
+			})
+		);
+	}
+
+	dispose(): void {
+		this._onDidChangeWorkspaceChatContext.dispose();
+		for (const d of this._disposables) {
+			d.dispose();
+		}
+	}
+
+	async provideWorkspaceChatContext(
+		_token: vscode.CancellationToken
+	): Promise<AgentuityContextItem[]> {
+		if (!hasProject()) {
+			return [];
+		}
+
+		const items: AgentuityContextItem[] = [];
+
+		items.push({
+			icon: new vscode.ThemeIcon('rocket'),
+			label: 'Agentuity Project',
+			modelDescription:
+				'Summary of the Agentuity AI agent project including authentication, agents, deployments, and dev server status',
+			contextType: 'workspace',
+		});
+
+		return items;
+	}
+
+	async provideChatContextExplicit(
+		token: vscode.CancellationToken
+	): Promise<AgentuityContextItem[]> {
+		if (!hasProject()) {
+			return [];
+		}
+
+		const items: AgentuityContextItem[] = [];
+
+		items.push({
+			icon: new vscode.ThemeIcon('rocket'),
+			label: 'Agentuity: Full Project Context',
+			modelDescription:
+				'Complete Agentuity project context including all agents, deployments, data stores, and dev server status',
+			contextType: 'workspace',
+		});
+
+		items.push({
+			icon: new vscode.ThemeIcon('hubot'),
+			label: 'Agentuity: Agents',
+			modelDescription: 'List of all agents in this Agentuity project with their configuration',
+			contextType: 'agents',
+		});
+
+		items.push({
+			icon: new vscode.ThemeIcon('cloud-upload'),
+			label: 'Agentuity: Deployments',
+			modelDescription: 'Recent deployments and their status for this Agentuity project',
+			contextType: 'deployments',
+		});
+
+		items.push({
+			icon: new vscode.ThemeIcon('server-process'),
+			label: 'Agentuity: Dev Server',
+			modelDescription: 'Current dev server status and configuration',
+			contextType: 'devServer',
+		});
+
+		if (!token.isCancellationRequested) {
+			const cli = getCliClient();
+			const agentsResult = await cli.listAgents();
+
+			if (agentsResult.success && agentsResult.data) {
+				for (const agent of agentsResult.data) {
+					items.push({
+						icon: new vscode.ThemeIcon('hubot'),
+						label: `Agentuity Agent: ${agent.name}`,
+						modelDescription: `Details for the "${agent.name}" agent including configuration, tools, and recent sessions`,
+						contextType: 'agent-detail',
+						agentId: agent.id,
+					});
+				}
+			}
+		}
+
+		return items;
+	}
+
+	async resolveChatContext(
+		item: AgentuityContextItem,
+		token: vscode.CancellationToken
+	): Promise<vscode.ChatContextItem> {
+		let value: string;
+
+		switch (item.contextType) {
+			case 'workspace':
+				value = await this.resolveWorkspaceContext(token);
+				break;
+			case 'agents':
+				value = await this.resolveAgentsContext(token);
+				break;
+			case 'deployments':
+				value = await this.resolveDeploymentsContext(token);
+				break;
+			case 'devServer':
+				value = this.resolveDevServerContext();
+				break;
+			case 'agent-detail':
+				value = await this.resolveAgentDetailContext(item.agentId!, token);
+				break;
+			default:
+				value = 'No context available';
+		}
+
+		return {
+			icon: item.icon,
+			label: item.label,
+			modelDescription: item.modelDescription,
+			value,
+		};
+	}
+
+	private async resolveWorkspaceContext(token: vscode.CancellationToken): Promise<string> {
+		const lines: string[] = ['# Agentuity Project Context', ''];
+
+		const authStatus = getAuthStatus();
+		lines.push('## Authentication');
+		if (authStatus.state === 'authenticated' && authStatus.user) {
+			lines.push(`- Status: Authenticated`);
+			lines.push(`- User: ${authStatus.user.firstName} ${authStatus.user.lastName}`);
+		} else {
+			lines.push('- Status: Not authenticated');
+		}
+		lines.push('');
+
+		const project = getCurrentProject();
+		lines.push('## Project');
+		if (project) {
+			lines.push(`- Project ID: ${project.projectId}`);
+			lines.push(`- Organization ID: ${project.orgId}`);
+			if (project.region) {
+				lines.push(`- Region: ${project.region}`);
+			}
+		} else {
+			lines.push('- No project configuration found');
+		}
+		lines.push('');
+
+		lines.push('## Dev Server');
+		const devServer = getDevServerManager();
+		lines.push(`- Status: ${devServer.getState()}`);
+		lines.push('');
+
+		if (!token.isCancellationRequested && hasProject()) {
+			const cli = getCliClient();
+
+			const agentsResult = await cli.listAgents();
+			if (agentsResult.success && agentsResult.data) {
+				lines.push(`## Agents (${agentsResult.data.length})`);
+				for (const agent of agentsResult.data) {
+					lines.push(`- **${agent.name}** (${agent.identifier || agent.id})`);
+					if (agent.description) {
+						lines.push(`  - ${agent.description}`);
+					}
+				}
+				lines.push('');
+			}
+
+			if (!token.isCancellationRequested) {
+				const deploymentsResult = await cli.listDeployments();
+				if (deploymentsResult.success && deploymentsResult.data) {
+					const recent = deploymentsResult.data.slice(0, 5);
+					lines.push(
+						`## Recent Deployments (${recent.length} of ${deploymentsResult.data.length})`
+					);
+					for (const dep of recent) {
+						const status = dep.active ? 'Active' : dep.state || 'Inactive';
+						const date = new Date(dep.createdAt).toLocaleDateString();
+						lines.push(`- ${dep.id.substring(0, 8)} - ${status} (${date})`);
+					}
+					lines.push('');
+				}
+			}
+		}
+
+		return lines.join('\n');
+	}
+
+	private async resolveAgentsContext(_token: vscode.CancellationToken): Promise<string> {
+		if (!hasProject()) {
+			return 'No Agentuity project found in workspace.';
+		}
+
+		const cli = getCliClient();
+		const result = await cli.listAgents();
+
+		if (!result.success || !result.data) {
+			return `Failed to fetch agents: ${result.error || 'Unknown error'}`;
+		}
+
+		const lines: string[] = [`# Agentuity Agents (${result.data.length})`, ''];
+
+		for (const agent of result.data) {
+			lines.push(`## ${agent.name}`);
+			lines.push(`- ID: ${agent.id}`);
+			lines.push(`- Identifier: ${agent.identifier || 'N/A'}`);
+			if (agent.description) {
+				lines.push(`- Description: ${agent.description}`);
+			}
+			if (agent.metadata?.filename) {
+				lines.push(`- Source File: ${agent.metadata.filename}`);
+			}
+			lines.push('');
+		}
+
+		return lines.join('\n');
+	}
+
+	private async resolveDeploymentsContext(_token: vscode.CancellationToken): Promise<string> {
+		if (!hasProject()) {
+			return 'No Agentuity project found in workspace.';
+		}
+
+		const cli = getCliClient();
+		const result = await cli.listDeployments();
+
+		if (!result.success || !result.data) {
+			return `Failed to fetch deployments: ${result.error || 'Unknown error'}`;
+		}
+
+		const lines: string[] = [`# Agentuity Deployments (${result.data.length})`, ''];
+
+		for (const dep of result.data.slice(0, 10)) {
+			const status = dep.active ? 'Active' : dep.state || 'Inactive';
+			const date = new Date(dep.createdAt).toLocaleString();
+			lines.push(`## Deployment ${dep.id.substring(0, 8)}`);
+			lines.push(`- Full ID: ${dep.id}`);
+			lines.push(`- Status: ${status}`);
+			lines.push(`- Created: ${date}`);
+			if (dep.tags?.length) {
+				lines.push(`- Tags: ${dep.tags.join(', ')}`);
+			}
+			lines.push('');
+		}
+
+		if (result.data.length > 10) {
+			lines.push(`*...and ${result.data.length - 10} more deployments*`);
+		}
+
+		return lines.join('\n');
+	}
+
+	private resolveDevServerContext(): string {
+		const devServer = getDevServerManager();
+		const state = devServer.getState();
+
+		const lines: string[] = ['# Agentuity Dev Server', ''];
+		lines.push(`- Status: ${state}`);
+
+		if (state === 'running') {
+			lines.push('- The dev server is currently running and ready to handle requests');
+			lines.push('- Use the Agentuity Workbench to test agents locally');
+		} else if (state === 'error') {
+			lines.push('- The dev server encountered an error');
+			lines.push('- Check the output panel for details');
+		} else {
+			lines.push('- The dev server is not running');
+			lines.push('- Run `agentuity dev` or use the "Start Dev Server" command to start it');
+		}
+
+		return lines.join('\n');
+	}
+
+	private async resolveAgentDetailContext(
+		agentId: string,
+		token: vscode.CancellationToken
+	): Promise<string> {
+		if (!hasProject()) {
+			return 'No Agentuity project found in workspace.';
+		}
+
+		const cli = getCliClient();
+		const agentsResult = await cli.listAgents();
+
+		if (!agentsResult.success || !agentsResult.data) {
+			return `Failed to fetch agent details: ${agentsResult.error || 'Unknown error'}`;
+		}
+
+		const agent = agentsResult.data.find((a) => a.id === agentId);
+		if (!agent) {
+			return `Agent with ID ${agentId} not found.`;
+		}
+
+		const lines: string[] = [`# Agent: ${agent.name}`, ''];
+		lines.push(`- ID: ${agent.id}`);
+		lines.push(`- Identifier: ${agent.identifier || 'N/A'}`);
+		if (agent.description) {
+			lines.push(`- Description: ${agent.description}`);
+		}
+		if (agent.metadata?.filename) {
+			lines.push(`- Source File: ${agent.metadata.filename}`);
+		}
+		lines.push('');
+
+		if (!token.isCancellationRequested) {
+			const sessionsResult = await cli.listSessions({ count: 10 });
+			if (sessionsResult.success && sessionsResult.data) {
+				const recentSessions = sessionsResult.data.slice(0, 5);
+				if (recentSessions.length > 0) {
+					lines.push(`## Recent Sessions (${recentSessions.length})`);
+					for (const session of recentSessions) {
+						const status = session.success ? '✓' : '✗';
+						const time = new Date(session.created_at).toLocaleString();
+						lines.push(
+							`- ${status} ${session.id.substring(0, 8)} - ${time} (${session.trigger})`
+						);
+					}
+				}
+			}
+		}
+
+		return lines.join('\n');
+	}
+}

package/src/features/chat/index.ts

@@ -1,2 +1,4 @@
 export { registerChatParticipant } from './agentuityParticipant';
 export { registerCliTool } from './cliTool';
+export { registerChatContextProvider } from './contextProvider';
+export { registerAgentTools } from './agentTools';

package/src/features/codeLens/index.ts

@@ -1,4 +1,6 @@
 import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
 import { AgentCodeLensProvider, type AgentCodeLensInfo } from './agentCodeLensProvider';
 import { getDevServerManager } from '../devServer';
 import { getCurrentProject } from '../../core/project';
@@ -6,6 +8,59 @@ import { getAgentProvider } from '../agentExplorer';
 
 const SESSIONS_BASE_URL = 'https://app-v1.agentuity.com';
 
+interface BuildMetadataAgent {
+	id: string;
+	name: string;
+	filename: string;
+	identifier?: string;
+}
+
+interface BuildMetadata {
+	agents?: BuildMetadataAgent[];
+}
+
+function findAgentIdFromMetadata(
+	project: { rootPath: string },
+	info: AgentCodeLensInfo
+): string | undefined {
+	try {
+		const metadataPath = path.join(project.rootPath, '.agentuity', 'agentuity.metadata.json');
+		if (!fs.existsSync(metadataPath)) {
+			return undefined;
+		}
+
+		const content = fs.readFileSync(metadataPath, 'utf-8');
+		const metadata: BuildMetadata = JSON.parse(content);
+
+		if (!metadata.agents || metadata.agents.length === 0) {
+			return undefined;
+		}
+
+		// Try to match by identifier first
+		if (info.identifier) {
+			const byIdentifier = metadata.agents.find(
+				(a) => a.name === info.identifier || a.identifier === info.identifier
+			);
+			if (byIdentifier) {
+				return byIdentifier.id;
+			}
+		}
+
+		// Try to match by filename
+		if (info.filePath) {
+			const relativePath = path.relative(project.rootPath, info.filePath);
+			const byFilename = metadata.agents.find((a) => a.filename === relativePath);
+			if (byFilename) {
+				return byFilename.id;
+			}
+		}
+
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 export function registerCodeLens(context: vscode.ExtensionContext): AgentCodeLensProvider {
 	const provider = new AgentCodeLensProvider();
 
@@ -46,8 +101,14 @@ export function registerCodeLens(context: vscode.ExtensionContext): AgentCodeLen
 					.getConfiguration('agentuity')
 					.get<number>('devServer.port', 3500);
 				let url = `http://localhost:${port}/workbench`;
-				if (info.identifier) {
-					url += `?agent=${encodeURIComponent(info.identifier)}`;
+
+				// Get agentId from build metadata
+				const project = getCurrentProject();
+				if (project) {
+					const agentId = findAgentIdFromMetadata(project, info);
+					if (agentId) {
+						url += `?agent=${encodeURIComponent(agentId)}`;
+					}
 				}
 
 				await vscode.env.openExternal(vscode.Uri.parse(url));

package/src/features/customAgents/index.ts

@@ -0,0 +1,252 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+
+const AGENTUITY_DEVELOPER_AGENT = `---
+name: Agentuity Developer
+description: Expert at building and debugging Agentuity AI agents
+tools:
+  - agentuity-agents
+  - agentuity-status
+  - agentuity-sessions
+  - agentuity-logs
+  - agentuity-dev
+  - agentuity-deployments
+---
+
+You are an expert Agentuity developer assistant. You help build, debug, and deploy AI agents using the Agentuity platform.
+
+## Your Capabilities
+
+You have access to specialized Agentuity tools:
+- **#agentuity-agents**: List all agents in the project
+- **#agentuity-status**: Get project status (auth, config, dev server, deployments)
+- **#agentuity-sessions**: View recent agent execution sessions
+- **#agentuity-logs**: Get detailed logs for a specific session
+- **#agentuity-dev**: Control the dev server (start/stop/restart/status)
+- **#agentuity-deployments**: List deployment history
+
+## Guidelines
+
+1. **Before making changes**, always check the current project status with #agentuity-status
+2. **For debugging**, fetch recent sessions and their logs to understand what went wrong
+3. **For testing**, ensure the dev server is running before suggesting tests
+4. **For deployment**, verify authentication status first
+
+## Agentuity Agent Structure
+
+Agentuity agents are TypeScript/JavaScript files that export a handler:
+
+\`\`\`typescript
+import { Agent } from '@agentuity/sdk';
+
+export default new Agent({
+  name: 'my-agent',
+  description: 'What this agent does',
+  async handler(request, context) {
+    // Agent logic here
+    return context.response.text('Hello!');
+  }
+});
+\`\`\`
+
+## Common Tasks
+
+- **Create agent**: Scaffold a new agent file with proper structure
+- **Debug failures**: Fetch session logs and analyze errors
+- **Test locally**: Start dev server and use the Workbench
+- **Deploy**: Run deployment after verifying all tests pass
+`;
+
+const AGENTUITY_REVIEWER_AGENT = `---
+name: Agentuity Reviewer
+description: Reviews Agentuity agent code for best practices and issues
+tools:
+  - agentuity-agents
+  - agentuity-status
+---
+
+You are an Agentuity code reviewer. You review agent implementations for:
+
+## Review Checklist
+
+### Security
+- [ ] No hardcoded secrets or API keys
+- [ ] Input validation on all user inputs
+- [ ] Proper error handling without leaking sensitive info
+
+### Performance
+- [ ] Efficient use of context and memory
+- [ ] Appropriate timeouts for external calls
+- [ ] No blocking operations in hot paths
+
+### Best Practices
+- [ ] Clear agent name and description
+- [ ] Proper TypeScript types
+- [ ] Meaningful error messages
+- [ ] Appropriate logging levels
+
+### Agentuity-Specific
+- [ ] Correct use of \`context.response\` methods
+- [ ] Proper handling of different content types
+- [ ] Appropriate use of tools and integrations
+
+## Review Output Format
+
+Provide feedback in this format:
+1. **Summary**: Overall assessment
+2. **Issues**: List of problems found with severity (Critical/Warning/Info)
+3. **Suggestions**: Improvements to consider
+4. **Code Examples**: Show corrected code where applicable
+`;
+
+const AGENTUITY_DEBUGGER_AGENT = `---
+name: Agentuity Debugger
+description: Diagnoses and fixes issues with Agentuity agents
+tools:
+  - agentuity-agents
+  - agentuity-status
+  - agentuity-sessions
+  - agentuity-logs
+  - agentuity-dev
+---
+
+You are an Agentuity debugging specialist. Your job is to diagnose and fix issues with AI agents.
+
+## Debugging Workflow
+
+1. **Gather Context**
+   - Use #agentuity-status to check project state
+   - Use #agentuity-sessions to find recent failures
+   - Use #agentuity-logs to get detailed error information
+
+2. **Analyze**
+   - Identify error patterns
+   - Check for common issues (auth, network, timeouts)
+   - Review agent code for bugs
+
+3. **Fix**
+   - Propose minimal, targeted fixes
+   - Explain the root cause
+   - Suggest tests to prevent regression
+
+## Common Issues
+
+### Agent Not Responding
+- Check if dev server is running (#agentuity-dev status)
+- Verify agent is properly exported
+- Check for infinite loops or blocking calls
+
+### Authentication Errors
+- Verify #agentuity-status shows authenticated
+- Check API key configuration
+- Ensure correct environment variables
+
+### Timeout Errors
+- Look for slow external API calls
+- Check for missing await statements
+- Review promise handling
+
+### Response Format Errors
+- Verify correct use of context.response methods
+- Check content-type headers
+- Validate JSON serialization
+`;
+
+export async function scaffoldCustomAgents(): Promise<void> {
+	const workspaceFolders = vscode.workspace.workspaceFolders;
+	if (!workspaceFolders || workspaceFolders.length === 0) {
+		vscode.window.showErrorMessage('No workspace folder open. Open a folder first.');
+		return;
+	}
+
+	const rootPath = workspaceFolders[0].uri.fsPath;
+	const agentsDir = path.join(rootPath, '.github', 'agents');
+
+	const agents = [
+		{ name: 'agentuity-developer.agent.md', content: AGENTUITY_DEVELOPER_AGENT },
+		{ name: 'agentuity-reviewer.agent.md', content: AGENTUITY_REVIEWER_AGENT },
+		{ name: 'agentuity-debugger.agent.md', content: AGENTUITY_DEBUGGER_AGENT },
+	];
+
+	const selected = await vscode.window.showQuickPick(
+		[
+			{ label: 'All Agents', description: 'Create all Agentuity custom agents', value: 'all' },
+			{
+				label: 'Agentuity Developer',
+				description: 'Expert at building and debugging agents',
+				value: 'developer',
+			},
+			{
+				label: 'Agentuity Reviewer',
+				description: 'Reviews agent code for best practices',
+				value: 'reviewer',
+			},
+			{
+				label: 'Agentuity Debugger',
+				description: 'Diagnoses and fixes agent issues',
+				value: 'debugger',
+			},
+		],
+		{
+			placeHolder: 'Select which custom agent(s) to create',
+			title: 'Create Agentuity Custom Agents',
+		}
+	);
+
+	if (!selected) {
+		return;
+	}
+
+	const agentsDirUri = vscode.Uri.file(agentsDir);
+
+	try {
+		await vscode.workspace.fs.createDirectory(agentsDirUri);
+	} catch {
+		// Directory might already exist
+	}
+
+	const toCreate =
+		selected.value === 'all'
+			? agents
+			: agents.filter((a) => a.name.includes(selected.value as string));
+
+	const writtenFiles: vscode.Uri[] = [];
+
+	for (const agent of toCreate) {
+		const filePath = vscode.Uri.file(path.join(agentsDir, agent.name));
+
+		try {
+			await vscode.workspace.fs.stat(filePath);
+			const overwrite = await vscode.window.showWarningMessage(
+				`${agent.name} already exists. Overwrite?`,
+				'Yes',
+				'No'
+			);
+			if (overwrite !== 'Yes') {
+				continue;
+			}
+		} catch {
+			// File doesn't exist, proceed
+		}
+
+		await vscode.workspace.fs.writeFile(filePath, Buffer.from(agent.content, 'utf-8'));
+		writtenFiles.push(filePath);
+	}
+
+	if (writtenFiles.length === 0) {
+		vscode.window.showInformationMessage('No custom agents were created.');
+		return;
+	}
+
+	vscode.window.showInformationMessage(
+		`Created ${writtenFiles.length} custom agent${writtenFiles.length > 1 ? 's' : ''} in .github/agents/`
+	);
+
+	await vscode.window.showTextDocument(writtenFiles[0]);
+}
+
+export function registerCustomAgentCommands(context: vscode.ExtensionContext): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.createCustomAgents', () => scaffoldCustomAgents())
+	);
+}