Spaces:

Baida07
/

Terminal

Running

App Files Files Community

145

sync: 188 file da Baida98/AI@f043b5da (2026-08-26 06:38 UTC) [deploy-all]

#103

by Baida07 - opened 3 days ago

base: refs/heads/main

←

from: refs/pr/103

Discussion Files changed

+228

-52

Files changed (4) hide show

agents/file_conversion.py +105 -29
agents/unified_loop_tools.py +48 -22
tests/test_direct_file_conversion.py +39 -0
tests/test_file_conversion.py +36 -1

agents/file_conversion.py CHANGED Viewed

@@ -1,7 +1,7 @@
-"""Conversioni tabellari deterministiche per allegati inclusi nei goal dell'agente.
-Il modulo interpreta esclusivamente blocchi CSV esplicitamente allegati dal client. Non apre
-path arbitrari, non esegue istruzioni contenute nel file e non invoca LLM.
 """
 from __future__ import annotations
@@ -16,12 +16,21 @@ _ATTACHMENT_RE = re.compile(
     r"###\s*📎\s*(?P<name>[^\n`]+?\.csv)\s*\([^\n]*\)\s*```\s*(?P<body>[\s\S]*?)```",
     re.IGNORECASE,
 )
 _TARGET_RE = re.compile(
-    r"\b(?:chiamat[oa]|nome|denominat[oa]|come)\s+['`\"]?(?P<name>[\w.-]+\.json)\b",
     re.IGNORECASE,
 )
 _CONVERSION_RE = re.compile(
-    r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,180}\b(?:csv|json)\b",
     re.IGNORECASE,
 )
@@ -32,6 +41,8 @@ class CsvJsonConversion:
     target_name: str
     content: str
     row_count: int
 def _coerce_scalar(value: str) -> Any:
@@ -50,38 +61,103 @@ def _csv_body(raw_body: str) -> str:
     return "\n".join(lines).strip()
 def convert_csv_attachment_to_json(goal: str) -> CsvJsonConversion | None:
-    """Converte il primo allegato CSV esplicitamente serializzato in JSON.
-    Il ritorno è ``None`` quando il goal non richiede una conversione CSV→JSON completa,
-    così il resto del loop conserva il comportamento esistente.
     """
     if not _CONVERSION_RE.search(goal):
         return None
-    attachment = _ATTACHMENT_RE.search(goal)
-    if not attachment:
-        return None
     target = _TARGET_RE.search(goal)
     if not target:
         return None
-    csv_body = _csv_body(attachment.group("body"))
-    if not csv_body:
-        return None
-    try:
-        reader = csv.DictReader(io.StringIO(csv_body))
-        if not reader.fieldnames or any(not header or not header.strip() for header in reader.fieldnames):
-            return None
-        rows = [
-            {str(key).strip(): _coerce_scalar(value or "") for key, value in row.items()}
-            for row in reader
-        ]
-    except (csv.Error, UnicodeError):
-        return None
-    return CsvJsonConversion(
-        source_name=attachment.group("name").strip(),
-        target_name=target.group("name").strip(),
-        content=json.dumps(rows, ensure_ascii=False, indent=2) + "\n",
-        row_count=len(rows),
     )

+"""Conversioni tabellari deterministiche per dati CSV espliciti nel goal.
+Il modulo interpreta solo CSV allegati oppure richiesti con ``contenuto esatto:``.
+Non apre path arbitrari, non esegue istruzioni contenute nel file e non invoca LLM.
 """
 from __future__ import annotations
     r"###\s*📎\s*(?P<name>[^\n`]+?\.csv)\s*\([^\n]*\)\s*```\s*(?P<body>[\s\S]*?)```",
     re.IGNORECASE,
 )
