codec-cortex 0.3.2__py3-none-any.whl

cortex/cli/commands/v2_roundtrip_bidir.py

@@ -0,0 +1,128 @@
+"""``cortex roundtrip-bidir`` — validate CORTEX ⇄ HCORTEX roundtrip.
+
+Canonical name: ``roundtrip-bidir`` (since v0.3.2).
+Deprecated alias: ``v2-roundtrip-bidir`` (still accepted).
+
+v2.3.1: Fixed Direction 2 logic — was using CORTEX as HCORTEX.
+Now properly tests both directions with correct format detection.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from ...core.errors import CortexError
+from ...v2.parser import parse_cortex_v2
+from ...v2.writer import write_cortex_v2
+from ...v2.view_renderer import render_hcortex
+from ...v2.hcortex_parser import parse_hcortex
+from ...v2.encoder import encode_cortex_from_ast
+from ...v2.equivalence import compare_ast_equivalent, compare_content_equivalent
+
+
+def run(args) -> int:
+    if not os.path.exists(args.input):
+        raise CortexError("E013_NOT_FOUND", f"file not found: {args.input}")
+
+    with open(args.input, "r", encoding="utf-8") as f:
+        text = f.read()
+
+    is_hcortex = "<!-- CODEC-CORTEX" in text and "internal_encoding: HCORTEX" in text
+    is_cortex = "<!-- CODEC-CORTEX" in text and "internal_encoding: CORTEX" in text
+
+    if is_cortex:
+        # Input is CORTEX
+        # Direction 1: CORTEX → HCORTEX → CORTEX (AST-equivalent)
+        print("=== Direction 1: CORTEX → HCORTEX → CORTEX ===")
+        rc1 = _roundtrip_cortex_to_hcortex_to_cortex(text)
+
+        # Direction 2: CORTEX → HCORTEX → CORTEX → HCORTEX (content-equivalent)
+        # We use the HCORTEX produced in Direction 1 as input
+        print("\n=== Direction 2: HCORTEX → CORTEX → HCORTEX ===")
+        # Generate HCORTEX from CORTEX first, then test HCORTEX → CORTEX → HCORTEX
+        doc = parse_cortex_v2(text)
+        hcortex_md, _ = render_hcortex(doc)
+        rc2 = _roundtrip_hcortex_to_cortex_to_hcortex(hcortex_md)
+        return rc1 or rc2
+
+    elif is_hcortex:
+        # Input is HCORTEX
+        # Direction 1: HCORTEX → CORTEX → HCORTEX (content-equivalent)
+        print("=== Direction 1: HCORTEX → CORTEX → HCORTEX ===")
+        rc1 = _roundtrip_hcortex_to_cortex_to_hcortex(text)
+
+        # Direction 2: HCORTEX → CORTEX → HCORTEX → CORTEX (AST-equivalent)
+        # Use the CORTEX reconstructed in Direction 1 as input
+        print("\n=== Direction 2: CORTEX → HCORTEX → CORTEX ===")
+        hdoc = parse_hcortex(text, strict=False)
+        doc, _ = encode_cortex_from_ast(hdoc)
+        cortex_text = write_cortex_v2(doc)
+        rc2 = _roundtrip_cortex_to_hcortex_to_cortex(cortex_text)
+        return rc1 or rc2
+    else:
+        print("ERROR: Could not detect format (no CODEC-CORTEX header)", file=sys.stderr)
+        return 1
+
+
+def _roundtrip_cortex_to_hcortex_to_cortex(cortex_text: str) -> int:
+    """CORTEX → HCORTEX → CORTEX: verify AST equivalence."""
+
+    cortex_text.encode("utf-8")
+    doc_orig = parse_cortex_v2(cortex_text)
+    sum(len(s.entries) for s in doc_orig.sections)
+
+    # CORTEX → HCORTEX
+    hcortex_md, diags = render_hcortex(doc_orig)
+    print(f"CORTEX → HCORTEX: {len(hcortex_md)} chars, {len(diags)} diags")
+
+    # HCORTEX → CORTEX
+    hdoc = parse_hcortex(hcortex_md, strict=False)
+    doc_reconstructed, enc_diags = encode_cortex_from_ast(hdoc)
+    recon_entry_count = sum(len(s.entries) for s in doc_reconstructed.sections)
+    print(f"HCORTEX → CORTEX: {len(doc_reconstructed.sections)} sections, {recon_entry_count} entries")
+    if enc_diags:
+        for d in enc_diags[:3]:
+            print(f"  [{d.severity}] {d.code}: {d.message}")
+
+    # Compare AST
+    ast_eq, diffs = compare_ast_equivalent(doc_orig, doc_reconstructed)
+    print(f"AST equivalent: {ast_eq} ({len(diffs)} diffs)")
+
+    if ast_eq:
+        print("✓ CORTEX → HCORTEX → CORTEX roundtrip: AST-equivalent")
+        return 0
+    else:
+        print("✗ Roundtrip NOT AST-equivalent")
+        for d in diffs[:5]:
+            print(f"  {d.kind} at {d.location}" + (f".{d.field}" if d.field else ""))
+        return 1
+
+
+def _roundtrip_hcortex_to_cortex_to_hcortex(hcortex_text: str) -> int:
+    """HCORTEX → CORTEX → HCORTEX: verify content equivalence."""
+
+    # HCORTEX → CORTEX
+    hdoc_orig = parse_hcortex(hcortex_text, strict=False)
+    doc, enc_diags = encode_cortex_from_ast(hdoc_orig)
+    print(f"HCORTEX → CORTEX: {len(doc.sections)} sections, {sum(len(s.entries) for s in doc.sections)} entries")
+    if enc_diags:
+        for d in enc_diags[:3]:
+            print(f"  [{d.severity}] {d.code}: {d.message}")
+
+    # CORTEX → HCORTEX
+    hcortex_regen, diags = render_hcortex(doc)
+    print(f"CORTEX → HCORTEX: {len(hcortex_regen)} chars")
+
+    # Compare content
+    content_eq, diffs = compare_content_equivalent(hcortex_text, hcortex_regen)
+    print(f"Content equivalent: {content_eq} ({len(diffs)} diffs)")
+
+    if content_eq:
+        print("✓ HCORTEX → CORTEX → HCORTEX roundtrip: content-equivalent")
+        return 0
+    else:
+        print("✗ Roundtrip NOT content-equivalent")
+        for d in diffs[:5]:
+            print(f"  {d.kind} at {d.location}")
+        return 1

cortex/cli/commands/v2_verify_view.py

@@ -0,0 +1,65 @@
+"""``cortex verify-view`` — validate VIEW coverage, reversibility, consistency.
+
+Canonical name: ``verify-view`` (since v0.3.2).
+Deprecated alias: ``v2-verify-view`` (still accepted).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+from ...core.errors import CortexError
+from ...v2.parser import parse_cortex_v2
+from ...v2.view import parse_view_entries_from_doc, calculate_view_coverage
+from ...v2.view_renderer import render_hcortex
+
+
+def run(args) -> int:
+    if not os.path.exists(args.input):
+        raise CortexError("E013_NOT_FOUND", f"file not found: {args.input}")
+
+    with open(args.input, "r", encoding="utf-8") as f:
+        text = f.read()
+
+    doc = parse_cortex_v2(text)
+    directives, view_diags = parse_view_entries_from_doc(doc)
+    coverage, uncovered = calculate_view_coverage(doc, directives)
+
+    # Render to get full diagnostics
+    _, render_diags = render_hcortex(doc)
+
+    all_diags = list(view_diags) + list(render_diags)
+    errors = [d for d in all_diags if d.severity == "error"]
+    warnings = [d for d in all_diags if d.severity == "warning"]
+
+    is_reversible = (coverage == 1.0) and (len(errors) == 0)
+
+    result = {
+        "view_count": len(directives),
+        "view_coverage_percent": int(coverage * 100),
+        "uncovered_count": len(uncovered),
+        "uncovered": uncovered[:20],
+        "errors": len(errors),
+        "warnings": len(warnings),
+        "reversible": is_reversible,
+        "diagnostics": [d.to_dict() for d in all_diags[:20]],
+    }
+
+    if args.format == "json":
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+    else:
+        print(f"VIEW directives: {len(directives)}")
+        print(f"VIEW coverage: {coverage:.1%}")
+        print(f"Uncovered entries: {len(uncovered)}")
+        print(f"Errors: {len(errors)}")
+        print(f"Warnings: {len(warnings)}")
+        print(f"Reversible: {is_reversible}")
+        for d in all_diags[:10]:
+            print(f"  [{d.severity}] {d.code}: {d.message}")
+
+    if errors:
+        return 1
+    if args.strict and warnings:
+        return 1
+    return 0

