@smoothbricks/cli 0.4.3 → 0.5.0

package/src/lib/conflict-markers.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  assertNoConflictMarkers,
+  type ConflictMarkerHit,
+  ConflictMarkersError,
+  findMarkerLines,
+  formatMarkerHits,
+  type MarkerScanShell,
+  parseGitGrep,
+  scanRefChangedForMarkers,
+  scanTrackedForMarkers,
+} from './conflict-markers.js';
+
+describe('findMarkerLines', () => {
+  it('detects ours/base/theirs markers with their 1-based line numbers', () => {
+    const text = [
+      '{',
+      '<<<<<<< HEAD',
+      '  "a": 1',
+      '||||||| base',
+      '  "a": 0',
+      '=======',
+      '  "a": 2',
+      '>>>>>>> feat',
+      '}',
+    ].join('\n');
+    expect(findMarkerLines(text)).toEqual([2, 4, 8]);
+  });
+
+  it('does not flag a bare ======= separator (Markdown h1 / diff fill)', () => {
+    expect(findMarkerLines('Title\n=======\nbody')).toEqual([]);
+  });
+
+  it('does not flag quoted/indented marker strings in source', () => {
+    const source = ["const OPEN = '<<<<<<< ';", "  const CLOSE = '>>>>>>> ';", 'const P = /^<<<<<<< /;'].join('\n');
+    expect(findMarkerLines(source)).toEqual([]);
+  });
+
+  it('returns empty for clean text', () => {
+    expect(findMarkerLines('{\n  "a": 1\n}\n')).toEqual([]);
+  });
+});
+
+describe('parseGitGrep', () => {
+  it('groups path:line:content rows by file', () => {
+    const stdout = ['pkg/a.json:12:<<<<<<< HEAD', 'pkg/a.json:16:>>>>>>> x', 'b.toml:36:<<<<<<< HEAD', ''].join('\n');
+    expect(parseGitGrep(stdout)).toEqual([
+      { file: 'pkg/a.json', lines: [12, 16] },
+      { file: 'b.toml', lines: [36] },
+    ]);
+  });
+
+  it('tolerates paths containing colons in content and skips malformed rows', () => {
+    const stdout = ['a.ts:3:foo: bar', 'garbage-without-colon', 'a.ts:9:>>>>>>> y'].join('\n');
+    expect(parseGitGrep(stdout)).toEqual([{ file: 'a.ts', lines: [3, 9] }]);
+  });
+
+  it('returns empty for empty output', () => {
+    expect(parseGitGrep('')).toEqual([]);
+  });
+});
+
+describe('scanTrackedForMarkers', () => {
+  it('returns hits when git grep finds markers (exit 0)', async () => {
+    const shell = scriptedShell([{ exitCode: 0, stdout: 'x.json:2:<<<<<<< HEAD\n', stderr: '' }]);
+    const hits = await scanTrackedForMarkers(shell.shell, '/repo');
+    expect(hits).toEqual([{ file: 'x.json', lines: [2] }]);
+    expect(shell.calls[0].args).toEqual(['grep', '-nI', '-E', '^(<<<<<<< |\\|\\|\\|\\|\\|\\|\\| |>>>>>>> )']);
+  });
+
+  it('passes pathspecs through after --', async () => {
+    const shell = scriptedShell([{ exitCode: 1, stdout: '', stderr: '' }]);
+    await scanTrackedForMarkers(shell.shell, '/repo', ['packages/a', 'packages/b']);
+    expect(shell.calls[0].args.slice(-3)).toEqual(['--', 'packages/a', 'packages/b']);
+  });
+
+  it('treats exit 1 as no matches', async () => {
+    const shell = scriptedShell([{ exitCode: 1, stdout: '', stderr: '' }]);
+    expect(await scanTrackedForMarkers(shell.shell, '/repo')).toEqual([]);
+  });
+
+  it('throws on git grep error (exit > 1)', async () => {
+    const shell = scriptedShell([{ exitCode: 128, stdout: '', stderr: 'not a git repo' }]);
+    await expect(scanTrackedForMarkers(shell.shell, '/repo')).rejects.toThrow('not a git repo');
+  });
+});
+
+describe('scanRefChangedForMarkers', () => {
+  it('reads changed-file blobs at head and reports only markered files', async () => {
+    const shell = scriptedShell([
+      { exitCode: 0, stdout: 'pkg/a.json\npkg/clean.ts\n', stderr: '' }, // git diff --name-only
+      { exitCode: 0, stdout: '{\n<<<<<<< HEAD\n=======\n>>>>>>> feat\n}\n', stderr: '' }, // show a.json
+      { exitCode: 0, stdout: 'export const ok = 1;\n', stderr: '' }, // show clean.ts
+    ]);
+    const hits = await scanRefChangedForMarkers(shell.shell, '/repo', 'base', 'head');
+    expect(hits).toEqual([{ file: 'pkg/a.json', lines: [2, 4] }]);
+    expect(shell.calls[0].args).toEqual(['diff', '--name-only', 'base...head']);
+    expect(shell.calls[1].args).toEqual(['show', 'head:pkg/a.json', '--textconv']);
+  });
+
+  it('skips files deleted/unreadable at head', async () => {
+    const shell = scriptedShell([
+      { exitCode: 0, stdout: 'gone.txt\n', stderr: '' },
+      { exitCode: 128, stdout: '', stderr: 'exists on disk, but not in head' },
+    ]);
+    expect(await scanRefChangedForMarkers(shell.shell, '/repo', 'base', 'head')).toEqual([]);
+  });
+});
+
+describe('formatMarkerHits', () => {
+  it('formats file + line list per hit', () => {
+    const hits: ConflictMarkerHit[] = [
+      { file: 'a.json', lines: [12, 16] },
+      { file: 'b.toml', lines: [3] },
+    ];
+    expect(formatMarkerHits(hits)).toBe('  a.json (lines 12, 16)\n  b.toml (lines 3)');
+  });
+});
+
+interface ScriptedCall {
+  command: string;
+  args: string[];
+  cwd: string;
+}
+
+function scriptedShell(responses: { exitCode: number; stdout: string; stderr: string }[]): {
+  shell: MarkerScanShell;
+  calls: ScriptedCall[];
+} {
+  const calls: ScriptedCall[] = [];
+  let index = 0;
+  const shell: MarkerScanShell = {
+    async runResult(command, args, cwd) {
+      calls.push({ command, args, cwd });
+      const response = responses[index++];
+      if (!response) {
+        throw new Error(`unexpected shell call: ${command} ${args.join(' ')}`);
+      }
+      return response;
+    },
+  };
+  return { shell, calls };
+}
+
+describe('assertNoConflictMarkers', () => {
+  it('throws ConflictMarkersError listing hits when markers exist', async () => {
+    const shell = scriptedShell([{ exitCode: 0, stdout: 'a.json:2:<<<<<<< HEAD\n', stderr: '' }]);
+    let caught: unknown;
+    try {
+      await assertNoConflictMarkers(shell.shell, '/repo', 'publish');
+    } catch (error) {
+      caught = error;
+    }
+    expect(caught).toBeInstanceOf(ConflictMarkersError);
+    if (caught instanceof ConflictMarkersError) {
+      expect(caught.hits).toEqual([{ file: 'a.json', lines: [2] }]);
+      expect(caught.message).toContain('Refusing to publish');
+    }
+  });
+
+  it('resolves when the tree is clean', async () => {
+    const shell = scriptedShell([{ exitCode: 1, stdout: '', stderr: '' }]);
+    await expect(assertNoConflictMarkers(shell.shell, '/repo', 'publish')).resolves.toBeUndefined();
+  });
+});

