fix(diff): make --parent default to current version and skip non-meaningful ancestors

[davidfirst]

Fixes several issues with bit diff --parent:

• when the parent is a snap, the diff silently fell back to a wrong comparison and showed "no diff" (a tag name was looked up for the parent ref; snaps have none).
• --parent without a version threw an error; it now defaults to the component's current version.
• when a tag is created by tag-from-scope (_tag) on a merged lane snap, the tag is identical to that snap, so diffing against the immediate parent showed "no diff". The diff now walks up the history, skipping hidden ancestors and snap ancestors with identical content (the latter covers releases with rebuilt artifacts, where the merged snap is not marked hidden). A tag ancestor is never skipped by content, so a legit tag created with --unmodified still shows no diff.
• --parent on the first version now shows all files as added.

Added e2e coverage for all the above.

[qodo-free-for-open-source-projects]

PR Summary by Qodo

Fix bit diff --parent defaulting and skip non-meaningful ancestors

🐞 Bug fix 🧪 Tests 📝 Documentation 🕐 20-40 Minutes

AI Description

• Make --parent default to the component’s current version when omitted.
• Fix parent resolution for snaps and first-version diffs (show all files added).
• Skip hidden/identical snap ancestors so --parent compares against a meaningful baseline.

Diagram

graph TD
  U["User: bit diff"] --> C["diff-cmd (CLI)"] --> M["ComponentCompareMain"] --> W{"--parent?"}
  W -->|"yes"| P["Parent selection"] --> I["Scope importer"] --> R[("Model repo")]
  P --> D["Compute diff"]
  W -->|"no"| D --> O["Diff output"]

  subgraph Legend
    direction LR
    _u[User] ~~~ _cmd[CLI command] ~~~ _svc[Service/logic] ~~~ _db[(Repository/store)] ~~~ _dec{Decision}
  end

Loading

High-Level Assessment

The following are alternative approaches to this PR:

1. Move parent-walk logic into ModelComponent/Version APIs

• ➕ Centralizes ancestry semantics (hidden/identical/tag-aware) for reuse across features
• ➕ Reduces command-layer complexity and makes behavior easier to test in isolation
• ➖ Larger refactor surface area and potential ripple effects for other consumers
• ➖ Requires careful API design to avoid leaking CLI-specific policy

2. Use cheap content hashes to skip identical ancestors (avoid full diffs)

• ➕ Potentially faster than computing diffs repeatedly while walking ancestors
• ➕ Clearer intent: compare snapshots by fingerprint, not by diff output
• ➖ Requires reliable hash definition (files + metadata) aligned with what diff considers meaningful
• ➖ Adds/depends on additional stored metadata or recalculation cost

3. Add an explicit flag (e.g. `--skip-identical-ancestors`) instead of default behavior

• ➕ Avoids surprising behavior changes for users expecting the immediate parent only
• ➕ Keeps default --parent semantics simpler and more predictable
• ➖ More CLI surface area and documentation burden
• ➖ Doesn’t fix the existing ‘no diff’ UX for common merge/tag-from-scope flows unless users discover the flag

Recommendation: The PR’s approach is appropriate for improving --parent usability in common lane-merge/tag-from-scope scenarios, and the tag-aware rule (never skipping tag ancestors by content) preserves expected semantics for legitimate no-change tags. If performance becomes an issue on deep histories, consider replacing the repeated diff calls during ancestor-walk with a hash/fingerprint check.

Files changed (3) +131 / -4

Bug fix (1) +39 / -3

component-compare.main.runtime.tsDefault '--parent' to current version and walk meaningful ancestors +39/-3

Default '--parent' to current version and walk meaningful ancestors

• Fixes '--parent' to default to 'component.id.version' when no version is provided and handles first-version comparisons by treating all files as added. Reworks parent resolution to traverse ancestors, skipping hidden versions and snap ancestors with identical content, while never skipping tag ancestors by content to preserve legitimate no-diff tags.

scopes/component/component-compare/component-compare.main.runtime.ts

Tests (1) +83 / -0

diff.e2e.tsAdd e2e coverage for 'diff --parent' edge cases +83/-0

Add e2e coverage for 'diff --parent' edge cases

