ctrlcode 0.1.0__py3-none-any.whl

ctrlcode/skills/__init__.py

@@ -0,0 +1,10 @@
+"""Skills system for ctrl-code."""
+
+from .loader import SkillLoader, Skill
+from .registry import SkillRegistry
+
+__all__ = [
+    "SkillLoader",
+    "Skill",
+    "SkillRegistry",
+]

ctrlcode/skills/builtin/commit.toml

@@ -0,0 +1,29 @@
+name = "commit"
+description = "Create a git commit with semantic commit message"
+requires_args = false
+
+prompt = """
+Create a git commit following these steps:
+
+1. Run `git status` to see all changes (staged and unstaged)
+2. Run `git diff` to review the actual changes
+3. Run `git log --oneline -5` to see recent commit message style
+4. Analyze the changes and create a semantic commit message that:
+   - Summarizes the nature of changes (new feature, bug fix, refactor, etc.)
+   - Is concise (1-2 sentences)
+   - Focuses on the "why" rather than the "what"
+   - Follows the commit style of this repository
+5. Stage relevant files (avoid staging secrets like .env files)
+6. Create the commit with message ending with:
+   Co-Authored-By: Ctrl+Code <noreply@ctrl.code>
+
+Important:
+- Do NOT commit files that contain secrets
+- Do NOT push unless explicitly requested
+- Use semantic commit format (e.g., "feat:", "fix:", "refactor:")
+"""
+
+examples = [
+    "/commit",
+    "skill:commit"
+]

ctrlcode/skills/builtin/docs.toml

@@ -0,0 +1,25 @@
+name = "docs"
+description = "Generate or improve documentation"
+requires_args = true
+
+prompt = """
+Generate or improve documentation for: {args}
+
+1. Read the relevant code files
+2. Understand the purpose and functionality
+3. Create documentation that includes:
+   - Clear description of what it does
+   - Usage examples
+   - Parameter descriptions
+   - Return value descriptions
+   - Important notes or warnings
+4. Follow the existing documentation style in the project
+5. Include code examples where helpful
+
+Make the documentation clear, concise, and helpful for users.
+"""
+
+examples = [
+    "/docs FuzzingOrchestrator",
+    "skill:docs(MyClass)"
+]

ctrlcode/skills/builtin/refactor.toml

@@ -0,0 +1,33 @@
+name = "refactor"
+description = "Refactor code for better quality"
+requires_args = true
+
+prompt = """
+Refactor the code: {args}
+
+1. Read and understand the current implementation
+2. Identify improvement opportunities:
+   - Code duplication
+   - Complex functions (high cyclomatic complexity)
+   - Poor naming
+   - Missing abstractions
+   - Violation of SOLID principles
+3. Propose refactoring changes with:
+   - Clear explanation of the issue
+   - Proposed solution
+   - Benefits of the change
+   - Any trade-offs
+4. Make the changes incrementally
+5. Ensure tests still pass after each change
+
+Focus on improving:
+- Readability
+- Maintainability
+- Testability
+- Performance (where applicable)
+"""
+
+examples = [
+    "/refactor FuzzingOrchestrator.fuzz",
+    "skill:refactor(process_turn method)"
+]

ctrlcode/skills/builtin/review.toml

@@ -0,0 +1,28 @@
+name = "review"
+description = "Review code changes for quality and potential issues"
+requires_args = false
+
+prompt = """
+Review the current code changes:
+
+1. Run `git diff` to see all changes
+2. Analyze the changes for:
+   - Code quality and style
+   - Potential bugs or edge cases
+   - Security vulnerabilities
+   - Performance issues
+   - Missing error handling
+   - Test coverage gaps
+3. Provide constructive feedback with:
+   - Positive observations (what's good)
+   - Issues found (severity: critical, major, minor)
+   - Specific suggestions for improvement
+   - Code examples where helpful
+
+Format your review clearly with sections for each category.
+"""
+
+examples = [
+    "/review",
+    "skill:review"
+]

ctrlcode/skills/builtin/test.toml

@@ -0,0 +1,28 @@
+name = "test"
+description = "Run tests and analyze results"
+requires_args = false
+
+prompt = """
+Run tests and analyze results:
+
+1. Identify the test framework (pytest, unittest, jest, etc.)
+2. Run the test suite
+3. If tests fail:
+   - Show the failing tests
+   - Analyze the failure reasons
+   - Suggest fixes
+4. If tests pass:
+   - Report test coverage if available
+   - Suggest additional test cases for edge cases
+5. Check for:
+   - Missing tests for new functionality
+   - Flaky tests
+   - Test performance issues
+
+Provide a summary with test counts, pass rate, and recommendations.
+"""
+
+examples = [
+    "/test",
+    "skill:test"
+]

ctrlcode/skills/loader.py

