ai-cr 1.0.1__py3-none-any.whl → 2.0.0.dev2__py3-none-any.whl

{ai_code_review → gito}/commands/repl.py

@@ -3,7 +3,7 @@ Python REPL
 """
 # flake8: noqa: F401
 import code
-from ema.cli import app
+
 
 # Imports for usage in REPL
 import os
@@ -17,6 +17,8 @@ from rich.pretty import pprint
 import microcore as mc
 from microcore import ui
 
+from ..cli import app
+
 @app.command(help="python REPL")
 def repl():
     code.interact(local=globals())

ai_code_review/.ai-code-review.toml → gito/config.toml

@@ -1,14 +1,20 @@
+# :class: gito.project_config.ProjectConfig
+
+# Defines the keyword or mention tag that triggers bot actions when referenced in code review comments.
+# list of strings, case-insensitive
+mention_triggers = ["gito", "bot", "ai", "/fix"]
 report_template_md = """
-## 🤖 I've Reviewed the Code
+<h2><a href="https://github.com/Nayjest/Gito"><img src="https://raw.githubusercontent.com/Nayjest/Gito/main/press-kit/logo/gito-bot-1_64top.png" align="left" width=64 height=50></a>I've Reviewed the Code</h2>
 
 {% if report.summary -%}
     {{ report.summary }}
 {%- endif %}
 
-**{%- if report.total_issues > 0 %}⚠️{% endif -%}
-Total issues: `{{ report.total_issues }}`
-{{- ' ' -}}
-in `{{ report.number_of_processed_files }}` files**
+{% if report.total_issues > 0 -%}
+**⚠️ {{ report.total_issues }} issue{{ 's' if report.total_issues != 1 else '' }} found** across {{ report.number_of_processed_files }} file{{ 's' if report.number_of_processed_files != 1 else '' }}
+{%- else -%}
+**✅ No issues found** in {{ report.number_of_processed_files }} file{{ 's' if report.number_of_processed_files != 1 else '' }}
+{%- endif -%}
 
 {%- for issue in report.plain_issues -%}
     {{"\n"}}## `#{{ issue.id}}`  {{ issue.title -}}
@@ -31,6 +37,77 @@ in `{{ report.number_of_processed_files }}` files**
     {{ "\n" }}
 {%- endfor -%}
 
+"""
+report_template_cli = """
+{{ Back.BLUE }}  +  +  +  ---==<<[ CODE REVIEW{{Style.NORMAL}} ]>>==---  +  +  +  {{Style.RESET_ALL}}
+{% if report.total_issues > 0 -%}
+{{ Style.BRIGHT }}{{Back.RED}} ⚠️ {{ report.total_issues }} issue{{ 's' if report.total_issues != 1 else '' }} {{Back.RESET}} found across {{Back.BLUE}} {{ report.number_of_processed_files }} {{Back.RESET}} file{{ 's' if report.number_of_processed_files != 1 else '' }}{{ Style.RESET_ALL }}
+{%- else -%}
+{{ Style.BRIGHT }}{{Back.GREEN}} ✅  No issues found {{Back.RESET}} in {{Back.BLUE}} {{ report.number_of_processed_files }} {{Back.RESET}} file{{ 's' if report.number_of_processed_files != 1 else '' }}{{ Style.RESET_ALL }}
+{%- endif -%}
+
+{%- if report.summary -%}
+    {{- "\n" }}
+    {{- "\n" }}{{- Style.BRIGHT }}✨  SUMMARY {{ Style.RESET_ALL -}}
+    {{- "\n" }}{{- report.summary -}}
+{%- endif %}
+{% for issue in report.plain_issues -%}
+    {{"\n"}}{{ Style.BRIGHT }}{{Back.RED}}[ {{ issue.id}} ]{{Back.RESET}}  {{ issue.title -}}{{ Style.RESET_ALL -}}
+    {{ "\n"}}{{ file_link(issue.file) -}}
+    {%- if issue.affected_lines -%}:{{issue.affected_lines[0].start_line}}{%- endif -%}
+    {{' '}}
+
+    {%- if issue.affected_lines -%}
+        {% if issue.affected_lines[0].end_line != issue.affected_lines[0].start_line or issue.affected_lines|length > 1 -%}
+            {{ ui.gray }}Lines{{' '}}
+            {{- Fore.RESET -}}
+            {%- for i in issue.affected_lines -%}
+                {{ i.start_line }}{%- if i.end_line != i.start_line -%}{{ ui.gray }}–{{Fore.RESET}}{{ i.end_line }}{%- endif -%}
+                {%- if loop.last == false -%}
+                    {{ ui.gray(', ') }}
+                {%- endif -%}
+            {%- endfor -%}
+        {%- endif -%}
+    {%- endif -%}
+    {{-"\n"-}}
+
+    {% if issue.details -%}
+    {{- "\n" -}}
+    {{- issue.details.strip() -}}
+    {{-"\n" -}}
+    {%- endif -%}
+
+    {%- for tag in issue.tags -%}
+        {{Back.YELLOW}}{{Fore.BLACK}} {{tag}} {{Style.RESET_ALL}}{{ ' ' }}
+    {%- endfor -%}
+    {%- if issue.tags %}{{ "\n" }}{% endif -%}
+
+    {%- for i in issue.affected_lines -%}
+        {%- if i.affected_code -%}
+        {{- "\n"+Fore.RED + " ╭─" + "─"*4 + "[ 💥 Affected Code   ]" + "─"*4 + " ─── ── ─\n" -}}
+        {{- textwrap.indent(i.affected_code.strip(), Fore.RED+' │  ') -}}
+        {{- "\n ╰─"+"─"*2+Style.RESET_ALL -}}
+        {%- endif -%}
+        {%- if i.proposal -%}
+            {%- set maxlen = 100 -%}
+            {%- if not i.affected_code %}{{ Fore.GREEN }} ╭────{% endif -%}
+            {#- Wrap right for one-liner, doesn't prevent copying code -#}
+            {%- if i.proposal.splitlines() | length == 1 and max_line_len(i.proposal)<80 -%}
+                {{- Fore.GREEN + "─"*2 + "[ 💡 Proposed Change ]" + "─"*(max_line_len(i.proposal)-29) + "─╮" +"\n" -}}
+                {{- block_wrap_lr(i.proposal, '', ' │', 60) -}}
+                {{- "\n" + " ╰──"+"─"*(max_line_len(i.proposal)-5+1)+"─╯" -}}
+            {#- Open right side to not prevent multiline code copying -#}
+            {%- else -%}
+                {{- Fore.GREEN + "─"*2 + "[ 💡 Proposed Change ]" + "─"*([max_line_len(i.proposal)-29+2,maxlen-26-2]|min -2) + "─╮" +"\n" -}}
+                {{- i.proposal -}}
+                {{- "\n" + " ╰───"+"─"*([[max_line_len(i.proposal)-29+2,maxlen-29+1]|min - 2 + 29 - 5,29-7+2]|max)+"─╯" -}}
+            {%- endif -%}
+
+            {{- Style.RESET_ALL -}}
+        {% endif -%}
+    {%- endfor -%}
+    {{ "\n" }}
+{%- endfor -%}
 """
 retries = 3
 prompt = """
@@ -64,7 +141,7 @@ Respond with a valid JSON array of issues in the following format:
         "details": "<issue_description>",
         "tags": ["<issue_tag1>", "<issue_tag2>"],
         "severity": <issue_severity>,
-        "confidence": <confidence_score>
+        "confidence": <confidence_score>,
         "affected_lines": [ // optional; list of affected lines
             {
                 "start_line": <start_line:int>,
@@ -119,18 +196,45 @@ summary_prompt = """
 Summarize the code review in one sentence.
 --Reviewed Changes--
 {% for part in diff %}{{ part }}\n{% endfor %}
---Detected Issues--
+--Issues Detected by You--
 {{ issues | tojson(indent=2) }}
 ---
-If code changes contains exceptional achievements, you may additionally present the award in summary text.
+If the code changes include exceptional achievements, you may also present an award to the author in the summary text.
+Note: Awards should only be given to authors of initial codebase changes, not to code reviewers.
 --Available Awards--
 {{ awards }}
 ---
+{% if pipeline_out.associated_issue and pipeline_out.associated_issue.title %}
+----SUBTASK----
+Include one sentence about how the code changes address the requirements of the associated issue listed below.
+
+--Associated Issue--
+# {{ pipeline_out.associated_issue.title }}
+{{ pipeline_out.associated_issue.description }}
+URL: {{ pipeline_out.associated_issue.url }}
+---
+
+Examples:
+
+In case if the implementation delivers what was requested:
+```
+✅  Implementation Satisfies [<ISSUE_KEY>](<ISSUE_URL>).
+```
+In case of any critical concerns:
+```
+⚠️  <Your concern 1 here>.
+⚠️  <Your concern 2 here>.
+```
+--------
+{% endif -%}
 - Your response will be parsed programmatically, so do not include any additional text.
+- Do not include the issues by itself to the summary, they are already provided in the context.
 - Use Markdown formatting in your response.
 {{ summary_requirements -}}
 """
-
+[pipeline_steps.jira]
+call="gito.pipeline_steps.jira.fetch_associated_issue"
+envs=["local","gh-action"]
 [prompt_vars]
 self_id = """
 You are a subsystem of an AI-powered software platform, specifically tasked with performing expert code reviews.

gito/constants.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+PROJECT_GITO_FOLDER = ".gito"
+PROJECT_CONFIG_FILE_NAME = "config.toml"
+PROJECT_CONFIG_FILE_PATH = Path(".gito") / PROJECT_CONFIG_FILE_NAME
+PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE = Path(__file__).resolve().parent / PROJECT_CONFIG_FILE_NAME
+HOME_ENV_PATH = Path("~/.gito/.env").expanduser()
+JSON_REPORT_FILE_NAME = "code-review-report.json"
+EXECUTABLE = "gito"

{ai_code_review → gito}/core.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import microcore as mc
 from git import Repo
+from gito.pipeline import Pipeline
 from unidiff import PatchSet, PatchedFile
 from unidiff.constants import DEV_NULL
 
@@ -14,6 +15,10 @@ from .report_struct import Report
 from .constants import JSON_REPORT_FILE_NAME
 
 
+def review_subject_is_index(what):
+    return not what or what == 'INDEX'
+
+
 def is_binary_file(repo: Repo, file_path: str) -> bool:
     """
     Check if a file is binary by attempting to read it as text.
@@ -25,7 +30,20 @@ def is_binary_file(repo: Repo, file_path: str) -> bool:
         # Try decoding as UTF-8; if it fails, it's likely binary
         content.decode("utf-8")
         return False
-    except (UnicodeDecodeError, KeyError):
+    except KeyError:
+        try:
+            fs_path = Path(repo.working_tree_dir) / file_path
+            fs_path.read_text(encoding='utf-8')
+            return False
+        except FileNotFoundError:
+            logging.error(f"File {file_path} not found in the repository.")
+            return True
+        except UnicodeDecodeError:
+            return True
+        except Exception as e:
+            logging.error(f"Error reading file {file_path}: {e}")
+            return True
+    except UnicodeDecodeError:
         return True
     except Exception as e:
         logging.warning(f"Error checking if file {file_path} is binary: {e}")
@@ -40,11 +58,12 @@ def get_diff(
 ) -> PatchSet | list[PatchedFile]:
     repo = repo or Repo(".")
     if not against:
-        against = repo.remotes.origin.refs.HEAD.reference.name  # origin/main
-    if not what:
+        # 'origin/main', 'origin/master', etc
+        against = repo.remotes.origin.refs.HEAD.reference.name
+    if review_subject_is_index(what):
         what = None  # working copy
     if use_merge_base:
-        if what is None:
+        if review_subject_is_index(what):
             try:
                 current_ref = repo.active_branch.name
             except TypeError:
@@ -65,7 +84,6 @@ def get_diff(
     )
     diff_content = repo.git.diff(against, what)
     diff = PatchSet.from_string(diff_content)
-    diff = PatchSet.from_string(diff_content)
 
     # Filter out binary files
     non_binary_diff = PatchSet([])
@@ -76,7 +94,9 @@ def get_diff(
             if patched_file.target_file != DEV_NULL
             else patched_file.source_file
         )
-        if file_path == DEV_NULL or is_binary_file(repo, file_path.lstrip("b/")):
+        if file_path == DEV_NULL:
+            continue
+        if is_binary_file(repo, file_path.lstrip("b/")):
             logging.info(f"Skipping binary file: {patched_file.path}")
             continue
         non_binary_diff.append(patched_file)
@@ -102,8 +122,18 @@ def filter_diff(
     return files
 
 
-def file_lines(repo: Repo, file: str, max_tokens: int = None) -> str:
-    text = repo.tree()[file].data_stream.read().decode()
+def file_lines(repo: Repo, file: str, max_tokens: int = None, use_local_files: bool = False) -> str:
+    if use_local_files:
+        file_path = Path(repo.working_tree_dir) / file
+        try:
+            text = file_path.read_text(encoding='utf-8')
+        except (FileNotFoundError, UnicodeDecodeError) as e:
+            logging.warning(f"Could not read file {file} from working directory: {e}")
+            text = repo.tree()[file].data_stream.read().decode('utf-8')
+    else:
+        # Read from HEAD (committed version)
+        text = repo.tree()[file].data_stream.read().decode('utf-8')
+
     lines = [f"{i + 1}: {line}\n" for i, line in enumerate(text.splitlines())]
     if max_tokens:
         lines, removed_qty = mc.tokenizing.fit_to_token_size(lines, max_tokens)
@@ -114,15 +144,16 @@ def file_lines(repo: Repo, file: str, max_tokens: int = None) -> str:
     return "".join(lines)
 
 
-def make_cr_summary(cfg: ProjectConfig, report: Report, diff):
+def make_cr_summary(config: ProjectConfig, report: Report, diff, **kwargs) -> str:
     return (
         mc.prompt(
-            cfg.summary_prompt,
-            diff=mc.tokenizing.fit_to_token_size(diff, cfg.max_code_tokens)[0],
+            config.summary_prompt,
+            diff=mc.tokenizing.fit_to_token_size(diff, config.max_code_tokens)[0],
             issues=report.issues,
-            **cfg.prompt_vars,
+            **config.prompt_vars,
+            **kwargs,
         ).to_llm()
-        if cfg.summary_prompt
+        if config.summary_prompt
         else ""
     )
 
@@ -135,8 +166,8 @@ async def review(
     use_merge_base: bool = True,
     out_folder: str | PathLike | None = None,
 ):
-    cfg = ProjectConfig.load()
     repo = repo or Repo(".")
+    cfg = ProjectConfig.load_for_repo(repo)
     out_folder = Path(out_folder or repo.working_tree_dir)
     diff = get_diff(
         repo=repo, what=what, against=against, use_merge_base=use_merge_base
@@ -152,6 +183,7 @@ async def review(
                 file_diff.path,
                 cfg.max_code_tokens
                 - mc.tokenizing.num_tokens_from_string(str(file_diff)),
+                use_local_files=review_subject_is_index(what)
             )
             if file_diff.target_file != DEV_NULL and not file_diff.is_added_file
             else ""
@@ -183,9 +215,25 @@ async def review(
     exec(cfg.post_process, {"mc": mc, **locals()})
     out_folder.mkdir(parents=True, exist_ok=True)
     report = Report(issues=issues, number_of_processed_files=len(diff))
-    report.summary = make_cr_summary(cfg, report, diff)
+    ctx = dict(
+        report=report,
+        config=cfg,
+        diff=diff,
+        repo=repo,
+        pipeline_out={},
+    )
+    if cfg.pipeline_steps:
+        pipe = Pipeline(
+            ctx=ctx,
+            steps=cfg.pipeline_steps
+        )
+        pipe.run()
+    else:
+        logging.info("No pipeline steps defined, skipping pipeline execution")
+
+    report.summary = make_cr_summary(**ctx)
     report.save(file_name=out_folder / JSON_REPORT_FILE_NAME)
     report_text = report.render(cfg, Report.Format.MARKDOWN)
-    print(mc.ui.yellow(report_text))
     text_report_path = out_folder / "code-review-report.md"
     text_report_path.write_text(report_text, encoding="utf-8")
+    report.to_cli()

gito/issue_trackers.py

@@ -0,0 +1,15 @@
+import re
+from dataclasses import dataclass, field
+
+
+def extract_issue_key(branch_name: str, min_len=2, max_len=10) -> str | None:
+    pattern = fr"\b[A-Z][A-Z0-9]{{{min_len - 1},{max_len - 1}}}-\d+\b"
+    match = re.search(pattern, branch_name)
+    return match.group(0) if match else None
+
+
+@dataclass
+class IssueTrackerIssue:
+    title: str = field(default="")
+    description: str = field(default="")
+    url: str = field(default="")

gito/pipeline.py

@@ -0,0 +1,70 @@
+import logging
+from enum import StrEnum
+from dataclasses import dataclass, field
+
+from gito.utils import is_running_in_github_action
+from microcore import ui
+from microcore.utils import resolve_callable
+
+
+class PipelineEnv(StrEnum):
+    LOCAL = "local"
+    GH_ACTION = "gh-action"
+
+    @staticmethod
+    def all():
+        return [PipelineEnv.LOCAL, PipelineEnv.GH_ACTION]
+
+    @staticmethod
+    def current():
+        return (
+            PipelineEnv.GH_ACTION
+            if is_running_in_github_action()
+            else PipelineEnv.LOCAL
+        )
+
+
+@dataclass
+class PipelineStep:
+    call: str
+    envs: list[PipelineEnv] = field(default_factory=PipelineEnv.all)
+
+    def get_callable(self):
+        """
+        Resolve the callable from the string representation.
+        """
+        return resolve_callable(self.call)
+
+    def run(self, *args, **kwargs):
+        return self.get_callable()(*args, **kwargs)
+
+
+@dataclass
+class Pipeline:
+    ctx: dict = field(default_factory=dict)
+    steps: dict[str, PipelineStep] = field(default_factory=dict)
+
+    def run(self, *args, **kwargs):
+        cur_env = PipelineEnv.current()
+        logging.info("Running pipeline... [env: %s]", ui.yellow(cur_env))
+        self.ctx["pipeline_out"] = self.ctx.get("pipeline_out", {})
+        for step_name, step in self.steps.items():
+            if cur_env in step.envs:
+                logging.info(f"Running pipeline step: {step_name}")
+                try:
+                    step_output = step.run(*args, **kwargs, **self.ctx)
+                    if isinstance(step_output, dict):
+                        self.ctx["pipeline_out"].update(step_output)
+                    self.ctx["pipeline_out"][step_name] = step_output
+                    if not step_output:
+                        logging.warning(
+                            f'Pipeline step "{step_name}" returned {repr(step_output)}.'
+                        )
+                except Exception as e:
+                    logging.error(f'Error in pipeline step "{step_name}": {e}')
+            else:
+                logging.info(
+                    f"Skipping pipeline step: {step_name}"
+                    f" [env: {ui.yellow(cur_env)} not in {step.envs}]"
+                )
+        return self.ctx["pipeline_out"]

gito/pipeline_steps/jira.py

@@ -0,0 +1,83 @@
+import logging
+import os
+
+import git
+from jira import JIRA
+
+from gito.issue_trackers import extract_issue_key, IssueTrackerIssue
+from gito.utils import is_running_in_github_action
+
+
+def fetch_issue(issue_key, jira_url, username, api_token) -> IssueTrackerIssue | None:
+    try:
+        jira = JIRA(jira_url, basic_auth=(username, api_token))
+        issue = jira.issue(issue_key)
+        return IssueTrackerIssue(
+            title=issue.fields.summary,
+            description=issue.fields.description or "",
+            url=f"{jira_url.rstrip('/')}/browse/{issue_key}"
+        )
+    except Exception as e:
+        logging.error(f"Failed to fetch Jira issue {issue_key}: {e}")
+        return None
+
+
+def get_branch(repo: git.Repo):
+    if is_running_in_github_action():
+        branch_name = os.getenv('GITHUB_HEAD_REF')
+        if branch_name:
+            return branch_name
+
+        github_ref = os.getenv('GITHUB_REF', '')
+        if github_ref.startswith('refs/heads/'):
+            return github_ref.replace('refs/heads/', '')
+    try:
+        branch_name = repo.active_branch.name
+        return branch_name
+    except Exception as e:  # @todo: specify more precise exception
+        logging.error("Could not determine the active branch name: %s", e)
+        return None
+
+
+def fetch_associated_issue(
+    repo: git.Repo,
+    jira_url=None,
+    jira_username=None,
+    jira_api_token=None,
+    **kwargs
+):
+    """
+    Pipeline step to fetch a Jira issue based on the current branch name.
+    """
+    branch_name = get_branch(repo)
+    if not branch_name:
+        logging.error("No active branch found in the repository, cannot determine Jira issue key.")
+        return None
+
+    if not (issue_key := extract_issue_key(branch_name)):
+        logging.error(f"No Jira issue key found in branch name: {branch_name}")
+        return None
+
+    jira_url = jira_url or os.getenv("JIRA_URL")
+    jira_username = (
+        jira_username
+        or os.getenv("JIRA_USERNAME")
+        or os.getenv("JIRA_USER")
+        or os.getenv("JIRA_EMAIL")
+    )
+    jira_token = (
+        jira_api_token
+        or os.getenv("JIRA_API_TOKEN")
+        or os.getenv("JIRA_API_KEY")
+        or os.getenv("JIRA_TOKEN")
+    )
+    try:
+        assert jira_url, "JIRA_URL is not set"
+        assert jira_username, "JIRA_USERNAME is not set"
+        assert jira_token, "JIRA_API_TOKEN is not set"
+    except AssertionError as e:
+        logging.error(f"Jira configuration error: {e}")
+        return None
+    return dict(
+        associated_issue=fetch_issue(issue_key, jira_url, jira_username, jira_token)
+    )

gito/project_config.py

@@ -0,0 +1,71 @@
+import logging
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import microcore as mc
+from gito.utils import detect_github_env
+from microcore import ui
+from git import Repo
+
+from .constants import PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, PROJECT_CONFIG_FILE_PATH
+from .pipeline import PipelineStep
+
+
+@dataclass
+class ProjectConfig:
+    prompt: str = ""
+    summary_prompt: str = ""
+    report_template_md: str = ""
+    """Markdown report template"""
+    report_template_cli: str = ""
+    """Report template for CLI output"""
+    post_process: str = ""
+    retries: int = 3
+    """LLM retries for one request"""
+    max_code_tokens: int = 32000
+    prompt_vars: dict = field(default_factory=dict)
+    mention_triggers: list[str] = field(default_factory=list)
+    """
+    Defines the keyword or mention tag that triggers bot actions
+    when referenced in code review comments.
+    """
+    pipeline_steps: dict[str, dict | PipelineStep] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.pipeline_steps = {
+            k: PipelineStep(**v) if isinstance(v, dict) else v
+            for k, v in self.pipeline_steps.items()
+        }
+
+    @staticmethod
+    def _read_bundled_defaults() -> dict:
+        with open(PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, "rb") as f:
+            config = tomllib.load(f)
+        return config
+
+    @staticmethod
+    def load_for_repo(repo: Repo):
+        return ProjectConfig.load(Path(repo.working_tree_dir) / PROJECT_CONFIG_FILE_PATH)
+
+    @staticmethod
+    def load(config_path: str | Path | None = None) -> "ProjectConfig":
+        config = ProjectConfig._read_bundled_defaults()
+        github_env = detect_github_env()
+        config["prompt_vars"] |= github_env | dict(github_env=github_env)
+
+        config_path = Path(config_path or PROJECT_CONFIG_FILE_PATH)
+        if config_path.exists():
+            logging.info(
+                f"Loading project-specific configuration from {mc.utils.file_link(config_path)}...")
+            default_prompt_vars = config["prompt_vars"]
+            with open(config_path, "rb") as f:
+                config.update(tomllib.load(f))
+            # overriding prompt_vars config section will not empty default values
+            config["prompt_vars"] = default_prompt_vars | config["prompt_vars"]
+        else:
+            logging.info(
+                f"No project config found at {ui.blue(config_path)}, using defaults"
+            )
+
+        return ProjectConfig(**config)

{ai_code_review → gito}/report_struct.py

@@ -3,12 +3,16 @@ import logging
 from dataclasses import dataclass, field, asdict
 from datetime import datetime
 from enum import StrEnum
+from pathlib import Path
 
 import microcore as mc
+from colorama import Fore, Style, Back
+from microcore.utils import file_link
+import textwrap
 
 from .constants import JSON_REPORT_FILE_NAME
 from .project_config import ProjectConfig
-from .utils import syntax_hint
+from .utils import syntax_hint, block_wrap_lr, max_line_len
 
 
 @dataclass
@@ -57,13 +61,15 @@ class Issue:
 class Report:
     class Format(StrEnum):
         MARKDOWN = "md"
+        CLI = "cli"
 
-    issues: dict = field(default_factory=dict)
+    issues: dict[str, list[Issue]] = field(default_factory=dict)
     summary: str = field(default="")
     number_of_processed_files: int = field(default=0)
     total_issues: int = field(init=False)
     created_at: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     model: str = field(default_factory=lambda: mc.config().MODEL)
+    pipeline_out: dict = field(default_factory=dict)
 
     @property
     def plain_issues(self):
@@ -94,15 +100,34 @@ class Report:
         logging.info(f"Report saved to {mc.utils.file_link(file_name)}")
 
     @staticmethod
-    def load(file_name: str = ""):
+    def load(file_name: str | Path = ""):
         with open(file_name or JSON_REPORT_FILE_NAME, "r") as f:
             data = json.load(f)
         data.pop("total_issues", None)
         return Report(**data)
 
     def render(
-        self, cfg: ProjectConfig = None, format: Format = Format.MARKDOWN
+        self,
+        config: ProjectConfig = None,
+        report_format: Format = Format.MARKDOWN,
     ) -> str:
-        cfg = cfg or ProjectConfig.load()
-        template = getattr(cfg, f"report_template_{format}")
-        return mc.prompt(template, report=self, **cfg.prompt_vars)
+        config = config or ProjectConfig.load()
+        template = getattr(config, f"report_template_{report_format}")
+        return mc.prompt(
+            template,
+            report=self,
+            ui=mc.ui,
+            Fore=Fore,
+            Style=Style,
+            Back=Back,
+            file_link=file_link,
+            textwrap=textwrap,
+            block_wrap_lr=block_wrap_lr,
+            max_line_len=max_line_len,
+            **config.prompt_vars
+        )
+
+    def to_cli(self, report_format=Format.CLI):
+        output = self.render(report_format=report_format)
+        print("")
+        print(output)