@mindfoldhq/trellis 0.5.12 → 0.5.14

package/dist/templates/trellis/scripts/common/session_context.py

@@ -50,12 +50,140 @@ _VERSION_RE = re.compile(
     r"^\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?\s*$"
 )
 _VERSION_TOKEN_RE = re.compile(r"\b\d+(?:\.\d+){1,2}(?:-[0-9A-Za-z.-]+)?\b")
+_POLYREPO_IGNORED_DIRS = {
+    "node_modules",
+    "target",
+    "dist",
+    "build",
+    "out",
+    "bin",
+    "obj",
+    "vendor",
+    "coverage",
+    "tmp",
+    "__pycache__",
+}
+_POLYREPO_SCAN_MAX_DEPTH = 2
+
+
+def _is_git_worktree(path: Path) -> bool:
+    """Return True when path is inside a Git worktree."""
+    rc, out, _ = run_git(["rev-parse", "--is-inside-work-tree"], cwd=path)
+    return rc == 0 and out.strip().lower() == "true"
+
+
+def _parse_recent_commits(log_output: str) -> list[dict]:
+    """Parse `git log --oneline` output into structured commit entries."""
+    commits = []
+    for line in log_output.splitlines():
+        if not line.strip():
+            continue
+        parts = line.split(" ", 1)
+        if len(parts) >= 2:
+            commits.append({"hash": parts[0], "message": parts[1]})
+        elif len(parts) == 1:
+            commits.append({"hash": parts[0], "message": ""})
+    return commits
+
+
+def _collect_git_repo_info(name: str, rel_path: str, repo_dir: Path) -> dict | None:
+    """Collect Git status for one known repository directory."""
+    if not (repo_dir / ".git").exists():
+        return None
+
+    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_dir)
+    branch = branch_out.strip() or "unknown"
+
+    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_dir)
+    changes = len([l for l in status_out.splitlines() if l.strip()])
+
+    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_dir)
+
+    return {
+        "name": name,
+        "path": rel_path,
+        "branch": branch,
+        "isClean": changes == 0,
+        "uncommittedChanges": changes,
+        "recentCommits": _parse_recent_commits(log_out),
+    }
+
+
+def _collect_root_git_info(repo_root: Path) -> dict:
+    """Collect root Git info without pretending a non-Git root is clean."""
+    if not _is_git_worktree(repo_root):
+        return {
+            "isRepo": False,
+            "branch": "",
+            "isClean": False,
+            "uncommittedChanges": 0,
+            "recentCommits": [],
+        }
+
+    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_root)
+    branch = branch_out.strip() or "unknown"
+
+    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_root)
+    status_lines = [line for line in status_out.splitlines() if line.strip()]
+
+    _, short_out, _ = run_git(["status", "--short"], cwd=repo_root)
+
+    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_root)
+
+    return {
+        "isRepo": True,
+        "branch": branch,
+        "isClean": len(status_lines) == 0,
+        "uncommittedChanges": len(status_lines),
+        "statusShort": short_out.splitlines(),
+        "recentCommits": _parse_recent_commits(log_out),
+    }
+
+
+def _discover_child_git_repos(repo_root: Path) -> list[tuple[str, str]]:
+    """Discover child Git repositories using the init-time polyrepo heuristic."""
+    found: list[str] = []
 
+    def is_candidate_dir(path: Path) -> bool:
+        name = path.name
+        return not name.startswith(".") and name not in _POLYREPO_IGNORED_DIRS
 
