devforgeai 1.0.5 → 1.0.7

package/src/claude/scripts/devforgeai_cli/feedback/validation.py

@@ -0,0 +1,163 @@
+"""
+Feedback validation utilities
+"""
+
+import re
+from typing import Tuple, List, Optional
+
+
+def validate_response_length(response: str, min_length: int = 5, max_length: int = 10000, warn_threshold: int = 2000) -> Tuple[bool, Optional[str]]:
+    """
+    Validate response length.
+
+    Args:
+        response: Response text
+        min_length: Minimum length (default: 5)
+        max_length: Maximum length (default: 10000)
+        warn_threshold: Threshold for warning (default: 2000)
+
+    Returns:
+        Tuple of (is_valid, warning_message)
+    """
+    length = len(response)
+
+    if length < min_length:
+        return False, f"Response too short (minimum {min_length} characters)"
+
+    if length > max_length:
+        return False, f"Response too long (maximum {max_length} characters)"
+
+    if length > warn_threshold:
+        return True, f"Response is long ({length} chars). Consider being more concise."
+
+    return True, None
+
+
+def detect_spam(text: str) -> bool:
+    """
+    Detect spam or noise in feedback.
+
+    Args:
+        text: Text to check
+
+    Returns:
+        True if spam detected, False otherwise
+    """
+    if len(text) == 0:
+        return True
+
+    # Check for character repetition (e.g., "aaaaaaa")
+    if len(set(text)) <= 3 and len(text) > 10:
+        return True
+
+    # Check for pattern repetition (e.g., "123412341234")
+    if len(text) > 20:
+        for pattern_len in range(3, 10):
+            pattern = text[:pattern_len]
+            if text == pattern * (len(text) // pattern_len):
+                return True
+
+    # Check for low word count
+    words = text.split()
+    if len(words) < 5 and len(text) > 50:
+        return True
+
+    # Check for non-alphanumeric ratio
+    alphanumeric_count = sum(c.isalnum() or c.isspace() for c in text)
+    if len(text) > 20 and alphanumeric_count / len(text) < 0.1:
+        return True
+
+    return False
+
+
+def is_coherent_text(text: str) -> bool:
+    """
+    Check if text is coherent (not random repetition).
+
+    Args:
+        text: Text to check
+
+    Returns:
+        True if coherent, False otherwise
+    """
+    if len(text) < 5:
+        return True
+
+    # Check for single character repetition
+    if len(set(text)) == 1:
+        return False
+
+    # Check for pattern repetition (check all possible pattern lengths)
+    for pattern_len in range(2, min(len(text) // 3 + 1, 10)):
+        pattern = text[:pattern_len]
+        repetitions = len(text) // pattern_len
+        # Check if text consists of repeated pattern
+        if repetitions >= 3:
+            reconstructed = pattern * repetitions
+            # Also check for partial match at end
+            if text == reconstructed or text == reconstructed + pattern[:len(text) - len(reconstructed)]:
+                return False
+
+    return True
+
+
+def check_sensitive_content(feedback: str) -> Tuple[bool, List[str]]:
+    """
+    Check if feedback contains sensitive content.
+
+    Args:
+        feedback: Feedback text
+
+    Returns:
+        Tuple of (is_sensitive, detected_types)
+    """
+    detected_types = []
+    text_lower = feedback.lower()
+
+    # Check for API keys or secrets (specific patterns first)
+    if re.search(r'sk-[a-zA-Z0-9]{20,}', feedback):
+        detected_types.append('secret')
+    elif re.search(r'(api[_\s-]?key)\s*[:=]?\s*[\w-]+', text_lower):
+        detected_types.append('api_key')
+
+    # Check for data loss concerns
+    if any(phrase in text_lower for phrase in ['data loss', 'deleted', 'lost data', 'production database']):
+        detected_types.append('data_loss')
+
+    # Check for critical issues (but not if it's just the word "exposed" from "api key exposed")
+    if any(phrase in text_lower for phrase in ['security breach', 'vulnerability']):
+        if 'api_key' not in detected_types and 'secret' not in detected_types:
+            detected_types.append('critical_issue')
+
+    return len(detected_types) > 0, detected_types
+
+
+def validate_story_id(story_id: str) -> bool:
+    """
+    Validate story ID format.
+
+    Args:
+        story_id: Story ID to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    pattern = r'^STORY-\d+$'
+    return bool(re.match(pattern, story_id))
+
+
+def validate_workflow_type(workflow_type: str) -> bool:
+    """
+    Validate workflow type.
+
+    Args:
+        workflow_type: Workflow type to validate
+
+    Returns:
+        True if valid, False otherwise
+    """
+    valid_types = [
+        'dev', 'qa', 'orchestrate', 'release', 'ideate',
+        'create-story', 'create-epic', 'create-sprint'
+    ]
+    return workflow_type in valid_types

package/src/claude/scripts/devforgeai_cli/headless/__init__.py

@@ -0,0 +1,30 @@
+"""
+Headless mode answer resolution for CI/CD pipelines (STORY-098).
+
+This package provides configuration-based answer resolution for AskUserQuestion
+prompts when running in headless mode (CI=true or -p flag).
+"""
+
+from .exceptions import HeadlessResolutionError, ConfigurationError
+from .answer_models import (
+    AnswerEntry,
+    HeadlessModeSettings,
+    DefaultSettings,
+    HeadlessAnswerConfiguration,
+    load_config,
+)
+from .pattern_matcher import PromptPatternMatcher, MatchResult
+from .answer_resolver import HeadlessAnswerResolver
+
+__all__ = [
+    "HeadlessResolutionError",
+    "ConfigurationError",
+    "AnswerEntry",
+    "HeadlessModeSettings",
+    "DefaultSettings",
+    "HeadlessAnswerConfiguration",
+    "load_config",
+    "PromptPatternMatcher",
+    "MatchResult",
+    "HeadlessAnswerResolver",
+]

package/src/claude/scripts/devforgeai_cli/headless/answer_models.py

@@ -0,0 +1,206 @@
+"""
+Configuration models for headless answer resolution (STORY-098).
+
+Follows patterns from feedback/config_manager.py and config_models.py.
+"""
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Optional, Any, List
+
+import yaml
+
+from .exceptions import ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+# Valid values for defaults.unknown_prompt
+VALID_DEFAULT_STRATEGIES = ["fail", "first_option", "skip"]
+
+
+@dataclass
+class AnswerEntry:
+    """Single answer configuration with pattern and answer."""
+
+    pattern: str
+    answer: str
+    description: Optional[str] = None
+
+    def __post_init__(self):
+        if not self.pattern:
+            raise ValueError("AnswerEntry requires a pattern")
+        if not self.answer:
+            raise ValueError("AnswerEntry requires an answer")
+
+
+@dataclass
+class HeadlessModeSettings:
+    """Headless mode configuration settings."""
+
+    enabled: bool = True
+    fail_on_unanswered: bool = True
+    log_matches: bool = True
+
+    def __post_init__(self):
+        if not isinstance(self.enabled, bool):
+            raise TypeError(f"enabled must be boolean, got {type(self.enabled).__name__}")
+        if not isinstance(self.fail_on_unanswered, bool):
+            raise TypeError(
+                f"fail_on_unanswered must be boolean, got {type(self.fail_on_unanswered).__name__}"
+            )
+        if not isinstance(self.log_matches, bool):
+            raise TypeError(f"log_matches must be boolean, got {type(self.log_matches).__name__}")
+
+
+@dataclass
+class DefaultSettings:
+    """Default behavior settings for unmatched prompts."""
+
+    unknown_prompt: str = "fail"
+
+    def __post_init__(self):
+        if self.unknown_prompt not in VALID_DEFAULT_STRATEGIES:
+            raise ValueError(
+                f"unknown_prompt must be one of {VALID_DEFAULT_STRATEGIES}, "
+                f"got '{self.unknown_prompt}'"
+            )
+
+
+@dataclass
+class HeadlessAnswerConfiguration:
+    """Complete headless answer configuration."""
+
+    headless_mode: HeadlessModeSettings
+    answers: Dict[str, AnswerEntry]
+    defaults: DefaultSettings
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "HeadlessAnswerConfiguration":
+        """Create configuration from dictionary."""
+        # Parse headless_mode section
+        hm_data = data.get("headless_mode", {})
+        headless_mode = HeadlessModeSettings(
+            enabled=hm_data.get("enabled", True),
+            fail_on_unanswered=hm_data.get("fail_on_unanswered", True),
+            log_matches=hm_data.get("log_matches", True),
+        )
+
+        # Parse answers section
+        answers_data = data.get("answers", {})
+        answers = {}
+        for key, entry in answers_data.items():
+            if isinstance(entry, dict):
+                # Validate regex pattern
+                pattern = entry.get("pattern", "")
+                try:
+                    re.compile(pattern, re.IGNORECASE)
+                except re.error as e:
+                    logger.warning(f"Invalid regex pattern for '{key}': {pattern} - {e}")
+
+                answers[key] = AnswerEntry(
+                    pattern=pattern,
+                    answer=entry.get("answer", ""),
+                    description=entry.get("description"),
+                )
+
+        # Parse defaults section
+        defaults_data = data.get("defaults", {})
+        defaults = DefaultSettings(unknown_prompt=defaults_data.get("unknown_prompt", "fail"))
+
+        return cls(headless_mode=headless_mode, answers=answers, defaults=defaults)
+
+
+def _detect_flat_format(data: Dict[str, Any]) -> bool:
+    """Detect if config is in legacy flat format."""
+    flat_keys = {
+        "test_failure_action",
+        "deferral_strategy",
+        "priority_default",
+        "technology_choice",
+        "circular_dependency_action",
+        "git_conflict_strategy",
+        "custom_answers",
+    }
+    return bool(flat_keys.intersection(data.keys()))
+
+
+def _migrate_flat_to_nested(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Migrate flat format to nested format with deprecation warning."""
+    logger.warning(
+        "Flat ci-answers.yaml format is deprecated. "
+        "Please migrate to nested format with headless_mode, answers, and defaults sections."
+    )
+
+    # Map flat keys to patterns
+    key_to_pattern = {
+        "test_failure_action": "Tests failed.*How should we proceed",
+        "deferral_strategy": "Do you approve this deferral",
+        "priority_default": "What is the story priority",
+        "technology_choice": "technology.*not specified",
+        "circular_dependency_action": "circular dependency",
+        "git_conflict_strategy": "Git conflict",
+    }
+
+    answers = {}
+    for key, pattern in key_to_pattern.items():
+        if key in data:
+            answers[key] = {"pattern": pattern, "answer": str(data[key])}
+
+    # Handle custom_answers if present
+    custom = data.get("custom_answers", {})
+    if isinstance(custom, dict):
+        for pattern, answer in custom.items():
+            safe_key = re.sub(r"[^a-zA-Z0-9_]", "_", pattern)[:50]
+            answers[f"custom_{safe_key}"] = {"pattern": pattern, "answer": str(answer)}
+
+    return {
+        "headless_mode": {"enabled": True, "fail_on_unanswered": True, "log_matches": True},
+        "answers": answers,
+        "defaults": {"unknown_prompt": "fail"},
+    }
+
+
+def load_config(config_path: Path) -> HeadlessAnswerConfiguration:
+    """
+    Load and validate configuration from YAML file.
+
+    AC#5: Answer Validation on Load
+    - Validates YAML syntax
+    - Validates required fields
+    - Validates field types and enum values
+
+    Args:
+        config_path: Path to ci-answers.yaml file
+
+    Returns:
+        HeadlessAnswerConfiguration object
+
+    Raises:
+        ConfigurationError: If YAML is malformed
+        ValueError: If required fields are missing or invalid
+        KeyError: If required sections are missing
+    """
+    if not config_path.exists():
+        raise ConfigurationError(f"Configuration file not found: {config_path}")
+
+    try:
+        with open(config_path, "r") as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        line = getattr(e, "problem_mark", None)
+        line_num = line.line + 1 if line else None
+        raise ConfigurationError(f"YAML parsing error: {e}", line_number=line_num)
+
+    if data is None:
+        raise ConfigurationError("Empty configuration file")
+
+    # Check for flat format and migrate
+    if _detect_flat_format(data):
+        data = _migrate_flat_to_nested(data)
+
+    # Validate required sections for nested format
+    if "defaults" not in data:
+        raise ValueError("Configuration missing required 'defaults' section")
+
+    return HeadlessAnswerConfiguration.from_dict(data)

package/src/claude/scripts/devforgeai_cli/headless/answer_resolver.py

@@ -0,0 +1,204 @@
+"""
+HeadlessAnswerResolver service (STORY-098).
+
+Main entry point for resolving AskUserQuestion prompts in headless mode.
+Follows singleton pattern from feedback/config_manager.py.
+
+AC#1: CI Answers Configuration File
+- Loads from devforgeai/config/ci-answers.yaml with fallbacks
+- Supports both nested (preferred) and flat (deprecated) formats
+
+AC#3: Fail-on-Unanswered Mode
+- Raises HeadlessResolutionError when fail_on_unanswered=true and no match
+
+BR-002: Interactive mode ignores ci-answers.yaml
+- Only resolves when is_headless_mode() returns True
+"""
+import logging
+import os
+import threading
+from pathlib import Path
+from typing import List, Optional
+
+from .answer_models import HeadlessAnswerConfiguration, load_config
+from .exceptions import HeadlessResolutionError, ConfigurationError
+from .pattern_matcher import PromptPatternMatcher, MatchResult
+
+logger = logging.getLogger(__name__)
+
+
+class HeadlessAnswerResolver:
+    """
+    Resolves AskUserQuestion prompts from CI configuration.
+
+    Singleton pattern for consistent configuration across invocations.
+    """
+
+    _instance: Optional["HeadlessAnswerResolver"] = None
+    _lock = threading.Lock()
+
+    def __init__(
+        self,
+        config_path: Optional[Path] = None,
+        search_paths: Optional[List[Path]] = None,
+    ):
+        """
+        Initialize resolver with configuration path.
+
+        Args:
+            config_path: Explicit path to ci-answers.yaml
+            search_paths: List of paths to search for config (in order)
+        """
+        self._config_path = config_path
+        self._search_paths = search_paths or self._default_search_paths()
+        self._config: Optional[HeadlessAnswerConfiguration] = None
+        self._matcher: Optional[PromptPatternMatcher] = None
+        self._loaded = False
+
+    @staticmethod
+    def _default_search_paths() -> List[Path]:
+        """Default paths to search for ci-answers.yaml."""
+        cwd = Path.cwd()
+        return [
+            cwd / "devforgeai" / "config" / "ci-answers.yaml",
+            cwd / "devforgeai" / "config" / "ci" / "ci-answers.yaml",
+            Path.home() / "devforgeai" / "config" / "ci-answers.yaml",
+        ]
+
+    def _find_config_file(self) -> Optional[Path]:
+        """Find ci-answers.yaml in search paths."""
+        if self._config_path and self._config_path.exists():
+            return self._config_path
+
+        for path in self._search_paths:
+            if path.exists():
+                logger.debug(f"Found ci-answers.yaml at: {path}")
+                return path
+
+        return None
+
+    @classmethod
+    def get_instance(cls) -> "HeadlessAnswerResolver":
+        """
+        Get singleton instance.
+
+        Thread-safe singleton pattern following config_manager.py.
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        """Reset singleton instance (for testing)."""
+        with cls._lock:
+            cls._instance = None
+
+    def is_configured(self) -> bool:
+        """Check if configuration file exists."""
+        return self._find_config_file() is not None
+
+    def is_headless_mode(self) -> bool:
+        """
+        Check if running in headless mode.
+
+        Detects:
+        - CI=true environment variable
+        - DEVFORGEAI_HEADLESS=true environment variable
+        - Non-interactive terminal (stdin not a tty)
+        """
+        if os.environ.get("CI") == "true":
+            return True
+        if os.environ.get("DEVFORGEAI_HEADLESS") == "true":
+            return True
+        # Check if stdin is a tty (interactive)
+        try:
+            return not os.isatty(0)
+        except Exception:
+            return False
+
+    def load_configuration(self) -> HeadlessAnswerConfiguration:
+        """
+        Load configuration from file.
+
+        AC#1: CI Answers Configuration File
+        - Reads from configured path or search paths
+        - Validates configuration on load (AC#5)
+
+        Returns:
+            HeadlessAnswerConfiguration object
+
+        Raises:
+            ConfigurationError: If config file not found or invalid
+        """
+        if self._loaded and self._config:
+            return self._config
+
+        config_path = self._find_config_file()
+        if config_path is None:
+            if self._config_path:
+                raise ConfigurationError(f"Configuration file not found: {self._config_path}")
+            raise ConfigurationError(
+                "No ci-answers.yaml found in search paths: "
+                + ", ".join(str(p) for p in self._search_paths)
+            )
+
+        self._config = load_config(config_path)
+        self._loaded = True
+
+        # Initialize pattern matcher
+        self._matcher = PromptPatternMatcher(
+            patterns={k: {"pattern": v.pattern, "answer": v.answer} for k, v in self._config.answers.items()},
+            default_strategy=self._config.defaults.unknown_prompt,
+            log_matches=self._config.headless_mode.log_matches,
+        )
+
+        logger.info(f"Loaded headless configuration from: {config_path}")
+        return self._config
+
+    def resolve(
+        self, prompt_text: str, options: List[str]
+    ) -> Optional[str]:
+        """
+        Resolve prompt to configured answer.
+
+        AC#2: Answer Matching Logic
+        - Matches prompt text against configured patterns
+        - Returns first matching answer
+
+        AC#3: Fail-on-Unanswered Mode
+        - Raises HeadlessResolutionError if no match and fail_on_unanswered=true
+
+        AC#4: Default Answer Fallback
+        - Uses default strategy when no pattern matches
+
+        Args:
+            prompt_text: The AskUserQuestion prompt text
+            options: Available answer options
+
+        Returns:
+            Selected answer string, or None if skip strategy
+
+        Raises:
+            HeadlessResolutionError: If no match and fail strategy
+        """
+        if not self._loaded:
+            self.load_configuration()
+
+        if self._matcher is None:
+            raise ConfigurationError("Configuration not loaded")
+
+        # Check fail_on_unanswered setting
+        if self._config and self._config.headless_mode.fail_on_unanswered:
+            # Use fail strategy if configured
+            result = self._matcher.match(prompt_text)
+            if result:
+                return result.answer
+            # No match - apply fail_on_unanswered
+            raise HeadlessResolutionError(prompt_text)
+
+        # Use default strategy
+        result = self._matcher.match_with_fallback(prompt_text, options)
+        return result.answer if result else None

package/src/claude/scripts/devforgeai_cli/headless/exceptions.py

@@ -0,0 +1,36 @@
+"""
+Exceptions for headless mode answer resolution (STORY-098).
+"""
+
+
+class HeadlessResolutionError(Exception):
+    """
+    Raised when a prompt cannot be resolved in headless mode.
+
+    AC#3: Fail-on-Unanswered Mode
+    - When fail_on_unanswered: true and no matching answer exists
+    - Error message includes prompt text for debugging
+    """
+
+    def __init__(self, prompt_text: str, message: str = None):
+        self.prompt_text = prompt_text
+        if message is None:
+            message = f"Headless mode: No answer configured for prompt '{prompt_text}'"
+        super().__init__(message)
+
+
+class ConfigurationError(Exception):
+    """
+    Raised when ci-answers.yaml configuration is invalid.
+
+    AC#5: Answer Validation on Load
+    - Invalid YAML syntax
+    - Missing required fields
+    - Invalid field values
+    """
+
+    def __init__(self, message: str, line_number: int = None):
+        self.line_number = line_number
+        if line_number:
+            message = f"{message} (line {line_number})"
+        super().__init__(message)