soulclaw-vscode 0.3.0

package/src/context/workspaceTracker.ts

@@ -0,0 +1,229 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+
+export interface WorkspaceContext {
+	workspacePath?: string;
+	currentFile?: string;
+	openFiles: string[];
+	gitBranch?: string;
+	projectType?: string;
+	soulConfig?: any;
+}
+
+export class WorkspaceTracker {
+	private context: WorkspaceContext = {
+		openFiles: []
+	};
+	
+	constructor(private extensionContext: vscode.ExtensionContext) {
+		this.setupEventListeners();
+		this.updateContext();
+	}
+	
+	private setupEventListeners(): void {
+		// Listen for active editor changes
+		vscode.window.onDidChangeActiveTextEditor(this.onActiveEditorChanged.bind(this));
+		
+		// Listen for file saves
+		vscode.workspace.onDidSaveTextDocument(this.onDocumentSaved.bind(this));
+		
+		// Listen for workspace changes
+		vscode.workspace.onDidChangeWorkspaceFolders(this.updateContext.bind(this));
+		
+		// Listen for configuration changes
+		vscode.workspace.onDidChangeConfiguration(this.onConfigurationChanged.bind(this));
+	}
+	
+	private onActiveEditorChanged(editor?: vscode.TextEditor): void {
+		if (editor) {
+			this.context.currentFile = editor.document.fileName;
+		}
+		this.updateOpenFiles();
+	}
+	
+	private onDocumentSaved(document: vscode.TextDocument): void {
+		// If a soul file was saved, reload soul config
+		const fileName = path.basename(document.fileName).toLowerCase();
+		if (fileName === 'soul.json') {
+			this.loadSoulConfig();
+		}
+	}
+	
+	private onConfigurationChanged(event: vscode.ConfigurationChangeEvent): void {
+		if (event.affectsConfiguration('clawsouls')) {
+			this.updateContext();
+		}
+	}
+	
+	private updateContext(): void {
+		this.updateWorkspacePath();
+		this.updateOpenFiles();
+		this.updateProjectType();
+		this.loadSoulConfig();
+		this.updateGitBranch();
+		this.syncProjectToToolsMd();
+	}
+	
+	private updateWorkspacePath(): void {
+		const workspaces = vscode.workspace.workspaceFolders;
+		if (workspaces && workspaces.length > 0) {
+			this.context.workspacePath = workspaces[0].uri.fsPath;
+		} else {
+			this.context.workspacePath = undefined;
+		}
+	}
+	
+	private updateOpenFiles(): void {
+		this.context.openFiles = vscode.window.tabGroups.all
+			.flatMap(group => group.tabs)
+			.map(tab => {
+				if (tab.input instanceof vscode.TabInputText) {
+					return tab.input.uri.fsPath;
+				}
+				return '';
+			})
+			.filter(path => path !== '');
+	}
+	
+	private updateProjectType(): void {
+		if (!this.context.workspacePath) {
+			this.context.projectType = undefined;
+			return;
+		}
+		
+		const rootPath = this.context.workspacePath;
+		
+		// Check for common project types
+		if (this.fileExists(path.join(rootPath, 'package.json'))) {
+			this.context.projectType = 'node';
+		} else if (this.fileExists(path.join(rootPath, 'requirements.txt')) || 
+				   this.fileExists(path.join(rootPath, 'pyproject.toml'))) {
+			this.context.projectType = 'python';
+		} else if (this.fileExists(path.join(rootPath, 'Cargo.toml'))) {
+			this.context.projectType = 'rust';
+		} else if (this.fileExists(path.join(rootPath, 'go.mod'))) {
+			this.context.projectType = 'go';
+		} else if (this.fileExists(path.join(rootPath, 'pom.xml')) || 
+				   this.fileExists(path.join(rootPath, 'build.gradle'))) {
+			this.context.projectType = 'java';
+		} else {
+			this.context.projectType = 'unknown';
+		}
+	}
+	
+	private async loadSoulConfig(): Promise<void> {
+		if (!this.context.workspacePath) {
+			this.context.soulConfig = undefined;
+			return;
+		}
+		
+		try {
+			const soulJsonPath = path.join(this.context.workspacePath, 'soul.json');
+			const document = await vscode.workspace.openTextDocument(soulJsonPath);
+			this.context.soulConfig = JSON.parse(document.getText());
+		} catch (error) {
+			this.context.soulConfig = undefined;
+		}
+	}
+	
+	private updateGitBranch(): void {
+		// For MVP, we'll implement a simple git branch detection
+		// This could be expanded to use the built-in Git extension API
+		if (!this.context.workspacePath) {
+			this.context.gitBranch = undefined;
+			return;
+		}
+		
+		try {
+			const gitHeadPath = path.join(this.context.workspacePath, '.git', 'HEAD');
+			if (this.fileExists(gitHeadPath)) {
+				// This is a simplified implementation
+				// A full implementation would read the HEAD file and resolve refs
+				this.context.gitBranch = 'main'; // Default
+			}
+		} catch (error) {
+			this.context.gitBranch = undefined;
+		}
+	}
+	
+	private fileExists(filePath: string): boolean {
+		try {
+			const stat = vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	
+	/**
+	 * Write current project info to ~/.openclaw/workspace/TOOLS.md
+	 * so the LLM knows the active project path.
+	 */
+	private syncProjectToToolsMd(): void {
+		if (!this.context.workspacePath) return;
+
+		const toolsMdPath = path.join(os.homedir(), '.openclaw', 'workspace', 'TOOLS.md');
+		const sectionHeader = '## Current Project';
+		const newSection = [
+			sectionHeader,
+			`- **Path**: \`${this.context.workspacePath}\``,
+			`- **Name**: ${path.basename(this.context.workspacePath)}`,
+			this.context.projectType ? `- **Type**: ${this.context.projectType}` : '',
+			this.context.gitBranch ? `- **Branch**: ${this.context.gitBranch}` : '',
+			`- **Updated**: ${new Date().toISOString()}`,
+		].filter(Boolean).join('\n');
+
+		try {
+			let content = '';
+			if (fs.existsSync(toolsMdPath)) {
+				content = fs.readFileSync(toolsMdPath, 'utf8');
+			}
+
+			// Replace existing section or append
+			const sectionRegex = /## Current Project[\s\S]*?(?=\n## |\n---|\n$|$)/;
+			if (sectionRegex.test(content)) {
+				content = content.replace(sectionRegex, newSection);
+			} else {
+				content = content.trimEnd() + '\n\n' + newSection + '\n';
+			}
+
+			fs.writeFileSync(toolsMdPath, content, 'utf8');
+		} catch {
+			// Non-fatal — TOOLS.md may not exist yet
+		}
+	}
+
+	public getContext(): WorkspaceContext {
+		return { ...this.context }; // Return a copy to prevent external modification
+	}
+	
+	public getCurrentFile(): string | undefined {
+		return this.context.currentFile;
+	}
+	
+	public getWorkspacePath(): string | undefined {
+		return this.context.workspacePath;
+	}
+	
+	public getSoulConfig(): any {
+		return this.context.soulConfig;
+	}
+	
+	public getProjectType(): string | undefined {
+		return this.context.projectType;
+	}
+	
+	public getRelativePath(absolutePath: string): string {
+		if (!this.context.workspacePath) {
+			return absolutePath;
+		}
+		
+		try {
+			return path.relative(this.context.workspacePath, absolutePath);
+		} catch {
+			return absolutePath;
+		}
+	}
+}

package/src/extension.ts

@@ -0,0 +1,198 @@
+import * as vscode from 'vscode';
+import { GatewayConnection } from './gateway/connection';
+import { ChatPanel } from './ui/chatPanel';
+import { SoulExplorerProvider } from './ui/soulExplorer';
+import { StatusBarManager } from './ui/statusBar';
+import { WorkspaceTracker } from './context/workspaceTracker';
+import { CheckpointProvider } from './ui/checkpointPanel';
+import { SwarmProvider } from './ui/swarmPanel';
+import { ChatHistoryProvider } from './ui/chatHistoryPanel';
+import { setupWizard } from './commands/setup';
+import { GatewayLauncher } from './gateway/launcher';
+
+export let gatewayConnection: GatewayConnection;
+export let gatewayLauncher: GatewayLauncher;
+export let chatPanel: ChatPanel;
+export let workspaceTracker: WorkspaceTracker;
+export let outputChannel: vscode.OutputChannel;
+
+export async function activate(context: vscode.ExtensionContext) {
+	_context = context;
+	// Create output channel (shows in OUTPUT panel Tasks dropdown)
+	outputChannel = vscode.window.createOutputChannel('SoulClaw');
+	context.subscriptions.push(outputChannel);
+	outputChannel.appendLine('SoulClaw v0.1.0 activated');
+	console.log('SoulClaw activated');
+
+	// Register ALL commands first — before anything that might throw
+	context.subscriptions.push(
+		vscode.commands.registerCommand('clawsouls.setup', async () => {
+			// Stop everything cleanly
+			if (gatewayConnection?.currentState === 'connected' || gatewayConnection?.currentState === 'connecting') {
+				gatewayConnection.disconnect();
+			}
+			if (gatewayLauncher?.isRunning()) {
+				gatewayLauncher.stop();
+			}
+			outputChannel.appendLine('Gateway stopped for setup');
+			// Wait for port to free
+			await new Promise(r => setTimeout(r, 2000));
+			
+			const result = await setupWizard();
+			outputChannel.appendLine(`Setup ${result.completed ? 'completed' : 'cancelled'} — starting Gateway...`);
+			await restartGateway();
+		}),
+		vscode.commands.registerCommand('clawsouls.openChat', () => chatPanel?.show()),
+		vscode.commands.registerCommand('clawsouls.clearChat', () => chatPanel?.clearChat()),
+		vscode.commands.registerCommand('clawsouls.switchHistory', () => chatPanel?.switchHistory()),
+		vscode.commands.registerCommand('clawsouls.restartGateway', () => gatewayConnection?.restart()),
+		vscode.commands.registerCommand('clawsouls.connect', async () => {
+			if (gatewayLauncher?.gatewayToken) {
+				gatewayConnection?.setToken(gatewayLauncher.gatewayToken);
+			}
+			outputChannel.appendLine('Manual connect triggered');
+			gatewayConnection?.disconnect();
+			await gatewayConnection?.connect();
+		}),
+		// clawsouls.refresh is registered by SoulExplorerProvider
+		vscode.commands.registerCommand('clawsouls.runScan', async () => {
+			const ws = vscode.workspace.workspaceFolders;
+			if (!ws) { vscode.window.showWarningMessage('No workspace open'); return; }
+			const dir = ws[0].uri.fsPath;
+			const terminal = vscode.window.createTerminal({ name: 'SoulScan', cwd: dir });
+			terminal.show();
+			terminal.sendText('npx clawsouls scan');
+		}),
+		vscode.commands.registerCommand('clawsouls.editSoul', async () => {
+			const ws = vscode.workspace.workspaceFolders;
+			if (!ws) return;
+			const fs = require('fs');
+			const pathMod = require('path');
+			const soulPath = pathMod.join(ws[0].uri.fsPath, 'soul.json');
+			if (!fs.existsSync(soulPath)) {
+				const create = await vscode.window.showInformationMessage('No soul.json found. Create one?', 'Create', 'Cancel');
+				if (create !== 'Create') return;
+				fs.writeFileSync(soulPath, JSON.stringify({
+					specVersion: "0.5",
+					name: "my-soul",
+					displayName: "My Soul",
+					version: "0.1.0",
+					description: "",
+					persona: { identity: "", style: "" }
+				}, null, 2));
+			}
+			const doc = await vscode.workspace.openTextDocument(soulPath);
+			await vscode.window.showTextDocument(doc);
+		}),
+		// clawsouls.initSwarm, joinAgent, pushChanges, pullLatest, mergeBranches → SwarmProvider
+		// clawsouls.createCheckpoint → CheckpointProvider
+	);
+	outputChannel.appendLine('Commands registered');
+
+	try {
+		// Initialize workspace tracker
+		workspaceTracker = new WorkspaceTracker(context);
+		
+		// Initialize Gateway connection
+		gatewayConnection = new GatewayConnection(context);
+		
+		// Initialize chat panel
+		chatPanel = new ChatPanel(context, gatewayConnection);
+		
+		// Initialize status bar
+		const statusBar = new StatusBarManager(context, gatewayConnection);
+		
+		// Initialize Soul Explorer
+		// Initialize Chat History panel
+		const chatHistoryProvider = new ChatHistoryProvider(context);
+		vscode.window.createTreeView('clawsouls.chatHistory', {
+			treeDataProvider: chatHistoryProvider
+		});
+
+		const soulExplorerProvider = new SoulExplorerProvider(context);
+		vscode.window.createTreeView('clawsouls.soulExplorer', {
+			treeDataProvider: soulExplorerProvider
+		});
+
+		// Initialize Swarm panel
+		const swarmProvider = new SwarmProvider(context);
+		vscode.window.createTreeView('clawsouls.swarm', {
+			treeDataProvider: swarmProvider
+		});
+
+		// Initialize Checkpoint panel
+		const checkpointProvider = new CheckpointProvider(context);
+		vscode.window.createTreeView('clawsouls.checkpoints', {
+			treeDataProvider: checkpointProvider
+		});
+
+		// First run: show setup wizard, wait for completion, then start gateway
+		const hasSetup = context.globalState.get('hasSetup', false);
+		if (!hasSetup) {
+			outputChannel.appendLine('First run — opening setup wizard...');
+			const result = await setupWizard();
+			context.globalState.update('hasSetup', true);
+			outputChannel.appendLine(`Setup ${result.completed ? 'completed' : 'skipped'} — starting Gateway...`);
+		}
+
+		// Launch gateway and connect
+		await restartGateway();
+
+		outputChannel.appendLine('Fully initialized');
+	} catch (err) {
+		outputChannel.appendLine(`Activation error: ${err}`);
+		console.error('SoulClaw activation error:', err);
+	}
+}
+
+let _context: vscode.ExtensionContext;
+
+async function restartGateway(): Promise<void> {
+	const config = vscode.workspace.getConfiguration('clawsouls');
+	if (!config.get('autoConnect', true)) return;
+
+	if (!gatewayLauncher) {
+		gatewayLauncher = new GatewayLauncher(_context);
+	}
+
+	outputChannel.appendLine('Ensuring Gateway is running...');
+	await gatewayLauncher.ensureRunning();
+
+	if (gatewayLauncher.gatewayToken) {
+		gatewayConnection.setToken(gatewayLauncher.gatewayToken);
+	}
+
+	outputChannel.appendLine('Connecting to Gateway...');
+	let connected = false;
+	for (let i = 0; i < 6; i++) {
+		try {
+			await gatewayConnection.connect();
+			await new Promise(r => setTimeout(r, 3000));
+			if (gatewayConnection.currentState === 'connected') {
+				connected = true;
+				break;
+			}
+			gatewayConnection.disconnect();
+		} catch {}
+		outputChannel.appendLine(`Connection attempt ${i + 1} failed, retrying in 5s...`);
+		await new Promise(r => setTimeout(r, 5000));
+	}
+	if (!connected) {
+		outputChannel.appendLine('Could not connect to Gateway after retries');
+	}
+}
+
+export function deactivate() {
+	console.log('SoulClaw deactivated');
+	
+	if (gatewayLauncher) {
+		gatewayLauncher.stop();
+	}
+	if (gatewayConnection) {
+		gatewayConnection.disconnect();
+	}
+	
+	if (chatPanel) {
+		chatPanel.dispose();
+	}
+}

package/src/gateway/connection.ts

@@ -0,0 +1,291 @@
+import * as vscode from 'vscode';
+import * as crypto from 'crypto';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const WebSocket = require('ws');
+
+function log(msg: string) {
+	try {
+		const { outputChannel } = require('../extension');
+		outputChannel?.appendLine(msg);
+	} catch {}
+	console.log(msg);
+}
+
+export type ConnectionState = 'idle' | 'connecting' | 'connected' | 'error' | 'disconnected';
+
+export interface GatewayMessage {
+	type: string;
+	data?: any;
+	event?: string;
+	payload?: any;
+	id?: string;
+	ok?: boolean;
+	error?: any;
+	method?: string;
+	params?: any;
+	seq?: number;
+}
+
+export class GatewayConnection {
+	private ws: any = null;
+	private state: ConnectionState = 'idle';
+	private readonly onStateChangedEmitter = new vscode.EventEmitter<ConnectionState>();
+	private readonly onMessageEmitter = new vscode.EventEmitter<GatewayMessage>();
+	private reconnectTimer: NodeJS.Timeout | null = null;
+	private pingTimer: NodeJS.Timeout | null = null;
+	private pendingRequests = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+	
+	public readonly onStateChanged = this.onStateChangedEmitter.event;
+	public readonly onMessage = this.onMessageEmitter.event;
+	
+	constructor(private context: vscode.ExtensionContext) {
+		this.context.subscriptions.push(
+			this.onStateChangedEmitter,
+			this.onMessageEmitter
+		);
+	}
+	
+	public get currentState(): ConnectionState {
+		return this.state;
+	}
+	
+	private token: string = '';
+
+	public setToken(token: string): void {
+		this.token = token;
+	}
+
+	public async connect(): Promise<void> {
+		if (this.state === 'connecting' || this.state === 'connected') {
+			return;
+		}
+		
+		this.setState('connecting');
+		
+		try {
+			const baseUrl = vscode.workspace.getConfiguration('clawsouls').get('gatewayUrl', 'ws://127.0.0.1:18789');
+			
+			log(`WS connecting to: ${baseUrl} (token: ${this.token ? 'yes' : 'no'})`);
+			
+			this.ws = new WebSocket(baseUrl);
+			
+			this.ws.on('open', () => {
+				log('WebSocket open — waiting for connect.challenge...');
+			});
+			
+			this.ws.on('message', (data: Buffer) => {
+				try {
+					const msg = JSON.parse(data.toString());
+					this.handleFrame(msg);
+				} catch (error) {
+					log(`Failed to parse Gateway message: ${error}`);
+				}
+			});
+			
+			this.ws.on('close', (code: number, reason: Buffer) => {
+				log(`WebSocket closed: code=${code} reason=${reason?.toString()}`);
+				this.setState('disconnected');
+				this.stopPing();
+				this.rejectAll(new Error(`WebSocket closed: ${code}`));
+				this.scheduleReconnect();
+			});
+			
+			this.ws.on('error', (error: Error) => {
+				log(`WebSocket error: ${error.message}`);
+				this.setState('error');
+				this.stopPing();
+				this.rejectAll(error);
+				this.scheduleReconnect();
+			});
+			
+		} catch (error: any) {
+			log(`Failed to connect to Gateway: ${error?.message || error}`);
+			this.setState('error');
+			this.scheduleReconnect();
+		}
+	}
+
+	private handleFrame(msg: any): void {
+		if (msg.type === 'event') {
+			if (msg.event === 'connect.challenge') {
+				const nonce = msg.payload?.nonce;
+				log(`Got connect.challenge (nonce: ${nonce ? 'yes' : 'no'})`);
+				this.sendConnectRequest(nonce);
+				return;
+			}
+			// Log all events for debugging
+			log(`Event: ${msg.event} state=${msg.payload?.state || '-'}`);
+			// Forward other events
+			this.onMessageEmitter.fire(msg);
+			return;
+		}
+
+		if (msg.type === 'res') {
+			const pending = this.pendingRequests.get(msg.id);
+			if (pending) {
+				this.pendingRequests.delete(msg.id);
+				if (msg.ok) {
+					pending.resolve(msg.payload);
+				} else {
+					pending.reject(new Error(msg.error?.message || 'Request failed'));
+				}
+			}
+			return;
+		}
+
+		// Forward anything else
+		this.onMessageEmitter.fire(msg);
+	}
+
+	private _sessionKey: string = 'main';
+	public get sessionKey(): string { return this._sessionKey; }
+
+	private async sendConnectRequest(nonce?: string): Promise<void> {
+		const params: any = {
+			minProtocol: 3,
+			maxProtocol: 3,
+			client: {
+				id: 'gateway-client',
+				displayName: 'SoulClaw (VSCode)',
+				version: '0.1.0',
+				platform: process.platform,
+				mode: 'ui'
+			},
+			caps: [],
+			auth: this.token ? { token: this.token } : undefined,
+			role: 'operator',
+			scopes: ['operator.admin']
+		};
+
+		try {
+			const hello = await this.request('connect', params);
+			// Extract session key from hello snapshot
+			const defaults = hello?.snapshot?.sessionDefaults;
+			if (defaults?.mainSessionKey) {
+				this._sessionKey = defaults.mainSessionKey;
+			}
+			log(`Connected! sessionKey=${this._sessionKey}`);
+			this.setState('connected');
+			this.startPing();
+		} catch (err: any) {
+			log(`Connect request failed: ${err.message}`);
+			this.ws?.close(1008, 'connect failed');
+		}
+	}
+
+	private request(method: string, params?: any): Promise<any> {
+		return new Promise((resolve, reject) => {
+			if (!this.ws || this.ws.readyState !== 1 /* OPEN */) {
+				reject(new Error('WebSocket not open'));
+				return;
+			}
+			const id = crypto.randomUUID();
+			const frame = {
+				type: 'req',
+				id,
+				method,
+				params
+			};
+			this.pendingRequests.set(id, { resolve, reject });
+			this.ws.send(JSON.stringify(frame));
+		});
+	}
+
+	private rejectAll(err: Error): void {
+		for (const [, p] of this.pendingRequests) {
+			p.reject(err);
+		}
+		this.pendingRequests.clear();
+	}
+
+	public disconnect(): void {
+		this.clearReconnectTimer();
+		this.stopPing();
+		this.rejectAll(new Error('Disconnected'));
+		
+		if (this.ws) {
+			this.ws.close();
+			this.ws = null;
+		}
+		
+		this.setState('idle');
+	}
+	
+	public async restart(): Promise<void> {
+		vscode.window.showInformationMessage('Restarting Gateway...');
+		this.disconnect();
+		await new Promise(resolve => setTimeout(resolve, 1000));
+		await this.connect();
+	}
+	
+	public sendMessage(message: GatewayMessage): void {
+		if (this.ws && this.state === 'connected') {
+			this.ws.send(JSON.stringify(message));
+		} else {
+			log('Cannot send message: Gateway not connected');
+			vscode.window.showWarningMessage('Gateway not connected. Trying to reconnect...');
+			this.connect();
+		}
+	}
+
+	/** Generic RPC request */
+	public async requestRPC(method: string, params?: any): Promise<any> {
+		return this.request(method, params);
+	}
+
+	/** Send a chat message to the gateway */
+	public async sendChat(text: string, sessionKey?: string): Promise<any> {
+		const key = sessionKey || this._sessionKey;
+		const idempotencyKey = crypto.randomUUID();
+		log(`chat.send → sessionKey=${key}, msg=${text.slice(0, 50)}`);
+		return this.request('chat.send', {
+			sessionKey: key,
+			message: text,
+			idempotencyKey,
+			deliver: false
+		});
+	}
+	
+	private setState(newState: ConnectionState): void {
+		if (this.state !== newState) {
+			this.state = newState;
+			this.onStateChangedEmitter.fire(newState);
+		}
+	}
+	
+	private scheduleReconnect(): void {
+		this.clearReconnectTimer();
+		
+		const config = vscode.workspace.getConfiguration('clawsouls');
+		if (config.get('autoConnect', true)) {
+			this.reconnectTimer = setTimeout(() => {
+				if (this.state !== 'connected') {
+					log('Attempting to reconnect to Gateway...');
+					this.connect();
+				}
+			}, 5000);
+		}
+	}
+	
+	private clearReconnectTimer(): void {
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+	}
+	
+	private startPing(): void {
+		this.pingTimer = setInterval(() => {
+			if (this.ws && this.state === 'connected') {
+				this.ws.ping();
+			}
+		}, 30000);
+	}
+	
+	private stopPing(): void {
+		if (this.pingTimer) {
+			clearInterval(this.pingTimer);
+			this.pingTimer = null;
+		}
+	}
+}