@softspark/ai-toolkit 1.5.1 → 1.6.1

package/llms.txt

@@ -14,6 +14,10 @@
 - [Best Practices](kb/best-practices/README.md)
 - [No Hardcoded Counts in Secondary Docs](kb/best-practices/no-hardcoded-counts.md)
 - [How-To Guides](kb/howto/README.md)
+- [Plan: Cloud Security Pack — Multi-Cloud Audit](kb/planning/cloud-security-pack-plan.md)
+- [Plan: Enterprise Config Inheritance — Multi-Repo Governance with `extends`](kb/planning/enterprise-config-inheritance-plan.md)
+- [Plan: Local Dashboard — `ai-toolkit ui`](kb/planning/local-dashboard-plan.md)
+- [Plan: Offline-First SLM Profile — Lightweight Mode for Local Models](kb/planning/offline-slm-profile-plan.md)
 - [SOP: Claude Toolkit Maintenance](kb/procedures/maintenance-sop.md)
 - [SOP: Release Preparation](kb/procedures/release-preparation-sop.md)
 - [SOP: Release Verification](kb/procedures/release-verification-sop.md)

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.1",
+  "version": "1.6.1",
   "components": {
     "agents": {
       "description": "44 specialized agents (orchestrator, backend, frontend, security, devops, etc.)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softspark/ai-toolkit",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "Professional-grade AI coding toolkit: 92 skills, 44 agents, multi-platform support (Claude, Cursor, Windsurf, Copilot, Gemini, Cline, Roo Code, Aider, Augment, Google Antigravity), machine-enforced safety constitution, persona presets, skill security auditor, expanded lifecycle hooks, 11 plugin packs, and benchmark tooling.",
   "keywords": [
     "claude",

package/scripts/add_rule.py

@@ -2,8 +2,9 @@
 """add-rule -- Register a rule file in ~/.ai-toolkit/rules/.
 
 Registered rules are automatically injected into all AI tool configs
-(Claude, Cursor, Windsurf, Gemini) on next 'ai-toolkit install',
-and into project-local configs (Copilot, Cline) on 'ai-toolkit install --local'.
+on next 'ai-toolkit install' or 'ai-toolkit update':
+  Global: Claude, Cursor, Windsurf, Gemini, Augment
+  Local (--local): all of the above + Copilot, Cline, Roo, Aider, Antigravity
 
 Usage:
   add_rule.py <rule-file> [rule-name]
@@ -47,8 +48,8 @@ def main() -> None:
     print(f"Registered: '{rule_name}' -> {dest}")
     print()
     print("Apply now:")
-    print("  ai-toolkit update            # global (Claude, Cursor, Windsurf, Gemini)")
-    print("  ai-toolkit update --local    # project-local (Copilot, Cline)")
+    print("  ai-toolkit update            # global (Claude, Cursor, Windsurf, Gemini, Augment)")
+    print("  ai-toolkit update --local    # project-local (all editors)")
 
 
 if __name__ == "__main__":

package/scripts/dir_rules_shared.py

@@ -439,3 +439,99 @@ def write_rules(target_dir: Path, rules: dict[str, callable],
         (out_dir / filename).write_text(content_fn(), encoding="utf-8")
         tag = f" ({label})" if label else ""
         print(f"  Generated: {subdir}/{filename}{tag}")
+
+
+# ---------------------------------------------------------------------------
+# Language → glob patterns for editors with file-type activation
+# ---------------------------------------------------------------------------
+
+LANG_GLOBS: dict[str, list[str]] = {
+    "python": ["**/*.py"],
+    "typescript": ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"],
+    "golang": ["**/*.go"],
+    "rust": ["**/*.rs"],
+    "java": ["**/*.java"],
+    "kotlin": ["**/*.kt", "**/*.kts"],
+    "swift": ["**/*.swift"],
+    "dart": ["**/*.dart"],
+    "csharp": ["**/*.cs"],
+    "php": ["**/*.php"],
+    "cpp": ["**/*.cpp", "**/*.cc", "**/*.cxx", "**/*.hpp", "**/*.h"],
+    "ruby": ["**/*.rb"],
+}
+
+
+def _resolve_app_rules_dir() -> Path:
+    """Resolve path to app/rules/ directory."""
+    return Path(__file__).resolve().parent.parent / "app" / "rules"
+
+
+def build_language_rules(
+    language_modules: list[str] | None,
+) -> dict[str, callable]:
+    """Build language-specific rule entries from app/rules/<lang>/.
+
+    Returns dict of filename -> callable (same shape as STANDARD_RULES).
+    Language modules use format ``rules-python``, ``rules-typescript``, etc.
+    Always includes ``common`` when any language is detected.
+    """
+    if not language_modules:
+        return {}
+
+    rules_src = _resolve_app_rules_dir()
+    if not rules_src.is_dir():
+        return {}
+
+    langs: list[str] = []
+    for mod in language_modules:
+        if mod.startswith("rules-"):
+            langs.append(mod[6:])
+    if not langs:
+        return {}
+
+    all_dirs: list[str] = ["common"]
+    for lang in langs:
+        if lang not in all_dirs:
+            all_dirs.append(lang)
+
+    result: dict[str, callable] = {}
+    for lang in all_dirs:
+        lang_path = rules_src / lang
+        if not lang_path.is_dir():
+            continue
+        parts: list[str] = []
+        for f in sorted(lang_path.glob("*.md")):
+            content = f.read_text(encoding="utf-8")
+            # Strip YAML frontmatter if present
+            if content.startswith("---"):
+                end = content.find("---", 3)
+                if end != -1:
+                    content = content[end + 3:].lstrip("\n")
+            parts.append(content.rstrip("\n"))
+
+        if parts:
+            combined = "\n\n".join(parts) + "\n"
+            filename = f"{PREFIX}lang-{lang}.md"
+            # Capture value via default arg to avoid late-binding closure
+            result[filename] = (lambda c: lambda: c)(combined)
+
+    return result
+
+
+def build_registered_rules(
+    rules_dir: Path | None,
+) -> dict[str, callable]:
+    """Build entries from user's registered rules (~/.ai-toolkit/rules/*.md).
+
+    Returns dict of filename -> callable (same shape as STANDARD_RULES).
+    """
+    if not rules_dir or not rules_dir.is_dir():
+        return {}
+
+    result: dict[str, callable] = {}
+    for rule_file in sorted(rules_dir.glob("*.md")):
+        content = rule_file.read_text(encoding="utf-8")
+        filename = f"{PREFIX}custom-{rule_file.stem}.md"
+        result[filename] = (lambda c: lambda: c)(content)
+
+    return result

package/scripts/generate_aider_conf.py

@@ -18,8 +18,9 @@ def main() -> None:
     print("# Use the architect mode for complex tasks, aligned with our 2-phase workflow")
     print("architect: true")
     print()
-    print("# Read global rules ")
+    print("# Read project rules (loaded as read-only context)")
     print("read:")
+    print('  - "CONVENTIONS.md"')
     print('  - ".claude/CLAUDE.md"')
     print('  - ".claude/constitution.md"')
     print('  - "AGENTS.md"')

package/scripts/generate_antigravity.py

@@ -18,12 +18,23 @@ import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from dir_rules_shared import STANDARD_RULES, STANDARD_WORKFLOWS, write_rules
-
-
-def generate(target_dir: Path) -> None:
+from dir_rules_shared import (
+    STANDARD_RULES,
+    STANDARD_WORKFLOWS,
+    build_language_rules,
+    build_registered_rules,
+    write_rules,
+)
+
+
+def generate(target_dir: Path, *,
+             language_modules: list[str] | None = None,
+             rules_dir: Path | None = None) -> None:
     """Write .agent/rules/ and .agent/workflows/ files to target_dir."""
-    write_rules(target_dir, STANDARD_RULES, ".agent/rules")
+    rules = dict(STANDARD_RULES)
+    rules.update(build_language_rules(language_modules))
+    rules.update(build_registered_rules(rules_dir))
+    write_rules(target_dir, rules, ".agent/rules")
     write_rules(target_dir, STANDARD_WORKFLOWS, ".agent/workflows")
 
 

package/scripts/generate_augment_rules.py

@@ -3,7 +3,7 @@
 
 Augment supports per-file rules with frontmatter:
   - type: always_apply  — always in context
-  - type: auto_attached + globs — attached for matching files
+  - type: agent_requested + globs — attached for matching files
 
 The existing generate_augment.py creates a single always_apply file.
 This generator adds granular per-category rules with appropriate types.
@@ -18,7 +18,10 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from dir_rules_shared import (
+    LANG_GLOBS,
     PREFIX,
+    build_language_rules,
+    build_registered_rules,
     cleanup_stale,
     rule_agents_and_skills,
     rule_code_style,
@@ -69,7 +72,7 @@ def _make_rules() -> dict[str, callable]:
         f"{PREFIX}code-style.md": lambda: _augment_wrap(
             rule_code_style(),
             description="Code style conventions",
-            rule_type="auto_attached",
+            rule_type="agent_requested",
             globs=["*.py", "*.ts", "*.tsx", "*.js", "*.jsx", "*.go", "*.rs",
                    "*.java", "*.kt", "*.swift", "*.dart", "*.cs", "*.php",
                    "*.cpp", "*.cc", "*.rb"],
@@ -77,7 +80,7 @@ def _make_rules() -> dict[str, callable]:
         f"{PREFIX}testing.md": lambda: _augment_wrap(
             rule_testing(),
             description="Testing standards and patterns",
-            rule_type="auto_attached",
+            rule_type="agent_requested",
             globs=["*.test.*", "*.spec.*", "test_*", "**/tests/**",
                    "**/test/**", "**/__tests__/**"],
         ),
@@ -87,14 +90,45 @@ def _make_rules() -> dict[str, callable]:
 RULES = _make_rules()
 
 
-def generate(target_dir: Path) -> None:
+def generate(target_dir: Path, *,
+             language_modules: list[str] | None = None,
+             rules_dir: Path | None = None) -> None:
     """Write .augment/rules/ai-toolkit-*.md files to target_dir."""
-    rules_dir = target_dir / ".augment" / "rules"
-    rules_dir.mkdir(parents=True, exist_ok=True)
-    cleanup_stale(rules_dir, set(RULES.keys()) | {"ai-toolkit.md"})
-
-    for filename, content_fn in RULES.items():
-        (rules_dir / filename).write_text(content_fn(), encoding="utf-8")
+    out_dir = target_dir / ".augment" / "rules"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    all_rules: dict[str, callable] = dict(RULES)
+
+    # Add language rules with Augment frontmatter
+    for filename, content_fn in build_language_rules(language_modules).items():
+        lang = filename.removeprefix(f"{PREFIX}lang-").removesuffix(".md")
+        globs = LANG_GLOBS.get(lang)
+        if globs:
+            all_rules[filename] = (lambda fn, l, g: lambda: _augment_wrap(
+                fn(),
+                description=f"{l.title()} language rules",
+                rule_type="agent_requested",
+                globs=g,
+            ))(content_fn, lang, globs)
+        else:
+            # common — always apply
+            all_rules[filename] = (lambda fn, l: lambda: _augment_wrap(
+                fn(),
+                description=f"{l.title()} language rules",
+            ))(content_fn, lang)
+
+    # Add registered rules with Augment frontmatter
+    for filename, content_fn in build_registered_rules(rules_dir).items():
+        name = filename.removeprefix(f"{PREFIX}custom-").removesuffix(".md")
+        all_rules[filename] = (lambda fn, n: lambda: _augment_wrap(
+            fn(),
+            description=f"Custom rule: {n}",
+        ))(content_fn, name)
+
+    cleanup_stale(out_dir, set(all_rules.keys()) | {"ai-toolkit.md"})
+
+    for filename, content_fn in all_rules.items():
+        (out_dir / filename).write_text(content_fn(), encoding="utf-8")
         print(f"  Generated: .augment/rules/{filename}")
 
 

package/scripts/generate_cline_rules.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-"""Generate .cline/rules/*.md files for Cline.
+"""Generate .clinerules/*.md files for Cline.
 
-Cline reads directory-based rules from .cline/rules/*.md (since Q1 2025).
-The legacy .clinerules single-file format is still generated separately
-by generate_cline.py for backwards compatibility.
+Cline reads rules from the .clinerules/ directory (since Cline 3.7).
+Each .md file inside .clinerules/ is automatically loaded.
+The legacy .clinerules single-file format is replaced by this directory.
 
 Usage:
   python3 scripts/generate_cline_rules.py [target-dir]
@@ -14,12 +14,27 @@ 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 .cline/rules/*.md files to target_dir."""
-    write_rules(target_dir, STANDARD_RULES, ".cline/rules")
+from dir_rules_shared import (
+    STANDARD_RULES,
+    build_language_rules,
+    build_registered_rules,
+    write_rules,
+)
+
+
+def generate(target_dir: Path, *,
+             language_modules: list[str] | None = None,
+             rules_dir: Path | None = None) -> None:
+    """Write .clinerules/*.md files to target_dir."""
+    # Migrate: if .clinerules exists as a single file, remove it
+    # so the directory can be created (Cline 3.7+ uses directory format)
+    clinerules = target_dir / ".clinerules"
+    if clinerules.is_file():
+        clinerules.unlink()
+    rules = dict(STANDARD_RULES)
+    rules.update(build_language_rules(language_modules))
+    rules.update(build_registered_rules(rules_dir))
+    write_rules(target_dir, rules, ".clinerules")
 
 
 def main() -> None:

package/scripts/generate_cursor_mdc.py

@@ -20,7 +20,10 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from dir_rules_shared import (
+    LANG_GLOBS,
     PREFIX,
+    build_language_rules,
+    build_registered_rules,
     cleanup_stale,
     rule_agents_and_skills,
     rule_code_style,
@@ -100,21 +103,47 @@ RULES = _make_rules()
 # Main
 # ---------------------------------------------------------------------------
 
-def generate(target_dir: Path) -> None:
+def generate(target_dir: Path, *,
+             language_modules: list[str] | None = None,
+             rules_dir: Path | None = None) -> None:
     """Write .cursor/rules/*.mdc files to target_dir."""
-    rules_dir = target_dir / ".cursor" / "rules"
-    rules_dir.mkdir(parents=True, exist_ok=True)
+    out_dir = target_dir / ".cursor" / "rules"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    all_rules: dict[str, callable] = dict(RULES)
+
+    # Add language rules wrapped in .mdc frontmatter
+    for filename, content_fn in build_language_rules(language_modules).items():
+        lang = filename.removeprefix(f"{PREFIX}lang-").removesuffix(".md")
+        globs = LANG_GLOBS.get(lang)
+        mdc_name = filename.replace(".md", ".mdc")
+        all_rules[mdc_name] = (lambda fn, l, g: lambda: _mdc(
+            fn(),
+            description=f"{l.title()} language rules",
+            globs=g if g else None,
+            always_apply=not g,
+        ))(content_fn, lang, globs)
+
+    # Add registered rules wrapped in .mdc frontmatter
+    for filename, content_fn in build_registered_rules(rules_dir).items():
+        name = filename.removeprefix(f"{PREFIX}custom-").removesuffix(".md")
+        mdc_name = filename.replace(".md", ".mdc")
+        all_rules[mdc_name] = (lambda fn, n: lambda: _mdc(
+            fn(),
+            description=f"Custom rule: {n}",
+            always_apply=True,
+        ))(content_fn, name)
 
     # Clean stale ai-toolkit-*.mdc files
-    current = set(RULES.keys())
-    if rules_dir.is_dir():
-        for f in rules_dir.iterdir():
+    current = set(all_rules.keys())
+    if out_dir.is_dir():
+        for f in out_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")
+    for filename, content_fn in all_rules.items():
+        (out_dir / filename).write_text(content_fn(), encoding="utf-8")
         print(f"  Generated: .cursor/rules/{filename}")
 
 

package/scripts/generate_roo_rules.py

@@ -13,12 +13,22 @@ import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from dir_rules_shared import STANDARD_RULES, write_rules
+from dir_rules_shared import (
+    STANDARD_RULES,
+    build_language_rules,
+    build_registered_rules,
+    write_rules,
+)
 
 
-def generate(target_dir: Path) -> None:
+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."""
-    write_rules(target_dir, STANDARD_RULES, ".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")
 
 
 def main() -> None:

package/scripts/generate_windsurf_rules.py

@@ -14,12 +14,22 @@ import sys
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from dir_rules_shared import STANDARD_RULES, write_rules
+from dir_rules_shared import (
+    STANDARD_RULES,
+    build_language_rules,
+    build_registered_rules,
+    write_rules,
+)
 
 
-def generate(target_dir: Path) -> None:
+def generate(target_dir: Path, *,
+             language_modules: list[str] | None = None,
+             rules_dir: Path | None = None) -> None:
     """Write .windsurf/rules/*.md files to target_dir."""
-    write_rules(target_dir, STANDARD_RULES, ".windsurf/rules")
+    rules = dict(STANDARD_RULES)
+    rules.update(build_language_rules(language_modules))
+    rules.update(build_registered_rules(rules_dir))
+    write_rules(target_dir, rules, ".windsurf/rules")
 
 
 def main() -> None:

package/scripts/install_steps/ai_tools.py

@@ -136,7 +136,6 @@ _EDITOR_MARKERS: dict[str, str] = {
     ".windsurfrules": "windsurf",
     ".windsurf/rules": "windsurf",
     ".clinerules": "cline",
-    ".cline/rules": "cline",
     ".roomodes": "roo",
     ".roo/rules": "roo",
     ".aider.conf.yml": "aider",
@@ -228,7 +227,8 @@ def install_local_project(rules_dir: Path, dry_run: bool, reset: bool,
     _inject_language_rules(cwd, language_modules)
 
     # Install editor configs only for resolved editors
-    _create_local_ai_tool_configs(cwd, rules_dir, resolved_editors)
+    _create_local_ai_tool_configs(cwd, rules_dir, resolved_editors,
+                                  language_modules=language_modules)
 
 
 def _inject_language_rules(cwd: Path, language_modules: list[str] | None) -> None:
@@ -308,7 +308,7 @@ def _install_local_dry_run(reset: bool, editors: list[str] | None = None) -> Non
         "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",
+        "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",
@@ -396,7 +396,8 @@ def _create_local_settings(cwd: Path, reset: bool) -> None:
 
 
 def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
-                                   editors: list[str]) -> None:
+                                   editors: list[str],
+                                   language_modules: list[str] | None = None) -> None:
     eds = set(editors)
 
     if "copilot" in eds:
@@ -413,7 +414,8 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
             rules_dir,
         )
         from generate_cursor_mdc import generate as gen_cursor_mdc
-        gen_cursor_mdc(cwd)
+        gen_cursor_mdc(cwd, language_modules=language_modules,
+                       rules_dir=rules_dir)
 
     if "windsurf" in eds:
         inject_with_rules(
@@ -422,23 +424,26 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
             rules_dir,
         )
         from generate_windsurf_rules import generate as gen_windsurf_rules
-        gen_windsurf_rules(cwd)
+        gen_windsurf_rules(cwd, language_modules=language_modules,
+                           rules_dir=rules_dir)
 
     if "cline" in eds:
-        inject_with_rules(
-            "generate-cline.sh",
-            cwd / ".clinerules",
-            rules_dir,
-        )
+        # Migrate: remove legacy .clinerules single file (replaced by directory)
+        legacy_clinerules = cwd / ".clinerules"
+        if legacy_clinerules.is_file():
+            legacy_clinerules.unlink()
+            print("  Migrated: .clinerules file → .clinerules/ directory")
         from generate_cline_rules import generate as gen_cline_rules
-        gen_cline_rules(cwd)
+        gen_cline_rules(cwd, language_modules=language_modules,
+                        rules_dir=rules_dir)
 
     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)
+        gen_roo_rules(cwd, language_modules=language_modules,
+                      rules_dir=rules_dir)
 
     if "aider" in eds:
         aider_output = run_script("generate-aider-conf.sh", capture=True)
@@ -448,10 +453,12 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
 
     if "augment" in eds:
         from generate_augment_rules import generate as gen_augment_rules
-        gen_augment_rules(cwd)
+        gen_augment_rules(cwd, language_modules=language_modules,
+                          rules_dir=rules_dir)
 
     if "antigravity" in eds:
         from generate_antigravity import generate as gen_antigravity
-        gen_antigravity(cwd)
+        gen_antigravity(cwd, language_modules=language_modules,
+                        rules_dir=rules_dir)
 
     run_script("install-git-hooks.sh", str(cwd))

package/scripts/validate.py

@@ -46,6 +46,7 @@ VALID_HOOK_EVENTS = frozenset({
 
 VALID_KB_CATEGORIES = frozenset({
     "reference", "howto", "procedures", "troubleshooting", "best-practices",
+    "planning",
 })
 
 PLANNED_ASSETS = [