@mrpatronz/nexusflow 0.2.12 → 0.2.17

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

@@ -1,44 +1,44 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { execa } from 'execa';
-import { detectAIAssistants } from './detect-ai.js';
-
-vi.mock('execa');
-
-describe('detectAIAssistants', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should detect claude and antigravity when commands exit with 0', async () => {
-    vi.mocked(execa).mockImplementation((command: any, args?: any, options?: any): any => {
-      if (command === 'claude' || command === 'agy') {
-        return Promise.resolve({ exitCode: 0 } as any);
-      }
-      return Promise.resolve({ exitCode: 1 } as any);
-    });
-
-    const result = await detectAIAssistants();
-
-    expect(result).toEqual([
-      { name: 'claude', displayName: 'Claude Code', detected: true, command: 'claude' },
-      { name: 'antigravity', displayName: 'Antigravity', detected: true, command: 'agy' },
-      { name: 'codex', displayName: 'OpenAI Codex', detected: false },
-      { name: 'copilot', displayName: 'GitHub Copilot', detected: true },
-      { name: 'cursor', displayName: 'Cursor', detected: false },
-    ]);
-  });
-
-  it('should handle failures gracefully and set detected to false', async () => {
-    vi.mocked(execa).mockRejectedValue(new Error('Spawn error'));
-
-    const result = await detectAIAssistants();
-
-    expect(result).toEqual([
-      { name: 'claude', displayName: 'Claude Code', detected: false },
-      { name: 'antigravity', displayName: 'Antigravity', detected: false },
-      { name: 'codex', displayName: 'OpenAI Codex', detected: false },
-      { name: 'copilot', displayName: 'GitHub Copilot', detected: true },
-      { name: 'cursor', displayName: 'Cursor', detected: false },
-    ]);
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execa } from 'execa';
+import { detectAIAssistants } from './detect-ai.js';
+
+vi.mock('execa');
+
+describe('detectAIAssistants', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should detect claude and antigravity when commands exit with 0', async () => {
+    vi.mocked(execa).mockImplementation((command: any, args?: any, options?: any): any => {
+      if (command === 'claude' || command === 'agy') {
+        return Promise.resolve({ exitCode: 0 } as any);
+      }
+      return Promise.resolve({ exitCode: 1 } as any);
+    });
+
+    const result = await detectAIAssistants();
+
+    expect(result).toEqual([
+      { name: 'claude', displayName: 'Claude Code', detected: true, command: 'claude' },
+      { name: 'antigravity', displayName: 'Antigravity', detected: true, command: 'agy' },
+      { name: 'codex', displayName: 'OpenAI Codex', detected: false },
+      { name: 'copilot', displayName: 'GitHub Copilot', detected: true },
+      { name: 'cursor', displayName: 'Cursor', detected: false },
+    ]);
+  });
+
+  it('should handle failures gracefully and set detected to false', async () => {
+    vi.mocked(execa).mockRejectedValue(new Error('Spawn error'));
+
+    const result = await detectAIAssistants();
+
+    expect(result).toEqual([
+      { name: 'claude', displayName: 'Claude Code', detected: false },
+      { name: 'antigravity', displayName: 'Antigravity', detected: false },
+      { name: 'codex', displayName: 'OpenAI Codex', detected: false },
+      { name: 'copilot', displayName: 'GitHub Copilot', detected: true },
+      { name: 'cursor', displayName: 'Cursor', detected: false },
+    ]);
+  });
+});

package/src/utils/detect-ai.ts

@@ -1,84 +1,84 @@
-/**
- * @module utils/detect-ai
- * Detects which AI coding assistants are available on the system.
- */
-
-import { execa } from 'execa';
-
-import type { AIAssistant, DetectedAI } from '../types.js';
-
-/**
- * Attempts to run `<command> --version` and returns `true` if the process
- * exits successfully (exit code 0).
- */
-async function commandExists(command: string): Promise<boolean> {
-  try {
-    const result = await execa(command, ['--version'], {
-      reject: false,
-      shell: process.platform === 'win32',
-    });
-    return result.exitCode === 0;
-  } catch {
-    // The command could not be spawned at all (not in PATH).
-    return false;
-  }
-}
-
-/**
- * Probes the system for known AI coding assistants and returns their status.
- *
- * Detection rules:
- * - **Claude**: detected if `claude` *or* `antigravity` is on PATH.
- *   When Antigravity is found it is labelled as `'claude'` because it
- *   generates `CLAUDE.md` context files.
- * - **Codex**: detected if `codex` is on PATH.
- * - **Copilot**: always shown as an option (convention-based via
- *   `.github/copilot-instructions.md`).
- * - **Cursor**: detected if `cursor` is on PATH.
- *
- * @returns An array of {@link DetectedAI} results, one per assistant.
- */
-export async function detectAIAssistants(): Promise<DetectedAI[]> {
-  // Run all probes concurrently.
-  const [hasClaude, hasAntigravity, hasCodex, hasCursor] = await Promise.all([
-    commandExists('claude'),
-    commandExists('agy'),
-    commandExists('codex'),
-    commandExists('cursor'),
-  ]);
-
-  const results: DetectedAI[] = [
-    {
-      name: 'claude' as AIAssistant,
-      displayName: 'Claude Code',
-      detected: hasClaude,
-      ...(hasClaude ? { command: 'claude' } : {}),
-    },
-    {
-      name: 'antigravity' as AIAssistant,
-      displayName: 'Antigravity',
-      detected: hasAntigravity,
-      ...(hasAntigravity ? { command: 'agy' } : {}),
-    },
-    {
-      name: 'codex' as AIAssistant,
-      displayName: 'OpenAI Codex',
-      detected: hasCodex,
-      ...(hasCodex ? { command: 'codex' } : {}),
-    },
-    {
-      name: 'copilot' as AIAssistant,
-      displayName: 'GitHub Copilot',
-      // Copilot is convention-based; always available as an option.
-      detected: true,
-    },
-    {
-      name: 'cursor' as AIAssistant,
-      displayName: 'Cursor',
-      detected: hasCursor,
-      ...(hasCursor ? { command: 'cursor' } : {}),
-    },
-  ];
-
-  return results;
-}
+/**
+ * @module utils/detect-ai
+ * Detects which AI coding assistants are available on the system.
+ */
+
+import { execa } from 'execa';
+
+import type { AIAssistant, DetectedAI } from '../types.js';
+
+/**
+ * Attempts to run `<command> --version` and returns `true` if the process
+ * exits successfully (exit code 0).
+ */
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    const result = await execa(command, ['--version'], {
+      reject: false,
+      shell: process.platform === 'win32',
+    });
+    return result.exitCode === 0;
+  } catch {
+    // The command could not be spawned at all (not in PATH).
+    return false;
+  }
+}
+
+/**
+ * Probes the system for known AI coding assistants and returns their status.
+ *
+ * Detection rules:
+ * - **Claude**: detected if `claude` *or* `antigravity` is on PATH.
+ *   When Antigravity is found it is labelled as `'claude'` because it
+ *   generates `CLAUDE.md` context files.
+ * - **Codex**: detected if `codex` is on PATH.
+ * - **Copilot**: always shown as an option (convention-based via
+ *   `.github/copilot-instructions.md`).
+ * - **Cursor**: detected if `cursor` is on PATH.
+ *
+ * @returns An array of {@link DetectedAI} results, one per assistant.
+ */
+export async function detectAIAssistants(): Promise<DetectedAI[]> {
+  // Run all probes concurrently.
+  const [hasClaude, hasAntigravity, hasCodex, hasCursor] = await Promise.all([
+    commandExists('claude'),
+    commandExists('agy'),
+    commandExists('codex'),
+    commandExists('cursor'),
+  ]);
+
+  const results: DetectedAI[] = [
+    {
+      name: 'claude' as AIAssistant,
+      displayName: 'Claude Code',
+      detected: hasClaude,
+      ...(hasClaude ? { command: 'claude' } : {}),
+    },
+    {
+      name: 'antigravity' as AIAssistant,
+      displayName: 'Antigravity',
+      detected: hasAntigravity,
+      ...(hasAntigravity ? { command: 'agy' } : {}),
+    },
+    {
+      name: 'codex' as AIAssistant,
+      displayName: 'OpenAI Codex',
+      detected: hasCodex,
+      ...(hasCodex ? { command: 'codex' } : {}),
+    },
+    {
+      name: 'copilot' as AIAssistant,
+      displayName: 'GitHub Copilot',
+      // Copilot is convention-based; always available as an option.
+      detected: true,
+    },
+    {
+      name: 'cursor' as AIAssistant,
+      displayName: 'Cursor',
+      detected: hasCursor,
+      ...(hasCursor ? { command: 'cursor' } : {}),
+    },
+  ];
+
+  return results;
+}

package/src/utils/detect-editors.test.ts

@@ -1,48 +1,48 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { execa } from 'execa';
-import { detectEditors } from './detect-editors.js';
-
-vi.mock('execa');
-
-describe('detectEditors', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should return detected = true for editors whose commands exit with 0', async () => {
-    vi.mocked(execa).mockImplementation((command: any, args?: any, options?: any): any => {
-      if (command === 'code' || command === 'cursor') {
-        return Promise.resolve({ exitCode: 0 } as any);
-      }
-      return Promise.resolve({ exitCode: 1 } as any);
-    });
-
-    const result = await detectEditors();
-
-    expect(result).toEqual([
-      { name: 'VS Code', command: 'code', detected: true },
-      { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
-      { name: 'Cursor', command: 'cursor', detected: true },
-      { name: 'Antigravity', command: 'agy', detected: false },
-    ]);
-
-    const isWin = process.platform === 'win32';
-    expect(execa).toHaveBeenCalledWith('code', ['--version'], { reject: false, shell: isWin });
-    expect(execa).toHaveBeenCalledWith('code-insiders', ['--version'], { reject: false, shell: isWin });
-    expect(execa).toHaveBeenCalledWith('cursor', ['--version'], { reject: false, shell: isWin });
-    expect(execa).toHaveBeenCalledWith('agy', ['--version'], { reject: false, shell: isWin });
-  });
-
-  it('should return detected = false for all editors if execa throws an error', async () => {
-    vi.mocked(execa).mockRejectedValue(new Error('Spawn error'));
-
-    const result = await detectEditors();
-
-    expect(result).toEqual([
-      { name: 'VS Code', command: 'code', detected: false },
-      { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
-      { name: 'Cursor', command: 'cursor', detected: false },
-      { name: 'Antigravity', command: 'agy', detected: false },
-    ]);
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { execa } from 'execa';
+import { detectEditors } from './detect-editors.js';
+
+vi.mock('execa');
+
+describe('detectEditors', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return detected = true for editors whose commands exit with 0', async () => {
+    vi.mocked(execa).mockImplementation((command: any, args?: any, options?: any): any => {
+      if (command === 'code' || command === 'cursor') {
+        return Promise.resolve({ exitCode: 0 } as any);
+      }
+      return Promise.resolve({ exitCode: 1 } as any);
+    });
+
+    const result = await detectEditors();
+
+    expect(result).toEqual([
+      { name: 'VS Code', command: 'code', detected: true },
+      { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
+      { name: 'Cursor', command: 'cursor', detected: true },
+      { name: 'Antigravity', command: 'antigravity', detected: false },
+    ]);
+
+    const isWin = process.platform === 'win32';
+    expect(execa).toHaveBeenCalledWith('code', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('code-insiders', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('cursor', ['--version'], { reject: false, shell: isWin });
+    expect(execa).toHaveBeenCalledWith('antigravity', ['--version'], { reject: false, shell: isWin });
+  });
+
+  it('should return detected = false for all editors if execa throws an error', async () => {
+    vi.mocked(execa).mockRejectedValue(new Error('Spawn error'));
+
+    const result = await detectEditors();
+
+    expect(result).toEqual([
+      { name: 'VS Code', command: 'code', detected: false },
+      { name: 'VS Code Insiders', command: 'code-insiders', detected: false },
+      { name: 'Cursor', command: 'cursor', detected: false },
+      { name: 'Antigravity', command: 'antigravity', detected: false },
+    ]);
+  });
+});

package/src/utils/detect-editors.ts

@@ -1,57 +1,57 @@
-/**
- * @module utils/detect-editors
- * Detects which code editors are available on the system.
- */
-
-import { execa } from 'execa';
-
-import type { DetectedEditor } from '../types.js';
-
-/** Editor definitions we probe for. */
-const EDITOR_CANDIDATES: ReadonlyArray<{ name: string; command: string }> = [
-  { name: 'VS Code', command: 'code' },
-  { name: 'VS Code Insiders', command: 'code-insiders' },
-  { name: 'Cursor', command: 'cursor' },
-  { name: 'Antigravity', command: 'agy' },
-];
-
-/**
- * Attempts to run `<command> --version` and returns `true` if the process
- * exits successfully (exit code 0).
- */
-async function commandExists(command: string): Promise<boolean> {
-  try {
-    const result = await execa(command, ['--version'], {
-      reject: false,
-      shell: process.platform === 'win32',
-    });
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Probes the system for known code editors by checking whether their CLI
- * commands are available on PATH.
- *
- * Currently checks for:
- * - **VS Code** (`code`)
- * - **VS Code Insiders** (`code-insiders`)
- * - **Cursor** (`cursor`)
- * - **Antigravity** (`antigravity`)
- *
- * @returns An array of {@link DetectedEditor} results, one per editor.
- */
-export async function detectEditors(): Promise<DetectedEditor[]> {
-  const probes = EDITOR_CANDIDATES.map(async (editor) => {
-    const detected = await commandExists(editor.command);
-    return {
-      name: editor.name,
-      command: editor.command,
-      detected,
-    } satisfies DetectedEditor;
-  });
-
-  return Promise.all(probes);
-}
+/**
+ * @module utils/detect-editors
+ * Detects which code editors are available on the system.
+ */
+
+import { execa } from 'execa';
+
+import type { DetectedEditor } from '../types.js';
+
+/** Editor definitions we probe for. */
+const EDITOR_CANDIDATES: ReadonlyArray<{ name: string; command: string }> = [
+  { name: 'VS Code', command: 'code' },
+  { name: 'VS Code Insiders', command: 'code-insiders' },
+  { name: 'Cursor', command: 'cursor' },
+  { name: 'Antigravity', command: 'antigravity' },
+];
+
+/**
+ * Attempts to run `<command> --version` and returns `true` if the process
+ * exits successfully (exit code 0).
+ */
+async function commandExists(command: string): Promise<boolean> {
+  try {
+    const result = await execa(command, ['--version'], {
+      reject: false,
+      shell: process.platform === 'win32',
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Probes the system for known code editors by checking whether their CLI
+ * commands are available on PATH.
+ *
+ * Currently checks for:
+ * - **VS Code** (`code`)
+ * - **VS Code Insiders** (`code-insiders`)
+ * - **Cursor** (`cursor`)
+ * - **Antigravity** (`antigravity`)
+ *
+ * @returns An array of {@link DetectedEditor} results, one per editor.
+ */
+export async function detectEditors(): Promise<DetectedEditor[]> {
+  const probes = EDITOR_CANDIDATES.map(async (editor) => {
+    const detected = await commandExists(editor.command);
+    return {
+      name: editor.name,
+      command: editor.command,
+      detected,
+    } satisfies DetectedEditor;
+  });
+
+  return Promise.all(probes);
+}

package/src/utils/git.test.ts

@@ -1,74 +1,74 @@
-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');
-    });
-  });
-});
+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');
+    });
+  });
+});