@intentsolutionsio/nosql-data-modeler 1.0.0 → 1.0.6

package/agents/nosql-agent.md

@@ -1,6 +1,34 @@
 ---
 name: nosql-agent
 description: Design NoSQL data models
+tools:
+- Read
+- Write
+- Edit
+- Bash
+- Glob
+- Grep
+- WebFetch
+- WebSearch
+- Task
+- TodoWrite
+model: sonnet
+color: purple
+version: 1.0.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+tags:
+- database
+- nosql
+disallowedTools: []
+skills: []
+background: false
+# ── upgrade levers — uncomment + set when tuning this agent ──
+# effort: high            # reasoning depth: low/medium/high/xhigh/max (omit = inherit session)
+# maxTurns: 50            # cap the agentic loop (omit = engine default)
+# memory: project         # persistent scope: user/project/local (omit = ephemeral)
+# isolation: worktree     # run in an isolated git worktree
+# initialPrompt: "…"      # seed the agent's first turn
+# hooks / mcpServers / permissionMode → set at the PLUGIN level, not on a plugin agent
 ---
 # NoSQL Data Modeler
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentsolutionsio/nosql-data-modeler",
-  "version": "1.0.0",
+  "version": "1.0.6",
   "description": "Database plugin for nosql-data-modeler",
   "keywords": [
     "database",

package/skills/modeling-nosql-data/SKILL.md

@@ -1,17 +1,22 @@
 ---
 name: modeling-nosql-data
-description: |
-  Build use when you need to work with NoSQL data modeling.
+description: 'Build use when you need to work with NoSQL data modeling.
+
   This skill provides NoSQL database design with comprehensive guidance and automation.
+
   Trigger with phrases like "model NoSQL data", "design document structure",
+
   or "optimize NoSQL schema".
 
+  '
 allowed-tools: Read, Write, Edit, Grep, Glob, Bash(psql:*), Bash(mysql:*), Bash(mongosh:*)
 version: 1.0.0
 author: Jeremy Longshore <jeremy@intentsolutions.io>
 license: MIT
-compatible-with: claude-code, codex, openclaw
-tags: [database, modeling-nosql]
+tags:
+- database
+- modeling-nosql
+compatibility: Designed for Claude Code, also compatible with Codex and OpenClaw
 ---
 # NoSQL Data Modeler
 
@@ -81,6 +86,6 @@ Design data models for NoSQL databases including MongoDB (document), DynamoDB (k
 
 - MongoDB data modeling patterns: https://www.mongodb.com/docs/manual/data-modeling/
 - DynamoDB single-table design: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-modeling-nosql.html
-- Cassandra data modeling guide: https://cassandra.apache.org/doc/latest/cassandra/data_modeling/
+- Cassandra data modeling guide:
 - Redis data structures: https://redis.io/docs/data-types/
-- NoSQL design patterns catalog: https://www.mongodb.com/docs/manual/applications/data-models/
+- NoSQL design patterns catalog:

package/skills/modeling-nosql-data/references/README.md

@@ -1,4 +1,3 @@
 # References
 
 Bundled resources for nosql-data-modeler skill
-

package/skills/modeling-nosql-data/scripts/generate_sample_data.py

@@ -11,8 +11,7 @@ import json
 import random
 import sys
 from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Dict, List, Any, Union
+from typing import Dict, List, Any
 from uuid import uuid4
 
 
@@ -79,10 +78,7 @@ class SampleDataGenerator:
             count = random.randint(min_items, max_items)
 
             if "items" in field_def:
-                return [
-                    SampleDataGenerator.generate_value(field_def["items"])
-                    for _ in range(count)
-                ]
+                return [SampleDataGenerator.generate_value(field_def["items"]) for _ in range(count)]
             else:
                 return [f"item{i}" for i in range(count)]
 
@@ -147,7 +143,7 @@ class SampleDataGenerator:
             True if successful, False otherwise
         """
         try:
-            with open(filepath, 'w') as f:
+            with open(filepath, "w") as f:
                 json.dump(self.generated_data, f, indent=2)
             return True
         except Exception as e:
@@ -165,9 +161,9 @@ class SampleDataGenerator:
             True if successful, False otherwise
         """
         try:
-            with open(filepath, 'w') as f:
+            with open(filepath, "w") as f:
                 for doc in self.generated_data:
-                    f.write(json.dumps(doc) + '\n')
+                    f.write(json.dumps(doc) + "\n")
             return True
         except Exception as e:
             print(f"Error exporting JSONL: {e}", file=sys.stderr)
@@ -200,7 +196,7 @@ class SampleDataGenerator:
 
             all_keys = sorted(list(all_keys))
 
-            with open(filepath, 'w', newline='') as f:
+            with open(filepath, "w", newline="") as f:
                 writer = csv.DictWriter(f, fieldnames=all_keys)
                 writer.writeheader()
                 writer.writerows(flattened)
@@ -210,7 +206,7 @@ class SampleDataGenerator:
             print(f"Error exporting CSV: {e}", file=sys.stderr)
             return False
 
-    def _flatten_dict(self, d: Dict, parent_key: str = '', sep: str = '.') -> Dict:
+    def _flatten_dict(self, d: Dict, parent_key: str = "", sep: str = ".") -> Dict:
         """
         Flatten nested dictionary.
 
@@ -252,7 +248,7 @@ def load_schema(filepath: str) -> Dict[str, Any]:
         json.JSONDecodeError: If file is not valid JSON
     """
     try:
-        with open(filepath, 'r') as f:
+        with open(filepath, "r") as f:
             return json.load(f)
     except FileNotFoundError:
         print(f"Error: Schema file not found: {filepath}", file=sys.stderr)
@@ -280,45 +276,16 @@ Examples:
 
   # Print to stdout
   %(prog)s --schema schema.json --count 5 --print
-        """
+        """,
     )
 
-    parser.add_argument(
-        "--schema",
-        required=True,
-        help="Path to JSON schema file"
-    )
-    parser.add_argument(
-        "--count",
-        type=int,
-        default=10,
-        help="Number of sample documents to generate (default: 10)"
-    )
-    parser.add_argument(
-        "--format",
-        default="json",
-        choices=["json", "jsonl", "csv"],
-        help="Output format"
-    )
-    parser.add_argument(
-        "--output",
-        help="Output file path"
-    )
-    parser.add_argument(
-        "--print",
-        action="store_true",
-        help="Print generated data to stdout"
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        help="Random seed for reproducible data"
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Print detailed output"
-    )
+    parser.add_argument("--schema", required=True, help="Path to JSON schema file")
+    parser.add_argument("--count", type=int, default=10, help="Number of sample documents to generate (default: 10)")
+    parser.add_argument("--format", default="json", choices=["json", "jsonl", "csv"], help="Output format")
+    parser.add_argument("--output", help="Output file path")
+    parser.add_argument("--print", action="store_true", help="Print generated data to stdout")
+    parser.add_argument("--seed", type=int, help="Random seed for reproducible data")
+    parser.add_argument("--verbose", action="store_true", help="Print detailed output")
 
     args = parser.parse_args()
 

package/skills/modeling-nosql-data/scripts/migrate_schema.py

@@ -9,9 +9,7 @@ This script converts schema definitions between different NoSQL database formats
 import argparse
 import json
 import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Any, Optional, Tuple
+from typing import Dict, List, Any
 
 
 class SchemaTransformer:
@@ -30,8 +28,8 @@ class SchemaTransformer:
                 "date": "date",
                 "object": "object",
                 "array": "array",
-                "null": "null"
-            }
+                "null": "null",
+            },
         },
         "dynamodb": {
             "name": "DynamoDB",
@@ -44,8 +42,8 @@ class SchemaTransformer:
                 "date": "S",
                 "object": "M",
                 "array": "L",
-                "binary": "B"
-            }
+                "binary": "B",
+            },
         },
         "firestore": {
             "name": "Firestore",
@@ -58,8 +56,8 @@ class SchemaTransformer:
                 "date": "timestampValue",
                 "object": "mapValue",
                 "array": "arrayValue",
-                "null": "nullValue"
-            }
+                "null": "nullValue",
+            },
         },
         "cosmosdb": {
             "name": "Azure Cosmos DB",
@@ -71,9 +69,9 @@ class SchemaTransformer:
                 "boolean": "boolean",
                 "date": "date",
                 "object": "object",
-                "array": "array"
-            }
-        }
+                "array": "array",
+            },
+        },
     }
 
     def __init__(self, source_type: str, target_type: str):