@@ -0,0 +1,111 @@
+"""Skill loading from TOML files."""
+
+import logging
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Optional
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore # Python < 3.11
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Skill:
+    """A skill definition."""
+
+    name: str
+    prompt: str
+    description: str = ""
+    requires_args: bool = False
+    examples: list[str] = field(default_factory=list)
+
+
+class SkillLoader:
+    """Loads skills from TOML files."""
+
+    def __init__(self, skills_dir: Optional[Path] = None):
+        """
+        Initialize skill loader.
+
+        Args:
+            skills_dir: Directory containing skill TOML files
+        """
+        self.skills_dir = skills_dir
+
+    def load_skill(self, skill_path: Path) -> Skill:
+        """
+        Load a skill from TOML file.
+
+        Args:
+            skill_path: Path to skill TOML file
+
+        Returns:
+            Loaded skill
+        """
+        with open(skill_path, "rb") as f:
+            data = tomllib.load(f)
+
+        return Skill(
+            name=data["name"],
+            prompt=data["prompt"],
+            description=data.get("description", ""),
+            requires_args=data.get("requires_args", False),
+            examples=data.get("examples", []),
+        )
+
+    def load_all(self) -> dict[str, Skill]:
+        """
+        Load all skills from directory.
+
+        Returns:
+            Dict mapping skill name to skill
+        """
+        skills: dict[str, Skill] = {}
+
+        if not self.skills_dir or not self.skills_dir.exists():
+            logger.warning(f"Skills directory not found: {self.skills_dir}")
+            return skills
+
+        for skill_file in self.skills_dir.glob("*.toml"):
+            try:
+                skill = self.load_skill(skill_file)
+                skills[skill.name] = skill
+                logger.info(f"Loaded skill: {skill.name}")
+            except Exception as e:
+                logger.error(f"Failed to load skill {skill_file}: {e}")
+
+        return skills
+
+    def load_from_paths(self, paths: list[Path]) -> dict[str, Skill]:
+        """
+        Load skills from multiple directories.
+
+        Args:
+            paths: List of directory paths
+
+        Returns:
+            Dict mapping skill name to skill
+        """
+        skills = {}
+
+        for path in paths:
+            if not path.exists():
+                logger.warning(f"Skill path not found: {path}")
+                continue
+
+            for skill_file in path.glob("*.toml"):
+                try:
+                    skill = self.load_skill(skill_file)
+                    if skill.name in skills:
+                        logger.warning(f"Skill '{skill.name}' already loaded, skipping")
+                    else:
+                        skills[skill.name] = skill
+                        logger.info(f"Loaded skill: {skill.name}")
+                except Exception as e:
+                    logger.error(f"Failed to load skill {skill_file}: {e}")
+
+        return skills

ctrlcode/skills/registry.py

@@ -0,0 +1,139 @@
+"""Skill registry for managing and expanding skills."""
+
+import re
+from typing import Optional
+
+from .loader import Skill
+
+
+class SkillRegistry:
+    """Registry for managing skills."""
+
+    def __init__(self):
+        """Initialize skill registry."""
+        self.skills: dict[str, Skill] = {}
+
+    def register(self, skill: Skill) -> None:
+        """
+        Register a skill.
+
+        Args:
+            skill: Skill to register
+        """
+        self.skills[skill.name] = skill
+
+    def register_all(self, skills: dict[str, Skill]) -> None:
+        """
+        Register multiple skills.
+
+        Args:
+            skills: Dict of skills to register
+        """
+        self.skills.update(skills)
+
+    def get(self, name: str) -> Optional[Skill]:
+        """
+        Get skill by name.
+
+        Args:
+            name: Skill name
+
+        Returns:
+            Skill or None if not found
+        """
+        return self.skills.get(name)
+
+    def list_skills(self) -> list[Skill]:
+        """
+        List all registered skills.
+
+        Returns:
+            List of all skills
+        """
+        return list(self.skills.values())
+
+    def expand(self, skill_name: str, args: str = "") -> str:
+        """
+        Expand skill to full prompt.
+
+        Args:
+            skill_name: Name of skill to expand
+            args: Optional arguments for skill
+
+        Returns:
+            Expanded prompt
+
+        Raises:
+            KeyError: If skill not found
+        """
+        skill = self.skills.get(skill_name)
+        if not skill:
+            raise KeyError(f"Skill not found: {skill_name}")
+
+        # Check if args required
+        if skill.requires_args and not args:
+            raise ValueError(f"Skill '{skill_name}' requires arguments")
+
+        # Expand prompt with args
+        prompt = skill.prompt
+
+        # Simple template expansion
+        # Supports {args} placeholder
+        prompt = prompt.replace("{args}", args)
+
+        return prompt
+
+    def parse_skill_command(self, user_input: str) -> tuple[Optional[str], Optional[str]]:
+        """
+        Parse skill command from user input.
+
+        Supports formats:
+        - /skill_name
+        - /skill_name arg1 arg2
+        - skill:skill_name
+        - skill:skill_name(arg1, arg2)
+
+        Args:
+            user_input: User input string
+
+        Returns:
+            Tuple of (skill_name, args) or (None, None) if not a skill command
+        """
+        # Check for /skill format
+        if user_input.startswith("/"):
+            parts = user_input[1:].split(None, 1)
+            skill_name = parts[0]
+            args = parts[1] if len(parts) > 1 else ""
+
+            if skill_name in self.skills:
+                return skill_name, args
+
+        # Check for skill:name format
+        skill_pattern = r"^skill:(\w+)(?:\((.*)\))?$"
+        match = re.match(skill_pattern, user_input.strip())
+        if match:
+            skill_name = match.group(1)
+            args = match.group(2) or ""
+
+            if skill_name in self.skills:
+                return skill_name, args
+
+        return None, None
+
+    def process_input(self, user_input: str) -> tuple[str, bool]:
+        """
+        Process user input and expand skills if found.
+
+        Args:
+            user_input: User input string
+
+        Returns:
+            Tuple of (processed_input, was_skill)
+        """
+        skill_name, args = self.parse_skill_command(user_input)
+
+        if skill_name:
+            expanded = self.expand(skill_name, args or "")
+            return expanded, True
+
+        return user_input, False

ctrlcode/storage/__init__.py

@@ -0,0 +1,19 @@
+"""Persistent storage for historical fuzzing data and knowledge base."""
+
+from ctrlcode.storage.history_db import (
+    BugPattern,
+    CodeRecord,
+    FuzzingSession,
+    HistoryDB,
+    OracleRecord,
+    StoredTest,
+)
+
+__all__ = [
+    "HistoryDB",
+    "FuzzingSession",
+    "CodeRecord",
+    "OracleRecord",
+    "BugPattern",
+    "StoredTest",
+]