• Adds a dedicated test suite validating '--parent' behavior for tags, snaps, missing version defaulting, first-version diffs, invalid argument combinations, and skipping hidden/identical snap ancestors while preserving tag no-diff semantics.

e2e/commands/diff.e2e.ts

Documentation (1) +9 / -1

diff-cmd.tsClarify '--parent' help text and add example for omitted version +9/-1

Clarify '--parent' help text and add example for omitted version

• Updates the CLI option description to reflect defaulting to the current version and adds an explicit usage example ('diff foo --parent').

scopes/component/component-compare/diff-cmd.ts

[qodo-free-for-open-source-projects]

Code Review by Qodo

🐞 Bugs (2) 📘 Rule violations (0) 📜 Skill insights (0)

1. No fields diff first version 🐞 Bug ≡ Correctness

Description

In computeDiff() when --parent is used on the first version (no parents), the function returns
after generating filesDiff and never computes fieldsDiff. This makes `bit diff <comp>
<first-version> --parent --configs-only` report “no matching changes”, and JSON output omits
dependency/aspect-config diffs that should be treated as added relative to no parent.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R249-255]

+      if (!parentRef) {
+        // it's the first version. show all files as new.
+        const versionFiles = await versionObject.modelFilesToSourceFiles(repository);
+        diffResult.filesDiff = await getFilesDiff([], versionFiles, 'no parent', targetVersion);
+        if (hasDiff(diffResult)) diffResult.hasDiff = true;
+        return diffResult;
+      }

Evidence

The first-version --parent path returns before calling updateFieldsDiff(), so fieldsDiff is
never populated. Downstream, filterDiffResults() removes filesDiff for --configs-only and
relies on fieldsDiff, resulting in an empty output for that mode.

scopes/component/component-compare/component-compare.main.runtime.ts[245-255]
components/legacy/component-diff/components-diff.ts[149-163]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
When `--parent` is used on a first version (no parent), `computeDiff()` returns early after populating only `filesDiff`. This prevents field-level diffs (dependencies/env/aspect-config) from being computed, which breaks `--configs-only` output and causes field diffs to be missing from JSON consumers.
### Issue Context
`filterDiffResults()` drops `filesDiff` for `--configs-only`, so without `fieldsDiff` the command outputs “(no matching changes)”, even though fields were introduced in the first version.
### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[249-255]
- components/legacy/component-diff/components-diff.ts[149-163]
### Suggested fix approach
- In the `!parentRef` branch, compute `fieldsDiff` as well.
- Option A (preferred): create/obtain a “no parent” baseline ConsumerComponent (empty deps/files/aspects) with a valid `version` string and run `diffBetweenComponentsObjects(baseline, toVersionComponent, diffOpts)`.
- Option B: factor out field-diff computation into a helper that can compare a real component against an explicit empty baseline without requiring a persisted Version.
- Ensure `diffResult.hasDiff` remains correct for both default output and `--configs-only`.
- Add an e2e (or unit) assertion for `bit diff bar/foo 0.0.1 --parent --configs-only` to prove the regression is fixed.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

2. Default version not imported ✓ Resolved 🐞 Bug ☼ Reliability

Description

In ComponentCompareMain.computeDiff(), the initial importWithoutDeps() runs before --parent
defaults version to component.id.version, so loadVersion(version) can run without importing
that resolved version first. If the current version object isn’t already present in the local object
store, modelComponent.loadVersion() will throw and bit diff  --parent will fail.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R239-245]