@@ -129,7 +127,7 @@ class SchemaTransformer:
         parsed = {
             "name": schema.get("$id", schema.get("title", "Schema")),
             "description": schema.get("description", ""),
-            "fields": {}
+            "fields": {},
         }
 
         # Extract fields based on source type
@@ -158,7 +156,7 @@ class SchemaTransformer:
                 "type": field_def.get("type", "string"),
                 "description": field_def.get("description", ""),
                 "required": "required" in str(field_def),
-                "indexed": field_def.get("indexed", False)
+                "indexed": field_def.get("indexed", False),
             }
 
         return fields
@@ -172,7 +170,7 @@ class SchemaTransformer:
             for attr in schema["AttributeDefinitions"]:
                 fields[attr["AttributeName"]] = {
                     "type": self._map_dynamodb_type(attr["AttributeType"]),
-                    "required": attr["AttributeName"] in schema.get("KeySchema", [])
+                    "required": attr["AttributeName"] in schema.get("KeySchema", []),
                 }
 
         return fields
@@ -184,10 +182,7 @@ class SchemaTransformer:
         if "fields" in schema:
             for field_name, field_def in schema["fields"].items():
                 field_type = self._extract_firestore_type(field_def)
-                fields[field_name] = {
-                    "type": field_type,
-                    "indexed": field_def.get("indexed", False)
-                }
+                fields[field_name] = {"type": field_type, "indexed": field_def.get("indexed", False)}
 
         return fields
 
@@ -211,7 +206,7 @@ class SchemaTransformer:
         for field_name, field_info in parsed["fields"].items():
             properties[field_name] = {
                 "type": field_info.get("type", "string"),
-                "description": field_info.get("description", "")
+                "description": field_info.get("description", ""),
             }
 
             if field_info.get("indexed"):
@@ -222,7 +217,7 @@ class SchemaTransformer:
             "$id": parsed["name"],
             "title": parsed["name"],
             "type": "object",
-            "properties": properties
+            "properties": properties,
         }
 
         return schema
@@ -235,18 +230,13 @@ class SchemaTransformer:
             field_type = field_info.get("type", "string")
             dynamo_type = self._map_type_to_dynamodb(field_type)
 
-            attributes.append({
-                "AttributeName": field_name,
-                "AttributeType": dynamo_type
-            })
+            attributes.append({"AttributeName": field_name, "AttributeType": dynamo_type})
 
         schema = {
             "TableName": parsed["name"],
             "AttributeDefinitions": attributes,
-            "KeySchema": [
-                {"AttributeName": "id", "KeyType": "HASH"}
-            ],
-            "BillingMode": "PAY_PER_REQUEST"
+            "KeySchema": [{"AttributeName": "id", "KeyType": "HASH"}],
+            "BillingMode": "PAY_PER_REQUEST",
         }
 
         return schema
@@ -258,17 +248,12 @@ class SchemaTransformer:
         for field_name, field_info in parsed["fields"].items():
             field_type = field_info.get("type", "string")
 
-            fields[field_name] = {
-                field_type + "Value": self._get_firestore_default(field_type)
-            }
+            fields[field_name] = {field_type + "Value": self._get_firestore_default(field_type)}
 
             if field_info.get("indexed"):
                 fields[field_name]["indexed"] = True
 
-        schema = {
-            "name": f"projects/PROJECT_ID/databases/(default)/documents/{parsed['name']}",
-            "fields": fields
-        }
+        schema = {"name": f"projects/PROJECT_ID/databases/(default)/documents/{parsed['name']}", "fields": fields}
 
         return schema
 
@@ -285,7 +270,7 @@ class SchemaTransformer:
             "boolean": "BOOL",
             "date": "S",
             "object": "M",
-            "array": "L"
+            "array": "L",
         }
         return type_map.get(source_type, "S")
 
@@ -300,7 +285,7 @@ class SchemaTransformer:
             "BS": "binary",
             "M": "object",
             "L": "array",
-            "BOOL": "boolean"
+            "BOOL": "boolean",
         }
         return type_map.get(dynamo_type, "string")
 
@@ -316,7 +301,7 @@ class SchemaTransformer:
                     "boolean": "boolean",
                     "timestamp": "date",
                     "map": "object",
-                    "array": "array"
+                    "array": "array",
                 }
                 return type_map.get(type_name, "string")
 
@@ -324,22 +309,14 @@ class SchemaTransformer:
 
     def _get_firestore_default(self, field_type: str) -> Any:
         """Get default value for Firestore field type."""
-        defaults = {
-            "string": "",
-            "number": 0,
-            "integer": 0,
-            "boolean": False,
-            "date": "",
-            "object": {},
-            "array": []
-        }
+        defaults = {"string": "", "number": 0, "integer": 0, "boolean": False, "date": "", "object": {}, "array": []}
         return defaults.get(field_type)
 
 
 def load_schema(filepath: str) -> Dict[str, Any]:
     """Load schema from JSON file."""
     try:
-        with open(filepath, 'r') as f:
+        with open(filepath, "r") as f:
             return json.load(f)
     except FileNotFoundError:
         print(f"Error: Schema file not found: {filepath}", file=sys.stderr)
@@ -360,7 +337,7 @@ def main():
         description="Migrate NoSQL schema between database types",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=f"""
-Supported database types: {', '.join(get_supported_databases())}
+Supported database types: {", ".join(get_supported_databases())}
 
 Examples:
   # MongoDB to DynamoDB
@@ -374,37 +351,15 @@ Examples:
 
   # List supported types
   %(prog)s --list-types
-        """
+        """,
     )
 
-    parser.add_argument(
-        "--from",
-        dest="source_type",
-        help="Source database type"
-    )
-    parser.add_argument(
-        "--to",
-        dest="target_type",
-        help="Target database type"
-    )
-    parser.add_argument(
-        "--schema",
-        help="Path to source schema file"
-    )
-    parser.add_argument(
-        "--output",
-        help="Output file for migrated schema"
-    )
-    parser.add_argument(
-        "--list-types",
-        action="store_true",
-        help="List supported database types"
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Print detailed output"
-    )
+    parser.add_argument("--from", dest="source_type", help="Source database type")
+    parser.add_argument("--to", dest="target_type", help="Target database type")
+    parser.add_argument("--schema", help="Path to source schema file")
+    parser.add_argument("--output", help="Output file for migrated schema")
+    parser.add_argument("--list-types", action="store_true", help="List supported database types")
+    parser.add_argument("--verbose", action="store_true", help="Print detailed output")
 
     args = parser.parse_args()
 
@@ -437,11 +392,11 @@ Examples:
 
         # Save to file if requested
         if args.output:
-            with open(args.output, 'w') as f:
+            with open(args.output, "w") as f:
                 f.write(output_json)
 
             if args.verbose:
-                print(f"✓ Schema migrated successfully", file=sys.stderr)
+                print("✓ Schema migrated successfully", file=sys.stderr)
                 print(f"✓ Saved to {args.output}", file=sys.stderr)
 
         sys.exit(0)

package/skills/modeling-nosql-data/scripts/validate_schema.py

@@ -10,8 +10,7 @@ import argparse
 import json
 import sys
 from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Any, Tuple
+from typing import Dict, List, Any
 
 
 class NoSQLSchemaValidator:
@@ -24,41 +23,41 @@ class NoSQLSchemaValidator:
             "checks": [
                 "Use camelCase or snake_case consistently",
                 "Avoid single-letter field names",
-                "Use descriptive names"
-            ]
+                "Use descriptive names",
+            ],
         },
         "indexing": {
             "rule": "Index strategy is defined",
             "checks": [
                 "Frequently queried fields are indexed",
                 "Composite indexes are defined for common queries",
-                "Index overhead is considered"
-            ]
+                "Index overhead is considered",
+            ],
         },
         "denormalization": {
             "rule": "Denormalization is used appropriately",
             "checks": [
                 "Denormalization reduces query complexity",
                 "Duplicate data is managed intentionally",
-                "Update patterns are considered"
-            ]
+                "Update patterns are considered",
+            ],
         },
         "data_types": {
             "rule": "Data types are appropriate",
             "checks": [
                 "Numeric fields use appropriate numeric types",
                 "Dates use datetime types",
-                "IDs use consistent types"
-            ]
+                "IDs use consistent types",
+            ],
         },
         "document_size": {
             "rule": "Document size is reasonable",
             "checks": [
                 "Documents don't exceed size limits (16MB for MongoDB)",
                 "Array fields don't grow unbounded",
-                "Large nested objects are avoided"
-            ]
-        }
+                "Large nested objects are avoided",
+            ],
+        },
     }
 
     # Common anti-patterns
@@ -67,38 +66,38 @@ class NoSQLSchemaValidator:
             "name": "unbounded_arrays",
             "description": "Arrays that can grow without limits",
             "severity": "high",
-            "recommendation": "Cap array size or use separate collections"
+            "recommendation": "Cap array size or use separate collections",
         },
         {
             "name": "deeply_nested",
             "description": "Deeply nested document structures (>3 levels)",
             "severity": "medium",
-            "recommendation": "Flatten structure or normalize data"
+            "recommendation": "Flatten structure or normalize data",
         },
         {
             "name": "no_indexes",
             "description": "Frequently queried fields without indexes",
             "severity": "high",
-            "recommendation": "Add indexes for query performance"
+            "recommendation": "Add indexes for query performance",
         },
         {
             "name": "inconsistent_types",
             "description": "Field with inconsistent data types across documents",
             "severity": "medium",
-            "recommendation": "Enforce schema validation or add type hints"
+            "recommendation": "Enforce schema validation or add type hints",
         },
         {
             "name": "circular_references",
             "description": "Circular document references",
             "severity": "high",
-            "recommendation": "Use one-way references or denormalization"
+            "recommendation": "Use one-way references or denormalization",
         },
         {
             "name": "missing_ids",
             "description": "Documents or arrays without ID fields",
             "severity": "high",
-            "recommendation": "Add unique IDs for referencing"
-        }
+            "recommendation": "Add unique IDs for referencing",
+        },
     ]
 
     def __init__(self):
@@ -117,7 +116,7 @@ class NoSQLSchemaValidator:
             True if successful, False otherwise
         """
         try:
-            with open(filepath, 'r') as f:
+            with open(filepath, "r") as f:
                 self.schema = json.load(f)
             return True
         except (FileNotFoundError, json.JSONDecodeError) as e:
@@ -147,12 +146,14 @@ class NoSQLSchemaValidator:
         # Check for inconsistency
         non_zero_styles = [count for count in naming_styles.values() if count > 0]
         if len(non_zero_styles) > 1:
-            issues.append({
-                "severity": "medium",
-                "type": "naming_inconsistency",
-                "message": "Inconsistent naming convention across fields",
-                "details": naming_styles
-            })
+            issues.append(
+                {
+                    "severity": "medium",
+                    "type": "naming_inconsistency",
+                    "message": "Inconsistent naming convention across fields",
+                    "details": naming_styles,
+                }
+            )
 
         return issues
 
@@ -166,21 +167,25 @@ class NoSQLSchemaValidator:
         issues = []
 
         if "indexes" not in self.schema:
-            issues.append({
-                "severity": "medium",
-                "type": "missing_indexes",
-                "message": "No indexes defined in schema",
-                "recommendation": "Define indexes for frequently queried fields"
-            })
+            issues.append(
+                {
+                    "severity": "medium",
+                    "type": "missing_indexes",
+                    "message": "No indexes defined in schema",
+                    "recommendation": "Define indexes for frequently queried fields",
+                }
+            )
         else:
             indexes = self.schema.get("indexes", [])
             if not indexes:
-                issues.append({
-                    "severity": "medium",
-                    "type": "empty_indexes",
-                    "message": "Indexes array is empty",
-                    "recommendation": "Add indexes for query optimization"
-                })
+                issues.append(
+                    {
+                        "severity": "medium",
+                        "type": "empty_indexes",
+                        "message": "Indexes array is empty",
+                        "recommendation": "Add indexes for query optimization",
+                    }
+                )
 
         return issues
 
@@ -197,23 +202,27 @@ class NoSQLSchemaValidator:
         for field, field_def in self._extract_fields(self.schema).items():
             if field_def.get("type") == "array":
                 if "max_items" not in field_def:
-                    issues.append({
-                        "severity": "high",
-                        "type": "unbounded_array",
-                        "field": field,
-                        "message": f"Array field '{field}' has no maximum size limit",
-                        "recommendation": "Set max_items or use separate collection"
-                    })
+                    issues.append(
+                        {
+                            "severity": "high",
+                            "type": "unbounded_array",
+                            "field": field,
+                            "message": f"Array field '{field}' has no maximum size limit",
+                            "recommendation": "Set max_items or use separate collection",
+                        }
+                    )
 
         # Check for deeply nested structures
         depth = self._calculate_nesting_depth(self.schema)
         if depth > 3:
-            issues.append({
-                "severity": "medium",
-                "type": "deeply_nested",
-                "message": f"Document nesting depth is {depth} levels (recommended: ≤3)",
-                "recommendation": "Flatten structure or normalize data"
-            })
+            issues.append(
+                {
+                    "severity": "medium",
+                    "type": "deeply_nested",
+                    "message": f"Document nesting depth is {depth} levels (recommended: ≤3)",
+                    "recommendation": "Flatten structure or normalize data",
+                }
+            )
 
         return issues
 
