git0 0.3.34 → 0.3.36

package/test/github-api-http.test.ts

@@ -0,0 +1,159 @@
+import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import http from 'http';
+import type { AddressInfo } from 'net';
+import GithubAPI from '../src/github-api.ts';
+
+/**
+ * Runs the real client against a local HTTP server standing in for
+ * api.github.com — no module mocking, so it behaves the same under vitest and
+ * `bun test`.
+ */
+const RELEASES = [
+  {
+    tag_name: 'v1.0.0',
+    name: 'v1.0.0',
+    published_at: '2024-01-01T00:00:00Z',
+    assets: [
+      { name: 'tool-linux-x86_64.tar.gz', browser_download_url: 'https://x/linux', size: 1, download_count: 1 },
+      { name: 'tool-windows-x86_64.zip', browser_download_url: 'https://x/win', size: 1, download_count: 1 },
+      { name: 'tool-macos-arm64.dmg', browser_download_url: 'https://x/mac', size: 1, download_count: 1 },
+    ],
+  },
+];
+
+const REPOS = [
+  { name: 'alpha', full_name: 'o/alpha', owner: { login: 'o' }, url: 'https://github.com/o/alpha', stargazers_count: 5 },
+  { name: 'beta', full_name: 'o/beta', owner: { login: 'o' }, url: 'https://github.com/o/beta', stargazers_count: 3 },
+];
+
+let server: http.Server;
+let base: string;
+let requests: Array<{ url: string; auth?: string }>;
+let mode: 'ok' | 'rate-limit' | 'empty';
+
+beforeAll(async () => {
+  server = http.createServer((req, res) => {
+    requests.push({ url: req.url ?? '', auth: req.headers.authorization });
+    const json = (status: number, body: unknown) => {
+      res.writeHead(status, { 'content-type': 'application/json' });
+      res.end(JSON.stringify(body));
+    };
+    if (mode === 'rate-limit') return json(403, { message: 'rate limit' });
+    if (req.url?.startsWith('/search/repositories')) {
+      return json(200, mode === 'empty' ? { total_count: 0 } : { items: REPOS });
+    }
+    if (req.url?.endsWith('/releases')) {
+      return json(200, req.url.includes('/alpha/') ? RELEASES : []);
+    }
+    json(404, { message: 'not found' });
+  });
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', r));
+  base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+
+afterAll(() => new Promise<void>((r) => server.close(() => r())));
+
+let logs: string[];
+let origLog: typeof console.log;
+let origErr: typeof console.error;
+let origExit: typeof process.exit;
+let exits: Array<number | undefined>;
+
+beforeEach(() => {
+  requests = [];
+  mode = 'ok';
+  logs = [];
+  exits = [];
+  origLog = console.log;
+  origErr = console.error;
+  origExit = process.exit;
+  console.log = (...a: unknown[]) => void logs.push(a.join(' '));
+  console.error = (...a: unknown[]) => void logs.push(a.join(' '));
+  (process as any).exit = (code?: number) => void exits.push(code);
+});
+
+afterEach(() => {
+  console.log = origLog;
+  console.error = origErr;
+  process.exit = origExit;
+});
+
+describe('GithubAPI over HTTP', () => {
+  test('searchRepositories queries by name sorted by stars and enriches release info', async () => {
+    const api = new GithubAPI({ baseURL: base });
+    const results = await api.searchRepositories('alpha', { perPage: 2 });
+
+    const search = requests.find((r) => r.url.startsWith('/search/repositories'))!;
+    expect(decodeURIComponent(search.url).replace(/\+/g, ' ')).toContain('q=alpha in:name');
+    expect(search.url).toContain('sort=stars');
+    expect(search.url).toContain('order=desc');
+    expect(search.url).toContain('per_page=2');
+
+    expect(results).toHaveLength(2);
+    const alpha = results.find((r) => r.name === 'alpha')!;
+    const beta = results.find((r) => r.name === 'beta')!;
+    expect(alpha.hasReleases).toBe(true);
+    expect(alpha.allReleases.length).toBeGreaterThan(0);
+    expect(beta.hasReleases).toBe(false);
+    expect(beta.hasCompatibleReleases).toBe(false);
+  });
+
+  test('getReleaseInfo: false returns the raw items without extra requests', async () => {
+    const api = new GithubAPI({ baseURL: base });
+    const results = await api.searchRepositories('alpha', { getReleaseInfo: false });
+    expect(results.map((r) => r.name)).toEqual(['alpha', 'beta']);
+    expect(requests.filter((r) => r.url.endsWith('/releases'))).toHaveLength(0);
+  });
+
+  test('an empty response logs and returns no results', async () => {
+    mode = 'empty';
+    const api = new GithubAPI({ baseURL: base });
+    expect(await api.searchRepositories('nothing')).toEqual([]);
+    expect(logs.join('\n')).toContain('No response');
+  });
+
+  test('sends the token as an Authorization header', async () => {
+    const api = new GithubAPI({ baseURL: base, token: 'abc123' });
+    await api.getReleases('o', 'alpha');
+    expect(requests[0].auth).toBe('token abc123');
+  });
+
+  test('falls back to GITHUB_TOKEN from the environment', async () => {
+    const prev = process.env.GITHUB_TOKEN;
+    process.env.GITHUB_TOKEN = 'envtoken';
+    try {
+      const api = new GithubAPI({ baseURL: base });
+      await api.getReleases('o', 'alpha');
+      expect(requests[0].auth).toBe('token envtoken');
+    } finally {
+      if (prev === undefined) delete process.env.GITHUB_TOKEN;
+      else process.env.GITHUB_TOKEN = prev;
+    }
+  });
+
+  test('getReleases categorizes by platform; getCompatibleReleases filters', async () => {
+    const api = new GithubAPI({ baseURL: base });
+    const all = await api.getReleases('o', 'alpha');
+    expect(all).toHaveLength(1);
+    expect(all[0].tag_name).toBe('v1.0.0');
+    expect(requests[0].url).toBe('/repos/o/alpha/releases');
+
+    const compatible = await api.getCompatibleReleases('o', 'alpha');
+    expect(Array.isArray(compatible)).toBe(true);
+  });
+
+  test('a 403 tells the user to set GITHUB_TOKEN and exits 1', async () => {
+    mode = 'rate-limit';
+    const api = new GithubAPI({ baseURL: base });
+    await api.getReleases('o', 'alpha').catch(() => {});
+    expect(logs.join('\n')).toContain('Rate limit exceeded. Set the GITHUB_TOKEN env var.');
+    expect(exits).toContain(1);
+  });
+
+  test('delegates the small helpers', () => {
+    const api = new GithubAPI({ baseURL: base });
+    expect(api.getCurrentPlatform().platform).toBe(process.platform);
+    expect(api.parseTarget('vitejs/vite')).toMatchObject({ owner: 'vitejs', name: 'vite' });
+    expect(api.parseTarget('react starter')).toBe(false);
+  });
+});

package/test/helpers/fake-shell.ts

@@ -0,0 +1,47 @@
+import { shell } from '../../src/utils.ts';
+
+/**
+ * Replaces the CLI's process-spawning seam (see `shell` in src/utils.ts) with a
+ * recorder, so install and IDE-launch logic can be observed without running
+ * anything. Works under both `vitest` and `bun test`.
+ */
+export interface FakeShell {
+  /** Commands run through `execSync`, excluding availability probes. */
+  commands: string[];
+  /** Availability probes (`command -v x` / `where x`), by tool name. */
+  probes: string[];
+  /** `spawn` calls as `[cmd, args]`. */
+  spawned: Array<[string, string[]]>;
+  restore(): void;
+}
+
+export function installFakeShell(
+  opts: { available?: string[]; failing?: string[] } = {}
+): FakeShell {
+  const { available = [], failing = [] } = opts;
+  const original = { execSync: shell.execSync, spawn: shell.spawn };
+  const fake: FakeShell = { commands: [], probes: [], spawned: [], restore() {} };
+
+  (shell as any).execSync = (cmd: string) => {
+    const probe = cmd.match(/^(?:command -v|where) (\S+)$/);
+    if (probe) {
+      fake.probes.push(probe[1]);
+      if (!available.includes(probe[1])) throw new Error(`${probe[1]}: not found`);
+      return Buffer.from('');
+    }
+    fake.commands.push(cmd);
+    if (failing.some((f) => cmd.startsWith(f))) throw new Error(`${cmd}: failed`);
+    return Buffer.from('');
+  };
+
+  (shell as any).spawn = (cmd: string, args: string[]) => {
+    fake.spawned.push([cmd, args]);
+    return { unref() {} };
+  };
+
+  fake.restore = () => {
+    (shell as any).execSync = original.execSync;
+    (shell as any).spawn = original.spawn;
+  };
+  return fake;
+}

package/test/ide.test.ts

@@ -0,0 +1,114 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { getInstalledIde, openInIDE } from '../src/ide.ts';
+import { shell } from '../src/utils.ts';
+import { installFakeShell, type FakeShell } from './helpers/fake-shell.ts';
+
+describe('getInstalledIde', () => {
+  let fake: FakeShell;
+  afterEach(() => fake?.restore());
+
+  test('returns null when no supported editor is installed', () => {
+    fake = installFakeShell();
+    expect(getInstalledIde()).toBeNull();
+    expect(fake.probes).toEqual([
+      'antigravity', 'cursor', 'windsurf', 'code', 'code-server', 'nvim', 'webstorm',
+    ]);
+  });
+
+  test('returns the first editor in priority order', () => {
+    fake = installFakeShell({ available: ['code', 'nvim', 'cursor'] });
+    expect(getInstalledIde()).toEqual({ name: 'Cursor', cmd: 'cursor' });
+    expect(fake.probes).toEqual(['antigravity', 'cursor']);
+  });
+
+  test('probes with `where` on Windows', () => {
+    fake = installFakeShell({ available: ['code'] });
+    const platform = Object.getOwnPropertyDescriptor(process, 'platform')!;
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    try {
+      expect(getInstalledIde()?.cmd).toBe('code');
+    } finally {
+      Object.defineProperty(process, 'platform', platform);
+    }
+  });
+});
+
+describe('openInIDE', () => {
+  let fake: FakeShell;
+  let logs: string[];
+  let origLog: typeof console.log;
+  let tmp: string;
+
+  beforeEach(() => {
+    logs = [];
+    origLog = console.log;
+    console.log = (...a: unknown[]) => void logs.push(a.join(' '));
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-ide-'));
+  });
+
+  afterEach(() => {
+    console.log = origLog;
+    fake?.restore();
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test('warns and spawns nothing without a supported IDE', () => {
+    fake = installFakeShell();
+    openInIDE(tmp);
+    expect(fake.spawned).toEqual([]);
+    expect(logs.join('\n')).toContain('No supported IDE found');
+  });
+
+  test('launches the IDE detached on the project directory', () => {
+    fake = installFakeShell({ available: ['code'] });
+    openInIDE(tmp);
+    expect(fake.spawned).toEqual([['code', [tmp]]]);
+    expect(logs.join('\n')).toContain(`Opening ${path.basename(tmp)} in VSCode`);
+  });
+
+  test('code-server gets --open', () => {
+    fake = installFakeShell({ available: ['code-server'] });
+    openInIDE(tmp);
+    expect(fake.spawned[0]).toEqual(['code-server', [tmp, '--open']]);
+  });
+
+  test('swallows launch errors', () => {
+    fake = installFakeShell({ available: ['code'] });
+    (shell as any).spawn = () => {
+      throw new Error('spawn failed');
+    };
+    expect(() => openInIDE(tmp)).not.toThrow();
+    expect(logs.join('\n')).not.toContain('Opening');
+  });
+
+  test('opens the README a few seconds later', async () => {
+    fake = installFakeShell({ available: ['code'] });
+    fs.writeFileSync(path.join(tmp, 'README.md'), '# hi');
+    openInIDE(tmp);
+    expect(fake.spawned).toHaveLength(1);
+    await new Promise((r) => setTimeout(r, 3200));
+    expect(fake.spawned).toHaveLength(2);
+    expect(fake.spawned[1]).toEqual(['code', [`${tmp}/README.md`]]);
+  }, 10_000);
+
+  test('falls back to package.json, and skips when there is no entry document', async () => {
+    fake = installFakeShell({ available: ['code'] });
+    fs.writeFileSync(path.join(tmp, 'package.json'), '{}');
+    openInIDE(tmp);
+    await new Promise((r) => setTimeout(r, 3200));
+    expect(fake.spawned[1]).toEqual(['code', [`${tmp}/package.json`]]);
+
+    const empty = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-ide-empty-'));
+    try {
+      const before = fake.spawned.length;
+      openInIDE(empty);
+      await new Promise((r) => setTimeout(r, 3200));
+      expect(fake.spawned.length).toBe(before + 1);
+    } finally {
+      fs.rmSync(empty, { recursive: true, force: true });
+    }
+  }, 15_000);
+});

package/test/install.test.ts

@@ -0,0 +1,132 @@
+import { describe, test, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { installDependencies } from '../src/install.ts';
+import { installFakeShell, type FakeShell } from './helpers/fake-shell.ts';
+
+describe('installDependencies', () => {
+  let cwd: string;
+  let project: string;
+  let fake: FakeShell;
+
+  const touch = (...names: string[]) => {
+    for (const n of names) fs.writeFileSync(path.join(project, n), '');
+  };
+
+  beforeEach(() => {
+    cwd = process.cwd();
+    project = fs.mkdtempSync(path.join(os.tmpdir(), 'git0-install-'));
+  });
+
+  afterEach(() => {
+    process.chdir(cwd);
+    fake?.restore();
+    fs.rmSync(project, { recursive: true, force: true });
+  });
+
+  test('changes into the target directory', async () => {
+    fake = installFakeShell();
+    await installDependencies(project);
+    expect(fs.realpathSync(process.cwd())).toBe(fs.realpathSync(project));
+  });
+
+  test('runs nothing for an empty project', async () => {
+    fake = installFakeShell({ available: ['bun'] });
+    await installDependencies(project);
+    expect(fake.commands).toEqual([]);
+  });
+
+  test('uses bun for a Node project when bun is available', async () => {
+    fake = installFakeShell({ available: ['bun'] });
+    touch('package.json');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['bun install', 'bun run dev; bun run start']);
+  });
+
+  test('falls back to npm for a Node project when bun is missing', async () => {
+    fake = installFakeShell();
+    touch('package.json');
+    await installDependencies(project);
+    expect(fake.probes).toEqual(['bun']);
+    expect(fake.commands).toEqual(['npm install', 'npm run dev; npm run start']);
+  });
+
+  test('probes with `where` on Windows', async () => {
+    fake = installFakeShell({ available: ['bun'] });
+    touch('package.json');
+    const platform = Object.getOwnPropertyDescriptor(process, 'platform')!;
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    try {
+      await installDependencies(project);
+    } finally {
+      Object.defineProperty(process, 'platform', platform);
+    }
+    expect(fake.probes).toEqual(['bun']);
+    expect(fake.commands[0]).toBe('bun install');
+  });
+
+  test('prefers docker-compose over a bare Dockerfile', async () => {
+    fake = installFakeShell();
+    touch('Dockerfile', 'docker-compose.yml');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['sudo docker-compose up -d']);
+  });
+
+  test('builds the image when only a Dockerfile exists', async () => {
+    fake = installFakeShell();
+    touch('Dockerfile');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['sudo docker build -t project .']);
+  });
+
+  test('does nothing for docker-compose.yml alone being removed mid-run', async () => {
+    fake = installFakeShell();
+    touch('docker-compose.yml');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['sudo docker-compose up -d']);
+  });
+
+  test('sets up a venv and installs requirements.txt', async () => {
+    fake = installFakeShell();
+    touch('requirements.txt');
+    await installDependencies(project);
+    expect(fake.commands).toEqual([
+      'python -m venv .venv',
+      'source .venv/bin/activate',
+      'pip install -r requirements.txt',
+    ]);
+  });
+
+  test('installs a setup.py project in editable mode', async () => {
+    fake = installFakeShell();
+    touch('setup.py');
+    await installDependencies(project);
+    expect(fake.commands).toEqual([
+      'python -m venv .venv',
+      'source .venv/bin/activate',
+      'pip install -e .',
+    ]);
+  });
+
+  test('builds Rust and Go projects', async () => {
+    fake = installFakeShell();
+    touch('Cargo.toml', 'go.mod');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['cargo build', 'go mod tidy']);
+  });
+
+  test('keeps going when an install command fails', async () => {
+    fake = installFakeShell({ failing: ['cargo'] });
+    touch('Cargo.toml', 'go.mod');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['cargo build', 'go mod tidy']);
+  });
+
+  test('handles a polyglot project in detector order', async () => {
+    fake = installFakeShell({ available: ['bun'] });
+    touch('package.json', 'go.mod');
+    await installDependencies(project);
+    expect(fake.commands).toEqual(['bun install', 'bun run dev; bun run start', 'go mod tidy']);
+  });
+});