const idList = ComponentIdList.fromArray(idsToImport);
await this.scope.legacyScope.scopeImporter.importWithoutDeps(idList, { cache: true, reason: 'to show diff' });
if (diffOpts.compareToParent) {
-      if (!version) throw new BitError('--parent flag expects to get version');
if (toVersion) throw new BitError('--parent flag expects to get only one version');
+      if (!version) version = component.id.version;
const versionObject = await modelComponent.loadVersion(version, repository);
-      const parent = versionObject.parents[0];
+      let parentRef = versionObject.parents[0];

Evidence

computeDiff() constructs idsToImport only from the CLI-provided version/toVersion, calls
importWithoutDeps(), and only then defaults version for --parent and immediately calls
loadVersion(version). ModelComponent.loadVersion() throws if the ref/object isn’t available in
the repository.

scopes/component/component-compare/component-compare.main.runtime.ts[235-245]
scopes/scope/objects/models/model-component.ts[908-913]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`computeDiff()` imports `idsToImport` before defaulting `version` for `--parent`. When `--parent` is used without an explicit version, the resolved `version` may not be imported, and `modelComponent.loadVersion(version, repository)` can throw if the object is missing locally.
### Issue Context
`ModelComponent.loadVersion()` throws when the ref/object can’t be found/loaded from the repository. Because the defaulting happens after the initial import step, the resolved version is not guaranteed to exist locally.
### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[235-245]
- scopes/scope/objects/models/model-component.ts[908-913]
### Suggested fix
- Resolve the effective `version`/`toVersion` (including the `--parent` defaulting) **before** building `idsToImport` and calling `importWithoutDeps()`.
- Alternatively, after `if (!version) version = component.id.version;` add an `importWithoutDeps()` call for `component.id.changeVersion(version)` before calling `loadVersion(version, ...)`.
- Keep the existing per-parent import inside the ancestor loop as-is (or batch import if desired), but ensure the initially diffed `toVersion` is present first.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

3. Identical snaps block fallback ✓ Resolved 🐞 Bug ≡ Correctness

Description

When all ancestors are non-hidden, untagged snaps identical to the target, sawNonHiddenAncestor
prevents the no-parent fallback even though no meaningful parent was found. A first release based on
an identical rebuilt merge snap can consequently report no diff instead of showing the target files
as added.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[304]

+      if (!foundMeaningfulParent && !sawNonHiddenAncestor) {

Evidence

The traversal marks every encountered non-hidden ancestor at line 277, but identical untagged snaps
do not set foundMeaningfulParent at lines 278-300. If such a snap is the final ancestor, traversal
ends at line 302; the condition at line 304 then bypasses the no-parent branch, while version
still references the skipped ancestor from line 275, so the normal path compares against it.

scopes/component/component-compare/component-compare.main.runtime.ts[265-315]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
When traversal exhausts only identical, non-tag snap ancestors, `foundMeaningfulParent` remains false but `sawNonHiddenAncestor` suppresses the empty-parent fallback. The final comparison then uses an ancestor that was deliberately skipped and can incorrectly report no diff.
## Issue Context
Tagged ancestors must remain meaningful even when identical. If traversal ends without finding any meaningful ancestor, use the no-parent behavior and add regression coverage for a target whose only parent is an identical, non-hidden snap.
## Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[265-312]
- e2e/commands/diff.e2e.ts[501-528]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

4. Empty files are not added 🐞 Bug ≡ Correctness

Description

The new no-parent path passes an empty baseline to getFilesDiff(), which represents both an absent
file and a present zero-byte file with empty content, so no textual diff is generated and the file
remains UNCHANGED. Consequently, --parent on a first version or all-hidden history does not show
all files as added when the version contains empty files.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[252]

+        diffResult.filesDiff = await getFilesDiff([], versionFiles, 'no parent', targetVersion);

Evidence

Both new no-parent branches call getFilesDiff([], versionFiles, ...). That helper converts a
missing baseline file to content: '', while a present zero-byte file also has empty content;
without diffOutput, its status remains UNCHANGED rather than NEW.

scopes/component/component-compare/component-compare.main.runtime.ts[249-254]
scopes/component/component-compare/component-compare.main.runtime.ts[303-310]
components/legacy/component-diff/components-diff.ts[68-100]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
No-parent comparisons must classify every target file as added, including zero-byte files. The current empty baseline is indistinguishable from an existing empty file inside `getFilesDiff()`.
## Issue Context
This affects first-version `--parent` comparisons and the all-hidden-chain fallback, including `--name-only` and JSON status output.
## Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[249-254]
- scopes/component/component-compare/component-compare.main.runtime.ts[303-310]
- components/legacy/component-diff/components-diff.ts[60-100]
- e2e/commands/diff.e2e.ts[485-493]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

5. Deleted components bypass parent mode ✓ Resolved 🐞 Bug ≡ Correctness

Description

For bit diff  --parent, computeDiff() returns a workspace deletion diff before the new
omitted-version default and ancestry traversal execute. The command therefore compares the current
stored files to an empty workspace instead of comparing the current version to its meaningful
ancestor.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R235-237]

+    if (diffOpts.compareToParent) {
+      if (toVersion) throw new BitError('--parent flag expects to get only one version');
+      if (!version) version = component.id.version;

Evidence

The component.isDeleted() branch at lines 217-223 returns immediately using model files versus an
empty file list. The added default and ancestry logic begin only at lines 235-245, while the CLI
documentation says an omitted version compares the current version to its ancestor.

scopes/component/component-compare/component-compare.main.runtime.ts[217-245]
scopes/component/component-compare/diff-cmd.ts[48-52]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
Ensure `--parent` historical comparison takes precedence over the workspace-deletion shortcut. A deleted component with an omitted version should still resolve its current stored version and compare it to its meaningful ancestor.
## Issue Context
The deletion early return currently occurs before all `compareToParent` handling, despite the CLI advertising versionless parent comparison.
## Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[217-245]
- e2e/commands/diff.e2e.ts[441-529]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

View more (5)

6. All-hidden chain lacks fallback ✓ Resolved 🐞 Bug ≡ Correctness

Description

The --parent ancestor walk sets version = parentVersion even for hidden ancestors, and if all
ancestors are skipped (hidden/identical) until the chain ends, the code falls through and diffs
against the last skipped hidden version. This can yield an incorrect base comparison (including an
unexpected “no diff”) instead of treating the target as having no meaningful parent.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R271-290]

+        const parentObject = await modelComponent.loadVersion(parentVersion, repository);
+        version = parentVersion;
+        if (!parentObject.hidden) {
+          if (parentTag) break;
+          // cheap check first. when the files differ, this ancestor is meaningful, no need to
+          // compute the full diff here (it is computed once below for the output).
+          if (!this.haveSameFiles(parentObject, versionObject)) break;
+          // files are identical, compute the diff to find out whether the fields (deps/config) differ.
+          const parentDiff = await this.diffBetweenVersionsObjects(
+            modelComponent,
+            parentObject,
+            versionObject,
+            parentVersion,
+            toVersion,
+            diffOpts
+          );
+          if (parentDiff.hasDiff) break;
+        }
+        parentRef = parentObject.parents[0];
+      }

