claude-dev-env 8.12.0 → 8.13.0

package/scripts/sync_to_cursor/canonical_docs.py

@@ -1,66 +0,0 @@
-"""Copy and verify canonical docs under .cursor/docs/."""
-
-import shutil
-from pathlib import Path
-
-from sync_to_cursor.config import ALL_CANONICAL_DOC_FILES
-from sync_to_cursor.hashing import sha256_bytes
-
-
-def sync_canonical_docs(
-    claude: Path,
-    cursor: Path,
-    dry_run: bool,
-    quiet: bool,
-) -> dict:
-    docs_out = cursor / "docs"
-    if not dry_run:
-        docs_out.mkdir(parents=True, exist_ok=True)
-    new_docs: dict = {}
-    for each_name in ALL_CANONICAL_DOC_FILES:
-        src = claude / "docs" / each_name
-        dst = docs_out / each_name
-        if not src.is_file():
-            if dst.is_file():
-                if not dry_run:
-                    dst.unlink()
-                if not quiet:
-                    print(f"WARN     docs/{each_name} (source removed — deleted stale copy at {dst})")
-            elif not quiet:
-                print(f"WARN     docs/{each_name} (missing source: {src})")
-            continue
-        key = f"docs/{each_name}"
-        src_hash = sha256_bytes(src.read_bytes())
-        if dry_run:
-            if dst.is_file():
-                out_hash = sha256_bytes(dst.read_bytes())
-            else:
-                out_hash = ""
-        else:
-            shutil.copy2(src, dst)
-            out_hash = sha256_bytes(dst.read_bytes())
-        new_docs[key] = {"sources_hash": src_hash, "output_hash": out_hash}
-    return new_docs
-
-
-def check_canonical_docs(claude: Path, cursor: Path, docs_entries: dict) -> bool:
-    for each_name in ALL_CANONICAL_DOC_FILES:
-        key = f"docs/{each_name}"
-        src = claude / "docs" / each_name
-        dst = cursor / "docs" / each_name
-        if not src.is_file():
-            if key in docs_entries:
-                return False
-            continue
-        if not dst.is_file():
-            return False
-        src_hash = sha256_bytes(src.read_bytes())
-        dst_hash = sha256_bytes(dst.read_bytes())
-        prev = docs_entries.get(key)
-        if not prev:
-            return False
-        if prev.get("sources_hash") != src_hash:
-            return False
-        if prev.get("output_hash") != dst_hash:
-            return False
-    return True

package/scripts/sync_to_cursor/config/__init__.py

@@ -1,8 +0,0 @@
-"""Shared configuration for the sync-to-cursor package."""
-
-GENERATOR_VERSION: str = "1.3.0"
-ALL_CANONICAL_DOC_FILES: tuple[str, ...] = ("CODE_RULES.md", "TEST_QUALITY.md")
-MAX_RULE_BODY_LINES: int = 50
-ALL_SKIPPED_RULE_FILE_NAMES: frozenset[str] = frozenset({"CLAUDE.md", "AGENTS.md"})
-MARKDOWN_SUFFIX: str = ".md"
-CLAUDE_RULES_DIRECTORY_NAME: str = "rules"

package/scripts/sync_to_cursor/engine.py

