pyneat-cli 2.3.0__tar.gz → 2.4.0__tar.gz

{pyneat_cli-2.3.0/pyneat_cli.egg-info → pyneat_cli-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyneat-cli
-Version: 2.3.0
+Version: 2.4.0
 Summary: Neat Python AI Code Cleaner — removes AI-generated code artifacts, dead code, and security vulnerabilities
 License: GNU AGPL-3.0-or-later
 Keywords: ai,code-cleaner,python,linter,formatter,security,dead-code,refactoring,ast,auto-fix

{pyneat_cli-2.3.0 → pyneat_cli-2.4.0}/pyneat/__init__.py

@@ -85,7 +85,7 @@ from .rules.ai_bugs import AIBugRule
 from .rules.duplication import CodeDuplicationRule
 from .rules.naming import NamingInconsistencyRule
 
-__version__ = "2.3.0"
+__version__ = "2.4.0"
 
 __all__ = [
     # Core

{pyneat_cli-2.3.0 → pyneat_cli-2.4.0}/pyneat/cli.py

@@ -374,6 +374,9 @@ def clean(input_file: str, output: str, in_place: bool, verbose: bool,
         click.echo(f"[ERROR] Write failed: {str(e)}", err=True)
         return 1
 
+    # Hiển thị menu gợi ý tính năng khác
+    show_feature_menu("clean", f"{len(result.changes_made)} changes made")
+
     return 0
 
 
@@ -802,6 +805,7 @@ def check(target, severity, cvss, output, format, fail_on, skip_deps, verbose, u
 
     start_time = time.time()
     all_findings: List[SecurityFinding] = []
+    rust_findings: List[SecurityFinding] = []  # Rust scanner results
     total_files = 0
 
     # Scan code files
@@ -861,11 +865,78 @@ def check(target, severity, cvss, output, format, fail_on, skip_deps, verbose, u
 
     elapsed = time.time() - start_time
 
+    # --------------------------------------------------------------------------
+    # Merge Rust scanner results into all_findings
+    # --------------------------------------------------------------------------
+    # rust_results is a list of dicts from the Rust scanner, keyed by byte offset
+    # We need to convert them to SecurityFinding objects and add to all_findings
+    rust_findings: List[SecurityFinding] = []
+    for rust_finding in rust_results:
+        # Extract line number from byte offset (approximate: count newlines)
+        start_byte = rust_finding.get("start", 0)
+        end_byte = rust_finding.get("end", start_byte)
+
+        # Get file content for line calculation
+        try:
+            file_content = Path(str(target_path)).read_text(encoding="utf-8")
+        except Exception:
+            file_content = ""
+
+        # Convert byte offset to line number (1-indexed)
+        start_line = file_content[:start_byte].count('\n') + 1 if start_byte > 0 else 1
+        end_line = file_content[:end_byte].count('\n') + 1 if end_byte > 0 else start_line
+
+        # Parse severity (Rust uses "critical", Python uses "critical")
+        sev_str = rust_finding.get("severity", "info")
+        if sev_str == "critical":
+            sev = SecuritySeverity.CRITICAL
+        elif sev_str == "high":
+            sev = SecuritySeverity.HIGH
+        elif sev_str == "medium":
+            sev = SecuritySeverity.MEDIUM
+        elif sev_str == "low":
+            sev = SecuritySeverity.LOW
+        else:
+            sev = SecuritySeverity.INFO
+
+        # Build CVSS vector from score
+        cvss_score = rust_finding.get("cvss_score")
+        cvss_vector = f"CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H" if cvss_score else ""
+
+        rust_finding_obj = SecurityFinding(
+            rule_id=rust_finding.get("rule_id", "SEC-UNK"),
+            severity=sev,
+            confidence=0.95,  # Rust scanner has high confidence
+            cwe_id=rust_finding.get("cwe_id") or "",
+            owasp_id=rust_finding.get("owasp_id") or "",
+            cvss_score=float(cvss_score) if cvss_score else 0.0,
+            cvss_vector=cvss_vector,
+            file=str(target_path),
+            start_line=start_line,
+            end_line=end_line,
+            snippet=rust_finding.get("snippet", "")[:200],
+            problem=rust_finding.get("problem", "Security issue detected"),
+            fix_constraints=(rust_finding.get("fix_hint", "Fix this security issue"),),
+            do_not=("Do not ignore this finding.",),
+            verify=("Review and fix the code.",),
+            resources=(),
+            can_auto_fix=rust_finding.get("auto_fix_available", False),
+            auto_fix_available=rust_finding.get("auto_fix_available", False),
+        )
+        rust_findings.append(rust_finding_obj)
+
     # Aggregate by severity
     summary = {"critical": 0, "high": 0, "medium": 0, "low": 0, "info": 0, "dep": len(dep_findings)}
+
+    # Count Python findings
     for f in all_findings:
         summary[f.severity] = summary.get(f.severity, 0) + 1
 
+    # Count Rust findings (merge into all_findings)
+    all_findings.extend(rust_findings)
+    for f in rust_findings:
+        summary[f.severity] = summary.get(f.severity, 0) + 1
+
     if format == 'json':
         output_data = {
             "scan_version": "1.0.0",
@@ -963,6 +1034,9 @@ def check(target, severity, cvss, output, format, fail_on, skip_deps, verbose, u
             click.echo("")
             click.secho(f"  [FAIL] Found {sev_label} issue(s) - exiting with code 1", fg="red", bold=True)
 
+    # Hiển thị menu gợi ý tính năng khác
+    show_feature_menu("check", f"{sum(summary.values()) - summary.get('dep', 0)} issues found")
+
     return exit_code
 
 
@@ -1362,5 +1436,138 @@ def security_db(update, status, force):
     return 0
 
 
+# --------------------------------------------------------------------------
+# Interactive Feature Menu
+# --------------------------------------------------------------------------
+
+def show_feature_menu(last_command: str = "", context: str = "") -> None:
+    """Show interactive menu guiding users to other features.
+
+    Args:
+        last_command: The command that was just run (e.g., "check", "clean")
+        context: Optional context about what was scanned/analyzed
+    """
+    click.echo("")
+    click.echo("")
+    click.echo("  ┌─────────────────────────────────────────────────────────────┐")
+    click.echo("  │                  EXPLORE MORE FEATURES                     │")
+    click.echo("  └─────────────────────────────────────────────────────────────┘")
+    click.echo("")
+
+    # Gợi ý thông minh dựa trên command vừa chạy
+    suggestions = _get_menu_suggestions(last_command, context)
+    for key, (icon, title, desc, cmd) in suggestions.items():
+        click.echo(f"  {click.style(f'[{key}]', fg='cyan', bold=True)} {icon} {click.style(title, bold=True)}")
+        click.echo(f"      {desc}")
+        click.echo(f"      → {click.style(cmd, fg='green')}")
+        click.echo("")
+
+    click.echo(f"  {click.style('[q]', fg='yellow', bold=True)} Exit - return to terminal")
+    click.echo(f"  {click.style('[Enter]', fg='white', dim=True)} Skip this menu")
+    click.echo("")
+    click.echo("  ────────────────────────────────────────────────────────────")
+    click.echo("")
+
+    # Chờ input
+    try:
+        choice = input("  Select option (Enter to exit): ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        choice = 'q'
+
+    if choice in ('q', 'quit', 'exit', ''):
+        return
+
+    # Xử lý lựa chọn
+    _handle_menu_choice(choice, suggestions)
+
+
+def _get_menu_suggestions(last_command: str, context: str) -> Dict[str, tuple]:
+    """Get smart menu suggestions based on the last command.
+
+    Returns dict of {key: (icon, title, description, command_example)}
+    """
+    all_options = {
+        # Bảo mật & Quét lỗi
+        '1': ('🔒', 'Security Check',
+               'Quét lỗ hổng: SQL injection, path traversal, hardcoded secrets...',
+               'pyneat check file.py'),
+        '2': ('📖', 'Explain Rule',
+               'Nguyên nhân, cách fix, CWE/OWASP, verification steps...',
+               'pyneat explain SEC-001'),
+
+        # Làm sạch code
+        '3': ('🧹', 'Clean Code',
+               'Thêm type hints, xóa unused imports, số magic, debug prints...',
+               'pyneat clean file.py'),
+
+        # Báo cáo & CI/CD
+        '4': ('📊', 'Export Report (JSON/SARIF)',
+               'Tích hợp CI/CD: GitHub Code Scanning, GitLab SAST...',
+               'pyneat report . -f sarif -o security.sarif'),
+
+        # So sánh & Debug
+        '5': ('🔍', 'View Diff',
+               'So sánh code trước và sau khi làm sạch...',
+               'pyneat clean file.py --diff'),
+
+        # Cấu hình
+        '6': ('📋', 'View All Rules',
+               'Trạng thái bật/tắt, severity, mô tả ngắn của mỗi rule...',
+               'pyneat rules'),
+        '7': ('⚙️', 'Configure & Optimize',
+               'Bật/tắt rules, đặt ngưỡng, cấu hình package...',
+               'pyneat rules --verbose'),
+    }
+
+    # Smart suggestions dựa trên command vừa chạy
+    if last_command == 'check':
+        # Sau check bảo mật → clean + explain + report
+        ordered = ['3', '2', '4', '5']
+    elif last_command == 'clean':
+        # Sau clean → check bảo mật + diff + report
+        ordered = ['1', '5', '4', '7']
+    elif last_command == 'explain':
+        # Sau explain → check + clean + report
+        ordered = ['1', '3', '4', '5']
+    elif last_command == 'rules':
+        # Sau rules → check + clean
+        ordered = ['1', '3', '2', '4']
+    elif last_command == 'report':
+        # Sau report → check + clean
+        ordered = ['1', '3', '2', '7']
+    else:
+        ordered = ['1', '3', '2', '4']
+
+    return {k: all_options[k] for k in ordered if k in all_options}
+
+
+def _handle_menu_choice(choice: str, suggestions: Dict[str, tuple]) -> None:
+    """Handle user's menu choice."""
+    choice_map = {
+        '1': ('check', 'pyneat check file.py --help'),
+        '2': ('explain', 'pyneat explain --help'),
+        '3': ('clean', 'pyneat clean file.py --help'),
+        '4': ('report', 'pyneat report --help'),
+        '5': ('diff', 'pyneat clean file.py --diff --help'),
+        '6': ('rules', 'pyneat rules --help'),
+        '7': ('config', 'pyneat rules --help'),
+    }
+
+    if choice in choice_map:
+        feature, help_cmd = choice_map[choice]
+        click.echo("")
+        click.echo(f"  📌 To use '{feature}':")
+        click.echo(f"     {click.style(help_cmd, fg='cyan')}")
+        click.echo("")
+        click.echo(f"  💡 View all options:")
+        click.echo(f"     {click.style(f'pyneat {feature} --help', fg='green')}")
+    else:
+        click.echo("")
+        click.echo(f"  {click.style('[!]', fg='yellow', bold=True)} Invalid option.")
+        click.echo(f"     Press 'q' or Enter to exit.")
+        click.echo("")
+        click.echo("  📚 Docs: https://pyneat.dev/docs")
+
+
 if __name__ == '__main__':
     cli()

{pyneat_cli-2.3.0 → pyneat_cli-2.4.0}/pyneat/scanner/rust_scanner.py

@@ -28,6 +28,7 @@ class RustScanner:
     _available: bool = False
     _binary_path: Optional[str] = None
     _version: Optional[str] = None
+    _cargo_root: Optional[str] = None
 
     def __new__(cls) -> 'RustScanner':
         """Singleton pattern to ensure only one Rust scanner instance."""
@@ -47,16 +48,26 @@ class RustScanner:
 
     def _find_binary(self) -> None:
         """Find the Rust binary in common locations."""
+        # Resolve relative paths from the project root (where pyneat package lives)
+        # This ensures the scanner works regardless of current working directory
+        package_dir = Path(__file__).resolve().parent  # .../pyneat/scanner/
+        project_root = package_dir.parent.parent  # .../pyneat/ -> .../
+        pyneat_rs_dir = project_root / "pyneat-rs"
+
         possible_paths = [
-            # Current directory
-            Path("pyneat-rs/target/debug/pyneat-rs.exe"),
-            Path("pyneat-rs/target/debug/pyneat-rs"),
+            # Relative to project root (where pyneat-rs/ directory lives)
+            pyneat_rs_dir / "target" / "debug" / "pyneat-rs.exe",
+            pyneat_rs_dir / "target" / "debug" / "pyneat-rs",
+            pyneat_rs_dir / "target" / "release" / "pyneat-rs.exe",
+            pyneat_rs_dir / "target" / "release" / "pyneat-rs",
             # Installed via maturin
             Path(sys.prefix) / "bin" / "pyneat-rs",
             Path(sys.prefix) / "Scripts" / "pyneat-rs.exe",
             # User installation
             Path.home() / ".cargo" / "bin" / "pyneat-rs",
-            # Current working directory
+            # Legacy relative paths (for backward compatibility)
+            Path("pyneat-rs") / "target" / "debug" / "pyneat-rs.exe",
+            Path("pyneat-rs") / "target" / "debug" / "pyneat-rs",
             Path.cwd() / "pyneat-rs.exe",
             Path.cwd() / "pyneat-rs",
         ]
@@ -78,14 +89,25 @@ class RustScanner:
         except ImportError:
             pass
 
-        # Try cargo run
+        # Try cargo run (relative to project root)
+        if pyneat_rs_dir.exists():
+            cargo_toml = pyneat_rs_dir / "Cargo.toml"
+            if cargo_toml.exists():
+                self._available = True
+                self._binary_path = "<cargo>"
+                self._cargo_root = str(pyneat_rs_dir)
+                logger.info("Rust scanner available via cargo run")
+                return
+
+        # Fallback: try relative to cwd (legacy support)
         cargo_path = Path("pyneat-rs")
         if cargo_path.exists():
-            Cargo_toml = cargo_path / "Cargo.toml"
-            if Cargo_toml.exists():
+            cargo_toml = cargo_path / "Cargo.toml"
+            if cargo_toml.exists():
                 self._available = True
                 self._binary_path = "<cargo>"
-                logger.info("Rust scanner available via cargo run")
+                self._cargo_root = str(cargo_path.resolve())
+                logger.info("Rust scanner available via cargo run (cwd fallback)")
 
     def _validate_binary(self) -> None:
         """Validate that the Rust binary is working."""
@@ -93,7 +115,7 @@ class RustScanner:
             if self._binary_path == "<cargo>":
                 result = subprocess.run(
                     ["cargo", "run", "--", "--version"],
-                    cwd="pyneat-rs",
+                    cwd=self._cargo_root or "pyneat-rs",
                     capture_output=True,
                     text=True,
                     timeout=30
@@ -161,7 +183,7 @@ class RustScanner:
         result = subprocess.run(
             ["cargo", "run", "--", "scan", "-f", "json"],
             input=code,
-            cwd="pyneat-rs",
+            cwd=self._cargo_root or "pyneat-rs",
             capture_output=True,
             text=True,
             timeout=60

{pyneat_cli-2.3.0 → pyneat_cli-2.4.0/pyneat_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyneat-cli
-Version: 2.3.0
+Version: 2.4.0
 Summary: Neat Python AI Code Cleaner — removes AI-generated code artifacts, dead code, and security vulnerabilities
 License: GNU AGPL-3.0-or-later
 Keywords: ai,code-cleaner,python,linter,formatter,security,dead-code,refactoring,ast,auto-fix

{pyneat_cli-2.3.0 → pyneat_cli-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyneat-cli"
-version = "2.3.0"
+version = "2.4.0"
 description = "Neat Python AI Code Cleaner — removes AI-generated code artifacts, dead code, and security vulnerabilities"
 license = {text = "GNU AGPL-3.0-or-later"}
 readme = "README.md"