aicomply-cli 0.1.0__py3-none-any.whl

aicomply/_version.py

@@ -0,0 +1,14 @@
+"""
+AIComply - Version Resolution
+Centraliza la versión del paquete usando importlib.metadata.
+Fallback a '0.1.0-dev' si el paquete no está instalado.
+"""
+
+try:
+    from importlib.metadata import version
+    try:
+        __version__ = version("aicomply-cli")
+    except Exception:
+        __version__ = version("aicomply")
+except Exception:
+    __version__ = "0.1.0-dev"

aicomply/classifier/assess.py

@@ -0,0 +1,220 @@
+"""
+AIComply - Interactive Risk Classifier (Decision Tree)
+Evalúa casos de uso y arquitecturas de IA mediante preguntas estructuradas
+para clasificar el sistema según el EU AI Act y el RGPD.
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from aicomply.schemas import RiskTier
+
+@dataclass
+class AssessmentResult:
+    """
+    Resultado estructurado de la evaluación guiada.
+    """
+    system_name: str
+    risk_tier: RiskTier
+    applicable_articles: List[str]
+    obligations: List[str]
+    compliance_deadline: str
+    rationale: str
+
+def run_interactive_assessment(console: Optional[Console] = None) -> AssessmentResult:
+    """
+    Ejecuta el cuestionario interactivo en la terminal.
+    """
+    console= console or Console()
+
+    console.print(
+        Panel(
+            "[bold cyan]Asistente de Clasificación Regulatoria - EU AI Act & RGPD[/bold cyan]\n"
+            "[dim]Responde a las siguientes preguntas técnicas y operativas sobre tu sistema.[/dim]",
+            border_style="cyan",
+            box=box.ROUNDED,
+        )
+    )
+
+    system_name = Prompt.ask("\n[bold]1. Nombre del sistema o proyecto[/bold]", default="AI-System")
+
+    # PASO 1: Ámbito del EU AI Act
+    is_ai = Confirm.ask(
+        "\n[bold]2. ¿El sistema infiere salidas (predicciones, contenido, decisiones) a partir de entradas usando modelos autónomos (ej. LLM, ML)?", default=True,
+    )
+    if not is_ai:
+        return AssessmentResult(
+            system_name=system_name,
+            risk_tier=RiskTier.MINIMAL_RISK,
+            applicable_articles=["Fuera de ámbito (Art. 3(1))"],
+            obligations=["No sujeto a las obligaciones del EU AI Act."],
+            compliance_deadline="N/A",
+            rationale="El software no cumple la definición de 'sistema de IA' según el Art. 3(1).",
+        )
+
+    # PASO 2: Prácticas Prohibidas (Art. 5) 
+    console.print("\n[bold yellow]── Evaluación de Prácticas Prohibidas (Art. 5) ──[/bold yellow]")
+    prohibited_checks = [
+        ("¿El sistema realiza puntuación social (social scoring) evaluando personas por su conducta?", "Art. 5(1)(c)"),
+        ("¿Utiliza técnicas subliminales o manipulativas para alterar el comportamiento causando daño?", "Art. 5(1)(a)"),
+        ("¿Infere emociones en lugares de trabajo o instituciones educativas (salvo fines médicos)?", "Art. 5(1)(f)"),
+        ("¿Realiza identificación biométrica remota en tiempo real en espacios públicos para fines policiales?", "Art. 5(1)(h)"),
+    ]
+
+    for question, ref in prohibited_checks:
+        if Confirm.ask(f"• {question}", default=False):
+            return AssessmentResult(
+                system_name=system_name,
+                risk_tier=RiskTier.PROHIBITED,
+                applicable_articles=["Art. 5", ref],
+                obligations=[
+                    "PROHIBICIÓN TOTAL DE DESPLIEGUE Y COMERCIALIZACIÓN.",
+                    "Retirada inmediata del mercado o cese de operaciones.",
+                    "Sanciones de hasta 35M€ o el 7% de la facturación global anual.",
+                ],
+                compliance_deadline="Aplicable desde febrero de 2025",
+                rationale=f"El sistema incurre en una práctica expresamente prohibida bajo el {ref}.",
+            )
+
+    # PASO 3: Sistemas de Alto Riesgo (Anexo I y Anexo III) 
+    console.print("\n[bold red]── Evaluación de Sistemas de Alto Riesgo (Art. 6 / Anexo III) ──[/bold red]")
+    high_risk_domains = [
+        "Biometría: categorización o identificación biométrica remota post-hoc.",
+        "Infraestructuras críticas: gestión de tráfico, redes de agua, gas, electricidad.",
+        "Educación y formación: admisión de alumnos o evaluación de estudiantes.",
+        "Empleo y RRHH: selección de personal, asignación de tareas o monitorización de rendimiento.",
+        "Servicios esenciales: evaluación de solvencia/scoring crediticio, acceso a ayudas públicas.",
+        "Fuerzas de seguridad, gestión de migración, asilo y control fronterizo.",
+        "Administración de justicia y procesos democráticos.",
+    ]
+    console.print("[dim]Dominios del Anexo III:[/dim]")
+    for domain in high_risk_domains:
+        console.print(f"  [dim]• {domain}[/dim]")
+
+    in_high_risk = Confirm.ask(
+        "\n¿El sistema se utiliza en alguno de estos dominios con impacto directo en derechos o seguridad?",
+        default=False,
+    )
+
+    if in_high_risk:
+        is_narrow_exception = Confirm.ask(
+            "¿El sistema realiza únicamente una tarea procedimental estrecha sin influir materialmente en la decisión final (Art. 6(3))?",
+            default=False,
+        )
+        if not is_narrow_exception:
+            return AssessmentResult(
+                system_name=system_name,
+                risk_tier=RiskTier.HIGH_RISK,
+                applicable_articles=["Art. 6", "Capítulo III", "Arts. 9-15", "Anexo III"],
+                obligations=[
+                    "Implantar un sistema continuo de gestión de riesgos (Art. 9).",
+                    "Gobernanza y mitigación de sesgos en datos de entrenamiento (Art. 10).",
+                    "Elaborar y mantener la documentación técnica (Art. 11 / Anexo IV).",
+                    "Habilitar registro automático de eventos (logging) continuo (Art. 12).",
+                    "Diseñar interfaces con supervisión humana efectiva y override (Art. 14).",
+                    "Asegurar robustez, precisión técnica y ciberseguridad (Art. 15).",
+                    "Registro obligatorio en la base de datos de la UE.",
+                ],
+                compliance_deadline="Agosto 2026 (Transparencia) / Diciembre 2027 (Alto Riesgo)",
+                rationale="El sistema opera dentro de los casos de uso críticos enumerados en el Anexo III.",
+            )
+
+    # PASO 4: Modelos de Propósito General (GPAI / LLMs) 
+    console.print("\n[bold cyan]── Modelos de IA de Propósito General (Capítulo V) ──[/bold cyan]")
+    is_gpai = Confirm.ask(
+        "¿Desarrollas, entrenas o afinas directamente un modelo base o GPAI (ej. LLM propio)?",
+        default=False,
+    )
+    if is_gpai:
+        return AssessmentResult(
+            system_name=system_name,
+            risk_tier=RiskTier.HIGH_RISK,
+            applicable_articles=["Capítulo V", "Arts. 51-55"],
+            obligations=[
+                "Documentación técnica del modelo y resumen público del entrenamiento.",
+                "Cumplimiento de la directiva sobre derechos de autor.",
+                "Si supera 10^25 FLOPs: Evaluación de riesgo sistémico y pruebas adversarias.",
+            ],
+            compliance_deadline="Agosto 2025",
+            rationale="Clasificado como Proveedor de Modelos de IA de Propósito General (GPAI).",
+        )
+
+    # PASO 5: Riesgo Limitado / Transparencia (Art. 50) 
+    console.print("\n[bold yellow]── Obligaciones de Transparencia (Art. 50) ──[/bold yellow]")
+    interacts_with_humans = Confirm.ask(
+        "¿El sistema interactúa directamente con usuarios (chatbots) o genera contenido sintético/deepfakes?",
+        default=True,
+    )
+    if interacts_with_humans:
+        return AssessmentResult(
+            system_name=system_name,
+            risk_tier=RiskTier.LIMITED_RISK,
+            applicable_articles=["Art. 50(1)", "Art. 50(2)", "RGPD Art. 13/14"],
+            obligations=[
+                "Notificar al usuario de forma clara e inmediata que interactúa con una IA.",
+                "Marcar el contenido sintético generado (audio, imagen, vídeo, texto) en formato legible por máquina.",
+                "Permitir el ejercicio de derechos RGPD sobre la información tratada.",
+            ],
+            compliance_deadline="Exigible desde agosto de 2026",
+            rationale="Sistemas que interactúan con personas o generan contenido sintético sujeto al Art. 50.",
+        )
+
+    # PASO 6: Riesgo Mínimo 
+    return AssessmentResult(
+        system_name=system_name,
+        risk_tier=RiskTier.MINIMAL_RISK,
+        applicable_articles=["Art. 95 (Códigos de conducta voluntarios)"],
+        obligations=[
+            "Sin obligaciones regulatorias vinculantes.",
+            "Recomendada adhesión voluntaria a códigos de buenas prácticas éticas.",
+        ],
+        compliance_deadline="Sin límite vinculante",
+        rationale="Sistemas sin riesgo significativo para derechos fundamentales o seguridad física.",
+    )
+
+
+def render_assessment_report(result: AssessmentResult, console: Optional[Console] = None) -> None:
+    """Presenta el dictamen de clasificación en la consola."""
+    console = console or Console()
+
+    tier_styles = {
+        RiskTier.PROHIBITED: ("PROHIBIDO (Art. 5)", "bold white on red"),
+        RiskTier.HIGH_RISK: ("ALTO RIESGO", "bold red"),
+        RiskTier.LIMITED_RISK: ("RIESGO LIMITADO", "bold yellow"),
+        RiskTier.MINIMAL_RISK: ("RIESGO MÍNIMO", "bold green"),
+    }
+    badge_label, badge_style = tier_styles[result.risk_tier]
+
+    table = Table(box=box.ROUNDED, expand=True)
+    table.add_column("Parámetro", style="bold cyan", width=24)
+    table.add_column("Detalle")
+
+    table.add_row("Sistema Auditado", f"[bold]{result.system_name}[/bold]")
+    table.add_row("Dictamen de Riesgo", f"[{badge_style}] {badge_label} [/{badge_style}]")
+    table.add_row("Artículos Clave", ", ".join(result.applicable_articles))
+    table.add_row("Entrada en Vigor", f"[bold yellow]{result.compliance_deadline}[/bold yellow]")
+    table.add_row("Fundamento Legal", result.rationale)
+
+    console.print()
+    console.print(
+        Panel(
+            table,
+            title="[bold blue]DICTAMEN DE CLASIFICACIÓN REGULATORIA (EU AI ACT)[/bold blue]",
+            border_style="bright_blue",
+            box=box.ROUNDED,
+        )
+    )
+
+    obs_table = Table(box=box.SIMPLE_HEAVY, expand=True)
+    obs_table.add_column("#", width=4, justify="center")
+    obs_table.add_column("Obligaciones Técnicas y Operativas Vinculantes")
+
+    for idx, ob in enumerate(result.obligations, start=1):
+        obs_table.add_row(str(idx), ob)
+
+    console.print(obs_table)

aicomply/classifier/risk_tier.py

@@ -0,0 +1,33 @@
+"""
+AIComply - Risk Tier Classifier
+Calcula la postura global de riesgo del repositorio basándose en la severidad y artículo de los hallazgos.
+"""
+
+from typing import List
+from aicomply.schemas import Finding, RiskTier
+
+
+# Jerarquía estricta de riesgo (de mayor a menor)
+TIER_HIERARCHY = [
+    RiskTier.PROHIBITED,
+    RiskTier.HIGH_RISK,
+    RiskTier.LIMITED_RISK,
+    RiskTier.MINIMAL_RISK,
+]
+
+
+def classify_overall_risk(findings: List[Finding]) -> RiskTier:
+    """
+    Determina el nivel de riesgo más restrictivo presente en el código escaneado.
+    Si no hay hallazgos, el sistema se cataloga como 'minimal_risk'.
+    """
+    if not findings:
+        return RiskTier.MINIMAL_RISK
+
+    present_tiers = {f.risk_tier for f in findings}
+    
+    for tier in TIER_HIERARCHY:
+        if tier in present_tiers:
+            return tier
+
+    return RiskTier.MINIMAL_RISK

aicomply/cli.py

@@ -0,0 +1,192 @@
+"""
+AIComply - CLI Entrypoint (Typer)
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Set
+import typer
+from rich.console import Console
+
+from aicomply.reporter.json_report import generate_json_report
+from aicomply.reporter.markdown_report import generate_markdown_report
+from aicomply.reporter.terminal import render_terminal_report
+from aicomply.reporter.sarif_reporter import generate_sarif_report
+from aicomply.rules.loader import RuleLoadError, load_rules_from_dir
+from aicomply.scanner.engine import ScanEngine
+
+from aicomply.classifier.assess import (
+    render_assessment_report,
+    run_interactive_assessment,
+)
+
+from aicomply.generator.annex_iv import AnnexIVGenerator
+
+
+app = typer.Typer(
+    name="aicomply",
+    help="CLI de cumplimiento técnico y análisis determinista del EU AI Act.",
+    add_completion=False,
+)
+console = Console()
+
+@app.callback()
+def main() -> None:
+    """CLI de cumplimiento técnico y análisis determinista del EU AI Act."""
+    pass
+
+class OutputFormat(str, Enum):
+    TERMINAL = "terminal"
+    JSON = "json"
+    MARKDOWN = "markdown"
+    SARIF = "sarif"
+
+def get_default_rules_dir() -> Path:
+    """
+    Obtiene la ruta base del catálogo de reglas
+    """
+    return Path(__file__).parent / "rules"
+
+
+@app.command(name="scan")
+def scan(
+    path: Path = typer.Argument(
+        ...,
+        help="Ruta al archivo o directorio a auditar.",
+        exists=True,
+        resolve_path=True,
+    ),
+    format: OutputFormat = typer.Option(
+        OutputFormat.TERMINAL,
+        "--format",
+        "-f",
+        help="Formato de salida del reporte (terminal, markdown, json).",
+    ),
+    articles: Optional[str] = typer.Option(
+        None,
+        "--articles",
+        "-a",
+        help="Filtrar por artículos separados por comas (ej. 5,12,13).",
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Ruta para guardar el reporte emitido en disco.",
+    ),
+    evidence: bool = typer.Option(
+        False,
+        "--evidence",
+        help="Incluir identificadores criptográficos SHA-256 por cada hallazgo.",
+    ),
+    rules_dir: Optional[Path] = typer.Option(
+        None,
+        "--rules-dir",
+        help="Directorio personalizado de reglas YAML.",
+    ),
+) -> None:
+    """Escanea el código fuente en busca de infracciones del EU AI Act."""
+    rules_path = rules_dir or get_default_rules_dir()
+
+    try:
+        catalog = load_rules_from_dir(rules_path)
+    except RuleLoadError as err:
+        console.print(f"[bold red]Error al cargar el catálogo de reglas:[/bold red] {err}")
+        raise typer.Exit(code=2)
+
+    target_articles: Optional[Set[str]] = None
+    if articles:
+        target_articles = {art.strip() for art in articles.split(",") if art.strip()}
+
+    engine = ScanEngine(catalog=catalog, target_articles=target_articles)
+
+    try:
+        report = engine.scan_path(path)
+    except Exception as exc:
+        console.print(f"[bold red]Error durante la ejecución del escaneo:[/bold red] {exc}")
+        raise typer.Exit(code=2)
+
+    # Gestión de salida según formato
+    if output:
+        if format == OutputFormat.JSON:
+            content = generate_json_report(report)
+        elif format == OutputFormat.SARIF:
+            content = generate_sarif_report(report)
+        else:
+            content = generate_markdown_report(report, include_evidence=evidence)
+            
+        output.write_text(content, encoding="utf-8")
+        console.print(f"[green]Reporte guardado exitosamente en:[/green] {output}")
+    else:
+        if format == OutputFormat.JSON:
+            typer.echo(generate_json_report(report))
+        elif format == OutputFormat.SARIF:
+            typer.echo(generate_sarif_report(report))
+        elif format == OutputFormat.MARKDOWN:
+            typer.echo(generate_markdown_report(report, include_evidence=evidence))
+        else:
+            render_terminal_report(report, include_evidence=evidence, console=console)
+
+    if report.summary.total_findings > 0:
+        raise typer.Exit(code=1)
+    raise typer.Exit(code=0)
+
+@app.command(name="assess")
+def assess() -> None:
+    """Asistente interactivo guiado para clasificar el nivel de riesgo de un caso de uso."""
+    result = run_interactive_assessment(console=console)
+    render_assessment_report(result, console=console)
+
+@app.command(name="docgen")
+def docgen(
+    path: Path = typer.Argument(
+        ...,
+        help="Ruta al repositorio del proyecto para auditar y documentar.",
+        exists=True,
+        resolve_path=True,
+    ),
+    system_name: str = typer.Option(
+        "AI-Production-System",
+        "--name",
+        "-n",
+        help="Nombre formal del sistema de IA para el dossier.",
+    ),
+    system_version: str = typer.Option(
+        "1.0.0",
+        "--version",
+        "-v",
+        help="Versión del sistema de IA.",
+    ),
+    output: Path = typer.Option(
+        Path("ANNEX_IV_TECHNICAL_DOCS.md"),
+        "--output",
+        "-o",
+        help="Ruta del archivo Markdown donde se guardará el expediente.",
+    ),
+    rules_dir: Optional[Path] = typer.Option(
+        None,
+        "--rules-dir",
+        help="Directorio personalizado de reglas YAML.",
+    ),
+) -> None:
+    """Genera el Dossier de Documentación Técnica formal exigido por el Anexo IV del EU AI Act."""
+    rules_path = rules_dir or get_default_rules_dir()
+
+    try:
+        catalog = load_rules_from_dir(rules_path)
+    except RuleLoadError as err:
+        console.print(f"[bold red]Error al cargar catálogo de reglas:[/bold red] {err}")
+        raise typer.Exit(code=2)
+
+    engine = ScanEngine(catalog=catalog)
+
+    with console.status("[bold cyan]Analizando arquitectura y generando expediente Anexo IV...[/bold cyan]"):
+        report = engine.scan_path(path)
+        generator = AnnexIVGenerator(report, system_name=system_name, version=system_version)
+        dossier_md = generator.generate_markdown_dossier()
+        output.write_text(dossier_md, encoding="utf-8")
+
+    console.print(f"[bold green][OK] Expediente Anexo IV generado con éxito:[/bold green] {output.resolve()}")
+
+if __name__ == "__main__":
+    app()

