@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/services/vfs-client.js

@@ -0,0 +1,348 @@
+/**
+ * VFS Client Service
+ * Handles all HTTP interactions with a virtual filesystem (VFS) backend
+ */
+import { VFSError } from '../types';
+const DEFAULT_BASE_URL = '/api/vfs';
+const DEFAULT_LOCK_TTL = 300000; // 5 minutes
+const DEFAULT_MAX_RETRIES = 30;
+const DEFAULT_RETRY_DELAY = 100; // 100ms
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+// ============================================================================
+// Configuration
+// ============================================================================
+let config = {
+    baseUrl: DEFAULT_BASE_URL,
+    timeout: DEFAULT_TIMEOUT,
+    lockTTL: DEFAULT_LOCK_TTL,
+    maxReconnectAttempts: 10
+};
+export function configure(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getConfig() {
+    return { ...config };
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function request(path, options = {}) {
+    const url = `${config.baseUrl}${path}`;
+    const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new VFSError(error.message || `HTTP ${response.status}`, mapStatusToErrorCode(response.status), error);
+        }
+        // Handle empty responses
+        const text = await response.text();
+        if (!text) {
+            return undefined;
+        }
+        return JSON.parse(text);
+    }
+    catch (err) {
+        if (err instanceof VFSError)
+            throw err;
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new VFSError('Request timeout', 'NETWORK_ERROR');
+        }
+        throw new VFSError(err instanceof Error ? err.message : 'Unknown error', 'NETWORK_ERROR', err);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function mapStatusToErrorCode(status) {
+    switch (status) {
+        case 404:
+            return 'FILE_NOT_FOUND';
+        case 403:
+            return 'PERMISSION_DENIED';
+        case 409:
+            return 'VERSION_CONFLICT';
+        case 423:
+            return 'FILE_LOCKED';
+        default:
+            return 'NETWORK_ERROR';
+    }
+}
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ============================================================================
+// Workspace Operations
+// ============================================================================
+export async function getWorkspace(workspaceId) {
+    return request(`/workspaces/${workspaceId}`);
+}
+export async function updateWorkspace(workspaceId, updates) {
+    return request(`/workspaces/${workspaceId}`, {
+        method: 'PATCH',
+        body: JSON.stringify(updates)
+    });
+}
+export async function listWorkspaces() {
+    return request('/workspaces');
+}
+// ============================================================================
+// File Operations
+// ============================================================================
+export async function readFile(workspaceId, path) {
+    return request(`/files?workspace=${workspaceId}&path=${encodeURIComponent(path)}`);
+}
+export async function writeFile(workspaceId, path, content, version) {
+    return request(`/files`, {
+        method: 'PUT',
+        body: JSON.stringify({ workspace: workspaceId, path, content, version })
+    });
+}
+export async function deleteFile(workspaceId, path, version) {
+    return request(`/files`, {
+        method: 'DELETE',
+        body: JSON.stringify({ workspace: workspaceId, path, version })
+    });
+}
+export async function renameFile(workspaceId, oldPath, newPath, version) {
+    return request(`/files/rename`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId, oldPath, newPath, version })
+    });
+}
+export async function getFileInfo(workspaceId, path) {
+    return request(`/files/info?workspace=${workspaceId}&path=${encodeURIComponent(path)}`);
+}
+export async function copyFile(workspaceId, sourcePath, destPath) {
+    return request(`/files/copy`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId, source: sourcePath, destination: destPath })
+    });
+}
+// ============================================================================
+// Directory Operations
+// ============================================================================
+export async function readDirectory(workspaceId, path) {
+    return request(`/dirs?workspace=${workspaceId}&path=${encodeURIComponent(path)}`);
+}
+export async function createDirectory(workspaceId, path) {
+    return request(`/dirs`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId, path })
+    });
+}
+export async function deleteDirectory(workspaceId, path, recursive = false) {
+    return request(`/dirs`, {
+        method: 'DELETE',
+        body: JSON.stringify({ workspace: workspaceId, path, recursive })
+    });
+}
+// ============================================================================
+// Quick Operations (Auto-Transaction)
+// ============================================================================
+export async function quickWriteFile(workspaceId, path, content) {
+    return request(`/quick/files`, {
+        method: 'PUT',
+        body: JSON.stringify({ workspace: workspaceId, path, content })
+    });
+}
+export async function quickDeleteFile(workspaceId, path) {
+    return request(`/quick/files`, {
+        method: 'DELETE',
+        body: JSON.stringify({ workspace: workspaceId, path })
+    });
+}
+// ============================================================================
+// Transaction Operations
+// ============================================================================
+export async function beginTransaction(workspaceId) {
+    const result = await request(`/tx/begin`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId })
+    });
+    return result.transactionId;
+}
+export async function commitTransaction(transactionId, operations) {
+    return request(`/tx/${transactionId}/commit`, {
+        method: 'POST',
+        body: JSON.stringify({ operations })
+    });
+}
+export async function rollbackTransaction(transactionId) {
+    return request(`/tx/${transactionId}/rollback`, {
+        method: 'POST'
+    });
+}
+export async function getTransaction(transactionId) {
+    return request(`/tx/${transactionId}`);
+}
+/**
+ * Execute multiple operations in a transaction
+ * Auto-commits on success, auto-rollbacks on failure
+ */
+export async function executeTransaction(workspaceId, operations) {
+    const txId = await beginTransaction(workspaceId);
+    try {
+        const result = await commitTransaction(txId, operations);
+        return result;
+    }
+    catch (err) {
+        await rollbackTransaction(txId).catch(() => {
+            // Rollback failed, transaction will auto-expire
+        });
+        throw err;
+    }
+}
+// ============================================================================
+// Lock Operations
+// ============================================================================
+export async function acquireLock(workspaceId, path, holder, options = {}) {
+    const { ttl = config.lockTTL ?? DEFAULT_LOCK_TTL, maxRetries = DEFAULT_MAX_RETRIES, retryDelay = DEFAULT_RETRY_DELAY, purpose } = options;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const lock = await request(`/locks`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    workspace: workspaceId,
+                    path,
+                    holder,
+                    ttl,
+                    purpose
+                })
+            });
+            return lock;
+        }
+        catch (err) {
+            if (err instanceof VFSError && err.code === 'FILE_LOCKED') {
+                lastError = err;
+                await sleep(retryDelay);
+                continue;
+            }
+            // Other error, throw immediately
+            throw err;
+        }
+    }
+    throw lastError || new VFSError('Failed to acquire lock after retries', 'FILE_LOCKED');
+}
+export async function releaseLock(workspaceId, path, holder) {
+    return request(`/locks`, {
+        method: 'DELETE',
+        body: JSON.stringify({ workspace: workspaceId, path, holder })
+    });
+}
+export async function refreshLock(workspaceId, path, holder) {
+    return request(`/locks/refresh`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId, path, holder })
+    });
+}
+export async function getLockInfo(workspaceId, path) {
+    try {
+        return await request(`/locks?workspace=${workspaceId}&path=${encodeURIComponent(path)}`);
+    }
+    catch (err) {
+        if (err instanceof VFSError && err.code === 'FILE_NOT_FOUND') {
+            return null; // No lock exists
+        }
+        throw err;
+    }
+}
+export async function listLocks(workspaceId) {
+    return request(`/locks?workspace=${workspaceId}`);
+}
+export async function forceReleaseLock(workspaceId, path, adminId) {
+    return request(`/locks/force`, {
+        method: 'DELETE',
+        body: JSON.stringify({ workspace: workspaceId, path, admin: adminId })
+    });
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Execute a function with a file lock
+ * Automatically acquires, executes, and releases
+ */
+export async function withLock(workspaceId, path, holder, fn, options) {
+    const lock = await acquireLock(workspaceId, path, holder, options);
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock(workspaceId, path, holder).catch(() => {
+            // Lock release failed, will auto-expire
+        });
+    }
+}
+/**
+ * Batch file operations with automatic locking and transaction
+ */
+export async function batchUpdate(workspaceId, holder, updates) {
+    // Acquire all locks first
+    const locks = [];
+    try {
+        for (const update of updates) {
+            const lock = await acquireLock(workspaceId, update.path, holder);
+            locks.push(lock);
+        }
+        // Execute transaction
+        const operations = updates.map((u) => ({
+            type: 'update',
+            path: u.path,
+            content: u.content,
+            version: u.version ?? 0
+        }));
+        return await executeTransaction(workspaceId, operations);
+    }
+    finally {
+        // Release all locks
+        for (const lock of locks) {
+            await releaseLock(workspaceId, lock.path, holder).catch(() => { });
+        }
+    }
+}
+/**
+ * Read file with automatic version tracking
+ */
+export async function readFileWithVersion(workspaceId, path) {
+    const file = await readFile(workspaceId, path);
+    return {
+        content: typeof file.content === 'string' ? file.content : '',
+        version: file.info.version
+    };
+}
+/**
+ * Write file with version conflict detection
+ */
+export async function safeWriteFile(workspaceId, path, content, expectedVersion) {
+    return writeFile(workspaceId, path, content, expectedVersion);
+}
+export async function searchFiles(workspaceId, options) {
+    return request(`/search`, {
+        method: 'POST',
+        body: JSON.stringify({ workspace: workspaceId, ...options })
+    });
+}
+// ============================================================================
+// Health Check
+// ============================================================================
+export async function healthCheck() {
+    const start = Date.now();
+    try {
+        await request('/health');
+        return { status: 'ok', latency: Date.now() - start };
+    }
+    catch {
+        return { status: 'error', latency: Date.now() - start };
+    }
+}

package/dist/stores/agents.svelte.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Agents store using Svelte 5 runes
+ * Manages multi-agent coordination and activity tracking
+ *
+ * Note: Svelte 5 modules cannot directly export $derived values.
+ * We use getter functions to expose reactive derived state.
+ */
+import type { Agent, AgentStatus, AgentTask, AgentProgress, TeamEvent, AgentActivity, AgentCursor, AgentFilter, AgentType, VFSEvent } from '../types';
+export declare function getAgents(): Agent[];
+export declare function getAgent(agentId: string): Agent | undefined;
+export declare function getOnlineAgents(): Agent[];
+export declare function getOfflineAgents(): Agent[];
+export declare function getBusyAgents(): Agent[];
+export declare function getStalledAgents(): Agent[];
+export declare function getAgentsByType(type: AgentType): Agent[];
+export declare function getAgentsWorkingOnFile(filePath: string): Agent[];
+export declare function getEvents(): TeamEvent[];
+export declare function getActivities(): AgentActivity[];
+export declare function getActivitiesForAgent(agentId: string): AgentActivity[];
+export declare function getRecentActivities(count: number): AgentActivity[];
+export declare function getCursors(): AgentCursor[];
+export declare function getCursor(agentId: string): AgentCursor | undefined;
+export declare function getCursorsForFile(filePath: string): AgentCursor[];
+export declare function getSelectedAgent(): Agent | undefined;
+export declare function getFilter(): AgentFilter;
+export declare function getConnected(): boolean;
+export declare function getError(): string | null;
+export declare function getFilteredAgents(): Agent[];
+export declare function getActiveTasksCount(): number;
+export declare function getTotalProgress(): number;
+export declare function getAgentCount(): number;
+export declare function getOnlineCount(): number;
+export declare const agents: {
+    readonly current: Agent[];
+};
+export declare const onlineAgents: {
+    readonly current: Agent[];
+};
+export declare const busyAgents: {
+    readonly current: Agent[];
+};
+export declare const events: {
+    readonly current: TeamEvent[];
+};
+export declare const activities: {
+    readonly current: AgentActivity[];
+};
+export declare const cursors: {
+    readonly current: AgentCursor[];
+};
+export declare const selectedAgent: {
+    readonly current: Agent | undefined;
+};
+export declare const filter: {
+    readonly current: AgentFilter;
+};
+export declare const connected: {
+    readonly current: boolean;
+};
+export declare const error: {
+    readonly current: string | null;
+};
+export declare function addAgent(agent: Agent): void;
+export declare function removeAgent(agentId: string): void;
+export declare function updateAgent(agentId: string, updates: Partial<Agent>): void;
+export declare function setAgentStatus(agentId: string, status: AgentStatus): void;
+export declare function setAgentTask(agentId: string, task: AgentTask | undefined): void;
+export declare function updateAgentProgress(agentId: string, progress: Partial<AgentProgress>): void;
+export declare function completeAgentTask(agentId: string, result: 'success' | 'failure' | 'partial', summary: string): void;
+export declare function updateCursor(cursor: AgentCursor): void;
+export declare function removeCursor(agentId: string): void;
+export declare function clearCursorsForFile(filePath: string): void;
+export declare function addEvent(event: TeamEvent): void;
+export declare function onTeamEvent(type: TeamEvent['type'] | '*', handler: (event: TeamEvent) => void): () => void;
+export declare function addActivity(activity: AgentActivity): void;
+export declare function selectAgent(agentId: string | null): void;
+export declare function setFilter(filter: AgentFilter): void;
+export declare function clearActivities(): void;
+export declare function clearEvents(): void;
+export declare function handleVFSEvent(event: VFSEvent): void;
+export declare function setConnected(connected: boolean): void;
+export declare function setError(error: string | null): void;
+export declare function clearError(): void;
+export declare function reset(): void;
+export declare function addMockAgents(): void;