Evidence

The loop assigns version = parentVersion before checking hidden, and there is no post-loop
fallback when parentRef becomes undefined. Hidden snaps are explicitly defined as not meaningful,
so diffing against a skipped hidden ancestor contradicts the intended semantics.

scopes/component/component-compare/component-compare.main.runtime.ts[263-293]
scopes/component/snapping/version-maker.ts[910-926]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The `--parent` ancestor-walk is intended to *skip* hidden (and some identical-content) ancestors. However, the implementation assigns `version = parentVersion` before it decides an ancestor is meaningful, and if the loop exhausts the chain without finding a meaningful parent, `version` remains set to the last skipped ancestor and the diff runs against it.
### Issue Context
Hidden versions are explicitly described as “un-meaningful snaps” (created by tag-from-scope flow). If the only available ancestors are hidden/identical and the chain ends, the correct behavior should be to treat this like “no parent” rather than diffing against a skipped hidden ancestor.
### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[263-290]
- scopes/component/snapping/version-maker.ts[910-926]
### Suggested fix approach
- Track whether a *meaningful* parent was found (e.g., `let meaningfulParentVersion: string | undefined`).
- Only assign `version = ...` when you actually decide to break and use that ancestor.
- After the loop, if no meaningful parent was found, reuse the existing no-parent behavior (build diff against empty base with labels like `no parent`).
- Add a regression test that creates a version whose parent chain is entirely hidden/identical and ends, asserting that `--parent` behaves like “no parent” rather than comparing against a skipped hidden ancestor.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

7. Parent help text misleading ✓ Resolved 🐞 Bug ⚙ Maintainability

Description

The CLI/help text describes --parent as comparing to the “immediate parent”, but the
implementation can walk past the immediate parent (skipping hidden/identical ancestors) and compare
against an earlier ancestor. This mismatch can confuse users about what version the diff is actually
computed against.

Code

scopes/component/component-compare/diff-cmd.ts[R48-52]

+    [
+      'p',
+      'parent',
+      'compare the specified "version" (or the current version if not specified) to its immediate parent, showing what changed in that version',
+    ],

Evidence

