hexiel 0.2.9__py3-none-any.whl

hexiel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.9"

hexiel/__main__.py

@@ -0,0 +1,5 @@
+"""`python -m hexiel` — same as the `hexiel` command (used by self-update restarts)."""
+
+from .main import main
+
+main()

hexiel/brand.py

@@ -0,0 +1,43 @@
+"""hexiel's logo: angel wings around an H under a halo. The image lives in
+docs/logo.svg (and web/logo.svg); this is the terminal rendition."""
+
+from rich.text import Text
+
+LOGO = r"""
+                       .-~~~~~-.
+  __.._                `-~~~~~-'                _..__
+  \    ``--.._          ██   ██          _..--''    /
+   \ ``--.._  ``--._    ██   ██    _.--''  _..--'' /
+    `-._    ``--._  \   ███████   /  _.--''    _.-'
+        `-.__     \  \  ██   ██  /  /     __.-'
+             `--.__\  \ ██   ██ /  /__.--'
+                    `-'         `-'
+"""
+LOGO_WIDTH = max(len(line) for line in LOGO.splitlines())
+GOLD = "#d9b55a"
+WING = ["#cfe6df", "#cfe6df", "#a8cfc4", "#93c2b5", "#7fb3a5", "#6aa294", "#5f9486", "#5f9486"]
+HALO_COLS = range(22, 33)
+
+
+def logo_text(tagline: str = "your codebase's guardian angel") -> Text:
+    """The coloured logo: gold halo + H, wings shaded light to sage."""
+    out = Text()
+    for row, line in enumerate(LOGO.strip("\n").splitlines()):
+        for col, ch in enumerate(line):
+            gold = ch == "█" or (row < 2 and col in HALO_COLS)
+            out.append(ch, style=f"bold {GOLD}" if gold else WING[min(row, len(WING) - 1)])
+        out.append("\n")
+    out.append(" " * 20 + "hexiel", style=f"bold {GOLD}")
+    out.append(f"  · {tagline}", style="#8b919d")
+    return out
+
+
+def small_logo_text() -> Text:
+    """One line for narrow terminals."""
+    out = Text()
+    out.append("~\\\\ ", style="#a8cfc4")
+    out.append("H", style=f"bold {GOLD}")
+    out.append(" //~  ", style="#a8cfc4")
+    out.append("hexiel", style=f"bold {GOLD}")
+    out.append(" · your codebase's guardian angel", style="#8b919d")
+    return out

hexiel/config.py

@@ -0,0 +1,194 @@
+"""Configuration loading and defaults for hexiel."""
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+def home_config_dir() -> Path:
+    return Path(os.environ.get("HEXIEL_HOME", Path.home() / ".config" / "hexiel"))
+
+
+def home_data_dir() -> Path:
+    return Path(os.environ.get("HEXIEL_DATA", Path.home() / ".local" / "share" / "hexiel"))
+
+
+def memory_dir() -> Path:
+    return home_data_dir() / "memory"
+
+
+def skills_dirs() -> list[Path]:
+    dirs = [home_data_dir() / "skills"]
+    # compat with existing Claude Code skills so nothing has to be copied over
+    dirs.append(Path.home() / ".claude" / "skills")
+    dirs.append(Path.cwd() / ".hexiel" / "skills")
+    dirs.append(Path.cwd() / ".claude" / "skills")
+    return dirs
+
+
+CONFIG_FILE = home_config_dir() / "config.toml"
+OLLAMA_HOST = "http://localhost:11434"
+
+
+def list_ollama_models(base_url: str = "") -> list[str]:
+    """Live model inventory from an Ollama server (local or cloud-backed)."""
+    import httpx
+    root = (base_url or OLLAMA_HOST).removesuffix("/v1").removesuffix("/")
+    try:
+        resp = httpx.get(f"{root}/api/tags", timeout=10)
+        return sorted(m["name"] for m in resp.json().get("models", []))
+    except (httpx.HTTPError, ValueError):
+        return []
+
+DEFAULT_CONFIG = '''\
+# hexiel configuration. Profiles live under [models.*]; pick one with /model NAME
+# or `hexiel --model NAME`. "default" selects the boot model.
+
+default = "glm-flash"
+
+[settings]
+auto_approve = false        # when true, write tools and bash run without approval
+compact_threshold = 0.82    # auto-compact when the prompt reaches this share of the context window
+request_timeout = 900       # seconds per provider request
+search_backend = "duckduckgo"   # "duckduckgo" (no key) or "searxng"
+searxng_url = ""            # e.g. http://localhost:8888 when search_backend = "searxng"
+
+[models.glm-flash]
+provider = "openai"         # "openai" = any OpenAI-compatible /chat/completions endpoint
+base_url = "http://localhost:11434/v1"
+model = "glm-5.3-flash:cloud"
+context_window = 200000     # tokens before auto-compaction kicks in
+max_output_tokens = 16384
+
+[models.kimi]
+provider = "openai"
+base_url = "http://localhost:11434/v1"
+model = "kimi-k2.7-code:cloud"
+context_window = 262144
+max_output_tokens = 16384
+
+[models.anthropic]
+provider = "anthropic"
+model = "claude-opus-5-5"
+api_key_env = "ANTHROPIC_API_KEY"
+context_window = 200000
+max_output_tokens = 16384
+
+[models.anthropic-sonnet]
+provider = "anthropic"
+model = "claude-sonnet-5-5"
+api_key_env = "ANTHROPIC_API_KEY"
+context_window = 200000
+max_output_tokens = 16384
+
+# ---- more big-model presets (fill in the key env var / base_url you have) ----
+
+[models.openai]
+provider = "openai"
+base_url = "https://api.openai.com/v1"
+model = "gpt-5.2"
+api_key_env = "OPENAI_API_KEY"
+context_window = 400000
+max_output_tokens = 16384
+
+[models.gemini]
+provider = "openai"         # Gemini speaks the OpenAI-compatible protocol
+base_url = "https://generativelanguage.googleapis.com/v1beta/openai"
+model = "gemini-2.5-pro"
+api_key_env = "GEMINI_API_KEY"
+context_window = 1000000
+max_output_tokens = 16384
+
+[models.xai]
+provider = "openai"
+base_url = "https://api.x.ai/v1"
+model = "grok-4"
+api_key_env = "XAI_API_KEY"
+context_window = 256000
+max_output_tokens = 16384
+
+[models.openrouter]
+provider = "openai"         # hundreds of models behind one key
+base_url = "https://openrouter.ai/api/v1"
+model = "anthropic/claude-opus-4.5"
+api_key_env = "OPENROUTER_API_KEY"
+context_window = 200000
+max_output_tokens = 16384
+
+[models.deepseek]
+provider = "openai"
+base_url = "https://api.deepseek.com/v1"
+model = "deepseek-chat"
+api_key_env = "DEEPSEEK_API_KEY"
+context_window = 128000
+max_output_tokens = 16384
+'''
+
+
+@dataclass
+class ModelConfig:
+    name: str
+    provider: str
+    model: str
+    base_url: str = ""
+    api_key_env: str = ""
+    context_window: int = 200_000
+    max_output_tokens: int = 16_384
+    extra_body: dict = field(default_factory=dict)
+
+
+@dataclass
+class Settings:
+    auto_approve: bool = False
+    compact_threshold: float = 0.82
+    request_timeout: int = 900
+    search_backend: str = "duckduckgo"
+    searxng_url: str = ""
+
+
+@dataclass
+class Config:
+    default_model: str
+    models: dict[str, ModelConfig]
+    settings: Settings
+
+    def model(self, name: str | None = None) -> ModelConfig:
+        key = name or self.default_model
+        if key not in self.models:
+            raise KeyError(f"unknown model profile '{key}' (have: {', '.join(self.models)})")
+        return self.models[key]
+
+
+def load_config(model_override: str | None = None) -> Config:
+    if not CONFIG_FILE.exists():
+        try:
+            CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+            CONFIG_FILE.write_text(DEFAULT_CONFIG)
+        except OSError:
+            pass
+
+    raw: dict = {}
+    if CONFIG_FILE.exists():
+        try:
+            raw = tomllib.loads(CONFIG_FILE.read_text())
+        except tomllib.TOMLDecodeError as exc:
+            raise SystemExit(f"bad config {CONFIG_FILE}: {exc}")
+
+    models: dict[str, ModelConfig] = {}
+    for name, body in raw.get("models", {}).items():
+        models[name] = ModelConfig(name=name, **body)
+
+    settings_raw = raw.get("settings", {})
+    settings = Settings(
+        auto_approve=bool(settings_raw.get("auto_approve", False)),
+        compact_threshold=float(settings_raw.get("compact_threshold", 0.82)),
+        request_timeout=int(settings_raw.get("request_timeout", 900)),
+        search_backend=str(settings_raw.get("search_backend", "duckduckgo")),
+        searxng_url=str(settings_raw.get("searxng_url", "")),
+    )
+
+    default_model = model_override or raw.get("default", next(iter(models), "default"))
+    if default_model not in models:
+        models.setdefault(default_model, ModelConfig(name=default_model, provider="openai"))
+    return Config(default_model=default_model, models=models, settings=settings)

