@softspark/ai-toolkit 1.5.0 → 1.6.0

package/llms.txt

@@ -14,7 +14,12 @@
 - [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)
 - [Agents Catalog](kb/reference/agents-catalog.md)
 - [Anti-Pattern Registry Format](kb/reference/anti-pattern-registry-format.md)

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.0",
+  "version": "1.6.0",
   "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.0",
+  "version": "1.6.0",
   "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/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_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

@@ -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,
@@ -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="auto_attached",
+                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

@@ -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 .cline/rules/*.md files to target_dir."""
-    write_rules(target_dir, STANDARD_RULES, ".cline/rules")
+    rules = dict(STANDARD_RULES)
+    rules.update(build_language_rules(language_modules))
+    rules.update(build_registered_rules(rules_dir))
+    write_rules(target_dir, rules, ".cline/rules")
 
 
 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

@@ -228,7 +228,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:
@@ -396,7 +397,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 +415,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,7 +425,8 @@ 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(
@@ -431,14 +435,16 @@ def _create_local_ai_tool_configs(cwd: Path, rules_dir: Path,
             rules_dir,
         )
         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 +454,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 = [