The option text explicitly says “immediate parent”, while the runtime code performs a `while
(parentRef)` walk that can skip ancestors and select a non-immediate parent for comparison.

scopes/component/component-compare/diff-cmd.ts[46-53]
scopes/component/component-compare/component-compare.main.runtime.ts[256-290]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
`--parent` no longer always compares to the *immediate* parent; it may skip hidden/identical ancestors. The CLI option description and generated CLI reference still promise immediate-parent semantics.
### Issue Context
The runtime implementation explicitly walks the parent chain and may stop at a non-immediate ancestor.
### Fix Focus Areas
- scopes/component/component-compare/diff-cmd.ts[48-52]
- scopes/harmony/cli-reference/cli-reference.json[3876-3880]
- scopes/harmony/cli-reference/cli-reference.mdx[847-857]
- scopes/component/component-compare/component-compare.main.runtime.ts[256-290]
### Suggested fix approach
- Reword the help text to something like:
- “compare the specified version (or current) to its nearest meaningful ancestor (skipping hidden/identical snap ancestors), showing what changed in that version”.
- Keep examples unchanged, but ensure docs match the ancestor-walk behavior.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

8. Misleading first-version labels ✓ Resolved 🐞 Bug ≡ Correctness

Description

In computeDiff() for --parent on the first version, the diff is generated against an empty base
but getFilesDiff() is called with identical A/B version labels, so the header becomes “(X
original)” vs “(X modified)” instead of clearly indicating an empty/nonexistent parent. This can
confuse users and any tooling that relies on the human-readable header labels.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R250-253]

+        // it's the first version. show all files as new.
+        const versionFiles = await versionObject.modelFilesToSourceFiles(repository);
+        diffResult.filesDiff = await getFilesDiff([], versionFiles, targetVersion, targetVersion);
+        if (hasDiff(diffResult)) diffResult.hasDiff = true;

Evidence

The first-version --parent branch explicitly diffs from an empty file list but passes the same
version label for both sides. getFilesDiff() treats equal labels specially and appends
“original/modified”, which misrepresents the comparison as “same version changed” rather than “no
parent -> first version”.

scopes/component/component-compare/component-compare.main.runtime.ts[249-255]
components/legacy/component-diff/components-diff.ts[60-73]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
When diffing the first version with `--parent`, we compare `[]` (no parent files) to the first version’s files, but we pass the same `targetVersion` label for both sides into `getFilesDiff()`. `getFilesDiff()` rewrites equal labels into `"<ver> original"` and `"<ver> modified"`, which is misleading here because the left side is not actually version `<ver>`.
## Issue Context
This happens only in the new first-version `--parent` branch.
## Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[249-255]
- components/legacy/component-diff/components-diff.ts[60-73]
## Suggested fix
Pass a distinct left label (e.g. `'<none>'`, `'no-parent'`, or `'∅'`) when the parent is missing, so headers render as:
- `--- file (<none>)`
- `+++ file (0.0.1)`
(Alternatively, add a dedicated optional param to `getFilesDiff()` to represent an empty base label, but the minimal change is to pass a different `filesAVersion` string in this branch.)

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

9. Order-dependent tag version ✓ Resolved 🐞 Bug ☼ Reliability

Description

The new e2e test hard-codes diffing against version 0.0.4, but its before() only creates an
unmodified tag without specifying a version, so running this test without the earlier sibling suite
can create 0.0.3 instead and make bit diff bar/foo 0.0.4 --parent fail with a missing-version
error.

Code

e2e/commands/diff.e2e.ts[R515-520]

+        helper.command.tagAllWithoutBuild('--unmodified'); // creates 0.0.4, identical to its parent tag 0.0.3
+      });
+      it('should show no diff rather than walking further up the history', () => {
+        const output = helper.command.diff('bar/foo 0.0.4 --parent');
+        expect(output).to.have.string(noDiffMessage);
+      });

Evidence

The test assumes tagAllWithoutBuild('--unmodified') creates 0.0.4, but the helper runs bit tag
with no explicit version, so the next auto-incremented tag depends on earlier tests (specifically
whether 0.0.3 was created by the prior sibling suite).