hexiel/doctor.py

@@ -0,0 +1,168 @@
+"""hexiel doctor: preflight checks with copy-paste fixes, plus the first-run
+wizard (same checks, guided). Run `hexiel doctor` any time."""
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from . import __version__
+from .config import CONFIG_FILE, load_config, home_data_dir
+from .gitlab import load_token
+
+
+def _check(label: str, ok: bool, detail: str = "", fix: str = "") -> bool:
+    mark = "\033[32m✓\033[0m" if sys.stdout.isatty() else "✓" if ok else "✗"
+    if not ok:
+        mark = "\033[31m✗\033[0m" if sys.stdout.isatty() else "✗"
+    line = f" {mark} {label}"
+    if detail:
+        line += f" — {detail}"
+    print(line)
+    if not ok and fix:
+        print(f"     fix: {fix}")
+    return ok
+
+
+def run_checks(cwd: str) -> dict:
+    """Run every check; returns {name: (ok, detail, fix)} and prints results."""
+    sys.path.insert(0, str(Path(__file__).parent))
+    results: dict[str, bool] = {}
+    print(f"hexiel {__version__} — doctor\n")
+
+    # config file
+    ok = CONFIG_FILE.exists()
+    results["config"] = _check(
+        "configuration", ok, str(CONFIG_FILE) if ok else "no config.toml yet",
+        fix="just run hexiel once — it writes a starter config")
+
+    cfg = None
+    try:
+        cfg = load_config()
+        results["config_parse"] = _check("config parses", True, ", ".join(cfg.models))
+    except SystemExit as exc:
+        results["config_parse"] = _check("config parses", False, str(exc))
+        return results
+
+    # python deps
+    for mod, needs in (("textual", "the TUI"), ("httpx", "all providers"),
+                       ("aiohttp", "the web UI (hexiel serve)")):
+        try:
+            __import__(mod)
+            results[f"dep:{mod}"] = _check(f"python: {mod}", True, f"for {needs}")
+        except ImportError:
+            results[f"dep:{mod}"] = _check(
+                f"python: {mod}", False, f"needed for {needs}",
+                fix=f"pip install ({mod}) in your hexiel venv")
+
+    # provider reachability
+    default_name = cfg.default_model
+    model_cfg = cfg.models.get(default_name)
+    results["model"] = _check(
+        f"default model '{default_name}'", model_cfg is not None,
+        f"{model_cfg.model} @ {model_cfg.base_url or model_cfg.provider}" if model_cfg else "")
+    if model_cfg and model_cfg.base_url:
+        import httpx
+        try:
+            from .config import list_ollama_models
+            models = list_ollama_models(model_cfg.base_url)
+            reachable = bool(models)
+            wanted = model_cfg.model in models
+            results["provider"] = _check(
+                "provider endpoint", reachable, f"{len(models)} models seen, "
+                f"target '{model_cfg.model}' {'available' if wanted else 'NOT in inventory'}",
+                fix="" if wanted else
+                    f"ollama pull {model_cfg.model}  (or /model <another>)")
+        except Exception as exc:  # noqa: BLE001
+            results["provider"] = _check("provider endpoint", False, repr(exc),
+                                         fix="start ollama serve (localhost:11434)")
+    elif model_cfg and model_cfg.api_key_env:
+        present = bool(os.environ.get(model_cfg.api_key_env))
+        results["provider"] = _check(
+            f"{model_cfg.provider} API key", present, model_cfg.api_key_env,
+            fix=f"export {model_cfg.api_key_env}=sk-… (or put it in shell profile)")
+
+    # toolchain
+    from .tooling import detect_toolchain
+    chain = detect_toolchain(cwd)
+    container = chain.container.binary if chain.container else None
+    results["container"] = _check(
+        "container runtime (docker/podman)", bool(container),
+        f"{container}{f' + compose' if (chain.container and chain.container.compose_command) else ''}"
+        if container else "none found — container tool disabled",
+        fix="sudo pacman -S docker && sudo systemctl enable --now docker")
+    results["test_runner"] = _check(
+        "test runner detection", bool(chain.test_runners),
+        ", ".join(r.label for r in chain.test_runners) or "none in this project")
+    results["git"] = _check("git", bool(shutil.which("git")),
+                            "(needed for the /ship and /heal flows)",
+                            fix="sudo pacman -S git")
+    pwsh = shutil.which("pwsh") or shutil.which("powershell.exe") or shutil.which("powershell")
+    if os.name == "nt":
+        results["powershell"] = _check(
+            "PowerShell", bool(pwsh), pwsh or "missing — the shell tools need it",
+            fix="winget install Microsoft.PowerShell")
+    else:
+        results["powershell"] = _check(
+            "powershell tool", bool(pwsh),
+            pwsh or "not installed — optional here, required on Windows hosts",
+            fix="yay -S powershell-bin (or winget install Microsoft.PowerShell)")
+
+    # gitlab token
+    token = load_token()
+    results["gitlab"] = _check(
+        "GitLab token", bool(token),
+        "set (proposes MRs with /ship)" if token else "not set — /ship /heal can only push, not open MRs",
+        fix="create one: https://gitlab.com/-/user_settings/personal_access_tokens (api scope),"
+            " then HEXIEL_GITLAB_TOKEN=… hexiel or /setup-gitlab <token>")
+
+    # memory + skills dirs
+    mem = home_data_dir() / "memory"
+    results["memory"] = _check("memory dir", mem.is_dir(), str(mem),
+                               fix="created automatically on first run; check permissions")
+    from .skills import discover
+    skills = discover(cwd)
+    results["skills"] = _check("skills", len(skills) > 0,
+                               ", ".join(s.name for s in skills[:8]) +
+                               (" …" if len(skills) > 8 else "") or "none installed")
+
+    # incidents
+    from .heal import unhealed
+    incidents = unhealed(cwd)
+    results["incidents"] = _check("self-heal queue", not incidents,
+                                  "all clear" if not incidents
+                                  else f"{len(incidents)} unhealed — run /heal in a session")
+
+    return results
+
+
+def wizard(cwd: str) -> None:
+    """First-run guided setup: config, provider pick, gitlab token (optional)."""
+    print("Welcome to hexiel — guided setup (all questions optional, Enter keeps defaults)\n")
+    if not CONFIG_FILE.exists():
+        load_config()   # writes starter config
+        print(f"  wrote {CONFIG_FILE}")
+    from .config import list_ollama_models
+    models = list_ollama_models()
+    if models:
+        names = ", ".join(models[:12]) + (" …" if len(models) > 12 else "")
+        print(f"  Ollama reachable — models: {names}")
+        print("  config already defaults to ollama cloud models; /model NAME switches anytime")
+    else:
+        print("  Ollama not reachable on localhost:11434 — `ollama serve` + "
+              "`ollama pull <model>` enables it, or add a cloud profile to config.toml")
+    if not load_token():
+        print("  no GitLab token: /ship and /heal can push branches but will not open MRs.")
+        print("  add later with /setup-gitlab <token> (api scope PAT).")
+    print("\nDone. Start a session with `hexiel` (TUI), `hexiel --serve` (browser), or `hexiel -p \"…\"`.")
+
+
+def doctor_main(cwd: str = ".") -> int:
+    results = run_checks(cwd)
+    failed = [k for k, ok in results.items() if not ok]
+    print()
+    if not failed:
+        print("all checks passed — hexiel is ready")
+        return 0
+    print(f"{len(failed)} check(s) need attention: {', '.join(failed)}")
+    return 1