@@ -233,21 +242,25 @@ class NoSQLSchemaValidator:
 
             # Check for type mismatches
             if field_type not in ["string", "number", "boolean", "object", "array", "date", "null"]:
-                issues.append({
-                    "severity": "medium",
-                    "type": "unknown_type",
-                    "field": field,
-                    "message": f"Unknown type '{field_type}' for field '{field}'"
-                })
+                issues.append(
+                    {
+                        "severity": "medium",
+                        "type": "unknown_type",
+                        "field": field,
+                        "message": f"Unknown type '{field_type}' for field '{field}'",
+                    }
+                )
 
             # Check for ID fields without proper type
             if "id" in field.lower() and field_type not in ["string", "number"]:
-                issues.append({
-                    "severity": "high",
-                    "type": "invalid_id_type",
-                    "field": field,
-                    "message": f"ID field '{field}' should be string or number, not {field_type}"
-                })
+                issues.append(
+                    {
+                        "severity": "high",
+                        "type": "invalid_id_type",
+                        "field": field,
+                        "message": f"ID field '{field}' should be string or number, not {field_type}",
+                    }
+                )
 
         return issues
 
@@ -327,12 +340,7 @@ class NoSQLSchemaValidator:
             "timestamp": datetime.now().isoformat(),
             "schema_name": self.schema.get("$id", "unknown"),
             "validations": [],
-            "summary": {
-                "critical": 0,
-                "high": 0,
-                "medium": 0,
-                "low": 0
-            }
+            "summary": {"critical": 0, "high": 0, "medium": 0, "low": 0},
         }
 
         # Run all validation methods
@@ -341,7 +349,7 @@ class NoSQLSchemaValidator:
             self.validate_indexes,
             self.validate_document_structure,
             self.validate_data_types,
-            self.validate_references
+            self.validate_references,
         ]
 
         for method in validation_methods:
@@ -367,10 +375,10 @@ def format_validation_report(results: Dict[str, Any]) -> str:
         Formatted report string
     """
     report = []
-    report.append(f"\n{'='*70}")
-    report.append(f"NoSQL Schema Validation Report")
+    report.append(f"\n{'=' * 70}")
+    report.append("NoSQL Schema Validation Report")
     report.append(f"Schema: {results['schema_name']}")
-    report.append(f"{'='*70}\n")
+    report.append(f"{'=' * 70}\n")
 
     summary = results.get("summary", {})
     report.append("Summary:")
@@ -387,7 +395,9 @@ def format_validation_report(results: Dict[str, Any]) -> str:
     else:
         report.append("Issues Found:\n")
 
-        for issue in sorted(validations, key=lambda x: ["critical", "high", "medium", "low"].index(x.get("severity", "low"))):
+        for issue in sorted(
+            validations, key=lambda x: ["critical", "high", "medium", "low"].index(x.get("severity", "low"))
+        ):
             severity = issue.get("severity", "low").upper()
             type_name = issue.get("type", "unknown")
             message = issue.get("message", "")
@@ -403,7 +413,7 @@ def format_validation_report(results: Dict[str, Any]) -> str:
 
             report.append("")
 
-    report.append(f"{'='*70}\n")
+    report.append(f"{'=' * 70}\n")
 
     return "\n".join(report)
 
@@ -418,29 +428,13 @@ Examples:
   %(prog)s --schema schema.json
   %(prog)s --schema user-schema.json --output report.json
   %(prog)s --schema product-schema.json --format json
-        """
+        """,
     )
 
-    parser.add_argument(
-        "--schema",
-        required=True,
-        help="Path to JSON schema file"
-    )
-    parser.add_argument(
-        "--output",
-        help="Output file for validation report (JSON)"
-    )
-    parser.add_argument(
-        "--format",
-        default="text",
-        choices=["text", "json"],
-        help="Output format"
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Print detailed output"
-    )
+    parser.add_argument("--schema", required=True, help="Path to JSON schema file")
+    parser.add_argument("--output", help="Output file for validation report (JSON)")
+    parser.add_argument("--format", default="text", choices=["text", "json"], help="Output format")
+    parser.add_argument("--verbose", action="store_true", help="Print detailed output")
 
     args = parser.parse_args()
 
@@ -468,7 +462,7 @@ Examples:
 
         # Save to file if requested
         if args.output:
-            with open(args.output, 'w') as f:
+            with open(args.output, "w") as f:
                 if args.format == "json":
                     json.dump(results, f, indent=2)
                 else: