agentuity-vscode 0.0.86

package/src/core/index.ts

@@ -0,0 +1,5 @@
+export * from './cliClient';
+export * from './auth';
+export * from './project';
+export * from './service';
+export * from './baseTreeDataProvider';

package/src/core/project.ts

@@ -0,0 +1,98 @@
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as jsonc from 'jsonc-parser';
+
+export interface AgentuityProject {
+	projectId: string;
+	orgId: string;
+	region?: string;
+	rootPath: string;
+}
+
+let _currentProject: AgentuityProject | undefined;
+const _onProjectChanged = new vscode.EventEmitter<AgentuityProject | undefined>();
+export const onProjectChanged = _onProjectChanged.event;
+
+export function getCurrentProject(): AgentuityProject | undefined {
+	return _currentProject;
+}
+
+export function hasProject(): boolean {
+	return _currentProject !== undefined;
+}
+
+function setProject(project: AgentuityProject | undefined): void {
+	_currentProject = project;
+	_onProjectChanged.fire(project);
+	void vscode.commands.executeCommand('setContext', 'agentuity.hasProject', project !== undefined);
+}
+
+export async function detectProject(): Promise<AgentuityProject | undefined> {
+	const workspaceFolders = vscode.workspace.workspaceFolders;
+
+	if (!workspaceFolders || workspaceFolders.length === 0) {
+		setProject(undefined);
+		return undefined;
+	}
+
+	for (const folder of workspaceFolders) {
+		const configPath = path.join(folder.uri.fsPath, 'agentuity.json');
+
+		if (fs.existsSync(configPath)) {
+			try {
+				const content = fs.readFileSync(configPath, 'utf-8');
+				const config = jsonc.parse(content) as Record<string, unknown>;
+
+				const project: AgentuityProject = {
+					projectId: config.projectId as string,
+					orgId: config.orgId as string,
+					region: config.region as string | undefined,
+					rootPath: folder.uri.fsPath,
+				};
+
+				setProject(project);
+				return project;
+			} catch {
+				// Invalid JSON, continue to next folder
+			}
+		}
+	}
+
+	setProject(undefined);
+	return undefined;
+}
+
+export function requireProject(): boolean {
+	if (!hasProject()) {
+		vscode.window
+			.showWarningMessage(
+				'No Agentuity project found. Open a folder containing agentuity.json.',
+				'Learn More'
+			)
+			.then((action) => {
+				if (action === 'Learn More') {
+					void vscode.env.openExternal(
+						vscode.Uri.parse('https://agentuity.com/docs/getting-started')
+					);
+				}
+			});
+		return false;
+	}
+	return true;
+}
+
+export function watchProjectConfig(context: vscode.ExtensionContext): void {
+	const watcher = vscode.workspace.createFileSystemWatcher('**/agentuity.json');
+
+	watcher.onDidCreate(() => void detectProject());
+	watcher.onDidDelete(() => void detectProject());
+	watcher.onDidChange(() => void detectProject());
+
+	context.subscriptions.push(watcher);
+}
+
+export function disposeProject(): void {
+	_currentProject = undefined;
+	_onProjectChanged.dispose();
+}

package/src/core/readonlyDocument.ts

@@ -0,0 +1,57 @@
+import * as vscode from 'vscode';
+
+const SCHEME = 'agentuity-readonly';
+
+const contentMap = new Map<string, { content: string; language: string }>();
+let counter = 0;
+
+class ReadonlyDocumentProvider implements vscode.TextDocumentContentProvider {
+	provideTextDocumentContent(uri: vscode.Uri): string {
+		const data = contentMap.get(uri.path);
+		return data?.content ?? '';
+	}
+}
+
+let registered = false;
+
+export function registerReadonlyDocumentProvider(context: vscode.ExtensionContext): void {
+	if (registered) return;
+	registered = true;
+
+	context.subscriptions.push(
+		vscode.workspace.registerTextDocumentContentProvider(SCHEME, new ReadonlyDocumentProvider())
+	);
+}
+
+export async function openReadonlyDocument(
+	content: string,
+	language: string,
+	title?: string
+): Promise<vscode.TextEditor> {
+	const id = `${++counter}`;
+	const name = title || `Agentuity-${id}`;
+	const path = `/${name}.${getExtension(language)}`;
+
+	contentMap.set(path, { content, language });
+
+	const uri = vscode.Uri.parse(`${SCHEME}:${path}`);
+	const doc = await vscode.workspace.openTextDocument(uri);
+
+	return vscode.window.showTextDocument(doc, { preview: false });
+}
+
+function getExtension(language: string): string {
+	const extensions: Record<string, string> = {
+		json: 'json',
+		javascript: 'js',
+		typescript: 'ts',
+		html: 'html',
+		css: 'css',
+		xml: 'xml',
+		yaml: 'yaml',
+		markdown: 'md',
+		log: 'log',
+		plaintext: 'txt',
+	};
+	return extensions[language] || 'txt';
+}

