scripts/structure-sentinel.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""

structure-sentinel.py -- minimal structure sentinel for a nomad-skeleton team workspace.



WHAT THIS IS

    A single, dependency-free script that runs four checks over this team's

    folder and prints a plain-language report. It is a GUARDRAIL, not a gate:

    it never blocks or edits anything, it only tells you what drifted.



FOUR CHECKS

    1. Existence   -- every file a persona names as "must-read" (the agent-home

                      six-piece set + the core governance files) really exists.

    2. Orphan      -- files that exist on disk under a memory/ folder but are

                      not mentioned in that folder's README.md index.

    3. Frontmatter -- .md files under the three mandatory zones (00-index/,

                      02-shared-knowledge/, 01-agents/*/memory/) carry the

                      required 4-field YAML header (type/owner/created/status)

                      with controlled values.

    4. Broken link -- relative markdown links (`[text](path)`) inside .md

                      files resolve to a real file on disk.



USAGE

    python3 structure-sentinel.py [team_root]              # macOS / Linux

    py -3   structure-sentinel.py [team_root]              # Windows

    python3 structure-sentinel.py [team_root] --json report.json



    macOS 12.3 removed /usr/bin/python, so `python` alone is not portable;

    `python3` is the portable name on macOS/Linux and `py -3` on Windows.



    team_root defaults to the current working directory. Exit code is 0 when

    everything is clean, 1 when any violation was found -- so it is safe to

    wire into a CI-style check without parsing stdout.



DESIGN NOTE

    This is a deliberately minimal port of a design pattern used in the

    author's own production team workspace (structure sentinel + metadata

    schema), generalized and stripped of any private names/paths for this

    starter kit. It reads the team's own governance doc

    (`00-index/metadata-conventions.md`) for the controlled value tables --

    see TYPE_VALUES / STATUS_VALUES below, which mirror that doc's word list.

    If you rename files or fold in new agents, this script needs no changes:

    everything it scans is discovered by walking the disk, not hard-coded

    per-agent (only the six-piece file list and the three mandatory-zone

    directory names are fixed, because those are the team-skeleton contract

    itself, not per-deployment content).

"""
from __future__ import annotations

import argparse
import json
import re
import sys
from datetime import datetime, timezone
from pathlib import Path

# Runtime version gate (a guardrail, not a gate): warn — don't exit — below Python 3.8.
# Reaching here means parsing already succeeded (the hard floor is the
# `from __future__ import annotations` above, needing 3.7+); this only nudges lower
# versions. ASCII-only so it prints safely on mis-encoded old environments.
if sys.version_info < (3, 8):
    sys.stderr.write(
        "[sentinel] Python %d.%d detected; 3.8+ recommended. Older versions may hit "
        "obscure syntax errors; please upgrade (Windows: use 'py -3').\n"
        % (sys.version_info.major, sys.version_info.minor)
    )

try:
    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
except Exception:
    pass

# ---------------------------------------------------------------------------
# Controlled value tables (mirrors 00-index/metadata-conventions.md)
# ---------------------------------------------------------------------------

TYPE_VALUES = {"index", "rule", "state", "log", "knowledge", "calibration", "archive"}
STATUS_VALUES = {"active", "draft", "to-fix", "expired", "archived"}
REQUIRED_FIELDS = ["type", "owner", "created", "status"]

MANDATORY_ZONE_DIRS = ["00-index", "02-shared-knowledge"]  # + 01-agents/*/memory (discovered)

# Directories that are source material / not-yet-instantiated skeletons --
# excluded from frontmatter + orphan checks (they intentionally keep
# placeholders / upstream content untouched; see the metadata-conventions doc
# §7 for why "workspace / 98-archive / 99-recycle-bin / templates" are exempt).
EXEMPT_DIR_NAMES = {
    "templates", "workspace", "98-archive", "99-recycle-bin", "97-inbox-misc",
    ".agent-modpack", ".git", "__pycache__", "skills",
}
EMPLOYEE_TEMPLATE_DIRNAME_MARKER = "fill-in, not loaded"  # substring match, badge-agnostic

AGENT_HOME_SIX_PIECE = [
    "AGENTS.md", "CLAUDE.md", "workspace",
    "memory/README.md", "memory/inbox.md", "memory/worklog.md",
]
# The Nuwa agent does not land through the standard six-piece assembly path
# (it lands via kernel + template-library + two purpose-built memory files --
# see the installer's build_plan()). Checked against a different, smaller
# required-file set below instead of being fully exempted from existence
# checking -- it still has to pass frontmatter / broken-link / orphan checks
# like everyone else, only the six-piece shape does not apply to it.
NUWA_AGENT_NAMES = {"nuwa", "女娲"}
NUWA_HOME_REQUIRED = [
    "AGENTS.md", "CLAUDE.md",
    "memory/judgment-calibration-log.md", "memory/forging-ledger.md",
]

FRONTMATTER_RE = re.compile(r"\A?---[ \t]*\r?\n(.*?)\r?\n---[ \t]*\r?\n", re.DOTALL)
FIELD_LINE_RE = re.compile(r"^([A-Za-z_]+):[ \t]*(.*)$")
ISO_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")

# Markdown inline link: [text](target) -- captures target, skips images'
# leading "!" naturally (the "!" just sits outside the match).
MD_LINK_RE = re.compile(r"\[[^\]]*\]\(([^)]+)\)")


def is_exempt_path(path: Path, root: Path) -> bool:
    rel_parts = path.relative_to(root).parts
    for part in rel_parts:
        if part in EXEMPT_DIR_NAMES:
            return True
        if EMPLOYEE_TEMPLATE_DIRNAME_MARKER in part:
            return True
    return False


def read_text(path: Path) -> str | None:
    try:
        text = path.read_text(encoding="utf-8")
    except Exception:
        return None
    if text.startswith(""):
        text = text[1:]
    return text


# ---------------------------------------------------------------------------
# Check 1: Existence
# ---------------------------------------------------------------------------

def check_existence(root: Path) -> list[dict]:
    violations: list[dict] = []
    if not (root / "team-config.json").exists():
        violations.append({
            "check": "existence", "severity": "high", "path": "team-config.json",
            "message": "team-config.json is missing -- the team's parameterized spine is gone.",
        })

    agents_root = root / "01-agents"
    if not agents_root.is_dir():
        violations.append({
            "check": "existence", "severity": "high", "path": "01-agents",
            "message": "01-agents/ directory is missing.",
        })
        return violations

    for agent_dir in sorted(p for p in agents_root.iterdir() if p.is_dir()):
        if EMPLOYEE_TEMPLATE_DIRNAME_MARKER in agent_dir.name:
            continue  # the fill-in template is checked structurally, not as a live agent
        required = NUWA_HOME_REQUIRED if agent_dir.name in NUWA_AGENT_NAMES else AGENT_HOME_SIX_PIECE
        for rel in required:
            if not (agent_dir / rel).exists():
                violations.append({
                    "check": "existence", "severity": "high",
                    "path": str((agent_dir / rel).relative_to(root)),
                    "message": f"agent home required file missing for '{agent_dir.name}'.",
                })
    return violations


# ---------------------------------------------------------------------------
# Check 2: Orphan (memory/ files not registered in memory/README.md)
# ---------------------------------------------------------------------------

def check_orphans(root: Path) -> list[dict]:
    violations: list[dict] = []
    agents_root = root / "01-agents"
    if not agents_root.is_dir():
        return violations
    for agent_dir in sorted(p for p in agents_root.iterdir() if p.is_dir()):
        if agent_dir.name in NUWA_AGENT_NAMES:
            continue  # Nuwa has no memory/README.md index by design -- see NUWA_HOME_REQUIRED
        mem_dir = agent_dir / "memory"
        if not mem_dir.is_dir():
            continue
        readme_path = mem_dir / "README.md"
        readme_text = read_text(readme_path)
        if readme_text is None:
            violations.append({
                "check": "orphan", "severity": "high",
                "path": str(readme_path.relative_to(root)),
                "message": "memory/README.md missing or unreadable -- orphan check skipped for this agent.",
            })
            continue
        for entry in sorted(mem_dir.iterdir()):
            if entry.is_dir():
                continue
            if entry.name == "README.md":
                continue
            if entry.name.startswith(".") or entry.name.endswith(".bak"):
                continue
            if entry.name not in readme_text:
                violations.append({
                    "check": "orphan", "severity": "medium",
                    "path": str(entry.relative_to(root)),
                    "message": f"'{entry.name}' exists on disk but is not mentioned in "
                               f"{readme_path.relative_to(root)} -- register it or delete it.",
                })
    return violations


# ---------------------------------------------------------------------------
# Check 3: Frontmatter schema
# ---------------------------------------------------------------------------

def parse_frontmatter(text: str) -> dict | None:
    m = FRONTMATTER_RE.match(text)
    if not m:
        return None
    fields: dict[str, str] = {}
    for line in m.group(1).splitlines():
        fm = FIELD_LINE_RE.match(line)
        if fm:
            fields[fm.group(1)] = fm.group(2).strip()
    return fields


def mandatory_zone_dirs(root: Path) -> list[Path]:
    dirs = [root / d for d in MANDATORY_ZONE_DIRS if (root / d).is_dir()]
    agents_root = root / "01-agents"
    if agents_root.is_dir():
        for agent_dir in sorted(p for p in agents_root.iterdir() if p.is_dir()):
            if EMPLOYEE_TEMPLATE_DIRNAME_MARKER in agent_dir.name:
                continue
            mem = agent_dir / "memory"
            if mem.is_dir():
                dirs.append(mem)
    return dirs


def check_frontmatter(root: Path) -> list[dict]:
    violations: list[dict] = []
    for zone in mandatory_zone_dirs(root):
        for md_path in sorted(zone.rglob("*.md")):
            if is_exempt_path(md_path, root):
                continue
            rel = md_path.relative_to(root)
            text = read_text(md_path)
            if text is None:
                violations.append({
                    "check": "frontmatter", "severity": "high", "path": str(rel),
                    "message": "file could not be read.",
                })
                continue
            fields = parse_frontmatter(text)
            if fields is None:
                violations.append({
                    "check": "frontmatter", "severity": "high", "path": str(rel),
                    "message": "missing YAML frontmatter (mandatory zone requires "
                               "type/owner/created/status).",
                })
                continue
            # Native-schema sniff (v0.4.0, mirrors the source team's sentinel
            # upgrade): all three team fields absent BUT a native field
            # (name/description/version/title) present = this file belongs to
            # another metadata system (SKILL.md, plugin manifests, ...) that
            # landed in a mandatory zone. Report it as "needs a human call"
            # instead of four misleading "required field missing" errors.
            if (not fields.get("type") and not fields.get("owner") and not fields.get("status")
                    and any(fields.get(k) for k in ("name", "description", "version", "title"))):
                violations.append({
                    "check": "frontmatter", "severity": "medium", "path": str(rel),
                    "message": "file carries another system's frontmatter schema "
                               "(name/description/version/title) inside a mandatory zone — "
                               "needs a human call: move it to where its system lives "
                               "(e.g. 90-methodology/skills/), or convert it to the team schema.",
                })
                continue
            for f in REQUIRED_FIELDS:
                if not fields.get(f):
                    violations.append({
                        "check": "frontmatter", "severity": "high", "path": str(rel),
                        "message": f"required field missing: {f}",
                    })
            if fields.get("type") and fields["type"] not in TYPE_VALUES:
                violations.append({
                    "check": "frontmatter", "severity": "high", "path": str(rel),
                    "message": f"type value '{fields['type']}' is not in the controlled "
                               f"7-value table: {sorted(TYPE_VALUES)}",
                })
            if fields.get("status") and fields["status"] not in STATUS_VALUES:
                violations.append({
                    "check": "frontmatter", "severity": "high", "path": str(rel),
                    "message": f"status value '{fields['status']}' is not in the controlled "
                               f"5-value table: {sorted(STATUS_VALUES)}",
                })
            created = fields.get("created")
            if created and not (ISO_DATE_RE.match(created) and _is_real_date(created)):
                violations.append({
                    "check": "frontmatter", "severity": "medium", "path": str(rel),
                    "message": f"created value '{created}' is not a valid YYYY-MM-DD date.",
                })
            # Archive-lingering hint (v0.4.0, mirrors the source team's sentinel
            # upgrade): a file marked archived/expired that still lives in a
            # mandatory (live) zone probably belongs in 98-archive/. Low
            # severity on purpose — sometimes an expired file is deliberately
            # kept in place as a tombstone; this is a nudge, not a violation.
            if fields.get("status") in ("archived", "expired"):
                violations.append({
                    "check": "frontmatter", "severity": "low", "path": str(rel),
                    "message": f"status is '{fields['status']}' but the file still lives in a "
                               "live mandatory zone — consider moving it to 98-archive/ "
                               "(or re-activate it if it is actually still in service).",
                })
    return violations


def _is_real_date(value: str) -> bool:
    try:
        datetime.strptime(value, "%Y-%m-%d")
        return True
    except ValueError:
        return False


# ---------------------------------------------------------------------------
# Check 4: Broken links (relative markdown links inside .md files)
# ---------------------------------------------------------------------------

def check_broken_links(root: Path) -> list[dict]:
    violations: list[dict] = []
    for md_path in sorted(root.rglob("*.md")):
        if is_exempt_path(md_path, root):
            continue
        text = read_text(md_path)
        if text is None:
            continue
        for m in MD_LINK_RE.finditer(text):
            target = m.group(1).strip()
            if not target:
                continue
            # Skip external / non-file targets.
            if re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://", target):  # http(s)://, mailto:, etc.
                continue
            if target.startswith("#"):
                continue
            if target.startswith("{{") and target.endswith("}}"):
                continue  # unresolved placeholder, not a real link yet
            # Strip a trailing anchor (#section) before resolving to a file.
            file_part = target.split("#", 1)[0].strip()
            if not file_part:
                continue
            if file_part.startswith("/"):
                candidate = root / file_part.lstrip("/")
            else:
                candidate = (md_path.parent / file_part).resolve()
            if not candidate.exists():
                violations.append({
                    "check": "broken-link", "severity": "medium",
                    "path": str(md_path.relative_to(root)),
                    "message": f"link target does not resolve to a file on disk: {target}",
                })
    return violations


# ---------------------------------------------------------------------------
# Report
# ---------------------------------------------------------------------------

def run_all(root: Path) -> dict:
    checks = {
        "existence": check_existence(root),
        "orphan": check_orphans(root),
        "frontmatter": check_frontmatter(root),
        "broken-link": check_broken_links(root),
    }
    all_violations = [v for vs in checks.values() for v in vs]
    return {
        "sentinelVersion": "0.1.0-min",
        "teamRoot": str(root),
        "ranAt": datetime.now(timezone.utc).isoformat(),
        "checkCounts": {name: len(vs) for name, vs in checks.items()},
        "totalViolations": len(all_violations),
        "overall": "CLEAN" if not all_violations else "DRIFT FOUND",
        "violations": all_violations,
    }


def render_report_text(report: dict) -> str:
    lines: list[str] = []
    lines.append(f"=== structure sentinel · {report['teamRoot']} ===")
    lines.append(f"ran at   : {report['ranAt']}")
    lines.append(f"overall  : {report['overall']}")
    lines.append(
        "checks   : existence={existence} orphan={orphan} frontmatter={frontmatter} "
        "broken-link={broken-link}".format(**report["checkCounts"])
    )
    lines.append("")
    if not report["violations"]:
        lines.append("Nothing to report -- structure looks clean.")
        return "\n".join(lines)
    by_check: dict[str, list[dict]] = {}
    for v in report["violations"]:
        by_check.setdefault(v["check"], []).append(v)
    for check_name, items in by_check.items():
        lines.append(f"-- {check_name} ({len(items)}) --")
        for v in items:
            lines.append(f"  [{v['severity']}] {v['path']}")
            lines.append(f"      {v['message']}")
        lines.append("")
    lines.append(
        f"TOTAL: {report['totalViolations']} issue(s). This is a guardrail, not a gate -- "
        f"nothing was changed. Fix what matters, re-run to confirm."
    )
    return "\n".join(lines)


def main() -> int:
    parser = argparse.ArgumentParser(description="Minimal structure sentinel for a nomad-skeleton team workspace.")
    parser.add_argument("team_root", nargs="?", default=".", help="Team root directory (default: cwd)")
    parser.add_argument("--json", dest="json_out", default=None, help="Also write a machine-readable JSON report to this path")
    args = parser.parse_args()

    root = Path(args.team_root).resolve()
    if not root.is_dir():
        print(f"ERROR: team_root does not exist or is not a directory: {root}")
        return 2

    report = run_all(root)
    print(render_report_text(report))

    if args.json_out:
        Path(args.json_out).write_text(
            json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8", newline="\n",
        )
        print(f"\nJSON report written: {args.json_out}")

    return 0 if report["overall"] == "CLEAN" else 1


if __name__ == "__main__":
    sys.exit(main())