theus-cli-linux-arm64 1.2.1 → 1.3.0

package/vendor/higiene-motor/inspect_file.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Unified inspect: text, images, and document containers."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from av_meta import inspect_av
+from common import (
+    MAX_INPUT_BYTES,
+    ROUTER_ADVICE,
+    classify_finding_confidence,
+    emit_json,
+    eprint,
+    read_text_input,
+)
+from container_meta import inspect_container
+from format_dispatch import classify
+from image_meta import inspect_image
+from text_unicode import human_report, inspect_text
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("path", type=Path, help="File to inspect")
+    p.add_argument("--json", action="store_true")
+    p.add_argument("--aggressive", action="store_true", help="Text: flag confusables")
+    p.add_argument(
+        "--as",
+        dest="force_type",
+        choices=("text", "image", "container", "av", "auto"),
+        default="auto",
+    )
+    p.add_argument(
+        "--force-text",
+        action="store_true",
+        help="Scan as text even when the bytes look like a binary container",
+    )
+    args = p.parse_args()
+
+    if not args.path.is_file():
+        eprint(f"not a file: {args.path}")
+        return 2
+
+    if args.path.stat().st_size > MAX_INPUT_BYTES:
+        eprint(f"refusing input larger than {MAX_INPUT_BYTES} bytes: {args.path}")
+        return 2
+
+    kind = args.force_type if args.force_type != "auto" else classify(args.path)
+    file_label = str(args.path.resolve())
+
+    # "unknown" means the bytes match no supported format. Inspect does not
+    # mutate, so report it as-is; --as / --force-text override to text.
+    if kind == "unknown":
+        if args.force_type == "text" or args.force_text:
+            kind = "text"
+        else:
+            note = (
+                "unrecognized format; pass --as text|image|container|av or --force-text to override"
+            )
+            if args.json:
+                emit_json({"kind": "unknown", "path": file_label, "note": note})
+            else:
+                print(f"File: {file_label}")
+                print("Kind: unknown")
+                print(note)
+            return 0
+
+    if kind == "text":
+        text = read_text_input(
+            str(args.path),
+            allow_binary=args.force_text,
+            advice=ROUTER_ADVICE,
+        )
+        report = inspect_text(text, aggressive=args.aggressive)
+        if args.json:
+            emit_json({"kind": "text", "path": file_label, **report.to_dict()})
+        else:
+            print(f"File: {file_label}")
+            print("Kind: text")
+            print(human_report(report))
+        return 0 if report.suspicious_total == 0 else 1
+
+    if kind == "image":
+        report = inspect_image(args.path)
+        if args.json:
+            emit_json({"kind": "image", "path": file_label, **report.to_dict()})
+        else:
+            print(f"File: {file_label}")
+            print("Kind: image")
+            print(f"Path: {report.path}")
+            print(f"Format: {report.format}")
+            print(f"C2PA: {report.has_c2pa}")
+            print(f"AI metadata: {report.has_ai_metadata}")
+            for f in report.findings:
+                print(f"  - [{classify_finding_confidence(f)}] {f}")
+        return 0 if not (report.has_c2pa or report.has_ai_metadata) else 1
+
+    if kind == "av":
+        report = inspect_av(args.path)
+        if args.json:
+            emit_json({"kind": "av", "path": file_label, **report.to_dict()})
+        else:
+            print(f"File: {file_label}")
+            print("Kind: av")
+            print(f"Path: {report.path}")
+            print(f"Format: {report.format}")
+            print(f"C2PA: {report.has_c2pa}")
+            print(f"AI metadata: {report.has_ai_metadata}")
+            for f in report.findings:
+                print(f"  - [{classify_finding_confidence(f)}] {f}")
+        return 0 if not (report.has_c2pa or report.has_ai_metadata) else 1
+
+    report = inspect_container(args.path)
+    if args.json:
+        emit_json({"kind": "container", "path": file_label, **report.to_dict()})
+    else:
+        print(f"File: {file_label}")
+        print("Kind: container")
+        print(f"Path: {report.path}")
+        print(f"Format: {report.format}")
+        print(f"C2PA: {report.has_c2pa}")
+        print(f"AI metadata: {report.has_ai_metadata}")
+        for f in report.findings:
+            print(f"  - [{classify_finding_confidence(f)}] {f}")
+    # layer_a_total counts body-text carriers that clean will strip; the text
+    # branch above already exits non-zero for those, so containers match.
+    if report.has_c2pa or report.has_ai_metadata or report.layer_a_total:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/higiene-motor/inspect_image.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Inspect raster images (PNG/JPEG/WebP/AVIF/HEIC/BMP/GIF/TIFF) for C2PA and AI-related metadata."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from common import classify_finding_confidence, emit_json
+from image_meta import inspect_image
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("path", type=Path, help="Image path (PNG/JPEG/WebP/AVIF/HEIC/BMP/GIF/TIFF)")
+    p.add_argument("--json", action="store_true")
+    p.add_argument(
+        "--synthid-dir",
+        type=str,
+        default=None,
+        help="reverse-SynthID checkout root for optional pixel SynthID scoring",
+    )
+    args = p.parse_args()
+
+    if not args.path.is_file():
+        print(f"not a file: {args.path}", file=sys.stderr)
+        return 2
+
+    report = inspect_image(args.path, synthid_dir=args.synthid_dir)
+    if args.json:
+        emit_json(report.to_dict())
+    else:
+        print(f"Path: {report.path}")
+        print(f"Format: {report.format}")
+        print(f"C2PA: {report.has_c2pa}")
+        print(f"AI metadata: {report.has_ai_metadata}")
+        if report.findings:
+            print("Findings:")
+            for f in report.findings:
+                print(f"  - [{classify_finding_confidence(f)}] {f}")
+        ct = report.tools.get("c2patool") or {}
+        print(f"c2patool: {'yes' if ct.get('available') else 'no'}")
+        et = report.tools.get("exiftool") or {}
+        print(f"exiftool: {'yes' if et.get('available') else 'no'}")
+        if et.get("interesting_lines"):
+            print("exiftool highlights:")
+            for line in et["interesting_lines"][:20]:
+                print(f"  {line}")
+        if report.synthid and report.synthid.get("available"):
+            label = "yes" if report.synthid.get("is_watermarked") else "no"
+            print(
+                "SynthID score: "
+                f"confidence {report.synthid.get('confidence', 0.0):.3f} "
+                f"(watermarked: {label})"
+            )
+            if report.synthid.get("is_watermarked"):
+                print(
+                    "Hint: optional pixel removal is available via "
+                    "clean_image.py IMG --remove-pixel ctrlregen "
+                    "--ctrlregen-dir $NOAI_WATERMARK_DIR"
+                )
+        elif report.synthid and report.synthid.get("error"):
+            print(f"SynthID score: error: {report.synthid['error']}")
+
+    return 0 if not (report.has_c2pa or report.has_ai_metadata) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/vendor/higiene-motor/inspect_text.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Inspect text for invisible Unicode / space homoglyphs (Layer A) and optional stylometry."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+# Allow running as script from any cwd
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from common import emit_json, read_text_input
+from score_stylometry import print_human_stylometry_report, score_text_stylometry
+from text_unicode import human_report, inspect_text
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("path", nargs="?", default="-", help="Text file path, or - for stdin")
+    p.add_argument("--json", action="store_true", help="JSON report")
+    p.add_argument(
+        "--aggressive",
+        action="store_true",
+        help="Also flag Latin confusable / fullwidth lookalikes",
+    )
+    p.add_argument(
+        "--strip-emoji-glue",
+        action="store_true",
+        help="Paranoid: flag all load-bearing invisibles too (emoji glue, script joiners, flag tags, same-script fillers/selectors, orthographic Cf)",
+    )
+    p.add_argument(
+        "--stylometry",
+        action="store_true",
+        help="Also run zero-LLM statistical and stylometric AI cadence scoring",
+    )
+    p.add_argument(
+        "--threshold",
+        type=float,
+        default=0.65,
+        help="Score threshold for --stylometry exit code (default: 0.65)",
+    )
+    p.add_argument(
+        "--force-text",
+        action="store_true",
+        help="Scan even when the input looks like a binary container",
+    )
+    args = p.parse_args()
+
+    text = read_text_input(args.path, allow_binary=args.force_text)
+    if text is None:
+        return 2
+
+    report = inspect_text(
+        text,
+        aggressive=args.aggressive,
+        strip_emoji_glue=args.strip_emoji_glue,
+    )
+
+    stylometry_report = None
+    if args.stylometry:
+        input_label = "<stdin>" if args.path == "-" else args.path
+        stylometry_report = score_text_stylometry(text, path=input_label)
+
+    if args.json:
+        data = report.to_dict()
+        if stylometry_report:
+            data["stylometry"] = stylometry_report.to_dict()
+        emit_json(data)
+    else:
+        print(human_report(report))
+        if stylometry_report:
+            print("\n" + "=" * 50 + "\n")
+            print_human_stylometry_report(stylometry_report, explain=True)
+
+    exit_code = 0
+    if report.suspicious_total > 0:
+        exit_code = 1
+    if stylometry_report and stylometry_report.score >= args.threshold:
+        exit_code = 1
+
+    return exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())