anvil-dev-framework 0.1.6 → 0.1.8

package/global/lib/ralph_state.py

@@ -580,9 +580,92 @@ To resume later, run: /ralph start "{self.objective}"
 
 
     # =========================================================================
-    # Linear Integration (ANV-211)
+    # Linear Integration (ANV-211, ANV-214)
     # =========================================================================
 
+    @classmethod
+    def initialize_from_project(
+        cls,
+        project_name: str,
+        no_sync: bool = False,
+        include_done: bool = False,
+        state_file: str = DEFAULT_STATE_FILE,
+    ) -> "RalphState":
+        """Initialize Ralph session from a Linear project (ANV-214).
+
+        Args:
+            project_name: Linear project name (e.g., "HUD Development")
+            no_sync: If True, don't sync status updates back to Linear
+            include_done: If True, include already-completed issues
+            state_file: Path to state file
+
+        Returns:
+            Initialized RalphState with Linear integration enabled in project mode
+        """
+        provider = _create_linear_provider()
+
+        try:
+            issues = provider.get_project_issues(
+                project_name=project_name, include_done=include_done
+            )
+        except (KeyError, AttributeError):
+            raise ValueError(f"Project '{project_name}' not found in Linear") from None
+
+        if not issues:
+            raise ValueError(f"Project '{project_name}' has no issues to process")
+
+        # Build LinearSubtask objects from Issue instances
+        subtasks = []
+        todo_items = []
+        for issue in issues:
+            issue_status = issue.status.value.lower() if issue.status else ""
+            status = "completed" if issue_status in ("done", "completed", "closed") else "todo"
+            subtask = LinearSubtask(
+                id=issue.id,
+                identifier=issue.identifier,
+                title=issue.title,
+                status=status,
+            )
+            subtasks.append(subtask)
+            if status == "todo":
+                todo_items.append(f"[{issue.identifier}] {issue.title}")
+
+        # Create LinearIntegration in project mode
+        linear_integration = LinearIntegration(
+            enabled=True,
+            mode="project",
+            parent_issue=None,
+            parent_id=None,
+            project_name=project_name,
+            subtasks=subtasks,
+            last_sync=datetime.now(timezone.utc).isoformat(),
+            no_sync=no_sync,
+        )
+
+        # Initialize state
+        state = cls(
+            task_name=f"Project: {project_name}",
+            objective=f"Complete all issues in project '{project_name}'",
+            iteration=0,
+            started_at=datetime.now(timezone.utc).isoformat(),
+            status="running",
+            no_change_count=0,
+            last_diff_hash="",
+            error_hashes=[],
+            max_iterations=DEFAULT_MAX_ITERATIONS,
+            completion_promise=DEFAULT_COMPLETION_PROMISE,
+            todo_items=todo_items,
+            completed_items=[],
+            context_checkpoint=None,
+            context_history=[],
+            linear_integration=linear_integration,
+            state_file=state_file,
+        )
+
+        Path(state_file).parent.mkdir(parents=True, exist_ok=True)
+        state.save()
+        return state
+
     @classmethod
     def initialize_from_linear(
         cls,
@@ -761,43 +844,102 @@ To resume later, run: /ralph start "{self.objective}"
                 return True
         return False
 
-    def sync_to_linear(self, identifier: str, state_name: str) -> bool:
-        """Sync subtask status to Linear.
+    def sync_to_linear(
+        self,
+        identifier: str,
+        state_name: str,
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+    ) -> bool:
+        """Sync subtask status to Linear with retry logic (ANV-215).
 
         Args:
             identifier: Linear issue identifier
             state_name: Target state name ("done", "in_progress", etc.)
+            max_retries: Maximum number of retry attempts
+            retry_delay: Initial delay between retries (exponential backoff)
 
         Returns:
             True if sync succeeded
         """
+        import time
+
         if not self.linear_integration or self.linear_integration.no_sync:
             return False
 
-        try:
-            # ANV-120: Use _create_linear_provider() to ensure proper team config
-            provider = _create_linear_provider()
-
-            # Import IssueStatus for state conversion
+        last_error = None
+        for attempt in range(max_retries):
             try:
-                from .issue_models import IssueStatus
-            except ImportError:
-                from issue_models import IssueStatus
+                # ANV-120: Use _create_linear_provider() to ensure proper team config
+                provider = _create_linear_provider()
 
-            # Convert state name to IssueStatus enum
-            target_status = IssueStatus.from_linear_state(state_name)
+                # Import IssueStatus for state conversion
+                try:
+                    from .issue_models import IssueStatus
+                except ImportError:
+                    from issue_models import IssueStatus
 
-            # Update issue with the converted status
-            provider.update_issue(identifier, status=target_status)
-            self.linear_integration.last_sync = datetime.now(timezone.utc).isoformat()
-            self.save()
-            return True
-        except (ImportError, AttributeError, ValueError, OSError) as e:
-            # Log the error for debugging but don't crash
-            # Catch: ImportError (module issues), AttributeError (API mismatch),
-            # ValueError (bad data), OSError (network/auth failures)
-            print(f"Warning: Failed to sync {identifier} to Linear: {e}")
-            return False
+                # Convert state name to IssueStatus enum
+                target_status = IssueStatus.from_linear_state(state_name)
+
+                # Update issue with the converted status
+                provider.update_issue(identifier, status=target_status)
+                self.linear_integration.last_sync = datetime.now(timezone.utc).isoformat()
+                self.save()
+                return True
+            except (ImportError, AttributeError, ValueError) as e:
+                # Non-retryable errors - fail immediately
+                print(f"Warning: Failed to sync {identifier} to Linear: {e}")
+                return False
+            except (OSError, Exception) as e:
+                # Retryable error (network/timeout/rate limit/API error)
+                # LinearProvider raises generic Exception for HTTP errors
+                last_error = e
+                if attempt < max_retries - 1:
+                    delay = retry_delay * (2 ** attempt)  # Exponential backoff
+                    print(f"Warning: Sync failed, retrying in {delay}s: {e}")
+                    time.sleep(delay)
+
+        # All retries exhausted
+        print(f"Warning: Failed to sync {identifier} after {max_retries} attempts: {last_error}")
+        return False
+
+    def mark_subtask_skipped(self, identifier: str, reason: str) -> bool:
+        """Mark a Linear subtask as skipped (ANV-215).
+
+        Args:
+            identifier: Linear issue identifier (e.g., "ANV-215")
+            reason: Reason for skipping
+
+        Returns:
+            True if subtask was found and updated
+        """
+        return self.mark_subtask_complete(identifier, skip_reason=reason)
+
+    def handle_missing_subtask(self, identifier: str) -> None:
+        """Handle a missing subtask gracefully (ANV-215).
+
+        Logs a warning and marks the subtask as skipped in local state
+        without attempting to sync to Linear.
+
+        Args:
+            identifier: Linear issue identifier
+        """
+        print(f"Warning: Subtask {identifier} not found in Linear, marking as skipped")
+        if self.linear_integration and self.linear_integration.enabled:
+            for subtask in self.linear_integration.subtasks:
+                if subtask.identifier == identifier:
+                    subtask.status = "skipped"
+                    subtask.skip_reason = "Not found in Linear"
+                    subtask.completed_at = datetime.now(timezone.utc).isoformat()
+
+                    # Remove from todo_items
+                    item_prefix = f"[{identifier}]"
+                    self.todo_items = [t for t in self.todo_items if not t.startswith(item_prefix)]
+                    self.save()
+                    return
+            # Subtask not found in local state
+            print(f"Warning: {identifier} not found in local state, no action taken")
 
     def get_linear_progress(self) -> Tuple[int, int, int]:
         """Get Linear subtask progress counts.
@@ -813,6 +955,49 @@ To resume later, run: /ralph start "{self.objective}"
         remaining = sum(1 for s in self.linear_integration.subtasks if s.status == "todo")
         return (completed, skipped, remaining)
 
+    def is_project_complete(self) -> bool:
+        """Check if all issues in project are complete (ANV-214).
+
+        Returns:
+            True if Linear integration is enabled in project mode and all
+            issues are either completed or skipped.
+        """
+        if not self.linear_integration or not self.linear_integration.enabled:
+            return False
+        if self.linear_integration.mode != "project":
+            return False
+        if not self.linear_integration.subtasks:
+            return False
+        return all(s.status != "todo" for s in self.linear_integration.subtasks)
+
+    def get_current_issue_context(self) -> Optional[Dict[str, Any]]:
+        """Get context for the current issue being worked on (ANV-214).
+
+        Returns:
+            Dictionary with current issue details, or None if no current issue.
+        """
+        next_subtask = self.get_next_subtask()
+        if not next_subtask:
+            return None
+
+        return {
+            "id": next_subtask.id,
+            "identifier": next_subtask.identifier,
+            "title": next_subtask.title,
+            "status": next_subtask.status,
+            "mode": self.linear_integration.mode if self.linear_integration else "issue",
+            "project_name": (
+                self.linear_integration.project_name
+                if self.linear_integration
+                else None
+            ),
+            "parent_issue": (
+                self.linear_integration.parent_issue
+                if self.linear_integration
+                else None
+            ),
+        }
+
 
 # =============================================================================
 # File Generation
@@ -1056,6 +1241,20 @@ def main():
         "--no-sync", action="store_true", help="Don't sync status back to Linear"
     )
 
