@softspark/ai-toolkit 3.0.2 → 3.1.0

package/scripts/install_steps/ai_tools.py

@@ -1,4 +1,4 @@
-"""Install AI tool configs (Cursor, Windsurf, Gemini, Augment, Codex) and local project setup."""
+"""Install global and project-local AI tool configs."""
 from __future__ import annotations
 
 import shutil
@@ -53,14 +53,6 @@ def install_ai_tools(target_dir: Path, rules_dir: Path,
     # control Claude components like agents, hooks, rules).  If an editor is
     # in the requested set, install it unconditionally.
 
-    if "cursor" in eds:
-        cursor_file = target_dir / ".cursor" / "rules"
-        if dry_run:
-            print("  Would inject: ~/.cursor/rules")
-        else:
-            inject_with_rules("generate-cursor-rules.sh", cursor_file, rules_dir)
-        installed.append("cursor")
-
     if "windsurf" in eds:
         windsurf_file = target_dir / ".codeium" / "windsurf" / "memories" / "global_rules.md"
         if dry_run:
@@ -85,6 +77,27 @@ def install_ai_tools(target_dir: Path, rules_dir: Path,
             inject_with_rules("generate-augment.sh", augment_file, rules_dir)
         installed.append("augment")
 
+    if "cline" in eds:
+        if dry_run:
+            print("  Would generate: ~/Documents/Cline/Rules/ai-toolkit-*.md")
+        else:
+            _install_cline_global(target_dir, rules_dir)
+        installed.append("cline")
+
+    if "roo" in eds:
+        if dry_run:
+            print("  Would generate: ~/.roo/rules/ai-toolkit-*.md")
+        else:
+            _install_roo_global(target_dir, rules_dir)
+        installed.append("roo")
+
+    if "aider" in eds:
+        if dry_run:
+            print("  Would create if missing: ~/.aider.conf.yml + ~/.aider-ai-toolkit-CONVENTIONS.md")
+        else:
+            _install_aider_global(target_dir, rules_dir)
+        installed.append("aider")
+
     if "codex" in eds:
         if dry_run:
             print("  Would inject: ~/AGENTS.md, ~/.agents/, ~/.codex/hooks.json")
@@ -102,7 +115,7 @@ def install_ai_tools(target_dir: Path, rules_dir: Path,
 
     print()
     print(f"  Available: {', '.join(GLOBAL_CAPABLE_EDITORS)}")
-    print("  Note: Copilot, Cline, Roo Code, Aider, Antigravity have no global config -- use 'ai-toolkit install --local' per project")
+    print("  Note: Cursor, Copilot, and Antigravity rule installs are project-local; use 'ai-toolkit install --local' for those.")
 
     return installed
 
@@ -136,6 +149,77 @@ def _install_codex_global(target_dir: Path, rules_dir: Path) -> None:
     _install_codex_skills(target_dir)
 
 
+def _install_cline_global(target_dir: Path, rules_dir: Path) -> None:
+    """Install Cline global rules in the documented user rules directory."""
+    from generate_cline_rules import generate as gen_cline_rules
+
+    rules_root = target_dir / "Documents" / "Cline" / "Rules"
+    gen_cline_rules(
+        target_dir,
+        rules_dir=rules_dir,
+        output_root=rules_root,
+        emit_workflows=False,
+        managed_scopes=("standard", "custom"),
+    )
+    print("  Created: ~/Documents/Cline/Rules/ai-toolkit-*.md")
+
+
+def _install_roo_global(target_dir: Path, rules_dir: Path) -> None:
+    """Install Roo Code global rules in ~/.roo/rules."""
+    from generate_roo_rules import generate as gen_roo_rules
+
+    gen_roo_rules(target_dir, rules_dir=rules_dir, output_root=target_dir / ".roo" / "rules")
+    print("  Created: ~/.roo/rules/ai-toolkit-*.md")
+
+
+def _install_aider_global(target_dir: Path, rules_dir: Path) -> None:
+    """Install an Aider global config only when it can be created safely.
+
+    Aider supports ~/.aider.conf.yml, but YAML merging without a parser risks
+    clobbering user settings. For existing files we leave the user's config
+    untouched and print an explicit next step.
+    """
+    conventions_file = target_dir / ".aider-ai-toolkit-CONVENTIONS.md"
+    inject_with_rules("generate_conventions.py", conventions_file, rules_dir)
+
+    config_file = target_dir / ".aider.conf.yml"
+    if config_file.exists():
+        print("  Kept: ~/.aider.conf.yml (already exists; not merging YAML automatically)")
+        print(f"  Available: {conventions_file} for manual read: entry")
+        return
+
+    default_model = _aider_default_model()
+    config_file.write_text(
+        "\n".join([
+            "# Aider configuration generated by ai-toolkit",
+            "# Aider docs: https://aider.chat/docs/config/aider_conf.html",
+            "",
+            "architect: true",
+            "auto-accept-architect: true",
+            "",
+            "read:",
+            f'  - "{conventions_file}"',
+            "",
+            f"model: {default_model}",
+            f"editor-model: {default_model}",
+            "",
+            'commit-prompt: "Write a short, concise commit message following Conventional Commits (feat/fix/chore/docs/test/refactor)."',
+            "attribute-co-authored-by: false",
+            "attribute-commit-message-author: false",
+            "attribute-commit-message-committer: false",
+            "",
+        ]),
+        encoding="utf-8",
+    )
+    print("  Created: ~/.aider.conf.yml")
+
+
+def _aider_default_model() -> str:
+    from _common import DEFAULT_CLAUDE_MODELS
+
+    return DEFAULT_CLAUDE_MODELS["sonnet"]
+
+
 def _install_opencode_global(target_dir: Path, rules_dir: Path) -> None:
     """Install opencode at the global level (~/.config/opencode/).
 
@@ -331,10 +415,10 @@ def install_local_project(rules_dir: Path, dry_run: bool, reset: bool,
     - ``full``: adds every native surface an editor can host (subagents,
       custom commands, hooks, skill-catalogue pointers).
 
-    ``codex_skills`` (opt-in, off by default) additionally writes a full skill
-    mirror under ``.codex/skills/``. Required even for ``--profile full`` —
-    the mirror is intentionally gated behind an extra flag to keep the default
-    footprint small.
+    ``codex_skills`` (opt-in, off by default) explicitly refreshes the full
+    Codex skill catalog under ``.agents/skills/``. ``--editors codex`` already
+    installs this catalog for normal local installs; the flag is kept as a
+    direct generator contract for scripts and dry-run verification.
 
     If ``merged_config`` is provided (from .softspark-toolkit.json extends resolution),
     additional rules and constitution amendments from the base config are injected.
@@ -491,53 +575,67 @@ def _apply_extends_config(cwd: Path, merged: dict) -> None:
 
 
 def _inject_language_rules(cwd: Path, language_modules: list[str] | None) -> None:
-    """Inject language-specific rule summary into project's .claude/CLAUDE.md.
+    """Inject ``app/rules/common/*.md`` content into project's ``.claude/CLAUDE.md``.
+
+    Per-language rules (``app/rules/<lang>/``) are NOT injected here -- they
+    ship as ``<lang>-rules`` knowledge skills under ``app/skills/`` and load
+    contextually via the Agent Skills progressive-disclosure mechanism. This
+    keeps ``CLAUDE.md`` small while ensuring language-specific guidance still
+    reaches Claude when relevant.
 
-    Instead of injecting full rule content (hundreds of lines), injects a
-    compact summary with the key rules per category. Full rules are available
-    as knowledge skills that Claude auto-loads contextually.
+    Common rules are language-agnostic (security, git workflow, testing,
+    coding-style, performance) and stay inlined so they remain in scope for
+    every prompt.
     """
     if not language_modules:
         return
 
     rules_src = app_dir / "rules"
-    if not rules_src.is_dir():
+    common_dir = rules_src / "common"
+    if not common_dir.is_dir():
         return
 
-    # Detect language names
+    # Detect requested per-language modules so we can name the linked skills
+    # in the marker block. The modules themselves are not inlined.
     langs: list[str] = []
     for mod in language_modules:
         if mod.startswith("rules-"):
-            langs.append(mod[6:])
+            name = mod[6:]
+            if name != "common":
+                langs.append(name)
+
+    # Inline full content of every common rule file, stripping YAML
+    # frontmatter so the resulting block reads as plain Markdown.
+    inlined: list[str] = []
+    for f in sorted(common_dir.glob("*.md")):
+        body = f.read_text(encoding="utf-8")
+        if body.startswith("---"):
+            end = body.find("\n---", 3)
+            if end != -1:
+                body = body[end + 4:].lstrip("\n")
+        inlined.append(body.rstrip())
 
-    if not langs:
-        return
-
-    # Build a lightweight reference pointer — NOT the full rules content.
-    # Full rules are available as knowledge skills (auto-loaded by Claude)
-    # and as files Claude can Read on demand.
-    toolkit_pkg = app_dir.parent
     lines: list[str] = ["# Language Rules", ""]
-    lines.append(f"This project uses: **{', '.join(langs)}**")
+    lines.append(
+        "Common (language-agnostic) rules apply to every change in this "
+        "project. Language-specific rules live in `<lang>-rules` knowledge "
+        "skills (e.g. `python-rules`, `typescript-rules`) and load "
+        "automatically when their triggers match -- you do not need to "
+        "Read them manually."
+    )
+    if langs:
+        skill_names = ", ".join(f"`{l}-rules`" for l in langs)
+        lines.append("")
+        lines.append(f"Detected languages: {skill_names}.")
     lines.append("")
-    lines.append("When writing or reviewing code, use the Glob and Read tools to read the rules:")
-    # Resolve actual installed path for the rules
-    rules_resolved = str(rules_src.resolve())
-    all_dirs: list[str] = ["common"]
-    for l in langs:
-        if l not in all_dirs:
-            all_dirs.append(l)
-    for lang in all_dirs:
-        lang_path = rules_src / lang
-        if lang_path.is_dir():
-            categories = ", ".join(f.stem for f in sorted(lang_path.glob("*.md")))
-            lines.append(f"- `{lang_path.resolve()}/` ({categories})")
+    lines.append("---")
     lines.append("")
-    lines.append("Read the relevant rule files before making code changes. Do NOT guess — read first.")
+    lines.extend(inlined)
 
-    # Write summary to temp file, then inject as section
+    # Write to temp file, then inject as a single named section so reruns are
+    # idempotent (existing block is replaced, not duplicated).
     import tempfile
-    combined = "\n".join(lines)
+    combined = "\n\n".join(lines).rstrip() + "\n"
     with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False,
                                      encoding="utf-8") as tmp:
         tmp.write(combined)
@@ -545,8 +643,11 @@ def _inject_language_rules(cwd: Path, language_modules: list[str] | None) -> Non
 
     try:
         inject_section(tmp_path, cwd / ".claude" / "CLAUDE.md", "language-rules")
-        lang_names = [l for l in langs if l != "common"]
-        print(f"  Injected: language rules summary (common + {', '.join(lang_names)})")
+        if langs:
+            print(f"  Injected: common rules + {len(langs)} language skill(s) "
+                  f"({', '.join(langs)})")
+        else:
+            print("  Injected: common rules")
     finally:
         tmp_path.unlink(missing_ok=True)
 
@@ -600,8 +701,10 @@ def _install_local_dry_run(reset: bool, editors: list[str] | None = None,
                   "$HOME/.augment/settings.json + .augment/skills/ (profile=full)")
         if "gemini" in eds:
             print("  Would generate: .gemini/commands/ + .gemini/skills/ (profile=full)")
-    if "codex" in eds and codex_skills:
-        print("  Would generate: .codex/skills/ full mirror (--codex-skills)")
+    if "codex" in eds:
+        print("  Would generate: .agents/skills/ Codex skills")
+        if codex_skills:
+            print("  Would refresh: .agents/skills/ via --codex-skills")
 
     if not eds:
         print("  No editors selected (use --editors <list> or --editors all)")
@@ -881,10 +984,10 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
         from generate_codex_hooks import generate as gen_codex_hooks
         gen_codex_hooks(cwd)
         print("  Created: .codex/hooks.json")
-        # .agents/skills/ — filtered symlinks (Codex-compatible skills only)
+        # .agents/skills/ — Codex discovery path for repo-local skills
         _install_codex_skills(cwd)
-        # .codex/skills/ — full mirror, gated behind explicit --codex-skills flag
-        # (does NOT activate automatically on --profile full — must opt in).
+        # --codex-skills explicitly re-runs the same Codex skill sync path.
+        # Codex upstream discovers skills from .agents/skills/, not .codex/skills/.
         if codex_skills:
             _try_generator("generate_codex_skills", cwd,
                            enable_codex_skills=True)

package/scripts/install_steps/install_state.py

@@ -88,8 +88,20 @@ def remove_mcp_template(name: str) -> None:
 # Default global install: Claude only — no other editors unless --editors is used
 DEFAULT_GLOBAL_EDITORS: list[str] = []
 
-# All editors that support global install (opt-in via --editors)
-GLOBAL_CAPABLE_EDITORS = ["augment", "codex", "cursor", "gemini", "opencode", "windsurf"]
+# All editors that support global install (opt-in via --editors).
+#
+# Cursor intentionally stays out of this list: its documented global rules
+# surface is the Settings UI, not a stable file path we can merge safely.
+GLOBAL_CAPABLE_EDITORS = [
+    "aider",
+    "augment",
+    "cline",
+    "codex",
+    "gemini",
+    "opencode",
+    "roo",
+    "windsurf",
+]
 
 
 def get_global_editors() -> list[str]:

package/scripts/mcp_editors.py

@@ -41,6 +41,13 @@ EDITOR_SPECS: dict[str, dict[str, str | None]] = {
         "format": "json",
         "doc_scope": "project + global",
     },
+    "roo": {
+        "label": "Roo Code",
+        "project_path": ".roo/mcp.json",
+        "global_path": None,
+        "format": "json",
+        "doc_scope": "project",
+    },
     "windsurf": {
         "label": "Windsurf",
         "project_path": None,