cortex/cli/commands/verify.py

@@ -0,0 +1,119 @@
+"""``cortex verify`` — validate a .cortex file and optionally roundtrip."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+
+from ...core.compare import compare_ast
+from ...core.document_kind import infer_document_kind
+from ...core.parser import parse_cortex
+from ...core.writer import write_cortex
+from ...core.validator import validate
+from ...hcortex import parse_hcortex_edit, render_hcortex_edit
+from ..commands import load_doc
+
+
+def run(args) -> int:
+    doc = load_doc(args.input)
+
+    # Apply explicit kind if provided (audit gap H-01/H-02)
+    kind = None
+    if getattr(args, "kind", None):
+        from ...core.document_kind import DocumentKind
+        kind = DocumentKind(kind=args.kind, source="cli")
+
+    strict = getattr(args, "strict", False)
+    diagnostics = validate(doc, strict=strict, kind=kind)
+    errors = [d for d in diagnostics if d.get("severity") == "error"]
+    warnings = [d for d in diagnostics if d.get("severity") == "warning"]
+
+    # Infer kind for display if not explicit
+    if kind is None:
+        kind = infer_document_kind(doc, args.input)
+
+    text_lines = []
+    text_lines.append(f"verifying: {args.input}")
+    text_lines.append(f"  kind:          {kind.kind} (inferred via {kind.source})")
+    text_lines.append(f"  sections:      {len(doc.sections)}")
+    text_lines.append(f"  sigils:        {len(doc.glossary.sigils)}")
+    total_entries = sum(len(s.entries) for s in doc.sections if s.id != "$0")
+    text_lines.append(f"  entries:       {total_entries}")
+    text_lines.append(f"  errors:        {len(errors)}")
+    text_lines.append(f"  warnings:      {len(warnings)}")
+    text_lines.append(f"  strict mode:   {strict}")
+    if errors:
+        text_lines.append("")
+        text_lines.append("errors:")
+        for e in errors:
+            text_lines.append(f"  [{e.get('code')}] {e.get('message')}")
+
+    roundtrip_ok = None
+    roundtrip_diffs = []
+    if args.roundtrip == "hcortex-edit":
+        md = render_hcortex_edit(doc, source=args.input)
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".hcortex.edit.md", delete=False, encoding="utf-8"
+        ) as tmp:
+            tmp.write(md)
+            tmp_path = tmp.name
+        try:
+            with open(tmp_path, "r", encoding="utf-8") as f:
+                md_text = f.read()
+            doc2 = parse_hcortex_edit(md_text, source=tmp_path)
+            cortex2 = write_cortex(doc2)
+            doc3 = parse_cortex(cortex2, path="<roundtrip>")
+            diff = compare_ast(doc, doc3)
+            roundtrip_ok = diff.equal
+            roundtrip_diffs = [d.to_dict() for d in diff.diffs]
+            if not roundtrip_ok:
+                text_lines.append(f"  roundtrip:     FAILED ({len(diff.diffs)} diff(s))")
+            else:
+                text_lines.append("  roundtrip:     OK (structural identity preserved)")
+        finally:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+    elif args.roundtrip == "cortex":
+        # Plain .cortex → .cortex roundtrip (no HCORTEX step)
+        text2 = write_cortex(doc)
+        doc3 = parse_cortex(text2, path="<roundtrip>")
+        diff = compare_ast(doc, doc3)
+        roundtrip_ok = diff.equal
+        roundtrip_diffs = [d.to_dict() for d in diff.diffs]
+        text_lines.append(
+            f"  roundtrip:     {'OK' if roundtrip_ok else 'FAILED'} "
+            f"({len(diff.diffs)} diff(s))"
+        )
+
+    payload = {
+        "text": "\n".join(text_lines),
+        "input": args.input,
+        "kind": kind.kind,
+        "sections": len(doc.sections),
+        "entries": total_entries,
+        "errors": errors,
+        "warnings": warnings,
+        "strict": strict,
+        "roundtrip": {
+            "mode": args.roundtrip,
+            "ok": roundtrip_ok,
+            "diffs": roundtrip_diffs,
+        } if args.roundtrip else None,
+    }
+
+    json_mode = getattr(args, "_json_mode", False)
+    if json_mode:
+        print(json.dumps(payload, indent=2, ensure_ascii=False, default=str))
+    else:
+        print(payload["text"])
+
+    if errors:
+        return 1
+    if strict and warnings:
+        return 1
+    if args.roundtrip and not roundtrip_ok:
+        return 2
+    return 0