@mrpatronz/nexusflow 0.2.19 → 1.3.0

package/src/utils/git.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { execa } from 'execa';
-import { isGitRepo, gitFetch, detectDefaultBranch } from './git.js';
-
-vi.mock('node:fs/promises');
-vi.mock('execa');
-
-describe('git utilities', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('isGitRepo', () => {
-    it('should return true if .git directory exists and is accessible', async () => {
-      vi.mocked(fs.access).mockResolvedValue(undefined);
-
-      const result = await isGitRepo('/mock/repo');
-
-      expect(result).toBe(true);
-      expect(fs.access).toHaveBeenCalledWith(path.join('/mock/repo', '.git'));
-    });
-
-    it('should return false if .git directory is not accessible', async () => {
-      vi.mocked(fs.access).mockRejectedValue(new Error('ENOENT'));
-
-      const result = await isGitRepo('/mock/repo');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('gitFetch', () => {
-    it('should run git fetch origin', async () => {
-      vi.mocked(execa).mockResolvedValue({} as any);
-
-      await gitFetch('/mock/repo');
-
-      expect(execa).toHaveBeenCalledWith('git', ['fetch', 'origin'], { cwd: '/mock/repo' });
-    });
-  });
-
-  describe('detectDefaultBranch', () => {
-    it('should prefer main over master', async () => {
-      vi.mocked(execa).mockResolvedValue({
-        stdout: '  origin/master\n  origin/main\n'
-      } as any);
-
-      const branch = await detectDefaultBranch('/mock/repo');
-
-      expect(branch).toBe('main');
-      expect(execa).toHaveBeenCalledWith('git', ['branch', '-r'], { cwd: '/mock/repo' });
-    });
-
-    it('should match master if main is not present', async () => {
-      vi.mocked(execa).mockResolvedValue({
-        stdout: '  origin/master\n  origin/feature-branch\n'
-      } as any);
-
-      const branch = await detectDefaultBranch('/mock/repo');
-
-      expect(branch).toBe('master');
-    });
-
-    it('should fallback to main if neither is present or command fails', async () => {
-      vi.mocked(execa).mockRejectedValue(new Error('git command failed'));
-
-      const branch = await detectDefaultBranch('/mock/repo');
-
-      expect(branch).toBe('main');
-    });
-  });
-});

package/src/utils/git.ts

@@ -1,117 +0,0 @@
-/**
- * @module utils/git
- * Low-level git helper functions used throughout NexusFlow.
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { execa } from 'execa';
-
-/**
- * Checks whether the given directory is a git repository
- * by testing for the presence of a `.git` entry.
- *
- * @param dirPath - Absolute path to the directory.
- * @returns `true` if a `.git` file or directory exists.
- */
-export async function isGitRepo(dirPath: string): Promise<boolean> {
-  try {
-    const gitPath = path.join(dirPath, '.git');
-    await fs.access(gitPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Runs `git fetch origin` inside the given repository.
- *
- * @param repoPath - Absolute path to the repo root.
- */
-export async function gitFetch(repoPath: string): Promise<void> {
-  await execa('git', ['fetch', 'origin'], { cwd: repoPath });
-}
-
-/**
- * Detects the default branch of a repository by inspecting remote branches.
- * Prefers `main` over `master`. Falls back to `'main'` when neither is found.
- *
- * @param repoPath - Absolute path to the repo root.
- * @returns The name of the default branch.
- */
-export async function detectDefaultBranch(repoPath: string): Promise<string> {
-  try {
-    const { stdout } = await execa('git', ['branch', '-r'], { cwd: repoPath });
-    const branches = stdout.split('\n').map((b) => b.trim());
-
-    if (branches.some((b) => b === 'origin/main' || b.endsWith('/origin/main'))) {
-      return 'main';
-    }
-
-    if (branches.some((b) => b === 'origin/master' || b.endsWith('/origin/master'))) {
-      return 'master';
-    }
-
-    // Fallback — assume main.
-    return 'main';
-  } catch {
-    return 'main';
-  }
-}
-
-/**
- * Checks if the given branch name matches Git branch conventions (based on git-check-ref-format):
- * - No spaces, backslashes, or control characters.
- * - At least 1 character long.
- * - Is not exactly '@'.
- * - Does not start with a dash.
- * - Does not start or end with a forward slash.
- * - Does not contain consecutive dots, consecutive slashes, or '@{'.
- * - Does not end with '.'.
- * - Does not contain forbidden characters: ~, ^, :, ?, *, [
- * - No component starts with a dot, ends with '.lock', or is exactly 'HEAD'.
- *
- * @param name - The branch name to validate.
- * @returns `true` if the branch name is valid.
- */
-export function isValidBranchName(name: string): boolean {
-  if (!name || name.length === 0) {
-    return false;
-  }
-  if (name === '@') {
-    return false;
-  }
-  if (name.startsWith('-')) {
-    return false;
-  }
-  const forbiddenCharsOrSpaces = /[\x00-\x20\x7F~^:?*[\\]/;
-  if (forbiddenCharsOrSpaces.test(name)) {
-    return false;
-  }
-  if (name.includes('..') || name.includes('@{') || name.includes('//')) {
-    return false;
-  }
-  if (name.startsWith('/') || name.endsWith('/')) {
-    return false;
-  }
-  if (name.endsWith('.')) {
-    return false;
-  }
-  
-  const components = name.split('/');
-  for (const component of components) {
-    if (component.startsWith('.')) {
-      return false;
-    }
-    if (component.endsWith('.lock')) {
-      return false;
-    }
-    if (component === 'HEAD') {
-      return false;
-    }
-  }
-
-  return true;
-}
-

package/src/utils/local-ai.test.ts

@@ -1,130 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { callLocalLlm, isOllamaModelAvailable, getOpenAiCompatibleUrl } from './local-ai.js';
-
-describe('local-ai utilities', () => {
-  beforeEach(() => {
-    vi.stubGlobal('fetch', vi.fn());
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('isOllamaModelAvailable', () => {
-    it('should match exact model names and tag variations', () => {
-      const models = [{ name: 'qwen2.5-coder:1.5b' }, { name: 'llama3:latest' }];
-      expect(isOllamaModelAvailable(models, 'qwen2.5-coder:1.5b')).toBe(true);
-      expect(isOllamaModelAvailable(models, 'llama3')).toBe(true);
-      expect(isOllamaModelAvailable(models, 'llama3:latest')).toBe(true);
-      expect(isOllamaModelAvailable(models, 'non-existent')).toBe(false);
-    });
-  });
-
-  describe('getOpenAiCompatibleUrl', () => {
-    it('should properly format endpoint URLs', () => {
-      expect(getOpenAiCompatibleUrl('http://localhost:11434', '/v1/chat/completions')).toBe('http://localhost:11434/v1/chat/completions');
-      expect(getOpenAiCompatibleUrl('http://localhost:11434/', '/v1/chat/completions')).toBe('http://localhost:11434/v1/chat/completions');
-      expect(getOpenAiCompatibleUrl('http://localhost:1234/v1', '/v1/chat/completions')).toBe('http://localhost:1234/v1/chat/completions');
-      expect(getOpenAiCompatibleUrl('http://localhost:1234/v1/', '/v1/chat/completions')).toBe('http://localhost:1234/v1/chat/completions');
-    });
-  });
-
-  describe('callLocalLlm', () => {
-    const configOllama = {
-      enabled: true,
-      provider: 'ollama' as const,
-      endpoint: 'http://localhost:11434',
-      model: 'qwen2.5-coder:1.5b',
-    };
-
-    const configOpenAi = {
-      enabled: true,
-      provider: 'openai-compatible' as const,
-      endpoint: 'http://localhost:1234/v1',
-      model: 'custom-model',
-    };
-
-    const messages = [{ role: 'user' as const, content: 'Hello' }];
-
-    it('should request and return message content for Ollama provider', async () => {
-      const mockResponse = {
-        message: {
-          content: 'Hello from Ollama!',
-        },
-      };
-
-      vi.mocked(fetch).mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockResponse),
-      } as any);
-
-      const response = await callLocalLlm(configOllama, messages);
-
-      expect(response).toBe('Hello from Ollama!');
-      expect(fetch).toHaveBeenCalledWith('http://localhost:11434/api/chat', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          model: 'qwen2.5-coder:1.5b',
-          messages,
-          stream: false,
-        }),
-        signal: expect.any(AbortSignal),
-      });
-    });
-
-    it('should throw an error if Ollama response is not ok', async () => {
-      vi.mocked(fetch).mockResolvedValue({
-        ok: false,
-        status: 500,
-        text: () => Promise.resolve('Internal server error'),
-      } as any);
-
-      await expect(callLocalLlm(configOllama, messages)).rejects.toThrow(
-        'Ollama request failed with status 500: Internal server error'
-      );
-    });
-
-    it('should request and return message content for OpenAI provider', async () => {
-      const mockResponse = {
-        choices: [
-          {
-            message: {
-              content: 'Hello from OpenAI!',
-            },
-          },
-        ],
-      };
-
-      vi.mocked(fetch).mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockResponse),
-      } as any);
-
-      const response = await callLocalLlm(configOpenAi, messages);
-
-      expect(response).toBe('Hello from OpenAI!');
-      expect(fetch).toHaveBeenCalledWith('http://localhost:1234/v1/chat/completions', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          model: 'custom-model',
-          messages,
-          stream: false,
-        }),
-        signal: expect.any(AbortSignal),
-      });
-    });
-
-    it('should throw an error if OpenAI response has invalid format', async () => {
-      vi.mocked(fetch).mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({}),
-      } as any);
-
-      await expect(callLocalLlm(configOpenAi, messages)).rejects.toThrow(
-        'Invalid response format received from OpenAI-compatible endpoint'
-      );
-    });
-  });
-});

package/src/utils/local-ai.ts

@@ -1,116 +0,0 @@
-/**
- * @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

@@ -1,158 +0,0 @@
-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);
-  });
-});