gOdoo-cli 1.0.4__tar.gz → 1.0.5__tar.gz

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/.agents/skills/godoo-source-workspaces/SKILL.md

@@ -12,7 +12,7 @@ validated before locks or paths and cannot alter host/container depth. Git owns
 archive caches below the shared source root. Never hand-edit managed worktrees or generated `.godoo/` and workspace
 files.
 
-Run `workspace sync` only with authority for the shared source root; it may reset verified managed worktrees.
+Run `workspace sync` only with authority for the shared source root; it updates verified managed worktrees.
 `workspace configure` regenerates state from checked sources. `workspace check` is offline and read-only. Run workspace
 commands from the project directory because that cwd supplies `.env` and manifest-relative paths.
 

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gOdoo-cli
-Version: 1.0.4
+Version: 1.0.5
 Summary: Odoo lifecycle, Python dependency preflight, and shared Git workspaces.
 Project-URL: repository, https://github.com/OpenJKSoftware/gOdoo
 Author-email: Joshua Kreuder <Joshua_Kreuder@outlook.com>

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/docs/workspace.md

@@ -15,7 +15,7 @@ cd /path/to/project
 # Set this in .env instead if each shell should inherit the same value.
 export GODOO_SOURCES_ROOT=/absolute/path/to/shared-sources
 
-# Synchronize managed sources. This can discard edits in verified worktrees.
+# Synchronize managed sources. Tracked edits and untracked path collisions stop synchronization.
 godoo workspace sync
 
 # Generate editor files from the selected sources.
