agentuity-vscode 0.0.86

package/src/features/chat/cliTool.ts

@@ -0,0 +1,91 @@
+import * as vscode from 'vscode';
+import { getCliClient } from '../../core/cliClient';
+
+const DESTRUCTIVE_PATTERNS = [
+	/^auth\s+logout/i,
+	/\bdelete\b/i,
+	/\bremove\b/i,
+	/\bdestroy\b/i,
+	/\bdrop\b/i,
+];
+
+const CONFIRMATION_PATTERNS = [/^cloud\s+deploy/i];
+
+export interface CliToolInput {
+	command: string;
+	jsonOutput?: boolean;
+}
+
+export class AgentuityCliTool implements vscode.LanguageModelTool<CliToolInput> {
+	async invoke(
+		options: vscode.LanguageModelToolInvocationOptions<CliToolInput>,
+		_token: vscode.CancellationToken
+	): Promise<vscode.LanguageModelToolResult> {
+		const { command, jsonOutput = true } = options.input;
+
+		if (!command || command.trim() === '') {
+			throw new Error('Command is required. Provide an agentuity CLI subcommand.');
+		}
+
+		for (const pattern of DESTRUCTIVE_PATTERNS) {
+			if (pattern.test(command)) {
+				throw new Error(
+					`Destructive command detected: "${command}". This command is not allowed via the AI assistant. Please run it manually in the terminal.`
+				);
+			}
+		}
+
+		const args = command.split(/\s+/).filter((arg) => arg.length > 0);
+
+		const cli = getCliClient();
+		const result = await cli.exec(args, { format: jsonOutput ? 'json' : 'text' });
+
+		if (!result.success) {
+			throw new Error(`CLI command failed: ${result.error}`);
+		}
+
+		const output =
+			typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
+
+		return new vscode.LanguageModelToolResult([new vscode.LanguageModelTextPart(output)]);
+	}
+
+	async prepareInvocation(
+		options: vscode.LanguageModelToolInvocationPrepareOptions<CliToolInput>,
+		_token: vscode.CancellationToken
+	): Promise<vscode.PreparedToolInvocation | undefined> {
+		const { command } = options.input;
+
+		for (const pattern of CONFIRMATION_PATTERNS) {
+			if (pattern.test(command)) {
+				return {
+					invocationMessage: `Run deployment command: \`agentuity ${command}\``,
+					confirmationMessages: {
+						title: 'Deploy to Agentuity Cloud',
+						message: new vscode.MarkdownString(
+							`This will deploy your project to Agentuity Cloud.\n\n\`\`\`bash\nagentuity ${command}\n\`\`\`\n\nDo you want to continue?`
+						),
+					},
+				};
+			}
+		}
+
+		return {
+			invocationMessage: `Running: \`agentuity ${command}\``,
+		};
+	}
+}
+
+export function registerCliTool(context: vscode.ExtensionContext): void {
+	if (!vscode.lm?.registerTool) {
+		return;
+	}
+
+	try {
+		const tool = new AgentuityCliTool();
+		const disposable = vscode.lm.registerTool('agentuity_run_cli', tool);
+		context.subscriptions.push(disposable);
+	} catch {
+		// LM API not available
+	}
+}

package/src/features/chat/index.ts

@@ -0,0 +1,2 @@
+export { registerChatParticipant } from './agentuityParticipant';
+export { registerCliTool } from './cliTool';

package/src/features/codeLens/agentCodeLensProvider.ts

@@ -0,0 +1,116 @@
+import * as vscode from 'vscode';
+
+export class AgentCodeLensProvider implements vscode.CodeLensProvider {
+	private _onDidChangeCodeLenses = new vscode.EventEmitter<void>();
+	readonly onDidChangeCodeLenses = this._onDidChangeCodeLenses.event;
+
+	// Match both: createAgent('name', { and createAgent({
+	private createAgentRegex = /createAgent\s*\(/g;
+
+	refresh(): void {
+		this._onDidChangeCodeLenses.fire();
+	}
+
+	provideCodeLenses(
+		document: vscode.TextDocument,
+		_token: vscode.CancellationToken
+	): vscode.CodeLens[] | Thenable<vscode.CodeLens[]> {
+		const codeLenses: vscode.CodeLens[] = [];
+		const text = document.getText();
+
+		let match: RegExpExecArray | null;
+		this.createAgentRegex.lastIndex = 0;
+
+		while ((match = this.createAgentRegex.exec(text)) !== null) {
+			const position = document.positionAt(match.index);
+			const range = new vscode.Range(position, position);
+
+			const agentInfo = this.extractAgentInfo(document, match.index);
+
+			codeLenses.push(
+				new vscode.CodeLens(range, {
+					title: '$(play) Open in Workbench',
+					command: 'agentuity.codeLens.openInWorkbench',
+					arguments: [agentInfo],
+					tooltip: 'Open this agent in the Agentuity Workbench (requires dev server running)',
+				})
+			);
+
+			codeLenses.push(
+				new vscode.CodeLens(range, {
+					title: '$(pulse) View Sessions',
+					command: 'agentuity.codeLens.viewSessions',
+					arguments: [agentInfo],
+					tooltip: 'View sessions for this agent',
+				})
+			);
+		}
+
+		return codeLenses;
+	}
+
+	private extractAgentInfo(
+		document: vscode.TextDocument,
+		startIndex: number
+	): AgentCodeLensInfo {
+		const text = document.getText();
+		const afterCreateAgent = text.substring(startIndex);
+
+		let name: string | undefined;
+		let identifier: string | undefined;
+
+		// Try to match createAgent('identifier', { pattern (first arg is the identifier)
+		const firstArgMatch = afterCreateAgent.match(/createAgent\s*\(\s*['"`]([^'"`]+)['"`]/);
+		if (firstArgMatch) {
+			identifier = firstArgMatch[1];
+			name = firstArgMatch[1];
+		}
+
+		// Also check for name property in the config object
+		const nameMatch = afterCreateAgent.match(/name\s*:\s*['"`]([^'"`]+)['"`]/);
+		if (nameMatch) {
+			name = nameMatch[1];
+		}
+
+		// Check for explicit identifier property (overrides first arg)
+		const identifierMatch = afterCreateAgent.match(/identifier\s*:\s*['"`]([^'"`]+)['"`]/);
+		if (identifierMatch) {
+			identifier = identifierMatch[1];
+		}
+
+		// Fallback: derive identifier from file path
+		if (!identifier) {
+			const relativePath = vscode.workspace.asRelativePath(document.uri);
+			const pathParts = relativePath.split('/');
+			const agentsIndex = pathParts.indexOf('agents');
+			if (agentsIndex !== -1 && agentsIndex < pathParts.length - 1) {
+				const agentPathParts = pathParts.slice(agentsIndex + 1);
+				const lastPart = agentPathParts[agentPathParts.length - 1];
+				if (lastPart === 'agent.ts' || lastPart === 'index.ts') {
+					agentPathParts.pop();
+				} else {
+					agentPathParts[agentPathParts.length - 1] = lastPart.replace(/\.(ts|js)$/, '');
+				}
+				if (agentPathParts.length > 0) {
+					identifier = agentPathParts.join('/');
+				}
+			}
+		}
+
+		return {
+			name,
+			identifier,
+			filePath: document.uri.fsPath,
+		};
+	}
+
+	dispose(): void {
+		this._onDidChangeCodeLenses.dispose();
+	}
+}
+
+export interface AgentCodeLensInfo {
+	name?: string;
+	identifier?: string;
+	filePath: string;
+}

package/src/features/codeLens/index.ts

@@ -0,0 +1,132 @@
+import * as vscode from 'vscode';
+import { AgentCodeLensProvider, type AgentCodeLensInfo } from './agentCodeLensProvider';
+import { getDevServerManager } from '../devServer';
+import { getCurrentProject } from '../../core/project';
+import { getAgentProvider } from '../agentExplorer';
+
+const SESSIONS_BASE_URL = 'https://app-v1.agentuity.com';
+
+export function registerCodeLens(context: vscode.ExtensionContext): AgentCodeLensProvider {
+	const provider = new AgentCodeLensProvider();
+
+	const selector: vscode.DocumentSelector = [
+		{ language: 'typescript', scheme: 'file' },
+		{ language: 'javascript', scheme: 'file' },
+	];
+
+	context.subscriptions.push(
+		vscode.languages.registerCodeLensProvider(selector, provider)
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.codeLens.openInWorkbench',
+			async (info: AgentCodeLensInfo) => {
+				const devServer = getDevServerManager();
+
+				if (devServer.getState() !== 'running') {
+					const action = await vscode.window.showWarningMessage(
+						'Dev server is not running. Start it to open the Workbench.',
+						'Start Dev Server',
+						'Cancel'
+					);
+
+					if (action === 'Start Dev Server') {
+						await vscode.commands.executeCommand('agentuity.dev.start');
+						await waitForDevServer(5000);
+
+						if (devServer.getState() !== 'running') {
+							vscode.window.showErrorMessage('Failed to start dev server');
+							return;
+						}
+					} else {
+						return;
+					}
+				}
+
+				const port = vscode.workspace.getConfiguration('agentuity').get<number>('devServer.port', 3500);
+				let url = `http://localhost:${port}/workbench`;
+				if (info.identifier) {
+					url += `?agent=${encodeURIComponent(info.identifier)}`;
+				}
+
+				await vscode.env.openExternal(vscode.Uri.parse(url));
+			}
+		)
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.codeLens.viewSessions',
+			async (info: AgentCodeLensInfo) => {
+				const project = getCurrentProject();
+				if (!project) {
+					vscode.window.showErrorMessage('No Agentuity project found');
+					return;
+				}
+
+				if (!info.identifier) {
+					vscode.window.showErrorMessage('Could not determine agent identifier');
+					return;
+				}
+
+				const agentProvider = getAgentProvider();
+				if (!agentProvider) {
+					vscode.window.showErrorMessage('Agent explorer not initialized');
+					return;
+				}
+
+				const agent = agentProvider.findAgentByIdentifier(info.identifier);
+
+				if (!agent) {
+					vscode.window.showWarningMessage(
+						`Agent "${info.identifier}" not found. Deploy your project first to view sessions.`
+					);
+					return;
+				}
+
+				const url = `${SESSIONS_BASE_URL}/projects/${project.projectId}/sessions?agent=${agent.id}`;
+				await vscode.env.openExternal(vscode.Uri.parse(url));
+			}
+		)
+	);
+
+	const devServer = getDevServerManager();
+	devServer.onStateChanged(() => {
+		provider.refresh();
+	});
+
+	context.subscriptions.push({ dispose: () => provider.dispose() });
+
+	return provider;
+}
+
+async function waitForDevServer(timeoutMs: number): Promise<boolean> {
+	const devServer = getDevServerManager();
+
+	return new Promise((resolve) => {
+		if (devServer.getState() === 'running') {
+			resolve(true);
+			return;
+		}
+
+		const timeout = setTimeout(() => {
+			disposable.dispose();
+			resolve(false);
+		}, timeoutMs);
+
+		const disposable = devServer.onStateChanged((state) => {
+			if (state === 'running') {
+				clearTimeout(timeout);
+				disposable.dispose();
+				resolve(true);
+			} else if (state === 'error' || state === 'stopped') {
+				clearTimeout(timeout);
+				disposable.dispose();
+				resolve(false);
+			}
+		});
+	});
+}
+
+export { AgentCodeLensProvider, type AgentCodeLensInfo };