+# Il target può essere espresso come "file chiamato foo.json" oppure come
+# "poi crea foo.json". Il gruppo è limitato a nomi semplici, quindi il parser
+# non accetta path traversal o istruzioni aggiuntive.
 _TARGET_RE = re.compile(
+    r"(?:\b(?:chiamat[oa]|nome|denominat[oa]|come)\s+|\b(?:crea|scrivi)\s+)"
+    r"['`\"]?(?P<name>[\w.-]+\.json)\b",
     re.IGNORECASE,
 )
 _CONVERSION_RE = re.compile(
+    r"\b(?:converti|trasforma|conversione|convert|transform)\b[\s\S]{0,240}\b(?:csv|json)\b",
+    re.IGNORECASE,
+)
+_INLINE_CSV_RE = re.compile(
+    r"\b(?:crea|scrivi)\s+(?P<name>[\w.-]+\.csv)\s+con\s+contenuto\s+esatto\s*:\s*"
+    r"(?P<body>[\s\S]*?)(?=\s*\.\s*(?:poi\s+)?(?:crea|scrivi)\s+[\w.-]+\.json\b|\Z)",
     re.IGNORECASE,
 )
     target_name: str
     content: str
     row_count: int
+    source_content: str
+    source_is_inline: bool = False
 def _coerce_scalar(value: str) -> Any:
     return "\n".join(lines).strip()
+def _parse_csv_rows(csv_body: str) -> list[dict[str, Any]] | None:
+    """Legge CSV senza tollerare header/colonne ambigue o righe tronche."""
+    try:
+        reader = csv.DictReader(io.StringIO(csv_body))
+        raw_headers = reader.fieldnames
+        if not raw_headers:
+            return None
+        headers = [str(header or "").strip() for header in raw_headers]
+        if any(not header for header in headers) or len(set(headers)) != len(headers):
+            return None
+        rows: list[dict[str, Any]] = []
+        for raw_row in reader:
+            # DictReader usa None per colonne in eccesso e per celle mancanti.
+            if None in raw_row or any(raw_row.get(header) is None for header in raw_headers):
+                return None
+            row = {
+                headers[index]: _coerce_scalar(raw_row[raw_headers[index]] or "")
+                for index in range(len(headers))
+            }
+            rows.append(row)
+        return rows
+    except (csv.Error, UnicodeError):
+        return None
+def validate_csv_json_equivalence(csv_content: str, json_content: str) -> tuple[bool, str]:
+    """Verifica che il JSON sia l’array esatto dei record CSV normalizzati.
+    La verifica è intenzionalmente stretta: stessa cardinalità, stesso ordine,
+    stesse chiavi e stessi valori dopo la coercizione deterministica del CSV.
+    """
+    expected = _parse_csv_rows(_csv_body(csv_content))
+    if expected is None:
+        return False, "CSV non valido o ambiguo"
+    try:
+        actual = json.loads(json_content)
+    except (TypeError, json.JSONDecodeError):
+        return False, "JSON non valido"
+    if not isinstance(actual, list):
+        return False, "il JSON deve essere un array"
+    if any(not isinstance(record, dict) for record in actual):
+        return False, "ogni record JSON deve essere un oggetto"
+    if actual != expected:
+        return False, "i record JSON non corrispondono esattamente al CSV"
+    return True, ""
+def _build_conversion(source_name: str, target_name: str, raw_body: str, *, source_is_inline: bool) -> CsvJsonConversion | None:
+    csv_body = _csv_body(raw_body)
+    rows = _parse_csv_rows(csv_body)
+    if rows is None:
+        return None
+    content = json.dumps(rows, ensure_ascii=False, indent=2) + "\n"
+    is_valid, _reason = validate_csv_json_equivalence(csv_body, content)
+    if not is_valid:
+        # Difesa di coerenza interna: una conversione diretta non può dichiararsi
+        # riuscita se il proprio serializzatore non supera il medesimo contratto.
+        return None
+    return CsvJsonConversion(
+        source_name=source_name.strip(),
+        target_name=target_name.strip(),
+        content=content,
+        row_count=len(rows),
+        source_content=csv_body + "\n",
+        source_is_inline=source_is_inline,
+    )
 def convert_csv_attachment_to_json(goal: str) -> CsvJsonConversion | None:
+    """Converte un CSV allegato o esplicitamente incluso nel goal in JSON.
+    Il ritorno è ``None`` quando il goal non definisce una conversione tabellare
+    completa: il resto del loop conserva quindi il comportamento esistente.
     """
     if not _CONVERSION_RE.search(goal):
         return None
     target = _TARGET_RE.search(goal)
     if not target:
         return None
+    inline = _INLINE_CSV_RE.search(goal)
+    if inline:
+        return _build_conversion(
+            inline.group("name"),
+            target.group("name"),
+            inline.group("body"),
+            source_is_inline=True,
+        )
+    attachment = _ATTACHMENT_RE.search(goal)
+    if not attachment:
+        return None
+    return _build_conversion(
+        attachment.group("name"),
+        target.group("name"),
+        attachment.group("body"),
+        source_is_inline=False,
     )

agents/unified_loop_tools.py CHANGED Viewed

@@ -25,7 +25,7 @@ _logger = logging.getLogger("agents.unified_loop_tools")
 # StepCallback centralizzato in unified_loop_types.py (P20-TD1 Fase 1)
 # S-FIX-IMPORT: aggiunto _maybe_await mancante che causava crash nel tool layer
 from agents.unified_loop_types import StepCallback, _maybe_await
-from agents.file_conversion import convert_csv_attachment_to_json
 class DirectToolsMixin:
     # ── Direct tool execution (S193) ─────────────────────────────────────────
     # Chiama TOOL_REGISTRY direttamente, senza smolagents, senza LLM per routing.
@@ -301,43 +301,69 @@ class DirectToolsMixin:
                 return None
             if not _gov_check("convert_csv_to_json", conversion.target_name):
                 return None
             try:
                 if on_step:
                     await _maybe_await(on_step({"action": "tool_start", "status": "running",
                         "title": "Conversione CSV in JSON",
-                        "explanation": f"Converto {conversion.source_name} in {conversion.target_name}…"}))
                 _t0 = asyncio.get_event_loop().time()
-                written = await asyncio.wait_for(
-                    TOOL_REGISTRY["write_file"]["_fn"](
-                        path=conversion.target_name,
-                        content=conversion.content,
-                    ),
-                    timeout=TOOL_TIMEOUT,
-                )
-                # Il registry restituisce `ok` per i tool filesystem; questa
-                # scorciatoia diretta aggira l'executor che normalmente adatta
-                # l'esito al contratto `success`.
-                if not written.get("ok"):
-                    return f"[convert_csv_to_json: errore — {str(written.get('error', 'scrittura non riuscita'))[:300]}]"
                 if on_step:
                     await _maybe_await(on_step({
-                        "action": "file_written",
-                        "status": "done",
-                        "path": conversion.target_name,
-                        "content": conversion.content,
                         "title": "File JSON creato",
-                        "explanation": f"Creato {conversion.target_name} con {conversion.row_count} record.",
                     }))
                 try:
                     from api.state import record_timing as _rtc
                     _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
                 except Exception as _e:
                     _logger.debug('[timing/record_timing] %s', _e)
                 return (
                     "[DIRECT_TERMINAL]\n"
-                    f"E2E_CONVERSION_OK: creato `{conversion.target_name}` da `{conversion.source_name}` "
-                    f"con {conversion.row_count} record.\n\n"
-                    f"Percorso workspace: `{conversion.target_name}`."
                 )
             except asyncio.TimeoutError:
                 return "[convert_csv_to_json: timeout]"

 # StepCallback centralizzato in unified_loop_types.py (P20-TD1 Fase 1)
 # S-FIX-IMPORT: aggiunto _maybe_await mancante che causava crash nel tool layer
 from agents.unified_loop_types import StepCallback, _maybe_await
+from agents.file_conversion import convert_csv_attachment_to_json, validate_csv_json_equivalence
 class DirectToolsMixin:
     # ── Direct tool execution (S193) ─────────────────────────────────────────
     # Chiama TOOL_REGISTRY direttamente, senza smolagents, senza LLM per routing.
                 return None
             if not _gov_check("convert_csv_to_json", conversion.target_name):
                 return None