e2e/commands/diff.e2e.ts[513-520]
components/legacy/e2e-helper/e2e-command-helper.ts[393-396]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The `diff with --parent flag` e2e suite has a nested `describe` that assumes tag `0.0.4` exists, but it only runs `tagAllWithoutBuild('--unmodified')` (no explicit `--ver`), so the created tag number depends on whether the previous sibling suite already created `0.0.3`.
### Issue Context
`tagAllWithoutBuild()` ultimately runs `bit tag` without providing an explicit version, so the next tag is auto-incremented from whatever is currently present in the workspace history.
### Fix Focus Areas
- e2e/commands/diff.e2e.ts[513-520]
### Suggested fix
Make the test self-contained by ensuring the required tags exist within the same setup scope. For example:
- In the `when the parent is a tag with identical content` block, create both tags needed (`0.0.3` then `0.0.4`) within that block (or move both tag operations into a shared `before()` and store the resulting tag names), and then diff against the tag you just created.
- Alternatively, avoid hard-coding `0.0.4` by determining the newly created tag version from the tag command output / `bit cat-component` and using that value in the diff command.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

10. Repeated parent diff computation ✓ Resolved 🐞 Bug ➹ Performance

Description

The new --parent ancestor walk can compute a full diff against multiple successive ancestors (load
versions, materialize files, run getFilesDiff) before finding a meaningful parent. On components
with long chains of non-hidden, untagged ancestors with identical content, this can make `bit diff
--parent` unexpectedly slow.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R261-283]

+      while (parentRef) {
+        const parentTag = modelComponent.getTagOfRefIfExists(parentRef);
+        const parentVersion: string = parentTag || parentRef.toString();
+        await this.scope.legacyScope.scopeImporter.importWithoutDeps(
+          ComponentIdList.fromArray([component.id.changeVersion(parentVersion)]),
+          { cache: true, reason: 'to show diff' }
+        );
+        const parentObject = await modelComponent.loadVersion(parentVersion, repository);
+        version = parentVersion;
+        if (!parentObject.hidden) {
+          if (parentTag) break;
+          const parentDiff = await this.diffBetweenVersionsObjects(
+            modelComponent,
+            parentObject,
+            versionObject,
+            parentVersion,
+            toVersion,
+            diffOpts
+          );
+          if (parentDiff.hasDiff) break;
+        }
+        parentRef = parentObject.parents[0];
+      }

Evidence

The loop calls diffBetweenVersionsObjects() to detect whether an ancestor has meaningful changes,
and that function generates file diffs via getFilesDiff(), which writes temp files and runs diff
for each file path. Repeating this per ancestor can be costly in worst-case histories.

scopes/component/component-compare/component-compare.main.runtime.ts[253-283]
scopes/component/component-compare/component-compare.main.runtime.ts[319-352]
components/legacy/component-diff/components-diff.ts[60-101]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The `--parent` walk-up loop may invoke `diffBetweenVersionsObjects()` multiple times, doing full file diff generation (temp writes + git diff) per ancestor just to answer the yes/no question “is content identical?”.
### Issue Context
This is only triggered when:
- the ancestor is not hidden,
- the ancestor is a snap (no tag), and
- the content is identical across multiple ancestors.
In that shape of history, the loop performs repeated expensive work.
### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[253-283]
- scopes/component/component-compare/component-compare.main.runtime.ts[319-352]
- components/legacy/component-diff/components-diff.ts[60-101]
### Suggested fix
- Add a lightweight “content equality” check for the ancestor-walk decision:
- e.g., compare per-file hashes and paths from `modelFilesToSourceFiles()` (without calling `getOneFileDiff()` / `git diff`) to decide if the parent is identical.
- Only when a non-identical ancestor is found, compute the full diff once for output.
- Keep the “never skip tag ancestor by content” rule by applying the fast equality check only when `parentTag` is falsy.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

11. CLI docs version regressed ✓ Resolved 🐞 Bug ≡ Correctness

Description

The regenerated CLI reference changes its advertised Bit version from 2.0.46 back to 2.0.45. This
misidentifies the release provenance of documentation that includes the new --parent behavior.

Code

scopes/harmony/cli-reference/cli-reference.docs.mdx[2]

+description: 'Bit command synopses. Bit version: 2.0.45'

Evidence

The changed front matter now reports 2.0.45, while the PR diff shows it replaced 2.0.46. The CLI
generator constructs this metadata from getBitVersion(), confirming that the value represents the
generating Bit release.

