chore: converting claude code to agent skills

Ramraj Bishnoie · Ramraj Bishnoie · commit e0cde0ddbcef · 2026-01-16T16:20:03.000-05:00
diff --git a/README.md b/README.md
@@ -54,7 +54,7 @@ Get started in minutes:
 ## How It Works
 
 1. **Security rules** are written in unified markdown format (`sources/` directory)
-2. **Conversion tools** translate rules to IDE-specific formats (Cursor, Windsurf, Copilot, Claude Code, Antigravity)
+2. **Conversion tools** translate rules to IDE-specific formats (Cursor, Windsurf, Copilot, Agent Skills, Antigravity)
 3. **Release automation** packages rules into downloadable ZIP files
 4. **AI assistants** reference these rules when generating or reviewing code
 5. **Secure code** is produced automatically without developer intervention
@@ -63,7 +63,7 @@ Get started in minutes:
 
 ```
 sources/           # Source rules
-skills/            # Claude Code plugin (generated, committed)
+skills/            # Agent Skills format (generated, committed)
 src/               # Conversion and validation tools
 dist/              # Other IDE bundles (generated, not committed)
 ```
diff --git a/src/convert_to_ide_formats.py b/src/convert_to_ide_formats.py
@@ -6,8 +6,8 @@
 Convert Unified Rules to IDE Formats
 
 Transforms the unified markdown sources into IDE-specific bundles (Cursor,
-Windsurf, Copilot, Claude Code). This script is the main entry point for producing
-distributable rule packs from the sources/ directory.
+Windsurf, Copilot, Agent Skills, Antigravity). This script is the main entry point
+for producing distributable rule packs from the sources/ directory.
 """
 
 import re
@@ -16,7 +16,13 @@
 from collections import defaultdict
 
 from converter import RuleConverter
-from formats import CursorFormat, WindsurfFormat, CopilotFormat, ClaudeCodeFormat, AntigravityFormat
+from formats import (
+    CursorFormat,
+    WindsurfFormat,
+    CopilotFormat,
+    AgentSkillsFormat,
+    AntigravityFormat,
+)
 from utils import get_version_from_pyproject
 from validate_versions import set_plugin_version, set_marketplace_version
 
@@ -26,7 +32,7 @@
 
 def sync_plugin_metadata(version: str) -> None:
     """
-    Sync version from pyproject.toml to Claude Code plugin metadata files.
+    Sync version from pyproject.toml to Agent Skills metadata files.
 
     Args:
         version: Version string from pyproject.toml
@@ -39,17 +45,17 @@ def sync_plugin_metadata(version: str) -> None:
 def matches_tag_filter(rule_tags: list[str], filter_tags: list[str]) -> bool:
     """
     Check if rule has all required tags (AND logic).
-    
+
     Args:
         rule_tags: List of tags from the rule (already normalized to lowercase)
         filter_tags: List of tags to filter by (already normalized to lowercase)
-    
+
     Returns:
         True if rule has all filter tags (or no filter), False otherwise
     """
     if not filter_tags:
         return True  # No filter means all pass
-    
+
     return all(tag in rule_tags for tag in filter_tags)
 
 
@@ -98,14 +104,20 @@ def update_skill_md(language_to_rules: dict[str, list[str]], skill_path: str) ->
     print(f"Updated SKILL.md with language mappings")
 
 
-def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode: bool = True, version: str = None, filter_tags: list[str] = None) -> dict[str, list[str]]:
+def convert_rules(
+    input_path: str,
+    output_dir: str = "dist",
+    include_agentskills: bool = True,
+    version: str = None,
+    filter_tags: list[str] = None,
+) -> dict[str, list[str]]:
     """
     Convert rule file(s) to all supported IDE formats using RuleConverter.
 
     Args:
         input_path: Path to a single .md file or folder containing .md files
         output_dir: Output directory (default: 'dist/')
-        include_claudecode: Whether to generate Claude Code plugin (default: True, only for core rules)
+        include_agentskills: Whether to generate Agent Skills format (default: True, only for core rules)
         version: Version string to use (default: read from pyproject.toml)
         filter_tags: Optional list of tags to filter by (AND logic, case-insensitive)
 
@@ -117,7 +129,7 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
         }
 
     Example:
-        results = convert_rules("sources/core", "dist", include_claudecode=True)
+        results = convert_rules("sources/core", "dist", include_agentskills=True)
         print(f"Converted {len(results['success'])} rules")
     """
     if version is None:
@@ -130,10 +142,10 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
         CopilotFormat(version),
         AntigravityFormat(version),
     ]