@@ -62,18 +62,19 @@ flowchart TD
     Check --> Build["Production image build copies<br/>selected sources into the image"]
 ```
 
-| Command                 | Changes state? | Purpose                                                                    |
-| ----------------------- | -------------- | -------------------------------------------------------------------------- |
-| `workspace sync`        | Yes            | Update managed worktrees and archive caches; may reset verified worktrees. |
-| `workspace configure`   | Yes            | Validate sources and generate editor files under `.godoo/workspace.lock`.  |
-| `workspace check`       | No             | Validate offline, without source-worktree or archive locks.                |
-| `workspace runtime-env` | No             | Validate sources and emit shell-safe resolved path assignments.            |
-| `workspace materialize` | Yes            | Copy selected sources into an image layout.                                |
-| `workspace storage`     | No             | Inspect shared source storage.                                             |
-| `workspace gc`          | Yes            | Manage shared storage cleanup; inspect `--help` before use.                |
+| Command                 | Changes state? | Purpose                                                                   |
+| ----------------------- | -------------- | ------------------------------------------------------------------------- |
+| `workspace sync`        | Yes            | Update managed worktrees and archive caches; preserve untracked files.    |
+| `workspace configure`   | Yes            | Validate sources and generate editor files under `.godoo/workspace.lock`. |
+| `workspace check`       | No             | Validate offline, without source-worktree or archive locks.               |
+| `workspace runtime-env` | No             | Validate sources and emit shell-safe resolved path assignments.           |
+| `workspace materialize` | Yes            | Copy selected sources into an image layout.                               |
+| `workspace storage`     | No             | Inspect shared source storage.                                            |
+| `workspace gc`          | Yes            | Manage shared storage cleanup; inspect `--help` before use.               |
 
 Git fetches report elapsed time every ten seconds and retain Git output for failure diagnostics. Git owns the pools,
-worktrees, branches, locks, and caches under the shared source root; use workspace commands to manage them.
+worktrees, branches, locks, and caches under the shared source root; use workspace commands to manage them. Tracked
+edits stop synchronization. Untracked and ignored files are preserved; Git rejects updates that would overwrite them.
 
 ## Editor configuration
 

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/src/godoo_cli/__about__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "1.0.4"
+__version__ = "1.0.5"

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/src/godoo_cli/git/repository.py

@@ -129,22 +129,6 @@ class GitRepository:
         """Return Git common directory for this repository."""
         return Path(self._require_repo().git.rev_parse("--git-common-dir"))
 
-    def switch(self, branch: str, start: str, *, discard_changes: bool = False) -> None:
-        """Switch an existing worktree branch to a commit."""
-        arguments: list[str] = []
-        if discard_changes:
-            arguments.append("--discard-changes")
-        arguments.extend(["-C", branch, start])
-        self._require_repo().git.switch(*arguments)
-
-    def reset_hard(self, commit: str) -> None:
-        """Reset the current worktree to commit."""
-        self._require_repo().git.reset("--hard", commit)
-
-    def clean(self) -> None:
-        """Remove untracked files from the current worktree."""
-        self._require_repo().git.clean("-fdx")
-
 
 def repository(path: Path) -> GitRepository:
     """Open a repository through the shared facade."""

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/src/godoo_cli/workspace/git.py

@@ -68,7 +68,7 @@ def _status_result(
     cwd: Path | None = None,
     env: dict[str, str] | None = None,
 ) -> tuple[int, str | bytes, str | bytes]:
-    """Run ignored status in porcelain NUL mode for the clean-tree safety check."""
+    """Run status in porcelain NUL mode for worktree safety checks."""
     return native_git_result(*arguments, cwd=cwd, env=env, binary=True)
 
 
@@ -444,36 +444,18 @@ def _head(path: Path) -> str:
     return _repo(path).head_commit()
 
 
-def _assert_clean(path: Path) -> None:
-    """Reject any direct change to a managed worktree."""
+def _assert_clean(path: Path, *, include_untracked: bool = False) -> None:
+    """Reject tracked changes, and all untracked files before removing a worktree."""
+    arguments = ["--untracked-files=all", "--ignored"] if include_untracked else ["--untracked-files=no"]
     returncode, stdout, stderr = _status_result(
-        "--no-optional-locks",
-        "-C",
-        str(path),
-        "status",
-        "--porcelain=v1",
-        "-z",
-        "--untracked-files=all",
-        "--ignored",
+        "--no-optional-locks", "-C", str(path), "status", "--porcelain=v1", "-z", *arguments
     )
     if returncode:
         detail = stderr.strip() or stdout.strip()
         if isinstance(detail, bytes):
             detail = detail.decode(errors="replace")
         workspace_fail(f"Git status failed for {path}: {detail}")
-    entries = os.fsdecode(stdout).split("\0")
-    unexpected = [
-        entry
-        for entry in entries
-        if entry
-        and not (
-            entry.startswith("!! ")
-            and (candidate := path / entry[3:]).name == ".DS_Store"
-            and candidate.is_file()
-            and not candidate.is_symlink()
-        )
-    ]
-    if unexpected:
+    if stdout:
         workspace_fail(f"Managed source is dirty; direct edits are unsupported: {path}")
 
 
@@ -542,6 +524,13 @@ def _checkout_environment() -> dict[str, str]:
     }
 
 
+def _reset_worktree(path: Path, commit: str) -> None:
+    """Restore tracked files without applying host Git configuration."""
+    _worktree_command(
+        "-C", str(path), "-c", "core.autocrlf=false", "reset", "--hard", commit, env=_checkout_environment()
+    )
+
+
 def _merge_commit(path: Path, tree: str, previous: str, commit: str) -> str:
     """Write the deterministic commit used for one ordered merge input."""
     environment = _checkout_environment()
@@ -564,10 +553,47 @@ def _merge_commit(path: Path, tree: str, previous: str, commit: str) -> str:
     )
 
 
+def _assert_no_ignored_merge_collisions(path: Path, commit: str) -> None:
+    """Reject ignored files that an incoming merge could overwrite."""
+
+    def names(*arguments: str) -> set[str]:
+        returncode, stdout, stderr = _status_result("-C", str(path), *arguments, "-z")
+        if returncode:
+            workspace_fail(f"Git path inspection failed for {path}: {os.fsdecode(stderr).strip()}")
+        return set(os.fsdecode(stdout).split("\0")) - {""}
+
+    ignored = names("ls-files", "--others", "--ignored", "--exclude-standard")
+    if not ignored:
+        return
+    tree = _merge_command(
+        "-C",
+        str(path),
+        "-c",
+        "merge.renormalize=false",
+        "-c",
+        "rerere.enabled=false",
+        "merge-tree",
+        "--write-tree",
+        "HEAD",
+        commit,
+        env=_checkout_environment(),
+    ).splitlines()[0]
+    incoming = names("ls-tree", "-r", "--name-only", tree)
+    for name in incoming:
+        parts = name.split("/")
+        if any("/".join(parts[:index]) in ignored for index in range(1, len(parts) + 1)):
+            workspace_fail(f"Ignored file would be overwritten by merge in {path}: {name}")
+    for name in ignored:
+        parts = name.split("/")
+        if any("/".join(parts[:index]) in incoming for index in range(1, len(parts) + 1)):
+            workspace_fail(f"Ignored file would be overwritten by merge in {path}: {name}")
+
+
 def _merge_sources(path: Path, merge_commits: tuple[str, ...]) -> str:
     """Merge ordered inputs using fixed configuration and reproducible commits."""
     environment = _checkout_environment()
     for commit in merge_commits:
+        _assert_no_ignored_merge_collisions(path, commit)
         previous = _head(path)
         _merge_command(
             "-C",
@@ -586,6 +612,7 @@ def _merge_sources(path: Path, merge_commits: tuple[str, ...]) -> str:
             "--no-commit",
             "--no-stat",
             "--no-edit",
+            "--no-overwrite-ignore",
             "--",
             commit,
             env=environment,
@@ -656,7 +683,7 @@ def _publish_worktree(
             occupant = next((item for item in records if Path(item.get("worktree", "")) == path), None)
             if occupant is not None:
                 _usable_worktree(pool, path, root)
-                _assert_clean(path)
+                _assert_clean(path, include_untracked=True)
                 _worktree_command("-C", str(pool), "worktree", "remove", str(path))
             elif path.exists() or path.is_symlink():
                 workspace_fail(f"Readable source worktree path is occupied: {path}")
@@ -668,16 +695,26 @@ def _publish_worktree(
             workspace_fail(
                 f"Managed worktree path is occupied by another branch: {path} ({record.get('branch', 'detached')})."
             )
+        _assert_clean(selected)
         previous = _head(selected)
-        if record.get("branch") != branch_ref:
-            _repo(selected).switch(worktree_branch, base_commit, discard_changes=True)
-        _repo(selected).reset_hard(base_commit)
-        _repo(selected).clean()
+        _worktree_command(
+            "-C",
+            str(selected),
+            "-c",
+            "core.hooksPath=/dev/null",
+            "-c",
+            "core.autocrlf=false",
+            "switch",
+            "--no-overwrite-ignore",
+            "-C",
+            worktree_branch,
+            base_commit,
+            env=_checkout_environment(),
+        )
         try:
             resolved = _merge_sources(selected, merge_commits) if merge_commits else _head(selected)
         except Exception:
-            _repo(selected).reset_hard(previous)
-            _repo(selected).clean()
+            _reset_worktree(selected, previous)
             raise
         return selected, resolved
 
@@ -731,8 +768,7 @@ def _create_worktree(
             )
             created_branch = not existing
             if existing:
-                _repo(staging).reset_hard(base_commit)
-                _repo(staging).clean()
+                _reset_worktree(staging, base_commit)
             resolved = _merge_sources(staging, merge_commits) if merge_commits else _head(staging)
             _assert_clean(staging)
             _worktree_command(

{godoo_cli-1.0.4 → godoo_cli-1.0.5}/tests/workspace/test_workspace_git.py

@@ -16,7 +16,6 @@ from godoo_cli.git import GitUrl, native_git_result, repository
 from godoo_cli.git.repository import Git
 from godoo_cli.models import GitMergeSource, GodooGitRepo
 from godoo_cli.workspace.git import (
-    _assert_clean,
     _check_ref_format,
     _ensure_pool,
     _worktree_pool,
@@ -532,7 +531,7 @@ def test_checkout_bytes_do_not_depend_on_host_line_ending_configuration(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
     """Guards the contract that checkout bytes do not depend on host line ending configuration."""
-    _working, remote, _initial = _remote(tmp_path)
+    working, remote, _initial = _remote(tmp_path)
     config = tmp_path / "gitconfig"
     config.write_text("[core]\n\tautocrlf = true\n", encoding="utf-8")
     monkeypatch.setenv("GIT_CONFIG_GLOBAL", str(config))
@@ -540,6 +539,10 @@ def test_checkout_bytes_do_not_depend_on_host_line_ending_configuration(
     selected, _selected_commit = _selection(remote, tmp_path / "sources")
 
     assert (Path(selected) / "shared.txt").read_bytes() == b"original\n"
+    _commit(working, "next.txt", "advanced\n")
+    _git(working, "push", str(remote), "19.0")
+    _selection(remote, tmp_path / "sources")
+    assert (Path(selected) / "next.txt").read_bytes() == b"advanced\n"
 
 
 def test_merge_order_is_part_of_recipe_identity(tmp_path: Path) -> None:
@@ -644,39 +647,124 @@ def _assert_existing_floating_worktree_is_reset(tmp_path: Path) -> None:
     assert _git(Path(selected), "rev-parse", "HEAD") == advanced
 
 
-def test_ignored_changes_are_removed_on_sync(tmp_path: Path) -> None:
-    """Guards the contract that ignored changes are removed on sync."""
+def test_untracked_and_ignored_files_survive_inspection_and_sync(tmp_path: Path) -> None:
     working, remote, _initial = _remote(tmp_path)
     _commit(working, ".gitignore", "ignored.txt\n")
     _git(working, "push", str(remote), "19.0")
     root = tmp_path / "sources"
     selected, _selected_commit = _selection(remote, root)
-    (Path(selected) / "ignored.txt").write_text("unsupported", encoding="utf-8")
+    path = Path(selected)
+    (path / "ignored.txt").write_text("ignored content", encoding="utf-8")
+    (path / "untracked.txt").write_text("user content", encoding="utf-8")
+    repo = GodooGitRepo(url=remote.as_uri(), branch="19.0")
 
+    _inspect_repo(repo, root=root, default_branch="19.0", role="odoo")
+    _commit(working, "new.txt", "upstream update")
+    _git(working, "push", str(remote), "19.0")
     _selection(remote, root)
-    assert not (Path(selected) / "ignored.txt").exists()
 
+    assert (path / "new.txt").read_text(encoding="utf-8") == "upstream update"
+    assert (path / "ignored.txt").read_text(encoding="utf-8") == "ignored content"
+    assert (path / "untracked.txt").read_text(encoding="utf-8") == "user content"
 
-def test_ignored_finder_metadata_does_not_make_worktree_dirty(tmp_path: Path) -> None:
-    """Guards the narrow exception for ignored Finder metadata."""
-    working, remote, _initial = _remote(tmp_path)
-    _commit(working, ".gitignore", ".DS_Store\nignored.txt\n")
-    _git(working, "push", str(remote), "19.0")
+
+@pytest.mark.parametrize("staged", [False, True])
+def test_sync_rejects_tracked_changes(tmp_path: Path, staged: bool) -> None:
+    _working, remote, _initial = _remote(tmp_path)
     root = tmp_path / "sources"
     selected, _selected_commit = _selection(remote, root)
     path = Path(selected)
-    (path / ".DS_Store").write_bytes(b"finder metadata")
-    (path / "ignored.txt").write_text("unsupported", encoding="utf-8")
+    (path / "shared.txt").write_text("user edit", encoding="utf-8")
+    if staged:
+        _git(path, "add", "shared.txt")
 
     with pytest.raises(WorkspaceError, match="Managed source is dirty"):
-        _assert_clean(path)
-    (path / "ignored.txt").unlink()
-    _assert_clean(path)
-    (path / ".DS_Store").unlink()
-    (path / ".DS_Store").mkdir()
-    (path / ".DS_Store" / "nested").write_bytes(b"finder metadata directory")
-    with pytest.raises(WorkspaceError, match="Managed source is dirty"):
-        _assert_clean(path)
+        _selection(remote, root)
+    assert (path / "shared.txt").read_text(encoding="utf-8") == "user edit"
+
+
+@pytest.mark.parametrize("ignored", [False, True])
+def test_sync_rejects_untracked_collision_with_new_commit(tmp_path: Path, ignored: bool) -> None:
+    working, remote, _initial = _remote(tmp_path)
+    if ignored:
+        _commit(working, ".gitignore", "collision.txt\n")
+        _git(working, "push", str(remote), "19.0")
+    root = tmp_path / "sources"
+    selected, _selected_commit = _selection(remote, root)
+    path = Path(selected)
+    previous = _git(path, "rev-parse", "HEAD")
+    (path / "collision.txt").write_text("user content", encoding="utf-8")
+    (working / "collision.txt").write_text("upstream content", encoding="utf-8")
+    _git(working, "add", "-f", "collision.txt")
+    _git(working, "commit", "-m", "add collision")
+    _git(working, "push", str(remote), "19.0")
+
+    with pytest.raises(WorkspaceError, match="would be overwritten"):
+        _selection(remote, root)
+    assert (path / "collision.txt").read_text(encoding="utf-8") == "user content"
+    assert _git(path, "rev-parse", "HEAD") == previous
+
+
+def test_merge_collision_preserves_ignored_file_and_previous_commit(tmp_path: Path) -> None:
+    working, remote, _initial = _remote(tmp_path)
+    _commit(working, ".gitignore", "collision.txt\n")
+    _git(working, "checkout", "-b", "feature")
+    _commit(working, "feature.txt", "feature")
+    _git(working, "push", str(remote), "19.0", "feature")
+    root = tmp_path / "sources"
+    spec = _merge_spec(remote)
+    source = _sync_repo(spec, root=root, default_branch="19.0", role="odoo")
+    path = source.host_path
+    previous = _git(path, "rev-parse", "HEAD")
+    (path / "collision.txt").write_text("user content", encoding="utf-8")
+    (working / "collision.txt").write_text("upstream content", encoding="utf-8")
+    _git(working, "add", "-f", "collision.txt")
+    _git(working, "commit", "-m", "add collision")
+    _git(working, "push", str(remote), "feature")
+
+    with pytest.raises(WorkspaceError, match="would be overwritten"):
+        _sync_repo(spec, root=root, default_branch="19.0", role="odoo")
+    assert (path / "collision.txt").read_text(encoding="utf-8") == "user content"
+    assert _git(path, "rev-parse", "HEAD") == previous
+
+
+def test_merge_allows_ignored_file_when_result_keeps_its_deletion(tmp_path: Path) -> None:
+    working, remote, initial = _remote(tmp_path)
+    _git(working, "checkout", "-b", "feature", initial)
+    _commit(working, "feature.txt", "feature")
+    _git(working, "checkout", "19.0")
+    _git(working, "rm", "shared.txt")
+    _commit(working, ".gitignore", "shared.txt\n")
+    _git(working, "push", str(remote), "19.0", "feature")
+    root = tmp_path / "sources"
+    spec = _merge_spec(remote)
+    source = _sync_repo(spec, root=root, default_branch="19.0", role="odoo")
+    ignored = source.host_path / "shared.txt"
+    ignored.write_text("user content", encoding="utf-8")
+
+    _sync_repo(spec, root=root, default_branch="19.0", role="odoo")
+
+    assert ignored.read_text(encoding="utf-8") == "user content"
+
+
+def test_legacy_occupant_with_ignored_file_is_preserved(tmp_path: Path) -> None:
+    working, remote, _initial = _remote(tmp_path)
+    initial = _commit(working, ".gitignore", "ignored.txt\n")
+    _git(working, "push", str(remote), "19.0")
+    root = tmp_path / "sources"
+    selected, _selected_commit = _selection(remote, root)
+    readable = Path(selected)
+    pool = _worktree_pool(readable)
+    legacy = root / "worktrees" / "godoo%2F19.0"
+    legacy.parent.mkdir()
+    _git(pool, "worktree", "move", str(readable), str(legacy))
+    _git(pool, "worktree", "add", "--detach", str(readable), initial)
+    (readable / "ignored.txt").write_text("user content", encoding="utf-8")
+
+    with pytest.raises(WorkspaceError, match="dirty"):
+        _selection(remote, root)
+    assert (readable / "ignored.txt").read_text(encoding="utf-8") == "user content"
+    assert legacy.exists()
 
 
 def test_unrelated_named_worktree_at_expected_path_is_preserved(tmp_path: Path) -> None: