code-jig 0.12.0__py3-none-any.whl

codejig/install.py

@@ -0,0 +1,381 @@
+import hashlib
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from codejig import gitgate, paths, tiers
+from codejig.atomicwrite import atomic_write
+from codejig.overlay import Overlay, load
+
+MARKER_BODY = "generated by code-jig sha256:"
+MARKER_NOTE = " : edit the core or the overlay, not this file"
+STYLES = {"md": ("<!-- ", " -->"), "hash": ("# ", "")}
+MARKER_PREFIX = STYLES["md"][0] + MARKER_BODY
+BOM = b"\xef\xbb\xbf"
+
+
+def stamp(body: str, style: str = "md") -> str:
+    head, tail = STYLES[style]
+    digest = hashlib.sha256(body.encode("utf-8")).hexdigest()
+    return f"{head}{MARKER_BODY}{digest}{MARKER_NOTE}{tail}\n{body}"
+
+
+def _off_path(directory: Path) -> bool:
+    want = os.path.normcase(os.path.abspath(directory))
+    return want not in [os.path.normcase(os.path.abspath(p)) for p in os.environ.get("PATH", "").split(os.pathsep) if p]
+
+
+def render_agents(core: Path, overlay_root: Path) -> str:
+    parts = [(core / "core" / "AGENTS.core.md").read_text(encoding="utf-8-sig")]
+    extra = overlay_root / "AGENTS.overlay.md"
+    if extra.is_file():
+        parts.append(extra.read_text(encoding="utf-8-sig"))
+    launcher = os.environ.get("CODE_JIG_LAUNCHER")
+    if launcher:
+        launcher = Path(launcher).with_name("code-jig" + Path(launcher).suffix)
+    if launcher and _off_path(launcher.parent):
+        parts.append(f"On this machine `code-jig` is not on PATH; run it as `{launcher}`.\n")
+    index = overlay_root / "knowledge" / "INDEX.md"
+    if index.is_file():
+        parts.append(f"## Knowledge\n\nThis machine keeps one fact per file in {index.parent}. "
+                     f"Read {index} when a task touches a tool, service or convention it may cover.\n")
+    return stamp("\n".join(p.rstrip("\n") + "\n" for p in parts))
+
+
+def is_generated(path: Path) -> bool:
+    data = path.read_bytes().removeprefix(BOM)
+    first, _, body = data.partition(b"\n")
+    for head, tail in STYLES.values():
+        prefix, suffix = (head + MARKER_BODY).encode(), (MARKER_NOTE + tail).encode()
+        if len(first) > len(prefix) + len(suffix) and first.startswith(prefix) and first.endswith(suffix):
+            digest = first[len(prefix): len(first) - len(suffix)].decode("ascii", "replace")
+            return hashlib.sha256(body).hexdigest() == digest
+    return False
+
+
+def _backup_name(path: Path) -> Path:
+    backup = path.with_name(f"{path.name}.bak-{time.strftime('%Y%m%d-%H%M%S')}")
+    n = 0
+    while backup.exists() or backup.is_symlink():
+        n += 1
+        backup = path.with_name(f"{path.name}.bak-{time.strftime('%Y%m%d-%H%M%S')}-{n}")
+    return backup
+
+
+def write_generated(path: Path, text: str) -> Path | None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    backup = None
+    if path.exists() and not is_generated(path):
+        backup = _backup_name(path)
+        shutil.copy2(path, backup)
+    atomic_write(path, text.encode("utf-8"))
+    return backup
+
+
+HOOK_STATUS = "code-jig collect"
+CLAUDE_CODE_WATERMARK_STATUS = "code-jig watermark"
+
+
+def interpreter() -> str:
+    return getattr(sys, "_base_executable", None) or sys.executable
+
+
+def hook_commands(lib: Path, home: Path, python: str) -> tuple[str, str]:
+    posix = f"PYTHONPATH={shlex.quote(str(lib))} {shlex.quote(python)} -P -s -m codejig --codex-home {shlex.quote(str(home))} collect"
+    windows = f'set "PYTHONPATH={lib}" && "{python}" -P -s -m codejig --codex-home "{home}" collect'
+    return posix, windows
+
+
+def watermark_commands(lib: Path, python: str, agent: str) -> tuple[str, str]:
+    posix = f"PYTHONPATH={shlex.quote(str(lib))} {shlex.quote(python)} -P -s -m codejig hooks --hook-type {agent}"
+    windows = f'set "PYTHONPATH={lib}" && "{python}" -P -s -m codejig hooks --hook-type {agent}'
+    return posix, windows
+
+
+def claude_code_watermark_hook(lib: Path, python: str) -> str:
+    return watermark_commands(lib, python, "claude-code")[0]
+
+
+def _without_status(groups: list, status: str) -> list:
+    return [g for g in groups if not (isinstance(g, dict) and any(
+        isinstance(h, dict) and h.get("statusMessage") == status for h in g.get("hooks") or []))]
+
+
+def valid_hook_groups(groups) -> bool:
+    return isinstance(groups, list) and all(
+        isinstance(g, dict) and isinstance(g.get("hooks", []), list)
+        and all(isinstance(h, dict) for h in g.get("hooks", [])) for g in groups)
+
+
+def _load_hooks(path: Path, event: str) -> tuple[dict, dict]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8-sig")) if path.is_file() else {"hooks": {}}
+    except (OSError, ValueError) as e:
+        raise ValueError(f"{path}: {e}") from e
+    hooks = data.setdefault("hooks", {}) if isinstance(data, dict) else None
+    if not isinstance(hooks, dict) or not valid_hook_groups(hooks.setdefault(event, [])):
+        raise ValueError(f'{path}: expected {{"hooks": {{"{event}": [...]}}}}')
+    return data, hooks
+
+
+def merged_hooks(path: Path, posix: str, windows: str, watermark: tuple[str, str] | None = None) -> str:
+    data, hooks = _load_hooks(path, "Stop")
+    hooks["Stop"] = _without_status(hooks["Stop"], HOOK_STATUS)
+    hooks["Stop"].append({"hooks": [{"type": "command", "command": posix, "commandWindows": windows,
+                                     "timeout": 60, "statusMessage": HOOK_STATUS}]})
+    if watermark is not None:
+        post = hooks.setdefault("PostToolUse", [])
+        if not isinstance(post, list):
+            raise ValueError(f'{path}: expected {{"hooks": {{"PostToolUse": [...]}}}}')
+        hooks["PostToolUse"] = _without_status(post, CLAUDE_CODE_WATERMARK_STATUS)
+        hooks["PostToolUse"].append({"hooks": [{"type": "command", "command": watermark[0],
+                                                "commandWindows": watermark[1], "timeout": 10,
+                                                "statusMessage": CLAUDE_CODE_WATERMARK_STATUS}]})
+    return json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+
+
+def write_merged(path: Path, text: str) -> Path | None:
+    if path.is_file() and path.read_bytes() == text.encode("utf-8"):
+        return None
+    path.parent.mkdir(parents=True, exist_ok=True)
+    backup = None
+    if path.exists():
+        backup = _backup_name(path)
+        shutil.copy2(path, backup)
+    atomic_write(path, text.encode("utf-8"))
+    return backup
+
+
+def merged_claude_code_hooks(path: Path, command: str) -> str:
+    data, hooks = _load_hooks(path, "PostToolUse")
+    hooks["PostToolUse"] = _without_status(hooks["PostToolUse"], CLAUDE_CODE_WATERMARK_STATUS)
+    hooks["PostToolUse"].append({
+        "matcher": "Write|Edit|MultiEdit|NotebookEdit",
+        "hooks": [{"type": "command", "command": command, "timeout": 10,
+                   "statusMessage": CLAUDE_CODE_WATERMARK_STATUS}],
+    })
+    return json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+
+
+RULES_PREFIX = "code-jig-"
+
+
+def rule_files(overlay_root: Path) -> dict[str, str]:
+    src = overlay_root / "rules"
+    if not src.is_dir():
+        return {}
+    return {f"{RULES_PREFIX}{p.stem}.rules": stamp(p.read_text(encoding="utf-8-sig"), "hash")
+            for p in sorted(src.glob("*.rules"))}
+
+
+def prune_rules(rules_dir: Path, keep: set[str]) -> list[str]:
+    lines = []
+    for f in sorted(rules_dir.glob(f"{RULES_PREFIX}*.rules")) if rules_dir.is_dir() else []:
+        if f.name in keep:
+            continue
+        if is_generated(f):
+            f.unlink()
+            lines.append(f"removed {f}: no longer in the overlay")
+        else:
+            lines.append(f"warning: left {f}: edited by hand, Codex still loads it")
+    return lines
+
+
+SKILL_SIDECAR = ".code-jig"
+NOT_INSTALLED = (SKILL_SIDECAR, ".skill-check", "evals.toml")
+
+
+def _skill_dirs(root: Path) -> dict[str, Path]:
+    return {p.parent.name: p.parent for p in sorted(root.glob("*/SKILL.md"))} if root.is_dir() else {}
+
+
+def skill_sources(core: Path, overlay_root: Path) -> dict[str, Path]:
+    core_skills, ov_skills = _skill_dirs(core / "skills"), _skill_dirs(overlay_root / "skills")
+    clash = sorted(set(core_skills) & set(ov_skills))
+    if clash:
+        raise ValueError(f"{overlay_root / 'skills'}: {', '.join(clash)} already in {core / 'skills'}; rename the overlay skill")
+    return {**core_skills, **ov_skills}
+
+
+def installed_file(src: Path, f: Path) -> bool:
+    rel = f.relative_to(src)
+    return "__pycache__" not in rel.parts and not (len(rel.parts) == 1 and rel.name in NOT_INSTALLED) and rel.parts[0] != "evals"
+
+
+def tree_digest(src: Path) -> str:
+    h = hashlib.sha256()
+    for f in sorted((p for p in src.rglob("*") if p.is_file() and installed_file(src, p)), key=lambda p: p.relative_to(src).parts):
+        h.update(f.relative_to(src).as_posix().encode() + b"\0" + f.read_bytes() + b"\0")
+    return h.hexdigest()
+
+
+def release_digest(root: Path) -> str:
+    h = hashlib.sha256()
+    files = []
+    for p in root.rglob("*"):
+        rel = p.relative_to(root)
+        if p.is_file() and "__pycache__" not in rel.parts and rel.as_posix() != "VERSION":
+            files.append((rel.as_posix(), p))
+    for rel, p in sorted(files):
+        h.update(rel.encode() + b"\0" + p.read_bytes() + b"\0")
+    return h.hexdigest()
+
+
+def _own_skill(d: Path) -> bool:
+    side = d / SKILL_SIDECAR
+    return side.is_file() and side.read_text(encoding="utf-8").strip() == tree_digest(d)
+
+
+def _ignore_installed(src: Path):
+    return lambda d, names: [n for n in names if n == "__pycache__" or (n in (*NOT_INSTALLED, "evals") and Path(d) == src)]
+
+
+def _install_skill(name: str, src: Path, dest: Path) -> list[str]:
+    lines = []
+    target = dest / name
+    if target.exists() and not _own_skill(target):
+        backups = dest.parent / "skills-backup"
+        backups.mkdir(parents=True, exist_ok=True)
+        backup = _backup_name(backups / name)
+        target.replace(backup)
+        lines.append(f"moved your previous {target} to {backup}")
+    elif target.exists():
+        shutil.rmtree(target)
+    shutil.copytree(src, target, ignore=_ignore_installed(src))
+    (target / SKILL_SIDECAR).write_text(tree_digest(target) + "\n", encoding="utf-8", newline="\n")
+    lines.append(f"wrote {target}")
+    return lines
+
+
+def _prune_skills(sources: dict[str, Path], dest: Path) -> list[str]:
+    lines = []
+    for d in sorted(p for p in dest.iterdir() if p.is_dir() and not p.is_symlink() and p.name not in sources and (p / SKILL_SIDECAR).is_file()):
+        if _own_skill(d):
+            shutil.rmtree(d)
+            lines.append(f"removed {d}: no longer in the core or overlay")
+        else:
+            lines.append(f"warning: left {d}: edited by hand, Codex still loads it")
+    return lines
+
+
+def install_skills(sources: dict[str, Path], dest: Path) -> list[str]:
+    lines = []
+    dest.mkdir(parents=True, exist_ok=True)
+    for name, src in sources.items():
+        lines += _install_skill(name, src, dest)
+    return lines + _prune_skills(sources, dest)
+
+
+def render_profile(tier: tiers.Tier, policy: str, compact: int | None = None) -> str:
+    return stamp(tiers.profile_body(tier, policy, compact), "hash")
+
+
+ROLE_TIERS = {"explorer": "bulk", "reviewer": "review", "judge": "deep"}
+
+
+def role_files(core: Path, ts: list[tiers.Tier]) -> dict[str, str]:
+    by = {t.name: t for t in ts}
+    out = {}
+    for role, tier in ROLE_TIERS.items():
+        template = core / "core" / "agents" / f"{role}.toml"
+        if tier in by and template.is_file():
+            t = by[tier]
+            head = f"model = {tiers.toml_str(t.model)}\nmodel_reasoning_effort = {tiers.toml_str(t.effort)}\n"
+            out[f"{role}.toml"] = stamp(head + template.read_text(encoding="utf-8-sig"), "hash")
+    return out
+
+
+def plan(core: Path, ov: Overlay, home: Path, claude_code_settings: Path | None = None) -> list[tuple[Path, str]]:
+    skill_sources(core, ov.root)
+    policy = tiers.extra_policy(ov.root)
+    outputs = [(home / "AGENTS.md", render_agents(core, ov.root))]
+    ts = tiers.load(core, ov.root)
+    outputs += [(home / f"{t.name}.config.toml", render_profile(t, policy, ov.auto_compact_token_limit)) for t in ts]
+    outputs += [(home / "agents" / name, text) for name, text in role_files(core, ts).items()]
+    outputs += [(home / "rules" / name, text) for name, text in rule_files(ov.root).items()]
+    lib = paths.state_dir() / "lib"
+    outputs += [(lib / "codejig" / p.name, stamp(p.read_text(encoding="utf-8"), "hash")) for p in sorted(((core / "codejig") if (core / "codejig").is_dir() else paths.CODE).glob("*.py"))]
+    outputs.append((home / "hooks.json", merged_hooks(home / "hooks.json", *hook_commands(lib, home, interpreter()),
+                                                      watermark=watermark_commands(lib, interpreter(), "codex"))))
+    if claude_code_settings and claude_code_settings.is_file():
+        outputs.append((claude_code_settings, merged_claude_code_hooks(claude_code_settings, claude_code_watermark_hook(lib, interpreter()))))
+    return outputs
+
+
+def _git_config(*args: str) -> str | None:
+    try:
+        r = subprocess.run(["git", "config", "--global", *args], capture_output=True, text=True, encoding="utf-8", check=False)
+    except OSError:
+        return None
+    return r.stdout.strip()
+
+
+def _same_path(a: str, b: Path) -> bool:
+    return bool(a) and os.path.normcase(os.path.abspath(os.path.expanduser(a))) == os.path.normcase(os.path.abspath(b))
+
+
+def git_gate(ov: Overlay) -> list[str]:
+    target = paths.state_dir() / "git-hooks"
+    current = _git_config("--get", "core.hooksPath")
+    if current is None:
+        return ["warning: git not found; the git gate was not installed"] if ov.git_gate else []
+    if not ov.git_gate:
+        if _same_path(current, target):
+            _git_config("--unset", "core.hooksPath")
+            return [f"removed the git gate: core.hooksPath no longer points at {target}"]
+        return []
+    for name, text in gitgate.shims(paths.state_dir() / "lib", interpreter(), ov.prose_gate, ov.push_cleanup is not False).items():
+        target.mkdir(parents=True, exist_ok=True)
+        atomic_write(target / name, text.encode("utf-8"), mode=0o755)
+    if current and not _same_path(current, target):
+        return [(f"warning: git core.hooksPath is {current}; the gate is in {target} but not active. "
+                 f"Activate it with: git config --global core.hooksPath \"{target}\" (each repo's own .git/hooks still run)")]
+    _git_config("core.hooksPath", str(target))
+    return [f"git gate active: core.hooksPath = {target}"]
+
+
+def run(core: Path, ov: Overlay, home: Path) -> list[str]:
+    lines = []
+    claude_settings = paths.claude_code_settings()
+    for target, text in plan(core, ov, home, claude_settings):
+        backup = (write_merged if target.name in ("hooks.json", "settings.json") else write_generated)(target, text)
+        lines.append(f"wrote {target}")
+        if backup:
+            lines.append(f"moved your previous file to {backup}")
+    lines += prune_rules(home / "rules", set(rule_files(ov.root)))
+    lines += install_skills(skill_sources(core, ov.root), paths.agents_skills())
+    lines += git_gate(ov)
+    override = home / "AGENTS.override.md"
+    if override.is_file() and override.stat().st_size > 0:
+        lines.append(f"warning: {override} exists and Codex loads it instead of {home / 'AGENTS.md'}")
+    return lines
+
+
+def missing_requirements() -> list[str]:
+    lines = []
+    if sys.version_info < (3, 11):
+        lines.append("Python 3.11 or newer")
+    if not shutil.which("git"):
+        lines.append("git (Fedora: sudo dnf install git; Debian/Ubuntu: sudo apt install git; macOS: xcode-select --install; Windows: winget install --id Git.Git -e)")
+    return lines
+
+
+def cli(args) -> int:
+    missing = missing_requirements()
+    for line in missing:
+        print(f"missing requirement: {line}", file=sys.stderr)
+    if missing:
+        return 2
+    try:
+        lines = run(paths.CORE, load(paths.overlay_dir(args.overlay)), paths.codex_home(args.codex_home))
+    except ValueError as e:
+        print(f"code-jig: {e}", file=sys.stderr)
+        return 2
+    for line in lines:
+        print(line)
+    return 0

