@mrpatronz/nexusflow 0.2.7 → 0.2.11

package/src/utils/local-ai.ts

@@ -0,0 +1,111 @@
+/**
+ * @module utils/local-ai
+ * Handles requests to local LLM servers (Ollama or OpenAI-compatible like LM Studio).
+ */
+
+import type { LocalLlmConfig } from '../types.js';
+
+export interface LocalLlmMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+/**
+ * Sends a chat completion request to the configured local LLM provider.
+ * Supports Ollama-specific API and standard OpenAI-compatible endpoints.
+ */
+export async function callLocalLlm(
+  config: LocalLlmConfig,
+  messages: LocalLlmMessage[],
+): Promise<string> {
+  const { provider, endpoint, model } = config;
+  const cleanEndpoint = endpoint.replace(/\/$/, '');
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 60_000);
+
+  try {
+    if (provider === 'ollama') {
+      const url = `${cleanEndpoint}/api/chat`;
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: false,
+        }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama request failed with status ${response.status}: ${text}`);
+      }
+
+      const data: any = await response.json();
+      if (data?.message?.content) {
+        return data.message.content;
+      }
+      throw new Error('Invalid response format received from Ollama');
+    } else {
+      // OpenAI-compatible provider
+      const url = getOpenAiCompatibleUrl(cleanEndpoint, '/v1/chat/completions');
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model,
+          messages,
+          stream: false,
+        }),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`OpenAI-compatible request failed with status ${response.status}: ${text}`);
+      }
+
+      const data: any = await response.json();
+      if (data?.choices?.[0]?.message?.content) {
+        return data.choices[0].message.content;
+      }
+      throw new Error('Invalid response format received from OpenAI-compatible endpoint');
+    }
+  } catch (error: any) {
+    if (error.name === 'AbortError') {
+      throw new Error('Local LLM request timed out after 60 seconds');
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Checks whether a target model name matches any model in an Ollama model list.
+ * Handles tag variations like 'model' vs 'model:latest' vs 'model:7b'.
+ */
+export function isOllamaModelAvailable(models: { name: string }[], targetModel: string): boolean {
+  const normalize = (name: string) => name.includes(':') ? name : `${name}:latest`;
+  const targetNorm = normalize(targetModel);
+  return models.some((m) => normalize(m.name) === targetNorm);
+}
+
+/**
+ * Helper to build standard OpenAI compatible URLs.
+ * Handles cases where the configured endpoint already has or does not have `/v1`.
+ */
+export function getOpenAiCompatibleUrl(endpoint: string, suffix: string): string {
+  const cleanEndpoint = endpoint.replace(/\/$/, '');
+  const hasV1 = /\/v1\/?$/.test(cleanEndpoint);
+  if (hasV1) {
+    return `${cleanEndpoint.replace(/\/v1\/?$/, '')}${suffix}`;
+  }
+  return `${cleanEndpoint}${suffix}`;
+}

package/src/utils/system-scanner.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execa } from 'execa';
+import * as os from 'node:os';
+import { scanSystemSpecs } from './system-scanner.js';
+
+vi.mock('execa');
+vi.mock('node:os', async () => {
+  const actual = await vi.importActual<typeof import('node:os')>('node:os');
+  return {
+    ...actual,
+    totalmem: vi.fn(),
+    platform: vi.fn(),
+  };
+});
+
+describe('scanSystemSpecs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should recommend 7b on windows with 16GB RAM even if no GPU detected', async () => {
+    vi.mocked(os.totalmem).mockReturnValue(16 * 1024 * 1024 * 1024);
+    vi.mocked(os.platform).mockReturnValue('win32');
+    vi.mocked(execa).mockResolvedValue({ stdout: '' } as any);
+
+    const specs = await scanSystemSpecs();
+
+    expect(specs.totalRamGb).toBe(16);
+    expect(specs.gpuName).toBe('Unknown/Integrated');
+    expect(specs.hasHardwareAcceleration).toBe(false);
+    expect(specs.recommendedModel).toBe('qwen2.5-coder:7b');
+  });
+
+  it('should recommend 1.5b on windows with 8GB RAM and no GPU', async () => {
+    vi.mocked(os.totalmem).mockReturnValue(8 * 1024 * 1024 * 1024);
+    vi.mocked(os.platform).mockReturnValue('win32');
+    vi.mocked(execa).mockResolvedValue({ stdout: '' } as any);
+
+    const specs = await scanSystemSpecs();
+
+    expect(specs.totalRamGb).toBe(8);
+    expect(specs.recommendedModel).toBe('qwen2.5-coder:1.5b');
+  });
+
+  it('should detect Nvidia GPU on Windows and recommend 7b with 12GB RAM', async () => {
+    vi.mocked(os.totalmem).mockReturnValue(12 * 1024 * 1024 * 1024);
+    vi.mocked(os.platform).mockReturnValue('win32');
+    vi.mocked(execa).mockResolvedValue({
+      stdout: 'NVIDIA GeForce RTX 4070 Laptop GPU\r\n'
+    } as any);
+
+    const specs = await scanSystemSpecs();
+
+    expect(specs.totalRamGb).toBe(12);
+    expect(specs.gpuName).toBe('NVIDIA GeForce RTX 4070 Laptop GPU');
+    expect(specs.hasHardwareAcceleration).toBe(true);
+    expect(specs.recommendedModel).toBe('qwen2.5-coder:7b');
+  });
+
+  it('should detect Apple Silicon on Darwin and recommend 7b with 12GB RAM', async () => {
+    vi.mocked(os.totalmem).mockReturnValue(12 * 1024 * 1024 * 1024);
+    vi.mocked(os.platform).mockReturnValue('darwin');
+    vi.mocked(execa).mockResolvedValue({
+      stdout: 'Apple M3 Max\n'
+    } as any);
+
+    const specs = await scanSystemSpecs();
+
+    expect(specs.totalRamGb).toBe(12);
+    expect(specs.gpuName).toBe('Apple Silicon (Integrated)');
+    expect(specs.hasHardwareAcceleration).toBe(true);
+    expect(specs.recommendedModel).toBe('qwen2.5-coder:7b');
+  });
+
+  it('should detect Linux GPU and recommend 7b with 12GB RAM', async () => {
+    vi.mocked(os.totalmem).mockReturnValue(12 * 1024 * 1024 * 1024);
+    vi.mocked(os.platform).mockReturnValue('linux');
+    vi.mocked(execa).mockResolvedValue({
+      stdout: '01:00.0 VGA compatible controller: NVIDIA Corporation AD104 [GeForce RTX 4070 Ti] (rev a1)\n'
+    } as any);
+
+    const specs = await scanSystemSpecs();
+
+    expect(specs.totalRamGb).toBe(12);
+    expect(specs.gpuName).toBe('NVIDIA Corporation AD104 [GeForce RTX 4070 Ti] (rev a1)');
+    expect(specs.hasHardwareAcceleration).toBe(true);
+    expect(specs.recommendedModel).toBe('qwen2.5-coder:7b');
+  });
+});

package/src/utils/system-scanner.ts

@@ -0,0 +1,96 @@
+/**
+ * @module utils/system-scanner
+ * Detects local system specifications (RAM, GPU) and recommends the optimal local LLM size.
+ */
+
+import { execa } from 'execa';
+import * as os from 'node:os';
+
+export interface SystemSpecs {
+  totalRamGb: number;
+  gpuName: string;
+  hasHardwareAcceleration: boolean;
+  recommendedModel: string;
+}
+
+/**
+ * Probes the local operating system to detect RAM and GPU specifications,
+ * returning a recommended local LLM model name.
+ */
+export async function scanSystemSpecs(): Promise<SystemSpecs> {
+  const totalRamGb = Math.round(os.totalmem() / (1024 * 1024 * 1024));
+  let gpuName = 'Unknown/Integrated';
+  let hasHardwareAcceleration = false;
+
+  const platform = os.platform();
+
+  try {
+    if (platform === 'win32') {
+      const { stdout } = await execa('powershell', ['-NoProfile', '-Command', 'Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name'], { reject: false });
+      if (stdout) {
+        const lines = stdout.split('\n')
+          .map(l => l.trim())
+          .filter(l => l && l.toLowerCase() !== 'name');
+        
+        if (lines.length > 0) {
+          gpuName = lines.join(', ');
+          const lowerGpu = gpuName.toLowerCase();
+          if (
+            lowerGpu.includes('nvidia') || 
+            lowerGpu.includes('radeon') || 
+            lowerGpu.includes('geforce') || 
+            lowerGpu.includes('rtx') || 
+            lowerGpu.includes('gtx')
+          ) {
+            hasHardwareAcceleration = true;
+          }
+        }
+      }
+    } else if (platform === 'darwin') {
+      const { stdout } = await execa('sysctl', ['-n', 'machdep.cpu.brand_string'], { reject: false });
+      if (stdout && stdout.toLowerCase().includes('apple')) {
+        gpuName = 'Apple Silicon (Integrated)';
+        hasHardwareAcceleration = true;
+      } else {
+        const { stdout: spOut } = await execa('system_profiler', ['SPDisplaysDataType'], { reject: false });
+        if (spOut) {
+          gpuName = 'Intel Mac GPU';
+          const lowerGpu = spOut.toLowerCase();
+          if (lowerGpu.includes('amd') || lowerGpu.includes('radeon') || lowerGpu.includes('nvidia')) {
+            hasHardwareAcceleration = true;
+          }
+        }
+      }
+    } else if (platform === 'linux') {
+      const { stdout } = await execa('lspci', [], { reject: false });
+      if (stdout) {
+        const gpuLines = stdout.split('\n').filter(line => line.toLowerCase().includes('vga') || line.toLowerCase().includes('3d'));
+        if (gpuLines.length > 0) {
+          gpuName = gpuLines.map(line => line.split(':').pop()?.trim()).filter(Boolean).join(', ');
+          const lowerGpu = gpuName.toLowerCase();
+          if (lowerGpu.includes('nvidia') || lowerGpu.includes('amd') || lowerGpu.includes('radeon')) {
+            hasHardwareAcceleration = true;
+          }
+        }
+      }
+    }
+  } catch {
+    // Ignore execution failures, fall back to default values
+  }
+
+  // Recommendation logic:
+  // - RAM >= 12GB AND has dedicated GPU/Apple Silicon -> Recommend 7B
+  // - RAM >= 16GB regardless of GPU -> Recommend 7B (can run fine on CPU)
+  // - Otherwise -> Recommend 1.5B (fast and safe)
+  let recommendedModel = 'qwen2.5-coder:1.5b';
+  if ((totalRamGb >= 12 && hasHardwareAcceleration) || totalRamGb >= 16) {
+    recommendedModel = 'qwen2.5-coder:7b';
+  }
+
+  return {
+    totalRamGb,
+    gpuName,
+    hasHardwareAcceleration,
+    recommendedModel,
+  };
+}

package/vitest.config.ts

@@ -7,7 +7,8 @@ export default defineConfig({
       '**/dist/**',
       '**/cypress/**',
       '**/.{idea,git,cache,output,temp}/**',
-      '**/scratch/**'
+      '**/scratch/**',
+      '**/gui/**'
     ]
   }
 });