-    
-    # Only include Claude Code for core rules (committed plugin)
-    if include_claudecode:
-        all_formats.append(ClaudeCodeFormat(version))
+
+    # Only include Agent Skills format for core rules (committed as skills)
+    if include_agentskills:
+        all_formats.append(AgentSkillsFormat(version))
 
     converter = RuleConverter(formats=all_formats)
     path = Path(input_path)
@@ -151,7 +163,7 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
         md_files = sorted(list(path.rglob("*.md")))
         if not md_files:
             raise ValueError(f"No .md files found in {input_path}")
-    
+
     print(f"Converting {len(md_files)} files from: {path}")
 
     # Setup output directory
@@ -165,7 +177,7 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
         try:
             # Convert the file (raises exceptions on error)
             result = converter.convert(md_file)
-            
+
             # Apply tag filter if specified
             if filter_tags and not matches_tag_filter(result.tags, filter_tags):
                 results["skipped"].append(result.filename)
@@ -175,17 +187,15 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
             output_files = []
             for format_name, output in result.outputs.items():
                 # Construct output path
-                # Claude Code goes to project root ./skills/
+                # Agent Skills goes to project root ./skills/
                 # Other formats go to dist/ (or specified output_dir)
-                if format_name == "claudecode":
+                if format_name == "agentskills":
                     base_dir = PROJECT_ROOT
                 else:
                     base_dir = output_base
-                
+
                 output_file = (
-                    base_dir
-                    / output.subpath
-                    / f"{result.basename}{output.extension}"
+                    base_dir / output.subpath / f"{result.basename}{output.extension}"
                 )
 
                 # Create directory if it doesn't exist and write file
@@ -225,30 +235,32 @@ def convert_rules(input_path: str, output_dir: str = "dist", include_claudecode:
             f"\nResults: {len(results['success'])} success, {len(results['errors'])} errors"
         )
 
-    # Generate SKILL.md with language mappings (only if Claude Code is included)
-    if include_claudecode and language_to_rules:
-        template_path = PROJECT_ROOT / "sources" / "core" / "codeguard-SKILLS.md.template"
-        
+    # Generate SKILL.md with language mappings (only if Agent Skills is included)
+    if include_agentskills and language_to_rules:
+        template_path = (
+            PROJECT_ROOT / "sources" / "core" / "codeguard-SKILLS.md.template"
+        )
+
         if not template_path.exists():
             raise FileNotFoundError(
                 f"SKILL.md template not found at {template_path}. "
-                "This file is required for Claude Code plugin generation."
+                "This file is required for Agent Skills generation."
             )
-        
+
         output_skill_dir = PROJECT_ROOT / "skills" / "software-security"
         output_skill_dir.mkdir(parents=True, exist_ok=True)
         output_skill_path = output_skill_dir / "SKILL.md"
-        
+
         # Read template and inject current version from pyproject.toml
         template_content = template_path.read_text(encoding="utf-8")
         # Replace the hardcoded version with actual version
         template_content = re.sub(
             r'codeguard-version:\s*"[^"]*"',
             f'codeguard-version: "{version}"',
-            template_content
+            template_content,
         )
         output_skill_path.write_text(template_content, encoding="utf-8")
-        
+
         update_skill_md(language_to_rules, str(output_skill_path))
 
     return results
@@ -262,15 +274,15 @@ def _resolve_source_paths(args) -> list[Path]:
     # If --source flags provided, resolve under sources/
     if args.source:
         return [Path("sources") / src for src in args.source]
-    
+
     # Default: core rules only
     return [Path("sources/core")]
 
 
 if __name__ == "__main__":
     import sys
     from argparse import ArgumentParser
-    
+
     parser = ArgumentParser(
         description="Convert unified rule markdown into IDE-specific bundles."
     )
@@ -291,7 +303,7 @@ def _resolve_source_paths(args) -> list[Path]:
         dest="tags",
         help="Filter rules by tags (comma-separated, case-insensitive, AND logic). Example: --tag api,web-security",
     )
-    
+
     cli_args = parser.parse_args()
     source_paths = _resolve_source_paths(cli_args)
 
@@ -307,27 +319,31 @@ def _resolve_source_paths(args) -> list[Path]:
         for source_path in source_paths:
             for md_file in source_path.rglob("*.md"):
                 filename_to_sources[md_file.name].append(source_path.name)
-        
-        duplicates = {name: srcs for name, srcs in filename_to_sources.items() if len(srcs) > 1}
+
+        duplicates = {
+            name: srcs for name, srcs in filename_to_sources.items() if len(srcs) > 1
+        }
         if duplicates:
             print(f"❌ Found {len(duplicates)} duplicate filename(s) across sources:")
             for filename, sources in duplicates.items():
                 print(f"   - {filename} in: {', '.join(sources)}")
             print("\nPlease rename files to have unique names across all sources.")
             sys.exit(1)
