@teambit/ci 1.0.485 → 1.0.487

package/sync/sync-state.spec.ts

@@ -0,0 +1,263 @@
+import { expect } from 'chai';
+import {
+  ABSENT_ON_BRANCH,
+  LANE_HEAD_TRAILER,
+  SYNC_COMMIT_MARKER,
+  branchStateFingerprint,
+  buildSyncCommitMessage,
+  fingerprintIdVersions,
+  hasSyncMarker,
+  isSyncAuthoredMessage,
+  parseBranchBitmap,
+  parseDevCommitCount,
+} from './sync-state';
+
+const DEFAULT_SCOPE = 'acme.shop';
+const SNAP_1 = 'a'.repeat(40);
+const SNAP_2 = 'b'.repeat(40);
+
+const LANE_SYNC = buildSyncCommitMessage('acme.shop/my-lane', 'a'.repeat(40));
+const MAIN_SYNC = 'chore(bit-sync): sync git to latest main scope versions\n\n[bit-sync]';
+/** `executeMergeDiverged`'s snap message: a LANE message, whose marker is inline and never a tip. */
+const LANE_SNAP = 'merge remote lane acme.shop/my-lane into my-lane [bit-sync]';
+
+describe('buildSyncCommitMessage', () => {
+  it('names the lane scope-qualified in the subject and carries both annotations', () => {
+    expect(LANE_SYNC.split('\n', 1)[0]).to.equal(`chore(bit-sync): sync lane acme.shop/my-lane @ ${'a'.repeat(9)}`);
+    expect(LANE_SYNC).to.include(`${LANE_HEAD_TRAILER}: ${'a'.repeat(40)}`);
+    expect(LANE_SYNC).to.include(SYNC_COMMIT_MARKER);
+    expect(buildSyncCommitMessage('other.scope/my-lane', 'b'.repeat(40))).to.include('sync lane other.scope/my-lane');
+  });
+});
+
+/**
+ * `hasSyncMarker` is the permissive loop guard; `isSyncAuthoredMessage` is an input to branch DELETION,
+ * so a false positive there costs a developer's branch. Every row states both answers, and the rows
+ * where they disagree are the laundering holes the strict probe exists to close.
+ */
+const MESSAGES: Array<[string, string, boolean, boolean]> = [
+  // message, hasSyncMarker, isSyncAuthoredMessage
+  ['what buildSyncCommitMessage produces', LANE_SYNC, true, true],
+  ['the raw `git log %B` shape, trailing newline and all', `${LANE_SYNC}\n`, true, true],
+  ['the main-scope sync commit, whose marker is also its own line', MAIN_SYNC, true, true],
+  ['CRLF line endings', `subject\r\n\r\n${SYNC_COMMIT_MARKER}\r\n`, true, true],
+  ['a message that merely quotes the marker mid-line', 'revert the [bit-sync] bitmap churn', true, false],
+  ['the marker quoted mid-line inside a body', 'fix: undo\n\nthis reverts a [bit-sync] commit\n', true, false],
+  ['the marker mentioned in a subject', 'chore: mention [bit-sync] here', true, false],
+  ['the inline-marker lane snap message', LANE_SNAP, true, false],
+  ['an ordinary commit', 'feat: something', false, false],
+  ['the lane-head trailer on its own', `${LANE_HEAD_TRAILER}: ${'c'.repeat(40)}`, false, false],
+];
+
+describe('sync-commit recognition', () => {
+  MESSAGES.forEach(([name, message, marker, authored]) => {
+    it(`${authored ? 'accepts' : 'REJECTS'} ${name}`, () => {
+      expect(hasSyncMarker(message), 'loop guard').to.equal(marker);
+      expect(isSyncAuthoredMessage(message), 'deletion gate').to.equal(authored);
+    });
+  });
+});
+
+/** A `.bitmap` in the exact shape bit writes it (schema 17) — what `git show` hands the parser. */
+function bitmapContent({
+  lane,
+  components = { comp1: SNAP_1, comp2: SNAP_2 },
+  prefix = '/**\n * DO NOT EDIT THIS FILE\n */\n\n',
+}: {
+  lane?: { scope: string; name: string };
+  components?: Record<string, string>;
+  prefix?: string;
+} = {}): string {
+  const body: Record<string, any> = {};
+  Object.entries(components).forEach(([name, version]) => {
+    body[name] = { name, scope: DEFAULT_SCOPE, version, mainFile: 'index.js', rootDir: name };
+  });
+  if (lane) body._bit_lane = { id: lane, exported: true };
+  body['$schema-version'] = '17.0.0';
+  return `${prefix}${JSON.stringify(body, null, 4)}`;
+}
+
+/** a `.bitmap` carrying whatever `_bit_lane` value the caller wants to see rejected */
+function bitmapWithRawLaneKey(laneKey: any): string {
+  return JSON.stringify({
+    comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'comp1' },
+    _bit_lane: laneKey,
+    '$schema-version': '17.0.0',
+  });
+}
+
+const onLane = (name = 'my-lane', scope = DEFAULT_SCOPE) =>
+  parseBranchBitmap(bitmapContent({ lane: { scope, name } }), DEFAULT_SCOPE) as NonNullable<
+    ReturnType<typeof parseBranchBitmap>
+  >;
+
+describe('parseBranchBitmap', () => {
+  it('reads the lane pointer scope-qualified — the attribution the ownership rule is built on', () => {
+    expect(onLane('my-lane', 'other.scope').laneIdStr).to.equal('other.scope/my-lane');
+  });
+
+  it('reads every component at the exact version the branch records', () => {
+    expect(onLane().versions).to.deep.equal({
+      [`${DEFAULT_SCOPE}/comp1`]: SNAP_1,
+      [`${DEFAULT_SCOPE}/comp2`]: SNAP_2,
+    });
+  });
+
+  it('survives the comment header bit prefixes every `.bitmap` with', () => {
+    // `.bitmap` is JSON-with-comments; a throw here silently degrades every branch to "not ours".
+    const state = parseBranchBitmap(
+      bitmapContent({ lane: { scope: DEFAULT_SCOPE, name: 'my-lane' }, prefix: '/* generated, do not edit */\n' }),
+      DEFAULT_SCOPE
+    );
+    expect(state?.laneIdStr).to.equal(`${DEFAULT_SCOPE}/my-lane`);
+  });
+
+  /**
+   * Only a pointer bit marked exported, carrying a scoped id, is attribution. Honouring anything else
+   * would read "lane removed" for a lane that never existed remotely and retire a developer branch —
+   * and a bare name could still trigger the branch-aliasing halt over a lane that does not exist.
+   */
+  const POINTERS: Array<[string, any, string | undefined]> = [
+    ['bit marked it not exported', { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: false }, undefined],
+    ['`exported` is missing entirely', { id: { scope: DEFAULT_SCOPE, name: 'foo' } }, undefined],
+    ['it is an empty object', {}, undefined],
+    ['`id` is a string rather than a {scope, name}', { id: `${DEFAULT_SCOPE}/foo`, exported: true }, undefined],
+    ['the lane id has no scope', { id: { scope: '', name: 'foo' }, exported: true }, undefined],
+    // non-vacuity for the rows above: a well-formed pointer through the same helper DOES attribute
+    [
+      'bit has marked the lane exported',
+      { id: { scope: DEFAULT_SCOPE, name: 'foo' }, exported: true },
+      `${DEFAULT_SCOPE}/foo`,
+    ],
+  ];
+
+  POINTERS.forEach(([name, laneKey, laneIdStr]) => {
+    it(`withholds attribution unless the pointer is usable: ${name}`, () => {
+      const state = parseBranchBitmap(bitmapWithRawLaneKey(laneKey), DEFAULT_SCOPE);
+      expect(state?.laneIdStr).to.equal(laneIdStr);
+    });
+  });
+
+  it('reports no lane pointer at all for a `.bitmap` on main — every ordinary developer branch', () => {
+    const state = parseBranchBitmap(bitmapContent(), DEFAULT_SCOPE);
+    expect(state).to.not.equal(undefined);
+    expect(state?.laneIdStr).to.equal(undefined);
+  });
+
+  /** Every way of not knowing must resolve to the answer that licenses nothing (no branch retired). */
+  const UNREADABLE: Array<[string, string | undefined]> = [
+    ['a `.bitmap` that is not valid JSON', '{ this is not json'],
+    ['a file git could not produce at all', undefined],
+    ['an empty file', ''],
+    ['a whitespace-only file', '   \n '],
+    [
+      'an entry bit itself refuses — a scoped component with no version',
+      JSON.stringify({
+        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },
+        '$schema-version': '17.0.0',
+      }),
+    ],
+    [
+      'two components claiming the same rootDir',
+      JSON.stringify({
+        comp1: { name: 'comp1', scope: DEFAULT_SCOPE, version: SNAP_1, mainFile: 'index.js', rootDir: 'shared' },
+        comp2: { name: 'comp2', scope: DEFAULT_SCOPE, version: SNAP_2, mainFile: 'index.js', rootDir: 'shared' },
+        '$schema-version': '17.0.0',
+      }),
+    ],
+  ];
+
+  UNREADABLE.forEach(([name, content]) => {
+    it(`degrades to undefined rather than guessing, for ${name}`, () => {
+      expect(parseBranchBitmap(content, DEFAULT_SCOPE)).to.equal(undefined);
+    });
+  });
+
+  it('falls back to the repository default scope for a component `.bitmap` does not scope', () => {
+    // `latest` can never equal a snap hash, so such a pair reads as not-converged — the safe direction.
+    const content = JSON.stringify({
+      comp1: { name: 'comp1', scope: '', defaultScope: DEFAULT_SCOPE, mainFile: 'index.js', rootDir: 'comp1' },
+      '$schema-version': '17.0.0',
+    });
+    expect(parseBranchBitmap(content, DEFAULT_SCOPE)?.versions).to.deep.equal({
+      [`${DEFAULT_SCOPE}/comp1`]: 'latest',
+    });
+  });
+});
+
+/**
+ * Only a count git actually printed may report "no dev commits" — that answer is an input to branch
+ * retirement, so every unreadable shape must read as "there is unmerged work" and keep the branch.
+ */
+const DEV_COMMIT_COUNTS: Array<[string, string, boolean]> = [
+  ['a count of commits on top of the state commit', '3', true],
+  ['the raw output shape, trailing newline and all', '3\n', true],
+  ['a genuine zero — the only license to retire', '0', false],
+  ["a genuine zero with git's trailing newline", '0\n', false],
+  ['empty output, which simple-git resolves with on some non-zero exits', '', true],
+  ['whitespace-only output', '  \n ', true],
+  ['git writing an error where the count was expected', 'fatal: bad revision', true],
+];
+
+describe('parseDevCommitCount', () => {
+  DEV_COMMIT_COUNTS.forEach(([name, raw, hasDevCommits]) => {
+    it(`${hasDevCommits ? 'keeps the branch' : 'permits retirement'} for ${name}`, () => {
+      expect(parseDevCommitCount(raw), JSON.stringify(raw)).to.equal(hasDevCommits);
+    });
+  });
+});
+
+describe('fingerprintIdVersions', () => {
+  it('is a single 40-hex token, and stable under reordering', () => {
+    // A single token survives being written into a commit trailer; order-stability keeps neither
+    // listing order looking like a state change.
+    const a = `${DEFAULT_SCOPE}/comp1@${SNAP_1}`;
+    const b = `${DEFAULT_SCOPE}/comp2@${SNAP_2}`;
+    expect(fingerprintIdVersions([a])).to.match(/^[0-9a-f]{40}$/);
+    expect(fingerprintIdVersions([a, b])).to.equal(fingerprintIdVersions([b, a]));
+  });
+});
+
+describe('branchStateFingerprint', () => {
+  const laneIds = [`${DEFAULT_SCOPE}/comp1`, `${DEFAULT_SCOPE}/comp2`];
+
+  it('equals the lane fingerprint when the branch records every lane component at the lane head', () => {
+    // Computed the way `laneHeadFingerprint` computes it — the two sides must be comparable.
+    const laneSide = fingerprintIdVersions([`${DEFAULT_SCOPE}/comp1@${SNAP_1}`, `${DEFAULT_SCOPE}/comp2@${SNAP_2}`]);
+    expect(branchStateFingerprint(onLane(), laneIds)).to.equal(laneSide);
+  });
+
+  it('differs when the lane moved a component the branch has not caught up with', () => {
+    const laneMoved = fingerprintIdVersions([
+      `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,
+      `${DEFAULT_SCOPE}/comp2@${'c'.repeat(40)}`,
+    ]);
+    expect(branchStateFingerprint(onLane(), laneIds)).to.not.equal(laneMoved);
+  });
+
+  it('counts a lane component the branch does not have at all', () => {
+    // Without the placeholder, "the lane grew a component" would fingerprint identically to "converged".
+    const grown = [...laneIds, `${DEFAULT_SCOPE}/comp3`];
+    expect(branchStateFingerprint(onLane(), grown)).to.not.equal(branchStateFingerprint(onLane(), laneIds));
+    expect(branchStateFingerprint(onLane(), grown)).to.equal(
+      fingerprintIdVersions([
+        `${DEFAULT_SCOPE}/comp1@${SNAP_1}`,
+        `${DEFAULT_SCOPE}/comp2@${SNAP_2}`,
+        `${DEFAULT_SCOPE}/comp3@${ABSENT_ON_BRANCH}`,
+      ])
+    );
+  });
+
+  it('ignores components the branch has that are not on the lane', () => {
+    // The `.bitmap` also carries non-lane components at their main versions; counting those would make
+    // an untouched pair read as diverged after any unrelated release.
+    const withExtra = parseBranchBitmap(
+      bitmapContent({
+        lane: { scope: DEFAULT_SCOPE, name: 'my-lane' },
+        components: { comp1: SNAP_1, comp2: SNAP_2, comp9: '0.0.7' },
+      }),
+      DEFAULT_SCOPE
+    ) as NonNullable<ReturnType<typeof parseBranchBitmap>>;
+    expect(branchStateFingerprint(withExtra, laneIds)).to.equal(branchStateFingerprint(onLane(), laneIds));
+  });
+});

package/sync/sync-state.ts

@@ -0,0 +1,176 @@
+import { BitMap } from '@teambit/legacy.bit-map';
+import { BIT_MAP } from '@teambit/legacy.constants';
+import { sha1 } from '@teambit/toolbox.crypto.sha1';
+import { git } from '../git';
+
+/**
+ * Sync state is derived from the `.bitmap` committed on a branch — the lane pointer (`_bit_lane`) and the
+ * per-component versions — never from commit messages, which are forgeable and rewritten by squash/rebase.
+ */
+
+/** What a branch's committed `.bitmap` says about the branch's bit state. */
+export type BranchBitmapState = {
+  /**
+   * The scope-qualified lane id `.bitmap` points at (`<scope>/<name>`), or undefined when there is no
+   * usable pointer — none at all (branch on main), or one bit marked not exported.
+   */
+  laneIdStr?: string;
+  /** `<scope>/<name>` -> version (a snap hash, or a semver tag on main), exactly as `.bitmap` records it. */
+  versions: Record<string, string>;
+};
+
+/**
+ * Parse a `.bitmap` file's content — no workspace, no filesystem. Fail-safe: an unreadable file returns
+ * undefined, and a pointer that parses but cannot attribute (unscoped id, `exported: false`) withholds
+ * `laneIdStr`; either way no lane id licenses nothing, so a parse failure can never authorize a deletion.
+ * An unexported pointer is ignored because its lane never existed on any remote and treating it as a
+ * mirror would retire the branch.
+ */
+export function parseBranchBitmap(content: string | undefined, defaultScope: string): BranchBitmapState | undefined {
+  if (!content || !content.trim()) return undefined;
+  try {
+    const bitMap = BitMap.loadFromContentWithoutLoadingFiles(Buffer.from(content, 'utf8'), '', '', defaultScope);
+    const versions: Record<string, string> = {};
+    bitMap.components.forEach((componentMap) => {
+      const version = componentMap.id.version;
+      // No version = never snapped/tagged; contributes nothing to the fingerprint.
+      if (version) versions[componentMap.id.toStringWithoutVersion()] = version;
+    });
+    // An unscoped lane id cannot be attribution: every comparison target is scope-qualified.
+    const laneId = bitMap.isLaneExported ? bitMap.laneId : undefined;
+    const laneIdStr = laneId?.scope ? laneId.toString() : undefined;
+    return { laneIdStr, versions };
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Fingerprint of `<component-id>@<version>` pairs: sorted (so listing/key order cannot perturb it), then
+ * sha1'd (the value doubles as a single-token `Bit-Lane-Head` trailer).
+ */
+export function fingerprintIdVersions(idAtVersion: string[]): string {
+  return sha1([...idAtVersion].sort().join('\n'));
+}
+
+/**
+ * Placeholder for a lane component the branch's `.bitmap` lacks. It must participate in the fingerprint,
+ * or "the lane grew a component" would fingerprint identically to "converged".
+ */
+export const ABSENT_ON_BRANCH = '<absent>';
+
+/**
+ * What the branch reflects, comparable to the lane's own fingerprint. Only the lane's components count:
+ * the `.bitmap` also carries non-lane components at their main versions, and including those would make
+ * an untouched pair read as diverged after any unrelated release.
+ */
+export function branchStateFingerprint(state: BranchBitmapState, laneComponentIds: string[]): string {
+  return fingerprintIdVersions(laneComponentIds.map((id) => `${id}@${state.versions[id] ?? ABSENT_ON_BRANCH}`));
+}
+
+export const LANE_HEAD_TRAILER = 'Bit-Lane-Head';
+/**
+ * Marks a commit as machine-generated. Duplicated in the `bit-git-sync` action repo's event router
+ * (the loop guard) — changing one copy without the other makes the reconciler re-trigger itself.
+ */
+export const SYNC_COMMIT_MARKER = '[bit-sync]';
+export const CONFLICT_LABEL = 'bit-sync-conflict';
+
+/**
+ * Permissive substring probe for "looks machine-generated" — the loop guard. Must NOT decide anything
+ * irreversible; see `isSyncAuthoredMessage`.
+ */
+export function hasSyncMarker(message: string): boolean {
+  return message.includes(SYNC_COMMIT_MARKER);
+}
+
+/**
+ * Strict probe for "we wrote this commit": the marker alone on its own line. This is an input to branch
+ * deletion, so a developer merely quoting the marker must never count as authorship. `\r?` tolerates CRLF;
+ * a recognition failure errs toward keeping the branch.
+ */
+export function isSyncAuthoredMessage(message: string): boolean {
+  return new RegExp(`^${SYNC_COMMIT_MARKER.replace(/[[\]]/g, '\\$&')}\\r?$`, 'm').test(message);
+}
+
+/**
+ * The sync commit's message. Every part is an annotation (audit trail + loop-guard marker); nothing reads
+ * it as state — messages are forgeable and rewritten on squash-merge. State comes from `.bitmap`.
+ */
+export function buildSyncCommitMessage(laneIdStr: string, laneHead: string): string {
+  return [
+    `chore(bit-sync): sync lane ${laneIdStr} @ ${laneHead.slice(0, 9)}`,
+    '',
+    `${LANE_HEAD_TRAILER}: ${laneHead}`,
+    SYNC_COMMIT_MARKER,
+  ].join('\n');
+}
+
+export type BranchSyncState = {
+  /**
+   * The newest first-parent commit that changed `.bitmap` — the reachability anchor for branch ownership
+   * and the baseline for `hasDevCommits`. Undefined when `.bitmap` was never written on the branch.
+   */
+  stateCommit?: string;
+  /**
+   * The branch tip's `.bitmap`, parsed; undefined when absent/unparseable (treated as "not ours").
+   * Reading at the tip equals reading at `stateCommit` — nothing after it changed the file.
+   */
+  bitmap?: BranchBitmapState;
+  /** Whether the branch carries commits on top of its bit state — work bit has not seen. */
+  hasDevCommits: boolean;
+  /** The branch tip's full commit message (subject + body), for the sync-marker loop-guard probe. */
+  tipMessage: string;
+  /**
+   * The tip sha every field above was read from. The retirement path re-reads the branch and refuses to
+   * delete anything else — the evidence licensed deleting THIS commit, not a later one.
+   */
+  tipSha?: string;
+};
+
+/**
+ * Whether a `rev-list --count` output reports commits. An unreadable count answers `true`: `false` is an
+ * input to branch retirement, so not knowing must withhold a deletion rather than license one. Empty
+ * output is reachable — simple-git's `raw` resolves with it on some non-zero exits.
+ */
+export function parseDevCommitCount(raw: string): boolean {
+  const count = Number.parseInt(raw.trim(), 10);
+  return Number.isNaN(count) ? true : count > 0;
+}
+
+/**
+ * Read a remote branch's sync state from its committed `.bitmap`. Assumes `git fetch origin` already ran.
+ * `--first-parent` is a correctness requirement: `git log` orders across all parents, so a `.bitmap`
+ * change that arrived through a merge would otherwise be picked as this branch's own state commit.
+ */
+export async function readBranchSyncState(
+  branch: string,
+  defaultBranch: string,
+  defaultScope: string
+): Promise<BranchSyncState> {
+  const revision = `origin/${branch}`;
+  const tipSha = (await git.raw(['rev-parse', revision])).trim() || undefined;
+  const tipMessage = (await git.raw(['log', revision, '-n', '1', '--format=%B'])).trimEnd();
+  const stateCommit =
+    (await git.raw(['log', revision, '--first-parent', '-n', '1', '--format=%H', '--', BIT_MAP])).trim() || undefined;
+
+  const bitmap = parseBranchBitmap(await readFileAtRef(revision, BIT_MAP), defaultScope);
+
+  const range = stateCommit ? `${stateCommit}..${revision}` : `origin/${defaultBranch}..${revision}`;
+  const count = await git.raw(['rev-list', range, '--count']);
+
+  return { stateCommit, bitmap, hasDevCommits: parseDevCommitCount(count), tipMessage, tipSha };
+}
+
+/**
+ * A file's content at a git ref, or undefined when it isn't there. simple-git's `raw` can resolve with
+ * empty output instead of rejecting on a missing path; `:./` keeps the path cwd-relative in case the
+ * workspace is a subdirectory of the repo.
+ */
+async function readFileAtRef(revision: string, filePath: string): Promise<string | undefined> {
+  try {
+    return await git.raw(['show', `${revision}:./${filePath}`]);
+  } catch {
+    return undefined;
+  }
+}

package/sync/workspace-lane.ts

@@ -0,0 +1,20 @@
+import type { LanesMain } from '@teambit/lanes';
+
+/**
+ * Current lane of this checkout, read from the workspace's `.bitmap` pointer only. Must NOT go through
+ * `lanes.getCurrentLane()`: that resolves via the local scope's lane object, which is absent on a cold
+ * runner and falsely answers "main". Unlike `parseBranchBitmap`, no `exported` gate applies here — this
+ * answers "which lane will the next bit operation act on?", not attribution/retirement.
+ */
+export function currentLaneIdStr(lanes: LanesMain): string | undefined {
+  const laneId = lanes.getCurrentLaneId();
+  return !laneId || laneId.isDefault() ? undefined : laneId.toString();
+}
+
+/**
+ * Ensure the lane the workspace points at is present in the local scope (idempotent; needed on a cold
+ * runner before bit-level operations that touch lane objects).
+ */
+export async function ensureCurrentLaneObject(lanes: LanesMain): Promise<void> {
+  await lanes.workspace?.importCurrentLaneIfMissing();
+}