ouroboros-ai 0.2.1__tar.gz → 0.2.3__tar.gz

{ouroboros_ai-0.2.1 → ouroboros_ai-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.2.1
+Version: 0.2.3
 Summary: Self-Improving AI Workflow System
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.2.1 → ouroboros_ai-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ouroboros-ai"
-version = "0.2.1"
+version = "0.2.3"
 description = "Self-Improving AI Workflow System"
 readme = "README.md"
 authors = [

{ouroboros_ai-0.2.1 → ouroboros_ai-0.2.3}/src/ouroboros/bigbang/ambiguity.py

@@ -9,6 +9,8 @@ The scoring algorithm evaluates three key components:
 - Success Criteria Clarity (30%): How measurable the success criteria are
 """
 
+import json
+import re
 from dataclasses import dataclass
 from typing import Any
 
@@ -110,15 +112,15 @@ class AmbiguityScorer:
     from interview conversation, producing reproducible scores.
 
     Uses adaptive token allocation: starts with `initial_max_tokens` and
-    doubles on truncation up to `MAX_TOKEN_LIMIT`. Retries up to `max_retries`
-    times on both provider errors and parse failures.
+    doubles on truncation up to `MAX_TOKEN_LIMIT`. Retries until success
+    by default (unlimited), or up to `max_retries` if specified.
 
     Attributes:
         llm_adapter: The LLM adapter for completions.
         model: Model identifier to use.
         temperature: Temperature for reproducibility (default 0.1).
         initial_max_tokens: Starting token limit (default 2048).
-        max_retries: Maximum retry attempts (default 3).
+        max_retries: Maximum retry attempts, or None for unlimited (default).
 
     Example:
         scorer = AmbiguityScorer(llm_adapter=LiteLLMAdapter())
@@ -138,7 +140,8 @@ class AmbiguityScorer:
     model: str = DEFAULT_MODEL
     temperature: float = SCORING_TEMPERATURE
     initial_max_tokens: int = 2048
-    max_retries: int = 3
+    max_retries: int | None = None  # None = unlimited retries
+    max_format_error_retries: int = 5  # Stop after N format errors (non-truncation)
 
     async def score(
         self, state: InterviewState
@@ -180,8 +183,15 @@ class AmbiguityScorer:
         current_max_tokens = self.initial_max_tokens
         last_error: Exception | ProviderError | None = None
         last_response: str = ""
+        attempt = 0
+
+        while True:
+            # Check retry limit if set
+            if self.max_retries is not None and attempt >= self.max_retries:
+                break
+
+            attempt += 1
 
-        for attempt in range(self.max_retries):
             config = CompletionConfig(
                 model=self.model,
                 temperature=self.temperature,
@@ -190,15 +200,15 @@ class AmbiguityScorer:
 
             result = await self.llm_adapter.complete(messages, config)
 
-            # Fix #3: Retry on provider errors (rate limits, transient failures)
+            # Retry on provider errors (rate limits, transient failures)
             if result.is_err:
                 last_error = result.error
                 log.warning(
                     "ambiguity.scoring.provider_error_retrying",
                     interview_id=state.interview_id,
                     error=str(result.error),
-                    attempt=attempt + 1,
-                    max_retries=self.max_retries,
+                    attempt=attempt,
+                    max_retries=self.max_retries or "unlimited",
                 )
                 continue
 
@@ -221,7 +231,7 @@ class AmbiguityScorer:
                     constraint_clarity=breakdown.constraint_clarity.clarity_score,
                     success_criteria_clarity=breakdown.success_criteria_clarity.clarity_score,
                     tokens_used=current_max_tokens,
-                    attempt=attempt + 1,
+                    attempt=attempt,
                 )
 
                 return Result.ok(ambiguity_score)
@@ -230,11 +240,11 @@ class AmbiguityScorer:
                 last_error = e
                 last_response = result.value.content
 
-                # Fix #2: Only increase tokens if response was truncated
+                # Only increase tokens if response was truncated
                 is_truncated = result.value.finish_reason == "length"
 
                 if is_truncated:
-                    # Double tokens on truncation (no upper limit)
+                    # Double tokens on truncation, capped at MAX_TOKEN_LIMIT if set
                     next_tokens = current_max_tokens * 2
                     if MAX_TOKEN_LIMIT is not None:
                         next_tokens = min(next_tokens, MAX_TOKEN_LIMIT)
@@ -242,7 +252,7 @@ class AmbiguityScorer:
                         "ambiguity.scoring.truncated_retrying",
                         interview_id=state.interview_id,
                         error=str(e),
-                        attempt=attempt + 1,
+                        attempt=attempt,
                         current_tokens=current_max_tokens,
                         next_tokens=next_tokens,
                     )
@@ -253,11 +263,11 @@ class AmbiguityScorer:
                         "ambiguity.scoring.format_error_retrying",
                         interview_id=state.interview_id,
                         error=str(e),
-                        attempt=attempt + 1,
+                        attempt=attempt,
                         finish_reason=result.value.finish_reason,
                     )
 
-        # All retries exhausted
+        # All retries exhausted (only reached if max_retries is set)
         log.warning(
             "ambiguity.scoring.failed",
             interview_id=state.interview_id,
@@ -296,38 +306,19 @@ class AmbiguityScorer:
         Returns:
             System prompt string.
         """
-        return """You are an expert requirements analyst evaluating the clarity of software requirements.
-
-Your task is to assess how clear and unambiguous the requirements are based on an interview conversation.
+        return """You are an expert requirements analyst. Evaluate the clarity of software requirements.
 
 Evaluate three components:
-1. Goal Clarity (40% weight): Is the goal statement specific and well-defined?
-   - Clear: "Build a CLI tool for task management with project grouping"
-   - Unclear: "Build something useful for productivity"
-
-2. Constraint Clarity (30% weight): Are constraints and limitations specified?
-   - Clear: "Must use Python 3.14+, no external database dependencies"
-   - Unclear: No mention of technical constraints or limitations
-
-3. Success Criteria Clarity (30% weight): Are success criteria measurable?
-   - Clear: "Tasks can be created, edited, deleted; supports filtering by status"
-   - Unclear: "The tool should be easy to use"
+1. Goal Clarity (40%): Is the goal specific and well-defined?
+2. Constraint Clarity (30%): Are constraints and limitations specified?
+3. Success Criteria Clarity (30%): Are success criteria measurable?
 
-For each component, provide:
-- A clarity score between 0.0 (completely unclear) and 1.0 (perfectly clear)
-- A brief justification (1-2 sentences max) explaining the score
+Score each from 0.0 (unclear) to 1.0 (perfectly clear). Scores above 0.8 require very specific requirements.
 
-IMPORTANT: You MUST provide ALL six fields below. Keep justifications concise.
+RESPOND ONLY WITH VALID JSON. No other text before or after.
 
-Respond in this exact format:
-GOAL_CLARITY_SCORE: <score>
-GOAL_CLARITY_JUSTIFICATION: <justification in 1-2 sentences>
-CONSTRAINT_CLARITY_SCORE: <score>
-CONSTRAINT_CLARITY_JUSTIFICATION: <justification in 1-2 sentences>
-SUCCESS_CRITERIA_CLARITY_SCORE: <score>
-SUCCESS_CRITERIA_CLARITY_JUSTIFICATION: <justification in 1-2 sentences>
-
-Be strict in your evaluation. Scores above 0.8 require very specific, measurable requirements."""
+Required JSON format:
+{"goal_clarity_score": 0.0, "goal_clarity_justification": "string", "constraint_clarity_score": 0.0, "constraint_clarity_justification": "string", "success_criteria_clarity_score": 0.0, "success_criteria_clarity_justification": "string"}"""
 
     def _build_scoring_user_prompt(self, context: str) -> str:
         """Build user prompt with interview context.
@@ -358,27 +349,23 @@ Analyze each component and provide scores with justifications."""
         Raises:
             ValueError: If response cannot be parsed.
         """
-        lines = response.strip().split("\n")
-        scores: dict[str, Any] = {}
-
-        for line in lines:
-            line = line.strip()
-            if not line:
-                continue
-
-            for prefix in [
-                "GOAL_CLARITY_SCORE:",
-                "GOAL_CLARITY_JUSTIFICATION:",
-                "CONSTRAINT_CLARITY_SCORE:",
-                "CONSTRAINT_CLARITY_JUSTIFICATION:",
-                "SUCCESS_CRITERIA_CLARITY_SCORE:",
-                "SUCCESS_CRITERIA_CLARITY_JUSTIFICATION:",
-            ]:
-                if line.startswith(prefix):
-                    key = prefix[:-1].lower()  # Remove colon and lowercase
-                    value = line[len(prefix) :].strip()
-                    scores[key] = value
-                    break
+        # Extract JSON from response (handle markdown code blocks)
+        text = response.strip()
+
+        # Try to find JSON in markdown code block
+        json_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
+        if json_match:
+            text = json_match.group(1)
+        else:
+            # Try to find raw JSON object
+            json_match = re.search(r"\{.*\}", text, re.DOTALL)
+            if json_match:
+                text = json_match.group(0)
+
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON response: {e}") from e
 
         # Validate all required fields are present
         required_fields = [
@@ -391,35 +378,32 @@ Analyze each component and provide scores with justifications."""
         ]
 
         for field_name in required_fields:
-            if field_name not in scores:
+            if field_name not in data:
                 raise ValueError(f"Missing required field: {field_name}")
 
-        # Parse scores to float
-        def parse_score(value: str) -> float:
-            try:
-                score = float(value)
-                return max(0.0, min(1.0, score))  # Clamp to [0, 1]
-            except ValueError as e:
-                raise ValueError(f"Invalid score value: {value}") from e
+        # Parse and clamp scores
+        def clamp_score(value: Any) -> float:
+            score = float(value)
+            return max(0.0, min(1.0, score))
 
         return ScoreBreakdown(
             goal_clarity=ComponentScore(
                 name="Goal Clarity",
-                clarity_score=parse_score(scores["goal_clarity_score"]),
+                clarity_score=clamp_score(data["goal_clarity_score"]),
                 weight=GOAL_CLARITY_WEIGHT,
-                justification=scores["goal_clarity_justification"],
+                justification=str(data["goal_clarity_justification"]),
             ),
             constraint_clarity=ComponentScore(
                 name="Constraint Clarity",
-                clarity_score=parse_score(scores["constraint_clarity_score"]),
+                clarity_score=clamp_score(data["constraint_clarity_score"]),
                 weight=CONSTRAINT_CLARITY_WEIGHT,
-                justification=scores["constraint_clarity_justification"],
+                justification=str(data["constraint_clarity_justification"]),
             ),
             success_criteria_clarity=ComponentScore(
                 name="Success Criteria Clarity",
-                clarity_score=parse_score(scores["success_criteria_clarity_score"]),
+                clarity_score=clamp_score(data["success_criteria_clarity_score"]),
                 weight=SUCCESS_CRITERIA_CLARITY_WEIGHT,
-                justification=scores["success_criteria_clarity_justification"],
+                justification=str(data["success_criteria_clarity_justification"]),
             ),
         )
 

{ouroboros_ai-0.2.1 → ouroboros_ai-0.2.3}/tests/unit/bigbang/test_ambiguity.py

@@ -46,13 +46,17 @@ def create_valid_scoring_response(
     success_score: float = 0.8,
     success_justification: str = "Success criteria are measurable.",
 ) -> str:
-    """Create a valid LLM scoring response string."""
-    return f"""GOAL_CLARITY_SCORE: {goal_score}
-GOAL_CLARITY_JUSTIFICATION: {goal_justification}
-CONSTRAINT_CLARITY_SCORE: {constraint_score}
-CONSTRAINT_CLARITY_JUSTIFICATION: {constraint_justification}
-SUCCESS_CRITERIA_CLARITY_SCORE: {success_score}
-SUCCESS_CRITERIA_CLARITY_JUSTIFICATION: {success_justification}"""
+    """Create a valid LLM scoring response string in JSON format."""
+    import json
+
+    return json.dumps({
+        "goal_clarity_score": goal_score,
+        "goal_clarity_justification": goal_justification,
+        "constraint_clarity_score": constraint_score,
+        "constraint_clarity_justification": constraint_justification,
+        "success_criteria_clarity_score": success_score,
+        "success_criteria_clarity_justification": success_justification,
+    })
 
 
 def create_interview_state_with_rounds(
@@ -302,7 +306,7 @@ class TestAmbiguityScorerInit:
         assert scorer.model == "openrouter/google/gemini-2.0-flash-001"
         assert scorer.temperature == SCORING_TEMPERATURE
         assert scorer.initial_max_tokens == 2048
-        assert scorer.max_retries == 3
+        assert scorer.max_retries is None  # Unlimited by default
 
     def test_scorer_custom_values(self) -> None:
         """AmbiguityScorer accepts custom values."""
@@ -665,41 +669,31 @@ class TestAmbiguityScorerParseResponse:
         mock_adapter = MagicMock()
         scorer = AmbiguityScorer(llm_adapter=mock_adapter)
 
-        response = """GOAL_CLARITY_SCORE: 0.9
-GOAL_CLARITY_JUSTIFICATION: Good goal."""
+        # JSON with missing field
+        response = '{"goal_clarity_score": 0.9, "goal_clarity_justification": "Good goal."}'
 
         with pytest.raises(ValueError, match="Missing required field"):
             scorer._parse_scoring_response(response)
 
-    def test_parse_response_invalid_score_format(self) -> None:
-        """_parse_scoring_response raises error for invalid score format."""
+    def test_parse_response_invalid_json(self) -> None:
+        """_parse_scoring_response raises error for invalid JSON."""
         mock_adapter = MagicMock()
         scorer = AmbiguityScorer(llm_adapter=mock_adapter)
 
-        response = """GOAL_CLARITY_SCORE: not_a_number
-GOAL_CLARITY_JUSTIFICATION: Test
-CONSTRAINT_CLARITY_SCORE: 0.8
-CONSTRAINT_CLARITY_JUSTIFICATION: Test
-SUCCESS_CRITERIA_CLARITY_SCORE: 0.7
-SUCCESS_CRITERIA_CLARITY_JUSTIFICATION: Test"""
+        response = "This is not valid JSON at all"
 
-        with pytest.raises(ValueError, match="Invalid score value"):
+        with pytest.raises(ValueError, match="Invalid JSON response"):
             scorer._parse_scoring_response(response)
 
-    def test_parse_response_with_extra_whitespace(self) -> None:
-        """_parse_scoring_response handles extra whitespace."""
+    def test_parse_response_with_markdown_code_block(self) -> None:
+        """_parse_scoring_response handles JSON in markdown code block."""
         mock_adapter = MagicMock()
         scorer = AmbiguityScorer(llm_adapter=mock_adapter)
 
-        response = """
-GOAL_CLARITY_SCORE:   0.85
-GOAL_CLARITY_JUSTIFICATION:   Clear goal with details.
-
-CONSTRAINT_CLARITY_SCORE: 0.75
-CONSTRAINT_CLARITY_JUSTIFICATION: Good constraints.
-
-SUCCESS_CRITERIA_CLARITY_SCORE: 0.65
-SUCCESS_CRITERIA_CLARITY_JUSTIFICATION: Clear criteria.
+        response = """Here is the analysis:
+```json
+{"goal_clarity_score": 0.85, "goal_clarity_justification": "Clear goal with details.", "constraint_clarity_score": 0.75, "constraint_clarity_justification": "Good constraints.", "success_criteria_clarity_score": 0.65, "success_criteria_clarity_justification": "Clear criteria."}
+```
 """
 
         breakdown = scorer._parse_scoring_response(response)

{ouroboros_ai-0.2.1 → ouroboros_ai-0.2.3}/uv.lock

@@ -892,7 +892,7 @@ wheels = [
 
 [[package]]
 name = "ouroboros-ai"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },