@softspark/ai-toolkit 4.5.1 → 4.7.0

package/scripts/generate_cursor_mdc.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 """Generate ``.cursor/rules/*.mdc`` files for Cursor IDE.
 
-Cursor reads rules from ``.cursor/rules/`` (since Cursor 0.45). Both ``.mdc``
-and plain ``.md`` extensions are accepted; we emit ``.mdc`` because only it
-carries the full YAML frontmatter used to control activation:
+Cursor reads rules from ``.cursor/rules/`` (since Cursor 0.45). Only ``.mdc``
+files are read — plain ``.md`` files in ``.cursor/rules/`` are ignored by the
+rules system (per cursor.com/docs/context/rules). ``.mdc`` carries the YAML
+frontmatter used to control activation:
 
   - ``alwaysApply: true``   — always in context
   - ``globs: ["**/*.ts"]``  — auto-attached for matching files

package/scripts/generate_opencode_commands.py

@@ -5,8 +5,10 @@ User-invocable skills become opencode slash commands. Knowledge skills
 (``user-invocable: false``) are excluded — they load automatically via
 AGENTS.md context instead of `/` invocation.
 
-Generated commands use the required ``template`` frontmatter field.
-Files are prefixed ``ai-toolkit-`` for clean uninstall.
+Generated commands put the prompt in the markdown BODY. opencode reads the
+body as the prompt template; the ``template`` frontmatter field is JSON-config
+only and is ignored in .md command files. Files are prefixed ``ai-toolkit-``
+for clean uninstall.
 
 opencode commands: https://opencode.ai/docs/commands/
 """
@@ -47,12 +49,11 @@ def _skill_body(skill_file: Path) -> str:
 
 def _render_opencode_command(skill_file: Path) -> str:
     """Render a single opencode command .md file from a user-invocable skill."""
-    name = frontmatter_field(skill_file, "name")
     description = frontmatter_field(skill_file, "description")
     agent_field = frontmatter_field(skill_file, "agent")
-    # opencode does NOT read "body" — the prompt is entirely in the `template`
-    # frontmatter field. We embed the SKILL.md body as the template using a
-    # YAML block scalar (``|``) which preserves newlines without escaping.
+    # opencode reads the command prompt from the markdown BODY of the file.
+    # The frontmatter only defines command properties; the `template` field is
+    # JSON-config-only and is ignored in .md command files.
     body = _skill_body(skill_file).rstrip()
 
     lines: list[str] = ["---"]
@@ -62,11 +63,10 @@ def _render_opencode_command(skill_file: Path) -> str:
     if agent_field:
         # opencode accepts an `agent` frontmatter field pointing at a subagent
         lines.append(f"agent: {_map_agent_name(agent_field)}")
-    lines.append("template: |")
-    for tpl_line in body.splitlines() or [""]:
-        lines.append(f"  {tpl_line}" if tpl_line else "  ")
     lines.append("---")
     lines.append("")
+    lines.append(body)
+    lines.append("")
     return "\n".join(lines)
 
 

package/scripts/generate_windsurf_hooks.py