scopes/harmony/cli-reference/cli-reference.docs.mdx[1-3]
scopes/harmony/cli/cli.cmd.ts[37-42]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The generated CLI reference incorrectly advertises Bit version 2.0.45 after previously identifying version 2.0.46.
## Issue Context
The front matter is generated from `getBitVersion()`, so it should reflect the intended current release rather than regress to an older version.
## Fix Focus Areas
- scopes/harmony/cli-reference/cli-reference.docs.mdx[1-3]
- scopes/harmony/cli/cli.cmd.ts[37-42]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

12. Help overstates ancestor skipping ✓ Resolved 🐞 Bug ⚙ Maintainability

Description

The --parent help says identical ancestors are skipped, but computeDiff() deliberately stops at
an identical tagged ancestor. Users may therefore expect traversal to continue when the command
correctly reports no diff against a tagged parent.

Code

scopes/component/component-compare/diff-cmd.ts[51]

+      'compare the specified "version" (or the current version if not specified) to its nearest meaningful ancestor, showing what changed in that version. ancestors that are hidden or identical (e.g. the merged snap a release-tag was created from) are skipped',

Evidence

The implementation explicitly treats a tagged parent as meaningful before checking file equality,
and the E2E test verifies that an identical tagged parent produces no diff rather than walking
farther back. This contradicts the unqualified help statement that identical ancestors are skipped.

scopes/component/component-compare/component-compare.main.runtime.ts[262-285]
e2e/commands/diff.e2e.ts[515-527]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The `--parent` help unconditionally says identical ancestors are skipped, while the implementation preserves tagged ancestors even when their content is identical.
## Issue Context
Update the source command help and keep the generated CLI reference files synchronized. Suggested wording: “hidden ancestors and identical untagged snap ancestors are skipped; tagged ancestors are retained.”
## Fix Focus Areas
- scopes/component/component-compare/diff-cmd.ts[48-52]
- scopes/harmony/cli-reference/cli-reference.json[3876-3880]
- scopes/harmony/cli-reference/cli-reference.mdx[847-857]

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

_{To customize comments, go to the Qodo configuration screen, or learn more in the docs.}

[qodo-free-for-open-source-projects]

Code Review by Qodo

🐞 Bugs (2) 📘 Rule violations (0) 📜 Skill insights (0)

1. Default version not imported 🐞 Bug ☼ Reliability ⭐ New

Description

In computeDiff(), when --parent is used without an explicit version, version is defaulted to
component.id.version only after importWithoutDeps() runs, so the current version may not be
imported before modelComponent.loadVersion(version) executes and can throw VersionNotFoundOnFS
if the object is missing locally.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R240-244]

    await this.scope.legacyScope.scopeImporter.importWithoutDeps(idList, { cache: true, reason: 'to show diff' });
    if (diffOpts.compareToParent) {
-      if (!version) throw new BitError('--parent flag expects to get version');
      if (toVersion) throw new BitError('--parent flag expects to get only one version');
+      if (!version) version = component.id.version;
      const versionObject = await modelComponent.loadVersion(version, repository);
-      const parent = versionObject.parents[0];

Evidence

computeDiff() imports only the explicit version/toVersion values, but in --parent mode it may
later set version from component.id.version and immediately call loadVersion();
loadVersion() throws if the object is not on disk.

scopes/component/component-compare/component-compare.main.runtime.ts[235-244]
scopes/scope/objects/models/model-component.ts[908-913]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

### Issue description
`bit diff <comp> --parent` now defaults the version to `component.id.version`, but this happens **after** the initial `scopeImporter.importWithoutDeps()` call (which imports only explicit CLI versions). If the current version object is not already in the local object store, `modelComponent.loadVersion(version, repository)` may throw (e.g. `VersionNotFoundOnFS`).

### Issue Context
- `computeDiff()` imports versions from `idsToImport` before entering the `compareToParent` branch.
- When the user omits the version, `idsToImport` is empty, so nothing is imported.
- `ModelComponent.loadVersion()` throws when the ref exists but the object file is missing locally.

### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[235-244]

### Proposed fix
Either:
1) Move the `--parent` defaulting logic earlier (before building `idsToImport` and calling `importWithoutDeps`), so the defaulted `version` is included in `idsToImport`, or
2) After `version` is defaulted inside the `compareToParent` branch, explicitly `importWithoutDeps([component.id.changeVersion(version)])` before calling `loadVersion(version, repository)`.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

