134 lines
4.1 KiB
Python
Executable File
134 lines
4.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""extract-patterns.py - Extract and summarize patterns from reference directory"""
|
|
|
|
import json
|
|
import re
|
|
from pathlib import Path
|
|
from typing import Dict, List
|
|
|
|
|
|
def extract_patterns(reference_dir: Path) -> Dict:
|
|
"""Extract patterns from reference/patterns.md"""
|
|
patterns_file = reference_dir / "patterns.md"
|
|
|
|
if not patterns_file.exists():
|
|
return {"error": "patterns.md not found"}
|
|
|
|
content = patterns_file.read_text()
|
|
|
|
patterns = []
|
|
|
|
# Extract pattern sections
|
|
pattern_regex = r"## Pattern \d+: (.+?)\n\n\*\*Use case\*\*: (.+?)\n\n\*\*Structure\*\*:\n```\n(.+?)\n```"
|
|
|
|
for match in re.finditer(pattern_regex, content, re.DOTALL):
|
|
name = match.group(1).strip()
|
|
use_case = match.group(2).strip()
|
|
structure = match.group(3).strip()
|
|
|
|
patterns.append({
|
|
"name": name,
|
|
"use_case": use_case,
|
|
"structure": structure
|
|
})
|
|
|
|
return {
|
|
"patterns_count": len(patterns),
|
|
"patterns": patterns
|
|
}
|
|
|
|
|
|
def extract_integration_patterns(reference_dir: Path) -> Dict:
|
|
"""Extract integration patterns from reference/integration-patterns.md"""
|
|
integration_file = reference_dir / "integration-patterns.md"
|
|
|
|
if not integration_file.exists():
|
|
return {"error": "integration-patterns.md not found"}
|
|
|
|
content = integration_file.read_text()
|
|
|
|
integrations = []
|
|
|
|
# Extract integration sections
|
|
integration_regex = r"## \d+\. (.+?)\n\n\*\*Pattern\*\*:\n```\n(.+?)\n```"
|
|
|
|
for match in re.finditer(integration_regex, content, re.DOTALL):
|
|
name = match.group(1).strip()
|
|
pattern = match.group(2).strip()
|
|
|
|
integrations.append({
|
|
"name": name,
|
|
"pattern": pattern
|
|
})
|
|
|
|
return {
|
|
"integration_patterns_count": len(integrations),
|
|
"integration_patterns": integrations
|
|
}
|
|
|
|
|
|
def extract_symbols(reference_dir: Path) -> Dict:
|
|
"""Extract symbolic language operators from reference/symbolic-language.md"""
|
|
symbols_file = reference_dir / "symbolic-language.md"
|
|
|
|
if not symbols_file.exists():
|
|
return {"error": "symbolic-language.md not found"}
|
|
|
|
content = symbols_file.read_text()
|
|
|
|
# Count sections
|
|
logic_ops = len(re.findall(r"### .+? \(.+?\)\n\*\*Symbol\*\*: `(.+?)`", content[:2000]))
|
|
quantifiers = len(re.findall(r"### .+?\n\*\*Symbol\*\*: `(.+?)`", content[2000:4000]))
|
|
set_ops = len(re.findall(r"### .+?\n\*\*Symbol\*\*: `(.+?)`", content[4000:6000]))
|
|
|
|
return {
|
|
"logic_operators": logic_ops,
|
|
"quantifiers": quantifiers,
|
|
"set_operations": set_ops,
|
|
"total_symbols": logic_ops + quantifiers + set_ops
|
|
}
|
|
|
|
|
|
def main():
|
|
"""Main entry point"""
|
|
skill_dir = Path(__file__).parent.parent
|
|
reference_dir = skill_dir / "reference"
|
|
|
|
if not reference_dir.exists():
|
|
print(json.dumps({"error": "reference directory not found"}, indent=2))
|
|
return
|
|
|
|
# Extract all patterns
|
|
patterns = extract_patterns(reference_dir)
|
|
integrations = extract_integration_patterns(reference_dir)
|
|
symbols = extract_symbols(reference_dir)
|
|
|
|
# Combine results
|
|
result = {
|
|
"skill": "subagent-prompt-construction",
|
|
"patterns": patterns,
|
|
"integration_patterns": integrations,
|
|
"symbolic_language": symbols,
|
|
"summary": {
|
|
"total_patterns": patterns.get("patterns_count", 0),
|
|
"total_integration_patterns": integrations.get("integration_patterns_count", 0),
|
|
"total_symbols": symbols.get("total_symbols", 0)
|
|
}
|
|
}
|
|
|
|
# Save to inventory
|
|
inventory_dir = skill_dir / "inventory"
|
|
inventory_dir.mkdir(exist_ok=True)
|
|
|
|
output_file = inventory_dir / "patterns-summary.json"
|
|
output_file.write_text(json.dumps(result, indent=2))
|
|
|
|
print(f"✅ Patterns extracted to {output_file}")
|
|
print(f" - {result['summary']['total_patterns']} core patterns")
|
|
print(f" - {result['summary']['total_integration_patterns']} integration patterns")
|
|
print(f" - {result['summary']['total_symbols']} symbolic operators")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|