sugarai 3.1.1.dev4__tar.gz → 3.1.1.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sugarai
-Version: 3.1.1.dev4
+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.dev4 → 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.dev4 → sugarai-3.1.1.dev6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sugarai"
-version = "3.1.1.dev4"
+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/issue_responder_config.py

@@ -0,0 +1,143 @@
+"""Configuration loader for the Issue Responder feature."""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+import yaml
+from pathlib import Path
+
+
+@dataclass
+class IssueResponderConfig:
+    """Configuration for AI-powered automatic issue responses.
+
+    Attributes:
+        enabled: Enable automatic issue responses
+        auto_post_threshold: Minimum confidence score (0.0-1.0) to auto-post responses
+        max_response_length: Maximum characters per response
+        response_delay_seconds: Delay before posting (0 = immediate)
+        rate_limit_per_hour: Maximum responses per hour (0 = unlimited)
+        respond_to_labels: Only respond to issues with these labels (empty = all)
+        skip_labels: Never respond to issues with these labels
+        skip_bot_issues: Skip issues created by bots
+        handle_follow_ups: How to handle follow-up comments - "ignore" | "queue" | "auto"
+        model: Claude model to use for generating responses
+    """
+
+    enabled: bool = False
+    auto_post_threshold: float = 0.8
+    max_response_length: int = 2000
+    response_delay_seconds: int = 0
+    rate_limit_per_hour: int = 10
+    respond_to_labels: List[str] = field(default_factory=list)
+    skip_labels: List[str] = field(
+        default_factory=lambda: ["wontfix", "duplicate", "stale"]
+    )
+    skip_bot_issues: bool = True
+    handle_follow_ups: str = "ignore"  # "ignore" | "queue" | "auto"
+    model: str = "claude-sonnet-4-20250514"
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "IssueResponderConfig":
+        """Create IssueResponderConfig from a dictionary.
+
+        Args:
+            data: Dictionary containing configuration values
+
+        Returns:
+            IssueResponderConfig instance
+
+        Example:
+            >>> config_data = {
+            ...     "enabled": True,
+            ...     "auto_post_threshold": 0.9,
+            ...     "respond_to_labels": ["question", "help-wanted"]
+            ... }
+            >>> config = IssueResponderConfig.from_dict(config_data)
+        """
+        # Filter to only include known fields
+        valid_fields = {f.name for f in cls.__dataclass_fields__.values()}
+        filtered_data = {k: v for k, v in data.items() if k in valid_fields}
+        return cls(**filtered_data)
+
+    @classmethod
+    def load_from_file(cls, config_path: str) -> "IssueResponderConfig":
+        """Load IssueResponderConfig from a YAML configuration file.
+
+        Args:
+            config_path: Path to the YAML configuration file
+
+        Returns:
+            IssueResponderConfig instance with values from the file
+
+        Raises:
+            FileNotFoundError: If the config file doesn't exist
+            KeyError: If the 'issue_responder' section is missing
+            yaml.YAMLError: If the YAML file is malformed
+
+        Example:
+            >>> config = IssueResponderConfig.load_from_file(".sugar/config.yaml")
+        """
+        config_file = Path(config_path)
+
+        if not config_file.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        with open(config_file, "r") as f:
+            config_data = yaml.safe_load(f)
+
+        # Navigate to the issue_responder section
+        if "sugar" not in config_data:
+            raise KeyError("Configuration file missing 'sugar' section")
+
+        if "issue_responder" not in config_data["sugar"]:
+            raise KeyError("Configuration file missing 'sugar.issue_responder' section")
+
+        issue_responder_data = config_data["sugar"]["issue_responder"]
+        return cls.from_dict(issue_responder_data)
+
+    def validate(self) -> List[str]:
+        """Validate configuration values and return list of errors.
+
+        Returns:
+            List of validation error messages (empty if valid)
+
+        Example:
+            >>> config = IssueResponderConfig(auto_post_threshold=1.5)
+            >>> errors = config.validate()
+            >>> if errors:
+            ...     print("Invalid configuration:", errors)
+        """
+        errors = []
+
+        # Validate auto_post_threshold
+        if not 0.0 <= self.auto_post_threshold <= 1.0:
+            errors.append(
+                f"auto_post_threshold must be between 0.0 and 1.0, got {self.auto_post_threshold}"
+            )
+
+        # Validate max_response_length
+        if self.max_response_length <= 0:
+            errors.append(
+                f"max_response_length must be positive, got {self.max_response_length}"
+            )
+
+        # Validate response_delay_seconds
+        if self.response_delay_seconds < 0:
+            errors.append(
+                f"response_delay_seconds must be non-negative, got {self.response_delay_seconds}"
+            )
+
+        # Validate rate_limit_per_hour
+        if self.rate_limit_per_hour < 0:
+            errors.append(
+                f"rate_limit_per_hour must be non-negative, got {self.rate_limit_per_hour}"
+            )
+
+        # Validate handle_follow_ups
+        valid_follow_up_values = {"ignore", "queue", "auto"}
+        if self.handle_follow_ups not in valid_follow_up_values:
+            errors.append(
+                f"handle_follow_ups must be one of {valid_follow_up_values}, got '{self.handle_follow_ups}'"
+            )
+
+        return errors

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.dev4 → sugarai-3.1.1.dev6}/sugar/discovery/github_watcher.py