aicomply/config.py

@@ -0,0 +1,49 @@
+"""
+AIComply - Project Configuration Loader (.aicomply.yaml)
+Permite definir exclusiones de reglas, rutas ignoradas y umbrales de fallo en CI/CD.
+"""
+from pathlib import Path
+from typing import List, Optional, Set
+from pydantic import BaseModel, ConfigDict, Field
+import yaml
+
+class AIComplyConfig(BaseModel):
+    """Esquema de configuración de AIComply por repositorio"""
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    exclude_paths: List[str] = Field(
+        default_factory=lambda: ["tests/**", "fixtures/**", "docs/**"],
+        description="Rutas o patrones glob a ignorar durante el escaneo."
+    )
+    ignore_rules: List[str] = Field(
+        default_factory=list,
+        description="IDs de reglas desactivadas globalmente (ej. ['EUAIA-ART15-001'])."
+    )
+    enforce_risk_tier: Optional[str] = Field(
+        default=None,
+        description="Nivel de riesgo máximo tolerado antes de fallar (ej. 'high_risk')."
+    )
+    custom_rules_dir: Optional[str] = Field(
+        default=None,
+        description="Ruta relativa a reglas personalizadas adicionales"
+    )
+
+def load_project_config(target_dir: Path) -> AIComplyConfig:
+    """Busca y carga un archivo .aicomply.yaml o aicomply.yml en el directorio objetivo."""
+    candidate_files = [
+        target_dir / ".aicomply.yaml",
+        target_dir / ".aicomply.yml",
+        target_dir / "aicomply.yaml",
+    ]
+
+    for config_path in candidate_files:
+        if config_path.is_file():
+            try:
+                with open(config_path, "r", encoding="UTF-8") as f:
+                    raw_data = yaml.safe_load(f) or {}
+                return AIComplyConfig.model_validate(raw_data)
+            except Exception:
+                # Si el archivo está corrupto, continuar con la configuración por efecto
+                return AIComplyConfig()
+    
+    return AIComplyConfig()