-    
+
     # Get version once and sync to metadata files
     version = get_version_from_pyproject()
     sync_plugin_metadata(version)
 
-    # Check if core is in the sources for Claude Code plugin generation
+    # Check if core is in the sources for Agent Skills generation
     has_core = Path("sources/core") in source_paths
     if has_core:
         # Validate template exists early
-        template_path = PROJECT_ROOT / "sources" / "core" / "codeguard-SKILLS.md.template"
+        template_path = (
+            PROJECT_ROOT / "sources" / "core" / "codeguard-SKILLS.md.template"
+        )
         if not template_path.exists():
             print(f"❌ SKILL.md template not found at {template_path}")
-            print("This file is required for Claude Code plugin generation.")
+            print("This file is required for Agent Skills generation.")
             sys.exit(1)
 
     # Clean output directories once before processing
@@ -341,46 +357,50 @@ def _resolve_source_paths(args) -> list[Path]:
         if skills_rules_dir.exists():
             shutil.rmtree(skills_rules_dir)
             print(f"✅ Cleaned skills/ directory")
-    
+
     # Print processing summary
     if len(source_paths) > 1:
-        sources_list = ', '.join(p.name for p in source_paths)
+        sources_list = ", ".join(p.name for p in source_paths)
         print(f"\nConverting {len(source_paths)} sources: {sources_list}")
         if has_core:
-            print("(Claude Code plugin will include only core rules)")
+            print("(Agent Skills will include only core rules)")
         print()
-    
+
     # Convert all sources
     aggregated = {"success": [], "errors": [], "skipped": []}
     # Parse comma-separated tags and normalize to lowercase
     filter_tags = None
     if cli_args.tags:
-        filter_tags = [tag.strip().lower() for tag in cli_args.tags.split(",") if tag.strip()]
-    
+        filter_tags = [
+            tag.strip().lower() for tag in cli_args.tags.split(",") if tag.strip()
+        ]
+
     # Print tag filter info if active
     if filter_tags:
-        print(f"Tag filter active: {', '.join(filter_tags)} (AND logic - rules must have all tags)\n")
-    
+        print(
+            f"Tag filter active: {', '.join(filter_tags)} (AND logic - rules must have all tags)\n"
+        )
+
     for source_path in source_paths:
         is_core = source_path == Path("sources/core")
-        
+
         print(f"Processing: {source_path}")
         results = convert_rules(
-            str(source_path), 
-            cli_args.output_dir, 
-            include_claudecode=is_core,
+            str(source_path),
+            cli_args.output_dir,
+            include_agentskills=is_core,
             version=version,
-            filter_tags=filter_tags
+            filter_tags=filter_tags,
         )
-        
+
         aggregated["success"].extend(results["success"])
         aggregated["errors"].extend(results["errors"])
         if "skipped" in results:
             aggregated["skipped"].extend(results["skipped"])
         print("")
-    
+
     if aggregated["errors"]:
         print("❌ Some conversions failed")
         sys.exit(1)
-    
+
     print("✅ All conversions successful")
diff --git a/src/formats/__init__.py b/src/formats/__init__.py
@@ -11,7 +11,8 @@
 - CursorFormat: Generates .mdc files for Cursor IDE
 - WindsurfFormat: Generates .md files for Windsurf IDE
 - CopilotFormat: Generates .instructions.md files for GitHub Copilot
-- ClaudeCodeFormat: Generates .md files for Claude Code plugins
+- AgentSkillsFormat: Generates .md files for Agent Skills (OpenAI Codex, Claude Code, other AI coding tools)
+- AntigravityFormat: Generates .md files for Google Antigravity
 
 Usage:
     from formats import BaseFormat, ProcessedRule, CursorFormat, WindsurfFormat, CopilotFormat, ClaudeCodeFormat
@@ -21,15 +22,16 @@
         CursorFormat(version),
         WindsurfFormat(version),
         CopilotFormat(version),
-        ClaudeCodeFormat(version),
+        AgentSkillsFormat(version),
+        AntigravityFormat(version),
     ]
 """
 
 from formats.base import BaseFormat, ProcessedRule
 from formats.cursor import CursorFormat
 from formats.windsurf import WindsurfFormat
 from formats.copilot import CopilotFormat
-from formats.claudecode import ClaudeCodeFormat
+from formats.agentskills import AgentSkillsFormat
 from formats.antigravity import AntigravityFormat
 
 __all__ = [
@@ -38,6 +40,6 @@
     "CursorFormat",
     "WindsurfFormat",
     "CopilotFormat",
-    "ClaudeCodeFormat",
+    "AgentSkillsFormat",
     "AntigravityFormat",
 ]
diff --git a/src/formats/agentskills.py b/src/formats/agentskills.py
