sugarai 3.1.1.dev3__tar.gz → 3.1.1.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sugarai
-Version: 3.1.1.dev3
+Version: 3.1.1.dev5
 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

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

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

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

sugarai-3.1.1.dev5/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.dev3 → sugarai-3.1.1.dev5}/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.dev3 → sugarai-3.1.1.dev5}/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)

{sugarai-3.1.1.dev3 → sugarai-3.1.1.dev5}/sugar/main.py

@@ -2126,6 +2126,29 @@ sugar:
   workflow:
     # Profiles: solo (direct commits), balanced (PRs), enterprise (full governance)
     profile: "solo"
+
+  # Issue Responder (AI-powered issue responses)
+  issue_responder:
+    enabled: false              # Enable automatic issue responses
+
+    # Response behavior
+    auto_post_threshold: 0.8    # Min confidence to auto-post (0.0-1.0)
+    max_response_length: 2000   # Max chars per response
+    response_delay_seconds: 0   # Delay before posting (0 = immediate)
+
+    # Rate limiting
+    rate_limit_per_hour: 10     # Max responses per hour (0 = unlimited)
+
+    # Issue filtering
+    respond_to_labels: []       # Empty = all issues, or ["question", "bug"]
+    skip_labels: ["wontfix", "duplicate", "stale"]
+    skip_bot_issues: true       # Skip issues created by bots
+
+    # Follow-up handling
+    handle_follow_ups: "ignore" # "ignore" | "queue" | "auto"
+
+    # Model selection
+    model: "claude-sonnet-4-20250514"
 """
 
 
@@ -3203,9 +3226,14 @@ def issue_analyze(ctx, issue_number, repo, output_format):
 @click.option(
     "--dry-run", is_flag=True, help="Show what would be posted without posting"
 )
+@click.option(
+    "--max-length",
+    default=2000,
+    help="Maximum response length in characters (default: 2000)",
+)
 @click.pass_context
 def issue_respond(
-    ctx, issue_number, repo, post, force_post, confidence_threshold, dry_run
+    ctx, issue_number, repo, post, force_post, confidence_threshold, dry_run, max_length
 ):
     """Generate an AI response to a GitHub issue
 
@@ -3234,6 +3262,7 @@ def issue_respond(
 
         # Process with IssueResponderProfile
         profile = IssueResponderProfile()
+        profile.config.settings["max_response_length"] = max_length
         input_data = {"issue": issue.to_dict(), "repo": repo or ""}
         processed = await profile.process_input(input_data)
 

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

@@ -232,16 +232,20 @@ Provide your response in this format:
         # Build the response
         response_content = parsed.get("response", content)
 
-        # Add signature if configured
+        # Get signature
+        signature = ""
         if self.config.settings.get("include_signature", True):
             signature = self.config.settings.get("signature", "")
-            if signature and signature not in response_content:
-                response_content += signature
 
-        # Truncate if needed
+        # Truncate if needed (reserve space for signature)
         max_length = self.config.settings.get("max_response_length", 2000)
-        if len(response_content) > max_length:
-            response_content = response_content[: max_length - 3] + "..."
+        content_max = max_length - len(signature) if signature else max_length
+        if len(response_content) > content_max:
+            response_content = response_content[: content_max - 3] + "..."
+
+        # Add signature after truncation
+        if signature and signature not in response_content:
+            response_content += signature
 
         confidence = parsed.get("confidence", 0.5)
         auto_post_threshold = self.config.settings.get("auto_post_threshold", 0.8)

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

@@ -0,0 +1,5 @@
+from .work_queue import WorkQueue
+from .task_type_manager import TaskTypeManager
+from .issue_response_manager import IssueResponseManager
+
+__all__ = ["WorkQueue", "TaskTypeManager", "IssueResponseManager"]