package/src/core/service.ts

@@ -0,0 +1,208 @@
+
+import {
+	getCliClient,
+	type CliClient,
+	type Agent,
+	type Session,
+	type Deployment,
+	type DbInfo,
+	type VectorSearchResult,
+} from './cliClient';
+import { getAuthStatus, checkAuth, type AuthStatus } from './auth';
+import { getCurrentProject, hasProject, type AgentuityProject } from './project';
+import { getDevServerManager, type DevServerState } from '../features/devServer';
+
+export interface AgentuityStatus {
+	auth: AuthStatus;
+	project: AgentuityProject | undefined;
+	devServer: DevServerState;
+	isReady: boolean;
+}
+
+export interface ListAgentsResult {
+	success: boolean;
+	agents: Agent[];
+	error?: string;
+}
+
+export interface ListSessionsResult {
+	success: boolean;
+	sessions: Session[];
+	error?: string;
+}
+
+export interface ListDeploymentsResult {
+	success: boolean;
+	deployments: Deployment[];
+	error?: string;
+}
+
+export interface ListDatabasesResult {
+	success: boolean;
+	databases: DbInfo[];
+	error?: string;
+}
+
+export interface VectorSearchResultData {
+	success: boolean;
+	results: VectorSearchResult[];
+	error?: string;
+}
+
+export class AgentuityService {
+	private cli: CliClient;
+
+	constructor() {
+		this.cli = getCliClient();
+	}
+
+	getStatus(): AgentuityStatus {
+		const auth = getAuthStatus();
+		const project = getCurrentProject();
+		const devServer = getDevServerManager().getState();
+
+		return {
+			auth,
+			project,
+			devServer,
+			isReady: auth.state === 'authenticated' && project !== undefined,
+		};
+	}
+
+	async refreshAuth(): Promise<AuthStatus> {
+		return checkAuth();
+	}
+
+	hasProject(): boolean {
+		return hasProject();
+	}
+
+	getProject(): AgentuityProject | undefined {
+		return getCurrentProject();
+	}
+
+	isDevServerRunning(): boolean {
+		return getDevServerManager().getState() === 'running';
+	}
+
+	async ensureDevServerRunning(): Promise<boolean> {
+		const devServer = getDevServerManager();
+		if (devServer.getState() === 'running') {
+			return true;
+		}
+
+		await devServer.start();
+
+		return new Promise((resolve) => {
+			const timeout = setTimeout(() => {
+				resolve(devServer.getState() === 'running');
+			}, 5000);
+
+			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);
+				}
+			});
+		});
+	}
+
+	async listAgents(): Promise<ListAgentsResult> {
+		const result = await this.cli.listAgents();
+		return {
+			success: result.success,
+			agents: result.data || [],
+			error: result.error,
+		};
+	}
+
+	async listSessions(count = 10): Promise<ListSessionsResult> {
+		const result = await this.cli.listSessions({ count });
+		return {
+			success: result.success,
+			sessions: result.data || [],
+			error: result.error,
+		};
+	}
+
+	async listDeployments(): Promise<ListDeploymentsResult> {
+		const result = await this.cli.listDeployments();
+		return {
+			success: result.success,
+			deployments: result.data || [],
+			error: result.error,
+		};
+	}
+
+	async listDatabases(): Promise<ListDatabasesResult> {
+		const result = await this.cli.listDatabases();
+		return {
+			success: result.success,
+			databases: result.data?.databases || [],
+			error: result.error,
+		};
+	}
+
+	async listKvNamespaces(): Promise<{ success: boolean; namespaces: string[]; error?: string }> {
+		const result = await this.cli.listKvNamespaces();
+		return {
+			success: result.success,
+			namespaces: result.data || [],
+			error: result.error,
+		};
+	}
+
+	async listKvKeys(
+		namespace: string
+	): Promise<{ success: boolean; keys: string[]; error?: string }> {
+		const result = await this.cli.listKvKeys(namespace);
+		return {
+			success: result.success,
+			keys: result.data?.keys || [],
+			error: result.error,
+		};
+	}
+
+	async vectorSearch(namespace: string, query: string): Promise<VectorSearchResultData> {
+		const result = await this.cli.vectorSearch(namespace, query);
+		return {
+			success: result.success,
+			results: result.data?.results || [],
+			error: result.error,
+		};
+	}
+
+	async getSessionLogs(
+		sessionId: string
+	): Promise<{ success: boolean; logs: Array<{ body: string; severity: string; timestamp: string }>; error?: string }> {
+		const result = await this.cli.getSessionLogs(sessionId);
+		return {
+			success: result.success,
+			logs: result.data || [],
+			error: result.error,
+		};
+	}
+
+	async getCliHelp(): Promise<string> {
+		const result = await this.cli.getAiPrompt();
+		return result.success && result.data ? result.data : '';
+	}
+}
+
+let _service: AgentuityService | undefined;
+
+export function getAgentuityService(): AgentuityService {
+	if (!_service) {
+		_service = new AgentuityService();
+	}
+	return _service;
+}
+
+export function disposeAgentuityService(): void {
+	_service = undefined;
+}

package/src/extension.ts

@@ -0,0 +1,260 @@
+import * as vscode from 'vscode';
+import {
+	getCliClient,
+	disposeCliClient,
+	checkAuth,
+	promptLogin,
+	disposeAuth,
+	detectProject,
+	watchProjectConfig,
+	disposeProject,
+	requireAuth,
+} from './core';
+import { registerReadonlyDocumentProvider } from './core/readonlyDocument';
+import { registerAgentExplorer } from './features/agentExplorer';
+import { registerDataExplorer } from './features/dataExplorer';
+import { registerDeploymentExplorer } from './features/deploymentExplorer';
+import { registerDevServerCommands } from './features/devServer';
+import { registerWorkbenchCommands } from './features/workbench';
+import { registerChatParticipant, registerCliTool } from './features/chat';
+import { registerCodeLens } from './features/codeLens';
+
+const outputChannel = vscode.window.createOutputChannel('Agentuity');
+
+function log(message: string): void {
+	outputChannel.appendLine(`[${new Date().toISOString()}] ${message}`);
+}
+
+export async function activate(context: vscode.ExtensionContext): Promise<void> {
+	log('Extension activating...');
+
+	watchProjectConfig(context);
+	registerReadonlyDocumentProvider(context);
+
+	const project = await detectProject();
+	log(`Project: ${project ? project.projectId : 'none'}`);
+
+	const authStatus = await checkAuth();
+	log(`Auth: ${authStatus.state}${authStatus.user ? ` (${authStatus.user.email})` : ''}`);
+
+	if (authStatus.state === 'cli-missing' || authStatus.state === 'unauthenticated') {
+		void promptLogin();
+	}
+
+	registerAuthCommands(context);
+	registerAiCommands(context);
+	registerSetupCommands(context);
+	registerDeployCommand(context);
+
+	const walkthroughShown = context.globalState.get('agentuity.walkthroughShown', false);
+	if (!walkthroughShown) {
+		await context.globalState.update('agentuity.walkthroughShown', true);
+		void vscode.commands.executeCommand(
+			'workbench.action.openWalkthrough',
+			'agentuity.agentuity#gettingStarted',
+			false
+		);
+	}
+
+	const agentProvider = registerAgentExplorer(context);
+	const dataProvider = registerDataExplorer(context);
+	const deploymentProvider = registerDeploymentExplorer(context);
+
+	registerRefreshCommands(context, {
+		agents: agentProvider,
+		data: dataProvider,
+		deployments: deploymentProvider,
+	});
+
+	context.subscriptions.push({
+		dispose: () => {
+			agentProvider.dispose();
+			dataProvider.dispose();
+			deploymentProvider.dispose();
+		},
+	});
+
+	registerDevServerCommands(context);
+	registerWorkbenchCommands(context);
+	registerChatParticipant(context);
+	registerCliTool(context);
+	registerCodeLens(context);
+
+	log('Extension activated');
+}
+
+function registerAuthCommands(context: vscode.ExtensionContext): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.login', () => {
+			const terminal = vscode.window.createTerminal('Agentuity Login');
+			terminal.sendText('agentuity auth login');
+			terminal.show();
+
+			vscode.window
+				.showInformationMessage(
+					'Complete login in the terminal, then refresh the extension.',
+					'Refresh'
+				)
+				.then((action) => {
+					if (action === 'Refresh') {
+						void checkAuth();
+					}
+				});
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.logout', async () => {
+			const cli = getCliClient();
+			const result = await cli.exec(['auth', 'logout']);
+
+			if (result.success) {
+				vscode.window.showInformationMessage('Logged out of Agentuity');
+				await checkAuth();
+			} else {
+				vscode.window.showErrorMessage(`Logout failed: ${result.error}`);
+			}
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.whoami', async () => {
+			const cli = getCliClient();
+			const result = await cli.whoami();
+
+			if (result.success && result.data) {
+				const user = result.data;
+				vscode.window.showInformationMessage(
+					`Logged in as: ${user.name || user.email} (${user.email})`
+				);
+			} else {
+				vscode.window.showWarningMessage('Not logged in to Agentuity');
+			}
+		})
+	);
+}
+
+function registerAiCommands(context: vscode.ExtensionContext): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.getAiCapabilities', async () => {
+			if (!(await requireAuth())) {
+				return undefined;
+			}
+
+			const cli = getCliClient();
+			const result = await cli.getAiCapabilities();
+
+			if (result.success) {
+				return result.data;
+			} else {
+				vscode.window.showErrorMessage(`Failed to get capabilities: ${result.error}`);
+				return undefined;
+			}
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.getAiSchema', async () => {
+			if (!(await requireAuth())) {
+				return undefined;
+			}
+
+			const cli = getCliClient();
+			const result = await cli.getAiSchema();
+
+			if (result.success) {
+				return result.data;
+			} else {
+				vscode.window.showErrorMessage(`Failed to get schema: ${result.error}`);
+				return undefined;
+			}
+		})
+	);
+}
+
+function registerSetupCommands(context: vscode.ExtensionContext): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.installCli', () => {
+			void vscode.env.openExternal(
+				vscode.Uri.parse('https://agentuity.dev/Introduction/getting-started')
+			);
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.createProject', () => {
+			const terminal = vscode.window.createTerminal('Agentuity');
+			terminal.sendText('agentuity project new');
+			terminal.show();
+		})
+	);
+}
+
+function registerDeployCommand(context: vscode.ExtensionContext): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.deploy', async () => {
+			if (!(await requireAuth())) {
+				return;
+			}
+
+			const answer = await vscode.window.showWarningMessage(
+				'Deploy to Agentuity Cloud?',
+				{ modal: true },
+				'Deploy'
+			);
+
+			if (answer !== 'Deploy') {
+				return;
+			}
+
+			const terminal = vscode.window.createTerminal('Agentuity Deploy');
+			terminal.sendText('agentuity cloud deploy');
+			terminal.show();
+		})
+	);
+}
+
+function registerRefreshCommands(
+	context: vscode.ExtensionContext,
+	providers: {
+		agents: ReturnType<typeof registerAgentExplorer>;
+		data: ReturnType<typeof registerDataExplorer>;
+		deployments: ReturnType<typeof registerDeploymentExplorer>;
+	}
+): void {
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.refresh', async () => {
+			await checkAuth();
+			await detectProject();
+			providers.agents.forceRefresh();
+			providers.data.refresh();
+			providers.deployments.forceRefresh();
+			vscode.window.showInformationMessage('Agentuity refreshed');
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.agents.refresh', () => {
+			void providers.agents.forceRefresh();
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.deployments.refresh', () => {
+			void providers.deployments.forceRefresh();
+		})
+	);
+
+	context.subscriptions.push(
+		vscode.commands.registerCommand('agentuity.data.refresh', () => {
+			providers.data.refresh();
+		})
+	);
+}
+
+export function deactivate(): void {
+	disposeCliClient();
+	disposeAuth();
+	disposeProject();
+	outputChannel.dispose();
+}