jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_sec/file_manager.py

@@ -8,14 +8,19 @@
 3. analysis.jsonl - 分析结果文件：包括所有聚类，聚类中哪些问题是问题，哪些问题是误报
 """
 
-from typing import Dict, List, Set, Tuple
-from pathlib import Path
 import json
-import typer
+from pathlib import Path
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Set
+from typing import Tuple
 
+from jarvis.jarvis_utils.output import PrettyOutput
 
 # ==================== 文件路径定义 ====================
 
+
 def get_candidates_file(sec_dir: Path) -> Path:
     """获取只扫结果文件路径"""
     return sec_dir / "candidates.jsonl"
@@ -33,10 +38,11 @@ def get_analysis_file(sec_dir: Path) -> Path:
 
 # ==================== 只扫结果文件 (candidates.jsonl) ====================
 
+
 def save_candidates(sec_dir: Path, candidates: List[Dict]) -> None:
     """
     保存只扫结果到 candidates.jsonl
-    
+
     格式：每行一个候选，包含所有原始信息 + gid
     {
         "gid": 1,
@@ -52,14 +58,16 @@ def save_candidates(sec_dir: Path, candidates: List[Dict]) -> None:
     """
     path = get_candidates_file(sec_dir)
     path.parent.mkdir(parents=True, exist_ok=True)
-    
+
     # 覆盖模式，确保文件内容是最新的
     with path.open("w", encoding="utf-8") as f:
         for candidate in candidates:
             f.write(json.dumps(candidate, ensure_ascii=False) + "\n")
-    
+
     try:
-        typer.secho(f"[jarvis-sec] 已保存 {len(candidates)} 个候选到 {path}", fg=typer.colors.GREEN)
+        PrettyOutput.auto_print(
+            f"✅ [jarvis-sec] 已保存 {len(candidates)} 个候选到 {path}"
+        )
     except Exception:
         pass
 
@@ -67,12 +75,12 @@ def save_candidates(sec_dir: Path, candidates: List[Dict]) -> None:
 def load_candidates(sec_dir: Path) -> List[Dict]:
     """
     从 candidates.jsonl 加载只扫结果
-    
+
     返回: 候选列表，每个候选包含gid
     """
     path = get_candidates_file(sec_dir)
     candidates = []
-    
+
     if path.exists():
         try:
             with path.open("r", encoding="utf-8", errors="ignore") as f:
@@ -87,10 +95,12 @@ def load_candidates(sec_dir: Path) -> List[Dict]:
                         pass
         except Exception as e:
             try:
-                typer.secho(f"[jarvis-sec] 警告：加载 candidates.jsonl 失败: {e}", fg=typer.colors.YELLOW)
+                PrettyOutput.auto_print(
+                    f"⚠️ [jarvis-sec] 警告：加载 candidates.jsonl 失败: {e}"
+                )
             except Exception:
                 pass
-    
+
     return candidates
 
 
@@ -110,10 +120,11 @@ def get_all_candidate_gids(sec_dir: Path) -> Set[int]:
 
 # ==================== 聚类信息文件 (clusters.jsonl) ====================
 
+
 def save_cluster(sec_dir: Path, cluster: Dict) -> None:
     """
     保存单个聚类到 clusters.jsonl（追加模式）
-    
+
     格式：每行一个聚类记录
     {
         "cluster_id": "file_path|batch_index|index",  # 唯一标识
@@ -129,7 +140,7 @@ def save_cluster(sec_dir: Path, cluster: Dict) -> None:
     """
     path = get_clusters_file(sec_dir)
     path.parent.mkdir(parents=True, exist_ok=True)
-    
+
     # 追加模式
     with path.open("a", encoding="utf-8") as f:
         f.write(json.dumps(cluster, ensure_ascii=False) + "\n")
@@ -138,12 +149,12 @@ def save_cluster(sec_dir: Path, cluster: Dict) -> None:
 def load_clusters(sec_dir: Path) -> List[Dict]:
     """
     从 clusters.jsonl 加载所有聚类
-    
+
     返回: 聚类列表
     """
     path = get_clusters_file(sec_dir)
     clusters = []
-    
+
     if path.exists():
         try:
             # 使用字典合并：key 为 cluster_id，合并同一个 cluster_id 的所有记录的 gid
@@ -159,28 +170,35 @@ def load_clusters(sec_dir: Path) -> List[Dict]:
                         if cluster_id:
                             if cluster_id in seen_clusters:
                                 # 如果已存在，合并 gid 列表（去重）
-                                existing_gids = set(seen_clusters[cluster_id].get("gids", []))
+                                existing_gids = set(
+                                    seen_clusters[cluster_id].get("gids", [])
+                                )
                                 new_gids = set(cluster.get("gids", []))
                                 merged_gids = sorted(list(existing_gids | new_gids))
                                 seen_clusters[cluster_id]["gids"] = merged_gids
                                 # 保留最新的其他字段（verification, is_invalid 等）
-                                seen_clusters[cluster_id].update({
-                                    k: v for k, v in cluster.items() 
-                                    if k != "gids" and k != "cluster_id"
-                                })
+                                seen_clusters[cluster_id].update(
+                                    {
+                                        k: v
+                                        for k, v in cluster.items()
+                                        if k != "gids" and k != "cluster_id"
+                                    }
+                                )
                             else:
                                 # 第一次遇到这个 cluster_id，直接保存
                                 seen_clusters[cluster_id] = cluster
                     except Exception:
                         pass
-            
+
             clusters = list(seen_clusters.values())
         except Exception as e:
             try:
-                typer.secho(f"[jarvis-sec] 警告：加载 clusters.jsonl 失败: {e}", fg=typer.colors.YELLOW)
+                PrettyOutput.auto_print(
+                    f"⚠️ [jarvis-sec] 警告：加载 clusters.jsonl 失败: {e}"
+                )
             except Exception:
                 pass
-    
+
     return clusters
 
 
@@ -204,22 +222,23 @@ def get_all_clustered_gids(sec_dir: Path) -> Set[int]:
 def validate_clustering_completeness(sec_dir: Path) -> Tuple[bool, Set[int]]:
     """
     校验聚类完整性，确保所有候选的gid都被聚类
-    
+
     返回: (is_complete, missing_gids)
     """
     all_candidate_gids = get_all_candidate_gids(sec_dir)
     all_clustered_gids = get_all_clustered_gids(sec_dir)
     missing_gids = all_candidate_gids - all_clustered_gids
-    
+
     return len(missing_gids) == 0, missing_gids
 
 
 # ==================== 分析结果文件 (analysis.jsonl) ====================
 
+
 def save_analysis_result(sec_dir: Path, analysis: Dict) -> None:
     """
     保存单个分析结果到 analysis.jsonl（追加模式）
-    
+
     格式：每行一个分析结果记录
     {
         "cluster_id": "file_path|batch_index|index",  # 对应的聚类ID
@@ -244,7 +263,7 @@ def save_analysis_result(sec_dir: Path, analysis: Dict) -> None:
     """
     path = get_analysis_file(sec_dir)
     path.parent.mkdir(parents=True, exist_ok=True)
-    
+
     # 追加模式
     with path.open("a", encoding="utf-8") as f:
         f.write(json.dumps(analysis, ensure_ascii=False) + "\n")
@@ -253,12 +272,12 @@ def save_analysis_result(sec_dir: Path, analysis: Dict) -> None:
 def load_analysis_results(sec_dir: Path) -> List[Dict]:
     """
     从 analysis.jsonl 加载所有分析结果
-    
+
     返回: 分析结果列表
     """
     path = get_analysis_file(sec_dir)
     results = []
-    
+
     if path.exists():
         try:
             # 使用字典合并：key 为 cluster_id，合并同一个 cluster_id 的所有记录
@@ -275,48 +294,73 @@ def load_analysis_results(sec_dir: Path) -> List[Dict]:
                             if cluster_id in seen_results:
                                 # 如果已存在，合并 gid、verified_gids、false_positive_gids 和 issues
                                 existing = seen_results[cluster_id]
-                                
+
                                 # 合并 gids（去重）
                                 existing_gids = set(existing.get("gids", []))
                                 new_gids = set(result.get("gids", []))
-                                existing["gids"] = sorted(list(existing_gids | new_gids))
-                                
+                                existing["gids"] = sorted(
+                                    list(existing_gids | new_gids)
+                                )
+
                                 # 合并 verified_gids（去重）
-                                existing_verified = set(existing.get("verified_gids", []))
+                                existing_verified = set(
+                                    existing.get("verified_gids", [])
+                                )
                                 new_verified = set(result.get("verified_gids", []))
-                                existing["verified_gids"] = sorted(list(existing_verified | new_verified))
-                                
+                                existing["verified_gids"] = sorted(
+                                    list(existing_verified | new_verified)
+                                )
+
                                 # 合并 false_positive_gids（去重）
-                                existing_false = set(existing.get("false_positive_gids", []))
+                                existing_false = set(
+                                    existing.get("false_positive_gids", [])
+                                )
                                 new_false = set(result.get("false_positive_gids", []))
-                                existing["false_positive_gids"] = sorted(list(existing_false | new_false))
-                                
+                                existing["false_positive_gids"] = sorted(
+                                    list(existing_false | new_false)
+                                )
+
                                 # 合并 issues（通过 gid 去重）
-                                existing_issues = {issue.get("gid"): issue for issue in existing.get("issues", [])}
+                                existing_issues = {
+                                    issue.get("gid"): issue
+                                    for issue in existing.get("issues", [])
+                                }
                                 for issue in result.get("issues", []):
                                     gid = issue.get("gid")
                                     if gid:
                                         existing_issues[gid] = issue  # 保留最新的 issue
                                 existing["issues"] = list(existing_issues.values())
-                                
+
                                 # 保留最新的其他字段
-                                existing.update({
-                                    k: v for k, v in result.items() 
-                                    if k not in ["gids", "verified_gids", "false_positive_gids", "issues", "cluster_id"]
-                                })
+                                existing.update(
+                                    {
+                                        k: v
+                                        for k, v in result.items()
+                                        if k
+                                        not in [
+                                            "gids",
+                                            "verified_gids",
+                                            "false_positive_gids",
+                                            "issues",
+                                            "cluster_id",
+                                        ]
+                                    }
+                                )
                             else:
                                 # 第一次遇到这个 cluster_id，直接保存
                                 seen_results[cluster_id] = result
                     except Exception:
                         pass
-            
+
             results = list(seen_results.values())
         except Exception as e:
             try:
-                typer.secho(f"[jarvis-sec] 警告：加载 analysis.jsonl 失败: {e}", fg=typer.colors.YELLOW)
+                PrettyOutput.auto_print(
+                    f"⚠️ [jarvis-sec] 警告：加载 analysis.jsonl 失败: {e}"
+                )
             except Exception:
                 pass
-    
+
     return results
 
 
@@ -373,10 +417,11 @@ def get_false_positive_gids(sec_dir: Path) -> Set[int]:
 
 # ==================== 断点恢复状态检查 ====================
 
-def get_resume_status(sec_dir: Path) -> Dict[str, any]:
+
+def get_resume_status(sec_dir: Path) -> Dict[str, Any]:
     """
     根据3个配置文件的存在性和状态，推断断点恢复状态
-    
+
     返回: {
         "has_candidates": bool,  # 是否有只扫结果
         "has_clusters": bool,  # 是否有聚类结果
@@ -398,30 +443,29 @@ def get_resume_status(sec_dir: Path) -> Dict[str, any]:
         "clustering_complete": False,
         "missing_gids": set(),
     }
-    
+
     # 检查只扫结果
     candidates = load_candidates(sec_dir)
     if candidates:
         status["has_candidates"] = True
         status["candidates_count"] = len(candidates)
-    
+
     # 检查聚类结果
     clusters = load_clusters(sec_dir)
     if clusters:
         status["has_clusters"] = True
         status["clusters_count"] = len(clusters)
-    
+
     # 检查分析结果
     results = load_analysis_results(sec_dir)
     if results:
         status["has_analysis"] = True
         status["analysis_count"] = len(results)
-    
+
     # 校验聚类完整性
     if status["has_candidates"]:
         is_complete, missing_gids = validate_clustering_completeness(sec_dir)
         status["clustering_complete"] = is_complete
         status["missing_gids"] = missing_gids
-    
-    return status
 
+    return status

jarvis/jarvis_sec/parsers.py

@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
 """解析模块 - 用于解析Agent返回的JSON格式摘要"""
 
-from typing import List, Optional
+from typing import List
+from typing import Optional
+
 from jarvis.jarvis_utils.jsonnet_compat import loads as json_loads
 
 
@@ -9,6 +11,7 @@ def parse_clusters_from_text(text: str) -> tuple[Optional[List], Optional[str]]:
     """解析聚类文本，返回(解析结果, 错误信息)"""
     try:
         import re as _re
+
         # 使用正则表达式进行大小写不敏感的匹配
         pattern = r"<CLUSTERS>([\s\S]*?)</CLUSTERS>"
         match = _re.search(pattern, text, flags=_re.IGNORECASE)
@@ -18,10 +21,10 @@ def parse_clusters_from_text(text: str) -> tuple[Optional[List], Optional[str]]:
             end = text.find("</CLUSTERS>")
             if start == -1 or end == -1 or end <= start:
                 return None, "未找到 <CLUSTERS> 或 </CLUSTERS> 标签，或标签顺序错误"
-            content = text[start + len("<CLUSTERS>"):end].strip()
+            content = text[start + len("<CLUSTERS>") : end].strip()
         else:
             content = match.group(1).strip()
-        
+
         if not content:
             return None, "JSON 内容为空"
         try:
@@ -45,6 +48,7 @@ def try_parse_summary_report(text: str) -> tuple[Optional[object], Optional[str]
     """
     try:
         import re as _re
+
         # 使用正则表达式进行大小写不敏感的匹配
         pattern = r"<REPORT>([\s\S]*?)</REPORT>"
         match = _re.search(pattern, text, flags=_re.IGNORECASE)
@@ -54,10 +58,10 @@ def try_parse_summary_report(text: str) -> tuple[Optional[object], Optional[str]
             end = text.find("</REPORT>")
             if start == -1 or end == -1 or end <= start:
                 return None, "未找到 <REPORT> 或 </REPORT> 标签，或标签顺序错误"
-            content = text[start + len("<REPORT>"):end].strip()
+            content = text[start + len("<REPORT>") : end].strip()
         else:
             content = match.group(1).strip()
-        
+
         if not content:
             return None, "JSON 内容为空"
         try:
@@ -70,4 +74,3 @@ def try_parse_summary_report(text: str) -> tuple[Optional[object], Optional[str]
         return None, f"JSON 解析结果不是字典或数组，而是 {type(data).__name__}"
     except Exception as e:
         return None, f"解析过程发生异常: {str(e)}"
-

jarvis/jarvis_sec/prompts.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 """提示词构建模块"""
 
+from jarvis.jarvis_utils.tag import ot
+
 
 def build_summary_prompt() -> str:
     """
@@ -121,7 +123,7 @@ def build_verification_summary_prompt() -> str:
 
 def get_review_system_prompt() -> str:
     """获取复核Agent的系统提示词"""
-    return """
+    return f"""
 # 复核Agent约束
 - 你的核心任务是复核聚类Agent给出的无效结论是否充分和正确。
 - 你需要仔细检查聚类Agent提供的invalid_reason是否充分，是否真的考虑了所有可能的路径。
@@ -137,7 +139,7 @@ def get_review_system_prompt() -> str:
   - 必须验证聚类Agent是否真的确认了所有路径都有保护措施。
   - 如果发现聚类Agent遗漏了某些路径、调用者或边界情况，必须判定为理由不充分。
   - 保守策略：有疑问时，一律判定为理由不充分，将候选重新加入验证流程。
-- 完成复核后，主输出仅打印结束符 <!!!COMPLETE!!!> ，不需要汇总结果。
+- 完成复核后，主输出仅打印结束符 {ot("!!!COMPLETE!!!")}，不要输出其他任何内容。任务总结将会在后面的交互中被询问。
     """.strip()
 
 
@@ -265,4 +267,3 @@ def get_cluster_summary_prompt() -> str:
 ]
 </CLUSTERS>
     """.strip()
-

jarvis/jarvis_sec/report.py

@@ -50,13 +50,17 @@ from __future__ import annotations
 import csv
 import hashlib
 import io
-from typing import Dict, List, Optional, Union
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
 
 # 依赖 Issue 结构，但本模块不直接导入 dataclass，接受 dict/Issue 两种形态
 try:
     from jarvis.jarvis_sec.types import Issue  # 类型提示用，避免循环依赖
 except Exception:
-    Issue = dict  # type: ignore
+    Issue = Dict[str, Any]  # type: ignore
 
 
 # ---------------------------
@@ -79,6 +83,7 @@ _SEVERITY_WEIGHT = {
     "low": 1.0,
 }
 
+
 def _as_dict(item: Union[Issue, Dict]) -> Dict:
     """
     将 Issue/dataclass 或 dict 统一为 dict。
@@ -112,7 +117,12 @@ def _normalize_issue(i: Dict) -> Dict:
     归一化字段并补充缺省值。
     """
     j = {
-        "language": i.get("language", "c/cpp" if str(i.get("file", "")).endswith((".c", ".cpp", ".h", ".hpp")) else "rust"),
+        "language": i.get(
+            "language",
+            "c/cpp"
+            if str(i.get("file", "")).endswith((".c", ".cpp", ".h", ".hpp"))
+            else "rust",
+        ),
         "category": i.get("category", "error_handling"),
         "pattern": i.get("pattern", ""),
         "file": i.get("file", ""),
@@ -143,6 +153,7 @@ def _make_issue_id(base: str, lang: str) -> str:
 # 聚合与评分
 # ---------------------------
 
+
 def aggregate_issues(
     issues: List[Union[Issue, Dict]],
     scanned_root: Optional[str] = None,
@@ -153,7 +164,7 @@ def aggregate_issues(
     """
     # 归一化所有 issues
     normalized_items = [_normalize_issue(_as_dict(it)) for it in issues]
-    
+
     # 去重：通过 gid 去重（如果存在），否则通过 file:line:category:pattern 去重
     # 保留第一个出现的 issue（因为 load_analysis_results 已经保留了最新的）
     seen_items: Dict[str, Dict] = {}
@@ -165,10 +176,10 @@ def aggregate_issues(
         else:
             # 如果没有 gid，使用 file:line:category:pattern 作为唯一标识
             key = f"{item.get('file')}:{item.get('line')}:{item.get('category')}:{item.get('pattern')}"
-        
+
         if key not in seen_items:
             seen_items[key] = item
-    
+
     items = list(seen_items.values())
 
     summary: Dict = {
@@ -206,6 +217,7 @@ def aggregate_issues(
 # Markdown 渲染
 # ---------------------------
 
+
 def format_markdown_report(report_json: Dict) -> str:
     """
     将聚合后的 JSON 报告渲染为 Markdown。
@@ -226,7 +238,9 @@ def format_markdown_report(report_json: Dict) -> str:
     # 概览
     lines.append("## 统计概览")
     by_lang = s.get("by_language", {})
-    lines.append(f"- 按语言: c/cpp={by_lang.get('c/cpp', 0)}, rust={by_lang.get('rust', 0)}")
+    lines.append(
+        f"- 按语言: c/cpp={by_lang.get('c/cpp', 0)}, rust={by_lang.get('rust', 0)}"
+    )
     lines.append("- 按类别：")
     by_cat = s.get("by_category", {})
     for k in _CATEGORY_ORDER:
@@ -241,14 +255,18 @@ def format_markdown_report(report_json: Dict) -> str:
     # 详细问题
     lines.append("## 详细问题")
     for i, it in enumerate(issues, start=1):
-        lines.append(f"### [{i}] {it.get('file')}:{it.get('line')} ({it.get('language')}, {it.get('category')})")
+        lines.append(
+            f"### [{i}] {it.get('file')}:{it.get('line')} ({it.get('language')}, {it.get('category')})"
+        )
         lines.append(f"- 模式: {it.get('pattern')}")
         lines.append(f"- 证据: `{it.get('evidence')}`")
         lines.append(f"- 前置条件: {it.get('preconditions')}")
         lines.append(f"- 触发路径: {it.get('trigger_path')}")
         lines.append(f"- 后果: {it.get('consequences')}")
         lines.append(f"- 建议: {it.get('suggestions')}")
-        lines.append(f"- 置信度: {it.get('confidence')}, 严重性: {it.get('severity')}, 评分: {it.get('score')}")
+        lines.append(
+            f"- 置信度: {it.get('confidence')}, 严重性: {it.get('severity')}, 评分: {it.get('score')}"
+        )
         lines.append("")
 
     return "\n".join(lines)
@@ -259,7 +277,7 @@ def format_csv_report(report_json: Dict) -> str:
     将聚合后的 JSON 报告渲染为 CSV 格式。
     """
     issues: List[Dict] = report_json.get("issues", [])
-    
+
     # 定义 CSV 列
     fieldnames = [
         "id",
@@ -277,19 +295,19 @@ def format_csv_report(report_json: Dict) -> str:
         "severity",
         "score",
     ]
-    
+
     # 使用 StringIO 来构建 CSV 字符串
     output = io.StringIO()
-    writer = csv.DictWriter(output, fieldnames=fieldnames, extrasaction='ignore')
-    
+    writer = csv.DictWriter(output, fieldnames=fieldnames, extrasaction="ignore")
+
     # 写入表头
     writer.writeheader()
-    
+
     # 写入数据行
     for it in issues:
         row = {field: str(it.get(field, "")) for field in fieldnames}
         writer.writerow(row)
-    
+
     return output.getvalue()
 
 
@@ -303,26 +321,30 @@ def build_json_and_markdown(
     """
     一次性生成报告文本。
     如果 output_file 后缀为 .csv，则输出 CSV 格式；否则输出 Markdown 格式。
-    
+
     Args:
         issues: 问题列表
         scanned_root: 扫描根目录
         scanned_files: 扫描文件数
         meta: 可选元数据
         output_file: 输出文件名（可选），用于判断输出格式
-        
+
     Returns:
         报告文本（Markdown 或 CSV 格式）
     """
-    report = aggregate_issues(issues, scanned_root=scanned_root, scanned_files=scanned_files)
+    report = aggregate_issues(
+        issues, scanned_root=scanned_root, scanned_files=scanned_files
+    )
     if meta is not None:
         try:
-            report["meta"] = meta  # 注入可选审计信息（仅用于JSON时保留，为兼容未来需要）
+            report["meta"] = (
+                meta  # 注入可选审计信息（仅用于JSON时保留，为兼容未来需要）
+            )
         except Exception:
             pass
-    
+
     # 根据输出文件名后缀选择格式
-    if output_file and output_file.lower().endswith('.csv'):
+    if output_file and output_file.lower().endswith(".csv"):
         return format_csv_report(report)
     else:
         return format_markdown_report(report)
@@ -333,4 +355,4 @@ __all__ = [
     "format_markdown_report",
     "format_csv_report",
     "build_json_and_markdown",
-]
+]