@@ -1,6 +1,12 @@
 #!/usr/bin/env python3
 """Generate .windsurf/hooks.json for Windsurf Cascade.
 
+DEPRECATED SURFACE: the Cascade agent is available only through 2026-07-01
+(Devin Local is the default agent since the 2026-06-02 Devin Desktop rebrand),
+and this hooks.json schema is Cascade-scoped. Migrate to the Devin CLI
+lifecycle-hooks surface (docs.devin.ai/cli/extensibility/hooks/*) before that
+date; tracked in the ecosystem registry status_note for windsurf.
+
 Writes `<target>/.windsurf/hooks.json`. Existing user hook entries are
 preserved; only entries tagged `_source: ai-toolkit` are replaced on
 regeneration. Windsurf merges system / user / workspace hooks at runtime, so

package/scripts/generate_windsurf_rules.py

@@ -1,17 +1,25 @@
 #!/usr/bin/env python3
-"""Generate ``.windsurf/rules/*.md`` (and workflows) for Windsurf IDE.
+"""Generate ``.devin/rules/*.md`` and ``.windsurf/rules/*.md`` (and workflows)
+for Devin Desktop (formerly Windsurf).
 
-Windsurf reads directory-based rules from ``.windsurf/rules/*.md`` (since
-mid-2025). Each rule file supports YAML frontmatter with these fields
-(from docs.windsurf.com/windsurf/cascade/memories):
+Windsurf rebranded to Devin Desktop on 2026-06-02. ``.devin/`` is now the
+primary read+write workspace tree; ``.windsurf/`` is a legacy read-only
+fallback that current builds still honor (docs.devin.ai/desktop/devin-desktop-faq:
+"The application already supports .devin/ as the primary workspace directory
+and falls back to .windsurf/ for backward compatibility"). We dual-emit the
+same content to both trees so old Windsurf builds keep working during the
+transition.
+
+Each rule file supports YAML frontmatter with these fields
+(from docs.devin.ai/desktop — memories docs):
 
 * ``trigger`` — activation mode: ``always_on`` | ``glob`` | ``model_decision``
-  | ``manual``. When omitted, Windsurf defaults to manual-only.
+  | ``manual``. When omitted, the IDE defaults to manual-only.
 * ``globs`` — comma-separated glob patterns (only when ``trigger: glob``).
 * ``description`` — shown to the model when ``trigger: model_decision``.
 
-Windsurf also reads workflow markdown files from ``.windsurf/workflows/*.md``
-which users invoke via ``/<name>`` slash commands (Cascade). This generator
+Workflow markdown files (invoked via ``/<name>`` slash commands) are emitted
+to ``.devin/workflows/*.md`` and ``.windsurf/workflows/*.md``. This generator
 emits the same workflow catalogue used by Antigravity and Cline.
 
 The legacy ``.windsurfrules`` single-file format is still produced by
@@ -142,20 +150,26 @@ def _build_rules(language_modules: list[str] | None,
 
 
 # ---------------------------------------------------------------------------
-# Workflows — .windsurf/workflows/<name>.md invocable via /<name>
+# Workflows — <tree>/workflows/<name>.md invocable via /<name>
 # ---------------------------------------------------------------------------
 
+# .devin/ is primary since the 2026-06-02 Devin Desktop rebrand; .windsurf/
+# is the legacy fallback still read by pre-rebrand builds.
+CONFIG_TREES: tuple[str, ...] = (".devin", ".windsurf")
+
+
 def _write_workflows(target_dir: Path, *, cleanup: bool = True) -> None:
-    """Write ``.windsurf/workflows/*.md`` files for Cascade slash commands."""
-    workflows_dir = target_dir / ".windsurf" / "workflows"
-    workflows_dir.mkdir(parents=True, exist_ok=True)
+    """Write ``workflows/*.md`` slash-command files to both config trees."""
+    for tree in CONFIG_TREES:
+        workflows_dir = target_dir / tree / "workflows"
+        workflows_dir.mkdir(parents=True, exist_ok=True)
 
-    if cleanup:
-        cleanup_stale(workflows_dir, set(STANDARD_WORKFLOWS.keys()))
+        if cleanup:
+            cleanup_stale(workflows_dir, set(STANDARD_WORKFLOWS.keys()))
 
-    for filename, content_fn in STANDARD_WORKFLOWS.items():
-        (workflows_dir / filename).write_text(content_fn(), encoding="utf-8")
-        print(f"  Generated: .windsurf/workflows/{filename}")
+        for filename, content_fn in STANDARD_WORKFLOWS.items():
+            (workflows_dir / filename).write_text(content_fn(), encoding="utf-8")
+            print(f"  Generated: {tree}/workflows/{filename}")
 
 
 # ---------------------------------------------------------------------------
@@ -170,15 +184,16 @@ def generate(target_dir: Path, *,
              managed_scopes: tuple[str, ...] = (
                  STANDARD_SCOPE, LANG_SCOPE, CUSTOM_SCOPE,
              )) -> None:
-    """Write ``.windsurf/rules/*.md`` and ``.windsurf/workflows/*.md``."""
+    """Write ``rules/*.md`` and ``workflows/*.md`` to both config trees."""
     rules = _build_rules(language_modules, rules_dir)
-    write_rules(
-        target_dir,
-        rules,
-        ".windsurf/rules",
-        cleanup=cleanup,
-        managed_scopes=managed_scopes,
-    )
+    for tree in CONFIG_TREES:
+        write_rules(
+            target_dir,
+            rules,
+            f"{tree}/rules",
+            cleanup=cleanup,
+            managed_scopes=managed_scopes,
+        )
 
     if emit_workflows:
         _write_workflows(target_dir, cleanup=cleanup)

package/scripts/generate_windsurf_skills.py

@@ -1,5 +1,11 @@
 #!/usr/bin/env python3
-"""Generate a Windsurf skill pointer under ``.windsurf/skills/``."""
+"""Generate a Devin Desktop (formerly Windsurf) skill pointer.
+
+Dual-emits under ``.devin/skills/`` (primary since the 2026-06-02 rebrand)
+and ``.windsurf/skills/`` (legacy fallback). Pass an explicit ``skill_root``
+to emit a single location instead (used for the ``~/.codeium/windsurf/``
+global install path).
+"""
 from __future__ import annotations
 
 import sys
@@ -8,13 +14,17 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from skill_pointer import POINTER_SKILL_NAME, write_pointer_skill
 
+DEFAULT_SKILL_ROOTS: tuple[str, ...] = (".devin/skills", ".windsurf/skills")
+
 
 def generate(target_dir: Path, *, emit_skill_pointer: bool = True,
-             skill_root: str = ".windsurf/skills") -> None:
+             skill_root: str | None = None) -> None:
     if not emit_skill_pointer:
         return
-    write_pointer_skill(target_dir, skill_root, "Windsurf")
-    print(f"  Generated: {skill_root}/{POINTER_SKILL_NAME}/SKILL.md")
+    roots = (skill_root,) if skill_root else DEFAULT_SKILL_ROOTS
+    for root in roots:
+        write_pointer_skill(target_dir, root, "Windsurf")
+        print(f"  Generated: {root}/{POINTER_SKILL_NAME}/SKILL.md")
 
 
 def main() -> None:

package/scripts/install.py

@@ -14,7 +14,7 @@ Claude Code (~/.claude/):
 Other tools (global config locations):
   - Windsurf: ~/.codeium/windsurf/memories/global_rules.md + ~/.codeium/windsurf/skills/
   - Gemini:   ~/.gemini/GEMINI.md
-  - Cline:    ~/.cline/rules/ + ~/.cline/skills/
+  - Cline:    ~/Documents/Cline/Rules/ + ~/.cline/skills/
   - Roo Code: ~/.roo/rules/
   - Aider:    ~/.aider.conf.yml (created only if absent)
   - Augment:  ~/.augment/rules/ai-toolkit.md

package/scripts/install_steps/ai_tools.py

@@ -79,7 +79,7 @@ def install_ai_tools(target_dir: Path, rules_dir: Path,
 
     if "cline" in eds:
         if dry_run:
-            print("  Would generate: ~/.cline/rules/ai-toolkit-*.md")
+            print("  Would generate: ~/Documents/Cline/Rules/ai-toolkit-*.md")
             print("  Would generate: ~/.cline/skills/ai-toolkit-skill-catalogue/SKILL.md")
         else:
             _install_cline_global(target_dir, rules_dir)
@@ -125,8 +125,8 @@ def _install_codex_global(target_dir: Path, rules_dir: Path) -> None:
     """Install Codex at the global level (~/ layer).
 
     Creates:
-      - ~/AGENTS.md (marker injection with rules)
-      - ~/.agents/rules/*.md (directory-based rules)
+      - ~/AGENTS.md (marker injection; universal coding rules inlined here —
+        Codex reads instructions only from AGENTS.md, not .agents/rules/)
       - ~/.agents/skills/* (skill symlinks)
       - ~/.codex/hooks.json (lifecycle hooks)
     """
@@ -136,13 +136,6 @@ def _install_codex_global(target_dir: Path, rules_dir: Path) -> None:
         rules_dir,
     )
 
-    from generate_codex_rules import generate as gen_codex_rules
-    gen_codex_rules(
-        target_dir,
-        rules_dir=rules_dir,
-        managed_scopes=("standard", "custom"),
-    )
-
     from generate_codex_hooks import generate as gen_codex_hooks
     gen_codex_hooks(target_dir)
     print("  Created: ~/.codex/hooks.json")
@@ -150,12 +143,33 @@ def _install_codex_global(target_dir: Path, rules_dir: Path) -> None:
     _install_codex_skills(target_dir)
 
 
+def _claude_skills_discoverable(project_dir: Path | None = None) -> bool:
+    """True when real ai-toolkit skills already exist at a ``.claude/skills``
+    directory the editor scans natively (project-local or global
+    ``~/.claude/skills``), making an editor skill-catalogue pointer redundant.
+
+    Cursor, Cline and Augment discover ``SKILL.md`` from ``.claude/skills`` and
+    ``~/.claude/skills`` by default, so when those are populated the pointer adds
+    nothing. (Windsurf/Devin gates that scan behind a setting and is excluded
+    from the conditional by its callers.) Returns ``False`` for editor-only
+    installs (no Claude skills present), where the pointer is the only
+    skill-discovery surface.
+    """
+    candidates = [Path.home() / ".claude" / "skills"]
+    if project_dir is not None:
+        candidates.insert(0, project_dir / ".claude" / "skills")
+    return any(d.is_dir() and any(d.glob("*/SKILL.md")) for d in candidates)
+
+
 def _install_windsurf_global(target_dir: Path, rules_dir: Path) -> None:
     """Install Windsurf global rules plus an Agent Skills catalogue pointer."""
     windsurf_file = target_dir / ".codeium" / "windsurf" / "memories" / "global_rules.md"
     inject_with_rules("generate-windsurf.sh", windsurf_file, rules_dir)
 
     from generate_windsurf_skills import generate as gen_windsurf_skills
