more-compute 0.4.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

frontend/hooks/useInlineDiff.ts

@@ -0,0 +1,269 @@
+"use client";
+
+import { useEffect, useRef, useCallback } from "react";
+import * as monaco from "monaco-editor";
+import * as Diff from "diff";
+import type { ProposedEdit } from "@/types/claude";
+
+interface UseInlineDiffProps {
+  editor: monaco.editor.IStandaloneCodeEditor | null;
+  cellIndex: number;
+  pendingEdit: ProposedEdit | undefined;
+  onApply: (editId: string) => void;
+  onReject: (editId: string) => void;
+}
+
+interface DiffDecoration {
+  range: monaco.Range;
+  options: monaco.editor.IModelDecorationOptions;
+}
+
+/**
+ * Hook to manage inline diff decorations in Monaco editor.
+ * Shows red/green line highlighting for proposed edits with accept/reject buttons.
+ */
+export function useInlineDiff({
+  editor,
+  cellIndex,
+  pendingEdit,
+  onApply,
+  onReject,
+}: UseInlineDiffProps) {
+  const decorationsRef = useRef<string[]>([]);
+  const widgetRef = useRef<monaco.editor.IContentWidget | null>(null);
+  const commandsRef = useRef<monaco.IDisposable[]>([]);
+
+  // Clear decorations and widgets
+  const clearDecorations = useCallback(() => {
+    if (!editor) return;
+
+    // Remove decorations
+    if (decorationsRef.current.length > 0) {
+      editor.deltaDecorations(decorationsRef.current, []);
+      decorationsRef.current = [];
+    }
+
+    // Remove widget
+    if (widgetRef.current) {
+      editor.removeContentWidget(widgetRef.current);
+      widgetRef.current = null;
+    }
+
+    // Dispose commands
+    commandsRef.current.forEach((d) => d.dispose());
+    commandsRef.current = [];
+  }, [editor]);
+
+  // Apply diff decorations
+  const applyDiffDecorations = useCallback(() => {
+    if (!editor || !pendingEdit || pendingEdit.status !== "pending") {
+      clearDecorations();
+      return;
+    }
+
+    const model = editor.getModel();
+    if (!model) return;
+
+    // Clear previous decorations first
+    clearDecorations();
+
+    // Compute diff between original and new code
+    const originalCode = pendingEdit.originalCode || "";
+    const newCode = pendingEdit.newCode || "";
+    const changes = Diff.diffLines(originalCode, newCode);
+
+    const decorations: DiffDecoration[] = [];
+
+    // Track line numbers in the new code (what's displayed)
+    let newLineNumber = 1;
+    // Track position for removed line indicators
+    let removedLinesBuffer: number[] = [];
+
+    // Calculate decorations based on diff
+    for (const change of changes) {
+      // Count actual lines (handle trailing newline edge case)
+      const lines = change.value.split('\n');
+      const lineCount = change.value.endsWith('\n') ? lines.length - 1 : lines.length;
+
+      if (change.added) {
+        // Added lines - green background (these lines exist in the editor)
+        for (let i = 0; i < lineCount; i++) {
+          const targetLine = newLineNumber + i;
+          if (targetLine <= model.getLineCount()) {
+            decorations.push({
+              range: new monaco.Range(targetLine, 1, targetLine, 1),
+              options: {
+                isWholeLine: true,
+                className: "monaco-diff-added",
+                glyphMarginClassName: "monaco-diff-added-glyph",
+                overviewRuler: {
+                  color: "#22c55e",
+                  position: monaco.editor.OverviewRulerLane.Left,
+                },
+              },
+            });
+          }
+        }
+        // Flush any pending removed lines indicator at this position
+        if (removedLinesBuffer.length > 0) {
+          const removedCount = removedLinesBuffer.reduce((a, b) => a + b, 0);
+          if (newLineNumber <= model.getLineCount()) {
+            decorations.push({
+              range: new monaco.Range(newLineNumber, 1, newLineNumber, 1),
+              options: {
+                isWholeLine: false,
+                glyphMarginClassName: "monaco-diff-removed-glyph",
+                overviewRuler: {
+                  color: "#ef4444",
+                  position: monaco.editor.OverviewRulerLane.Left,
+                },
+              },
+            });
+          }
+          removedLinesBuffer = [];
+        }
+        newLineNumber += lineCount;
+      } else if (change.removed) {
+        // Removed lines - track for indicator (these lines don't exist in editor)
+        removedLinesBuffer.push(lineCount);
+      } else {
+        // Unchanged lines - flush any removed indicator first
+        if (removedLinesBuffer.length > 0) {
+          const removedCount = removedLinesBuffer.reduce((a, b) => a + b, 0);
+          if (newLineNumber <= model.getLineCount()) {
+            decorations.push({
+              range: new monaco.Range(newLineNumber, 1, newLineNumber, 1),
+              options: {
+                isWholeLine: false,
+                glyphMarginClassName: "monaco-diff-removed-glyph",
+                overviewRuler: {
+                  color: "#ef4444",
+                  position: monaco.editor.OverviewRulerLane.Left,
+                },
+              },
+            });
+          }
+          removedLinesBuffer = [];
+        }
+        newLineNumber += lineCount;
+      }
+    }
+
+    // Handle any remaining removed lines at the end
+    if (removedLinesBuffer.length > 0) {
+      const lastLine = Math.min(newLineNumber, model.getLineCount());
+      if (lastLine >= 1) {
+        decorations.push({
+          range: new monaco.Range(lastLine, 1, lastLine, 1),
+          options: {
+            isWholeLine: false,
+            glyphMarginClassName: "monaco-diff-removed-glyph",
+            overviewRuler: {
+              color: "#ef4444",
+              position: monaco.editor.OverviewRulerLane.Left,
+            },
+          },
+        });
+      }
+    }
+
+    // Apply decorations
+    decorationsRef.current = editor.deltaDecorations(
+      [],
+      decorations.map((d) => ({
+        range: d.range,
+        options: d.options,
+      }))
+    );
+
+    // Add content widget for accept/reject buttons at the top of the editor
+    const widget: monaco.editor.IContentWidget = {
+      getId: () => `claude-diff-widget-${cellIndex}`,
+      getDomNode: () => {
+        const container = document.createElement("div");
+        container.className = "diff-widget-overlay";
+
+        const keepBtn = document.createElement("button");
+        keepBtn.className = "diff-widget-btn accept";
+        keepBtn.innerHTML = `<span>Keep</span> <kbd>Cmd+Y</kbd>`;
+        keepBtn.onclick = () => onApply(pendingEdit.id);
+
+        const undoBtn = document.createElement("button");
+        undoBtn.className = "diff-widget-btn reject";
+        undoBtn.innerHTML = `<span>Undo</span> <kbd>Cmd+N</kbd>`;
+        undoBtn.onclick = () => onReject(pendingEdit.id);
+
+        container.appendChild(keepBtn);
+        container.appendChild(undoBtn);
+
+        return container;
+      },
+      getPosition: () => ({
+        position: { lineNumber: 1, column: 1 },
+        preference: [
+          monaco.editor.ContentWidgetPositionPreference.ABOVE,
+          monaco.editor.ContentWidgetPositionPreference.BELOW,
+        ],
+      }),
+    };
+
+    editor.addContentWidget(widget);
+    widgetRef.current = widget;
+
+    // Add keyboard shortcuts
+    const acceptCommand = editor.addCommand(
+      monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyY,
+      () => onApply(pendingEdit.id)
+    );
+    const rejectCommand = editor.addCommand(
+      monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyN,
+      () => onReject(pendingEdit.id)
+    );
+
+    // Note: addCommand returns a command ID (string), not disposable
+    // We'll track via decoration cleanup instead
+  }, [editor, pendingEdit, cellIndex, onApply, onReject, clearDecorations]);
+
+  // Effect to apply/update decorations when edit changes
+  useEffect(() => {
+    applyDiffDecorations();
+
+    return () => {
+      clearDecorations();
+    };
+  }, [applyDiffDecorations, clearDecorations]);
+
+  // Return whether there's an active diff
+  return {
+    hasDiff: pendingEdit?.status === "pending",
+    clearDecorations,
+  };
+}
+
+/**
+ * Utility function to compute unified diff for display
+ */
+export function computeUnifiedDiff(
+  originalCode: string,
+  newCode: string
+): { type: "added" | "removed" | "unchanged"; content: string }[] {
+  const changes = Diff.diffLines(originalCode, newCode);
+  const result: { type: "added" | "removed" | "unchanged"; content: string }[] =
+    [];
+
+  for (const change of changes) {
+    const lines = change.value.split("\n").filter((l) => l !== "");
+
+    for (const line of lines) {
+      if (change.added) {
+        result.push({ type: "added", content: line });
+      } else if (change.removed) {
+        result.push({ type: "removed", content: line });
+      } else {
+        result.push({ type: "unchanged", content: line });
+      }
+    }
+  }
+
+  return result;
+}

frontend/lib/api.ts

@@ -171,8 +171,13 @@ export interface GpuAvailabilityParams {
   regions?: string[];
   gpu_count?: number;
   gpu_type?: string;
-  socket?: string;
-  security?: string;
+  // RunPod specific
+  secure_cloud?: boolean;
+  community_cloud?: boolean;
+  // Vast.ai specific
+  verified?: boolean;
+  min_reliability?: number;
+  min_gpu_ram?: number;
 }
 
 export interface PodsListParams {
@@ -187,18 +192,26 @@ export interface GpuAvailability {
   socket: string;
   provider: string;
   gpuCount: number;
-  gpuMemory: number;
-  security: string;
-  prices: {
+  gpuMemory?: number;
+  security?: string;
+  // Prime Intellect format
+  prices?: {
     onDemand: number;
     communityPrice: number | null;
     isVariable: boolean | null;
     currency: string;
   };
-  images: string[];
+  // Lambda Labs / other providers format
+  priceHr?: number;
+  gpuName?: string;
+  regionDescription?: string;
+  vcpus?: number;
+  memoryGb?: number;
+  storageGb?: number;
+  images?: string[];
   region: string | null;
-  dataCenter: string | null;
-  country: string | null;
+  dataCenter?: string | null;
+  country?: string | null;
   disk?: {
     minCount: number | null;
     defaultCount: number | null;
@@ -299,11 +312,22 @@ export async function fetchGpuAvailability(
   if (params?.gpu_type) {
     queryParams.set("gpu_type", params.gpu_type);
   }
-  if (params?.socket) {
-    queryParams.set("socket", params.socket);
+  // RunPod specific
+  if (params?.secure_cloud !== undefined) {
+    queryParams.set("secure_cloud", String(params.secure_cloud));
+  }
+  if (params?.community_cloud !== undefined) {
+    queryParams.set("community_cloud", String(params.community_cloud));
+  }
+  // Vast.ai specific
+  if (params?.verified !== undefined) {
+    queryParams.set("verified", String(params.verified));
   }
-  if (params?.security) {
-    queryParams.set("security", params.security);
+  if (params?.min_reliability !== undefined) {
+    queryParams.set("min_reliability", String(params.min_reliability));
+  }
+  if (params?.min_gpu_ram !== undefined) {
+    queryParams.set("min_gpu_ram", String(params.min_gpu_ram));
   }
 
   const query = queryParams.toString();
@@ -471,3 +495,290 @@ export async function fixIndentation(code: string): Promise<string> {
   const data = await response.json();
   return data.fixed_code;
 }
+
+// ============================================================================
+// Multi-Provider GPU API Types & Functions
+// ============================================================================
+
+export interface ProviderInfo {
+  name: string;
+  display_name: string;
+  api_key_env_name: string;
+  supports_ssh: boolean;
+  dashboard_url: string;
+  configured: boolean;
+  is_active: boolean;
+}
+
+export interface ProvidersListResponse {
+  providers: ProviderInfo[];
+  active_provider: string | null;
+}
+
+export interface ProviderConfigRequest {
+  api_key: string;
+  make_active?: boolean;
+}
+
+export interface ProviderConfigResponse {
+  configured: boolean;
+  provider: string;
+  is_active: boolean;
+}
+
+export interface SetActiveProviderRequest {
+  provider: string;
+}
+
+export interface SetActiveProviderResponse {
+  active_provider: string;
+  success: boolean;
+}
+
+// Extended pod response with provider info
+export interface PodResponseWithProvider extends PodResponse {
+  provider?: string;
+}
+
+// Extended connection status with provider info
+export interface PodConnectionStatusWithProvider extends PodConnectionStatus {
+  provider?: string;
+}
+
+/**
+ * Fetch list of all available GPU providers with their configuration status.
+ */
+export async function fetchGpuProviders(): Promise<ProvidersListResponse> {
+  const response = await fetch("/api/gpu/providers");
+  if (!response.ok) {
+    throw new Error(`Failed to fetch GPU providers: ${response.status}`);
+  }
+  return response.json();
+}
+
+/**
+ * Configure a GPU provider with an API key.
+ */
+export async function configureGpuProvider(
+  providerName: string,
+  config: ProviderConfigRequest
+): Promise<ProviderConfigResponse> {
+  const response = await fetch(`/api/gpu/providers/${providerName}/config`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(config),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to configure provider: ${response.status} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Set the active GPU provider.
+ */
+export async function setActiveGpuProvider(
+  providerName: string
+): Promise<SetActiveProviderResponse> {
+  const response = await fetch("/api/gpu/providers/active", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ provider: providerName }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to set active provider: ${response.status} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Fetch GPU availability from a specific provider.
+ */
+export async function fetchProviderGpuAvailability(
+  providerName: string,
+  params?: GpuAvailabilityParams
+): Promise<GpuAvailabilityResponse & { provider: string }> {
+  const queryParams = new URLSearchParams();
+
+  if (params?.regions) {
+    params.regions.forEach((region) => queryParams.append("regions", region));
+  }
+  if (params?.gpu_count !== undefined) {
+    queryParams.set("gpu_count", String(params.gpu_count));
+  }
+  if (params?.gpu_type) {
+    queryParams.set("gpu_type", params.gpu_type);
+  }
+  // RunPod specific
+  if (params?.secure_cloud !== undefined) {
+    queryParams.set("secure_cloud", String(params.secure_cloud));
+  }
+  if (params?.community_cloud !== undefined) {
+    queryParams.set("community_cloud", String(params.community_cloud));
+  }
+  // Vast.ai specific
+  if (params?.verified !== undefined) {
+    queryParams.set("verified", String(params.verified));
+  }
+  if (params?.min_reliability !== undefined) {
+    queryParams.set("min_reliability", String(params.min_reliability));
+  }
+  if (params?.min_gpu_ram !== undefined) {
+    queryParams.set("min_gpu_ram", String(params.min_gpu_ram));
+  }
+
+  const query = queryParams.toString();
+  const url = query
+    ? `/api/gpu/providers/${providerName}/availability?${query}`
+    : `/api/gpu/providers/${providerName}/availability`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch GPU availability from ${providerName}: ${response.status}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Fetch pods from a specific provider.
+ */
+export async function fetchProviderPods(
+  providerName: string,
+  params?: PodsListParams
+): Promise<PodsListResponse & { provider: string }> {
+  const queryParams = new URLSearchParams();
+
+  if (params?.status) {
+    queryParams.set("status", params.status);
+  }
+  if (params?.limit !== undefined) {
+    queryParams.set("limit", String(params.limit));
+  }
+  if (params?.offset !== undefined) {
+    queryParams.set("offset", String(params.offset));
+  }
+
+  const query = queryParams.toString();
+  const url = query
+    ? `/api/gpu/providers/${providerName}/pods?${query}`
+    : `/api/gpu/providers/${providerName}/pods`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch pods from ${providerName}: ${response.status}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Create a pod with a specific provider.
+ */
+export async function createProviderPod(
+  providerName: string,
+  podRequest: CreatePodRequest
+): Promise<PodResponseWithProvider> {
+  const response = await fetch(`/api/gpu/providers/${providerName}/pods`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(podRequest),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to create pod with ${providerName}: ${response.status} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Fetch a specific pod from a provider.
+ */
+export async function fetchProviderPod(
+  providerName: string,
+  podId: string
+): Promise<PodResponseWithProvider> {
+  const response = await fetch(
+    `/api/gpu/providers/${providerName}/pods/${podId}`
+  );
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch pod from ${providerName}: ${response.status}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Delete a pod from a specific provider.
+ */
+export async function deleteProviderPod(
+  providerName: string,
+  podId: string
+): Promise<DeletePodResponse & { provider: string }> {
+  const response = await fetch(
+    `/api/gpu/providers/${providerName}/pods/${podId}`,
+    {
+      method: "DELETE",
+    }
+  );
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to delete pod from ${providerName}: ${response.status} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}
+
+/**
+ * Connect to a pod from a specific provider.
+ */
+export async function connectToProviderPod(
+  providerName: string,
+  podId: string
+): Promise<PodConnectionResponse & { provider: string }> {
+  const response = await fetch(
+    `/api/gpu/providers/${providerName}/pods/${podId}/connect`,
+    {
+      method: "POST",
+    }
+  );
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to connect to pod: ${response.status} - ${errorText}`
+    );
+  }
+
+  return response.json();
+}

frontend/lib/settings.ts

@@ -111,11 +111,13 @@ export type MetricsCollectionMode = 'persistent' | 'on-demand';
 export type NotebookSettings = {
   theme: keyof typeof THEMES;
   metricsCollectionMode: MetricsCollectionMode;
+  claudeAutoPreview: boolean; // Whether to auto-preview Claude's code edits in cells
 };
 
 export const DEFAULT_SETTINGS: NotebookSettings = {
   theme: 'light',
   metricsCollectionMode: 'on-demand', // Only collect metrics when popup is open to save memory
+  claudeAutoPreview: false, // OFF by default - users must explicitly enable auto-preview
 };
 
 const STORAGE_KEY = 'morecompute-settings';
@@ -134,6 +136,9 @@ export function loadSettings(): NotebookSettings {
       metricsCollectionMode: parsed.metricsCollectionMode === 'on-demand' || parsed.metricsCollectionMode === 'persistent'
         ? parsed.metricsCollectionMode
         : DEFAULT_SETTINGS.metricsCollectionMode,
+      claudeAutoPreview: typeof parsed.claudeAutoPreview === 'boolean'
+        ? parsed.claudeAutoPreview
+        : DEFAULT_SETTINGS.claudeAutoPreview,
     };
 
     // Save cleaned settings back to localStorage

frontend/lib/websocket-native.ts

@@ -14,7 +14,6 @@ export class WebSocketService {
         this.ws = new WebSocket(this.url);
         
         this.ws.onopen = () => {
-          console.log('Connected to server');
           this.reconnectAttempts = 0;
           this.emit('connect', null);
           resolve();
@@ -26,8 +25,7 @@ export class WebSocketService {
           reject(error);
         };
 
-        this.ws.onclose = (ev) => {
-          console.log('Disconnected from server', { code: ev.code, reason: ev.reason, wasClean: ev.wasClean });
+        this.ws.onclose = () => {
           this.emit('disconnect', null);
           this.handleDisconnect();
         };
@@ -35,10 +33,9 @@ export class WebSocketService {
         this.ws.onmessage = (event) => {
           try {
             const data = JSON.parse(event.data);
-            console.log('[WS RECV]', data);
             this.handleMessage(data);
-          } catch (error) {
-            console.error('Failed to parse message:', error);
+          } catch {
+            // Failed to parse message
           }
         };
       } catch (error) {
@@ -115,9 +112,8 @@ export class WebSocketService {
     // Attempt to reconnect
     if (this.reconnectAttempts < this.maxReconnectAttempts) {
       this.reconnectAttempts++;
-      console.log(`Attempting to reconnect (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
       setTimeout(() => {
-        this.connect(this.url).catch(console.error);
+        this.connect(this.url).catch(() => {});
       }, 1000 * this.reconnectAttempts);
     }
   }