tgit 0.34.1__tar.gz → 0.35.0__tar.gz

{tgit-0.34.1 → tgit-0.35.0}/CHANGELOG.md

@@ -1,3 +1,27 @@
+## v0.35.0
+
+[v0.34.2...v0.35.0](https://github.com/Jannchie/tgit/compare/v0.34.2...v0.35.0)
+
+### :sparkles: Features
+
+- **version**: add support for syncing Cargo.lock with Cargo.toml - By [Jannchie](mailto:jannchie@gmail.com) in [7ca29ae](https://github.com/Jannchie/tgit/commit/7ca29ae)
+
+### :wrench: Chores
+
+- update risk detection guidelines - By [Jannchie](mailto:jannchie@gmail.com) in [b5e0762](https://github.com/Jannchie/tgit/commit/b5e0762)
+
+## v0.34.2
+
+[v0.34.1...v0.34.2](https://github.com/Jannchie/tgit/compare/v0.34.1...v0.34.2)
+
+### :adhesive_bandage: Fixes
+
+- **version**: replace utf-8 errors handling in version file reads - By [Jannchie](mailto:jannchie@gmail.com) in [27dd1f8](https://github.com/Jannchie/tgit/commit/27dd1f8)
+
+### :test_tube: Tests
+
+- **cargo**: add unit tests for cargo version updates - By [Jianqi Pan](mailto:jannchie@gmail.com) in [bce5042](https://github.com/Jannchie/tgit/commit/bce5042)
+
 ## v0.34.1
 
 [v0.34.0...v0.34.1](https://github.com/Jannchie/tgit/compare/v0.34.0...v0.34.1)

{tgit-0.34.1 → tgit-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tgit
-Version: 0.34.1
+Version: 0.35.0
 Summary: AI-powered Git CLI for commits, changelogs, and semantic versioning.
 Project-URL: Homepage, https://github.com/Jannchie/tgit
 Project-URL: Repository, https://github.com/Jannchie/tgit

{tgit-0.34.1 → tgit-0.35.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tgit"
-version = "0.34.1"
+version = "0.35.0"
 description = "AI-powered Git CLI for commits, changelogs, and semantic versioning."
 authors = [{ name = "Jannchie", email = "jannchie@gmail.com" }]
 dependencies = [

{tgit-0.34.1 → tgit-0.35.0}/tests/integration/test_version_integration.py

@@ -305,6 +305,110 @@ description = "Test package"
         node_modules_content = json.loads(node_modules_package_json.read_text())
         assert node_modules_content["version"] == "1.0.0"
 
+    def _build_args(self, tmp_path, *, recursive: bool) -> VersionArgs:
+        return VersionArgs(
+            version="",
+            verbose=0,
+            no_commit=True,
+            no_tag=True,
+            no_push=True,
+            patch=False,
+            minor=False,
+            major=False,
+            prepatch="",
+            preminor="",
+            premajor="",
+            recursive=recursive,
+            custom="",
+            path=str(tmp_path),
+        )
+
+    def test_update_version_files_syncs_cargo_lock(self, tmp_path):
+        """End-to-end: bumping a crate's Cargo.toml also rewrites its
+        Cargo.lock entry. The lockfile lives next to the manifest."""
+        (tmp_path / "Cargo.toml").write_text(
+            '[package]\nname = "demo"\nversion = "0.1.0"\n',
+            encoding="utf-8",
+        )
+        (tmp_path / "Cargo.lock").write_text(
+            '[[package]]\nname = "demo"\nversion = "0.1.0"\n',
+            encoding="utf-8",
+        )
+        update_version_files(
+            self._build_args(tmp_path, recursive=False),
+            Version(major=0, minor=2, patch=0),
+            verbose=0,
+            recursive=False,
+        )
+        assert 'version = "0.2.0"' in (tmp_path / "Cargo.toml").read_text()
+        assert 'version = "0.2.0"' in (tmp_path / "Cargo.lock").read_text()
+
+    def test_update_version_files_workspace_lockfile_dedups(self, tmp_path):
+        """Cargo workspace with two members and one shared lockfile —
+        both [[package]] entries get rewritten, but the lockfile is
+        not duplicated."""
+        (tmp_path / ".git").mkdir()
+        (tmp_path / "Cargo.toml").write_text(
+            '[workspace]\nmembers = ["crates/alpha", "crates/beta"]\n',
+            encoding="utf-8",
+        )
+        (tmp_path / "Cargo.lock").write_text(
+            '[[package]]\nname = "alpha"\nversion = "0.1.0"\n\n'
+            '[[package]]\nname = "beta"\nversion = "0.1.0"\n',
+            encoding="utf-8",
+        )
+        alpha = tmp_path / "crates" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "Cargo.toml").write_text(
+            '[package]\nname = "alpha"\nversion = "0.1.0"\n',
+            encoding="utf-8",
+        )
+        beta = tmp_path / "crates" / "beta"
+        beta.mkdir(parents=True)
+        (beta / "Cargo.toml").write_text(
+            '[package]\nname = "beta"\nversion = "0.1.0"\n',
+            encoding="utf-8",
+        )
+        update_version_files(
+            self._build_args(tmp_path, recursive=True),
+            Version(major=0, minor=2, patch=0),
+            verbose=0,
+            recursive=True,
+        )
+        lockfile_content = (tmp_path / "Cargo.lock").read_text()
+        assert lockfile_content.count('version = "0.2.0"') == 2
+        assert 'version = "0.1.0"' not in lockfile_content
+
+    def test_update_version_files_pnpm_root_without_version(self, tmp_path):
+        """pnpm workspace root without `version`: bump must insert
+        one in the root package.json and update children too."""
+        (tmp_path / "package.json").write_text(
+            '{\n  "name": "monorepo",\n  "private": true\n}\n',
+            encoding="utf-8",
+        )
+        (tmp_path / "pnpm-workspace.yaml").write_text(
+            'packages:\n  - "packages/*"\n',
+            encoding="utf-8",
+        )
+        alpha = tmp_path / "packages" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text(
+            '{"name": "@x/alpha", "version": "0.1.0"}\n',
+            encoding="utf-8",
+        )
+
+        update_version_files(
+            self._build_args(tmp_path, recursive=True),
+            Version(major=0, minor=2, patch=0),
+            verbose=0,
+            recursive=True,
+        )
+        root_data = json.loads((tmp_path / "package.json").read_text())
+        assert root_data["version"] == "0.2.0"
+        assert root_data["name"] == "monorepo"
+        child_data = json.loads((alpha / "package.json").read_text())
+        assert child_data["version"] == "0.2.0"
+
     @patch("tgit.version.get_next_version")
     @patch("tgit.version.get_current_version")
     @patch("tgit.version.update_version_files")

{tgit-0.34.1 → tgit-0.35.0}/tests/unit/test_version.py

@@ -10,6 +10,8 @@ from tgit.version import (
     VersionArgs,
     VersionChoice,
     _apply_version_choice,
+    _find_cargo_lock_for,
+    _get_cargo_package_name,
     _get_default_bump_from_commits,
     _handle_explicit_version_args,
     _handle_interactive_version_selection,
@@ -17,8 +19,11 @@ from tgit.version import (
     _parse_gitignore,
     _prompt_for_version_choice,
     _should_ignore_path,
+    _version_from_workspace_children,
     bump_version,
+    cargo_lockfiles_for_manifests,
     execute_git_commands,
+    find_workspace_package_jsons,
     format_diff_lines,
     get_current_version,
     get_custom_version,
@@ -37,8 +42,11 @@ from tgit.version import (
     get_version_from_version_txt,
     handle_version,
     show_file_diff,
+    sync_cargo_lockfiles,
+    update_cargo_lock_version,
     update_cargo_toml_version,
     update_file,
+    update_package_json_version,
     update_version_files,
     update_version_in_file,
     version,
@@ -941,6 +949,443 @@ members = ["other-crate"]
         update_cargo_toml_version(non_existent_file, "1.0.0", 0, show_diff=False)
 
 
+class TestGetCargoPackageName:
+    """Test cases for _get_cargo_package_name."""
+
+    def test_basic(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = "arthash"\nversion = "0.2.0"\n')
+        assert _get_cargo_package_name(cargo_toml) == "arthash"
+
+    def test_missing_file(self, tmp_path):
+        assert _get_cargo_package_name(tmp_path / "Cargo.toml") is None
+
+    def test_missing_package_section(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[workspace]\nmembers = ["a"]\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_missing_name_key(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_empty_name(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = ""\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_invalid_toml(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text("this is not valid toml [[[")
+        assert _get_cargo_package_name(cargo_toml) is None
+
+
+class TestFindCargoLockFor:
+    """Test cases for _find_cargo_lock_for."""
+
+    def test_same_directory(self, tmp_path):
+        """Single-crate layout: Cargo.toml and Cargo.lock side-by-side."""
+        (tmp_path / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        assert _find_cargo_lock_for(tmp_path) == lockfile
+
+    def test_parent_directory(self, tmp_path):
+        """Workspace layout: lockfile lives at workspace root."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        member = tmp_path / "crates" / "alpha"
+        member.mkdir(parents=True)
+        (member / "Cargo.toml").write_text('[package]\nname = "alpha"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(member) == lockfile
+
+    def test_no_lockfile_returns_none(self, tmp_path):
+        (tmp_path / ".git").mkdir()
+        crate = tmp_path / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(crate) is None
+
+    def test_stops_at_git_root(self, tmp_path):
+        """Must not escape the current repo, even if an outer Cargo.lock exists."""
+        outer_lock = tmp_path / "Cargo.lock"
+        outer_lock.write_text("# outer\n")
+        repo = tmp_path / "inner_repo"
+        repo.mkdir()
+        (repo / ".git").mkdir()
+        crate = repo / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        # Should NOT find the outer Cargo.lock — that's in a different repo.
+        assert _find_cargo_lock_for(crate) is None
+
+
+class TestUpdateCargoLockVersion:
+    """Test cases for update_cargo_lock_version."""
+
+    @staticmethod
+    def _make_lockfile(tmp_path: Path, content: str) -> Path:
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(content, encoding="utf-8")
+        return lockfile
+
+    def test_local_crate_version_updated(self, tmp_path):
+        """Workspace member (no source field) gets its version rewritten."""
+        content = (
+            "# This file is automatically @generated by Cargo.\n"
+            "version = 4\n\n"
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        assert 'version = "0.3.0"' in new_content
+        assert 'version = "0.2.0"' not in new_content
+
+    def test_registry_dep_with_same_name_not_touched(self, tmp_path):
+        """A registry dep named identically to the local crate must NOT be hit.
+
+        Registry entries have `source = "registry+..."` between `name` and
+        `version`, so they fail the "name immediately followed by version"
+        anchor. Local crates fit the anchor exactly.
+        """
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'source = "registry+https://github.com/rust-lang/crates.io-index"\n'
+            'version = "9.9.9"\n'
+            'checksum = "deadbeef"\n\n'
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        # registry entry untouched
+        assert 'version = "9.9.9"' in new_content
+        # local entry bumped
+        assert 'version = "0.3.0"' in new_content
+        # only one occurrence of the new version (didn't accidentally double-write)
+        assert new_content.count('version = "0.3.0"') == 1
+
+    def test_crate_not_in_lockfile_is_noop(self, tmp_path):
+        """If the crate isn't recorded, nothing changes."""
+        content = (
+            "[[package]]\n"
+            'name = "other"\n'
+            'version = "1.0.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert lockfile.read_text() == content
+
+    def test_missing_lockfile_is_noop(self, tmp_path):
+        """Pure non-Rust projects don't have a Cargo.lock — must not error."""
+        lockfile = tmp_path / "Cargo.lock"
+        # Should not raise.
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert not lockfile.exists()
+
+    def test_already_in_sync_is_noop(self, tmp_path):
+        """Idempotent: same version in -> file unchanged."""
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.3.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        before = lockfile.stat().st_mtime_ns
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        # Content identical; we explicitly skip the write in that case.
+        assert lockfile.read_text() == content
+        # And the file was not rewritten (mtime preserved). Some filesystems
+        # have coarse mtime resolution, so this guard is a tightening only —
+        # the content check above is the real assertion.
+        assert lockfile.stat().st_mtime_ns == before
+
+
+class TestSyncCargoLockfiles:
+    """sync_cargo_lockfiles is the post-manifest step that rewrites
+    every Cargo.lock entry matching a bumped manifest. Manifest update
+    and lockfile sync are deliberately decoupled so workspace members
+    sharing one lockfile don't trigger N rewrites of it."""
+
+    def test_syncs_sibling_lockfile(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "arthash"\n'
+            'version = "0.3.0"\n',
+            encoding="utf-8",
+        )
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        sync_cargo_lockfiles([cargo_toml], "0.3.0", 0, show_diff=False)
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_syncs_workspace_root_lockfile(self, tmp_path):
+        """Workspace member's manifest, lockfile at the workspace root."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        member_dir = tmp_path / "crates" / "alpha"
+        member_dir.mkdir(parents=True)
+        cargo_toml = member_dir / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.3.0"\n',
+            encoding="utf-8",
+        )
+        sync_cargo_lockfiles([cargo_toml], "0.3.0", 0, show_diff=False)
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_no_lockfile_present_is_noop(self, tmp_path):
+        """Pure non-Rust projects or fresh crates may lack a lockfile."""
+        (tmp_path / ".git").mkdir()
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.3.0"\n',
+            encoding="utf-8",
+        )
+        # Should not raise.
+        sync_cargo_lockfiles([cargo_toml], "0.3.0", 0, show_diff=False)
+
+    def test_workspace_members_dedup_to_one_lockfile_rewrite(self, tmp_path):
+        """Two members share one lockfile; both their entries must be
+        rewritten, and the lockfile resolution must not duplicate."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n'
+            "\n"
+            "[[package]]\n"
+            'name = "beta"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        alpha_toml = tmp_path / "crates" / "alpha" / "Cargo.toml"
+        alpha_toml.parent.mkdir(parents=True)
+        alpha_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.3.0"\n',
+            encoding="utf-8",
+        )
+        beta_toml = tmp_path / "crates" / "beta" / "Cargo.toml"
+        beta_toml.parent.mkdir(parents=True)
+        beta_toml.write_text(
+            "[package]\n"
+            'name = "beta"\n'
+            'version = "0.3.0"\n',
+            encoding="utf-8",
+        )
+        sync_cargo_lockfiles([alpha_toml, beta_toml], "0.3.0", 0, show_diff=False)
+        new_content = lockfile.read_text()
+        assert new_content.count('version = "0.3.0"') == 2
+        assert 'version = "0.2.0"' not in new_content
+
+    def test_manifests_without_package_name_skipped(self, tmp_path):
+        """A pure [workspace] manifest has no `name`; nothing to do."""
+        (tmp_path / ".git").mkdir()
+        ws_toml = tmp_path / "Cargo.toml"
+        ws_toml.write_text('[workspace]\nmembers = ["crates/alpha"]\n', encoding="utf-8")
+        lockfile = tmp_path / "Cargo.lock"
+        original = '[[package]]\nname = "alpha"\nversion = "0.2.0"\n'
+        lockfile.write_text(original, encoding="utf-8")
+        sync_cargo_lockfiles([ws_toml], "0.3.0", 0, show_diff=False)
+        assert lockfile.read_text() == original
+
+
+class TestCargoLockfilesForManifests:
+    """Resolution of unique Cargo.lock files for a manifest set."""
+
+    def test_dedups_shared_workspace_lockfile(self, tmp_path):
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        alpha = tmp_path / "crates" / "alpha" / "Cargo.toml"
+        alpha.parent.mkdir(parents=True)
+        alpha.write_text('[package]\nname = "alpha"\nversion = "0.1.0"\n')
+        beta = tmp_path / "crates" / "beta" / "Cargo.toml"
+        beta.parent.mkdir(parents=True)
+        beta.write_text('[package]\nname = "beta"\nversion = "0.1.0"\n')
+        result = cargo_lockfiles_for_manifests([alpha, beta])
+        assert result == [lockfile]
+
+    def test_ignores_non_cargo_paths(self, tmp_path):
+        assert cargo_lockfiles_for_manifests([tmp_path / "package.json"]) == []
+
+    def test_missing_lockfile_returns_empty(self, tmp_path):
+        (tmp_path / ".git").mkdir()
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        assert cargo_lockfiles_for_manifests([cargo_toml]) == []
+
+
+class TestUpdatePackageJsonVersion:
+    """update_package_json_version handles both replace (most pkgs) and
+    insert (pnpm/npm workspace roots that omit `version`)."""
+
+    def test_replaces_existing_version(self, tmp_path):
+        pkg = tmp_path / "package.json"
+        pkg.write_text('{\n  "name": "x",\n  "version": "0.1.0"\n}\n', encoding="utf-8")
+        update_package_json_version(str(pkg), "0.2.0", 0, show_diff=False)
+        assert '"version": "0.2.0"' in pkg.read_text()
+        assert '"version": "0.1.0"' not in pkg.read_text()
+
+    def test_inserts_when_missing(self, tmp_path):
+        """Workspace root without `version` — must end up with one
+        and remain valid JSON."""
+        pkg = tmp_path / "package.json"
+        pkg.write_text(
+            '{\n  "name": "monorepo",\n  "private": true,\n  "workspaces": ["packages/*"]\n}\n',
+            encoding="utf-8",
+        )
+        update_package_json_version(str(pkg), "1.0.0", 0, show_diff=False)
+        new_content = pkg.read_text()
+        assert '"version": "1.0.0"' in new_content
+        # Still valid JSON
+        import json as _json
+        data = _json.loads(new_content)
+        assert data["version"] == "1.0.0"
+        assert data["name"] == "monorepo"
+
+    def test_only_first_version_match_replaced(self, tmp_path):
+        """Avoid touching a nested `"version"` inside dependencies."""
+        pkg = tmp_path / "package.json"
+        pkg.write_text(
+            '{\n'
+            '  "name": "x",\n'
+            '  "version": "0.1.0",\n'
+            '  "dependencies": {\n'
+            '    "left-pad": "1.3.0"\n'
+            '  }\n'
+            '}\n',
+            encoding="utf-8",
+        )
+        update_package_json_version(str(pkg), "0.2.0", 0, show_diff=False)
+        new_content = pkg.read_text()
+        assert '"version": "0.2.0"' in new_content
+        # left-pad pin must remain unchanged
+        assert '"left-pad": "1.3.0"' in new_content
+
+    def test_file_not_exists_is_noop(self, tmp_path):
+        # Should not raise.
+        update_package_json_version(str(tmp_path / "missing.json"), "1.0.0", 0, show_diff=False)
+
+
+class TestWorkspaceVersionDiscovery:
+    """When the root package.json omits `version` (typical pnpm/yarn
+    monorepo root), version detection falls back to the highest
+    version among workspace children."""
+
+    def test_pnpm_workspace_yaml_resolves_child_versions(self, tmp_path):
+        (tmp_path / "package.json").write_text('{"name": "root", "private": true}\n', encoding="utf-8")
+        (tmp_path / "pnpm-workspace.yaml").write_text('packages:\n  - "packages/*"\n', encoding="utf-8")
+        alpha = tmp_path / "packages" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text('{"name": "@x/alpha", "version": "1.2.3"}\n', encoding="utf-8")
+        beta = tmp_path / "packages" / "beta"
+        beta.mkdir(parents=True)
+        (beta / "package.json").write_text('{"name": "@x/beta", "version": "1.5.0"}\n', encoding="utf-8")
+
+        version = get_version_from_package_json(tmp_path)
+        assert version is not None
+        # Max of child versions
+        assert (version.major, version.minor, version.patch) == (1, 5, 0)
+
+    def test_npm_workspaces_field_list(self, tmp_path):
+        (tmp_path / "package.json").write_text(
+            '{"name": "root", "private": true, "workspaces": ["packages/*"]}\n',
+            encoding="utf-8",
+        )
+        alpha = tmp_path / "packages" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text('{"name": "@x/alpha", "version": "0.4.0"}\n', encoding="utf-8")
+
+        version = get_version_from_package_json(tmp_path)
+        assert version is not None
+        assert (version.major, version.minor, version.patch) == (0, 4, 0)
+
+    def test_yarn_workspaces_object_form(self, tmp_path):
+        (tmp_path / "package.json").write_text(
+            '{"name": "root", "workspaces": {"packages": ["modules/*"]}}\n',
+            encoding="utf-8",
+        )
+        alpha = tmp_path / "modules" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text('{"name": "@x/alpha", "version": "2.0.1"}\n', encoding="utf-8")
+
+        version = get_version_from_package_json(tmp_path)
+        assert version is not None
+        assert (version.major, version.minor, version.patch) == (2, 0, 1)
+
+    def test_root_version_takes_precedence(self, tmp_path):
+        """If root has its own version, children are ignored."""
+        (tmp_path / "package.json").write_text(
+            '{"name": "root", "version": "5.0.0", "workspaces": ["packages/*"]}\n',
+            encoding="utf-8",
+        )
+        alpha = tmp_path / "packages" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text('{"version": "9.9.9"}\n', encoding="utf-8")
+        version = get_version_from_package_json(tmp_path)
+        assert version is not None
+        assert (version.major, version.minor, version.patch) == (5, 0, 0)
+
+    def test_no_workspace_no_version_returns_none(self, tmp_path):
+        (tmp_path / "package.json").write_text('{"name": "x"}\n', encoding="utf-8")
+        assert get_version_from_package_json(tmp_path) is None
+
+    def test_child_without_version_skipped(self, tmp_path):
+        (tmp_path / "package.json").write_text('{"workspaces": ["packages/*"]}\n', encoding="utf-8")
+        alpha = tmp_path / "packages" / "alpha"
+        alpha.mkdir(parents=True)
+        (alpha / "package.json").write_text('{"name": "@x/alpha"}\n', encoding="utf-8")
+        beta = tmp_path / "packages" / "beta"
+        beta.mkdir(parents=True)
+        (beta / "package.json").write_text('{"name": "@x/beta", "version": "0.1.0"}\n', encoding="utf-8")
+
+        version = get_version_from_package_json(tmp_path)
+        assert version is not None
+        assert (version.major, version.minor, version.patch) == (0, 1, 0)
+
+    def test_find_workspace_package_jsons_excludes_root(self, tmp_path):
+        (tmp_path / "package.json").write_text('{"workspaces": ["."]}\n', encoding="utf-8")
+        result = find_workspace_package_jsons(tmp_path)
+        assert result == []
+
+    def test_version_from_workspace_children_no_workspace(self, tmp_path):
+        """No workspaces config at all → no children, returns None."""
+        assert _version_from_workspace_children(tmp_path) is None
+
+
 class TestParseGitignore:
     """Test cases for _parse_gitignore function."""
 

{tgit-0.34.1 → tgit-0.35.0}/tests/unit/test_version_coverage.py

@@ -311,14 +311,12 @@ version = "invalid"
             str(file_path), r'version\s*=\s*".*?"', 'version = "1.2.3"', 0, show_diff=False
         )
 
-    @patch("tgit.version.update_file")
+    @patch("tgit.version.update_package_json_version")
     def test_update_version_in_file_package_json(self, mock_update, tmp_path):
         """Test update_version_in_file for package.json."""
         file_path = tmp_path / "package.json"
         update_version_in_file(0, "1.2.3", "package.json", file_path)
-        mock_update.assert_called_once_with(
-            str(file_path), r'"version":\s*".*?"', '"version": "1.2.3"', 0, show_diff=False
-        )
+        mock_update.assert_called_once_with(str(file_path), "1.2.3", 0, show_diff=False)
 
     @patch("tgit.version.update_file")
     def test_update_version_in_file_version_txt(self, mock_update, tmp_path):