@softspark/ai-toolkit 3.0.1 → 3.1.0

package/scripts/generate_language_rules_skills.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""Generate language-rules knowledge skills from app/rules/<lang>/*.md.
+
+Each language directory under ``app/rules/`` (except ``common/``) is compiled
+into a single ``app/skills/<lang>-rules/SKILL.md`` knowledge skill. The skill
+is ``user-invocable: false`` so Claude loads it contextually when the
+description triggers match (file extensions, framework names).
+
+This is the proper progressive-disclosure replacement for the v1.3.8 pointer
+block in ``.claude/CLAUDE.md``: instead of nudging Claude to Read absolute
+nvm-pinned paths on demand, the rules ride on the Agent Skills mechanism.
+
+Common rules (``app/rules/common/``) stay inlined in ``CLAUDE.md`` because
+they are language-agnostic and should be visible regardless of context.
+
+Idempotent: rerunning overwrites generated SKILL.md but leaves any other
+files in the skill directory alone.
+
+Usage:
+    python3 scripts/generate_language_rules_skills.py            # write all
+    python3 scripts/generate_language_rules_skills.py --check    # dry-run
+    python3 scripts/generate_language_rules_skills.py --langs python,rust
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from textwrap import dedent
+
+ROOT = Path(__file__).resolve().parent.parent
+RULES_DIR = ROOT / "app" / "rules"
+SKILLS_DIR = ROOT / "app" / "skills"
+
+# Per-language description triggers. Concrete file extensions and framework
+# names give Claude a high-signal match against user prompts and file paths,
+# so the skill activates reliably when the user is actually working in that
+# language.
+TRIGGERS: dict[str, dict[str, str]] = {
+    "python": {
+        "label": "Python",
+        "triggers": ".py, .pyi, pyproject.toml, requirements.txt, Pipfile, FastAPI, Django, Flask, pytest, SQLAlchemy, ruff, mypy",
+    },
+    "typescript": {
+        "label": "TypeScript/JavaScript",
+        "triggers": ".ts, .tsx, .js, .jsx, package.json, tsconfig.json, React, Next.js, Vue, Vite, Vitest, Jest, ESLint",
+    },
+    "golang": {
+        "label": "Go",
+        "triggers": ".go, go.mod, go.sum, Gin, Echo, Gorilla, testing, gofmt",
+    },
+    "rust": {
+        "label": "Rust",
+        "triggers": ".rs, Cargo.toml, Cargo.lock, Tokio, Axum, Serde, clippy, cargo test",
+    },
+    "java": {
+        "label": "Java",
+        "triggers": ".java, pom.xml, build.gradle, Spring, Spring Boot, JPA, Hibernate, JUnit, Maven, Gradle",
+    },
+    "kotlin": {
+        "label": "Kotlin",
+        "triggers": ".kt, .kts, build.gradle.kts, Ktor, Jetpack Compose, coroutines, kotlinx",
+    },
+    "swift": {
+        "label": "Swift",
+        "triggers": ".swift, Package.swift, .xcodeproj, SwiftUI, Combine, async/await, XCTest",
+    },
+    "dart": {
+        "label": "Dart/Flutter",
+        "triggers": ".dart, pubspec.yaml, Flutter, Riverpod, Bloc, widget, StatelessWidget, StatefulWidget",
+    },
+    "csharp": {
+        "label": "C#/.NET",
+        "triggers": ".cs, .csproj, .sln, ASP.NET, ASP.NET Core, EF Core, LINQ, NUnit, xUnit, dotnet",
+    },
+    "php": {
+        "label": "PHP",
+        "triggers": ".php, composer.json, Laravel, Symfony, PHPUnit, PSR-12, Composer",
+    },
+    "cpp": {
+        "label": "C++",
+        "triggers": ".cpp, .cc, .cxx, .hpp, .h, CMakeLists.txt, Makefile, GoogleTest, clang-tidy",
+    },
+    "ruby": {
+        "label": "Ruby",
+        "triggers": ".rb, Gemfile, .gemspec, Rails, ActiveRecord, Sidekiq, RSpec, Sorbet, rubocop",
+    },
+    "medplum": {
+        "label": "Medplum (FHIR healthcare)",
+        "triggers": "medplum.config.mts, medplum.config.ts, FHIR, Medplum, Bot, Subscription, Questionnaire",
+    },
+}
+
+
+def _strip_frontmatter(text: str) -> str:
+    """Remove YAML frontmatter (--- ... ---) if present."""
+    if not text.startswith("---"):
+        return text.lstrip("\n")
+    end = text.find("\n---", 3)
+    if end == -1:
+        return text.lstrip("\n")
+    return text[end + 4:].lstrip("\n")
+
+
+def _category_title(stem: str) -> str:
+    """Convert filename stem (e.g. ``coding-style``) to a section title."""
+    return " ".join(part.capitalize() for part in stem.split("-"))
+
+
+def _build_skill_body(lang_dir: Path) -> str:
+    """Concatenate all rule category files into a skill body."""
+    parts: list[str] = []
+    for f in sorted(lang_dir.glob("*.md")):
+        body = _strip_frontmatter(f.read_text(encoding="utf-8")).rstrip()
+        # If the source file already starts with a top-level "# Title", keep
+        # it. Otherwise, prepend a "## Category" header so the skill body
+        # has structure.
+        if body.lstrip().startswith("#"):
+            parts.append(body)
+        else:
+            parts.append(f"## {_category_title(f.stem)}\n\n{body}")
+    return "\n\n".join(parts) + "\n"
+
+
+def _build_description(lang: str) -> str:
+    meta = TRIGGERS.get(lang)
+    if not meta:
+        return (
+            f"{lang.capitalize()} coding rules: coding-style, frameworks, "
+            f"patterns, security, testing. Load when writing or reviewing "
+            f"{lang.capitalize()} code."
+        )
+    label = meta["label"]
+    triggers = meta["triggers"]
+    return (
+        f"{label} coding rules from ai-toolkit: coding-style, frameworks, "
+        f"patterns, security, testing. "
+        f"Triggers: {triggers}. "
+        f"Load when writing, reviewing, or editing {label} code."
+    )
+
+
+def _build_skill_md(lang: str, lang_dir: Path) -> str:
+    description = _build_description(lang)
+    body = _build_skill_body(lang_dir)
+    label = TRIGGERS.get(lang, {}).get("label", lang.capitalize())
+    frontmatter = dedent(
+        f"""\
+        ---
+        name: {lang}-rules
+        description: "{description}"
+        effort: medium
+        user-invocable: false
+        allowed-tools: Read
+        ---
+
+        # {label} Rules
+
+        These rules come from `app/rules/{lang}/` in ai-toolkit. They cover
+        the project's standards for coding style, frameworks, patterns,
+        security, and testing in {label}. Apply them when writing or
+        reviewing {label} code.
+
+        """
+    )
+    return frontmatter + body
+
+
+def discover_languages() -> list[str]:
+    """List language directories under app/rules/ excluding ``common``."""
+    if not RULES_DIR.is_dir():
+        return []
+    out: list[str] = []
+    for d in sorted(RULES_DIR.iterdir()):
+        if not d.is_dir() or d.name == "common":
+            continue
+        if any(d.glob("*.md")):
+            out.append(d.name)
+    return out
+
+
+def generate(langs: list[str] | None = None, check: bool = False) -> int:
+    """Generate skills. Returns count of skills written (or that would be)."""
+    languages = langs if langs else discover_languages()
+    written = 0
+    for lang in languages:
+        lang_dir = RULES_DIR / lang
+        if not lang_dir.is_dir():
+            print(f"  SKIP: {lang} (directory missing)", file=sys.stderr)
+            continue
+        skill_dir = SKILLS_DIR / f"{lang}-rules"
+        skill_md = skill_dir / "SKILL.md"
+        content = _build_skill_md(lang, lang_dir)
+
+        if check:
+            existing = skill_md.read_text(encoding="utf-8") if skill_md.is_file() else ""
+            status = "OK" if existing == content else "DIFF"
+            print(f"  [{status}] {skill_md.relative_to(ROOT)}")
+            if existing != content:
+                written += 1
+            continue
+
+        skill_dir.mkdir(parents=True, exist_ok=True)
+        skill_md.write_text(content, encoding="utf-8")
+        print(f"  Wrote: {skill_md.relative_to(ROOT)}")
+        written += 1
+    return written
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0])
+    ap.add_argument(
+        "--langs",
+        default="",
+        help="Comma-separated language list (default: all)",
+    )
+    ap.add_argument(
+        "--check",
+        action="store_true",
+        help="Dry-run: report which skills would change without writing",
+    )
+    args = ap.parse_args()
+    langs = [s.strip() for s in args.langs.split(",") if s.strip()] or None
+    n = generate(langs=langs, check=args.check)
+    if args.check and n > 0:
+        print(f"\n{n} skill(s) out of date. Re-run without --check.", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/generate_roo_rules.py

@@ -23,12 +23,20 @@ from dir_rules_shared import (
 
 def generate(target_dir: Path, *,
              language_modules: list[str] | None = None,
-             rules_dir: Path | None = None) -> None:
-    """Write .roo/rules/*.md files to target_dir."""
+             rules_dir: Path | None = None,
+             output_root: Path | None = None) -> None:
+    """Write Roo Code rule files.
+
+    By default writes project-local ``target_dir/.roo/rules/*.md``. When
+    ``output_root`` is provided, writes directly into that directory for
+    documented global rules such as ``~/.roo/rules``.
+    """
     rules = dict(STANDARD_RULES)
     rules.update(build_language_rules(language_modules))
     rules.update(build_registered_rules(rules_dir))
-    write_rules(target_dir, rules, ".roo/rules")
+    root = output_root.parent if output_root is not None else target_dir
+    subdir = output_root.name if output_root is not None else ".roo/rules"
+    write_rules(root, rules, subdir)
 
 
 def main() -> None:

package/scripts/install.py

@@ -12,9 +12,14 @@ Claude Code (~/.claude/):
   - Rules injected into ~/.claude/CLAUDE.md
 
 Other tools (global config locations):
-  - Cursor:   ~/.cursor/rules
   - Windsurf: ~/.codeium/windsurf/memories/global_rules.md
   - Gemini:   ~/.gemini/GEMINI.md
+  - Cline:    ~/Documents/Cline/Rules/
+  - Roo Code: ~/.roo/rules/
+  - Aider:    ~/.aider.conf.yml (created only if absent)
+  - Augment:  ~/.augment/rules/ai-toolkit.md
+  - Codex:    ~/AGENTS.md, ~/.agents/, ~/.codex/hooks.json
+  - opencode: ~/.config/opencode/
 
 Registered rules (~/.softspark/ai-toolkit/rules/*.md) are also injected into
 all of the above. Add rules with: ai-toolkit add-rule <rule.md>

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,