kanibako-cli 1.6.0.dev26__tar.gz → 1.6.0.dev30__tar.gz

{kanibako_cli-1.6.0.dev26/src/kanibako_cli.egg-info → kanibako_cli-1.6.0.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev26
+Version: 1.6.0.dev30
 Summary: Run AI coding agents in rootless containers with per-project isolation
 Requires-Python: >=3.11
 License-File: LICENSE.md

{kanibako_cli-1.6.0.dev26 → kanibako_cli-1.6.0.dev30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kanibako-cli"
-version = "1.6.0.dev26"
+version = "1.6.0.dev30"
 description = "Run AI coding agents in rootless containers with per-project isolation"
 requires-python = ">=3.11"
 dependencies = ["argcomplete>=3.0", "PyYAML>=6.0", "packaging>=20.0"]

{kanibako_cli-1.6.0.dev26 → kanibako_cli-1.6.0.dev30}/src/kanibako/__init__.py

@@ -1,6 +1,6 @@
 """kanibako: Run AI coding agents in rootless containers with per-project isolation."""
 
-__version__ = "1.6.0.dev26"
+__version__ = "1.6.0.dev30"
 
 # The oldest build version whose ``setup`` run is still considered current.  The
 # setup-completion gate (W1) re-nudges the user to re-run ``kanibako setup`` when

{kanibako_cli-1.6.0.dev26 → kanibako_cli-1.6.0.dev30}/src/kanibako/templates.py

@@ -107,26 +107,47 @@ def apply_template_layers(
     """Seed *home* once by copying the ordered template *layers* in order.
 
     The 1.6.0 home-seed model layers ordered template sources into the box home
-    at creation (base -> agent -> workset; later overlays earlier).  Each layer
-    in *layers* is copied into *home* in sequence with ``dirs_exist_ok=True`` so
-    a later layer's file overwrites an earlier layer's file at the same relative
-    path (per-file LAST-WINS).  Layers that do not exist on disk are skipped (a
-    ``<None>`` / absent layer contributes nothing — e.g. STANDALONE boxes have
-    no workset layer).
-
-    This is SEED-ONCE: callers invoke it only on box creation
-    (``proj.is_new``).  It does NOT special-case or merge any file — every file
+    at creation (base -> agent -> workset; later overlays earlier).  The copy is
+    NON-DESTRUCTIVE toward files that ALREADY EXIST in *home* before this seed
+    pass begins: such a pre-existing file (a user-edited home file on a
+    marker-less migrated box) is NEVER clobbered.  This is the guard against
+    re-seed DATA LOSS — a box whose home is already populated but lacks the
+    ``.seeded`` marker would otherwise have its files overwritten.
+
+    Within a SINGLE seed pass, cross-layer LAST-WINS is still honoured: a file
+    written by an earlier layer during this pass IS overwritten by a later
+    layer's file at the same relative path.  A per-pass ``written`` set of
+    relative paths distinguishes "created earlier this pass" (override OK) from
+    "pre-existed before the pass" (preserve).  Layers that do not exist on disk
+    are skipped (a ``<None>`` / absent layer contributes nothing — e.g.
+    STANDALONE boxes have no workset layer).
+
+    This is SEED-ONCE: callers invoke it only when the box still
+    :func:`needs_seed`.  It does NOT special-case or merge any file — every file
     is a plain ordered copy (the CLAUDE.md merge special-case is gone, D-B5).
-    The caller is responsible for never re-running it on a subsequent launch so
-    user edits made inside the box survive (D-B6).
+    The caller is responsible for never re-running it once the box is marked
+    seeded so user edits made inside the box survive (D-B6); the non-destructive
+    copy here is an additional safety net for the marker-less re-seed case.
     """
+    written: set[Path] = set()
     for layer in layers:
         if layer is None:
             continue
         if not layer.is_dir():
             continue
-        home.mkdir(parents=True, exist_ok=True)
-        shutil.copytree(str(layer), str(home), dirs_exist_ok=True)
+        for entry in sorted(layer.rglob("*")):
+            if not entry.is_file():
+                continue
+            rel = entry.relative_to(layer)
+            target = home / rel
+            # Write when an earlier layer in THIS pass created the file
+            # (last-wins override) OR the target does not yet exist.  Skip a
+            # target that pre-existed the pass (a user/pre-existing file).
+            if rel not in written and target.exists():
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(str(entry), str(target))
+            written.add(rel)
 
 
 # ---------------------------------------------------------------------------

{kanibako_cli-1.6.0.dev26 → kanibako_cli-1.6.0.dev30/src/kanibako_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.6.0.dev26
+Version: 1.6.0.dev30
 Summary: Run AI coding agents in rootless containers with per-project isolation
 Requires-Python: >=3.11
 License-File: LICENSE.md

{kanibako_cli-1.6.0.dev26 → kanibako_cli-1.6.0.dev30}/tests/test_templates.py

@@ -76,6 +76,70 @@ class TestApplyTemplateLayers:
         assert (home / "user-edited.txt").read_text() == "user changes"
         assert (home / "base-only.txt").read_text() == "base"
 
+    def test_existing_home_file_not_clobbered_by_same_path_layer(self, tmp_path):
+        """A pre-existing home file is preserved even when a layer ships the same path.
+
+        This is the re-seed DATA-LOSS guard: a marker-less migrated box has a
+        home full of user-edited files; a layer with a file at the same relative
+        path must NOT overwrite the user's content.
+        """
+        home = tmp_path / "home"
+        home.mkdir()
+        (home / "shared.txt").write_text("user changes")
+        base = self._layer(tmp_path, "base", {
+            "shared.txt": "base version",
+            "base-only.txt": "base",
+        })
+
+        apply_template_layers(home, [base])
+
+        # Pre-existing file preserved (NOT clobbered by the layer's same-path file).
+        assert (home / "shared.txt").read_text() == "user changes"
+        # New file from the layer still lands.
+        assert (home / "base-only.txt").read_text() == "base"
+
+    def test_cross_layer_last_wins_when_home_absent(self, tmp_path):
+        """Two layers both shipping foo.txt -> later layer wins (home didn't have it)."""
+        home = tmp_path / "home"
+        home.mkdir()
+        base = self._layer(tmp_path, "base", {"foo.txt": "base version"})
+        agent = self._layer(tmp_path, "agent", {"foo.txt": "agent version"})
+
+        apply_template_layers(home, [base, agent])
+
+        # Later layer overrides the earlier layer's file written THIS pass.
+        assert (home / "foo.txt").read_text() == "agent version"
+
+    def test_new_layer_files_land_in_nonempty_home(self, tmp_path):
+        """Files unique to a layer are copied into an existing non-empty home."""
+        home = tmp_path / "home"
+        home.mkdir()
+        (home / "user-edited.txt").write_text("user changes")
+        base = self._layer(tmp_path, "base", {
+            "base-only.txt": "base",
+            "nested/deep.txt": "deep",
+        })
+
+        apply_template_layers(home, [base])
+
+        # Pre-existing user file untouched.
+        assert (home / "user-edited.txt").read_text() == "user changes"
+        # New unique files (including nested) land.
+        assert (home / "base-only.txt").read_text() == "base"
+        assert (home / "nested" / "deep.txt").read_text() == "deep"
+
+    def test_existing_nested_file_not_clobbered(self, tmp_path):
+        """A pre-existing file in a nested home subdir is preserved against a layer."""
+        home = tmp_path / "home"
+        nested = home / ".claude"
+        nested.mkdir(parents=True)
+        (nested / "settings.json").write_text("user settings")
+        agent = self._layer(tmp_path, "agent", {".claude/settings.json": "shipped"})
+
+        apply_template_layers(home, [agent])
+
+        assert (home / ".claude" / "settings.json").read_text() == "user settings"
+
     def test_none_and_missing_layers_skipped(self, tmp_path):
         """A None layer or a layer dir that doesn't exist contributes nothing."""
         home = tmp_path / "home"