+            # Il successo diretto è consentito solo dopo il confronto semantico
+            # record-per-record. Questo blocca cataloghi generici/allucinati prima
+            # che il loop possa dichiarare una conversione corretta.
+            is_valid, validation_error = validate_csv_json_equivalence(
+                conversion.source_content,
+                conversion.content,
+            )
+            if not is_valid:
+                return f"[convert_csv_to_json: validazione fallita — {validation_error}]"
+            async def _write(path: str, content: str) -> dict[str, Any]:
+                return await asyncio.wait_for(
+                    TOOL_REGISTRY["write_file"]["_fn"](path=path, content=content),
+                    timeout=TOOL_TIMEOUT,
+                )
             try:
                 if on_step:
                     await _maybe_await(on_step({"action": "tool_start", "status": "running",
                         "title": "Conversione CSV in JSON",
+                        "explanation": f"Converto {conversion.source_name} in {conversion.target_name} con verifica record…"}))
                 _t0 = asyncio.get_event_loop().time()
+                # Per il CSV inline il goal richiede esplicitamente entrambi gli
+                # artefatti. Gli allegati conservano il comportamento esistente:
+                # viene scritto soltanto il JSON, poiché la fonte è già disponibile.
+                written_paths: list[str] = []
+                if conversion.source_is_inline:
+                    source_written = await _write(conversion.source_name, conversion.source_content)
+                    if not source_written.get("ok"):
+                        return f"[convert_csv_to_json: errore sorgente — {str(source_written.get('error', 'scrittura non riuscita'))[:300]}]"
+                    written_paths.append(conversion.source_name)
+                    if on_step:
+                        await _maybe_await(on_step({
+                            "action": "file_written", "status": "done",
+                            "path": conversion.source_name, "content": conversion.source_content,
+                            "title": "File CSV creato",
+                            "explanation": f"Creato {conversion.source_name} con i dati sorgente verificati.",
+                        }))
+                target_written = await _write(conversion.target_name, conversion.content)
+                if not target_written.get("ok"):
+                    return f"[convert_csv_to_json: errore JSON — {str(target_written.get('error', 'scrittura non riuscita'))[:300]}]"
+                written_paths.append(conversion.target_name)
                 if on_step:
                     await _maybe_await(on_step({
+                        "action": "file_written", "status": "done",
+                        "path": conversion.target_name, "content": conversion.content,
                         "title": "File JSON creato",
+                        "explanation": f"Creato {conversion.target_name} con {conversion.row_count} record verificati.",
                     }))
                 try:
                     from api.state import record_timing as _rtc
                     _rtc("tool_call", (asyncio.get_event_loop().time() - _t0) * 1000)
                 except Exception as _e:
                     _logger.debug('[timing/record_timing] %s', _e)
+                paths = ", ".join(f"`{path}`" for path in written_paths)
                 return (
                     "[DIRECT_TERMINAL]\n"
+                    f"E2E_CONVERSION_OK: verificati {conversion.row_count} record tra `{conversion.source_name}` "
+                    f"e `{conversion.target_name}`.\n\n"
+                    f"File workspace salvati: {paths}."
                 )
             except asyncio.TimeoutError:
                 return "[convert_csv_to_json: timeout]"

tests/test_direct_file_conversion.py CHANGED Viewed

@@ -67,6 +67,45 @@ mese,richieste,successi
     assert any(event.get("action") == "file_written" for event in events)
 def test_direct_image_returns_renderable_terminal_markdown_without_llm():
     writes = {}
     _install_tool_stubs(writes)

     assert any(event.get("action") == "file_written" for event in events)
