@softspark/ai-toolkit 1.3.14 → 1.4.0

package/scripts/generate_cursor_mdc.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Generate .cursor/rules/*.mdc files for Cursor IDE.
+
+Cursor reads rules from .cursor/rules/*.mdc (since Cursor 0.45).
+Each .mdc file has YAML frontmatter controlling when the rule applies:
+  - alwaysApply: true  — always in context
+  - globs: ["**/*.ts"] — auto-attached for matching files
+  - description: "..." — AI decides whether to include (Agent Requested)
+
+The legacy .cursorrules format is still generated separately by
+generate_cursor_rules.py for backwards compatibility.
+
+Usage:
+  python3 scripts/generate_cursor_mdc.py [target-dir]
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from dir_rules_shared import (
+    PREFIX,
+    cleanup_stale,
+    rule_agents_and_skills,
+    rule_code_style,
+    rule_quality_standards,
+    rule_security,
+    rule_testing,
+    rule_workflow,
+)
+
+
+# ---------------------------------------------------------------------------
+# .mdc wrapper: prepends YAML frontmatter to markdown content
+# ---------------------------------------------------------------------------
+
+def _mdc(content: str, *, description: str = "",
+         globs: list[str] | None = None,
+         always_apply: bool = False) -> str:
+    """Wrap markdown content with Cursor .mdc YAML frontmatter."""
+    lines = ["---"]
+    if description:
+        lines.append(f"description: {description}")
+    if globs:
+        globs_str = ", ".join(f'"{g}"' for g in globs)
+        lines.append(f"globs: [{globs_str}]")
+    lines.append(f"alwaysApply: {'true' if always_apply else 'false'}")
+    lines.append("---")
+    lines.append("")
+    lines.append(content.rstrip("\n"))
+    lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Rule files registry
+# ---------------------------------------------------------------------------
+
+def _make_rules() -> dict[str, callable]:
+    """Build the .mdc rule file registry."""
+    return {
+        # Always active
+        f"{PREFIX}agents-and-skills.mdc": lambda: _mdc(
+            rule_agents_and_skills(),
+            description="AI toolkit agents, skills, and guidelines catalog",
+            always_apply=True,
+        ),
+        f"{PREFIX}security.mdc": lambda: _mdc(
+            rule_security(),
+            description="Security rules — OWASP, secrets, input validation",
+            always_apply=True,
+        ),
+        f"{PREFIX}quality-standards.mdc": lambda: _mdc(
+            rule_quality_standards(),
+            description="Quality standards — tests, safety, operational integrity",
+            always_apply=True,
+        ),
+        # Auto-attached by file type
+        f"{PREFIX}code-style.mdc": lambda: _mdc(
+            rule_code_style(),
+            description="Code style conventions for all languages",
+        ),
+        f"{PREFIX}testing.mdc": lambda: _mdc(
+            rule_testing(),
+            description="Testing standards and patterns",
+            globs=["**/*.test.*", "**/*.spec.*", "**/test_*", "**/tests/**"],
+        ),
+        f"{PREFIX}workflow.mdc": lambda: _mdc(
+            rule_workflow(),
+            description="Development workflow — planning, commits, quality gates",
+        ),
+    }
+
+
+RULES = _make_rules()
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def generate(target_dir: Path) -> None:
+    """Write .cursor/rules/*.mdc files to target_dir."""
+    rules_dir = target_dir / ".cursor" / "rules"
+    rules_dir.mkdir(parents=True, exist_ok=True)
+
+    # Clean stale ai-toolkit-*.mdc files
+    current = set(RULES.keys())
+    if rules_dir.is_dir():
+        for f in rules_dir.iterdir():
+            if f.name.startswith(PREFIX) and f.suffix == ".mdc" and f.name not in current:
+                f.unlink()
+                print(f"  Removed stale: .cursor/rules/{f.name}")
+
+    for filename, content_fn in RULES.items():
+        (rules_dir / filename).write_text(content_fn(), encoding="utf-8")
+        print(f"  Generated: .cursor/rules/{filename}")
+
+
+def main() -> None:
+    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
+    generate(target)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/generate_roo_rules.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""Generate .roo/rules/*.md shared rules for Roo Code.
+
+Roo Code reads shared rules from .roo/rules/*.md (applied to all modes).
+The .roomodes JSON is still generated separately by generate_roo_modes.py.
+
+Usage:
+  python3 scripts/generate_roo_rules.py [target-dir]
+"""
+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, write_rules
+
+
+def generate(target_dir: Path) -> None:
+    """Write .roo/rules/*.md files to target_dir."""
+    write_rules(target_dir, STANDARD_RULES, ".roo/rules")
+
+
+def main() -> None:
+    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
+    generate(target)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/generate_windsurf_rules.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Generate .windsurf/rules/*.md files for Windsurf IDE.
+
+Windsurf reads directory-based rules from .windsurf/rules/*.md (since mid-2025).
+The legacy .windsurfrules single-file format is still generated separately
+by generate_windsurf.py for backwards compatibility.
+
+Usage:
+  python3 scripts/generate_windsurf_rules.py [target-dir]
+"""
+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, write_rules
+
+
+def generate(target_dir: Path) -> None:
+    """Write .windsurf/rules/*.md files to target_dir."""
+    write_rules(target_dir, STANDARD_RULES, ".windsurf/rules")
+
+
+def main() -> None:
+    target = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
+    generate(target)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/install.py

@@ -197,6 +197,8 @@ def parse_args(argv: list[str]) -> dict:
         "modules": "",
         "auto_detect": False,
         "status": False,
+        "lang": "",
+        "editors": "",
     }
     i = 0
     while i < len(argv):
@@ -236,6 +238,16 @@ def parse_args(argv: list[str]) -> dict:
         elif arg == "--modules":
             i += 1
             cfg["modules"] = argv[i] if i < len(argv) else ""
+        elif arg.startswith("--lang="):
+            cfg["lang"] = arg.split("=", 1)[1]
+        elif arg == "--lang":
+            i += 1
+            cfg["lang"] = argv[i] if i < len(argv) else ""
+        elif arg.startswith("--editors="):
+            cfg["editors"] = arg.split("=", 1)[1]
+        elif arg == "--editors":
+            i += 1
+            cfg["editors"] = argv[i] if i < len(argv) else ""
         elif arg.startswith("-"):
             print(f"Unknown option: {arg}")
             sys.exit(1)
@@ -405,6 +417,17 @@ def main() -> None:
     persona: str = cfg["persona"]
     modules_arg: str = cfg["modules"]
     auto_detect: bool = cfg["auto_detect"]
+    lang_arg: str = cfg["lang"]
+
+    # --lang <list> → merge into --modules as rules-<lang> entries
+    _LANG_ALIASES = {"go": "golang", "c++": "cpp", "c#": "csharp", "cs": "csharp"}
+    if lang_arg:
+        langs = [_LANG_ALIASES.get(l.strip(), l.strip()) for l in lang_arg.split(",") if l.strip()]
+        lang_modules = ",".join(f"rules-{l}" for l in langs)
+        modules_arg = f"{modules_arg},{lang_modules}" if modules_arg else lang_modules
+        auto_detect = False  # explicit --lang overrides auto-detect
+        if not local:
+            local = True  # language rules are project-local
 
     rules_dir = Path.home() / ".ai-toolkit" / "rules"
     hooks_scripts_dir = Path.home() / ".ai-toolkit" / "hooks"
@@ -447,7 +470,9 @@ def main() -> None:
     if local:
         # Pass language modules for --auto-detect / --modules rules-*
         lang_modules = [m for m in (resolved_modules or []) if m.startswith("rules-")]
-        install_local_project(rules_dir, dry_run, reset, lang_modules or None)
+        editors_arg: str = cfg["editors"]
+        install_local_project(rules_dir, dry_run, reset, lang_modules or None,
+                              editors=editors_arg)
 
     install_persona(target_dir, persona, dry_run)
     install_strict_git_hooks(profile, local, dry_run)

package/scripts/install_steps/ai_tools.py

@@ -120,18 +120,81 @@ def run_script(script_name: str, *args: str, capture: bool = False) -> str:
     return result.stdout if capture else ""
 
 
+# All known editor identifiers for --editors flag
+ALL_EDITORS = [
+    "copilot", "cursor", "windsurf", "cline", "roo",
+    "aider", "augment", "antigravity",
+]
+
+# Map of project files/dirs → editor names for auto-detection
+_EDITOR_MARKERS: dict[str, str] = {
+    ".github/copilot-instructions.md": "copilot",
+    ".cursorrules": "cursor",
+    ".cursor/rules": "cursor",
+    ".windsurfrules": "windsurf",
+    ".windsurf/rules": "windsurf",
+    ".clinerules": "cline",
+    ".cline/rules": "cline",
+    ".roomodes": "roo",
+    ".roo/rules": "roo",
+    ".aider.conf.yml": "aider",
+    "CONVENTIONS.md": "aider",
+    ".augment/rules": "augment",
+    ".agent/rules": "antigravity",
+}
+
+
+def _detect_editors(cwd: Path) -> list[str]:
+    """Detect which editors have configs in the project directory."""
+    found: set[str] = set()
+    for marker, editor in _EDITOR_MARKERS.items():
+        p = cwd / marker
+        if p.exists():
+            found.add(editor)
+    return sorted(found)
+
+
+def _resolve_editors(editors_arg: str, cwd: Path) -> list[str]:
+    """Resolve --editors argument to a list of editor names.
+
+    - ""           → auto-detect from existing project files (empty if none found)
+    - "all"        → all editors
+    - "cursor,aider" → explicit list
+    """
+    if editors_arg == "all":
+        return list(ALL_EDITORS)
+    if editors_arg:
+        return [e.strip() for e in editors_arg.split(",") if e.strip()]
+    # Auto-detect: return editors that already have configs in the project
+    return _detect_editors(cwd)
+
+
 def install_local_project(rules_dir: Path, dry_run: bool, reset: bool,
-                          language_modules: list[str] | None = None) -> None:
-    """Install project-local configs."""
+                          language_modules: list[str] | None = None,
+                          editors: str = "") -> None:
+    """Install project-local configs.
+
+    Claude Code configs (CLAUDE.md, settings, constitution) are always installed.
+    Editor configs are installed based on ``--editors`` flag:
+    - ``--editors all``: install all editors
+    - ``--editors cursor,aider``: install only these
+    - (empty): auto-detect from existing project files, install only those
+    """
     cwd = Path.cwd()
+    resolved_editors = _resolve_editors(editors, cwd)
+
     print()
     print(f"## Project-local ({cwd})")
     if reset:
         print("   Mode: RESET (all local configs will be wiped and recreated)")
+    if resolved_editors:
+        print(f"   Editors: {', '.join(resolved_editors)}")
+    else:
+        print("   Editors: none (use --editors <list> or --editors all to enable)")
     print()
 
     if dry_run:
-        _install_local_dry_run(reset)
+        _install_local_dry_run(reset, resolved_editors)
         if language_modules:
             print(f"  Would inject language rules: {', '.join(language_modules)}")
         return
@@ -162,7 +225,8 @@ def install_local_project(rules_dir: Path, dry_run: bool, reset: bool,
     # Inject language-specific rules into project CLAUDE.md
     _inject_language_rules(cwd, language_modules)
 
-    _create_local_ai_tool_configs(cwd, rules_dir)
+    # Install editor configs only for resolved editors
+    _create_local_ai_tool_configs(cwd, rules_dir, resolved_editors)
 
 
 def _inject_language_rules(cwd: Path, language_modules: list[str] | None) -> None:
@@ -226,21 +290,36 @@ def _inject_language_rules(cwd: Path, language_modules: list[str] | None) -> Non
         tmp_path.unlink(missing_ok=True)
 
 
-def _install_local_dry_run(reset: bool) -> None:
+def _install_local_dry_run(reset: bool, editors: list[str] | None = None) -> None:
+    eds = set(editors or [])
     if reset:
         print("  Would remove: CLAUDE.md, .claude/settings.local.json")
-        print("  Would remove: .claude/constitution.md, .github/copilot-instructions.md, .clinerules, .roomodes, .aider.conf.yml")
+        print("  Would remove: .claude/constitution.md and all editor configs")
         print("  Would recreate all from templates (clean slate)")
-        print("  Would install git hooks (if .git/hooks exists)")
     else:
         print("  Would create: CLAUDE.md (if missing)")
         print("  Would create: .claude/settings.local.json (if missing)")
         print("  Would inject: .claude/constitution.md")
-        print("  Would inject: .github/copilot-instructions.md")
-        print("  Would inject: .clinerules")
-        print("  Would inject: .roomodes")
-        print("  Would inject: .aider.conf.yml")
-        print("  Would install: .git/hooks/pre-commit")
+
+    # Editor-specific dry-run messages
+    _EDITOR_DRY_RUN = {
+        "copilot":      "  Would inject: .github/copilot-instructions.md",
+        "cursor":       "  Would generate: .cursorrules + .cursor/rules/*.mdc",
+        "windsurf":     "  Would generate: .windsurfrules + .windsurf/rules/*.md",
+        "cline":        "  Would generate: .clinerules + .cline/rules/*.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/",
+    }
+    for ed, msg in _EDITOR_DRY_RUN.items():
+        if ed in eds:
+            print(msg)
+
+    if not eds:
+        print("  No editors selected (use --editors <list> or --editors all)")
+
+    print("  Would install: .git/hooks/pre-commit")
 
 
 def _reset_local_configs(cwd: Path) -> None:
@@ -314,24 +393,63 @@ def _create_local_settings(cwd: Path, reset: bool) -> None:
         print("  Kept: .claude/settings.local.json (already exists)")
 
 
-def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path) -> None:
-    inject_with_rules(
-        "generate-copilot.sh",
-        cwd / ".github" / "copilot-instructions.md",
-        rules_dir,
-    )
-    inject_with_rules(
-        "generate-cline.sh",
-        cwd / ".clinerules",
-        rules_dir,
-    )
-
-    roo_output = run_script("generate-roo-modes.sh", capture=True)
-    (cwd / ".roomodes").write_text(roo_output, encoding="utf-8")
-    print("  Created: .roomodes")
-
-    aider_output = run_script("generate-aider-conf.sh", capture=True)
-    (cwd / ".aider.conf.yml").write_text(aider_output, encoding="utf-8")
-    print("  Created: .aider.conf.yml")
+def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
+                                   editors: list[str]) -> None:
+    eds = set(editors)
+
+    if "copilot" in eds:
+        inject_with_rules(
+            "generate-copilot.sh",
+            cwd / ".github" / "copilot-instructions.md",
+            rules_dir,
+        )
+
+    if "cursor" in eds:
+        inject_with_rules(
+            "generate-cursor-rules.sh",
+            cwd / ".cursorrules",
+            rules_dir,
+        )
+        from generate_cursor_mdc import generate as gen_cursor_mdc
+        gen_cursor_mdc(cwd)
+
+    if "windsurf" in eds:
+        inject_with_rules(
+            "generate-windsurf.sh",
+            cwd / ".windsurfrules",
+            rules_dir,
+        )
+        from generate_windsurf_rules import generate as gen_windsurf_rules
+        gen_windsurf_rules(cwd)
+
+    if "cline" in eds:
+        inject_with_rules(
+            "generate-cline.sh",
+            cwd / ".clinerules",
+            rules_dir,
+        )
+        from generate_cline_rules import generate as gen_cline_rules
+        gen_cline_rules(cwd)
+
+    if "roo" in eds:
+        roo_output = run_script("generate-roo-modes.sh", capture=True)
+        (cwd / ".roomodes").write_text(roo_output, encoding="utf-8")
+        print("  Created: .roomodes")
+        from generate_roo_rules import generate as gen_roo_rules
+        gen_roo_rules(cwd)
+
+    if "aider" in eds:
+        aider_output = run_script("generate-aider-conf.sh", capture=True)
+        (cwd / ".aider.conf.yml").write_text(aider_output, encoding="utf-8")
+        print("  Created: .aider.conf.yml")
+        inject_with_rules("generate_conventions.py", cwd / "CONVENTIONS.md", rules_dir)
+
+    if "augment" in eds:
+        from generate_augment_rules import generate as gen_augment_rules
+        gen_augment_rules(cwd)
+
+    if "antigravity" in eds:
+        from generate_antigravity import generate as gen_antigravity
+        gen_antigravity(cwd)
 
     run_script("install-git-hooks.sh", str(cwd))

package/scripts/install_steps/detect_language.py

@@ -1,10 +1,40 @@
-"""Detect project language from file markers in the manifest."""
+"""Detect project language from file markers and source file extensions."""
 from __future__ import annotations
 
 import json
 from pathlib import Path
 
 
+# Map file extensions to manifest module names.
+# Only extensions that unambiguously identify a language are listed.
+_EXT_TO_MODULE: dict[str, str] = {
+    ".py": "rules-python",
+    ".ts": "rules-typescript",
+    ".tsx": "rules-typescript",
+    ".go": "rules-golang",
+    ".rs": "rules-rust",
+    ".java": "rules-java",
+    ".kt": "rules-kotlin",
+    ".kts": "rules-kotlin",
+    ".swift": "rules-swift",
+    ".dart": "rules-dart",
+    ".cs": "rules-csharp",
+    ".php": "rules-php",
+    ".cpp": "rules-cpp",
+    ".cc": "rules-cpp",
+    ".cxx": "rules-cpp",
+    ".hpp": "rules-cpp",
+    ".rb": "rules-ruby",
+}
+
+# Directories that should never be scanned (dependency dirs, build output, etc.)
+_SKIP_DIRS = frozenset({
+    "node_modules", ".git", "__pycache__", "venv", ".venv", "env",
+    "dist", "build", ".tox", ".mypy_cache", ".pytest_cache",
+    "vendor", "target", ".next", ".nuxt", "coverage",
+})
+
+
 def _load_manifest_modules(toolkit_dir: Path) -> dict:
     """Load the modules section from manifest.json."""
     manifest_path = toolkit_dir / "manifest.json"
@@ -24,19 +54,49 @@ def _glob_matches(project_dir: Path, pattern: str) -> bool:
     return any(project_dir.glob(pattern))
 
 
+def _detect_by_extensions(project_dir: Path) -> set[str]:
+    """Scan source files (top-level + 1 level deep) and return detected modules.
+
+    Skips dependency/build directories for speed. Stops scanning for a
+    given extension once one match is found.
+    """
+    found: set[str] = set()
+    seen_exts: set[str] = set()
+
+    for child in project_dir.iterdir():
+        if child.is_file():
+            ext = child.suffix
+            if ext in _EXT_TO_MODULE and ext not in seen_exts:
+                seen_exts.add(ext)
+                found.add(_EXT_TO_MODULE[ext])
+        elif child.is_dir() and child.name not in _SKIP_DIRS:
+            for grandchild in child.iterdir():
+                if grandchild.is_file():
+                    ext = grandchild.suffix
+                    if ext in _EXT_TO_MODULE and ext not in seen_exts:
+                        seen_exts.add(ext)
+                        found.add(_EXT_TO_MODULE[ext])
+
+    return found
+
+
 def detect_languages(project_dir: Path, toolkit_dir: Path) -> list[str]:
     """Return list of detected language module names.
 
-    Scans ``project_dir`` for marker files defined in each module's
-    ``auto_detect`` list inside ``manifest.json``.
+    Two-phase detection:
+    1. Marker files (``auto_detect`` in manifest.json) — config-level signals.
+    2. Source file extensions (top-level + 1 deep) — actual code presence.
+
+    Both phases contribute; duplicates are merged.
 
     Returns:
         Sorted list of matching module names, e.g.
         ``["rules-python", "rules-typescript"]``.
     """
     modules = _load_manifest_modules(toolkit_dir)
-    detected: list[str] = []
+    detected: set[str] = set()
 
+    # Phase 1: marker files from manifest
     for module_name, module_cfg in modules.items():
         markers = module_cfg.get("auto_detect")
         if not markers:
@@ -44,7 +104,10 @@ def detect_languages(project_dir: Path, toolkit_dir: Path) -> list[str]:
 
         for pattern in markers:
             if _glob_matches(project_dir, pattern):
-                detected.append(module_name)
+                detected.add(module_name)
                 break  # one match is enough for this module
 
+    # Phase 2: source file extensions
+    detected |= _detect_by_extensions(project_dir)
+
     return sorted(detected)