claude-code-conductor 0.2.0__tar.gz → 0.2.1__tar.gz

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.2.1] - 2026-05-01
+
+### Fixed
+- `c3 init` no longer copies personal/working files when run against the live
+  development tree. Two regressions in 0.2.0 caused this:
+  1. `templates_dir()` walked up from `__file__` looking for any ancestor with
+     `.claude/` + `pyproject.toml`. A wheel install in a venv that happened to
+     live inside the C3 source tree (e.g. `claude-code-conductor/.venv/...`)
+     therefore resolved to the dirty live `.claude/` instead of the bundled
+     `_template/`. The dev fallback is now anchored to `<root>/src/c3/` ancestry
+     so site-packages-loaded copies always use `importlib.resources`.
+  2. `_copytree` did not apply the same exclusion rules as the build hook,
+     so even legitimate editable installs (which intentionally serve the live
+     `.claude/`) could leak personal files. `cli_init` and `cli_update` now
+     share `c3._excludes` with `hatch_build.py`.
+
+### Added
+- `src/c3/_excludes.py` — single source of truth for excluded paths
+  (reports/, memory/sessions/, memory/patterns.json, docs/decisions.md, etc.).
+- Regression tests:
+  - `tests/test_paths.py` — `_resolve_dev_template` rejects site-packages paths.
+  - `tests/test_excludes.py` — KEEP_PATTERNS override EXCLUDE_PATTERNS.
+  - `tests/test_cli_init.py::test_init_excludes_personal_files` — init does not
+    leak personal files even when given a "dirty" template tree.
+
 ## [0.2.0] - 2026-05-01
 
 ### Added

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 0.2.0
+Version: 0.2.1
 Summary: Multi-agent orchestration framework for Claude Code (C3)
 Project-URL: Homepage, https://github.com/satoh-y-0323/claude-code-conductor
 Project-URL: Repository, https://github.com/satoh-y-0323/claude-code-conductor

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/hatch_build.py

@@ -17,25 +17,25 @@ from pathlib import Path
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
 
 
-# Files / directories that must NOT be redistributed (matched against paths
-# relative to the project root). Globs use fnmatch semantics.
+# Patterns matched against paths relative to ``.claude/``.
+# IMPORTANT: keep these in sync with ``src/c3/_excludes.py``. The build hook
+# runs before the package is importable, so we duplicate rather than import.
 EXCLUDE_PATTERNS: tuple[str, ...] = (
-    ".claude/reports/*",
-    ".claude/memory/sessions/*",
-    ".claude/memory/patterns.json",
-    ".claude/memory/agent-audit.log",
-    ".claude/tmp/*",
-    ".claude/docs/decisions.md",
-    ".claude/docs/taxonomy.md",
-    ".claude/docs/game-studios-research.md",
+    "reports/*",
+    "memory/sessions/*",
+    "memory/patterns.json",
+    "memory/agent-audit.log",
+    "tmp/*",
+    "docs/decisions.md",
+    "docs/taxonomy.md",
+    "docs/game-studios-research.md",
 )
 
-# Patterns that should always survive even if their parent matches an exclude.
 KEEP_PATTERNS: tuple[str, ...] = (
-    ".claude/reports/.gitkeep",
-    ".claude/memory/.gitkeep",
-    ".claude/memory/sessions/.gitkeep",
-    ".claude/tmp/.gitkeep",
+    "reports/.gitkeep",
+    "memory/.gitkeep",
+    "memory/sessions/.gitkeep",
+    "tmp/.gitkeep",
 )
 
 
@@ -53,17 +53,16 @@ class StageTemplateHook(BuildHookInterface):
         if dest.exists():
             shutil.rmtree(dest)
         dest.mkdir(parents=True, exist_ok=True)
-        _copy_filtered(source, dest, root)
+        _copy_filtered(source, dest, source)
 
 
-def _copy_filtered(src: Path, dst: Path, project_root: Path) -> None:
+def _copy_filtered(src: Path, dst: Path, claude_root: Path) -> None:
     for entry in src.iterdir():
-        rel = entry.relative_to(project_root).as_posix()
+        rel = entry.relative_to(claude_root).as_posix()
         if entry.is_dir():
             sub_dst = dst / entry.name
             sub_dst.mkdir(exist_ok=True)
-            _copy_filtered(entry, sub_dst, project_root)
-            # Drop any empty dirs that ended up with nothing to keep.
+            _copy_filtered(entry, sub_dst, claude_root)
             if not any(sub_dst.iterdir()):
                 sub_dst.rmdir()
         elif entry.is_file():
@@ -73,6 +72,6 @@ def _copy_filtered(src: Path, dst: Path, project_root: Path) -> None:
 
 
 def _should_skip(rel: str) -> bool:
-    if any(fnmatch.fnmatch(rel, p) for p in KEEP_PATTERNS):
+    if any(fnmatch.fnmatchcase(rel, p) for p in KEEP_PATTERNS):
         return False
-    return any(fnmatch.fnmatch(rel, p) for p in EXCLUDE_PATTERNS)
+    return any(fnmatch.fnmatchcase(rel, p) for p in EXCLUDE_PATTERNS)

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/src/c3/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Conductor (C3) - multi-agent orchestration framework for Claude Code."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

claude_code_conductor-0.2.1/src/c3/_excludes.py

@@ -0,0 +1,43 @@
+"""Files inside ``.claude/`` that are personal/working state.
+
+Used by:
+
+- ``c3 init``    — never copied to the destination project
+- ``c3 update``  — never overwritten in the destination project
+- ``hatch_build.py`` — never bundled into the wheel template (the patterns are
+  duplicated there because the build hook runs *before* the package is
+  importable; keep both lists in sync)
+
+Patterns are POSIX-style and relative to the ``.claude/`` directory itself
+(e.g. ``"reports/*"``, not ``".claude/reports/*"``). ``KEEP_PATTERNS`` win
+over ``EXCLUDE_PATTERNS`` so that placeholder ``.gitkeep`` files survive.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+
+EXCLUDE_PATTERNS: tuple[str, ...] = (
+    "reports/*",
+    "memory/sessions/*",
+    "memory/patterns.json",
+    "memory/agent-audit.log",
+    "tmp/*",
+    "docs/decisions.md",
+    "docs/taxonomy.md",
+    "docs/game-studios-research.md",
+)
+
+KEEP_PATTERNS: tuple[str, ...] = (
+    "reports/.gitkeep",
+    "memory/.gitkeep",
+    "memory/sessions/.gitkeep",
+    "tmp/.gitkeep",
+)
+
+
+def should_skip(rel_posix: str) -> bool:
+    """Return True if the path (relative to ``.claude/``) is personal state."""
+    if any(fnmatch.fnmatchcase(rel_posix, p) for p in KEEP_PATTERNS):
+        return False
+    return any(fnmatch.fnmatchcase(rel_posix, p) for p in EXCLUDE_PATTERNS)

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/src/c3/cli_init.py

@@ -7,6 +7,7 @@ import shutil
 import sys
 from pathlib import Path
 
+from c3._excludes import should_skip
 from c3.paths import templates_dir
 
 
@@ -56,15 +57,28 @@ def handle(args: argparse.Namespace) -> int:
     return 0
 
 
-def _copytree(src: Path, dst: Path) -> int:
-    """Copy src -> dst recursively; return number of regular files written."""
+def _copytree(src: Path, dst: Path, *, root: Path | None = None) -> int:
+    """Copy ``src`` -> ``dst`` recursively, skipping personal/working files.
+
+    ``root`` defaults to ``src`` and represents the ``.claude/`` directory; the
+    relative path from ``root`` is what ``should_skip`` matches against.
+    Returns the number of regular files written.
+    """
+    if root is None:
+        root = src
     dst.mkdir(parents=True, exist_ok=True)
     count = 0
     for entry in src.iterdir():
+        rel = entry.relative_to(root).as_posix()
         target = dst / entry.name
         if entry.is_dir():
-            count += _copytree(entry, target)
+            count += _copytree(entry, target, root=root)
+            # Drop directories that ended up empty (everything inside was skipped).
+            if not any(target.iterdir()):
+                target.rmdir()
         elif entry.is_file():
+            if should_skip(rel):
+                continue
             shutil.copy2(entry, target)
             count += 1
     return count

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/src/c3/cli_update.py

@@ -8,23 +8,9 @@ import shutil
 import sys
 from pathlib import Path
 
+from c3._excludes import should_skip
 from c3.paths import templates_dir
 
-# Files that the user is expected to edit locally; never overwrite them.
-# These match the .gitignore entries used in the C3 source repo.
-_LOCAL_FILES: tuple[str, ...] = (
-    "docs/decisions.md",
-    "docs/taxonomy.md",
-    "docs/game-studios-research.md",
-    "memory/patterns.json",
-    "memory/agent-audit.log",
-)
-_LOCAL_DIRS: tuple[str, ...] = (
-    "memory/sessions",
-    "reports",
-    "tmp",
-)
-
 
 def register(subparsers: argparse._SubParsersAction) -> None:
     parser = subparsers.add_parser(
@@ -90,10 +76,12 @@ def _walk_diff(template: Path, dest: Path):
     """Yield (action, absolute_dest_path) tuples for files that differ.
 
     Only ``add`` and ``update`` are emitted; we never delete files in dest.
+    Personal/working files (per ``c3._excludes``) are skipped both as bundle
+    sources and as overwrite targets.
     """
     for src_file in _iter_files(template):
         rel = src_file.relative_to(template)
-        if _is_local(rel):
+        if should_skip(rel.as_posix()):
             continue
         target = dest / rel
         if not target.exists():
@@ -108,10 +96,3 @@ def _iter_files(root: Path):
             yield from _iter_files(entry)
         elif entry.is_file():
             yield entry
-
-
-def _is_local(rel: Path) -> bool:
-    rel_posix = rel.as_posix()
-    if rel_posix in _LOCAL_FILES:
-        return True
-    return any(rel_posix == d or rel_posix.startswith(d + "/") for d in _LOCAL_DIRS)

{claude_code_conductor-0.2.0 → claude_code_conductor-0.2.1}/src/c3/paths.py

@@ -30,24 +30,22 @@ def templates_dir() -> Path:
 
     Resolution order:
 
-    1. Dev source: walk up from this file looking for a sibling ``.claude/``
-       next to a ``pyproject.toml``. This makes editable installs (``pip install
-       -e .``) reflect live edits to the source ``.claude/`` without rebuilding.
-       In a wheel-installed environment the ``.py`` files live under
-       ``site-packages/`` and this lookup naturally returns no match.
-    2. Installed location: ``importlib.resources.files("c3") / "_template" / ".claude"``.
+    1. Editable / source install: this module is being loaded directly from
+       ``<root>/src/c3/paths.py`` (i.e. via ``pip install -e .`` or
+       ``PYTHONPATH=src``) AND ``<root>/.claude/`` and ``<root>/pyproject.toml``
+       both exist. Use the live ``.claude/`` so dev edits are reflected
+       immediately. The check is anchored on the ``src/c3/`` ancestry so that a
+       venv that happens to live *inside* the C3 source tree does not trigger
+       this branch when a wheel-installed copy of the package is in use.
+    2. Wheel install: ``importlib.resources.files("c3") / "_template" / ".claude"``.
        This is the path produced by hatchling's build hook + ``force-include``
        during ``pip install``.
 
-    Raises ``FileNotFoundError`` if neither location exists. This usually means
-    the package was built without the template (manually copied source tree) -
-    reinstall via pip to fix.
+    Raises ``FileNotFoundError`` if neither location resolves.
     """
-    here = Path(__file__).resolve()
-    for parent in here.parents:
-        candidate = parent / ".claude"
-        if candidate.is_dir() and (parent / "pyproject.toml").is_file():
-            return candidate
+    dev = _resolve_dev_template(Path(__file__).resolve())
+    if dev is not None:
+        return dev
 
     try:
         bundled = _resource_files("c3").joinpath("_template", ".claude")
@@ -62,3 +60,17 @@ def templates_dir() -> Path:
         "Reinstall claude-code-conductor with "
         "`pip install --force-reinstall claude-code-conductor`."
     )
+
+
+def _resolve_dev_template(here: Path) -> Path | None:
+    """Return the live ``.claude/`` only when ``here`` is loaded from ``<root>/src/c3/``.
+
+    Split out so that the resolution logic is testable with synthetic paths.
+    """
+    if here.parent.name != "c3" or here.parent.parent.name != "src":
+        return None
+    project_root = here.parent.parent.parent
+    candidate = project_root / ".claude"
+    if candidate.is_dir() and (project_root / "pyproject.toml").is_file():
+        return candidate
+    return None