@mondaydotcomorg/z2h-cli 0.7.2 → 0.9.1

package/src/util/git/__tests__/repo.test.ts

@@ -0,0 +1,208 @@
+import path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { execa } from 'execa';
+import fs from 'fs-extra';
+import {
+  GitConflictError,
+  defaultS3Remote,
+  cloneRepo,
+  safeBackupIfDirty,
+  pullAndResolve,
+  remoteHead,
+  localHead,
+  commitDetailedAndPush,
+  initAndPush,
+} from '../repo';
+
+vi.mock('execa', () => ({ execa: vi.fn() }));
+vi.mock('fs-extra', () => ({
+  default: {
+    copy: vi.fn(),
+    readFile: vi.fn(),
+    outputFile: vi.fn(),
+    pathExists: vi.fn(),
+  },
+}));
+
+const mockExeca = vi.mocked(execa);
+const mockFs = vi.mocked(fs, true);
+
+const DIR = '/home/user/zth-projects/my-app';
+const execaOk = (stdout = '') => ({ stdout } as never);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockFs.readFile.mockRejectedValue(new Error('ENOENT'));
+  mockFs.outputFile.mockResolvedValue(undefined);
+  mockFs.copy.mockResolvedValue(undefined);
+});
+
+// ── defaultS3Remote ──────────────────────────────────────────────────────────
+
+describe('defaultS3Remote', () => {
+  it('returns the expected S3 URL', () => {
+    expect(defaultS3Remote('my-app')).toBe('s3://prod-use1-bigbrain-zth-mf-assets/my-app/git');
+  });
+});
+
+// ── cloneRepo ────────────────────────────────────────────────────────────────
+
+describe('cloneRepo', () => {
+  it('calls git clone with correct args', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk());
+    await cloneRepo('s3://bucket/my-app/git', DIR);
+    expect(mockExeca).toHaveBeenCalledWith('git', ['clone', 's3://bucket/my-app/git', DIR]);
+  });
+});
+
+// ── initAndPush ──────────────────────────────────────────────────────────────
+
+describe('initAndPush', () => {
+  it('runs the correct git command sequence', async () => {
+    mockExeca.mockResolvedValue(execaOk());
+
+    await initAndPush(DIR, 's3://bucket/my-app/git');
+
+    const calls = mockExeca.mock.calls.map(c => c.slice(0, 2));
+    expect(calls).toContainEqual(['git', ['init', '-b', 'master']]);
+    expect(calls).toContainEqual(['git', ['add', '.']]);
+    expect(calls).toContainEqual(['git', ['commit', '-m', 'Initial commit']]);
+    expect(calls).toContainEqual(['git', ['remote', 'add', 'origin', 's3://bucket/my-app/git']]);
+    expect(calls).toContainEqual(['git', ['push', '-u', 'origin', 'master']]);
+  });
+
+  it('writes missing gitignore entries', async () => {
+    mockFs.readFile.mockResolvedValueOnce('' as never);
+    mockExeca.mockResolvedValue(execaOk());
+
+    await initAndPush(DIR, 's3://bucket/my-app/git');
+
+    expect(mockFs.outputFile).toHaveBeenCalledWith(
+      path.join(DIR, '.gitignore'),
+      expect.stringContaining('node_modules/')
+    );
+  });
+
+  it('skips gitignore write when all entries already present', async () => {
+    mockFs.readFile.mockResolvedValueOnce('node_modules/\n.zth/\nbuild/\n' as never);
+    mockExeca.mockResolvedValue(execaOk());
+
+    await initAndPush(DIR, 's3://bucket/my-app/git');
+
+    expect(mockFs.outputFile).not.toHaveBeenCalled();
+  });
+});
+
+// ── safeBackupIfDirty ────────────────────────────────────────────────────────
+
+describe('safeBackupIfDirty', () => {
+  it('copies dir to backup when working tree is dirty', async () => {
+    mockExeca
+      .mockResolvedValueOnce(execaOk('M src/index.ts')) // git status --porcelain
+      .mockResolvedValueOnce(execaOk('abc123')); // git rev-parse HEAD
+
+    await safeBackupIfDirty(DIR);
+
+    expect(mockFs.copy).toHaveBeenCalledWith(DIR, '/home/user/zth-projects/my-app.backup-abc123', { overwrite: false });
+  });
+
+  it('skips backup when working tree is clean', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk('')); // git status --porcelain — empty
+
+    await safeBackupIfDirty(DIR);
+
+    expect(mockFs.copy).not.toHaveBeenCalled();
+  });
+
+  it('skips backup silently when not a git repo', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('not a git repository'));
+
+    await expect(safeBackupIfDirty(DIR)).resolves.toBeUndefined();
+    expect(mockFs.copy).not.toHaveBeenCalled();
+  });
+});
+
+// ── pullAndResolve ───────────────────────────────────────────────────────────
+
+describe('pullAndResolve', () => {
+  it('resolves when pull fast-forwards cleanly', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk()); // git pull --ff-only
+
+    await expect(pullAndResolve(DIR)).resolves.toBeUndefined();
+  });
+
+  it('throws GitConflictError on non-fast-forward', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('fatal: Not possible to fast-forward')); // git pull
+
+    await expect(pullAndResolve(DIR)).rejects.toThrow(GitConflictError);
+  });
+});
+
+// ── remoteHead ───────────────────────────────────────────────────────────────
+
+describe('remoteHead', () => {
+  it('parses the SHA from ls-remote output', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk('deadbeef\trefs/heads/master'));
+    expect(await remoteHead(DIR)).toBe('deadbeef');
+  });
+
+  it('throws when ls-remote returns empty', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk(''));
+    await expect(remoteHead(DIR)).rejects.toThrow('could not read remote head');
+  });
+});
+
+// ── localHead ────────────────────────────────────────────────────────────────
+
+describe('localHead', () => {
+  it('returns trimmed SHA', async () => {
+    mockExeca.mockResolvedValueOnce(execaOk('abc123\n'));
+    expect(await localHead(DIR)).toBe('abc123');
+  });
+});
+
+// ── commitDetailedAndPush ────────────────────────────────────────────────────
+
+describe('commitDetailedAndPush', () => {
+  it('commits with a version-prefixed message and pushes', async () => {
+    mockExeca
+      .mockResolvedValueOnce(execaOk(' M src/index.ts\n?? new-file.ts')) // git status --short (XY + space prefix)
+      .mockResolvedValueOnce(execaOk()) // git add .
+      .mockResolvedValueOnce(execaOk()) // git commit
+      .mockResolvedValueOnce(execaOk()); // git push
+
+    await commitDetailedAndPush(DIR, 3);
+
+    const commitCall = mockExeca.mock.calls.find(c => c[0] === 'git' && (c[1] as string[])[0] === 'commit');
+    expect(commitCall).toBeDefined();
+    const msg = (commitCall![1] as string[])[2];
+    expect(msg).toMatch(/^v3:/);
+    expect(msg).toContain('src/index.ts');
+  });
+
+  it('throws GitConflictError when push is rejected', async () => {
+    mockExeca
+      .mockResolvedValueOnce(execaOk('')) // git status --short
+      .mockResolvedValueOnce(execaOk()) // git add .
+      .mockResolvedValueOnce(execaOk()) // git commit
+      .mockRejectedValueOnce(new Error('[rejected]')); // git push
+
+    await expect(commitDetailedAndPush(DIR, 4)).rejects.toThrow(GitConflictError);
+  });
+
+  it('truncates long file lists to 5 entries', async () => {
+    const manyFiles = Array.from({ length: 8 }, (_, i) => ` M file${i}.ts`).join('\n');
+    mockExeca
+      .mockResolvedValueOnce(execaOk(manyFiles))
+      .mockResolvedValueOnce(execaOk())
+      .mockResolvedValueOnce(execaOk())
+      .mockResolvedValueOnce(execaOk());
+
+    await commitDetailedAndPush(DIR, 1);
+
+    const commitCall = mockExeca.mock.calls.find(c => c[0] === 'git' && (c[1] as string[])[0] === 'commit');
+    const msg = (commitCall![1] as string[])[2];
+    expect(msg).toContain('+3 more');
+  });
+});

package/src/util/git/repo.ts

@@ -0,0 +1,112 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { BUCKET_WRITE_NAME } from '../../constants';
+
+export class GitConflictError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GitConflictError';
+  }
+}
+
+const REQUIRED_GITIGNORE_ENTRIES = ['node_modules/', '.zth/', 'build/'];
+
+export function defaultS3Remote(app: string): string {
+  return `s3://${BUCKET_WRITE_NAME}/${app}/git`;
+}
+
+export async function initAndPush(dir: string, remote: string): Promise<void> {
+  await ensureGitignore(dir);
+  await execa('git', ['init', '-b', 'master'], { cwd: dir });
+  await execa('git', ['add', '.'], { cwd: dir });
+  await execa('git', ['commit', '-m', 'Initial commit'], { cwd: dir });
+  await execa('git', ['remote', 'add', 'origin', remote], { cwd: dir });
+  await execa('git', ['push', '-u', 'origin', 'master'], { cwd: dir });
+}
+
+export async function cloneRepo(remote: string, dir: string): Promise<void> {
+  await execa('git', ['clone', remote, dir]);
+}
+
+export async function safeBackupIfDirty(dir: string): Promise<void> {
+  let status: string;
+  try {
+    ({ stdout: status } = await execa('git', ['status', '--porcelain'], { cwd: dir }));
+  } catch {
+    return;
+  }
+  if (!status.trim()) {
+    return;
+  }
+  const sha = await localHead(dir).catch(() => 'unknown');
+  const appName = path.basename(dir);
+  const backupDir = path.join(path.dirname(dir), `${appName}.backup-${sha}`);
+  await fs.copy(dir, backupDir, { overwrite: false });
+}
+
+export async function pullAndResolve(dir: string): Promise<void> {
+  try {
+    await execa('git', ['pull', '--ff-only'], { cwd: dir });
+  } catch {
+    // TODO(Phase 7): safeBackupIfDirty(dir) → resolveDivergence(dir) instead of throwing
+    throw new GitConflictError(
+      'This app changed while you were working — please re-open it to get the latest version.'
+    );
+  }
+}
+
+export async function remoteHead(dir: string): Promise<string> {
+  const { stdout } = await execa('git', ['ls-remote', 'origin', 'refs/heads/master'], { cwd: dir });
+  const sha = stdout.split('\t')[0]?.trim();
+  if (!sha) {
+    throw new Error('could not read remote head — is the remote reachable?');
+  }
+  return sha;
+}
+
+export async function localHead(dir: string): Promise<string> {
+  const { stdout } = await execa('git', ['rev-parse', 'HEAD'], { cwd: dir });
+  return stdout.trim();
+}
+
+export async function commitDetailedAndPush(dir: string, version: number): Promise<void> {
+  const message = await buildCommitMessage(dir, version);
+  await execa('git', ['add', '.'], { cwd: dir });
+  await execa('git', ['commit', '-m', message], { cwd: dir });
+  try {
+    await execa('git', ['push'], { cwd: dir });
+  } catch {
+    throw new GitConflictError('push rejected — remote has new commits');
+  }
+}
+
+async function buildCommitMessage(dir: string, version: number): Promise<string> {
+  // TODO(Phase 7): replace with LLM-generated summary using git diff + commit messages
+  const { stdout } = await execa('git', ['status', '--short'], { cwd: dir });
+  const files = stdout
+    .split('\n')
+    .map(line => line.slice(3).trim())
+    .filter(Boolean);
+  const fileList = files.length
+    ? files.slice(0, 5).join(', ') + (files.length > 5 ? ` (+${files.length - 5} more)` : '')
+    : 'no changes';
+  return `v${version}: deploy — ${fileList}`;
+}
+
+async function ensureGitignore(dir: string): Promise<void> {
+  const gitignorePath = path.join(dir, '.gitignore');
+  let content = '';
+  try {
+    content = await fs.readFile(gitignorePath, 'utf8');
+  } catch {
+    // file doesn't exist yet
+  }
+  const lines = content.split('\n').map(l => l.trim());
+  const missing = REQUIRED_GITIGNORE_ENTRIES.filter(entry => !lines.includes(entry));
+  if (missing.length === 0) {
+    return;
+  }
+  const separator = content && !content.endsWith('\n') ? '\n' : '';
+  await fs.outputFile(gitignorePath, content + separator + missing.join('\n') + '\n');
+}

package/src/util/manifest.ts

@@ -23,6 +23,7 @@ export interface AssetManifestFile {
   nonExternalsEntrypoints?: string[];
   scriptType?: 'module' | 'classic';
   mfs?: string[];
+  gitRemote: string;
 }
 
 export interface ManifestEntry extends AssetManifestFile {