@mrpatronz/nexusflow 0.2.17 → 0.2.19

package/src/utils/local-ai.ts

@@ -1,111 +1,116 @@
-/**
- * @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}`;
-}
+/**
+ * @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 headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+      };
+      if (config.apiKey) {
+        headers['Authorization'] = `Bearer ${config.apiKey}`;
+      }
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        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/multi-git.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execa } from 'execa';
+import { rebaseRepo } from './multi-git.js';
+
+vi.mock('execa');
+
+/** Builds an execa-style error carrying stderr (as execa does on non-zero exit). */
+function gitError(stderr: string): Error {
+  return Object.assign(new Error('git failed'), { stderr });
+}
+
+interface GitMockOpts {
+  fetchError?: Error;
+  statusStdout?: string;      // output of `git status --porcelain` ('' = clean)
+  stashPushError?: Error;
+  stashPopError?: Error;
+  rebaseError?: Error;
+  rebaseStdout?: string;
+}
+
+/** Resolves a single mocked `git` call by subcommand. */
+async function routeGit(a: string[], opts: GitMockOpts): Promise<{ stdout: string }> {
+  const sub = a[0];
+  if (sub === 'fetch') {
+    if (opts.fetchError) throw opts.fetchError;
+    return { stdout: '' };
+  }
+  if (sub === 'status') {
+    return { stdout: opts.statusStdout ?? '' };
+  }
+  if (sub === 'stash' && a[1] === 'push') {
+    if (opts.stashPushError) throw opts.stashPushError;
+    return { stdout: '' };
+  }
+  if (sub === 'stash' && a[1] === 'pop') {
+    if (opts.stashPopError) throw opts.stashPopError;
+    return { stdout: '' };
+  }
+  if (sub === 'rebase' && a[1] === '--abort') {
+    return { stdout: '' };
+  }
+  if (sub === 'rebase') {
+    if (opts.rebaseError) throw opts.rebaseError;
+    return { stdout: opts.rebaseStdout ?? 'Successfully rebased.' };
+  }
+  return { stdout: '' };
+}
+
+/** Routes mocked `git` calls by subcommand so each test declares only what matters. */
+function mockGit(opts: GitMockOpts): void {
+  vi.mocked(execa).mockImplementation(((_file: any, args: any) =>
+    routeGit(args as string[], opts)) as any);
+}
+
+/** Returns the recorded execa calls as arrays of git args. */
+function gitCalls(): string[][] {
+  return vi.mocked(execa).mock.calls.map((c) => c[1] as string[]);
+}
+
+describe('rebaseRepo', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('reports "rebased" for a clean tree with new base commits', async () => {
+    mockGit({ statusStdout: '', rebaseStdout: 'Successfully rebased and updated.' });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe('rebased');
+    expect(result.stashed).toBeFalsy();
+    // No stash should be created for a clean tree.
+    expect(gitCalls().some((c) => c[0] === 'stash')).toBe(false);
+  });
+
+  it('reports "up-to-date" when already current', async () => {
+    mockGit({ statusStdout: '', rebaseStdout: 'Current branch feature is up to date.' });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe('up-to-date');
+  });
+
+  it('auto-stashes a dirty tree and restores it (the regression fix)', async () => {
+    mockGit({ statusStdout: ' M src/app.ts\n', rebaseStdout: 'Successfully rebased.' });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.success).toBe(true);
+    expect(result.status).toBe('rebased');
+    expect(result.stashed).toBe(true);
+
+    const calls = gitCalls();
+    // Stash push (with untracked) before rebase, stash pop after.
+    expect(calls).toContainEqual(['stash', 'push', '-u', '-m', 'nexusflow-autostash']);
+    expect(calls).toContainEqual(['stash', 'pop']);
+  });
+
+  it('classifies a fetch failure as "error", not a conflict', async () => {
+    mockGit({ fetchError: gitError('fatal: unable to access origin: Could not resolve host') });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.success).toBe(false);
+    expect(result.status).toBe('error');
+    expect(result.message).toMatch(/^Fetch failed:/);
+    expect(result.conflict).toBeUndefined();
+    // Should never attempt a rebase if fetch failed.
+    expect(gitCalls().some((c) => c[0] === 'rebase')).toBe(false);
+  });
+
+  it('classifies a real merge conflict as "conflict" and aborts', async () => {
+    mockGit({
+      statusStdout: '',
+      rebaseError: gitError('CONFLICT (content): Merge conflict in src/app.ts'),
+    });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.success).toBe(false);
+    expect(result.status).toBe('conflict');
+    expect(result.conflict).toContain('CONFLICT');
+    expect(gitCalls()).toContainEqual(['rebase', '--abort']);
+  });
+
+  it('restores the stash after aborting a conflicting rebase on a dirty tree', async () => {
+    mockGit({
+      statusStdout: ' M src/app.ts\n',
+      rebaseError: gitError('CONFLICT (content): Merge conflict'),
+    });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    expect(result.status).toBe('conflict');
+    expect(result.stashed).toBe(true);
+    const calls = gitCalls();
+    expect(calls).toContainEqual(['rebase', '--abort']);
+    expect(calls).toContainEqual(['stash', 'pop']); // local work restored
+  });
+
+  it('reports "stash-conflict" when the rebase lands but the stash pop conflicts', async () => {
+    mockGit({
+      statusStdout: ' M src/app.ts\n',
+      rebaseStdout: 'Successfully rebased.',
+      stashPopError: gitError('CONFLICT (content): Merge conflict in src/app.ts'),
+    });
+
+    const result = await rebaseRepo('/repo', 'main');
+
+    // The rebase itself succeeded, so success is true, but it needs attention.
+    expect(result.success).toBe(true);
+    expect(result.status).toBe('stash-conflict');
+    expect(result.stashed).toBe(true);
+    expect(result.message).toMatch(/stash preserved/i);
+  });
+});