wizard-central-toolkit 0.2.0__py3-none-any.whl

wiz_central_toolkit/jsonwiz/__main__.py

@@ -0,0 +1,21 @@
+"""Entry point for wiz dispatch."""
+import sys
+from .lib import cli as internal_cli
+
+# Wrap main() to accept argv (wiz dispatcher calls main(args))
+def main(argv=None):
+    # Save original sys.argv
+    old_argv = sys.argv
+    # Replace with provided argv (or empty list)
+    if argv is not None:
+        sys.argv = [sys.argv[0]] + list(argv)
+    try:
+        return internal_cli.main()
+    finally:
+        sys.argv = old_argv
+
+# Also expose for module-level access
+__all__ = ['main']
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/jsonwiz/cli.py

@@ -0,0 +1,4 @@
+"""jsonwiz CLI entry point; the implementation lives in lib/cli.py."""
+from .lib.cli import main
+
+__all__ = ["main"]

wiz_central_toolkit/jsonwiz/lib/__init__.py

@@ -0,0 +1 @@
+# wizard package init

wiz_central_toolkit/jsonwiz/lib/cli.py

@@ -0,0 +1,138 @@
+"""json-wizard CLI front-end."""
+import sys
+import json as jsonlib
+from pathlib import Path
+from .json_wizard import JsonWizard
+
+def _read_source(arg: str):
+    if arg == "-":
+        return sys.stdin.read()
+    p = Path(arg)
+    if not p.exists():
+        print(f"[FAIL] file not found: {arg}")
+        return None
+    return p.read_text()
+
+def main(argv=None) -> int:
+    args = sys.argv[1:] if argv is None else list(argv)
+    if not args or args[0] in ("-h", "--help", "help"):
+        print("JSON Wizard — standalone JSON doctor")
+        print("alias: jsonwiz")
+        print("usage: json_wizard <command> [args]")
+        print("  validate <file|->      check JSON validity with line/col on failure")
+        print("  pretty <file|->        pretty-print to stdout")
+        print("  compact <file|->       minify to one line")
+        print("  inspect <file|->       structural summary")
+        print("  keys <file|->          top-level keys")
+        print("  get <file|-> <path>    dotted-path value lookup (a.b.0.c)")
+        print("  diff <a> <b>           structural diff of two JSON docs")
+        print("  stats <file|->         type census: depths, counts")
+        print("  merge <a> <b>          deep merge (b wins) to stdout")
+        return 0
+
+    cmd = args[0]
+    wiz = JsonWizard()
+
+    if cmd in ("validate", "pretty", "compact", "inspect", "keys", "get", "stats"):
+        if len(args) < 2:
+            print("out of scope")
+            return 2
+        source = _read_source(args[1])
+        if source is None:
+            return 1
+
+        if cmd == "validate":
+            result = wiz.validate(source)
+            if result["valid"]:
+                print(f"[OK] valid JSON (root type: {result['type']})")
+                return 0
+            print(f"[FAIL] invalid JSON at line {result['line']}, col {result['col']}: {result['error']}")
+            return 1
+        if cmd == "pretty":
+            try:
+                print(wiz.pretty(source))
+                return 0
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+        if cmd == "compact":
+            try:
+                print(wiz.compact(source))
+                return 0
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+        if cmd == "inspect":
+            try:
+                print(jsonlib.dumps(wiz.inspect(source), indent=2))
+                return 0
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+        if cmd == "keys":
+            try:
+                keys = wiz.keys(source)
+                print("\n".join(keys) or "[FAIL] root is not an object")
+                return 0
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+        if cmd == "get":
+            if len(args) < 3:
+                print("out of scope - get requires a path")
+                return 2
+            try:
+                value = wiz.get(source, args[2])
+                if isinstance(value, (dict, list)):
+                    print(jsonlib.dumps(value, indent=2))
+                else:
+                    print(jsonlib.dumps(value))
+                return 0
+            except (KeyError, IndexError) as e:
+                print(f"[FAIL] path not found: {e}")
+                return 1
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+        if cmd == "stats":
+            try:
+                print(jsonlib.dumps(wiz.stats(source), indent=2))
+                return 0
+            except jsonlib.JSONDecodeError as e:
+                print(f"[FAIL] invalid JSON: {e}")
+                return 1
+
+    if cmd in ("diff", "merge"):
+        if len(args) < 3:
+            print(f"out of scope - {cmd} requires two files")
+            return 2
+        sa = _read_source(args[1])
+        sb = _read_source(args[2])
+        if sa is None or sb is None:
+            return 1
+        try:
+            if cmd == "diff":
+                changes = wiz.diff(sa, sb)
+                if not changes:
+                    print("[OK] identical structure and values")
+                    return 0
+                for kind, path, old, new in changes:
+                    loc = ".".join(str(p) for p in path)
+                    print(f"[DIFF] {kind} at {loc}")
+                    if kind == "changed":
+                        print(f"       a: {jsonlib.dumps(old)}")
+                        print(f"       b: {jsonlib.dumps(new)}")
+                    elif kind == "added":
+                        print(f"       b: {jsonlib.dumps(new)}")
+                    else:
+                        print(f"       a: {jsonlib.dumps(old)}")
+                return 1
+            if cmd == "merge":
+                print(jsonlib.dumps(wiz.merge(sa, sb), indent=2))
+                return 0
+        except (jsonlib.JSONDecodeError, TypeError) as e:
+            print(f"[FAIL] {e}")
+            return 1
+
+    print("out of scope")
+    return 2

wiz_central_toolkit/jsonwiz/lib/json_wizard.py

@@ -0,0 +1,133 @@
+"""json-wizard core: standalone, importable JSON doctor. Validate, pretty-print, inspect."""
+import json
+from pathlib import Path
+
+class JsonWizard:
+    """JSON validation and inspection engine. Never modifies the input file."""
+
+    def validate(self, source: str) -> dict:
+        try:
+            parsed = json.loads(source)
+        except json.JSONDecodeError as e:
+            return {"valid": False, "error": str(e), "line": e.lineno, "col": e.colno}
+        return {"valid": True, "type": type(parsed).__name__}
+
+    def pretty(self, source: str, indent: int = 2) -> str:
+        return json.dumps(json.loads(source), indent=indent)
+
+    def inspect(self, source: str) -> dict:
+        parsed = json.loads(source)
+
+        def summarize(obj):
+            if isinstance(obj, dict):
+                return {k: summarize(v) for k, v in obj.items()}
+            if isinstance(obj, list):
+                return {"_list_len": len(obj)}
+            return obj
+
+        return summarize(parsed)
+
+    def keys(self, source: str) -> list:
+        parsed = json.loads(source)
+        if isinstance(parsed, dict):
+            return list(parsed.keys())
+        return []
+
+    def compact(self, source: str) -> str:
+        return json.dumps(json.loads(source), separators=(",", ":"))
+
+    def get(self, source: str, path: str):
+        """Dotted-path lookup. Numeric segments index arrays."""
+        node = json.loads(source)
+        for seg in path.split("."):
+            if isinstance(node, dict) and seg in node:
+                node = node[seg]
+            elif isinstance(node, list) and seg.lstrip("-").isdigit():
+                idx = int(seg)
+                if -len(node) <= idx < len(node):
+                    node = node[idx]
+                else:
+                    raise IndexError(f"index {seg} out of range")
+            else:
+                raise KeyError(f"path segment not found: {seg}")
+        return node
+
+    def diff(self, source_a: str, source_b: str) -> list:
+        """Structural diff: list of paths where the docs differ."""
+        a = json.loads(source_a)
+        b = json.loads(source_b)
+        changes = []
+
+        def walk(x, y, path):
+            if isinstance(x, dict) and isinstance(y, dict):
+                for k in sorted(set(x) | set(y)):
+                    if k not in x:
+                        changes.append(("added", path + [k], None, y[k]))
+                    elif k not in y:
+                        changes.append(("removed", path + [k], x[k], None))
+                    else:
+                        walk(x[k], y[k], path + [k])
+            elif isinstance(x, list) and isinstance(y, list):
+                for i in range(max(len(x), len(y))):
+                    if i >= len(x):
+                        changes.append(("added", path + [i], None, y[i]))
+                    elif i >= len(y):
+                        changes.append(("removed", path + [i], x[i], None))
+                    else:
+                        walk(x[i], y[i], path + [i])
+            elif x != y:
+                changes.append(("changed", path, x, y))
+
+        walk(a, b, [])
+        return changes
+
+    def stats(self, source: str) -> dict:
+        parsed = json.loads(source)
+        counts = {"dict": 0, "list": 0, "str": 0, "number": 0, "bool": 0, "null": 0}
+
+        def walk(obj, depth):
+            max_d = depth
+            if isinstance(obj, dict):
+                counts["dict"] += 1
+                for v in obj.values():
+                    max_d = max(max_d, walk(v, depth + 1))
+            elif isinstance(obj, list):
+                counts["list"] += 1
+                for v in obj:
+                    max_d = max(max_d, walk(v, depth + 1))
+            elif isinstance(obj, str):
+                counts["str"] += 1
+            elif isinstance(obj, bool):
+                counts["bool"] += 1
+            elif obj is None:
+                counts["null"] += 1
+            else:
+                counts["number"] += 1
+            return max_d
+
+        depth = walk(parsed, 0)
+        root_keys = len(parsed) if isinstance(parsed, dict) else None
+        return {
+            "root_type": type(parsed).__name__,
+            "root_keys": root_keys,
+            "max_depth": depth,
+            **counts,
+        }
+
+    def merge(self, source_a: str, source_b: str) -> dict:
+        """Deep merge: b wins on scalars, dicts merge recursively, lists replace."""
+        a = json.loads(source_a)
+        b = json.loads(source_b)
+        if not isinstance(a, dict) or not isinstance(b, dict):
+            raise TypeError("merge requires two root objects")
+        return self._deep_merge(a, b)
+
+    @staticmethod
+    def _deep_merge(a: dict, b: dict) -> dict:
+        out = dict(a)
+        for k, v in b.items():
+            if isinstance(v, dict) and isinstance(out.get(k), dict):
+                out[k] = JsonWizard._deep_merge(out[k], v)
+            else:
+                out[k] = v
+        return out

wiz_central_toolkit/pythonwiz/__main__.py

@@ -0,0 +1,21 @@
+"""Entry point for wiz dispatch."""
+import sys
+from .lib import cli as internal_cli
+
+# Wrap main() to accept argv (wiz dispatcher calls main(args))
+def main(argv=None):
+    # Save original sys.argv
+    old_argv = sys.argv
+    # Replace with provided argv (or empty list)
+    if argv is not None:
+        sys.argv = [sys.argv[0]] + list(argv)
+    try:
+        return internal_cli.main()
+    finally:
+        sys.argv = old_argv
+
+# Also expose for module-level access
+__all__ = ['main']
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/pythonwiz/lib/__init__.py

@@ -0,0 +1 @@
+# wizard package init

wiz_central_toolkit/pythonwiz/lib/cli.py

@@ -0,0 +1,247 @@
+"""python-wizard CLI front-end."""
+import sys
+import json
+from pathlib import Path
+from .python_wizard import PythonWizard
+
+HELP = """Python Wizard — standalone Python doctor (parse only, never executes)
+alias: pythonwiz
+usage: python_wizard <command> <target>
+
+  check <file|dir>     syntax validation (the fleet gate)
+  entry <file>         shebang + interpreter validation
+  outline <file>       symbol map: classes/functions + line numbers
+  imports <file>       stdlib/third_party/local/relative inventory
+  todos <file>         TODO/FIXME/XXX/BUG/HACK markers
+  deadcode <file>      defined-but-unreferenced candidates (heuristic)
+  complexity <file>    branch count per function, hottest first
+  loc <file>           lines/code/blank/comment/function stats
+  docstrings <file>    defs missing docstrings
+  explain <file>       syntax error with source lines shown
+  shebangs <dir>       sweep tree, validate every shebang
+  deps <file>          third-party imports as requirements list
+  callmap <file>       who-calls-whom per function
+  longest <file>       functions ranked by length
+  excepts <file>       bare/broad except handlers + swallows
+  secrets <file>       hardcoded credential patterns (values redacted;
+                       --show-secrets prints them — a deliberate opt-in)
+  mainguard <file>     has __main__ guard?
+  globals <file>       module-level mutable state audit
+  magic <file>         suspicious numeric literals
+  compare <a> <b>      structural symbol diff of two files
+  tree <dir>           directory aggregate summary
+  score <file>         composite health score 0-100"""
+
+def _file(arg: str):
+    p = Path(arg)
+    if not p.exists():
+        print(f"[FAIL] not found: {arg}")
+        return None
+    return p
+
+def main() -> int:
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help", "help"):
+        print(HELP)
+        return 0
+
+    cmd = args[0]
+    wiz = PythonWizard()
+
+    # ---- existing ----
+    if cmd == "check":
+        if len(args) < 2:
+            print("out of scope")
+            return 2
+        target = _file(args[1])
+        if target is None:
+            return 1
+        if target.is_dir():
+            results = wiz.check_dir(target)
+            if not results:
+                print(f"[FAIL] no .py files found under {target}")
+                return 1
+            bad = 0
+            for r in results:
+                if r["valid"]:
+                    print(f"[OK]   {r['file']}")
+                else:
+                    bad += 1
+                    print(f"[FAIL] {r['file']} line {r.get('line')}, col {r.get('col')}: {r['error']}")
+            print(f"\n{len(results) - bad}/{len(results)} valid, {bad} invalid")
+            return 1 if bad else 0
+        r = wiz.check_file(target)
+        print(f"[OK] {target}" if r["valid"]
+              else f"[FAIL] {target} line {r['line']}, col {r['col']}: {r['error']}")
+        return 0 if r["valid"] else 1
+
+    if cmd == "entry":
+        if len(args) < 2:
+            print("out of scope")
+            return 2
+        r = wiz.check_entry(_file(args[1]))
+        print(f"[OK] shebang valid: {r.get('interpreter')}" if r["valid"]
+              else f"[FAIL] {r['error']}")
+        return 0 if r["valid"] else 1
+
+    # ---- two-file commands ----
+    if cmd == "compare":
+        if len(args) < 3:
+            print("out of scope")
+            return 2
+        a, b = _file(args[1]), _file(args[2])
+        if a is None or b is None:
+            return 1
+        r = wiz.compare_symbols(a, b)
+        if "error" in r:
+            print(f"[FAIL] unparseable file: {r['error']}")
+            return 1
+        if not r["only_a"] and not r["only_b"]:
+            print("[OK] identical symbol sets")
+            return 0
+        for kind, n in r["only_a"]:
+            print(f"only in {args[1]}: {kind} {n}")
+        for kind, n in r["only_b"]:
+            print(f"only in {args[2]}: {kind} {n}")
+        print(f"[DIFF] {len(r['only_a'])} only-a, {len(r['only_b'])} only-b, "
+              f"{len(r['common'])} common")
+        return 1
+
+    # ---- dir commands ----
+    if cmd in ("shebangs", "tree"):
+        if len(args) < 2:
+            print("out of scope")
+            return 2
+        d = Path(args[1])
+        if not d.is_dir():
+            print(f"[FAIL] not a directory: {d}")
+            return 1
+        if cmd == "shebangs":
+            results = wiz.shebangs_dir(d)
+            if not results:
+                print("[FAIL] no shebang-bearing .py files found")
+                return 1
+            bad = 0
+            for p, interp, ok in results:
+                if ok:
+                    print(f"[OK]   {p} -> {interp}")
+                else:
+                    bad += 1
+                    print(f"[FAIL] {p} -> {interp}")
+            print(f"\n{len(results) - bad}/{len(results)} valid, {bad} invalid")
+            return 1 if bad else 0
+        print(json.dumps(wiz.tree_summary(d), indent=2))
+        return 0
+
+    # ---- single-file commands ----
+    single = ("outline", "imports", "todos", "deadcode", "complexity", "loc",
+              "docstrings", "explain", "deps", "callmap", "longest",
+              "excepts", "secrets", "mainguard", "globals", "magic", "score")
+    if cmd in single:
+        show_secrets = False
+        if cmd == "secrets" and "--show-secrets" in args[1:]:
+            # Deliberate opt-in (AVS ruling, 2026-11-09): the flag is
+            # stripped wherever it sits so the file stays at args[1].
+            show_secrets = True
+            args = [args[0]] + [a for a in args[1:] if a != "--show-secrets"]
+        if len(args) < 2:
+            print("out of scope")
+            return 2
+        p = _file(args[1])
+        if p is None:
+            return 1
+
+        if cmd == "outline":
+            rows = wiz.outline(p)
+            print("\n".join(f"L{ln:4d} {kind:5s} {name}"
+                            for kind, name, ln in rows) or "[FAIL] no symbols")
+            return 0
+        if cmd == "imports":
+            print(json.dumps(wiz.imports_of(p), indent=2))
+            return 0
+        if cmd == "todos":
+            rows = wiz.todos_of(p)
+            print("\n".join(f"L{ln:4d} [{tag}] {msg}" for ln, tag, msg in rows)
+                  or "[OK] no markers found")
+            return 1 if rows else 0
+        if cmd == "deadcode":
+            rows = wiz.deadcode(p)
+            print("[hint] candidates only — attribute-called methods may false-positive")
+            print("\n".join(f"L{ln:4d} {name}" for name, ln in rows)
+                  or "[OK] no dead code candidates")
+            return 1 if rows else 0
+        if cmd == "complexity":
+            print("\n".join(f"{c:3d} branches  L{ln:4d} {name}"
+                            for name, ln, c in wiz.complexity(p))
+                  or "[FAIL] no functions")
+            return 0
+        if cmd == "loc":
+            print(json.dumps(wiz.loc_stats(p), indent=2))
+            return 0
+        if cmd == "docstrings":
+            rows = wiz.docstring_report(p)
+            print("\n".join(f"L{ln:4d} {name} — no docstring" for ln, name in rows)
+                  or "[OK] all documented")
+            return 1 if rows else 0
+        if cmd == "explain":
+            r = wiz.explain_error(p)
+            if r["valid"]:
+                print(f"[OK] {p} parses clean — nothing to explain")
+                return 0
+            print(f"[FAIL] {p} line {r['line']}, col {r['col']}: {r['error']}")
+            print("\n".join(r["context"]))
+            return 1
+        if cmd == "deps":
+            deps = wiz.deps(p)
+            print("\n".join(deps) or "[OK] stdlib-only — zero third-party deps")
+            return 0
+        if cmd == "callmap":
+            print(json.dumps(wiz.call_map(p), indent=2))
+            return 0
+        if cmd == "longest":
+            print("\n".join(f"{length:4d} lines  L{ln:4d} {name}"
+                            for name, ln, length in wiz.longest_functions(p))
+                  or "[FAIL] no functions")
+            return 0
+        if cmd == "excepts":
+            rows = wiz.bare_excepts(p)
+            print("\n".join(f"L{ln:4d} {kind} except{' + swallow' if swallow else ''}"
+                            for ln, kind, swallow in rows)
+                  or "[OK] no bare/broad excepts")
+            return 1 if rows else 0
+        if cmd == "secrets":
+            rows = wiz.secrets_scan(p, show_secrets=show_secrets)
+            if show_secrets:
+                # Exactly the pre-ruling full-line behaviour.
+                print("\n".join(f"L{ln:4d} {line}" for ln, _kind, line in rows)
+                      or "[OK] no credential patterns found")
+            else:
+                print("\n".join(f"L{ln:4d} [{kind}] {line}"
+                                for ln, kind, line in rows)
+                      or "[OK] no credential patterns found")
+            return 1 if rows else 0
+        if cmd == "mainguard":
+            r = wiz.main_guard(p)
+            print("[OK] __main__ guard present" if r["has_main_guard"]
+                  else "[FAIL] no __main__ guard")
+            return 0 if r["has_main_guard"] else 1
+        if cmd == "globals":
+            rows = wiz.globals_audit(p)
+            print("\n".join(f"L{ln:4d} {names} ({mut})" for ln, names, mut in rows)
+                  or "[OK] no module-level assignments")
+            mutables = [r for r in rows if r[2] == "mutable"]
+            return 1 if mutables else 0
+        if cmd == "magic":
+            rows = wiz.magic_numbers(p)
+            print("\n".join(f"L{ln:4d} {val}" for ln, val in rows)
+                  or "[OK] no suspicious literals")
+            return 0
+        if cmd == "score":
+            print(json.dumps(wiz.health_score(p), indent=2))
+            return 0
+
+    print("out of scope")
+    return 2
+
+if __name__ == "__main__":
+    sys.exit(main())