2. Repeated parent diff computation 🐞 Bug ➹ Performance

Description

The new --parent ancestor walk can compute a full diff against multiple successive ancestors (load
versions, materialize files, run getFilesDiff) before finding a meaningful parent. On components
with long chains of non-hidden, untagged ancestors with identical content, this can make `bit diff
--parent` unexpectedly slow.

Code

scopes/component/component-compare/component-compare.main.runtime.ts[R261-283]

+      while (parentRef) {
+        const parentTag = modelComponent.getTagOfRefIfExists(parentRef);
+        const parentVersion: string = parentTag || parentRef.toString();
+        await this.scope.legacyScope.scopeImporter.importWithoutDeps(
+          ComponentIdList.fromArray([component.id.changeVersion(parentVersion)]),
+          { cache: true, reason: 'to show diff' }
+        );
+        const parentObject = await modelComponent.loadVersion(parentVersion, repository);
+        version = parentVersion;
+        if (!parentObject.hidden) {
+          if (parentTag) break;
+          const parentDiff = await this.diffBetweenVersionsObjects(
+            modelComponent,
+            parentObject,
+            versionObject,
+            parentVersion,
+            toVersion,
+            diffOpts
+          );
+          if (parentDiff.hasDiff) break;
+        }
+        parentRef = parentObject.parents[0];
+      }

Evidence

The loop calls diffBetweenVersionsObjects() to detect whether an ancestor has meaningful changes,
and that function generates file diffs via getFilesDiff(), which writes temp files and runs diff
for each file path. Repeating this per ancestor can be costly in worst-case histories.

scopes/component/component-compare/component-compare.main.runtime.ts[253-283]
scopes/component/component-compare/component-compare.main.runtime.ts[319-352]
components/legacy/component-diff/components-diff.ts[60-101]

Agent prompt

The issue below was found during a code review. Follow the provided context and guidance below and implement a solution

## Issue description
The `--parent` walk-up loop may invoke `diffBetweenVersionsObjects()` multiple times, doing full file diff generation (temp writes + git diff) per ancestor just to answer the yes/no question “is content identical?”.
### Issue Context
This is only triggered when:
- the ancestor is not hidden,
- the ancestor is a snap (no tag), and
- the content is identical across multiple ancestors.
In that shape of history, the loop performs repeated expensive work.
### Fix Focus Areas
- scopes/component/component-compare/component-compare.main.runtime.ts[253-283]
- scopes/component/component-compare/component-compare.main.runtime.ts[319-352]
- components/legacy/component-diff/components-diff.ts[60-101]
### Suggested fix
- Add a lightweight “content equality” check for the ancestor-walk decision:
- e.g., compare per-file hashes and paths from `modelFilesToSourceFiles()` (without calling `getOneFileDiff()` / `git diff`) to decide if the parent is identical.
- Only when a non-identical ancestor is found, compute the full diff once for output.
- Keep the “never skip tag ancestor by content” rule by applying the fast equality check only when `parentTag` is falsy.

ⓘ Copy this prompt and use it to remediate the issue with your preferred AI generation tools

---

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 8bd7871

[qodo-free-for-open-source-projects]

Code Review by Qodo

New Review Started

This review has been superseded by a new analysis

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 0fea3d4

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit e929db9

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 76a00c6

[davidfirst]

Addressed the remaining open items from the latest Qodo review (commit dd3601d):

• Misleading first-version labels: --parent on a version with no parent now passes a distinct no parent base label to getFilesDiff(), so the header reads --- <file> (no parent) / +++ <file> (<version>) instead of the confusing "(X original) / (X modified)". The e2e test asserts the new labels.
• Repeated parent diff computation: already addressed in 0fea3d4 with the cheap haveSameFiles per-file hash check (the review snippet shows the pre-fix code); the full diff is only computed when files are identical, to detect fields-only changes.

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit dd3601d

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 80f82bf

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 828a4a6

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit d43b98a

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit e6d4999

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit a2f262b

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit 800f236

[qodo-free-for-open-source-projects]

Code review by qodo was updated up to the latest commit ac7f09b