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

wiz_central_toolkit/diffwiz/lib/diff_wizard.py

@@ -0,0 +1,89 @@
+"""diff-wizard core: standalone change-truth doctor. Unified file diffs, filtered tree diffs."""
+import difflib
+from pathlib import Path
+
+SKIP_DIRS = {".venv", ".git", "__pycache__", ".bootstrap", "node_modules"}
+
+class DiffWizard:
+    """Read-only truth engine. Never modifies either side of a comparison."""
+
+    def diff_files(self, path_a: Path, path_b: Path) -> str:
+        a_lines = path_a.read_text(errors="replace").splitlines(keepends=True)
+        b_lines = path_b.read_text(errors="replace").splitlines(keepends=True)
+        return "".join(difflib.unified_diff(
+            a_lines, b_lines,
+            fromfile=str(path_a), tofile=str(path_b),
+        ))
+
+    def diff_dirs(self, dir_a: Path, dir_b: Path) -> dict:
+        files_a = {
+            str(p.relative_to(dir_a)): p
+            for p in dir_a.rglob("*")
+            if p.is_file() and not any(part in SKIP_DIRS for part in p.parts)
+        }
+        files_b = {
+            str(p.relative_to(dir_b)): p
+            for p in dir_b.rglob("*")
+            if p.is_file() and not any(part in SKIP_DIRS for part in p.parts)
+        }
+        only_a = sorted(set(files_a) - set(files_b))
+        only_b = sorted(set(files_b) - set(files_a))
+        common = sorted(set(files_a) & set(files_b))
+        differing = [rel for rel in common
+                     if files_a[rel].read_bytes() != files_b[rel].read_bytes()]
+        return {"only_a": only_a, "only_b": only_b, "differing": differing}
+
+    def diff_files_context(self, path_a: Path, path_b: Path, context: int = 3) -> str:
+        a_lines = path_a.read_text(errors="replace").splitlines(keepends=True)
+        b_lines = path_b.read_text(errors="replace").splitlines(keepends=True)
+        return "".join(difflib.unified_diff(
+            a_lines, b_lines,
+            fromfile=str(path_a), tofile=str(path_b),
+            n=context,
+        ))
+
+    def diff_summary(self, source_a: Path, source_b: Path) -> dict:
+        if source_a.is_dir() and source_b.is_dir():
+            result = self.diff_dirs(source_a, source_b)
+            added = len(result["only_b"])
+            removed = len(result["only_a"])
+            changed = len(result["differing"])
+            if not (added or removed or changed):
+                return {"identical": True}
+            return {
+                "identical": False,
+                "added_lines": added + changed,
+                "removed_lines": removed + changed,
+                "hunks": added + removed + changed,
+            }
+        diff_text = self.diff_files(source_a, source_b)
+        if not diff_text:
+            return {"identical": True}
+        added = sum(1 for line in diff_text.splitlines() if line.startswith("+") and not line.startswith("+++"))
+        removed = sum(1 for line in diff_text.splitlines() if line.startswith("-") and not line.startswith("---"))
+        changed_hunks = sum(1 for line in diff_text.splitlines() if "@@" in line)
+        return {"identical": False, "added_lines": added, "removed_lines": removed, "hunks": changed_hunks}
+
+    def diff_word_level(self, source_a: Path, source_b: Path) -> str:
+        a_text = source_a.read_text(errors="replace")
+        b_text = source_b.read_text(errors="replace")
+        a_words = a_text.split()
+        b_words = b_text.split()
+        matcher = difflib.SequenceMatcher(None, a_words, b_words)
+        output = []
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == "equal":
+                output.append(" ".join(a_words[i1:i2]))
+            elif tag == "replace":
+                output.append(f"<del>{' '.join(a_words[i1:i2])}</del><ins>{' '.join(b_words[j1:j2])}</ins>")
+            elif tag == "delete":
+                output.append(f"<del>{' '.join(a_words[i1:i2])}</del>")
+            elif tag == "insert":
+                output.append(f"<ins>{' '.join(b_words[j1:j2])}</ins>")
+        return "\n".join(output)
+
+    def files_identical(self, path_a: Path, path_b: Path) -> bool:
+        return path_a.read_bytes() == path_b.read_bytes()
+
+    def diff_files_reverse(self, path_a: Path, path_b: Path) -> str:
+        return self.diff_files(path_b, path_a)

wiz_central_toolkit/godfatherwiz/__main__.py

@@ -0,0 +1,18 @@
+"""Entry point for godfatherwiz dispatch."""
+import sys
+from .lib import cli as internal_cli
+
+def main(argv=None):
+    old_argv = sys.argv
+    if argv is not None:
+        sys.argv = [sys.argv[0]] + list(argv)
+    try:
+        return internal_cli.main()
+    finally:
+        sys.argv = old_argv
+
+# Expose main at module level for tools_registry.py
+__all__ = ['main']
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/godfatherwiz/ai.py

@@ -0,0 +1,136 @@
+"""Optional AI providers for Godfatherwiz.
+
+AI is disabled by default. Requests are made only when ask() is called with
+a configured provider.
+"""
+
+import json
+import os
+from urllib.request import Request, urlopen
+
+
+class AIProviderError(RuntimeError):
+    """Raised when AI is disabled or a provider request fails."""
+
+
+def provider_name() -> str:
+    """Return the configured provider name, defaulting to disabled."""
+    return os.environ.get("WIZ_AI_PROVIDER", "none").strip().lower() or "none"
+
+
+def provider_config() -> dict:
+    """Return the active provider configuration from environment variables."""
+    provider = provider_name()
+    defaults = {
+        "ollama": "http://localhost:11434",
+        "openai": "https://api.openai.com/v1",
+        "openai-compatible": "https://api.example.com/v1",
+        "anthropic": "https://api.anthropic.com/v1",
+    }
+    return {
+        "provider": provider,
+        "model": os.environ.get("WIZ_AI_MODEL", ""),
+        "base_url": os.environ.get("WIZ_AI_BASE_URL", defaults.get(provider, "")),
+        "api_key": (
+            os.environ.get("WIZ_AI_API_KEY")
+            or os.environ.get("OPENAI_API_KEY", "")
+            if provider in ("openai", "openai-compatible")
+            else os.environ.get("WIZ_AI_API_KEY")
+            or os.environ.get("ANTHROPIC_API_KEY", "")
+            if provider == "anthropic"
+            else ""
+        ),
+    }
+
+
+def status_text() -> str:
+    """Describe AI availability without exposing credentials."""
+    provider = provider_name()
+    if provider == "none":
+        return (
+            "AI provider: none\n"
+            "Deterministic tool routing is available.\n"
+            "Set WIZ_AI_PROVIDER to enable optional AI."
+        )
+    config = provider_config()
+    return (
+        f"AI provider: {provider}\n"
+        f"AI model: {config['model'] or '(default)'}\n"
+        f"AI endpoint: {config['base_url']}"
+    )
+
+
+def _post_json(url: str, payload: dict, headers: dict) -> dict:
+    request = Request(
+        url,
+        data=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json", **headers},
+        method="POST",
+    )
+    try:
+        with urlopen(request, timeout=60) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except Exception as exc:
+        raise AIProviderError(f"AI provider request failed: {exc}") from exc
+
+
+def ask(prompt: str) -> str:
+    """Send a prompt to the configured provider and return its response."""
+    config = provider_config()
+    provider = config["provider"]
+    if provider == "none":
+        raise AIProviderError("No AI provider configured")
+    if provider not in ("ollama", "openai", "openai-compatible", "anthropic"):
+        raise AIProviderError(f"Unsupported AI provider: {provider}")
+
+    model = config["model"]
+    base_url = config["base_url"].rstrip("/")
+
+    if provider == "ollama":
+        data = _post_json(
+            f"{base_url}/api/chat",
+            {
+                "model": model or "llama3.2",
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": False,
+            },
+            {},
+        )
+        try:
+            return data["message"]["content"]
+        except (KeyError, TypeError) as exc:
+            raise AIProviderError("Unexpected Ollama response") from exc
+
+    api_key = config["api_key"]
+    if not api_key:
+        raise AIProviderError(f"No API key configured for {provider}")
+
+    if provider == "anthropic":
+        data = _post_json(
+            f"{base_url}/messages",
+            {
+                "model": model or "claude-3-5-sonnet-latest",
+                "max_tokens": 1024,
+                "messages": [{"role": "user", "content": prompt}],
+            },
+            {"x-api-key": api_key, "anthropic-version": "2023-06-01"},
+        )
+        try:
+            return "".join(
+                item["text"] for item in data["content"] if item.get("type") == "text"
+            )
+        except (KeyError, TypeError) as exc:
+            raise AIProviderError("Unexpected Anthropic response") from exc
+
+    data = _post_json(
+        f"{base_url}/chat/completions",
+        {
+            "model": model or "gpt-4o-mini",
+            "messages": [{"role": "user", "content": prompt}],
+        },
+        {"Authorization": f"Bearer {api_key}"},
+    )
+    try:
+        return data["choices"][0]["message"]["content"]
+    except (KeyError, IndexError, TypeError) as exc:
+        raise AIProviderError("Unexpected OpenAI-compatible response") from exc

wiz_central_toolkit/godfatherwiz/lib/__init__.py

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