+def test_direct_inline_csv_conversion_writes_source_and_semantically_equivalent_json():
+    writes = {}
+    _install_tool_stubs(writes)
+    from agents.unified_loop_tools import DirectToolsMixin
+    class Harness(DirectToolsMixin):
+        def _max_tokens_for_goal(self, _goal):
+            return 4096
+    events = []
+    async def on_step(event):
+        events.append(event)
+    goal = """Esegui solo nel workspace VFS locale questa conversione deterministica.
+Crea capability_catalog.csv con contenuto esatto: id,name,active
+1,alpha,true
+2,beta,false
+. Poi crea capability_catalog.json con lo stesso catalogo come array JSON valido di due oggetti.
+Non usare rete, shell, servizi esterni o provider aggiuntivi."""
+    output, called, succeeded, errors = asyncio.run(
+        Harness()._run_direct_tools(goal, on_step=on_step)
+    )
+    assert output.startswith("[DIRECT_TERMINAL]\nE2E_CONVERSION_OK")
+    assert "verificati 2 record" in output
+    assert called == 1
+    assert succeeded == 1
+    assert errors == 0
+    assert writes["capability_catalog.csv"] == "id,name,active\n1,alpha,true\n2,beta,false\n"
+    assert writes["capability_catalog.json"] == (
+        '[\n  {\n    "id": 1,\n    "name": "alpha",\n    "active": "true"\n  },\n'
+        '  {\n    "id": 2,\n    "name": "beta",\n    "active": "false"\n  }\n]\n'
+    )
+    assert {event.get("path") for event in events if event.get("action") == "file_written"} == {
+        "capability_catalog.csv", "capability_catalog.json"
+    }
 def test_direct_image_returns_renderable_terminal_markdown_without_llm():
     writes = {}
     _install_tool_stubs(writes)

tests/test_file_conversion.py CHANGED Viewed

@@ -1,4 +1,4 @@
-from agents.file_conversion import convert_csv_attachment_to_json
 from agents.goal_verifier import GoalVerifier
@@ -33,6 +33,41 @@ def test_convert_csv_attachment_requires_explicit_json_target():
     assert convert_csv_attachment_to_json(_goal(target="output.txt")) is None
 def test_file_conversion_is_not_a_code_goal_even_with_e2e_marker():
     assert GoalVerifier.is_code_goal(_goal()) is False

+from agents.file_conversion import convert_csv_attachment_to_json, validate_csv_json_equivalence
 from agents.goal_verifier import GoalVerifier
     assert convert_csv_attachment_to_json(_goal(target="output.txt")) is None
+def test_inline_csv_conversion_preserves_the_exact_mobile_fixture():
+    goal = """Esegui solo nel workspace VFS locale questa conversione deterministica.
+Crea capability_catalog.csv con contenuto esatto: id,name,active
+1,alpha,true
+2,beta,false
+. Poi crea capability_catalog.json con lo stesso catalogo come array JSON valido di due oggetti.
+Non usare rete, shell, servizi esterni o provider aggiuntivi."""
+    result = convert_csv_attachment_to_json(goal)
+    assert result is not None
+    assert result.source_is_inline is True
+    assert result.source_name == "capability_catalog.csv"
+    assert result.target_name == "capability_catalog.json"
+    assert result.source_content == "id,name,active\n1,alpha,true\n2,beta,false\n"
+    assert result.row_count == 2
+    assert '"name": "alpha"' in result.content
+    assert '"name": "beta"' in result.content
+    assert '"CAP-001"' not in result.content
+    assert validate_csv_json_equivalence(result.source_content, result.content) == (True, "")
+def test_semantic_validator_rejects_a_generic_catalog_even_when_its_json_is_valid():
+    csv_content = "id,name,active\n1,alpha,true\n2,beta,false\n"
+    generic_catalog = """[
+      {"id": "CAP-001", "name": "Data Ingestion", "active": true},
+      {"id": "CAP-002", "name": "Data Cleaning", "active": false}
+    ]"""
+    is_valid, reason = validate_csv_json_equivalence(csv_content, generic_catalog)
+    assert is_valid is False
+    assert "non corrispondono" in reason
 def test_file_conversion_is_not_a_code_goal_even_with_e2e_marker():
     assert GoalVerifier.is_code_goal(_goal()) is False