sugarai 3.1.1.dev5__tar.gz → 3.1.1.dev6__tar.gz

{sugarai-3.1.1.dev5/sugarai.egg-info → sugarai-3.1.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sugarai
-Version: 3.1.1.dev5
+Version: 3.1.1.dev6
 Summary: Sugar 🍰 - A dev team that never stops. Delegate full tasks to AI in the background.
 Author-email: Steven Leggett <contact@roboticforce.io>
 License: MIT
@@ -228,6 +228,16 @@ sugar issue respond 42 --post
 
 The Issue Responder evaluates confidence before posting. Use `--force-post` to override the confidence check, or adjust the threshold with `--confidence-threshold`.
 
+**Custom Prompts:** Customize Sugar's responses per-project by creating `.sugar/prompts/issue_responder.json`:
+
+```json
+{
+  "instructions": "You are a helpful assistant for MyProject. Be friendly and professional.",
+  "guidelines": ["Always search the codebase first", "Include file paths"],
+  "constraints": ["Never share API keys", "Don't promise release dates"]
+}
+```
+
 **Full documentation:** [docs/issue-responder.md](docs/issue-responder.md)
 
 ## How It Works

{sugarai-3.1.1.dev5 → sugarai-3.1.1.dev6}/README.md

@@ -174,6 +174,16 @@ sugar issue respond 42 --post
 
 The Issue Responder evaluates confidence before posting. Use `--force-post` to override the confidence check, or adjust the threshold with `--confidence-threshold`.
 
+**Custom Prompts:** Customize Sugar's responses per-project by creating `.sugar/prompts/issue_responder.json`:
+
+```json
+{
+  "instructions": "You are a helpful assistant for MyProject. Be friendly and professional.",
+  "guidelines": ["Always search the codebase first", "Include file paths"],
+  "constraints": ["Never share API keys", "Don't promise release dates"]
+}
+```
+
 **Full documentation:** [docs/issue-responder.md](docs/issue-responder.md)
 
 ## How It Works

{sugarai-3.1.1.dev5 → sugarai-3.1.1.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sugarai"
-version = "3.1.1.dev5"
+version = "3.1.1.dev6"
 description = "Sugar 🍰 - A dev team that never stops. Delegate full tasks to AI in the background."
 readme = "README.md"
 requires-python = ">=3.11"

sugarai-3.1.1.dev6/sugar/config/__init__.py

@@ -0,0 +1,6 @@
+"""Sugar configuration loaders."""
+
+from .issue_responder_config import IssueResponderConfig
+from .prompt_config import PersonaConfig, PromptConfig
+
+__all__ = ["IssueResponderConfig", "PersonaConfig", "PromptConfig"]

sugarai-3.1.1.dev6/sugar/config/prompt_config.py

@@ -0,0 +1,135 @@
+"""
+Prompt configuration for Issue Responder
+
+Loads custom prompt configuration from .sugar/prompts/issue_responder.json
+"""
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PersonaConfig:
+    """Agent persona configuration"""
+
+    role: Optional[str] = None
+    goal: Optional[str] = None
+    expertise: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PersonaConfig":
+        """Create PersonaConfig from a dictionary.
+
+        Args:
+            data: Dictionary containing persona configuration
+
+        Returns:
+            PersonaConfig instance
+        """
+        return cls(
+            role=data.get("role"),
+            goal=data.get("goal"),
+            expertise=data.get("expertise", []),
+        )
+
+
+@dataclass
+class PromptConfig:
+    """Custom prompt configuration for Issue Responder"""
+
+    instructions: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    persona: Optional[PersonaConfig] = None
+    guidelines: List[str] = field(default_factory=list)
+    constraints: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PromptConfig":
+        """Load from dictionary"""
+        persona_data = data.get("persona")
+        persona = PersonaConfig.from_dict(persona_data) if persona_data else None
+
+        return cls(
+            instructions=data.get("instructions", ""),
+            name=data.get("name"),
+            description=data.get("description"),
+            persona=persona,
+            guidelines=data.get("guidelines", []),
+            constraints=data.get("constraints", []),
+        )
+
+    @classmethod
+    def load_from_file(cls, config_path: Path = None) -> Optional["PromptConfig"]:
+        """
+        Load from JSON file.
+
+        Default path: .sugar/prompts/issue_responder.json
+        Returns None if file doesn't exist (use defaults)
+        """
+        if config_path is None:
+            config_path = Path(".sugar/prompts/issue_responder.json")
+
+        if not config_path.exists():
+            logger.debug(f"No custom prompt config at {config_path}")
+            return None
+
+        try:
+            with open(config_path) as f:
+                data = json.load(f)
+            return cls.from_dict(data)
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in {config_path}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error loading prompt config: {e}")
+            return None
+
+    def validate(self) -> List[str]:
+        """Validate configuration, return list of errors"""
+        errors = []
+        if not self.instructions or not self.instructions.strip():
+            errors.append("instructions is required and cannot be empty")
+        return errors
+
+    def build_system_prompt_additions(self) -> str:
+        """
+        Build the system prompt additions from this config.
+        Returns a string to be added to the base system prompt.
+        """
+        parts = []
+
+        # Add persona section
+        if self.persona:
+            persona_parts = []
+            if self.persona.role:
+                persona_parts.append(f"**Role**: {self.persona.role}")
+            if self.persona.goal:
+                persona_parts.append(f"**Goal**: {self.persona.goal}")
+            if self.persona.expertise:
+                persona_parts.append(
+                    f"**Expertise**: {', '.join(self.persona.expertise)}"
+                )
+            if persona_parts:
+                parts.append("## Your Persona\n" + "\n".join(persona_parts))
+
+        # Add instructions
+        if self.instructions:
+            parts.append(f"## Project-Specific Instructions\n{self.instructions}")
+
+        # Add guidelines
+        if self.guidelines:
+            guidelines_text = "\n".join(f"- {g}" for g in self.guidelines)
+            parts.append(f"## Guidelines\n{guidelines_text}")
+
+        # Add constraints
+        if self.constraints:
+            constraints_text = "\n".join(f"- {c}" for c in self.constraints)
+            parts.append(f"## Constraints\n{constraints_text}")
+
+        return "\n\n".join(parts)

{sugarai-3.1.1.dev5 → sugarai-3.1.1.dev6}/sugar/profiles/issue_responder.py

@@ -15,6 +15,7 @@ import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
+from ..config import PromptConfig
 from .base import BaseProfile, ProfileConfig
 
 logger = logging.getLogger(__name__)
@@ -110,7 +111,7 @@ class IssueResponderProfile(BaseProfile):
             if repo:
                 repo_info = f"\nRepository: {repo}"
 
-        return f"""You are Sugar, an AI assistant that helps respond to GitHub issues.
+        base_prompt = f"""You are Sugar, an AI assistant that helps respond to GitHub issues.
 
 {repo_info}
 
@@ -156,6 +157,20 @@ Rate your confidence in your response:
 Only auto-post responses with confidence >= 0.8.
 """
 
+        # Load custom prompt config if available
+        custom_config = PromptConfig.load_from_file()
+        if custom_config:
+            errors = custom_config.validate()
+            if errors:
+                logger.warning(f"Invalid prompt config: {errors}")
+            else:
+                custom_additions = custom_config.build_system_prompt_additions()
+                if custom_additions:
+                    base_prompt += f"\n\n# Custom Configuration\n\n{custom_additions}"
+                    logger.info("Loaded custom prompt configuration")
+
+        return base_prompt
+
     async def process_input(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
         """Process issue data for analysis"""
         issue = input_data.get("issue", {})

{sugarai-3.1.1.dev5 → sugarai-3.1.1.dev6/sugarai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sugarai
-Version: 3.1.1.dev5
+Version: 3.1.1.dev6
 Summary: Sugar 🍰 - A dev team that never stops. Delegate full tasks to AI in the background.
 Author-email: Steven Leggett <contact@roboticforce.io>
 License: MIT
@@ -228,6 +228,16 @@ sugar issue respond 42 --post
 
 The Issue Responder evaluates confidence before posting. Use `--force-post` to override the confidence check, or adjust the threshold with `--confidence-threshold`.
 
+**Custom Prompts:** Customize Sugar's responses per-project by creating `.sugar/prompts/issue_responder.json`:
+
+```json
+{
+  "instructions": "You are a helpful assistant for MyProject. Be friendly and professional.",
+  "guidelines": ["Always search the codebase first", "Include file paths"],
+  "constraints": ["Never share API keys", "Don't promise release dates"]
+}
+```
+
 **Full documentation:** [docs/issue-responder.md](docs/issue-responder.md)
 
 ## How It Works

{sugarai-3.1.1.dev5 → sugarai-3.1.1.dev6}/sugarai.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ sugar/billing/tiers.py
 sugar/billing/usage.py
 sugar/config/__init__.py
 sugar/config/issue_responder_config.py
+sugar/config/prompt_config.py
 sugar/core/__init__.py
 sugar/core/loop.py
 sugar/discovery/__init__.py
@@ -77,6 +78,7 @@ tests/test_issue_responder_cli.py
 tests/test_issue_response_integration.py
 tests/test_orchestration.py
 tests/test_profiles.py
+tests/test_prompt_config.py
 tests/test_quality_gates.py
 tests/test_storage.py
 tests/test_subagent_manager.py

sugarai-3.1.1.dev6/tests/test_prompt_config.py

@@ -0,0 +1,359 @@
+"""
+Tests for prompt configuration system
+"""
+
+import json
+import pytest
+from pathlib import Path
+
+from sugar.config.prompt_config import PersonaConfig, PromptConfig
+
+
+class TestPersonaConfig:
+    """Test PersonaConfig dataclass"""
+
+    def test_default_values(self):
+        """Test default values for PersonaConfig"""
+        persona = PersonaConfig()
+
+        assert persona.role is None
+        assert persona.goal is None
+        assert persona.expertise == []
+
+    def test_from_dict_with_full_data(self):
+        """Test from_dict with all fields populated"""
+        data = {
+            "role": "Senior QA Engineer",
+            "goal": "Ensure high-quality test coverage",
+            "expertise": ["pytest", "playwright", "test automation"],
+        }
+
+        persona = PersonaConfig.from_dict(data)
+
+        assert persona.role == "Senior QA Engineer"
+        assert persona.goal == "Ensure high-quality test coverage"
+        assert persona.expertise == ["pytest", "playwright", "test automation"]
+
+    def test_from_dict_with_partial_data(self):
+        """Test from_dict with only some fields"""
+        data = {"role": "QA Engineer"}
+
+        persona = PersonaConfig.from_dict(data)
+
+        assert persona.role == "QA Engineer"
+        assert persona.goal is None
+        assert persona.expertise == []
+
+    def test_from_dict_with_empty_dict(self):
+        """Test from_dict with empty dictionary"""
+        persona = PersonaConfig.from_dict({})
+
+        assert persona.role is None
+        assert persona.goal is None
+        assert persona.expertise == []
+
+
+class TestPromptConfig:
+    """Test PromptConfig dataclass"""
+
+    def test_default_values(self):
+        """Test default values for PromptConfig with required instructions"""
+        config = PromptConfig(instructions="Always write tests first")
+
+        assert config.instructions == "Always write tests first"
+        assert config.name is None
+        assert config.description is None
+        assert config.persona is None
+        assert config.guidelines == []
+        assert config.constraints == []
+
+    def test_from_dict_with_full_data(self):
+        """Test from_dict with all fields populated"""
+        data = {
+            "name": "Test-First Development",
+            "description": "TDD approach for all features",
+            "instructions": "Write tests before implementation",
+            "persona": {
+                "role": "Senior QA Engineer",
+                "goal": "Ensure code quality",
+                "expertise": ["pytest", "TDD"],
+            },
+            "guidelines": ["Use descriptive test names", "Follow AAA pattern"],
+            "constraints": ["Minimum 80% coverage", "No skipped tests"],
+        }
+
+        config = PromptConfig.from_dict(data)
+
+        assert config.name == "Test-First Development"
+        assert config.description == "TDD approach for all features"
+        assert config.instructions == "Write tests before implementation"
+        assert config.persona is not None
+        assert config.persona.role == "Senior QA Engineer"
+        assert config.persona.goal == "Ensure code quality"
+        assert config.persona.expertise == ["pytest", "TDD"]
+        assert config.guidelines == ["Use descriptive test names", "Follow AAA pattern"]
+        assert config.constraints == ["Minimum 80% coverage", "No skipped tests"]
+
+    def test_from_dict_with_partial_data(self):
+        """Test from_dict with only required fields"""
+        data = {"instructions": "Follow project coding standards"}
+
+        config = PromptConfig.from_dict(data)
+
+        assert config.instructions == "Follow project coding standards"
+        assert config.name is None
+        assert config.description is None
+        assert config.persona is None
+        assert config.guidelines == []
+        assert config.constraints == []
+
+    def test_from_dict_without_persona(self):
+        """Test from_dict when persona is not provided"""
+        data = {
+            "instructions": "Use black for formatting",
+            "guidelines": ["Follow PEP 8"],
+        }
+
+        config = PromptConfig.from_dict(data)
+
+        assert config.instructions == "Use black for formatting"
+        assert config.persona is None
+        assert config.guidelines == ["Follow PEP 8"]
+
+    def test_validation_missing_instructions(self):
+        """Test validation fails when instructions is missing"""
+        config = PromptConfig(instructions="")
+
+        errors = config.validate()
+
+        assert len(errors) == 1
+        assert "instructions is required and cannot be empty" in errors[0]
+
+    def test_validation_empty_instructions(self):
+        """Test validation fails when instructions is whitespace only"""
+        config = PromptConfig(instructions="   ")
+
+        errors = config.validate()
+
+        assert len(errors) == 1
+        assert "instructions is required and cannot be empty" in errors[0]
+
+    def test_validation_valid_config(self):
+        """Test validation passes for valid config"""
+        config = PromptConfig(
+            instructions="Follow coding standards",
+            guidelines=["Use type hints", "Write docstrings"],
+        )
+
+        errors = config.validate()
+
+        assert len(errors) == 0
+
+
+class TestLoadFromFile:
+    """Test file loading functionality"""
+
+    def test_load_from_file_missing_file(self, tmp_path):
+        """Test load_from_file returns None for missing file"""
+        config_path = tmp_path / "nonexistent.json"
+
+        config = PromptConfig.load_from_file(config_path)
+
+        assert config is None
+
+    def test_load_from_file_invalid_json(self, tmp_path):
+        """Test load_from_file returns None for invalid JSON"""
+        config_path = tmp_path / "invalid.json"
+        config_path.write_text("{ invalid json }")
+
+        config = PromptConfig.load_from_file(config_path)
+
+        assert config is None
+
+    def test_load_from_file_valid_json(self, tmp_path):
+        """Test load_from_file returns config for valid JSON"""
+        config_path = tmp_path / "config.json"
+        data = {
+            "name": "Project Config",
+            "instructions": "Follow project guidelines",
+            "persona": {"role": "Developer", "goal": "Build quality software"},
+            "guidelines": ["Write clean code"],
+            "constraints": ["No magic numbers"],
+        }
+        config_path.write_text(json.dumps(data))
+
+        config = PromptConfig.load_from_file(config_path)
+
+        assert config is not None
+        assert config.name == "Project Config"
+        assert config.instructions == "Follow project guidelines"
+        assert config.persona is not None
+        assert config.persona.role == "Developer"
+        assert config.guidelines == ["Write clean code"]
+        assert config.constraints == ["No magic numbers"]
+
+    def test_load_from_file_minimal_valid_json(self, tmp_path):
+        """Test load_from_file with minimal valid JSON"""
+        config_path = tmp_path / "minimal.json"
+        data = {"instructions": "Minimal config"}
+        config_path.write_text(json.dumps(data))
+
+        config = PromptConfig.load_from_file(config_path)
+
+        assert config is not None
+        assert config.instructions == "Minimal config"
+        assert config.persona is None
+        assert config.guidelines == []
+        assert config.constraints == []
+
+    def test_load_from_file_default_path(self, tmp_path, monkeypatch):
+        """Test load_from_file uses default path when not specified"""
+        # Change to tmp_path directory
+        monkeypatch.chdir(tmp_path)
+
+        # Create default path
+        default_dir = tmp_path / ".sugar" / "prompts"
+        default_dir.mkdir(parents=True)
+        config_path = default_dir / "issue_responder.json"
+        data = {"instructions": "Default config"}
+        config_path.write_text(json.dumps(data))
+
+        config = PromptConfig.load_from_file()
+
+        assert config is not None
+        assert config.instructions == "Default config"
+
+
+class TestBuildSystemPromptAdditions:
+    """Test build_system_prompt_additions functionality"""
+
+    def test_minimal_config_with_only_instructions(self):
+        """Test returns formatted instructions for minimal config"""
+        config = PromptConfig(instructions="Follow coding standards")
+
+        result = config.build_system_prompt_additions()
+
+        assert "## Project-Specific Instructions\nFollow coding standards" in result
+        assert "## Your Persona" not in result
+        assert "## Guidelines" not in result
+        assert "## Constraints" not in result
+
+    def test_includes_persona_section(self):
+        """Test includes persona section when persona provided"""
+        config = PromptConfig(
+            instructions="Write tests",
+            persona=PersonaConfig(
+                role="QA Engineer",
+                goal="Ensure quality",
+                expertise=["pytest", "testing"],
+            ),
+        )
+
+        result = config.build_system_prompt_additions()
+
+        assert "## Your Persona" in result
+        assert "**Role**: QA Engineer" in result
+        assert "**Goal**: Ensure quality" in result
+        assert "**Expertise**: pytest, testing" in result
+
+    def test_includes_guidelines_when_provided(self):
+        """Test includes guidelines section when provided"""
+        config = PromptConfig(
+            instructions="Write clean code",
+            guidelines=["Use type hints", "Write docstrings", "Follow PEP 8"],
+        )
+
+        result = config.build_system_prompt_additions()
+
+        assert "## Guidelines" in result
+        assert "- Use type hints" in result
+        assert "- Write docstrings" in result
+        assert "- Follow PEP 8" in result
+
+    def test_includes_constraints_when_provided(self):
+        """Test includes constraints section when provided"""
+        config = PromptConfig(
+            instructions="Follow rules",
+            constraints=[
+                "No TODO comments",
+                "Max line length 88",
+                "Type all functions",
+            ],
+        )
+
+        result = config.build_system_prompt_additions()
+
+        assert "## Constraints" in result
+        assert "- No TODO comments" in result
+        assert "- Max line length 88" in result
+        assert "- Type all functions" in result
+
+    def test_combines_all_sections_properly(self):
+        """Test combines all sections in correct order"""
+        config = PromptConfig(
+            instructions="Main instructions here",
+            persona=PersonaConfig(role="Developer", goal="Build features"),
+            guidelines=["Guideline 1", "Guideline 2"],
+            constraints=["Constraint 1"],
+        )
+
+        result = config.build_system_prompt_additions()
+
+        # Check all sections are present
+        assert "## Your Persona" in result
+        assert "## Project-Specific Instructions" in result
+        assert "## Guidelines" in result
+        assert "## Constraints" in result
+
+        # Check order (persona, instructions, guidelines, constraints)
+        persona_idx = result.index("## Your Persona")
+        instructions_idx = result.index("## Project-Specific Instructions")
+        guidelines_idx = result.index("## Guidelines")
+        constraints_idx = result.index("## Constraints")
+
+        assert persona_idx < instructions_idx < guidelines_idx < constraints_idx
+
+        # Check sections are separated by double newlines
+        assert "\n\n" in result
+
+    def test_persona_with_partial_fields(self):
+        """Test persona section with only some fields populated"""
+        config = PromptConfig(
+            instructions="Instructions",
+            persona=PersonaConfig(role="Developer"),  # Only role, no goal/expertise
+        )
+
+        result = config.build_system_prompt_additions()
+
+        assert "## Your Persona" in result
+        assert "**Role**: Developer" in result
+        assert "**Goal**:" not in result
+        assert "**Expertise**:" not in result
+
+    def test_empty_persona_not_included(self):
+        """Test persona section not included if all fields are None/empty"""
+        config = PromptConfig(
+            instructions="Instructions",
+            persona=PersonaConfig(),  # All fields None/empty
+        )
+
+        result = config.build_system_prompt_additions()
+
+        # Persona section should not be included if no fields are populated
+        assert "## Your Persona" not in result
+
+    def test_section_formatting(self):
+        """Test proper markdown formatting of sections"""
+        config = PromptConfig(
+            instructions="These are the instructions.\nMultiline instructions work.",
+            guidelines=["First guideline", "Second guideline"],
+        )
+
+        result = config.build_system_prompt_additions()
+
+        # Check instructions preserve newlines
+        assert "These are the instructions.\nMultiline instructions work." in result
+
+        # Check guidelines are bulleted
+        assert "- First guideline" in result
+        assert "- Second guideline" in result

sugarai-3.1.1.dev5/sugar/config/__init__.py

@@ -1,5 +0,0 @@
-"""Sugar configuration loaders."""
-
-from .issue_responder_config import IssueResponderConfig
-
-__all__ = ["IssueResponderConfig"]