-def _collect_package_git_info(repo_root: Path) -> list[dict]:
-    """Collect git status and recent commits for packages with independent git repos.
+    def scan(rel_dir: Path, depth: int) -> None:
+        if depth >= _POLYREPO_SCAN_MAX_DEPTH:
+            return
+        abs_dir = repo_root / rel_dir
+        try:
+            children = sorted(abs_dir.iterdir(), key=lambda p: p.name)
+        except OSError:
+            return
 
-    Only packages marked with ``git: true`` in config.yaml are included.
+        for child in children:
+            if not child.is_dir() or not is_candidate_dir(child):
+                continue
+
+            child_rel = (
+                rel_dir / child.name if rel_dir != Path(".") else Path(child.name)
+            )
+            if (child / ".git").exists():
+                found.append(child_rel.as_posix())
+                continue
+            scan(child_rel, depth + 1)
+
+    scan(Path("."), 0)
+    if len(found) < 2:
+        return []
+    return [(path.replace("/", "_"), path) for path in sorted(found)]
+
+
+def _collect_package_git_info(
+    repo_root: Path,
+    discover_unconfigured: bool = False,
+) -> list[dict]:
+    """Collect Git status for independent package repositories.
+
+    Packages marked with ``git: true`` in config.yaml are authoritative.
+    When the Trellis root is not a Git repo and no configured package repos are
+    available, optionally fall back to the bounded polyrepo child scan.
 
     Returns:
         List of dicts with keys: name, path, branch, isClean,
@@ -63,41 +191,56 @@ def _collect_package_git_info(repo_root: Path) -> list[dict]:
         Empty list if no git-repo packages are configured.
     """
     git_pkgs = get_git_packages(repo_root)
-    if not git_pkgs:
-        return []
-
     result = []
     for pkg_name, pkg_path in git_pkgs.items():
         pkg_dir = repo_root / pkg_path
-        if not (pkg_dir / ".git").exists():
-            continue
+        info = _collect_git_repo_info(pkg_name, pkg_path, pkg_dir)
+        if info is not None:
+            result.append(info)
 
-        _, branch_out, _ = run_git(["branch", "--show-current"], cwd=pkg_dir)
-        branch = branch_out.strip() or "unknown"
-
-        _, status_out, _ = run_git(["status", "--porcelain"], cwd=pkg_dir)
-        changes = len([l for l in status_out.splitlines() if l.strip()])
-
-        _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=pkg_dir)
-        commits = []
-        for line in log_out.splitlines():
-            if line.strip():
-                parts = line.split(" ", 1)
-                if len(parts) >= 2:
-                    commits.append({"hash": parts[0], "message": parts[1]})
-                elif len(parts) == 1:
-                    commits.append({"hash": parts[0], "message": ""})
-
-        result.append({
-            "name": pkg_name,
-            "path": pkg_path,
-            "branch": branch,
-            "isClean": changes == 0,
-            "uncommittedChanges": changes,
-            "recentCommits": commits,
-        })
+    if result or not discover_unconfigured:
+        return result
+
+    discovered = []
+    for pkg_name, pkg_path in _discover_child_git_repos(repo_root):
+        info = _collect_git_repo_info(pkg_name, pkg_path, repo_root / pkg_path)
+        if info is not None:
+            discovered.append(info)
+    return discovered
 
-    return result
+
+def _append_root_git_context(lines: list[str], root_git_info: dict) -> None:
+    """Append root Git status without misleading non-Git roots."""
+    lines.append("## GIT STATUS")
+    if not root_git_info["isRepo"]:
+        lines.append("Root is not a Git repository.")
+        lines.append("Run Git commands from the package repository paths listed below.")
+    else:
+        lines.append(f"Branch: {root_git_info['branch']}")
+        if root_git_info["isClean"]:
+            lines.append("Working directory: Clean")
+        else:
+            lines.append(
+                f"Working directory: {root_git_info['uncommittedChanges']} "
+                "uncommitted change(s)"
+            )
+            lines.append("")
+            lines.append("Changes:")
+            for line in root_git_info.get("statusShort", [])[:10]:
+                lines.append(line)
+    lines.append("")
+
+    lines.append("## RECENT COMMITS")
+    if not root_git_info["isRepo"]:
+        lines.append(
+            "Root has no Git commit history because it is not a Git repository."
+        )
+    elif root_git_info["recentCommits"]:
+        for commit in root_git_info["recentCommits"]:
+            lines.append(f"{commit['hash']} {commit['message']}")
+    else:
+        lines.append("(no commits)")
+    lines.append("")
 
 
 def _append_package_git_context(lines: list[str], package_git_info: list[dict]) -> None:
@@ -301,24 +444,7 @@ def get_context_json(repo_root: Path | None = None) -> dict:
             f"{DIR_WORKFLOW}/{DIR_WORKSPACE}/{developer}/{journal_file.name}"
         )
 
-    # Git info
-    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_root)
-    branch = branch_out.strip() or "unknown"
-
-    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_root)
-    git_status_count = len([line for line in status_out.splitlines() if line.strip()])
-    is_clean = git_status_count == 0
-
-    # Recent commits
-    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_root)
-    commits = []
-    for line in log_out.splitlines():
-        if line.strip():
-            parts = line.split(" ", 1)
-            if len(parts) >= 2:
-                commits.append({"hash": parts[0], "message": parts[1]})
-            elif len(parts) == 1:
-                commits.append({"hash": parts[0], "message": ""})
+    root_git_info = _collect_root_git_info(repo_root)
 
     # Tasks
     tasks = [
@@ -333,15 +459,19 @@ def get_context_json(repo_root: Path | None = None) -> dict:
     ]
 
     # Package git repos (independent sub-repositories)
-    pkg_git_info = _collect_package_git_info(repo_root)
+    pkg_git_info = _collect_package_git_info(
+        repo_root,
+        discover_unconfigured=not root_git_info["isRepo"],
+    )
 
     result = {
         "developer": developer or "",
         "git": {
-            "branch": branch,
-            "isClean": is_clean,
-            "uncommittedChanges": git_status_count,
-            "recentCommits": commits,
+            "isRepo": root_git_info["isRepo"],
+            "branch": root_git_info["branch"],
+            "isClean": root_git_info["isClean"],
+            "uncommittedChanges": root_git_info["uncommittedChanges"],
+            "recentCommits": root_git_info["recentCommits"],
         },
         "tasks": {
             "active": tasks,
@@ -405,39 +535,17 @@ def get_context_text(repo_root: Path | None = None) -> str:
     lines.append(f"Name: {developer}")
     lines.append("")
 
-    # Git status
-    lines.append("## GIT STATUS")
-    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_root)
-    branch = branch_out.strip() or "unknown"
-    lines.append(f"Branch: {branch}")
-
-    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_root)
-    status_lines = [line for line in status_out.splitlines() if line.strip()]
-    status_count = len(status_lines)
-
-    if status_count == 0:
-        lines.append("Working directory: Clean")
-    else:
-        lines.append(f"Working directory: {status_count} uncommitted change(s)")
-        lines.append("")
-        lines.append("Changes:")
-        _, short_out, _ = run_git(["status", "--short"], cwd=repo_root)
-        for line in short_out.splitlines()[:10]:
-            lines.append(line)
-    lines.append("")
-
-    # Recent commits
-    lines.append("## RECENT COMMITS")
-    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_root)
-    if log_out.strip():
-        for line in log_out.splitlines():
-            lines.append(line)
-    else:
-        lines.append("(no commits)")
-    lines.append("")
+    root_git_info = _collect_root_git_info(repo_root)
+    _append_root_git_context(lines, root_git_info)
 
     # Package git repos — independent sub-repositories
-    _append_package_git_context(lines, _collect_package_git_info(repo_root))
+    _append_package_git_context(
+        lines,
+        _collect_package_git_info(
+            repo_root,
+            discover_unconfigured=not root_git_info["isRepo"],
+        ),
+    )
 
     # Current task
     lines.append("## CURRENT TASK")
@@ -557,20 +665,7 @@ def get_context_record_json(repo_root: Path | None = None) -> dict:
     developer = get_developer(repo_root)
     tasks_dir = get_tasks_dir(repo_root)
 
-    # Git info
-    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_root)
-    branch = branch_out.strip() or "unknown"
-
-    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_root)
-    git_status_count = len([line for line in status_out.splitlines() if line.strip()])
-
-    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_root)
-    commits = []
-    for line in log_out.splitlines():
-        if line.strip():
-            parts = line.split(" ", 1)
-            if len(parts) >= 2:
-                commits.append({"hash": parts[0], "message": parts[1]})
+    root_git_info = _collect_root_git_info(repo_root)
 
     # My tasks (single pass — collect statuses and filter by assignee)
     all_tasks_list = list(iter_active_tasks(tasks_dir))
@@ -610,15 +705,19 @@ def get_context_record_json(repo_root: Path | None = None) -> dict:
             }
 
     # Package git repos
-    pkg_git_info = _collect_package_git_info(repo_root)
+    pkg_git_info = _collect_package_git_info(
+        repo_root,
+        discover_unconfigured=not root_git_info["isRepo"],
+    )
 
     result = {
         "developer": developer or "",
         "git": {
-            "branch": branch,
-            "isClean": git_status_count == 0,
-            "uncommittedChanges": git_status_count,
-            "recentCommits": commits,
+            "isRepo": root_git_info["isRepo"],
+            "branch": root_git_info["branch"],
+            "isClean": root_git_info["isClean"],
+            "uncommittedChanges": root_git_info["uncommittedChanges"],
+            "recentCommits": root_git_info["recentCommits"],
         },
         "myTasks": my_tasks,
         "currentTask": current_task_info,
@@ -673,39 +772,17 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
         lines.append("(no active tasks assigned to you)")
     lines.append("")
 
-    # GIT STATUS
-    lines.append("## GIT STATUS")
-    _, branch_out, _ = run_git(["branch", "--show-current"], cwd=repo_root)
-    branch = branch_out.strip() or "unknown"
-    lines.append(f"Branch: {branch}")
-
-    _, status_out, _ = run_git(["status", "--porcelain"], cwd=repo_root)
-    status_lines = [line for line in status_out.splitlines() if line.strip()]
-    status_count = len(status_lines)
-
-    if status_count == 0:
-        lines.append("Working directory: Clean")
-    else:
-        lines.append(f"Working directory: {status_count} uncommitted change(s)")
-        lines.append("")
-        lines.append("Changes:")
-        _, short_out, _ = run_git(["status", "--short"], cwd=repo_root)
-        for line in short_out.splitlines()[:10]:
-            lines.append(line)
-    lines.append("")
-
-    # RECENT COMMITS
-    lines.append("## RECENT COMMITS")
-    _, log_out, _ = run_git(["log", "--oneline", "-5"], cwd=repo_root)
-    if log_out.strip():
-        for line in log_out.splitlines():
-            lines.append(line)
-    else:
-        lines.append("(no commits)")
-    lines.append("")
+    root_git_info = _collect_root_git_info(repo_root)
+    _append_root_git_context(lines, root_git_info)
 
     # Package git repos — independent sub-repositories
-    _append_package_git_context(lines, _collect_package_git_info(repo_root))
+    _append_package_git_context(
+        lines,
+        _collect_package_git_info(
+            repo_root,
+            discover_unconfigured=not root_git_info["isRepo"],
+        ),
+    )
 
     # CURRENT TASK
     lines.append("## CURRENT TASK")

package/dist/templates/trellis/scripts/common/task_store.py

@@ -337,6 +337,9 @@ def cmd_archive(args: argparse.Namespace) -> int:
 
     # Update status before archiving
     today = datetime.now().strftime("%Y-%m-%d")
+    # Names of child task dirs whose task.json gets modified below; passed
+    # into safe_archive_paths_to_add so they're staged in this commit.
+    modified_children: list[str] = []
     if task_json_path.is_file():
         data = read_json(task_json_path)
         if data:
@@ -361,6 +364,7 @@ def cmd_archive(args: argparse.Namespace) -> int:
                             if child_data:
                                 child_data["parent"] = None
                                 write_json(child_json, child_data)
+                                modified_children.append(child_dir_path.name)
 
     # Clear any session that still points at this task before the path moves.
     from .active_task import clear_task_from_sessions
@@ -375,7 +379,7 @@ def cmd_archive(args: argparse.Namespace) -> int:
 
         # Auto-commit unless --no-commit
         if not getattr(args, "no_commit", False):
-            _auto_commit_archive(dir_name, repo_root)
+            _auto_commit_archive(dir_name, repo_root, modified_children)
 
         # Return the archive path
         print(f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}/{year_month}/{dir_name}")
@@ -388,18 +392,26 @@ def cmd_archive(args: argparse.Namespace) -> int:
     return 1
 
 
-def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
+def _auto_commit_archive(
+    task_name: str,
+    repo_root: Path,
+    modified_children: list[str] | None = None,
+) -> None:
     """Stage Trellis-owned task paths and commit after archive.
 
-    Only stages specific subpaths (the archive subtree and active task dirs),
-    never the whole ``.trellis/`` tree. If ``.gitignore`` blocks the paths,
-    we warn + skip — we do NOT retry with ``git add -f``. The warning
-    explicitly forbids ``git add -f .trellis/`` (which would fan out to
-    caches/backups) and points users at ``session_auto_commit: false``.
+    Scoped narrowly to the archived task's source + destination paths
+    plus any child task dirs whose ``task.json`` was edited (parent →
+    children relationship update). Dirty changes in OTHER active task
+    dirs are NOT bundled into the archive commit.
 
-    Honors ``session_auto_commit`` in ``.trellis/config.yaml``: when set to
-    ``false``, this function returns immediately without touching git
-    (the archive directory move on disk is unaffected).
+    If ``.gitignore`` blocks the paths, we warn + skip — we do NOT
+    retry with ``git add -f``. The warning explicitly forbids
+    ``git add -f .trellis/`` (which would fan out to caches/backups)
+    and points users at ``session_auto_commit: false``.
+
+    Honors ``session_auto_commit`` in ``.trellis/config.yaml``: when
+    set to ``false``, this function returns immediately without
+    touching git (the archive directory move on disk is unaffected).
     """
     if not get_session_auto_commit(repo_root):
         print(
@@ -408,7 +420,9 @@ def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
         )
         return
 
-    paths = safe_archive_paths_to_add(repo_root)
+    paths = safe_archive_paths_to_add(
+        repo_root, task_name=task_name, modified_children=modified_children
+    )
     if not paths:
         print("[OK] No task changes to commit.", file=sys.stderr)
         return
@@ -424,8 +438,24 @@ def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
             )
         return
 
+    # Belt-and-suspenders for the phantom-delete bug: `safe_git_add` uses
+    # `git add` (no -A) which only stages additions/modifications. The
+    # source task directory was moved away by `shutil.move`, so its files
+    # need an explicit `git rm --cached` to stage the deletions in this
+    # same commit — otherwise they sit as uncommitted "phantom deletes"
+    # against HEAD until something later picks them up.
+    #
+    # `--ignore-unmatch` makes this a no-op when the task was never tracked
+    # (e.g. archiving a task that lived only in working tree).
+    source_rel = f"{DIR_WORKFLOW}/{DIR_TASKS}/{task_name}"
+    run_git(
+        ["rm", "-r", "--cached", "--ignore-unmatch", "--", source_rel],
+        cwd=repo_root,
+    )
+
     rc, _, _ = run_git(
-        ["diff", "--cached", "--quiet", "--", *paths], cwd=repo_root
+        ["diff", "--cached", "--quiet", "--", *paths, source_rel],
+        cwd=repo_root,
     )
     if rc == 0:
         print("[OK] No task changes to commit.", file=sys.stderr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindfoldhq/trellis",
-  "version": "0.5.12",
+  "version": "0.5.14",
   "description": "AI capabilities grow like ivy — Trellis provides the structure to guide them along a disciplined path",
   "type": "module",
   "main": "./dist/index.js",