+    # Windsurf is excluded from the .claude/skills conditional: its native scan
+    # of .claude/skills is gated behind a Devin "Claude Code config reading"
+    # setting, so we always emit the pointer as a reliable fallback.
     gen_windsurf_skills(
         target_dir,
         skill_root=".codeium/windsurf/skills",
@@ -166,7 +180,9 @@ def _install_cline_global(target_dir: Path, rules_dir: Path) -> None:
     """Install Cline global rules in the documented ~/.cline directory."""
     from generate_cline_rules import generate as gen_cline_rules
 
-    rules_root = target_dir / ".cline" / "rules"
+    # Cline reads GLOBAL rules from ~/Documents/Cline/Rules/ (docs.cline.bot);
+    # ~/.cline/rules/ is not a Cline-read path.
+    rules_root = target_dir / "Documents" / "Cline" / "Rules"
     gen_cline_rules(
         target_dir,
         rules_dir=rules_dir,
@@ -174,10 +190,10 @@ def _install_cline_global(target_dir: Path, rules_dir: Path) -> None:
         emit_workflows=False,
         managed_scopes=("standard", "custom"),
     )
-    print("  Created: ~/.cline/rules/ai-toolkit-*.md")
+    print("  Created: ~/Documents/Cline/Rules/ai-toolkit-*.md")
 
     from generate_cline_skills import generate as gen_cline_skills
-    gen_cline_skills(target_dir)
+    gen_cline_skills(target_dir, emit_skill_pointer=not _claude_skills_discoverable(target_dir))
 
 
 def _install_roo_global(target_dir: Path, rules_dir: Path) -> None:
@@ -365,12 +381,19 @@ _EDITOR_MARKERS: dict[str, str] = {
     ".cursor/rules": "cursor",
     ".windsurfrules": "windsurf",
     ".windsurf/rules": "windsurf",
+    # .devin/ is the primary Devin Desktop tree since the 2026-06-02 rebrand;
+    # .windsurf/ markers stay to detect legacy installs.
+    ".devin/rules": "windsurf",
     ".clinerules": "cline",
     ".roomodes": "roo",
     ".roo/rules": "roo",
     ".aider.conf.yml": "aider",
     "CONVENTIONS.md": "aider",
     ".augment/rules": "augment",
+    # Antigravity 2.0 default is plural .agents/; .agents/workflows is the
+    # unambiguous marker (Codex also writes .agents/rules but no workflows).
+    # Singular .agent/rules is kept to detect legacy installs.
+    ".agents/workflows": "antigravity",
     ".agent/rules": "antigravity",
     ".agents/skills": "codex",
     ".codex": "codex",
@@ -391,11 +414,25 @@ def _detect_editors(cwd: Path) -> list[str]:
     found: set[str] = set()
     for marker, editor in _EDITOR_MARKERS.items():
         p = cwd / marker
-        if p.exists():
-            found.add(editor)
+        if not p.exists():
+            continue
+        if marker == ".agents/skills" and _is_pointer_only_skills_dir(p):
+            # The Antigravity CLI pointer skill also lives in .agents/skills/;
+            # only real (materialized) skills indicate a Codex install.
+            continue
+        found.add(editor)
     return sorted(found)
 
 
+def _is_pointer_only_skills_dir(skills_dir: Path) -> bool:
+    """True when a skills dir holds only the ai-toolkit pointer skill."""
+    try:
+        entries = [e.name for e in skills_dir.iterdir() if not e.name.startswith(".")]
+    except OSError:
+        return False
+    return entries == ["ai-toolkit-skill-catalogue"]
+
+
 def _resolve_editors(editors_arg: str, cwd: Path) -> list[str]:
     """Resolve --editors argument to a list of editor names.
 
@@ -689,12 +726,12 @@ def _install_local_dry_run(reset: bool, editors: list[str] | None = None,
     _EDITOR_DRY_RUN = {
         "copilot":      "  Would inject: .github/copilot-instructions.md",
         "cursor":       "  Would generate: .cursorrules + .cursor/rules/*.mdc",
-        "windsurf":     "  Would generate: .windsurfrules + .windsurf/rules/*.md",
+        "windsurf":     "  Would generate: .windsurfrules + .devin/rules/*.md + .windsurf/rules/*.md",
         "cline":        "  Would generate: .clinerules/*.md",
         "roo":          "  Would generate: .roomodes + .roo/rules/*.md",
         "aider":        "  Would generate: .aider.conf.yml + CONVENTIONS.md",
         "augment":      "  Would generate: .augment/rules/ai-toolkit-*.md",
-        "antigravity":  "  Would generate: .agent/rules/ + .agent/workflows/",
+        "antigravity":  "  Would generate: .agents/rules/ + .agents/workflows/",
         "gemini":       "  Would generate: GEMINI.md",
         "opencode":     "  Would generate: AGENTS.md + .opencode/{agents,commands,plugins}/ + opencode.json",
     }
@@ -711,7 +748,7 @@ def _install_local_dry_run(reset: bool, editors: list[str] | None = None,
         if "cursor" in eds:
             print("  Would generate: .cursor/hooks.json + .cursor/agents/ + .cursor/skills/ (profile=full)")
         if "windsurf" in eds:
-            print("  Would generate: .windsurf/hooks.json + .windsurf/skills/ (profile=full)")
+            print("  Would generate: .windsurf/hooks.json + .devin/skills/ + .windsurf/skills/ (profile=full)")
         if "cline" in eds:
             print("  Would generate: .cline/skills/ (profile=full)")
         if "augment" in eds:
@@ -899,6 +936,12 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
     add_copilot_dir = _profile in {"standard", "strict", "full"}
     add_gemini_hooks = _profile in {"standard", "strict", "full"}
     add_native_surfaces = _profile == "full"
+    # Skip the editor skill-catalogue pointer when real skills are already
+    # discoverable at .claude/skills (project or ~/.claude/skills global):
+    # Cursor/Cline/Augment read those natively and by default. Emit it only as
+    # the editor-only fallback when no Claude skills are present. Windsurf is
+    # excluded (its .claude scan is gated) and keeps its pointer unconditionally.
+    emit_pointer = not _claude_skills_discoverable(cwd)
 
     if "copilot" in eds:
         inject_with_rules(
@@ -925,7 +968,7 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
         if add_native_surfaces:
             _try_generator("generate_cursor_hooks", cwd)
             _try_generator("generate_cursor_agents", cwd)
-            _try_generator("generate_cursor_skills", cwd)
+            _try_generator("generate_cursor_skills", cwd, emit_skill_pointer=emit_pointer)
 
     if "windsurf" in eds:
         inject_with_rules(
@@ -938,6 +981,7 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
                            rules_dir=rules_dir)
         if add_native_surfaces:
             _try_generator("generate_windsurf_hooks", cwd)
+            # Windsurf pointer stays unconditional (its .claude scan is gated).
             _try_generator("generate_windsurf_skills", cwd)
 
     if "cline" in eds:
@@ -954,7 +998,7 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
             managed_scopes=("standard", "lang", "custom"),
         )
         if add_native_surfaces:
-            _try_generator("generate_cline_skills", cwd)
+            _try_generator("generate_cline_skills", cwd, emit_skill_pointer=emit_pointer)
 
     if "roo" in eds:
         roo_output = run_script("generate-roo-modes.sh", capture=True)
@@ -980,7 +1024,7 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
             # Augment hooks live under $HOME/.augment/settings.json. The
             # generator takes HOME (not cwd) per bucket-1 contract.
             _try_generator("generate_augment_hooks", Path.home())
-            _try_generator("generate_augment_skills", cwd)
+            _try_generator("generate_augment_skills", cwd, emit_skill_pointer=emit_pointer)
 
     if "antigravity" in eds:
         from generate_antigravity import generate as gen_antigravity
@@ -988,20 +1032,14 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
                         rules_dir=rules_dir)
 
     if "codex" in eds:
-        # AGENTS.md — marker injection (like CLAUDE.md)
+        # AGENTS.md — marker injection; universal coding rules are inlined into
+        # AGENTS.md (Codex reads instructions only from AGENTS.md, not a
+        # .agents/rules/ directory). Language rules reach Codex via .agents/skills/.
         inject_with_rules(
             "generate_codex.py",
             cwd / "AGENTS.md",
             rules_dir,
         )
-        # .agents/rules/ — directory-based rules
-        from generate_codex_rules import generate as gen_codex_rules
-        gen_codex_rules(
-            cwd,
-            language_modules=language_modules,
-            rules_dir=rules_dir,
-            managed_scopes=("standard", "lang", "custom"),
-        )
         # .codex/hooks.json — Codex lifecycle hooks
         from generate_codex_hooks import generate as gen_codex_hooks
         gen_codex_hooks(cwd)

package/scripts/plugin.py

@@ -33,7 +33,6 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 from _common import app_dir, inject_section, inject_rule, remove_rule_section
 from codex_skill_adapter import cleanup_codex_skills, sync_codex_skill
 from generate_codex_hooks import generate as generate_codex_hooks
-from generate_codex_rules import generate as generate_codex_rules
 from install_steps.ai_tools import inject_with_rules
 from paths import HOOKS_DIR as _HOOKS_DIR
 from paths import RULES_DIR, TOOLKIT_DATA_DIR
@@ -536,8 +535,9 @@ def _install_codex_extra_skills(pack: dict, pack_dir: Path) -> None:
 
 def _install_codex_base() -> None:
     _ensure_core_hook_scripts()
+    # Universal coding rules are inlined into AGENTS.md by generate_codex.py;
+    # Codex does not read a .agents/rules/ directory.
     inject_with_rules("generate_codex.py", CODEX_ROOT / "AGENTS.md", RULES_DIR)
-    generate_codex_rules(CODEX_ROOT, rules_dir=RULES_DIR)
     hooks_path = CODEX_ROOT / ".codex" / "hooks.json"
     existing = _load_json(hooks_path, {"hooks": {}})
     plugin_entries: dict[str, list[dict]] = {}

package/scripts/validate.py

@@ -851,6 +851,7 @@ _README_PLATFORM_KEY = {
     "claude code": "claude",
     "cursor": "cursor",
     "windsurf": "windsurf",
+    "windsurf (devin desktop)": "windsurf",
     "gemini cli": "gemini",
     "github copilot": "copilot",
     "cline": "cline",

package/scripts/generate_codex_rules.py

@@ -1,52 +0,0 @@
-#!/usr/bin/env python3
-"""Generate Codex CLI .agents/rules/ files.
-
-Codex discovers rules in .agents/rules/ at the project root.
-This generator follows the same pattern as generate_antigravity.py.
-
-Usage:
-  python3 scripts/generate_codex_rules.py [target-dir]
-
-Writes files directly to target-dir/.agents/rules/.
-"""
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-from dir_rules_shared import (
-    STANDARD_RULES,
-    STANDARD_SCOPE,
-    build_language_rules,
-    build_registered_rules,
-    write_rules,
-)
-
-
-def generate(target_dir: Path, *,
-             language_modules: list[str] | None = None,
-             rules_dir: Path | None = None,
-             cleanup: bool = True,
-             managed_scopes: tuple[str, ...] = (STANDARD_SCOPE,)) -> None:
-    """Write .agents/rules/ files to target_dir."""
-    rules = dict(STANDARD_RULES)
-    rules.update(build_language_rules(language_modules))
-    rules.update(build_registered_rules(rules_dir))
-    write_rules(
-        target_dir,
-        rules,
-        ".agents/rules",
-        cleanup=cleanup,
-        managed_scopes=managed_scopes,
-    )
-
-
-def main() -> None:
-    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
-    from paths import RULES_DIR
-    generate(target, rules_dir=RULES_DIR)
-
-
-if __name__ == "__main__":
-    main()