+    # Init-project command (ANV-214)
+    init_project_parser = subparsers.add_parser(
+        "init-project", help="Initialize Ralph from Linear project"
+    )
+    init_project_parser.add_argument(
+        "--project", required=True, help="Linear project name (e.g., 'HUD Development')"
+    )
+    init_project_parser.add_argument(
+        "--no-sync", action="store_true", help="Don't sync status back to Linear"
+    )
+    init_project_parser.add_argument(
+        "--include-done", action="store_true", help="Include already-completed issues"
+    )
+
     # Sync command (ANV-211)
     sync_parser = subparsers.add_parser("sync", help="Sync status with Linear")
     # --complete and --skip are mutually exclusive
@@ -1161,6 +1360,47 @@ def main():
         except ImportError as e:
             print(f"Error: Could not load Linear provider - {e}")
 
+    elif args.command == "init-project":
+        try:
+            state = RalphState.initialize_from_project(
+                project_name=args.project,
+                no_sync=args.no_sync,
+                include_done=args.include_done,
+            )
+
+            # Create supporting files
+            create_fix_plan(
+                state.task_name,
+                state.objective,
+                state.todo_items,
+            )
+            create_progress_file(
+                state.task_name,
+                state.objective,
+                len(state.todo_items),
+            )
+            create_prompt_file(
+                state.task_name,
+                state.objective,
+                remaining_count=len(state.todo_items),
+                total_items=len(state.todo_items),
+                started_at=state.started_at,
+            )
+
+            completed, skipped, remaining = state.get_linear_progress()
+            print(f"Ralph session initialized from project: {args.project}")
+            print(f"   State file: {state.state_file}")
+            print(f"   Issues: {remaining} todo, {completed} already done")
+            if args.include_done:
+                print("   Include done: YES (processing all issues)")
+            if args.no_sync:
+                print("   Sync: DISABLED (changes won't update Linear)")
+
+        except ValueError as e:
+            print(f"Error: {e}")
+        except ImportError as e:
+            print(f"Error: Could not load Linear provider - {e}")
+
     elif args.command == "sync":
         state = RalphState.load()
         if not state: