agentuity-vscode 0.0.86

package/src/features/dataExplorer/index.ts

@@ -0,0 +1,362 @@
+import * as vscode from 'vscode';
+import { DataTreeDataProvider, DataTreeItem } from './dataTreeData';
+import { onAuthStatusChanged } from '../../core/auth';
+import { onProjectChanged } from '../../core/project';
+import { getCliClient } from '../../core/cliClient';
+import { openReadonlyDocument } from '../../core/readonlyDocument';
+
+export function registerDataExplorer(context: vscode.ExtensionContext): DataTreeDataProvider {
+	const provider = new DataTreeDataProvider();
+
+	const treeView = vscode.window.createTreeView('agentuity.data', {
+		treeDataProvider: provider,
+		showCollapseAll: true,
+	});
+
+	treeView.onDidChangeSelection(async (e) => {
+		if (e.selection.length === 0) return;
+		const item = e.selection[0];
+
+		if (item.itemType === 'key' && item.parentName) {
+			await openDataValue(item);
+		} else if (item.itemType === 'database') {
+			await copyDatabaseConnectionString(item);
+		} else if (item.itemType === 'vectorResult' && item.parentName) {
+			await openVectorDocument(item);
+		} else if (item.itemType === 'storageFile' && item.parentName) {
+			await openStorageFile(item);
+		} else if (item.itemType === 'streamItem' && item.streamInfo) {
+			await openStreamDetails(item);
+		}
+	});
+
+	const authSub = onAuthStatusChanged(() => {
+		provider.refresh();
+	});
+
+	const projectSub = onProjectChanged(() => {
+		provider.refresh();
+	});
+
+	// Database commands
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.db.copyConnectionString',
+			async (item: DataTreeItem) => {
+				if (item?.itemType === 'database') {
+					await copyDatabaseConnectionString(item);
+				}
+			}
+		)
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.db.openConnectionUri',
+			async (item: DataTreeItem) => {
+				if (item?.itemType !== 'database') return;
+
+				const cli = getCliClient();
+				const name = String(item.label);
+				const result = await cli.getDatabase(name);
+
+				if (!result.success || !result.data) {
+					vscode.window.showErrorMessage(
+						`Failed to get database "${name}": ${result.error ?? 'Unknown error'}`
+					);
+					return;
+				}
+
+				try {
+					await vscode.env.openExternal(vscode.Uri.parse(result.data.url));
+				} catch {
+					vscode.window.showErrorMessage(`Could not open URI: ${result.data.url}`);
+				}
+			}
+		)
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.db.viewLogs', async (item: DataTreeItem) => {
+			if (item?.itemType !== 'database') return;
+
+			const cli = getCliClient();
+			const name = String(item.label);
+
+			await vscode.window.withProgress(
+				{
+					location: vscode.ProgressLocation.Notification,
+					title: `Fetching database logs for "${name}"...`,
+					cancellable: false,
+				},
+				async () => {
+					const result = await cli.getDbLogs(name, { limit: 100 });
+
+					if (!result.success || !result.data) {
+						vscode.window.showErrorMessage(
+							`Failed to fetch database logs: ${result.error ?? 'Unknown error'}`
+						);
+						return;
+					}
+
+					if (result.data.length === 0) {
+						vscode.window.showInformationMessage('No logs found for this database');
+						return;
+					}
+
+					const logContent = result.data
+						.map((log) => {
+							const timestamp = new Date(log.timestamp).toLocaleString();
+							const duration = `${log.duration}ms`;
+							const sql =
+								log.sql.length > 200 ? log.sql.substring(0, 200) + '...' : log.sql;
+							const errorLine = log.error ? `\n  ERROR: ${log.error}` : '';
+							return `[${timestamp}] [${log.command}] (${duration})\n  ${sql}${errorLine}`;
+						})
+						.join('\n\n');
+
+					await openReadonlyDocument(logContent, 'log', `db-logs-${name}`);
+				}
+			);
+		})
+	);
+
+	// Vector commands
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.vector.search', async () => {
+			const cli = getCliClient();
+
+			const namespace = await vscode.window.showInputBox({
+				prompt: 'Vector namespace',
+				placeHolder: 'e.g., default, products, knowledge-base',
+				ignoreFocusOut: true,
+			});
+			if (!namespace) return;
+
+			const query = await vscode.window.showInputBox({
+				prompt: 'Search query (text to find similar vectors)',
+				placeHolder: 'Enter search text...',
+				ignoreFocusOut: true,
+			});
+			if (!query) return;
+
+			const result = await cli.vectorSearch(namespace, query);
+			if (!result.success || !result.data) {
+				vscode.window.showErrorMessage(
+					`Vector search failed: ${result.error ?? 'Unknown error'}`
+				);
+				return;
+			}
+
+			provider.addVectorSearchGroup({
+				id: `${namespace}:${Date.now()}`,
+				label: `"${query}" in ${namespace}`,
+				namespace,
+				query,
+				results: result.data.results ?? [],
+			});
+
+			vscode.window.showInformationMessage(
+				`Found ${result.data.count} result${result.data.count !== 1 ? 's' : ''}`
+			);
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.vector.clearSearches', () => {
+			provider.clearVectorSearchGroups();
+			vscode.window.showInformationMessage('Cleared vector search results');
+		})
+	);
+
+	context.subscriptions.push(treeView, authSub, projectSub, { dispose: () => provider.dispose() });
+
+	return provider;
+}
+
+async function copyDatabaseConnectionString(item: DataTreeItem): Promise<void> {
+	const cli = getCliClient();
+	const name = String(item.label);
+	const result = await cli.getDatabase(name);
+
+	if (!result.success || !result.data) {
+		vscode.window.showErrorMessage(
+			`Failed to get database "${name}": ${result.error ?? 'Unknown error'}`
+		);
+		return;
+	}
+
+	await vscode.env.clipboard.writeText(result.data.url);
+	vscode.window.showInformationMessage(`Copied connection string for "${name}" to clipboard`);
+}
+
+async function openVectorDocument(item: DataTreeItem): Promise<void> {
+	const cli = getCliClient();
+	const key = item.label as string;
+	const namespace = item.parentName!;
+
+	const result = await cli.getVector(namespace, key);
+	if (!result.success || !result.data) {
+		vscode.window.showErrorMessage(`Failed to get vector: ${result.error}`);
+		return;
+	}
+
+	if (!result.data.exists) {
+		vscode.window.showWarningMessage(`Vector "${key}" does not exist`);
+		return;
+	}
+
+	// Build content with metadata at top, then document
+	const lines: string[] = [];
+
+	// Add metadata section
+	lines.push('=== Metadata ===');
+	lines.push(`Key: ${result.data.key}`);
+	lines.push(`ID: ${result.data.id}`);
+	if (result.data.metadata && Object.keys(result.data.metadata).length > 0) {
+		lines.push(`Metadata: ${JSON.stringify(result.data.metadata, null, 2)}`);
+	}
+
+	lines.push('');
+	lines.push('=== Document ===');
+	lines.push('');
+	lines.push(result.data.document);
+
+	await openReadonlyDocument(lines.join('\n'), 'plaintext', `vector-${key}`);
+}
+
+async function openDataValue(item: DataTreeItem): Promise<void> {
+	const cli = getCliClient();
+	const key = item.label as string;
+	const namespace = item.parentName!;
+
+	const result = await cli.getKvValue(namespace, key);
+	if (result.success && result.data) {
+		if (!result.data.exists) {
+			vscode.window.showWarningMessage(`Key "${key}" does not exist`);
+			return;
+		}
+		await openContent(result.data.data, result.data.contentType);
+	} else {
+		vscode.window.showErrorMessage(`Failed to get value: ${result.error}`);
+	}
+}
+
+async function openStorageFile(item: DataTreeItem): Promise<void> {
+	const cli = getCliClient();
+	const filename = item.label as string;
+	const bucket = item.parentName!;
+
+	const result = await cli.getStorageFileMetadata(bucket, filename);
+	if (!result.success || !result.data) {
+		vscode.window.showErrorMessage(`Failed to get file metadata: ${result.error}`);
+		return;
+	}
+
+	const lines: string[] = [];
+	lines.push('=== Storage File Metadata ===');
+	lines.push(`Bucket: ${result.data.bucket}`);
+	lines.push(`Filename: ${result.data.filename}`);
+	if (result.data.size !== undefined) {
+		lines.push(`Size: ${formatFileSize(result.data.size)}`);
+	}
+	if (result.data.contentType) {
+		lines.push(`Content-Type: ${result.data.contentType}`);
+	}
+	if (result.data.lastModified) {
+		lines.push(`Last Modified: ${result.data.lastModified}`);
+	}
+
+	await openReadonlyDocument(lines.join('\n'), 'plaintext', `storage-${filename}`);
+}
+
+async function openStreamDetails(item: DataTreeItem): Promise<void> {
+	const stream = item.streamInfo!;
+
+	const content = JSON.stringify(
+		{
+			id: stream.id,
+			name: stream.name,
+			url: stream.url,
+			sizeBytes: stream.sizeBytes,
+			metadata: stream.metadata,
+		},
+		null,
+		2
+	);
+
+	await openReadonlyDocument(content, 'json', `stream-${stream.name}`);
+}
+
+function formatFileSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+function getLanguageFromContentType(contentType: string): string {
+	const typeMap: Record<string, string> = {
+		'application/json': 'json',
+		'text/html': 'html',
+		'text/xml': 'xml',
+		'application/xml': 'xml',
+		'text/yaml': 'yaml',
+		'application/x-yaml': 'yaml',
+		'text/markdown': 'markdown',
+		'text/css': 'css',
+		'text/javascript': 'javascript',
+		'application/javascript': 'javascript',
+	};
+
+	for (const [type, lang] of Object.entries(typeMap)) {
+		if (contentType.startsWith(type)) {
+			return lang;
+		}
+	}
+
+	if (contentType.startsWith('text/')) {
+		return 'plaintext';
+	}
+
+	return 'plaintext';
+}
+
+async function openContent(data: unknown, contentType: string): Promise<void> {
+	const language = getLanguageFromContentType(contentType);
+	let content: string;
+
+	if (typeof data === 'string') {
+		content = data;
+	} else if (isRawByteObject(data)) {
+		// CLI returns binary data as {0: byte, 1: byte, ...} object
+		content = bytesToString(data as Record<string, number>);
+	} else {
+		content = JSON.stringify(data, null, 2);
+	}
+
+	// Format JSON nicely
+	if (language === 'json' && typeof data !== 'string') {
+		content = JSON.stringify(data, null, 2);
+	}
+
+	await openReadonlyDocument(content, language, 'kv-value');
+}
+
+function isRawByteObject(data: unknown): boolean {
+	if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+		return false;
+	}
+	const keys = Object.keys(data);
+	if (keys.length === 0) return false;
+	// Check if keys are numeric indices
+	return keys.every((k) => /^\d+$/.test(k));
+}
+
+function bytesToString(data: Record<string, number>): string {
+	const indices = Object.keys(data)
+		.map(Number)
+		.sort((a, b) => a - b);
+	const bytes = indices.map((i) => data[String(i)]);
+	return String.fromCharCode(...bytes);
+}

package/src/features/deploymentExplorer/deploymentTreeData.ts

@@ -0,0 +1,238 @@
+import * as vscode from 'vscode';
+import { getCliClient, type Deployment } from '../../core/cliClient';
+import { getAuthStatus } from '../../core/auth';
+import { hasProject } from '../../core/project';
+
+export type DeploymentItemType = 'deployment' | 'info' | 'message';
+
+export class DeploymentTreeItem extends vscode.TreeItem {
+	constructor(
+		public readonly label: string,
+		public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+		public readonly itemType: DeploymentItemType,
+		public readonly deploymentData?: Deployment
+	) {
+		super(label, collapsibleState);
+		this.setIcon();
+		this.contextValue = itemType;
+	}
+
+	private setIcon(): void {
+		switch (this.itemType) {
+			case 'deployment':
+				if (this.deploymentData?.active) {
+					this.iconPath = new vscode.ThemeIcon(
+						'rocket',
+						new vscode.ThemeColor('charts.green')
+					);
+				} else {
+					this.iconPath = new vscode.ThemeIcon('history');
+				}
+				break;
+			case 'info':
+			case 'message':
+				this.iconPath = new vscode.ThemeIcon('info');
+				break;
+		}
+	}
+}
+
+export class DeploymentTreeDataProvider implements vscode.TreeDataProvider<DeploymentTreeItem> {
+	private _onDidChangeTreeData = new vscode.EventEmitter<
+		DeploymentTreeItem | undefined | null | void
+	>();
+	readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+	private deployments: Deployment[] = [];
+	private loading = false;
+	private error: string | undefined;
+
+	refresh(): void {
+		this._onDidChangeTreeData.fire();
+	}
+
+	getTreeItem(element: DeploymentTreeItem): vscode.TreeItem {
+		return element;
+	}
+
+	async getChildren(element?: DeploymentTreeItem): Promise<DeploymentTreeItem[]> {
+		if (element) {
+			if (element.itemType === 'deployment' && element.deploymentData) {
+				return this.getDeploymentDetails(element.deploymentData);
+			}
+			return [];
+		}
+
+		const authStatus = getAuthStatus();
+		if (authStatus.state === 'unknown') {
+			return [
+				new DeploymentTreeItem(
+					'Checking auth...',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		if (authStatus.state === 'cli-missing') {
+			return [
+				new DeploymentTreeItem(
+					'CLI not installed',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		if (authStatus.state === 'unauthenticated') {
+			return [
+				new DeploymentTreeItem(
+					'Not logged in',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		if (!hasProject()) {
+			return [
+				new DeploymentTreeItem(
+					'No project detected',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		if (this.loading) {
+			return [
+				new DeploymentTreeItem('Loading...', vscode.TreeItemCollapsibleState.None, 'message'),
+			];
+		}
+
+		if (this.error) {
+			return [
+				new DeploymentTreeItem(
+					`Error: ${this.error}`,
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		if (this.deployments.length === 0) {
+			await this.loadDeployments();
+		}
+
+		if (this.deployments.length === 0) {
+			return [
+				new DeploymentTreeItem(
+					'No deployments found',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
+			];
+		}
+
+		return this.deployments.map((dep) => {
+			const label = dep.active ? `${dep.id} (active)` : dep.id;
+			const item = new DeploymentTreeItem(
+				label,
+				vscode.TreeItemCollapsibleState.Collapsed,
+				'deployment',
+				dep
+			);
+			item.description = dep.state || '';
+			item.tooltip = this.formatTooltip(dep);
+			return item;
+		});
+	}
+
+	private getDeploymentDetails(dep: Deployment): DeploymentTreeItem[] {
+		const items: DeploymentTreeItem[] = [];
+
+		items.push(
+			new DeploymentTreeItem(
+				`State: ${dep.state || 'unknown'}`,
+				vscode.TreeItemCollapsibleState.None,
+				'info'
+			)
+		);
+		items.push(
+			new DeploymentTreeItem(
+				`Created: ${new Date(dep.createdAt).toLocaleString()}`,
+				vscode.TreeItemCollapsibleState.None,
+				'info'
+			)
+		);
+		if (dep.message) {
+			items.push(
+				new DeploymentTreeItem(
+					`Message: ${dep.message}`,
+					vscode.TreeItemCollapsibleState.None,
+					'info'
+				)
+			);
+		}
+		if (dep.tags.length > 0) {
+			items.push(
+				new DeploymentTreeItem(
+					`Tags: ${dep.tags.join(', ')}`,
+					vscode.TreeItemCollapsibleState.None,
+					'info'
+				)
+			);
+		}
+
+		return items;
+	}
+
+	private formatTooltip(dep: Deployment): string {
+		const lines = [
+			`ID: ${dep.id}`,
+			`State: ${dep.state || 'unknown'}`,
+			`Active: ${dep.active ? 'Yes' : 'No'}`,
+			`Created: ${new Date(dep.createdAt).toLocaleString()}`,
+		];
+		if (dep.message) {
+			lines.push(`Message: ${dep.message}`);
+		}
+		if (dep.tags.length > 0) {
+			lines.push(`Tags: ${dep.tags.join(', ')}`);
+		}
+		return lines.join('\n');
+	}
+
+	private async loadDeployments(): Promise<void> {
+		this.loading = true;
+		this.error = undefined;
+
+		try {
+			const cli = getCliClient();
+			const result = await cli.listDeployments(10);
+
+			if (result.success && result.data) {
+				this.deployments = Array.isArray(result.data) ? result.data : [];
+			} else {
+				this.error = result.error || 'Failed to load deployments';
+				this.deployments = [];
+			}
+		} catch (err) {
+			this.error = err instanceof Error ? err.message : 'Unknown error';
+			this.deployments = [];
+		} finally {
+			this.loading = false;
+		}
+	}
+
+	async forceRefresh(): Promise<void> {
+		this.deployments = [];
+		this.error = undefined;
+		await this.loadDeployments();
+		this.refresh();
+	}
+
+	dispose(): void {
+		this._onDidChangeTreeData.dispose();
+	}
+}

package/src/features/deploymentExplorer/index.ts

@@ -0,0 +1,107 @@
+import * as vscode from 'vscode';
+import { DeploymentTreeDataProvider, DeploymentTreeItem } from './deploymentTreeData';
+import { onAuthStatusChanged } from '../../core/auth';
+import { onProjectChanged } from '../../core/project';
+import { getCliClient } from '../../core/cliClient';
+import { openReadonlyDocument } from '../../core/readonlyDocument';
+
+export function registerDeploymentExplorer(
+	context: vscode.ExtensionContext
+): DeploymentTreeDataProvider {
+	const provider = new DeploymentTreeDataProvider();
+
+	const treeView = vscode.window.createTreeView('agentuity.deployments', {
+		treeDataProvider: provider,
+		showCollapseAll: true,
+	});
+
+	treeView.onDidChangeSelection(async (e) => {
+		if (e.selection.length === 0) return;
+		const item = e.selection[0];
+
+		if (item.itemType === 'deployment' && item.deploymentData) {
+			await showDeploymentDetails(item.deploymentData.id);
+		}
+	});
+
+	const authSub = onAuthStatusChanged(() => {
+		provider.refresh();
+	});
+
+	const projectSub = onProjectChanged(() => {
+		void provider.forceRefresh();
+	});
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.deployment.viewLogs',
+			async (item: DeploymentTreeItem) => {
+				if (item?.deploymentData) {
+					await viewDeploymentLogs(item.deploymentData.id);
+				}
+			}
+		)
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand(
+			'agentuity.deployment.showDetails',
+			async (item: DeploymentTreeItem) => {
+				if (item?.deploymentData) {
+					await showDeploymentDetails(item.deploymentData.id);
+				}
+			}
+		)
+	);
+
+	context.subscriptions.push(treeView, authSub, projectSub, { dispose: () => provider.dispose() });
+
+	return provider;
+}
+
+async function showDeploymentDetails(deploymentId: string): Promise<void> {
+	const cli = getCliClient();
+	const result = await cli.getDeployment(deploymentId);
+
+	if (result.success && result.data) {
+		const content = JSON.stringify(result.data, null, 2);
+		await openReadonlyDocument(content, 'json', `deployment-${deploymentId.substring(0, 8)}`);
+	} else {
+		vscode.window.showErrorMessage(`Failed to get deployment details: ${result.error}`);
+	}
+}
+
+async function viewDeploymentLogs(deploymentId: string): Promise<void> {
+	const cli = getCliClient();
+
+	await vscode.window.withProgress(
+		{
+			location: vscode.ProgressLocation.Notification,
+			title: 'Fetching deployment logs...',
+			cancellable: false,
+		},
+		async () => {
+			const result = await cli.getDeploymentLogs(deploymentId, 100);
+
+			if (result.success && result.data) {
+				if (result.data.length === 0) {
+					vscode.window.showInformationMessage('No logs found for this deployment');
+					return;
+				}
+
+				const logContent = result.data
+					.map((log) => {
+						const timestamp = new Date(log.timestamp).toLocaleString();
+						return `[${timestamp}] [${log.severity}] ${log.body}`;
+					})
+					.join('\n');
+
+				await openReadonlyDocument(logContent, 'log', `deployment-logs-${deploymentId.substring(0, 8)}`);
+			} else {
+				vscode.window.showErrorMessage(`Failed to fetch logs: ${result.error}`);
+			}
+		}
+	);
+}
+
+export { DeploymentTreeDataProvider };