@@ -11,6 +11,9 @@ import os
 from datetime import datetime, timedelta, timezone
 from typing import List, Dict, Any, Optional
 
+from ..storage import IssueResponseManager
+from ..config import IssueResponderConfig
+
 # Optional PyGithub import
 try:
     from github import Github, GithubException
@@ -25,11 +28,20 @@ logger = logging.getLogger(__name__)
 class GitHubWatcher:
     """Monitor GitHub repository for issues and pull requests"""
 
-    def __init__(self, config: dict):
+    def __init__(
+        self,
+        config: dict,
+        issue_responder_config: Optional[IssueResponderConfig] = None,
+    ):
         self.config = config
         self.enabled = config.get("enabled", False)
         self.repo_name = config.get("repo", "")
         self.auth_method = config.get("auth_method", "auto")
+        self.issue_responder_config = issue_responder_config
+
+        # Initialize IssueResponseManager
+        db_path = config.get("db_path", ".sugar/sugar.db")
+        self.issue_response_manager = IssueResponseManager(db_path)
 
         if not self.enabled:
             return
@@ -156,6 +168,20 @@ class GitHubWatcher:
         work_items = []
 
         try:
+            # Initialize issue response manager
+            await self.issue_response_manager.initialize()
+
+            # Load issue responder config if not provided in constructor
+            responder_config = self.issue_responder_config
+            if responder_config is None:
+                try:
+                    responder_config = IssueResponderConfig.load_from_file(
+                        ".sugar/config.yaml"
+                    )
+                except (FileNotFoundError, KeyError):
+                    # If config doesn't exist, use default (disabled)
+                    responder_config = IssueResponderConfig()
+
             gh_command = self.config.get("gh_cli", {}).get("command", "gh")
             issue_labels = self.config.get("issue_labels", ["bug", "enhancement"])
 
@@ -163,6 +189,7 @@ class GitHubWatcher:
             self._log_label_filtering_mode(issue_labels)
 
             # Get all open issues first (we'll filter by labels after)
+            # Include author field for bot detection
             cmd = [
                 gh_command,
                 "issue",
@@ -174,7 +201,7 @@ class GitHubWatcher:
                 "--limit",
                 "50",  # Get more issues to filter from
                 "--json",
-                "number,title,body,labels,assignees,comments,createdAt,updatedAt,url",
+                "number,title,body,labels,assignees,comments,createdAt,updatedAt,url,author",
             ]
 
             # Note: We don't use --label flag here because it uses AND logic
@@ -211,6 +238,49 @@ class GitHubWatcher:
             )
 
             for issue in filtered_issues:
+                # Check if issue responder is enabled and should create response work item
+                if responder_config.enabled and self._should_respond_to_issue(
+                    issue, responder_config
+                ):
+                    # Check if we've already responded to this issue
+                    has_responded = await self.issue_response_manager.has_responded(
+                        self.repo_name, issue["number"], "initial"
+                    )
+
+                    if not has_responded:
+                        # Create issue response work item
+                        response_work_item = {
+                            "type": "issue_response",
+                            "title": f"Respond to issue #{issue['number']}: {issue['title']}",
+                            "source_file": f"github://issues/{issue['number']}",
+                            "priority": 2,  # Medium priority
+                            "context": {
+                                "github_issue": {
+                                    "number": issue["number"],
+                                    "title": issue["title"],
+                                    "body": issue.get("body", ""),
+                                    "user": {
+                                        "login": issue.get("author", {}).get(
+                                            "login", "unknown"
+                                        )
+                                    },
+                                    "labels": [
+                                        label["name"]
+                                        for label in issue.get("labels", [])
+                                    ],
+                                    "created_at": issue["createdAt"],
+                                },
+                                "repo": self.repo_name,
+                                "response_type": "initial",
+                            },
+                        }
+                        work_items.append(response_work_item)
+                        logger.debug(
+                            f"Created issue_response work item for #{issue['number']}"
+                        )
+                        continue
+
+                # Create standard work item if not creating a response item
                 work_item = self._create_work_item_from_issue_data(issue)
                 if work_item:
                     work_items.append(work_item)
@@ -225,6 +295,20 @@ class GitHubWatcher:
         work_items = []
 
         try:
+            # Initialize issue response manager
+            await self.issue_response_manager.initialize()
+
+            # Load issue responder config if not provided in constructor
+            responder_config = self.issue_responder_config
+            if responder_config is None:
+                try:
+                    responder_config = IssueResponderConfig.load_from_file(
+                        ".sugar/config.yaml"
+                    )
+                except (FileNotFoundError, KeyError):
+                    # If config doesn't exist, use default (disabled)
+                    responder_config = IssueResponderConfig()
+
             # Get recent issues
             since = datetime.now(timezone.utc) - timedelta(days=7)
             repo = self.github.get_repo(self.repo_name)
@@ -263,8 +347,50 @@ class GitHubWatcher:
                     "createdAt": issue.created_at.isoformat(),
                     "updatedAt": issue.updated_at.isoformat(),
                     "url": issue.html_url,
+                    "author": {"login": issue.user.login},
                 }
 
+                # Check if issue responder is enabled and should create response work item
+                if responder_config.enabled and self._should_respond_to_issue(
+                    issue_data, responder_config
+                ):
+                    # Check if we've already responded to this issue
+                    has_responded = await self.issue_response_manager.has_responded(
+                        self.repo_name, issue.number, "initial"
+                    )
+
+                    if not has_responded:
+                        # Create issue response work item
+                        response_work_item = {
+                            "type": "issue_response",
+                            "title": f"Respond to issue #{issue.number}: {issue.title}",
+                            "source_file": f"github://issues/{issue.number}",
+                            "priority": 2,  # Medium priority
+                            "context": {
+                                "github_issue": {
+                                    "number": issue.number,
+                                    "title": issue.title,
+                                    "body": issue.body or "",
+                                    "user": {"login": issue.user.login},
+                                    "labels": [label.name for label in issue.labels],
+                                    "created_at": issue.created_at.isoformat(),
+                                },
+                                "repo": self.repo_name,
+                                "response_type": "initial",
+                            },
+                        }
+                        work_items.append(response_work_item)
+                        logger.debug(
+                            f"Created issue_response work item for #{issue.number}"
+                        )
+                        processed_count += 1
+
+                        # Limit to 10 issues after filtering
+                        if processed_count >= 10:
+                            break
+                        continue
+
+                # Create standard work item if not creating a response item
                 work_item = self._create_work_item_from_issue_data(issue_data)
                 if work_item:
                     work_items.append(work_item)
@@ -552,6 +678,32 @@ class GitHubWatcher:
             logger.error(f"Error using PyGithub to assign: {e}")
             return False
 
+    def _should_respond_to_issue(
+        self, issue: dict, config: IssueResponderConfig
+    ) -> bool:
+        """Check if we should create a response work item for this issue"""
+        # Check bot issues
+        if config.skip_bot_issues:
+            author = issue.get("author", {}).get("login", "")
+            if author.endswith("[bot]") or "[bot]" in author:
+                return False
+
+        # Check skip labels
+        issue_labels = [l.get("name", "") for l in issue.get("labels", [])]
+        for skip_label in config.skip_labels:
+            if skip_label in issue_labels:
+                return False
+
+        # Check respond_to_labels (if not empty, issue must have one of these)
+        if config.respond_to_labels:
+            has_matching_label = any(
+                label in issue_labels for label in config.respond_to_labels
+            )
+            if not has_matching_label:
+                return False
+
+        return True
+
     def _should_include_issue_by_labels(
         self, issue_labels: list, config_labels: list, original_config: list
     ) -> bool:

{sugarai-3.1.1.dev4 → sugarai-3.1.1.dev6}/sugar/executor/agent_sdk_executor.py

@@ -16,6 +16,10 @@ from typing import Any, Dict, List, Optional
 
 from .base import BaseExecutor, ExecutionResult
 from ..agent import SugarAgent, SugarAgentConfig
+from ..storage import IssueResponseManager
+from ..profiles import IssueResponderProfile
+from ..config import IssueResponderConfig
+from ..integrations import GitHubClient
 
 logger = logging.getLogger(__name__)
 
@@ -83,6 +87,76 @@ class AgentSDKExecutor(BaseExecutor):
             )
         return self._agent
 
+    async def _execute_issue_response(self, work_item: Dict) -> Dict:
+        """Execute an issue response task using IssueResponderProfile"""
+        # Extract issue data from work_item context
+        context = work_item.get("context", {})
+        issue_data = context.get("github_issue", {})
+        repo = context.get("repo", "")
+
+        # Load config
+        config = IssueResponderConfig.load_from_file(".sugar/config.yaml")
+
+        # Create profile with config settings
+        profile = IssueResponderProfile()
+        profile.config.settings["max_response_length"] = config.max_response_length
+        profile.config.settings["auto_post_threshold"] = config.auto_post_threshold
+
+        # Process input
+        input_data = {"issue": issue_data, "repo": repo}
+        processed = await profile.process_input(input_data)
+
+        # Execute with agent
+        agent_config = SugarAgentConfig(
+            model=config.model,
+            permission_mode="default",
+            allowed_tools=["Read", "Glob", "Grep"],
+            system_prompt_additions=profile.get_system_prompt({"repo": repo}),
+        )
+
+        agent = SugarAgent(agent_config)
+        await agent.start_session()
+
+        try:
+            response = await agent.execute(processed["prompt"])
+            output_data = {"content": response.content}
+            result = await profile.process_output(output_data)
+
+            response_data = result.get("response", {})
+            confidence = response_data.get("confidence", 0.0)
+            content = response_data.get("content", "")
+
+            # Check if should auto-post
+            should_post = confidence >= config.auto_post_threshold
+
+            if should_post:
+                # Post to GitHub
+                client = GitHubClient(repo=repo)
+                client.post_comment(issue_data["number"], content)
+
+                # Record response
+                manager = IssueResponseManager()
+                await manager.initialize()
+                await manager.record_response(
+                    repo=repo,
+                    issue_number=issue_data["number"],
+                    response_type="initial",
+                    confidence=confidence,
+                    response_content=content,
+                    labels_applied=response_data.get("suggested_labels", []),
+                    was_auto_posted=True,
+                    work_item_id=work_item.get("id"),
+                )
+
+            return {
+                "success": True,
+                "posted": should_post,
+                "confidence": confidence,
+                "content": content,
+            }
+        finally:
+            await agent.end_session()
+
     async def execute_work(self, work_item: Dict[str, Any]) -> Dict[str, Any]:
         """
         Execute a work item using the Claude Agent SDK.
@@ -93,6 +167,12 @@ class AgentSDKExecutor(BaseExecutor):
         Returns:
             Result dictionary compatible with Sugar's workflow
         """
+        # Check for specialized task types
+        task_type = work_item.get("type", "")
+
+        if task_type == "issue_response":
+            return await self._execute_issue_response(work_item)
+
         if self.dry_run:
             logger.info(f"DRY RUN: Simulating execution of {work_item.get('title')}")
             return await self._simulate_execution(work_item)