package/src/lib/conflict-markers.ts

@@ -0,0 +1,150 @@
+/**
+ * Shared detection of Git merge-conflict markers.
+ *
+ * Real conflict markers always sit at column 0 and are a 7-character run of
+ * `<`, `|`, or `>` followed by a space (the diff3 base marker `|||||||` and the
+ * ours/theirs markers `<<<<<<< ` / `>>>>>>> `). We deliberately do NOT match a
+ * bare `=======` separator: it is ambiguous with Markdown h1 underlines and adds
+ * no signal (a real conflict always carries the angle/pipe markers too). The
+ * column-0 anchor also means quoted marker strings inside source (which are
+ * indented) never false-positive.
+ */
+export const CONFLICT_MARKER_PATTERN = '^(<<<<<<< |\\|\\|\\|\\|\\|\\|\\| |>>>>>>> )';
+
+const conflictMarkerRe = new RegExp(CONFLICT_MARKER_PATTERN);
+
+export interface ConflictMarkerHit {
+  /** Repo-relative path of the offending file. */
+  readonly file: string;
+  /** 1-based line numbers carrying a conflict marker. */
+  readonly lines: number[];
+}
+
+/** 1-based line numbers of every conflict-marker line in `text`. */
+export function findMarkerLines(text: string): number[] {
+  const hits: number[] = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (conflictMarkerRe.test(lines[i])) {
+      hits.push(i + 1);
+    }
+  }
+  return hits;
+}
+
+export interface MarkerScanShell {
+  runResult(
+    command: string,
+    args: string[],
+    cwd: string,
+  ): Promise<{ exitCode: number; stdout: string; stderr: string }>;
+}
+
+/**
+ * Scan tracked files in the working tree for conflict markers via `git grep`.
+ * `pathspecs` optionally restricts the scan (e.g. release package roots).
+ */
+export async function scanTrackedForMarkers(
+  shell: MarkerScanShell,
+  root: string,
+  pathspecs: string[] = [],
+): Promise<ConflictMarkerHit[]> {
+  const args = ['grep', '-nI', '-E', CONFLICT_MARKER_PATTERN];
+  if (pathspecs.length > 0) {
+    args.push('--', ...pathspecs);
+  }
+  const { exitCode, stdout, stderr } = await shell.runResult('git', args, root);
+  // git grep: 0 = matches found, 1 = no matches, >1 = error.
+  if (exitCode > 1) {
+    throw new Error(`git grep for conflict markers failed: ${stderr.trim() || `exit ${exitCode}`}`);
+  }
+  return parseGitGrep(stdout);
+}
+
+/** Thrown by {@link assertNoConflictMarkers} so callers/tests can inspect the hits. */
+export class ConflictMarkersError extends Error {
+  constructor(
+    readonly hits: ConflictMarkerHit[],
+    context: string,
+  ) {
+    super(`Refusing to ${context}: conflict markers found in ${hits.length} file(s):\n${formatMarkerHits(hits)}`);
+    this.name = 'ConflictMarkersError';
+  }
+}
+
+/**
+ * Reusable publish/merge guard: throw {@link ConflictMarkersError} when any
+ * tracked file carries conflict markers. `context` names the blocked operation
+ * (e.g. `'publish'`) for the message.
+ */
+export async function assertNoConflictMarkers(shell: MarkerScanShell, root: string, context: string): Promise<void> {
+  const hits = await scanTrackedForMarkers(shell, root);
+  if (hits.length > 0) {
+    throw new ConflictMarkersError(hits, context);
+  }
+}
+
+/**
+ * Scan the files changed between `baseRef` and `headRef` (three-dot, i.e. since
+ * their merge base) for conflict markers, reading blobs at `headRef` — no
+ * checkout or working-tree mutation required.
+ */
+export async function scanRefChangedForMarkers(
+  shell: MarkerScanShell,
+  root: string,
+  baseRef: string,
+  headRef: string,
+): Promise<ConflictMarkerHit[]> {
+  const diff = await shell.runResult('git', ['diff', '--name-only', `${baseRef}...${headRef}`], root);
+  if (diff.exitCode !== 0) {
+    throw new Error(`git diff ${baseRef}...${headRef} failed: ${diff.stderr.trim() || `exit ${diff.exitCode}`}`);
+  }
+  const files = diff.stdout.split('\n').filter((line) => line.length > 0);
+  const hits: ConflictMarkerHit[] = [];
+  for (const file of files) {
+    const show = await shell.runResult('git', ['show', `${headRef}:${file}`, '--textconv'], root);
+    if (show.exitCode !== 0) {
+      continue; // deleted at head / binary / unreadable — not a marker source
+    }
+    const lines = findMarkerLines(show.stdout);
+    if (lines.length > 0) {
+      hits.push({ file, lines });
+    }
+  }
+  return hits;
+}
+
+/** Parse `path:line:content` rows from `git grep -n` into per-file hits. */
+export function parseGitGrep(stdout: string): ConflictMarkerHit[] {
+  const byFile = new Map<string, number[]>();
+  for (const row of stdout.split('\n')) {
+    if (row.length === 0) {
+      continue;
+    }
+    const firstColon = row.indexOf(':');
+    if (firstColon < 0) {
+      continue;
+    }
+    const secondColon = row.indexOf(':', firstColon + 1);
+    if (secondColon < 0) {
+      continue;
+    }
+    const file = row.slice(0, firstColon);
+    const line = Number.parseInt(row.slice(firstColon + 1, secondColon), 10);
+    if (!Number.isFinite(line)) {
+      continue;
+    }
+    const existing = byFile.get(file);
+    if (existing) {
+      existing.push(line);
+    } else {
+      byFile.set(file, [line]);
+    }
+  }
+  return [...byFile.entries()].map(([file, lines]) => ({ file, lines }));
+}
+
+/** Human-readable one-liner summary of marker hits, e.g. for CLI output. */
+export function formatMarkerHits(hits: ConflictMarkerHit[]): string {
+  return hits.map((hit) => `  ${hit.file} (lines ${hit.lines.join(', ')})`).join('\n');
+}

package/src/pr/index.test.ts

@@ -0,0 +1,187 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from 'bun:test';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { type PrResolveShell, resolvePrConflicts } from './index.js';
+
+let gitDir: string;
+
+beforeEach(() => {
+  gitDir = mkdtempSync(join(tmpdir(), 'smoo-pr-'));
+  spyOn(console, 'log').mockImplementation(() => {});
+  spyOn(console, 'error').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  rmSync(gitDir, { recursive: true, force: true });
+});
+
+const PR_JSON = JSON.stringify({
+  number: 40,
+  url: 'https://github.com/conloca/private/pull/40',
+  headRefName: 'gar-sync/private-to-public',
+  baseRefName: 'public-mirror',
+  isCrossRepository: false,
+});
+const MARKERED = '{\n<<<<<<< HEAD\n  "a": 1\n=======\n  "a": 2\n>>>>>>> feat\n}\n';
+const CLEAN = '{\n  "a": 1\n}\n';
+
+const statePath = () => join(gitDir, 'smoo', 'pr-resolve.json');
+
+describe('smoo pr resolve — phase A (start)', () => {
+  it('reports clean and writes no state when the PR has no markers', async () => {
+    const shell = scriptedShell([
+      ok(gitDir), // rev-parse --absolute-git-dir
+      ok(''), // status --porcelain (clean tree)
+      ok(PR_JSON), // gh pr view
+      ok('a.json\n'), // diff --name-only base...head
+      ok(CLEAN), // show head:a.json
+    ]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runCommands).not.toContainEqual(expect.stringContaining('checkout'));
+  });
+
+  it('checks out the branch, saves state, and returns 2 when markers exist', async () => {
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok(''),
+      ok(PR_JSON),
+      ok('a.json\n'),
+      ok(MARKERED),
+      ok('main\n'), // symbolic-ref (current branch)
+      ok('deadbeefcafe\n'), // rev-parse HEAD
+    ]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(2);
+    const state = JSON.parse(readFileSync(statePath(), 'utf8'));
+    expect(state.pr).toBe(40);
+    expect(state.headBranch).toBe('gar-sync/private-to-public');
+    expect(state.originalBranch).toBe('main');
+    expect(state.remote).toBe('origin');
+    expect(shell.runCommands).toContainEqual(
+      'git checkout -B gar-sync/private-to-public origin/gar-sync/private-to-public',
+    );
+  });
+
+  it('refuses to start on a dirty working tree', async () => {
+    const shell = scriptedShell([ok(gitDir), ok(' M src/x.ts\n')]);
+    const exit = await resolvePrConflicts('/repo', '40', { remote: 'origin' }, shell.shell);
+    expect(exit).toBe(1);
+    expect(existsSync(statePath())).toBe(false);
+  });
+});
+
+describe('smoo pr resolve — phase B (finish)', () => {
+  it('pushes and restores the original branch when markers are resolved', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok('gar-sync/private-to-public\n'), // symbolic-ref (on the PR branch)
+      ok(''), // status --porcelain (committed, clean)
+      ok('a.json\n'), // diff --name-only base...HEAD
+      ok(CLEAN), // show HEAD:a.json (resolved)
+      ok(''), // git push (fast-forward)
+    ]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runResultCommands).toContainEqual('git push origin HEAD:refs/heads/gar-sync/private-to-public');
+    expect(shell.runCommands).toContainEqual('git checkout main');
+  });
+
+  it('returns 2 and keeps state when markers still remain', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([
+      ok(gitDir),
+      ok('gar-sync/private-to-public\n'),
+      ok(''),
+      ok('a.json\n'),
+      ok(MARKERED), // still markered
+    ]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(2);
+    expect(existsSync(statePath())).toBe(true);
+    expect(shell.runResultCommands).not.toContainEqual(expect.stringContaining('push'));
+  });
+
+  it('returns 2 when the resolution is not committed', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir), ok('gar-sync/private-to-public\n'), ok(' M a.json\n')]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(2);
+    expect(existsSync(statePath())).toBe(true);
+  });
+
+  it('errors when HEAD is not on the PR branch', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir), ok('some-other-branch\n')]);
+    const exit = await resolvePrConflicts('/repo', undefined, {}, shell.shell);
+    expect(exit).toBe(1);
+    expect(existsSync(statePath())).toBe(true);
+  });
+
+  it('errors when pointed at a different PR mid-resolution', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir)]);
+    const exit = await resolvePrConflicts('/repo', '99', {}, shell.shell);
+    expect(exit).toBe(1);
+  });
+});
+
+describe('smoo pr resolve --abort', () => {
+  it('restores the original branch and clears state', async () => {
+    writeState({ originalBranch: 'main' });
+    const shell = scriptedShell([ok(gitDir)]);
+    const exit = await resolvePrConflicts('/repo', undefined, { abort: true }, shell.shell);
+    expect(exit).toBe(0);
+    expect(existsSync(statePath())).toBe(false);
+    expect(shell.runCommands).toContainEqual('git checkout main');
+  });
+});
+
+function writeState(overrides: Record<string, unknown>): void {
+  mkdirSync(join(gitDir, 'smoo'), { recursive: true });
+  const state = {
+    pr: 40,
+    url: 'https://github.com/conloca/private/pull/40',
+    headBranch: 'gar-sync/private-to-public',
+    baseBranch: 'public-mirror',
+    remote: 'origin',
+    crossRepo: false,
+    originalBranch: 'main',
+    originalSha: 'deadbeefcafe',
+    startedAt: '2026-07-01T00:00:00Z',
+    ...overrides,
+  };
+  writeFileSync(statePath(), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+function ok(stdout: string): { exitCode: number; stdout: string; stderr: string } {
+  return { exitCode: 0, stdout, stderr: '' };
+}
+
+function scriptedShell(responses: { exitCode: number; stdout: string; stderr: string }[]): {
+  shell: PrResolveShell;
+  runCommands: string[];
+  runResultCommands: string[];
+} {
+  const runCommands: string[] = [];
+  const runResultCommands: string[] = [];
+  let index = 0;
+  const shell: PrResolveShell = {
+    async runResult(command, args, _cwd) {
+      runResultCommands.push(`${command} ${args.join(' ')}`);
+      const response = responses[index++];
+      if (!response) {
+        throw new Error(`unexpected runResult call: ${command} ${args.join(' ')}`);
+      }
+      return response;
+    },
+    async run(command, args, _cwd) {
+      runCommands.push(`${command} ${args.join(' ')}`);
+    },
+  };
+  return { shell, runCommands, runResultCommands };
+}