osa_tool 0.3.2__tar.gz → 0.3.4__tar.gz

{osa_tool-0.3.2 → osa_tool-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osa_tool
-Version: 0.3.2
+Version: 0.3.4
 Summary: Tool that just makes your open source project better!
 License-Expression: BSD-3-Clause
 License-File: LICENSE

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/config/settings.py

@@ -64,6 +64,10 @@ class GitSettings(BaseModel):
             else:
                 raise ValueError(f"{self.repository} does not exist.")
         else:
+            # A URL copied from a browser often carries a trailing slash, and the
+            # remote helpers append ".git" to this value verbatim, which would make
+            # "owner/repo/" into "owner/repo/.git" and fail the clone.
+            self.repository = str(self.repository).rstrip("/")
             self.host_domain, self.host, self.name, self.full_name = parse_git_url(str(self.repository))
         return self
 

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/core/git/git_agent.py

@@ -904,7 +904,7 @@ class GitHubAgent(GitAgent):
         else:
             logger.error(f"Failed to post a comment to PR #{pr_number}: {response.status_code} - {response.text}")
 
-    def create_pull_request(self, title: str = None, body: str = None, changes: bool = False) -> None:
+    def create_pull_request(self, title: str = None, body: str = None, changes: bool = False) -> str | None:
         """Creates or updates a pull request on GitHub.
 
         This method implements intelligent PR management:
@@ -975,6 +975,7 @@ class GitHubAgent(GitAgent):
                         f"updating PR #{pr_number}",
                         raise_exception=False,
                     )
+            return existing_pr.get("html_url")
         elif changes:
             report_files = self.get_attachment_branch_files()
             report_branch = "osa_tool_attachments"
@@ -997,7 +998,9 @@ class GitHubAgent(GitAgent):
 
             response = request_with_retry("post", url, json=pr_data, headers=headers)
             if response.status_code == 201:
-                logger.info(f"GitHub pull request created successfully: {response.json()['html_url']}")
+                pr_url = response.json()["html_url"]
+                logger.info(f"GitHub pull request created successfully: {pr_url}")
+                return pr_url
             else:
                 self._handle_api_error(response, "creating pull request", raise_exception=True)
 

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/core/llm/llm.py

@@ -641,7 +641,7 @@ class ProtollmHandler(ModelHandler):
                     time.sleep(retry_delay)
 
         logger.debug(repr(last_error))
-        raise
+        raise last_error
 
     async def async_run_chain(
         self, prompt: str, parser: PydanticOutputParser, system_message: str = None, retry_delay: float = 0.5
@@ -702,15 +702,23 @@ class ProtollmHandler(ModelHandler):
         }
         return url_templates.get(self.model_settings.api, f"{self.model_settings.base_url};{model_name}")
 
-    def _get_llm_params(self):
+    def _get_llm_params(self, model_name: str | None = None):
         """Extract LLM parameters from config"""
         llm_params = ["temperature", "max_tokens", "top_p"]
 
-        return {
+        params = {
             name: getattr(self.model_settings, name)
             for name in llm_params
             if getattr(self.model_settings, name, None) is not None
         }
+        if (
+            self.model_settings.api == "openai"
+            and urlparse(self.model_settings.base_url).hostname == "api.openai.com"
+            and (model_name or self.model_settings.model).startswith(("gpt-6-", "gpt-6."))
+        ):
+            params.pop("temperature", None)
+            params.pop("top_p", None)
+        return params
 
     def _configure_api(self, model_name: str) -> None:
         """
@@ -727,10 +735,12 @@ class ProtollmHandler(ModelHandler):
         # 401 "User not found" errors)
         dotenv.load_dotenv(override=True)
 
+        params = self._get_llm_params(model_name)
+        if urlparse(self.model_settings.base_url).hostname != "api.openai.com":
+            params["extra_body"] = {"providers": {"only": self.model_settings.allowed_providers}}
         self.client = create_llm_connector(
             model_url=self._build_model_url(model_name),
-            extra_body={"providers": {"only": self.model_settings.allowed_providers}},
-            **self._get_llm_params(),
+            **params,
         )
 
     def _limit_tokens(

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/core/models/agent_status.py

@@ -8,3 +8,4 @@ class AgentStatus(str, Enum):
     WAITING_FOR_USER = "waiting_for_user"
     ERROR = "error"
     COMPLETED = "completed"
+    STOPPED = "stopped"

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/operations/codebase/docstring_generation/docgen.py

@@ -1522,6 +1522,30 @@ class DocGen(object):
         dot_path = ".".join(processed_parts)
         return f"::: {dot_path}"
 
+    @staticmethod
+    def _path_inside_repo(target: str | Path, repo_path: Path) -> Path:
+        """
+        Returns a path relative to the repository root.
+
+        Analysis results carry absolute paths whenever OSA runs with --output.
+        Dropping only the leading component then leaves the rest of the filesystem
+        prefix in place, which nests osa_docs under the machine's own directory
+        tree and, on Windows, pushes the result past the path length limit.
+
+        Args:
+            target: The analysed file or directory path.
+            repo_path: The resolved root of the analysed repository.
+
+        Returns:
+            Path: The target expressed relative to the repository root.
+        """
+        candidate = Path(target)
+        try:
+            return candidate.resolve().relative_to(repo_path)
+        except ValueError:
+            # callers may pass a path that merely starts with the repository directory
+            return Path(*candidate.parts[1:])
+
     def generate_documentation_mkdocs(self, path: str, files_info, modules_info) -> None:
         """
         Generates MkDocs documentation for a Python project based on provided path.
@@ -1547,8 +1571,8 @@ class DocGen(object):
                 continue
             parent_dir = Path(file).parent
             file_name = Path(file).name
-            relative_path = Path(*Path(file).parts[1::])
-            new_path = Path(init_doc_path, Path(*Path(parent_dir).parts[1::]))
+            relative_path = self._path_inside_repo(file, repo_path)
+            new_path = Path(init_doc_path, self._path_inside_repo(parent_dir, repo_path))
             new_path.mkdir(parents=True, exist_ok=True)
             text = (
                 f"# {file_name.strip('.py').replace('_', ' ').title()}\n\n"
@@ -1559,7 +1583,7 @@ class DocGen(object):
             new_file.write_text(text)
 
         for module in modules_info:
-            new_file = Path(init_doc_path, Path(*Path(module).parts[1::]))
+            new_file = Path(init_doc_path, self._path_inside_repo(module, repo_path))
             new_file.mkdir(parents=True, exist_ok=True)
             text = modules_info[module]
             Path(new_file, "index.md").write_text(text)

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/operations/docs/readme_generation/sections/header.py

@@ -15,6 +15,10 @@ from osa_tool.tools.repository_analysis.sourcerank import SourceRank
 from osa_tool.utils.logger import logger
 from osa_tool.utils.utils import osa_project_root, resolve_repo_path, resolve_repo_web_identity
 
+# Shields.io badge style applied to the tech icons. Every URL in shieldsio_icons.json
+# carries a single "{0}" placeholder for it; "flat" matches the license badge above them.
+BADGE_STYLE = "flat"
+
 
 class HeaderBuilder:
     """Produce the top-of-README header with project name, info badges, and tech badges."""
@@ -129,7 +133,7 @@ class HeaderBuilder:
         badges: list[str] = ["Built with:\n"]
         for tech in sorted(self.techs):
             if tech in icons:
-                badges.append(f"![{tech}]({icons[tech][0]})")
+                badges.append(f"![{tech}]({icons[tech][0].format(BADGE_STYLE)})")
             if len(badges) >= self.max_tech_badges + 1:
                 break
         if len(badges) <= 3:

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/osa_agent/agents/finalizer/agent.py

@@ -45,6 +45,7 @@ class FinalizerAgent(BaseAgent):
 
         events = self._collect_events(state)
         summary = self._summarize_events(state, events) if events else ""
+        state.final_summary = summary
 
         # PR or logs
         if create_fork and create_pr:
@@ -56,7 +57,7 @@ class FinalizerAgent(BaseAgent):
             if about_message:
                 pr_body += "\n\n---\n\n" + about_message
 
-            self.context.git_agent.create_pull_request(
+            state.pull_request_url = self.context.git_agent.create_pull_request(
                 body=pr_body,
                 changes=changes,
             )

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/osa_agent/agents/planner/agent.py

@@ -54,7 +54,9 @@ class PlannerAgent(BaseAgent):
 
         state.status = AgentStatus.ANALYZING
         logger.info("Planner started")
-        register_all_operations()
+        # Installed wheels do not contain the source checkout's docs tree.
+        # Runtime registration must not attempt to regenerate developer docs.
+        register_all_operations(generate_docs=False)
 
         # Maintain plan history when re-planning after review: append last plan or clear for new request
         if state.active_request_source == "reviewer" and state.plan:

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/osa_agent/agents/reviewer/agent.py

@@ -90,9 +90,9 @@ class ReviewerAgent(BaseAgent):
         if state.review_cycle_count >= state.max_review_cycles:
             self._reset_clarification(state)
             state.review_cycles_exhausted = True
-            state.approval = True
+            state.status = AgentStatus.STOPPED
             logger.warning(
-                "Max review cycles reached (%s/%s); routing to finalizer",
+                "Max review cycles reached (%s/%s); ending without finalization",
                 state.review_cycle_count,
                 state.max_review_cycles,
             )

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/osa_agent/graph.py

@@ -70,7 +70,7 @@ def build_graph(context: AgentContext) -> Any:
     # reviewer → finalizer | planner
     graph.add_conditional_edges(
         "reviewer",
-        lambda state: ("finalizer" if state.approval else "planner"),
+        lambda state: (END if state.review_cycles_exhausted else "finalizer" if state.approval else "planner"),
     )
 
     graph.add_edge("finalizer", END)

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/osa_agent/state.py

@@ -67,6 +67,8 @@ class OSAState(BaseModel):
     max_review_cycles: int = 3
     review_cycle_count: int = 0
     review_cycles_exhausted: bool = False
+    final_summary: Optional[str] = None
+    pull_request_url: Optional[str] = None
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/run_chat.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import time
 
 from osa_tool.config.osa_config import OSAConfig
@@ -22,8 +23,15 @@ from osa_tool.utils.utils import (
 def main():
     # Create a command line argument parser
     parser = build_parser_from_yaml(extra_sections=["settings"])
+    parser.add_argument("--web-chat", action="store_true", help="Use the JSON-lines web chat protocol.")
+    parser.add_argument("--log-dir", help="Directory for OSA log files.")
     args = parser.parse_args()
 
+    if args.web_chat:
+        from osa_tool.web_chat import run_web_chat
+
+        return run_web_chat(args)
+
     # Collecting user parameters
     user_input: InitialChatInput = collect_user_input()
 
@@ -76,4 +84,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

{osa_tool-0.3.2 → osa_tool-0.3.4}/osa_tool/ui/input_for_chat.py

@@ -1,4 +1,5 @@
-from typing import Optional
+from contextvars import ContextVar
+from typing import Callable, Optional
 
 from pydantic import BaseModel
 from rich.console import Console
@@ -6,6 +7,9 @@ from rich.console import Console
 from osa_tool.osa_agent.state import OSAState
 
 console = Console()
+_web_question_handler: ContextVar[Callable[["OSAState"], dict] | None] = ContextVar(
+    "web_question_handler", default=None
+)
 
 
 class InitialChatInput(BaseModel):
@@ -57,6 +61,10 @@ def wait_for_user_clarification(state: OSAState) -> dict:
     if not state.clarification_required:
         raise RuntimeError("wait_for_user_clarification called but no clarification was requested")
 
+    web_handler = _web_question_handler.get()
+    if web_handler is not None:
+        return web_handler(state)
+
     payload = state.clarification_payload or {}
     question = payload.get("question", "Additional information required:")
     fields = payload.get("fields", [])

osa_tool-0.3.4/osa_tool/web_chat.py

@@ -0,0 +1,255 @@
+"""JSON-lines transport for the agent graph used by browser clients.
+
+The terminal chat remains in :mod:`osa_tool.run_chat`. Only this opt-in mode
+uses stdin and stdout as a machine-readable protocol.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import uuid
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, TextIO
+
+from osa_tool.config.osa_config import OSAConfig
+from osa_tool.config.settings import ConfigManager
+from osa_tool.core.models.agent_status import AgentStatus
+from osa_tool.osa_agent.context import AgentContext
+from osa_tool.osa_agent.graph import build_graph
+from osa_tool.osa_agent.state import OSAState
+from osa_tool.run import initialize_git_platform, resolve_publishing_options
+from osa_tool.ui.input_for_chat import _web_question_handler
+from osa_tool.utils.logger import logger, setup_logging
+from osa_tool.utils.utils import (
+    osa_project_root,
+    parse_folder_name,
+    prepare_local_output_repository,
+    switch_to_output_directory,
+)
+
+
+class ChatProtocolError(ValueError):
+    """The browser sent an invalid protocol message."""
+
+
+class ChatCancelled(Exception):
+    """The browser closed or cancelled an interactive run."""
+
+
+class JsonLineChatIO:
+    def __init__(self, source: TextIO, sink: TextIO):
+        self.source = source
+        self.sink = sink
+        self.output_dir: Path | None = None
+
+    def emit(self, event_type: str, **fields: Any) -> None:
+        self.sink.write(json.dumps({"type": event_type, **fields}, default=str) + "\n")
+        self.sink.flush()
+
+    def _read(self) -> dict[str, Any]:
+        line = self.source.readline(1_048_577)
+        if not line:
+            raise ChatCancelled("Browser connection closed")
+        if len(line) > 1_048_576:
+            raise ChatProtocolError("Message is too large")
+        try:
+            value = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise ChatProtocolError("Expected a JSON object") from exc
+        if not isinstance(value, dict):
+            raise ChatProtocolError("Expected a JSON object")
+        if value.get("type") == "cancel":
+            raise ChatCancelled("Run cancelled")
+        return value
+
+    def read_start(self) -> dict[str, str | None]:
+        message = self._read()
+        repository = message.get("repository")
+        request = message.get("request")
+        attachment = message.get("attachment")
+        if message.get("type") != "start":
+            raise ChatProtocolError("First message must have type 'start'")
+        if not isinstance(repository, str) or not repository.strip():
+            raise ChatProtocolError("Repository is required")
+        if not isinstance(request, str) or not request.strip():
+            raise ChatProtocolError("Request is required")
+        if attachment is not None and not isinstance(attachment, str):
+            raise ChatProtocolError("Attachment must be a string or null")
+        return {
+            "repository": repository.strip(),
+            "request": request.strip(),
+            "attachment": attachment.strip() or None if isinstance(attachment, str) else None,
+        }
+
+    def ask(self, state: OSAState) -> dict[str, str | None]:
+        payload = state.clarification_payload or {}
+        fields = payload.get("fields", [])
+        question_id = uuid.uuid4().hex
+        if state.clarification_type == "review":
+            self.emit(
+                "review",
+                tasks=_task_results(state),
+                artifacts=_artifact_paths(state, self.output_dir),
+                events=_artifact_events(state),
+            )
+        self.emit(
+            "question",
+            id=question_id,
+            agent=state.clarification_agent,
+            kind=state.clarification_type,
+            question=payload.get("question", "Additional information required"),
+            fields=fields,
+        )
+        while True:
+            try:
+                message = self._read()
+                if message.get("type") != "answer" or message.get("id") != question_id:
+                    raise ChatProtocolError("Answer does not match the pending question")
+                values = message.get("values")
+                if not isinstance(values, dict):
+                    raise ChatProtocolError("Answer values must be an object")
+                names = {field["name"] for field in fields}
+                if set(values) - names:
+                    raise ChatProtocolError("Answer contains unknown fields")
+                answers: dict[str, str | None] = {}
+                for field in fields:
+                    name = field["name"]
+                    value = values.get(name)
+                    if value is not None and not isinstance(value, str):
+                        raise ChatProtocolError(f"{name} must be text")
+                    value = value.strip() if value else None
+                    if field.get("required") and not value:
+                        raise ChatProtocolError(f"{name} is required")
+                    if name == "accept" and value and value.lower() not in {"yes", "y", "no", "n"}:
+                        raise ChatProtocolError("Approval must be yes or no")
+                    answers[name] = value
+                return answers
+            except ChatProtocolError as exc:
+                self.emit("error", message=str(exc), recoverable=True)
+
+
+@contextmanager
+def use_web_questions(handler):
+    token = _web_question_handler.set(handler)
+    try:
+        yield
+    finally:
+        _web_question_handler.reset(token)
+
+
+def _artifact_paths(state: OSAState, output_dir: Path | None) -> list[str]:
+    if output_dir is None:
+        return []
+    paths: set[str] = set()
+    for artifact in state.artifacts.values():
+        if not isinstance(artifact, dict):
+            continue
+        for event in artifact.get("events", []):
+            target = event.get("target") if isinstance(event, dict) else getattr(event, "target", None)
+            if not isinstance(target, (str, Path)):
+                continue
+            path = Path(target)
+            if not path.is_absolute():
+                path = Path(state.repo_path or output_dir) / path
+            path = path.resolve()
+            if path.is_file() and path.is_relative_to(output_dir):
+                paths.add(str(path))
+    return sorted(paths)
+
+
+def _task_results(state: OSAState) -> list[dict[str, Any]]:
+    return [{"id": task.id, "status": task.status.value, "result": task.result} for task in state.plan]
+
+
+def _artifact_events(state: OSAState) -> list[dict[str, str]]:
+    events: list[dict[str, str]] = []
+    for artifact in state.artifacts.values():
+        if not isinstance(artifact, dict):
+            continue
+        for event in artifact.get("events", []):
+            kind = event.get("kind") if isinstance(event, dict) else getattr(event, "kind", None)
+            target = event.get("target") if isinstance(event, dict) else getattr(event, "target", None)
+            if kind is not None and target is not None:
+                events.append({"kind": str(getattr(kind, "value", kind)), "target": str(target)})
+    return events[:50]
+
+
+def _run(args, io: JsonLineChatIO) -> int:
+    start = io.read_start()
+    args.repository = start["repository"]
+    output_dir = Path(args.output).resolve() if args.output else None
+    io.output_dir = output_dir
+    logs_dir = args.log_dir or str(Path(osa_project_root()).parent / "logs")
+    setup_logging(parse_folder_name(args.repository), logs_dir)
+
+    if output_dir is not None:
+        switch_to_output_directory(output_dir)
+        if os.path.isdir(args.repository):
+            args.repository = str(prepare_local_output_repository(args.repository, output_dir))
+
+    config_manager = ConfigManager(args)
+    git_agent, workflow_manager = initialize_git_platform(args, config_manager)
+    create_fork, create_pull_request = resolve_publishing_options(args, git_agent)
+    context = AgentContext(
+        OSAConfig(
+            config_manager=config_manager,
+            git_agent=git_agent,
+            workflow_manager=workflow_manager,
+            create_fork=create_fork,
+            create_pull_request=create_pull_request,
+            delete_dir=args.delete_dir,
+            enable_replanning=True,
+            enable_memory=True,
+        )
+    )
+    state = OSAState(
+        repo_url=start["repository"],
+        attachment=start["attachment"],
+        active_request=start["request"],
+        active_request_source="user",
+        session_id=uuid.uuid4().hex,
+        status=AgentStatus.INIT,
+    )
+    io.emit("started", session_id=state.session_id)
+    with use_web_questions(io.ask):
+        for value in build_graph(context).stream(state, stream_mode="values"):
+            state = OSAState.model_validate(value)
+            if state.active_agent:
+                io.emit("progress", agent=state.active_agent, status=state.status.value)
+
+    if state.review_cycles_exhausted:
+        io.emit("stopped", reason="review_cycles_exhausted", message="Revision limit reached without approval")
+        return 0
+    if state.status != AgentStatus.COMPLETED:
+        raise RuntimeError(f"Agent graph ended with status {state.status.value}")
+    io.emit(
+        "completed",
+        summary=state.final_summary or "Run completed",
+        tasks=_task_results(state),
+        artifacts=_artifact_paths(state, output_dir),
+        pull_request_url=state.pull_request_url,
+    )
+    return 0
+
+
+def run_web_chat(args) -> int:
+    """Run the web protocol with stdout reserved exclusively for JSON lines."""
+    sys.stdout.flush()
+    wire = os.fdopen(os.dup(sys.stdout.fileno()), "w", encoding="utf-8", buffering=1)
+    os.dup2(sys.stderr.fileno(), sys.stdout.fileno())
+    sys.stdout = sys.stderr
+    io = JsonLineChatIO(sys.stdin, wire)
+    try:
+        return _run(args, io)
+    except ChatCancelled as exc:
+        io.emit("stopped", reason="cancelled", message=str(exc))
+        return 0
+    except Exception as exc:
+        logger.exception("Web chat failed")
+        io.emit("error", message=str(exc), recoverable=False)
+        return 1
+    finally:
+        wire.close()

{osa_tool-0.3.2 → osa_tool-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "osa_tool"
-version = "0.3.2"
+version = "0.3.4"
 description = "Tool that just makes your open source project better!"
 requires-python = ">=3.11,<4.0"
 authors = [