codejig/managed.py

@@ -0,0 +1,64 @@
+import os
+import sys
+import tomllib
+from pathlib import Path
+
+from codejig.tiers import Tier
+
+Check = tuple[str, str, str]
+
+
+def requirements_path() -> Path:
+    if sys.platform == "win32":
+        return Path(os.environ.get("ProgramData", "C:\\ProgramData")) / "OpenAI" / "Codex" / "requirements.toml"
+    return Path("/etc/codex/requirements.toml")
+
+
+def _read_here(path: Path, name: str) -> tuple[dict, list[Check]]:
+    if not path.is_file():
+        return {}, [("ok", name, f"none at {path}; cloud-delivered requirements are not visible to doctor")]
+    try:
+        here = tomllib.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, ValueError) as e:
+        return {}, [("FAIL", name, f"{path}: {e}")]
+    return here, [("ok", name, f"read {path}; cloud-delivered requirements are not visible to doctor")]
+
+
+def _policy_checks(here: dict, ts: list[Tier]) -> list[Check]:
+    checks: list[Check] = []
+    reviewers = here.get("allowed_approvals_reviewers")
+    if isinstance(reviewers, list) and "auto_review" not in reviewers:
+        checks.append(("FAIL", "guardian allowed", f"allowed_approvals_reviewers = {reviewers}; the tier profiles need auto_review"))
+    auto_review = here.get("auto_review") if isinstance(here.get("auto_review"), dict) else {}
+    ignored = auto_review.get("ignore_rules") if isinstance(auto_review.get("ignore_rules"), list) else []
+    hit = sorted({t.model for t in ts} & {m for m in ignored if isinstance(m, str)})
+    if hit:
+        checks.append(("warn", "overlay rules", f"auto_review.ignore_rules lists {', '.join(hit)}; allow rules do nothing for those models"))
+    if here.get("allow_managed_hooks_only") is True:
+        checks.append(("warn", "hooks", "allow_managed_hooks_only = true; the pack's hooks will not run"))
+    if here.get("guardian_extra_policy"):
+        checks.append(("warn", "guardian policy", "managed guardian_extra_policy replaces the overlay guardian-policy.md"))
+    return checks
+
+
+def _bench_diff(here: dict, bench: Path) -> Check:
+    try:
+        sim = tomllib.loads(bench.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as e:
+        return ("warn", "bench diff", f"{bench}: {e}")
+    parts = []
+    if only_here := sorted(set(here) - set(sim)):
+        parts.append(f"locked here, not simulated: {', '.join(only_here)}")
+    if only_bench := sorted(set(sim) - set(here)):
+        parts.append(f"simulated, not locked here: {', '.join(only_bench)}")
+    if changed := sorted(k for k in set(here) & set(sim) if here[k] != sim[k]):
+        parts.append(f"different values: {', '.join(changed)}")
+    return ("warn", "bench diff", "; ".join(parts)) if parts else ("ok", "bench diff", "matches bench/requirements.toml")
+
+
+def check_requirements(path: Path, bench: Path, ts: list[Tier]) -> list[Check]:
+    name = "managed requirements"
+    here, checks = _read_here(path, name)
+    if checks[0][0] == "FAIL":
+        return checks
+    return checks + _policy_checks(here, ts) + [_bench_diff(here, bench)]