@@ -1,219 +0,0 @@
-"""Sync Claude rules to Cursor .mdc files and manifest."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-from sync_to_cursor.canonical_docs import check_canonical_docs, sync_canonical_docs
-from sync_to_cursor.config import GENERATOR_VERSION
-from sync_to_cursor.hashing import sha256_bytes
-from sync_to_cursor.paths import llm_layout_paths
-from sync_to_cursor.rules import RuleMapping, _full_mdc, apply_transform, build_mappings
-
-
-def _load_manifest(manifest_path: Path) -> dict:
-    if not manifest_path.is_file():
-        return {}
-    try:
-        return json.loads(manifest_path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError:
-        return {}
-
-
-def _sources_hash(paths: tuple[Path, ...]) -> str:
-    return sha256_bytes(b"\x00".join(p.read_bytes() for p in paths))
-
-
-def _run_check(
-    mappings: tuple[RuleMapping, ...],
-    out_dir: Path,
-    entries_meta: dict,
-    claude: Path,
-    cursor: Path,
-    docs_entries_meta: dict,
-) -> int:
-    for each_mapping in mappings:
-        key = f"rules/{each_mapping.output_name}"
-        out_path = out_dir / each_mapping.output_name
-        missing = [source for source in each_mapping.sources if not source.is_file()]
-        if missing:
-            if each_mapping.always_apply:
-                return 1
-            continue
-        src_hash = _sources_hash(each_mapping.sources)
-        prev = entries_meta.get(key, {})
-        if src_hash != prev.get("sources_hash"):
-            return 1
-        prev_out = prev.get("output_hash", "")
-        if out_path.is_file() and prev_out:
-            if sha256_bytes(out_path.read_bytes()) != prev_out:
-                return 1
-        elif not out_path.is_file():
-            return 1
-    if out_dir.is_dir():
-        for each_path in out_dir.glob("*.mdc"):
-            if each_path.name not in {x.output_name for x in mappings}:
-                return 1
-    if not check_canonical_docs(claude, cursor, docs_entries_meta):
-        return 1
-    return 0
-
-
-def _sync_rules(
-    mappings: tuple[RuleMapping, ...],
-    out_dir: Path,
-    entries_meta: dict,
-    *,
-    force: bool,
-    dry_run: bool,
-    quiet: bool,
-    cursor: Path,
-) -> tuple[dict, dict]:
-    summary: dict = {"skip": 0, "update": 0, "tampered": 0, "warn": 0, "orphan": 0}
-    new_entries: dict = {}
-    write_allowed = not dry_run
-
-    for each_mapping in mappings:
-        key = f"rules/{each_mapping.output_name}"
-        out_path = out_dir / each_mapping.output_name
-        missing = [source for source in each_mapping.sources if not source.is_file()]
-        if missing:
-            summary["warn"] += 1
-            if not quiet:
-                print(f"WARN     rules/{each_mapping.output_name} (missing source: {missing})")
-            continue
-
-        src_hash = _sources_hash(each_mapping.sources)
-        prev = entries_meta.get(key, {})
-        prev_src = prev.get("sources_hash", "")
-        prev_out = prev.get("output_hash", "")
-
-        if (
-            not force
-            and out_path.is_file()
-            and prev_src == src_hash
-            and prev_out
-            and sha256_bytes(out_path.read_bytes()) == prev_out
-        ):
-            summary["skip"] += 1
-            new_entries[key] = {"sources_hash": src_hash, "output_hash": prev_out}
-            continue
-
-        if (
-            not force
-            and out_path.is_file()
-            and prev_src == src_hash
-            and prev_out
-            and sha256_bytes(out_path.read_bytes()) != prev_out
-        ):
-            summary["tampered"] += 1
-            if not quiet:
-                print(f"TAMPERED rules/{each_mapping.output_name} (manual edit; regenerating)")
-
-        summary["update"] += 1
-        if not quiet:
-            print(f"UPDATE   rules/{each_mapping.output_name}")
-
-        body = apply_transform(
-            each_mapping.transform,
-            each_mapping.sources,
-            strip_leading_frontmatter=each_mapping.strip_leading_frontmatter,
-        )
-        full = _full_mdc(each_mapping, body)
-        out_hash = sha256_bytes(full.encode("utf-8"))
-        new_entries[key] = {"sources_hash": src_hash, "output_hash": out_hash}
-
-        if write_allowed:
-            out_path.write_text(full, encoding="utf-8", newline="\n")
-
-    expected = {each_mapping.output_name for each_mapping in mappings}
-    for each_path in out_dir.glob("*.mdc"):
-        if each_path.name not in expected:
-            summary["orphan"] += 1
-            if not quiet:
-                print(f"WARN     {each_path.relative_to(cursor)} (orphan — not generated by this tool)")
-
-    return summary, new_entries
-
-
-def _layout_from_args(args: argparse.Namespace) -> tuple[Path, Path, Path, Path]:
-    """Resolve Claude and Cursor roots from flags or the default layout.
-
-    Args:
-        args: Parsed CLI arguments.
-
-    Returns:
-        Claude root, Cursor root, rules output directory, and manifest path.
-
-    Raises:
-        SystemExit: When only one of `--claude-root` / `--cursor-root` is set.
-    """
-    claude_root = args.claude_root
-    cursor_root = args.cursor_root
-    if (claude_root is None) != (cursor_root is None):
-        raise SystemExit("both --claude-root and --cursor-root are required")
-    if claude_root is None:
-        return llm_layout_paths()
-    claude = Path(claude_root).expanduser().resolve()
-    cursor = Path(cursor_root).expanduser().resolve()
-    return claude, cursor, cursor / "rules", cursor / ".sync-manifest.json"
-
-
-def run(argv: list[str] | None = None) -> int:
-    argument_parser = argparse.ArgumentParser(description="Sync Claude rules to Cursor .mdc files")
-    argument_parser.add_argument("--force", action="store_true", help="Regenerate all outputs")
-    argument_parser.add_argument("--dry-run", action="store_true", help="Print actions only")
-    argument_parser.add_argument("--check", action="store_true", help="Exit 1 if anything stale")
-    argument_parser.add_argument("--quiet", action="store_true", help="Minimal output when up to date")
-    argument_parser.add_argument("--claude-root", help="Claude layout root holding rules/ and docs/")
-    argument_parser.add_argument("--cursor-root", help="Cursor layout root receiving rules/ and docs/")
-    args = argument_parser.parse_args(argv)
-
-    claude, cursor, out_dir, manifest_path = _layout_from_args(args)
-    mappings = build_mappings(claude)
-    old_manifest = _load_manifest(manifest_path)
-    entries_meta: dict = old_manifest.get("entries", {})
-    docs_entries_meta: dict = old_manifest.get("docs_entries", {})
-
-    if args.check:
-        return _run_check(mappings, out_dir, entries_meta, claude, cursor, docs_entries_meta)
-
-    if not args.dry_run:
-        out_dir.mkdir(parents=True, exist_ok=True)
-    new_docs_entries = sync_canonical_docs(claude, cursor, args.dry_run, args.quiet)
-
-    summary, new_entries = _sync_rules(
-        mappings,
-        out_dir,
-        entries_meta,
-        force=args.force,
-        dry_run=args.dry_run,
-        quiet=args.quiet,
-        cursor=cursor,
-    )
-
-    manifest_out = {
-        "generated_at": datetime.now(timezone.utc).isoformat(),
-        "generator_version": GENERATOR_VERSION,
-        "entries": new_entries,
-        "docs_entries": new_docs_entries,
-    }
-    if not args.dry_run:
-        manifest_path.write_text(json.dumps(manifest_out, indent=2) + "\n", encoding="utf-8")
-
-    if (
-        not args.quiet
-        and summary["skip"]
-        and not any((summary["update"], summary["tampered"], summary["warn"], summary["orphan"]))
-    ):
-        print(f"SKIP     all {summary['skip']} rule(s) unchanged")
-
-    return 0
-
-
-def main() -> int:
-    return run(sys.argv[1:])

package/scripts/sync_to_cursor/hashing.py

@@ -1,7 +0,0 @@
-"""Content hashing for manifest entries."""
-
-import hashlib
-
-
-def sha256_bytes(content_bytes: bytes) -> str:
-    return hashlib.sha256(content_bytes).hexdigest()

package/scripts/sync_to_cursor/paths.py

@@ -1,18 +0,0 @@
-"""Resolve Claude / Cursor layout paths (LLM_SETTINGS_ROOT or home)."""
-
-import os
-from pathlib import Path
-
-
-def llm_layout_paths() -> tuple[Path, Path, Path, Path]:
-    """Return (claude_dir, cursor_dir, rules_out_dir, manifest_path)."""
-    raw = os.environ.get("LLM_SETTINGS_ROOT", "").strip()
-    if raw:
-        base = Path(raw).expanduser().resolve()
-        claude = base / ".claude"
-        cursor = base / ".cursor"
-    else:
-        home = Path.home()
-        claude = home / ".claude"
-        cursor = home / ".cursor"
-    return claude, cursor, cursor / "rules", cursor / ".sync-manifest.json"