fux-engine 0.2.0__tar.gz → 0.3.0__tar.gz

{fux_engine-0.2.0/fux_engine.egg-info → fux_engine-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fux-engine
-Version: 0.2.0
+Version: 0.3.0
 Summary: Fux — a portable agent-aware knowledge engine: rules, memory, narrative, and graph in one frontmatter substrate.
 Author-email: arpit arya <arpitarya.me@gmail.com>
 License: MIT

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/__init__.py

@@ -3,4 +3,4 @@
 One frontmatter substrate → derived index, graph, and memory views.
 $0 deterministic maintenance; no mandatory LLM calls. See docs/fux-plan.md.
 """
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/assets/graph_boot.js

@@ -459,7 +459,7 @@ function showDetail(n){ $("agentrow").style.display="flex";
     `<span class="lab" style="${hue!=null?"":"color:var(--muted)"}">${n.type}${isKnow(n)?" · knowledge layer":""}</span></div>`+
     `<div class="ins-title">${esc(n.label)}</div>`+
     `<div class="ins-sub">community ${n.community} · degree ${deg[n.id]||0} · centrality ${(n.centrality||0).toFixed(3)}`+
-      (n.file?` · ${esc(n.file)}${n.line?":"+n.line:""}`:"")+`</div>`;
+      (n.file?` · ${fileLink(n)}`:"")+`</div>`;
   const pills=[]; if(n.layer)pills.push(["layer: "+n.layer,1]); if(n.domain)pills.push(["domain: "+n.domain,0]);
   if(n.status)pills.push(["status: "+n.status,0]); if(isGod(n))pills.push(["⭐ hub",1]);
   if(pills.length) s += `<div class="pills">`+pills.map(([p,a])=>`<span class="pill${a?" amb":""}">${esc(p)}</span>`).join("")+`</div>`;
@@ -472,6 +472,14 @@ function showDetail(n){ $("agentrow").style.display="flex";
   $("detail").innerHTML = s; wireGo(); }
 function clearDetail(){ $("agentrow").style.display="none";
   $("detail").innerHTML = `<div class="ins-sub" style="margin:0">Click a node. Double-click to focus its neighbourhood.</div>`; }
+// file:line → an <editor>://file/<abs>:<line>:<col> deep link (opens VSCode/Cursor on
+// the exact line). Falls back to plain text when the build embedded no project ROOT.
+function fileLink(n){
+  const label = esc(n.file) + (n.line ? ":"+n.line : "");
+  if(!ROOT) return label;
+  const href = encodeURI(EDITOR + "://file" + ROOT + "/" + n.file + ":" + (n.line||1) + ":1");
+  return `<a href="${href}" title="open in ${esc(EDITOR)} at line ${n.line||1}"`+
+    ` style="color:#ffb877;text-decoration:none">${label}<span style="opacity:.6"> ↗</span></a>`; }
 
 // ---- markdown export ----------------------------------------------------
 function nodeMarkdown(n){ let s=`### ${n.label} (${n.type})\n`;

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/assets/graph_template.html

@@ -301,6 +301,8 @@
 </div>
 <script>
 const DATA = __GRAPH_DATA__;
+const ROOT = __ROOT__;       // absolute project dir (for editor deep links)
+const EDITOR = __EDITOR__;   // vscode | vscode-insiders | cursor | windsurf
 // node-type accent (used by community/heat lenses + meters); knowledge ignites amber.
 const COLORS = { "code-file":"#3e4750","function":"#4a5560","class":"#5a4f63",
   "rule":"#ffa44f","formula":"#ffd27f","glossary":"#ffce8a","invariant":"#ff7a5c",

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/build.py

@@ -17,7 +17,9 @@ def run(root: Path, full: bool = False) -> dict:
 
     g = graph.build(root, rs, cfg, full=full)
     fp.out_file("graph.json").write_text(graph.to_json(g), encoding="utf-8")
-    fp.out_file("graph.html").write_text(graphhtml.render(g), encoding="utf-8")
+    fp.out_file("graph.html").write_text(
+        graphhtml.render(g, root=root, editor=cfg.get("graph_editor", "vscode")),
+        encoding="utf-8")
     fp.out_file("GRAPH_REPORT.md").write_text(report.render(g), encoding="utf-8")
 
     narr = narrative.render(rs)

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/cli.py

@@ -141,6 +141,15 @@ def build_parser() -> argparse.ArgumentParser:
 
     sub.add_parser("report", help="write GRAPH_REPORT.md (god nodes + communities)").set_defaults(fn=cligraph.cmd_report)
 
+    hk = sub.add_parser("hooks", help="install/uninstall/status Fux hooks across git + agents")
+    hk.add_argument("action", choices=["install", "uninstall", "status"], nargs="?",
+                    default="install", help="default: install")
+    hk.add_argument("--all", action="store_true", help="all surfaces (the default)")
+    for _s in ("git", "claude", "codex", "copilot"):
+        hk.add_argument(f"--{_s}", action="store_true", help=f"only the {_s} surface")
+    hk.add_argument("--recall", action="store_true", help="also wire the UserPromptSubmit recall hook")
+    hk.set_defaults(fn=clicmds.cmd_hooks)
+
     sub.add_parser("setup", help="copy bundled assets (schema, hooks, skills) to ~/.claude/fux/").set_defaults(fn=clicmds.cmd_setup)
 
     fr = sub.add_parser("fetch-rules", help="fetch plain text from a URL / file / PDF for rule extraction")

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/clicmds.py

@@ -5,8 +5,8 @@ import shutil
 import subprocess
 from pathlib import Path
 
-from fux import (build, check, config, context, fix, gate, importer, initcmd,
-                 mcpserver, paths, serve)
+from fux import (build, check, config, context, fix, gate, hookinstall, importer,
+                 initcmd, mcpserver, paths, serve)
 from fux.cliutil import root
 from fux.findings import blocking
 
@@ -24,6 +24,23 @@ def cmd_init(args) -> int:
     return 0
 
 
+def cmd_hooks(args) -> int:
+    """install | uninstall | status across git + claude + codex + copilot surfaces."""
+    picked = [s for s in hookinstall.SURFACES if getattr(args, s, False)]
+    surfaces = None if (getattr(args, "all", False) or not picked) else picked
+    if args.action == "status":
+        for surface, on in hookinstall.status(root()).items():
+            print(f"  {'✔' if on else '·'} {surface:<8} {'wired' if on else 'not wired'}")
+        return 0
+    fn = hookinstall.uninstall if args.action == "uninstall" else hookinstall.install
+    kw = {} if args.action == "uninstall" else {"recall": getattr(args, "recall", False)}
+    verb = "removed from" if args.action == "uninstall" else "wired into"
+    print(f"✔ Fux hooks {verb}:")
+    for surface, where in fn(root(), surfaces, **kw).items():
+        print(f"  {surface:<8} → {where}")
+    return 0
+
+
 def cmd_build(args) -> int:
     s = build.run(root(), full=getattr(args, "full", False))
     print(f"✔ Built: {s['active']} active rules · {s['code_files']} code files · "

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/config.py

@@ -32,6 +32,8 @@ DEFAULTS = {
     "cost_tracking": False,    # opt-in: record each lookup's savings → cumulative cost.json (§12)
     "parity_stay": [],        # docs that stay/are out-of-scope for `fux parity` (§17.17)
     "context_budget_tokens": 0,  # >0 ⇒ knapsack-pack the SessionStart INDEX (§17.25)
+    "graph_editor": "vscode",  # editor URI scheme for clickable graph.html node links:
+                               # vscode | vscode-insiders | cursor | windsurf (§7)
 }
 
 
@@ -81,5 +83,8 @@ def default_toml() -> str:
         "parity_stay = []\n\n"
         "# Token budget for the SessionStart INDEX. 0 = inject everything; >0 picks\n"
         "# the optimal (knapsack) rule subset that fits — for very large corpora.\n"
-        "context_budget_tokens = 0\n"
+        "context_budget_tokens = 0\n\n"
+        "# Editor for clickable file:line node links in graph.html.\n"
+        "# vscode | vscode-insiders | cursor | windsurf\n"
+        'graph_editor = "vscode"\n'
     )

fux_engine-0.3.0/fux/data/hooks/pre_commit.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# Fux pre-commit — rebuild the derived views ($0, AST-only) and stage them so
+# .fux/out/ always matches the committed code IN THE SAME COMMIT. Non-blocking:
+# a build failure warns but never aborts the commit (use `fux gate` to *block* on
+# drift). git invokes this with cwd at the repo root. Installed by `fux hooks install`.
+set -uo pipefail
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=_common.sh
+. "$DIR/_common.sh"
+
+# Skip during rebase/merge/cherry-pick — don't fight --continue with new changes.
+GIT_DIR="$(git rev-parse --git-dir 2>/dev/null || echo .git)"
+[ -d "$GIT_DIR/rebase-merge" ] && exit 0
+[ -d "$GIT_DIR/rebase-apply" ] && exit 0
+[ -f "$GIT_DIR/MERGE_HEAD" ] && exit 0
+[ -f "$GIT_DIR/CHERRY_PICK_HEAD" ] && exit 0
+
+# Only act inside a project that has a .fux/ footprint.
+fux_run context >/dev/null 2>&1 || exit 0
+
+echo "[fux hook] rebuilding derived views..."
+if fux_run build >/dev/null 2>&1; then
+  git add .fux/out 2>/dev/null || true   # .session-*.json is gitignored, so skipped
+else
+  echo "[fux hook] build failed — committing without refreshed views (run \`fux build\`)."
+fi
+exit 0

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux/graph.py

@@ -126,7 +126,9 @@ def _xref(nodes: dict, texts: dict[str, str], covered: set[tuple[str, str]]) ->
     index = _symbol_index(nodes)
     seen, out = set(), []
     for rel, text in texts.items():
-        for name in astextract.call_names(text) - astextract.CALL_KEYWORDS:
+        # `call_names` returns a set — sort so reference-edge order (and thus
+        # graph.json) is reproducible across builds (no PYTHONHASHSEED churn).
+        for name in sorted(astextract.call_names(text) - astextract.CALL_KEYWORDS):
             for tid in index.get(name, []):
                 if tid.startswith(rel + "::") or (rel, tid) in covered or (rel, tid) in seen:
                     continue

fux_engine-0.3.0/fux/graphhtml.py

@@ -0,0 +1,20 @@
+"""Render the merged graph as a self-contained interactive HTML file (plan §7)."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_ASSETS = Path(__file__).parent / "assets"
+
+
+def render(graph: dict, root: Path | None = None, editor: str = "vscode") -> str:
+    """Build the offline viewer. ``root`` (absolute project dir) + ``editor`` make
+    file:line node labels clickable as ``<editor>://file/<abs>:<line>`` deep links."""
+    template = (_ASSETS / "graph_template.html").read_text(encoding="utf-8")
+    boot = (_ASSETS / "graph_boot.js").read_text(encoding="utf-8")
+    data = json.dumps(graph, ensure_ascii=False)
+    root_str = str(root.resolve()) if root is not None else ""
+    return (template.replace("__GRAPH_DATA__", data)
+            .replace("__BOOT__", boot)
+            .replace("__ROOT__", json.dumps(root_str))
+            .replace("__EDITOR__", json.dumps(editor or "vscode")))

fux_engine-0.3.0/fux/hookinstall.py

@@ -0,0 +1,88 @@
+"""`fux hooks install` — wire Fux across every agent surface from one command.
+
+Four surfaces, all pointing at the *installed package* scripts (~/.claude/fux/hooks),
+never a sibling dev checkout:
+  git      → .git/hooks/pre-commit shim → packaged pre_commit.sh (build + stage views)
+  claude   → .claude/settings.json      (SessionStart/PostToolUse/Stop hooks)
+  codex    → .codex/hooks.json
+  copilot  → .copilot/settings.json
+Idempotent; `uninstall` / `status` mirror it. Git is non-blocking by design.
+"""
+from __future__ import annotations
+
+import stat
+from pathlib import Path
+
+from fux import gitutil, paths, settings
+
+SURFACES = ["git", "claude", "codex", "copilot"]
+_MARK = "fux-hook"
+
+
+def _packaged_precommit() -> Path:
+    return paths.claude_home() / "fux" / "hooks" / "pre_commit.sh"
+
+
+def _shim(target: Path) -> str:
+    return (f"#!/bin/sh\n# {_MARK} — installed by `fux hooks install`. Delegates to the\n"
+            f"# packaged Fux pre-commit (build derived views + stage them).\n"
+            f'HOOK="{target}"\n'
+            '[ -x "$HOOK" ] && exec "$HOOK" "$@"\n'
+            'exit 0\n')
+
+
+def _install_git(root: Path) -> str:
+    hooks = gitutil.hooks_dir(root)
+    if hooks is None:
+        return "skipped (not a git repo)"
+    hooks.mkdir(parents=True, exist_ok=True)
+    hook = hooks / "pre-commit"
+    if hook.exists() and _MARK not in hook.read_text(encoding="utf-8", errors="ignore"):
+        backup = hook.with_suffix(".pre-fux")
+        hook.rename(backup)
+        note = f" (existing hook backed up → {backup.name})"
+    else:
+        note = ""
+    hook.write_text(_shim(_packaged_precommit()), encoding="utf-8")
+    hook.chmod(hook.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    return f"{hook}{note}"
+
+
+def install(root: Path, surfaces: list[str] | None = None, recall: bool = False) -> dict:
+    todo = surfaces or SURFACES
+    out: dict[str, str] = {}
+    if "git" in todo:
+        out["git"] = _install_git(root)
+    for agent in ("claude", "codex", "copilot"):
+        if agent in todo:
+            out[agent] = str(settings.wire_file(root / settings.AGENT_FILES[agent], recall=recall))
+    return out
+
+
+def uninstall(root: Path, surfaces: list[str] | None = None) -> dict:
+    todo = surfaces or SURFACES
+    out: dict[str, str] = {}
+    if "git" in todo:
+        hooks = gitutil.hooks_dir(root)
+        hook = hooks / "pre-commit" if hooks else None
+        if hook and hook.exists() and _MARK in hook.read_text(encoding="utf-8", errors="ignore"):
+            hook.unlink()
+            out["git"] = "removed"
+        else:
+            out["git"] = "not installed"
+    for agent in ("claude", "codex", "copilot"):
+        if agent in todo:
+            removed = settings.unwire_file(root / settings.AGENT_FILES[agent])
+            out[agent] = "removed" if removed else "not installed"
+    return out
+
+
+def status(root: Path) -> dict:
+    out: dict[str, bool] = {}
+    hooks = gitutil.hooks_dir(root)
+    hook = hooks / "pre-commit" if hooks else None
+    out["git"] = bool(hook and hook.exists()
+                      and _MARK in hook.read_text(encoding="utf-8", errors="ignore"))
+    for agent in ("claude", "codex", "copilot"):
+        out[agent] = settings.is_wired(root / settings.AGENT_FILES[agent])
+    return out

fux_engine-0.3.0/fux/settings.py

@@ -0,0 +1,95 @@
+"""Wire Fux hooks into an agent's JSON settings (plan §8). Idempotent.
+
+Claude (`.claude/settings.json`), Codex (`.codex/hooks.json`), and Copilot
+(`.copilot/settings.json`) share one event→hook shape, so one writer serves all
+three. Prefers the installed wrapper scripts (~/.claude/fux/hooks/*.sh, which carry
+a `python -m fux` fallback) so hooks fire even when the `fux` console script is not
+on PATH; falls back to the bare `fux <subcommand>` form otherwise.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from fux import paths
+
+# event → (wrapper script name, bare-command fallback, optional matcher)
+_SPEC = {
+    "SessionStart": ("session_start.sh", "fux context", None),
+    "PostToolUse": ("post_tool_use.sh", "fux hook-touch", "Edit|Write"),
+    "Stop": ("stop.sh", "fux hook-check", None),
+}
+_RECALL = {"UserPromptSubmit": ("user_prompt_submit.sh", "fux hook-recall", None)}
+
+# agent → settings file (relative to project root)
+AGENT_FILES = {
+    "claude": Path(".claude") / "settings.json",
+    "codex": Path(".codex") / "hooks.json",
+    "copilot": Path(".copilot") / "settings.json",
+}
+
+
+def _command(script: str, fallback: str) -> str:
+    wrapper = paths.claude_home() / "fux" / "hooks" / script
+    return str(wrapper) if wrapper.exists() else fallback
+
+
+def _entry(script: str, fallback: str, matcher: str | None) -> dict:
+    hook = {"hooks": [{"type": "command", "command": _command(script, fallback)}]}
+    if matcher:
+        hook["matcher"] = matcher
+    return hook
+
+
+def wire_file(path: Path, recall: bool = False) -> Path:
+    """Wire the Fux hook spec into one agent settings file. Idempotent per event."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = json.loads(path.read_text()) if path.exists() else {}
+    hooks = data.setdefault("hooks", {})
+    spec = {**_SPEC, **(_RECALL if recall else {})}
+    for event, (script, fallback, matcher) in spec.items():
+        existing = hooks.setdefault(event, [])
+        if not _already(existing):
+            existing.append(_entry(script, fallback, matcher))
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def wire(root: Path, recall: bool = False) -> Path:
+    """Wire Claude's `.claude/settings.json` (the original entry point)."""
+    return wire_file(root / AGENT_FILES["claude"], recall=recall)
+
+
+def unwire_file(path: Path) -> bool:
+    """Remove every Fux hook entry from an agent settings file. True if changed."""
+    if not path.exists():
+        return False
+    data = json.loads(path.read_text())
+    hooks = data.get("hooks", {})
+    changed = False
+    for event in list(hooks):
+        kept = [e for e in hooks[event]
+                if not any("fux" in h.get("command", "") for h in e.get("hooks", []))]
+        if len(kept) != len(hooks[event]):
+            changed = True
+        hooks[event] = kept
+        if not hooks[event]:
+            del hooks[event]
+    if changed:
+        path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return changed
+
+
+def is_wired(path: Path) -> bool:
+    """True if any Fux hook is present in this agent settings file."""
+    if not path.exists():
+        return False
+    hooks = json.loads(path.read_text()).get("hooks", {})
+    return any("fux" in h.get("command", "")
+               for evs in hooks.values() for e in evs for h in e.get("hooks", []))
+
+
+def _already(existing: list) -> bool:
+    """True if any Fux hook (either wiring form) is already present for this event."""
+    cmds = [h.get("command", "") for e in existing for h in e.get("hooks", [])]
+    return any("fux" in c for c in cmds)

{fux_engine-0.2.0 → fux_engine-0.3.0/fux_engine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fux-engine
-Version: 0.2.0
+Version: 0.3.0
 Summary: Fux — a portable agent-aware knowledge engine: rules, memory, narrative, and graph in one frontmatter substrate.
 Author-email: arpit arya <arpitarya.me@gmail.com>
 License: MIT

{fux_engine-0.2.0 → fux_engine-0.3.0}/fux_engine.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ fux/governance.py
 fux/graph.py
 fux/graphhtml.py
 fux/graphquery.py
+fux/hookinstall.py
 fux/hookio.py
 fux/hooks.py
 fux/hybrid.py
@@ -82,6 +83,7 @@ fux/data/global/rules/files-max-100-lines.md
 fux/data/global/rules/no-secrets-in-vcs.md
 fux/data/hooks/_common.sh
 fux/data/hooks/post_tool_use.sh
+fux/data/hooks/pre_commit.sh
 fux/data/hooks/session_start.sh
 fux/data/hooks/stop.sh
 fux/data/hooks/user_prompt_submit.sh
@@ -120,7 +122,10 @@ tests/test_fetch_rules.py
 tests/test_frontmatter.py
 tests/test_fuzz_mine.py
 tests/test_globs.py
+tests/test_graph_determinism.py
 tests/test_graphhtml.py
+tests/test_graphhtml_links.py
+tests/test_hookinstall.py
 tests/test_hybrid.py
 tests/test_impact.py
 tests/test_lint_stats_gate.py

fux_engine-0.3.0/tests/test_graph_determinism.py

@@ -0,0 +1,30 @@
+"""Reproducible builds: `_xref` iterates a set (`call_names`), so without an
+explicit sort the `references` edge order — and thus graph.json — churns across
+builds under hash randomization, making committed views noisy. The fix sorts the
+iteration; this guards it by asserting the emitted order is canonical (sorted)."""
+from __future__ import annotations
+
+import json
+
+from fux import build
+
+
+def _refs_from(project, src_file):
+    g = json.loads((project / ".fux" / "out" / "graph.json").read_text())
+    return [e for e in g["edges"]
+            if e["type"] == "references" and e["source"] == src_file]
+
+
+def test_reference_edges_emitted_in_sorted_target_order(project):
+    # caller.py references three symbols defined elsewhere, at module scope (so they
+    # are loose file→symbol `references`, the edges built by `_xref`).
+    (project / "src" / "defs.py").write_text(
+        "def zeta():\n    return 1\n\ndef alpha():\n    return 2\n\ndef mu():\n    return 3\n")
+    (project / "src" / "caller.py").write_text("zeta()\nalpha()\nmu()\n")
+    build.run(project)
+
+    refs = _refs_from(project, "src/caller.py")
+    names = [e["target"].split("::", 1)[1] for e in refs]
+    assert set(names) >= {"alpha", "mu", "zeta"}, names
+    # canonical order — independent of set-iteration / PYTHONHASHSEED.
+    assert names == sorted(names), f"reference edges not in sorted order: {names}"

fux_engine-0.3.0/tests/test_graphhtml_links.py

@@ -0,0 +1,31 @@
+"""graph.html embeds the project root + editor scheme so node file:line labels
+become clickable <editor>://file/<abs>:<line> deep links."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from fux import graphhtml
+
+
+def _graph():
+    return {"nodes": [{"id": "src/a.py::f", "label": "f", "type": "function",
+                       "file": "src/a.py", "line": 12}],
+            "edges": [], "meta": {}}
+
+
+def test_render_embeds_resolved_root_and_editor(tmp_path):
+    html = graphhtml.render(_graph(), root=tmp_path, editor="cursor")
+    assert f'const ROOT = "{tmp_path.resolve()}"' in html
+    assert 'const EDITOR = "cursor"' in html
+    assert "function fileLink" in html          # the deep-link helper is shipped
+
+
+def test_render_defaults_editor_to_vscode(tmp_path):
+    html = graphhtml.render(_graph(), root=tmp_path)
+    assert 'const EDITOR = "vscode"' in html
+
+
+def test_render_without_root_is_inert():
+    # No root → empty ROOT string → fileLink falls back to plain text (no crash).
+    html = graphhtml.render(_graph())
+    assert 'const ROOT = ""' in html

fux_engine-0.3.0/tests/test_hookinstall.py

@@ -0,0 +1,73 @@
+"""`fux hooks install` wires git + claude + codex + copilot from one command,
+always pointing at packaged scripts, idempotent, with status/uninstall mirrors."""
+from __future__ import annotations
+
+import json
+import subprocess
+
+from fux import hookinstall, settings
+
+
+def _git_init(root):
+    subprocess.run(["git", "init", "-q"], cwd=root, check=True)
+
+
+def test_install_wires_all_three_agents(project):
+    out = hookinstall.install(project, ["claude", "codex", "copilot"])
+    for agent, rel in settings.AGENT_FILES.items():
+        path = project / rel
+        assert path.exists(), f"{agent} settings not written"
+        hooks = json.loads(path.read_text())["hooks"]
+        cmds = [h["command"] for evs in hooks.values() for e in evs for h in e["hooks"]]
+        assert any("fux" in c for c in cmds), f"{agent} has no fux hook"
+    assert set(out) == {"claude", "codex", "copilot"}
+
+
+def test_install_is_idempotent(project):
+    hookinstall.install(project, ["claude"])
+    hookinstall.install(project, ["claude"])
+    hooks = json.loads((project / ".claude/settings.json").read_text())["hooks"]
+    # SessionStart wired exactly once, not duplicated on a second install.
+    assert len(hooks["SessionStart"]) == 1
+
+
+def test_git_install_writes_executable_precommit_shim(project):
+    _git_init(project)
+    out = hookinstall.install(project, ["git"])
+    hook = project / ".git" / "hooks" / "pre-commit"
+    assert hook.exists() and hook.stat().st_mode & 0o111, "pre-commit not executable"
+    body = hook.read_text()
+    assert "fux-hook" in body                       # our marker
+    assert "pre_commit.sh" in body                  # delegates to the packaged script
+    assert str(hook) in out["git"]
+
+
+def test_git_install_backs_up_foreign_precommit(project):
+    _git_init(project)
+    hook = project / ".git" / "hooks" / "pre-commit"
+    hook.write_text("#!/bin/sh\necho mine\n")
+    hookinstall.install(project, ["git"])
+    assert (project / ".git" / "hooks" / "pre-commit.pre-fux").exists()
+    assert "fux-hook" in hook.read_text()
+
+
+def test_status_and_uninstall_roundtrip(project):
+    _git_init(project)
+    hookinstall.install(project)
+    st = hookinstall.status(project)
+    assert all(st.values()), st
+    hookinstall.uninstall(project)
+    st2 = hookinstall.status(project)
+    assert not any(st2.values()), st2
+
+
+def test_uninstall_leaves_foreign_hooks(project):
+    settings.wire_file(project / ".claude/settings.json")
+    data = json.loads((project / ".claude/settings.json").read_text())
+    data["hooks"].setdefault("SessionStart", [])[0]  # fux entry exists
+    data["hooks"]["Stop"].append({"hooks": [{"type": "command", "command": "echo other"}]})
+    (project / ".claude/settings.json").write_text(json.dumps(data))
+    hookinstall.uninstall(project, ["claude"])
+    hooks = json.loads((project / ".claude/settings.json").read_text())["hooks"]
+    cmds = [h["command"] for evs in hooks.values() for e in evs for h in e["hooks"]]
+    assert "echo other" in cmds and not any("fux" in c for c in cmds)

fux_engine-0.2.0/fux/graphhtml.py

@@ -1,14 +0,0 @@
-"""Render the merged graph as a self-contained interactive HTML file (plan §7)."""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-_ASSETS = Path(__file__).parent / "assets"
-
-
-def render(graph: dict) -> str:
-    template = (_ASSETS / "graph_template.html").read_text(encoding="utf-8")
-    boot = (_ASSETS / "graph_boot.js").read_text(encoding="utf-8")
-    data = json.dumps(graph, ensure_ascii=False)
-    return template.replace("__GRAPH_DATA__", data).replace("__BOOT__", boot)

fux_engine-0.2.0/fux/settings.py

@@ -1,52 +0,0 @@
-"""Wire Fux hooks into a project's .claude/settings.json (plan §8). Idempotent.
-
-Prefers the installed wrapper scripts (~/.claude/fux/hooks/*.sh, which carry a
-`python -m fux` fallback) so hooks work even when the `fux` console script is not
-on PATH; falls back to the bare `fux <subcommand>` form otherwise.
-"""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from fux import paths
-
-# event → (wrapper script name, bare-command fallback, optional matcher)
-_SPEC = {
-    "SessionStart": ("session_start.sh", "fux context", None),
-    "PostToolUse": ("post_tool_use.sh", "fux hook-touch", "Edit|Write"),
-    "Stop": ("stop.sh", "fux hook-check", None),
-}
-_RECALL = {"UserPromptSubmit": ("user_prompt_submit.sh", "fux hook-recall", None)}
-
-
-def _command(script: str, fallback: str) -> str:
-    wrapper = paths.claude_home() / "fux" / "hooks" / script
-    return str(wrapper) if wrapper.exists() else fallback
-
-
-def _entry(script: str, fallback: str, matcher: str | None) -> dict:
-    hook = {"hooks": [{"type": "command", "command": _command(script, fallback)}]}
-    if matcher:
-        hook["matcher"] = matcher
-    return hook
-
-
-def wire(root: Path, recall: bool = False) -> Path:
-    path = root / ".claude" / "settings.json"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    data = json.loads(path.read_text()) if path.exists() else {}
-    hooks = data.setdefault("hooks", {})
-    spec = {**_SPEC, **(_RECALL if recall else {})}
-    for event, (script, fallback, matcher) in spec.items():
-        existing = hooks.setdefault(event, [])
-        if not _already(existing):
-            existing.append(_entry(script, fallback, matcher))
-    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
-    return path
-
-
-def _already(existing: list) -> bool:
-    """True if any Fux hook (either wiring form) is already present for this event."""
-    cmds = [h.get("command", "") for e in existing for h in e.get("hooks", [])]
-    return any("fux" in c for c in cmds)