operations are wrapped in try except

fix WhatHasBeenDoneReportGenerator generation summary

Author: fl1pcoin

osa_tool/config/prompts/analysis.toml

@@ -49,131 +49,39 @@ RULES:
 
 """
 
-after_report_text_prompt = """
-DEFINITIONS:
-
-translate_dirs — Translate directory names to English
-convert_notebooks — Convert Jupyter notebooks to Python scripts
-translate_readme — Translate README file to English
-ensure_license — Ensure a LICENSE file is present
-community_docs — Add or update community documentation files
-docstring — Add or update docstrings in source code
-report — Generate refactoring report
-readme — Create a README file
-requirements — Add or update requirements file
-organize — Reorganize project structure
-about — Add project description or about section
-validate_paper — Validate academic paper files
-validate_doc — Validate documentation files
-generate_workflows — Generate CI or automation workflows
-include_tests — Add or include tests
-include_black — Add Black code formatter
-include_pep8 — Add PEP8 compliance checks
-include_autopep8 — Add autopep8 formatter
-include_fix_pep8 — Automatically fix PEP8 issues
-include_pypi — Prepare project for PyPI publishing
-python_versions — Specify supported Python versions
-pep8_tool — Configure PEP8 checking tool
-use_poetry — Use Poetry for dependency management
-include_codecov — Add Codecov integration
-
-
-INPUT DATA (tasks list):
-
-{tasks_list}
+after_report_summary_from_events_prompt = """
+INPUT DATA (operations list):
 
-TASK:
+{operations}
 
-Write a connected textual summary of the repository refactoring.
+TASK:
+Write a short factual summary of what was performed.
 
 REQUIREMENTS:
-- Write approximately two short paragraphs
-- Use plain text only
+- Use only operations with performed == Yes
+- Base the wording on the provided events and result fields
+- Keep it concise (about two short paragraphs)
 - Do not use markdown
 - Do not use bullet points or lists
-- Do NOT mention tasks that were not performed
-- Do NOT explain why something was not done
-- Do NOT use modal or speculative language (avoid words like "may", "might", "likely")
-- Describe only actions that were actually performed
-- Use neutral but natural technical language
-- Write in confident past tense
-- Base the text ONLY on tasks with value "Yes"
-
-STYLE:
-- Clear and readable
-- Slightly narrative, but professional
-- No bureaucratic or legalistic phrasing
-- No assumptions or interpretation beyond task definitions
 
 OUTPUT:
-Return only the text summary.
-Do not add any explanations or extra text.
+Return ONLY JSON matching the system message schema.
 """
 
-after_report_blocks_prompt = """
-TASK DEFINITIONS:
-
-translate_dirs — Translate directory names to English
-convert_notebooks — Convert Jupyter notebooks to Python scripts
-translate_readme — Translate README file to English
-ensure_license — Ensure a LICENSE file is present
-community_docs — Add or update community documentation files
-docstring — Add or update docstrings in source code
-report — Generate refactoring report
-readme — Create a README file
-requirements — Add or update requirements file
-organize — Reorganize project structure
-about — Add project description or about section
-validate_paper — Validate academic paper files
-validate_doc — Validate documentation files
-generate_workflows — Generate CI or automation workflows
-include_tests — Add or include tests
-include_black — Add Black code formatter
-include_pep8 — Add PEP8 compliance checks
-include_autopep8 — Add autopep8 formatter
-include_fix_pep8 — Automatically fix PEP8 issues
-include_pypi — Prepare project for PyPI publishing
-python_versions — Specify supported Python versions
-pep8_tool — Configure PEP8 checking tool
-use_poetry — Use Poetry for dependency management
-include_codecov — Add Codecov integration
-
-
-INPUT DATA (tasks list):
-
-{tasks_list}
-
-TASK:
-
-You must summarize the result of repository refactoring based ONLY on the tasks listed above.
-
-Group tasks into logical blocks.
-Each logical block must contain:
-- a short name (plain sentence)
-- a short description (plain sentence)
-- a list of task numbers that belong to this block
+after_report_blocks_from_events_prompt = """
+INPUT DATA (operations list):
 
-OUTPUT FORMAT:
+{operations}
 
-Return ONLY valid JSON.
-No extra text, no explanations, no markdown.
-
-JSON structure:
-[
-  {{
-    "name": "Block name as a plain sentence",
-    "description": "Short description as a plain sentence",
-    "tasks": [1, 2]
-  }}
-]
-
-RULES (IMPORTANT):
+TASK:
+Group performed operations into logical blocks.
 
-1. Use double quotes only
-2. Output must be valid JSON
-3. Use ONLY task numbers from the input list
-4. Every task from 1 to 7 MUST be used exactly once
-5. Do NOT invent new tasks
-7. "tasks" must contain only numbers
+REQUIREMENTS:
+- Include ONLY operations with performed == Yes
+- Each performed operation must appear in exactly one block
+- "tasks" must list operation names exactly as provided (strings)
+- Do not invent operations
 
+OUTPUT:
+Return ONLY JSON matching the system message schema.
 """

osa_tool/config/prompts/system_messages.toml

@@ -174,4 +174,52 @@ Strict rules:
 {{
   "summary": "text",
 }}
+"""
+
+after_report_summary = """
+You are an assistant that writes concise and professional factual summary of made changes to repository.
+
+Input will contain a list of operations with:
+- performed flag (Yes/No)
+- normalized result payload
+- operation events (kind, target, optional data)
+
+Strict rules:
+- You MUST return a valid JSON object.
+- The JSON MUST conform exactly to the following schema:
+
+{{
+  "summary": "text"
+}}
+
+Content rules:
+- Only describe actions that were actually performed (performed == Yes).
+- Base claims on the provided events and result fields only.
+- Do NOT invent files, changes, or outcomes not present in the input.
+- Write in confident past tense.
+"""
+
+after_report_blocks = """
+You group performed operations into logical blocks.
+
+Input will contain a list of operations with performed flag (Yes/No) and details.
+
+Strict rules:
+- You MUST return valid JSON.
+- The JSON MUST be an array of objects with this schema:
+
+[
+  {{
+    "name": "short block name",
+    "description": "short block description",
+    "tasks": ["Operation name 1", "Operation name 2"]
+  }}
+]
+
+Grouping rules:
+- Use ONLY operation names exactly as provided in the input list.
+- Include ONLY operations where performed == Yes.
+- Every performed operation must appear in exactly one block.
+- Do NOT include operations with performed == No.
+- Do NOT add extra text outside JSON.
 """

osa_tool/operations/analysis/repository_report/report_generator.py

@@ -1,10 +1,12 @@
 import os
 
+from langchain_core.output_parsers import PydanticOutputParser
 from pydantic import ValidationError
 
 from osa_tool.config.settings import ConfigManager
 from osa_tool.core.git.metadata import RepositoryMetadata
 from osa_tool.core.llm.llm import ModelHandler, ModelHandlerFactory
+from osa_tool.core.models.event import OperationEvent
 from osa_tool.operations.analysis.repository_report.response_validation import (
     RepositoryReport,
     RepositoryStructure,
@@ -13,6 +15,8 @@
     OverallAssessment,
     AfterReportBlock,
     AfterReport,
+    AfterReportSummary,
+    AfterReportBlocksPlan,
 )
 from osa_tool.tools.repository_analysis.sourcerank import SourceRank
 from osa_tool.utils.logger import logger
@@ -90,11 +94,17 @@ def _extract_presence_files(self) -> list[str]:
 
 
 class AfterReportTextGenerator:
-    def __init__(self, config_manger: ConfigManager, what_has_been_done: list[tuple[str, bool]]) -> None:
+    def __init__(
+        self,
+        config_manger: ConfigManager,
+        completed_tasks: list[tuple[str, bool]],
+        task_results: dict[str, dict] | None = None,
+    ) -> None:
         self.config_manager = config_manger
         self.model_settings = self.config_manager.get_model_settings("general")
-        self.prompts = self.config_manager.config.prompts
-        self.what_has_been_done = what_has_been_done
+        self.prompts = self.config_manager.get_prompts()
+        self.completed_tasks = completed_tasks
+        self.task_results = task_results or {}
         self.model_handler: ModelHandler = ModelHandlerFactory.build(self.model_settings)
 
     def make_request(self) -> AfterReport:
@@ -104,32 +114,90 @@ def make_request(self) -> AfterReport:
         Returns:
             The generated OSA work summary response from the model.
         """
-        formatted_tasks = "\n".join(
-            f"Task {i}. {n}: {'Yes' if d else 'No'}" for i, (n, d) in enumerate(self.what_has_been_done)
-        )
-        json_prompt = PromptBuilder.render(
-            self.prompts.get("analysis.after_report_blocks_prompt"),
-            tasks_list=formatted_tasks,
-        )
-        summary_prompt = PromptBuilder.render(
-            self.prompts.get("analysis.after_report_text_prompt"),
-            tasks_list=formatted_tasks,
-        )
+        performed_lookup = {name: done for name, done in self.completed_tasks}
+        operations_text = self._operations_to_text(self.completed_tasks, self.task_results)
 
         try:
-            summary = self.model_handler.send_request(prompt=summary_prompt)
-            json_result = self.model_handler.send_and_parse(
-                prompt=json_prompt,
-                parser=lambda raw: [
-                    AfterReportBlock(
-                        name=d["name"],
-                        description=d["description"],
-                        tasks=[self.what_has_been_done[i] for i in d["tasks"]],
-                    )
-                    for d in JsonProcessor.parse(raw, expected_type=list)
-                ],
+            # Summary (structured JSON -> AfterReportSummary)
+            summary_parser = PydanticOutputParser(pydantic_object=AfterReportSummary)
+            summary_system = self.prompts.get("system_messages.after_report_summary")
+            summary_prompt = PromptBuilder.render(
+                self.prompts.get("analysis.after_report_summary_from_events_prompt"),
+                operations=operations_text,
+            )
+            summary_obj: AfterReportSummary = self.model_handler.run_chain(
+                prompt=summary_prompt,
+                parser=summary_parser,
+                system_message=summary_system,
+            )
+
+            # Blocks (structured JSON -> AfterReportBlocksPlan)
+            blocks_parser = PydanticOutputParser(pydantic_object=AfterReportBlocksPlan)
+            blocks_system = self.prompts.get("system_messages.after_report_blocks")
+            blocks_prompt = PromptBuilder.render(
+                self.prompts.get("analysis.after_report_blocks_from_events_prompt"),
+                operations=operations_text,
+            )
+            blocks_plan: AfterReportBlocksPlan = self.model_handler.run_chain(
+                prompt=blocks_prompt,
+                parser=blocks_parser,
+                system_message=blocks_system,
             )
-            return AfterReport(summary=summary, blocks=json_result)
+
+            blocks: list[AfterReportBlock] = []
+            for block in blocks_plan.root:
+                tasks = [(t, bool(performed_lookup.get(t, False))) for t in block.tasks]
+                blocks.append(AfterReportBlock(name=block.name, description=block.description, tasks=tasks))
+
+            return AfterReport(summary=summary_obj.summary, blocks=blocks)
+
         except Exception as e:
-            logger.error(f"Unexpected error while parsing RepositoryReport: {e}")
-            raise ValueError(f"Failed to process model response: {e}")
+            logger.error("Unexpected error while generating AfterReport: %s", e)
+            raise ValueError(f"Failed to process model response: {e}") from e
+
+    @staticmethod
+    def _events_to_text(events: list[OperationEvent]) -> str:
+        lines: list[str] = []
+        for e in events:
+            kind = getattr(e.kind, "value", str(e.kind))
+            line = "- %s: %s" % (kind, e.target)
+            data = getattr(e, "data", None) or {}
+            if data:
+                line += " (%s)" % ", ".join("%s=%s" % (k, v) for k, v in data.items())
+            lines.append(line)
+        return "\n".join(lines)
+
+    def _operations_to_text(self, completed_tasks: list[tuple[str, bool]], task_results: dict[str, dict]) -> str:
+        parts: list[str] = []
+
+        for name, done in completed_tasks:
+            details = task_results.get(name) or {}
+            result = details.get("result")
+            events = details.get("events") or []
+
+            # Result (truncate)
+            result_text = "None"
+            if result is not None:
+                result_text = str(result)
+                if len(result_text) > 600:
+                    result_text = result_text[:600] + "..."
+
+            # Events text
+            try:
+                events_text = self._events_to_text(events)
+            except Exception:
+                events_text = "\n".join("- %s" % str(e) for e in events) if events else ""
+
+            parts.append(
+                "\n".join(
+                    [
+                        f"Operation: {name}",
+                        f"Performed: {'Yes' if done else 'No'}",
+                        f"Result: {result_text}",
+                        "Events:",
+                        events_text or "- (none)",
+                    ]
+                )
+            )
+
+        return "\n\n---\n\n".join(parts)

osa_tool/operations/analysis/repository_report/report_maker.py

@@ -22,6 +22,7 @@
 from osa_tool.core.git.git_agent import GitAgent
 from osa_tool.core.models.event import OperationEvent, EventKind
 from osa_tool.operations.analysis.repository_report.report_generator import TextGenerator, AfterReportTextGenerator
+from osa_tool.scheduler.plan import Plan
 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
@@ -404,14 +405,15 @@ class WhatHasBeenDoneReportGenerator(AbstractReportGenerator):
     def __init__(
         self,
         config_manager: ConfigManager,
-        what_has_been_done: list[tuple[str, bool]],
+        plan: Plan,
         git_agent: GitAgent,
     ):
         super().__init__(config_manager, git_agent)
         self.filename = f"{self.metadata.name}_work_summary.pdf"
         self.output_path = os.path.join(os.getcwd(), self.filename)
-        self.what_has_been_done = what_has_been_done
-        self.text_generator = AfterReportTextGenerator(config_manager, self.what_has_been_done)
+        self.completed_tasks = plan.list_for_report
+        self.task_results = plan.results or {}
+        self.text_generator = AfterReportTextGenerator(config_manager, self.completed_tasks, self.task_results)
         self.start_log = f"Starting creating summary for OSA work"
         self.report_header = "OSA Work Summary"
         self.events: list[OperationEvent] = []