titan-cli 0.1.16__tar.gz → 0.2.0__tar.gz

{titan_cli-0.1.16 → titan_cli-0.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: titan-cli
-Version: 0.1.16
+Version: 0.2.0
 Summary: Modular development tools orchestrator - Streamline your workflows with AI integration and intuitive terminal UI
-Home-page: https://github.com/masorange/titan-cli
 License: MIT
+License-File: LICENSE
 Keywords: cli,workflow,orchestrator,automation,devtools,ai
 Author: MasOrange Apps Team
 Author-email: apps-management-stores@masorange.es
@@ -17,6 +17,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: anthropic (>=0.75.0,<0.76.0)
 Requires-Dist: google-auth (>=2.43.0,<3.0.0)
 Requires-Dist: google-genai (>=1.58.0,<2.0.0)
@@ -32,7 +34,8 @@ Requires-Dist: textual (>=1.0.0,<2.0.0)
 Requires-Dist: tomli (>=2.0.0,<3.0.0)
 Requires-Dist: tomli-w (>=1.0.0,<2.0.0)
 Requires-Dist: typer (>=0.20.0,<1.0.0)
-Project-URL: Documentation, https://github.com/masorange/titan-cli
+Project-URL: Documentation, https://masorange.github.io/titan-cli/
+Project-URL: Homepage, https://github.com/masorange/titan-cli
 Project-URL: Repository, https://github.com/masorange/titan-cli
 Description-Content-Type: text/markdown
 

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-git/titan_plugin_git/steps/push_step.py

@@ -1,5 +1,5 @@
 # plugins/titan-plugin-git/titan_plugin_git/steps/push_step.py
-from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error, Skip
 from titan_cli.core.result import ClientSuccess, ClientError
 from titan_plugin_git.messages import msg
 
@@ -57,9 +57,24 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
     exists_result = ctx.git.branch_exists_on_remote(branch=branch_to_use, remote=remote_to_use)
     match exists_result:
         case ClientSuccess(data=exists):
-            # The first push of a branch should set the upstream
             if not exists:
+                # The first push of a branch should set the upstream
                 set_upstream = True
+            else:
+                # Branch exists on remote — check if there's anything to push
+                unpushed_result = ctx.git.count_unpushed_commits(branch=branch_to_use, remote=remote_to_use)
+                match unpushed_result:
+                    case ClientSuccess(data=unpushed_count):
+                        if unpushed_count == 0:
+                            ctx.textual.success_text(f"Branch {branch_to_use} is already up to date with {remote_to_use}")
+                            ctx.textual.end_step("success")
+                            return Skip(
+                                "Branch already pushed",
+                                metadata={"pr_head_branch": branch_to_use}
+                            )
+                    case ClientError():
+                        # If we can't count, proceed with push anyway
+                        pass
         case ClientError(error_message=err):
             ctx.textual.end_step("error")
             return Error(f"Failed to check remote branch: {err}")

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-git/titan_plugin_git/steps/status_step.py

@@ -16,7 +16,9 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
 
     Behavior:
         - If there are uncommitted changes: Returns Success and continues workflow
-        - If working directory is clean: Returns Exit (stops workflow - nothing to commit)
+        - If working directory is clean: Returns Exit — nothing to commit.
+          In nested workflows (e.g. commit-ai called from create-pr-ai), the engine
+          converts Exit to Success so the parent workflow continues normally.
 
     Requires:
         ctx.git: An initialized GitClient.
@@ -26,7 +28,7 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
 
     Returns:
         Success: If there are changes to commit (workflow continues)
-        Exit: If working directory is clean (workflow stops - nothing to commit)
+        Exit: If working directory is clean (stops commit workflow; parent continues)
         Error: If the GitClient is not available or the git command fails.
     """
     if not ctx.textual:
@@ -54,13 +56,12 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
                     metadata={"git_status": status}
                 )
             else:
-                # Working directory is clean - exit workflow (nothing to commit)
+                # Working directory is clean — nothing to commit, exit early.
+                # If commit-ai is nested inside another workflow (e.g. create-pr-ai),
+                # the engine converts this Exit to Success so the parent continues.
                 ctx.textual.success_text(msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN)
-                ctx.textual.text("")
-                ctx.textual.dim_text("Nothing to commit. Skipping workflow.")
                 ctx.textual.end_step("success")
 
-                # Exit workflow early (not an error)
                 return Exit("No changes to commit", metadata={"git_status": status})
 
         case ClientError(error_message=err):

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/clients/github_client.py

@@ -215,6 +215,10 @@ class GitHubClient:
         """Reply to a PR comment."""
         return self._review_service.reply_to_comment(pr_number, comment_id, body)
 
+    def get_pr_general_comments(self, pr_number: int) -> ClientResult[List[UICommentThread]]:
+        """Get general PR comments (not attached to code lines)."""
+        return self._review_service.get_pr_general_comments(pr_number)
+
     def add_issue_comment(self, pr_number: int, body: str) -> ClientResult[None]:
         """Add a general comment to PR (issue comment)."""
         return self._review_service.add_issue_comment(pr_number, body)

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/clients/network/graphql_queries.py

@@ -44,6 +44,29 @@ query($owner: String!, $repo: String!, $prNumber: Int!) {
 }
 '''
 
+GET_PR_ISSUE_COMMENTS = '''
+query($owner: String!, $repo: String!, $prNumber: Int!) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $prNumber) {
+      comments(first: 100) {
+        nodes {
+          databaseId
+          body
+          author {
+            login
+            ... on User {
+              name
+            }
+          }
+          createdAt
+          updatedAt
+        }
+      }
+    }
+  }
+}
+'''
+
 GET_PR_NODE_ID = '''
 query($owner: String!, $repo: String!, $prNumber: Int!) {
   repository(owner: $owner, name: $repo) {

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/clients/services/review_service.py

@@ -6,14 +6,13 @@ Business logic for PR review operations.
 Uses GraphQL for complex operations (threads, comments, resolve).
 """
 import json
-import subprocess
 from typing import List, Optional, Dict, Any
 
 from titan_cli.core.result import ClientResult, ClientSuccess, ClientError
 from titan_cli.core.logging import log_client_operation
 from ..network import GHNetwork, GraphQLNetwork, graphql_queries
 from ...models.network.rest import NetworkReview
-from ...models.network.graphql import GraphQLPullRequestReviewThread
+from ...models.network.graphql import GraphQLPullRequestReviewThread, GraphQLIssueComment
 from ...models.view import UICommentThread, UIReview
 from ...models.mappers import from_graphql_review_thread, from_network_review
 from ...exceptions import GitHubAPIError
@@ -106,6 +105,66 @@ class ReviewService:
         except GitHubAPIError as e:
             return ClientError(error_message=str(e), error_code="API_ERROR")
 
+    @log_client_operation()
+    def get_pr_general_comments(
+        self, pr_number: int
+    ) -> ClientResult[List[UICommentThread]]:
+        """
+        Get general PR comments (not attached to code lines).
+
+        Uses GraphQL to fetch top-level PR comments and wraps each one as
+        a pseudo-thread (thread_id = "general_{id}") for uniform rendering.
+
+        Args:
+            pr_number: PR number
+
+        Returns:
+            ClientResult[List[UICommentThread]]
+        """
+        try:
+            repo_string = self.gh.get_repo_string()
+            owner, repo = repo_string.split('/')
+
+            variables = {
+                "owner": owner,
+                "repo": repo,
+                "prNumber": pr_number
+            }
+
+            response = self.graphql.run_query(
+                graphql_queries.GET_PR_ISSUE_COMMENTS,
+                variables
+            )
+
+            comments_data = (
+                response.get("data", {})
+                .get("repository", {})
+                .get("pullRequest", {})
+                .get("comments", {})
+                .get("nodes", [])
+            )
+
+            network_comments = [
+                GraphQLIssueComment.from_graphql(c) for c in comments_data
+            ]
+
+            ui_threads = [
+                UICommentThread.from_issue_comment(c) for c in network_comments
+            ]
+
+            return ClientSuccess(
+                data=ui_threads,
+                message=f"Found {len(ui_threads)} general comments"
+            )
+
+        except (KeyError, ValueError) as e:
+            return ClientError(
+                error_message=f"Failed to parse general comments: {e}",
+                error_code="PARSE_ERROR"
+            )
+        except GitHubAPIError as e:
+            return ClientError(error_message=str(e), error_code="API_ERROR")
+
     @log_client_operation()
     def resolve_review_thread(self, thread_node_id: str) -> ClientResult[None]:
         """
@@ -191,16 +250,9 @@ class ReviewService:
                 "--input", "-",
             ]
 
-            # Run with JSON payload via stdin
-            result = subprocess.run(
-                ["gh"] + args,
-                input=json.dumps(payload),
-                capture_output=True,
-                text=True,
-                check=True,
-            )
+            result = self.gh.run_command(args, stdin_input=json.dumps(payload))
 
-            response = json.loads(result.stdout)
+            response = json.loads(result)
             review_id = response["id"]
 
             return ClientSuccess(
@@ -213,11 +265,6 @@ class ReviewService:
                 error_message=f"Failed to parse review response: {e}",
                 error_code="PARSE_ERROR"
             )
-        except subprocess.CalledProcessError as e:
-            return ClientError(
-                error_message=f"Failed to create draft review: gh API returned exit code {e.returncode}",
-                error_code="API_ERROR"
-            )
         except GitHubAPIError as e:
             return ClientError(error_message=str(e), error_code="API_ERROR")
 

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/models/view.py

@@ -94,6 +94,36 @@ class UICommentThread:
         from .mappers import from_graphql_review_thread
         return from_graphql_review_thread(thread)
 
+    @classmethod
+    def from_issue_comment(cls, comment: 'Any') -> 'UICommentThread':
+        """
+        Wrap a GraphQLIssueComment as a pseudo-thread for uniform rendering.
+
+        General PR comments have no thread concept, so they are wrapped in a
+        UICommentThread with a synthetic thread_id ("general_{id}") that
+        downstream code uses to distinguish them from review threads.
+
+        Args:
+            comment: GraphQLIssueComment instance from GraphQL
+
+        Returns:
+            UICommentThread with thread_id="general_{id}", no replies, not resolved
+        """
+        from .mappers import from_graphql_issue_comment
+        ui_comment = from_graphql_issue_comment(comment)
+        return cls(
+            thread_id=f"general_{comment.databaseId}",
+            main_comment=ui_comment,
+            replies=[],
+            is_resolved=False,
+            is_outdated=False
+        )
+
+    @property
+    def is_general_comment(self) -> bool:
+        """True if this thread wraps a general PR comment (not an inline review thread)."""
+        return self.thread_id.startswith("general_")
+
 
 @dataclass
 class UIPullRequest:

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/operations/__init__.py

@@ -14,6 +14,7 @@ Modules:
 
 from .comment_operations import (
     build_ai_review_context,
+    build_ai_review_prompt,
     find_ai_response_file,
     create_commit_message,
     reply_to_comment_batch,
@@ -22,6 +23,7 @@ from .comment_operations import (
 
 from .pr_operations import (
     fetch_pr_threads,
+    fetch_pr_general_comments,
 )
 
 from .worktree_operations import (
@@ -44,6 +46,7 @@ from .issue_operations import (
 __all__ = [
     # Comment operations
     "build_ai_review_context",
+    "build_ai_review_prompt",
     "find_ai_response_file",
     "create_commit_message",
     "reply_to_comment_batch",
@@ -51,6 +54,7 @@ __all__ = [
 
     # PR operations
     "fetch_pr_threads",
+    "fetch_pr_general_comments",
 
     # Worktree operations
     "setup_worktree",

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/operations/comment_operations.py

@@ -35,13 +35,6 @@ def build_ai_review_context(
             "diff_hunk": str (acotado),
             "thread": [{"author": str, "date": str, "body": str}, ...]
         }
-
-    Example:
-        >>> context = build_ai_review_context(pr_thread, "feat: Add feature")
-        >>> context['pr']
-        'feat: Add feature'
-        >>> len(context['diff_hunk'].split('\\n'))
-        11  # ~11 lines instead of 200+
     """
     main_comment = pr_thread.main_comment
 
@@ -93,11 +86,6 @@ def find_ai_response_file(comment_id: int, expected_path: str) -> Optional[str]:
 
     Returns:
         Path to the found file, or None if not found
-
-    Example:
-        >>> path = find_ai_response_file(123, "/tmp/titan-ai-response-comment-123.txt")
-        >>> path
-        '/home/user/.gemini/tmp/.../titan-ai-response-comment-123.txt'
     """
     # Try expected location first
     if os.path.exists(expected_path):
@@ -145,6 +133,56 @@ def create_commit_message(comment_body: str, comment_author: str, comment_path:
     return message
 
 
+def build_ai_review_prompt(response_file: str) -> str:
+    """
+    Build the prompt template for AI review of a PR comment thread.
+
+    Args:
+        response_file: Path where the AI should write text responses
+
+    Returns:
+        Prompt string with {context} placeholder for the JSON context
+    """
+    return f"""Review this PR comment thread:
+
+```json
+{{context}}
+```
+
+## Your Task
+
+1. **First, evaluate if the review comment makes sense:**
+   - Is the feedback valid and applicable to the current code?
+   - Is the requested change appropriate?
+   - Could previous attempts have already addressed this (check the thread conversation)?
+
+2. **Then, based on your evaluation:**
+   - **If the comment makes sense**: Make the necessary code changes to address it
+   - **If the comment doesn't make sense or is outdated**:
+     * DO NOT make code changes
+     * Write your explanation/response EXACTLY to this file path: {response_file}
+     * IMPORTANT: Use this exact command to write the response:
+       ```bash
+       cat > {response_file} << 'EOF'
+       Your response text here
+       EOF
+       ```
+
+## Response Style (CRITICAL)
+- **Keep responses SHORT and CONCISE** (maximum 2-3 sentences)
+- **Be direct and to the point** - no verbose explanations
+- **Avoid multiple paragraphs** - use a single short paragraph
+- **Don't over-explain** - state the key point clearly and move on
+- Example GOOD: "This is intentional. The logic handles X at layer Y, ensuring Z."
+- Example BAD: Long multi-paragraph explanations with bullet points and detailed justifications
+
+Note: Review the entire conversation thread carefully - previous fix attempts may have failed or been incomplete.
+
+## When You're Done
+Once you have completed your single action (code fix OR written the response file), tell the user:
+"Done. Press Ctrl+C twice to exit and return to Titan." """
+
+
 def prepare_replies_for_sending(
     pending_responses: Dict[int, Dict],
     comment_commits: Dict[int, str],
@@ -202,12 +240,6 @@ def reply_to_comment_batch(
 
     Returns:
         Dictionary mapping comment_id -> success (bool)
-
-    Example:
-        >>> replies = {123: "Fixed", 456: "Done"}
-        >>> results = reply_to_comment_batch(github, 789, replies)
-        >>> results
-        {123: True, 456: True}
     """
     results = {}
 

{titan_cli-0.1.16 → titan_cli-0.2.0}/plugins/titan-plugin-github/titan_plugin_github/operations/pr_operations.py

@@ -10,6 +10,55 @@ from titan_cli.core.result import ClientSuccess, ClientError
 from ..models.view import UICommentThread
 
 
+def fetch_pr_general_comments(
+    github_client,
+    pr_number: int,
+) -> List[UICommentThread]:
+    """
+    Fetch general PR comments (not attached to code lines).
+
+    Filters out:
+    - Bot comments
+    - Empty comments
+    - JSON-only comments (coverage reports, CI badges, etc.)
+
+    Args:
+        github_client: GitHub client instance
+        pr_number: PR number
+
+    Returns:
+        List of UICommentThread pseudo-threads (thread_id starts with "general_")
+
+    Raises:
+        Exception: If fetching comments fails
+    """
+    result = github_client.get_pr_general_comments(pr_number)
+
+    match result:
+        case ClientSuccess(data=threads):
+            all_threads = threads
+        case ClientError(error_message=err):
+            raise Exception(f"Failed to fetch general comments: {err}")
+        case _:
+            raise Exception("Unexpected result type")
+
+    filtered = []
+    for thread in all_threads:
+        comment = thread.main_comment
+        if not comment:
+            continue
+        if comment.author_login and 'bot' in comment.author_login.lower():
+            continue
+        if not comment.body or not comment.body.strip():
+            continue
+        body_stripped = comment.body.strip()
+        if body_stripped.startswith('{') and body_stripped.endswith('}'):
+            continue
+        filtered.append(thread)
+
+    return filtered
+
+
 def fetch_pr_threads(
     github_client,
     pr_number: int,
@@ -34,13 +83,6 @@ def fetch_pr_threads(
 
     Raises:
         Exception: If fetching threads fails
-
-    Example:
-        >>> threads = fetch_pr_threads(github, 123, include_resolved=False)
-        >>> len(threads)
-        5
-        >>> all(not t.is_resolved for t in threads)
-        True
     """
     # Fetch all threads using GraphQL
     result = github_client.get_pr_review_threads(