aicomply/evidence/hasher.py

@@ -0,0 +1,47 @@
+"""
+AIComply - Cryptographic Evidence & Hasher
+Genera identificadores SHA-256 deterministas para hallazgos individuales
+y para el conjunto del reporte de auditoría.
+"""
+
+import hashlib
+import json
+from typing import Any, Dict, List
+from aicomply.schemas import CodeLocation, Finding
+
+
+def compute_finding_hash(
+    rule_id: str,
+    location: CodeLocation,
+    target: str,
+    snippet: str = ""
+) -> str:
+    """
+    Calcula un hash SHA-256 determinista para un hallazgo específico.
+    Normaliza rutas relativas y elimina variaciones de espacios en blanco.
+    """
+    normalized_snippet = snippet.replace("\r\n", "\n").replace("\r", "\n").strip()
+    canonical_payload = {
+        "rule_id": rule_id.strip().upper(),
+        "file_path": location.file_path.replace("\\", "/").strip(),
+        "start_line": location.start_line,
+        "end_line": location.end_line,
+        "target": target.strip(),
+        "snippet_normalized": normalized_snippet,
+    }
+    
+    encoded = json.dumps(canonical_payload, sort_keys=True).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def compute_scan_hash(findings: List[Finding]) -> str:
+    """
+    Calcula un hash SHA-256 consolidado para la ejecución completa del escaneo.
+    Se ordenan los IDs de los hallazgos para asegurar determinismo.
+    """
+    if not findings:
+        return hashlib.sha256(b"AIComply_EMPTY_CLEAN_SCAN").hexdigest()
+
+    sorted_hashes = sorted([f.id for f in findings])
+    consolidated_payload = "|".join(sorted_hashes).encode("utf-8")
+    return hashlib.sha256(consolidated_payload).hexdigest()