research-diff 0.1.0__py3-none-any.whl

research_diff/suggest.py

@@ -0,0 +1,154 @@
+"""`research-diff suggest`: your LLM proposes markers for notes and paper files that have none, as a patch.
+
+It never writes a file. Every proposal is checked before it reaches the patch: the file is one it was shown, the line
+exists, each new line reads as a marker in that file's own form (a Markdown definition or link line, a `% ` LaTeX
+comment, a `# research-diff:` comment), and a new id is not one the research already uses. Apply the patch with
+`git apply`, or edit it first, or drop it.
+
+The LLM is the one your Claude Code uses (its settings, or ANTHROPIC_* in the environment), else an OpenAI-compatible
+gateway exported in your shell (SYSTEM_DIFF_LLM_* or LLM_*), as system-diff's summary finds it. Only the files you
+asked about are sent.
+"""
+from __future__ import annotations
+
+import difflib
+import json
+import re
+import urllib.request
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from system_diff.extract import glob_rx
+from system_diff.narrate import claude_llm, shell_llm
+from system_diff.sources import git
+
+from . import compare
+from .extract import ATTR_RX, COMMENT_RX, _def_rx
+
+SYSTEM = (
+    "You add research markers to a researcher's own files so a tool can map their research. A marker is an id and a "
+    "title: Q (question), H (hypothesis), E (experiment), R (result), C (claim) and a number, e.g. 'H3: Warm-up removes "
+    "the gap', followed by lines such as 'answers: Q1', 'tests: H2', 'of: E1', 'supports: H1', 'weakens: C1', 'relies "
+    "on: H1, R2', 'status: open', 'metrics: acc=0.91'. In Markdown write them as headings or plain lines; in LaTeX as "
+    "comments starting with '% '; in Python as '# research-diff: E2 tests H2'. Only mark what the text already says: "
+    "never invent results, numbers or statuses. Reuse existing ids when the text is about them; new ids must not be in "
+    "the list of existing ids. Answer with JSON only: {\"markers\": [{\"file\": path, \"after_line\": n, \"lines\": "
+    "[...]}]}, where after_line is the line number the new lines go after (0 for the top)."
+)
+
+
+def _ask(s: Dict[str, Any], user: str, timeout: int = 120) -> str:
+    if s.get("kind") == "openai":
+        url, body = s["base_url"] + "/chat/completions", {"model": s["model"], "max_tokens": 4000,
+                                                           "messages": [{"role": "system", "content": SYSTEM},
+                                                                        {"role": "user", "content": user}]}
+        headers = {"content-type": "application/json", "authorization": "Bearer " + s["token"]}
+    else:
+        url, body = s["base_url"] + "/v1/messages", {"model": s["model"], "max_tokens": 4000, "system": SYSTEM,
+                                                      "messages": [{"role": "user", "content": user}]}
+        headers = {"content-type": "application/json", "anthropic-version": "2023-06-01",
+                   "authorization": "Bearer " + s["token"], "x-api-key": s["token"]}
+    req = urllib.request.Request(url, data=json.dumps(body).encode(), method="POST", headers=headers)
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        data = json.loads(r.read())
+    if s.get("kind") == "openai":
+        return ((data.get("choices") or [{}])[0].get("message") or {}).get("content") or ""
+    return "".join(b.get("text", "") for b in data.get("content", []) if b.get("type") == "text")
+
+
+def default_llm(root: Path) -> Optional[Callable[[str], str]]:
+    s = claude_llm(root) or shell_llm()
+    return (lambda user: _ask(s, user)) if s else None
+
+
+def _valid(line: str, path: str, def_rx: re.Pattern) -> bool:
+    if path.endswith(".tex"):
+        body = line[1:].strip() if line.startswith("%") else None
+        return bool(body) and bool(def_rx.match(body) or ATTR_RX.match(body))
+    if path.endswith((".py", ".ipynb", ".yaml", ".yml", ".toml")):
+        return bool(COMMENT_RX.search(line))
+    return bool(def_rx.match(line) or ATTR_RX.match(line) or not line.strip())
+
+
+def suggest(root: Path, files: List[str], ask: Callable[[str], str], config_path: Optional[str] = None) -> Dict[str, Any]:
+    """{patch, accepted, refused}: the proposals that passed the checks as one unified diff, and why others did not."""
+    bp, cfg, _ = compare.read(root, ".", config_path)
+    def_rx = _def_rx(cfg["kinds"])
+    texts = {f: (root / f).read_text(encoding="utf-8") for f in files if (root / f).is_file()}
+    shown = "\n\n".join(f"=== {f}\n" + "\n".join(f"{i:4} {ln}" for i, ln in enumerate(t.splitlines(), 1))
+                        for f, t in texts.items())
+    user = (f"Existing ids: {', '.join(bp['nodes']) or 'none'}\n\nAdd markers to these files (line numbers on the "
+            f"left are not part of the files):\n\n{shown[:60000]}")
+    raw = ask(user)
+    m = re.search(r"\{.*\}", raw, re.S)
+    try:
+        proposals = json.loads(m.group(0)).get("markers", []) if m else []
+    except ValueError:
+        proposals = []
+    used = set(bp["nodes"])
+    inserts: Dict[str, List[tuple]] = {}
+    accepted, refused = [], []
+    for p in proposals:
+        f, at, lines = p.get("file"), p.get("after_line"), [str(x) for x in p.get("lines") or []]
+        if f not in texts:
+            refused.append(f"{f}: not one of the files it was shown")
+            continue
+        n = len(texts[f].splitlines())
+        if not isinstance(at, int) or not 0 <= at <= n:
+            refused.append(f"{f}: line {at} does not exist")
+            continue
+        bad = [ln for ln in lines if not _valid(ln, f, def_rx)]
+        if bad or not lines:
+            refused.append(f"{f}:{at}: not a marker: {bad[0] if bad else '(nothing)'}")
+            continue
+        new_ids = [d.group(1) for ln in lines if (d := def_rx.match(ln.lstrip('% ')))]
+        clash = [i for i in new_ids if i in used]
+        if clash:
+            refused.append(f"{f}:{at}: {clash[0]} is already used")
+            continue
+        used |= set(new_ids)
+        inserts.setdefault(f, []).append((at, lines))
+        accepted.append(f"{f}:{at}: " + "; ".join(lines)[:120])
+    patch = []
+    for f, items in sorted(inserts.items()):
+        old = texts[f].splitlines(keepends=True)
+        new = list(old)
+        for at, lines in sorted(items, key=lambda x: -x[0]):   # from the bottom, so line numbers hold
+            new[at:at] = [ln + "\n" for ln in lines] + (["\n"] if f.endswith(".md") else [])
+        patch += difflib.unified_diff(old, new, f"a/{f}", f"b/{f}")
+    return {"patch": "".join(patch), "accepted": accepted, "refused": refused}
+
+
+def untagged(root: Path, config_path: Optional[str] = None) -> List[str]:
+    """Notes and paper files with no marker yet."""
+    bp, cfg, _ = compare.read(root, ".", config_path)
+    tagged = {f for n in bp["nodes"].values() for f in n["files"]}
+    tracked = git("ls-files", cwd=root).splitlines()
+    globs = [glob_rx(g) for g in cfg["notes"] + cfg["paper"]]
+    skip = [glob_rx(g) for g in cfg.get("ignore", [])]
+    return [f for f in tracked if any(r.match(f) for r in globs) and not any(r.match(f) for r in skip) and f not in tagged]
+
+
+def run(root: Path, files: List[str], out: str = "", config_path: Optional[str] = None,
+        ask: Optional[Callable[[str], str]] = None) -> int:
+    files = files or untagged(root, config_path)
+    if not files:
+        print("every notes and paper file already has markers; name files to read them anyway")
+        return 0
+    ask = ask or default_llm(root)
+    if ask is None:
+        print("no LLM to ask: research-diff uses your Claude Code's settings or ANTHROPIC_*, else SYSTEM_DIFF_LLM_*")
+        return 1
+    got = suggest(root, files, ask, config_path)
+    for line in got["refused"]:
+        print(f"refused  {line}")
+    if not got["patch"]:
+        print("no marker to suggest")
+        return 0
+    path = Path(out) if out else Path(git("rev-parse", "--absolute-git-dir", cwd=root).strip()) / "research-diff" / "suggest.patch"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(got["patch"], encoding="utf-8", newline="\n")
+    for line in got["accepted"]:
+        print(f"proposed {line}")
+    print(f"\nnothing was changed: read {path}, then `git apply {path}` to take it")
+    return 0

research_diff/trackers.py

@@ -0,0 +1,103 @@
+"""Runs from experiment trackers, as results: MLflow's local file store (`mlruns/`) and W&B's local run folders
+(`wandb/`), read with the standard library. A run belongs to an experiment when it is tagged with its id:
+`research-diff.experiment` (or `research_id`) as an MLflow tag or param, or `research_id` in the W&B config.
+
+Tracker folders are usually git-ignored, so a checkpoint could not see them. `sync` writes their runs into
+`research/runs.json`, which is tracked: the runs are then on the map, in git, and in the next diff.
+"""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+
+RUNS = "research/runs.json"
+TAGS = ("research-diff.experiment", "research_id", "research-diff")
+
+
+def _last_metric(path: Path) -> float:
+    """MLflow keeps one line per step, `timestamp value step`; the last one is the run's value."""
+    lines = [ln.split() for ln in path.read_text(encoding="utf-8").splitlines() if ln.strip()]
+    return float(lines[-1][1])
+
+
+def read_mlflow(store: Path) -> List[Dict[str, Any]]:
+    out = []
+    for meta in sorted(store.glob("*/*/meta.yaml")):
+        run = meta.parent
+        exp = ""
+        for kind in ("tags", "params"):
+            for t in TAGS:
+                p = run / kind / t
+                if p.is_file():
+                    exp = exp or p.read_text(encoding="utf-8").strip()
+        if not exp:
+            continue
+        metrics = {}
+        for m in sorted((run / "metrics").glob("**/*")) if (run / "metrics").is_dir() else []:
+            if m.is_file():
+                try:
+                    metrics[m.relative_to(run / "metrics").as_posix()] = _last_metric(m)
+                except (ValueError, IndexError):
+                    continue
+        name_file = run / "tags" / "mlflow.runName"
+        out.append({"experiment": exp, "source": "mlflow", "run": run.name,
+                    "name": name_file.read_text(encoding="utf-8").strip() if name_file.is_file() else run.name[:8],
+                    "metrics": metrics})
+    return out
+
+
+def _wandb_config_value(text: str, key: str) -> str:
+    """W&B's config.yaml keeps each key as `key:\\n  desc: …\\n  value: X`."""
+    m = re.search(rf"^{re.escape(key)}:\s*\n(?:\s+.*\n)*?\s+value:\s*(.+)$", text, re.M)
+    return m.group(1).strip().strip("'\"") if m else ""
+
+
+def read_wandb(folder: Path) -> List[Dict[str, Any]]:
+    out = []
+    for run in sorted(p for p in folder.glob("*run-*") if p.is_dir()):
+        files = run / "files"
+        cfg = (files / "config.yaml").read_text(encoding="utf-8") if (files / "config.yaml").is_file() else ""
+        exp = next((v for k in TAGS if (v := _wandb_config_value(cfg, k))), "")
+        summary = files / "wandb-summary.json"
+        if not exp or not summary.is_file():
+            continue
+        try:
+            data = json.loads(summary.read_text(encoding="utf-8"))
+        except ValueError:
+            continue
+        metrics = {k: float(v) for k, v in data.items() if isinstance(v, (int, float)) and not isinstance(v, bool)
+                   and not k.startswith("_")}
+        out.append({"experiment": exp, "source": "wandb", "run": run.name.rsplit("-", 1)[-1], "name": run.name,
+                    "metrics": metrics})
+    return out
+
+
+def sync(root: Path, mlflow: str = "mlruns", wandb: str = "wandb") -> Dict[str, Any]:
+    """Write the trackers' tagged runs to research/runs.json. Returns {runs, written}; nothing is written when no
+    tracker folder exists, and the file only changes when a run does."""
+    runs: List[Dict[str, Any]] = []
+    if (root / mlflow).is_dir():
+        runs += read_mlflow(root / mlflow)
+    if (root / wandb).is_dir():
+        runs += read_wandb(root / wandb)
+    if not runs and not (root / RUNS).is_file():
+        return {"runs": 0, "written": False}
+    runs.sort(key=lambda r: (r["experiment"], r["source"], r["run"]))
+    text = json.dumps({"runs": runs}, indent=1, sort_keys=True) + "\n"
+    path = root / RUNS
+    if path.is_file() and path.read_text(encoding="utf-8") == text:
+        return {"runs": len(runs), "written": False}
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8", newline="\n") as f:
+        f.write(text)
+    return {"runs": len(runs), "written": True}
+
+
+def run_nodes(text: str) -> List[Dict[str, Any]]:
+    """The runs of a runs.json, for extract."""
+    try:
+        return list(json.loads(text).get("runs") or [])
+    except (ValueError, AttributeError):
+        return []

research_diff/watch.py

@@ -0,0 +1,69 @@
+"""`research-diff watch`: a live page of what changed in the research since the checkpoint, with Mark as seen.
+system-diff's watcher, pointed at the research map: the same page, the same token, one look at a time."""
+from __future__ import annotations
+
+import subprocess
+import threading
+import time
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+from typing import Optional
+
+from system_diff import watch as base
+from system_diff.compare import worktree_tree
+
+from . import compare, graph
+
+
+class Watcher(base.Watcher):
+    def key(self) -> tuple:
+        compare.sync_trackers(self.root, self.config_path)   # a new tracker run changes research/runs.json
+        return worktree_tree(self.root), compare._rev(self.root, compare.CHECKPOINT_REF)
+
+    def refresh(self) -> None:
+        try:
+            c = compare.compare(self.root, self.base, ".", self.config_path)
+            new = {"headline": c.diff["headline"], "plan": c.diff["plan"],
+                   "svg": graph.diff_svg(c.diff, c.before, c.after, c.cfg) or "",
+                   "changes": len(c.diff["changes"]), "base": c.base, "error": ""}
+        except (OSError, subprocess.CalledProcessError, ValueError, KeyError) as exc:
+            new = {"error": f"{type(exc).__name__}: {exc}"}
+        with self.lock:
+            self.state.update(new, version=self.state["version"] + 1, at=time.strftime("%H:%M:%S"))
+
+    def mark_seen(self) -> None:
+        with self.busy:
+            compare.checkpoint(self.root)
+        self.tick(force=True)
+
+
+PAGE = base.PAGE.replace("<title>System diff</title>", "<title>Research diff</title>").replace(
+    "<h1>System diff</h1>", "<h1>Research diff</h1>")
+
+
+def serve(root: Path, base_point: str = "checkpoint", port: int = 8766, config_path: Optional[str] = None,
+          interval: float = 2.0, ready=None) -> None:
+    w = Watcher(root, base_point, config_path, interval)
+    handler = base.handler(w)
+    handler.do_GET_base = handler.do_GET
+
+    def do_GET(self):
+        if self.path in ("/", "/index.html"):
+            return self._send(200, PAGE.replace("__TOKEN__", w.token).encode(), "text/html; charset=utf-8")
+        return self.do_GET_base()
+
+    handler.do_GET = do_GET
+    server = ThreadingHTTPServer(("127.0.0.1", port), handler)
+    threading.Thread(target=w.loop, daemon=True).start()
+    url = f"http://127.0.0.1:{server.server_address[1]}/"
+    if ready:
+        ready(url, server, w)
+    else:
+        print(f"research-diff watch: {url} (Ctrl-C to stop)", flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        w.stop.set()
+        server.server_close()

research_diff-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: research-diff
+Version: 0.1.0
+Summary: Maps your research from its notes, experiment configs, results and paper (questions, hypotheses, experiments, results, claims) and shows what each iteration changed. Built for exploring ideas with AI coding agents.
+Project-URL: Homepage, https://github.com/simplifiedmachine/research-diff
+Project-URL: Documentation, https://github.com/simplifiedmachine/research-diff/wiki
+Author: simplifiedmachine
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude-code,experiment-tracking,hypotheses,mcp,reproducibility,research
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: system-diff==0.1.0
+Provides-Extra: dev
+Requires-Dist: mcp>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.10; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# research-diff
+
+Maps your research from its notes, experiment configs, results and paper (questions, hypotheses, experiments,
+results, claims) and shows what each iteration changed. Built for exploring ideas with AI coding agents.
+
+<!-- research-map:begin -->
+![Research map, generated from the notes, configs, results and paper](https://raw.githubusercontent.com/simplifiedmachine/research-diff/main/docs/research.svg)
+
+<details><summary>1 open warning</summary>
+
+- H2 is open and no experiment tests it
+
+</details>
+<!-- research-map:end -->
+
+The map above is this repository's own example (`examples/batch-size`), regenerated from its files on every change.
+
+## What it reads
+
+Markers in your own files, in one grammar: an id (`Q` question, `H` hypothesis, `E` experiment, `R` result,
+`C` claim, and a number) and a title, then links and a status on the lines after it.
+
+```markdown
+## H2: Learning-rate warm-up removes the gap      <- notes (Markdown): a heading or a list item
+answers: Q1
+status: open                                      <- open | supported | refuted | anything you like
+```
+
+| Where | How |
+|---|---|
+| Notes (`.md`) | definitions as above; `tests:`, `of:`, `supports:`, `weakens:`, `relies on:`, `metrics: acc=0.91` |
+| Experiment configs (YAML, JSON, TOML) | a `research:` block: `id`, `title`, `tests`, `status`, and `results: out/e1.json`, whose numbers become the result `E1.results` |
+| Scripts and notebooks | a comment: `# research-diff: E2 tests H2` |
+| The paper (LaTeX) | a comment: `% C1: Small batches win` and `% relies on: H1, R1`; the paragraph's `\cite{…}` become its sources; `% expects: E1.results acc.batch32 > 0.85` warns when a result stops meeting it |
+
+The map is built from markers only, so the same files always give the same map. It warns when a claim relies on
+nothing or on a refuted hypothesis, when a number no longer meets what a claim `expects:`, when an open hypothesis has no experiment, and when a link points at nothing.
+
+## Use
+
+```sh
+pipx install research-diff
+research-diff map --out docs            # research.svg and research.json
+research-diff diff --base HEAD          # what your uncommitted iteration did
+research-diff sync                      # MLflow / W&B runs into research/runs.json
+research-diff checkpoint                # mark what you have understood
+research-diff diff                      # only what came after that
+```
+
+A diff reads like: *Adds 1 hypothesis (H3); H1: open → refuted; E1.results acc.b32: 0.874 → 0.881 (+0.8%); 1 new
+link; 2 new warnings (C1 relies on H1, which is refuted…).* It comes with the exact list (`plan.txt`) and a picture of
+only what changed (`diff.svg`).
+
+## With AI coding agents
+
+```sh
+pipx inject research-diff mcp
+research-diff setup claude     # a Stop hook, a skill and the MCP server (--scope project, --undo)
+research-diff watch            # http://127.0.0.1:8766/ : the research diff since your checkpoint, live
+```
+
+After every Claude Code turn one line says what changed in the research. The agent's tools: `research_diff`,
+`research_map`, `log_result` (records a run's metrics and what it supports or weakens in `research/log.md`, so it is
+on the map and in git) and `checkpoint`. The pictures, snapshots and live page are
+[system-diff](https://github.com/simplifiedmachine/system-diff)'s.
+
+## Experiment trackers
+
+Runs logged to MLflow (its local `mlruns/` store) or W&B (its local `wandb/` folders) become results of the experiment
+they are tagged with: `research-diff.experiment` (or `research_id`) as an MLflow tag or param, `research_id` in the W&B
+config. Tracker folders are usually git-ignored, so `research-diff sync` copies their runs into `research/runs.json`,
+which is tracked: the runs are then on the map, in git and in the next diff. The hook, the live page and the MCP tools
+sync on their own.
+
+## Markers suggested by your LLM
+
+```sh
+research-diff suggest                 # notes and paper files with no marker yet, or name the files
+git apply .git/research-diff/suggest.patch
+```
+
+Your LLM (the one your Claude Code uses) proposes markers for what the text already says. Each proposal is checked
+before it reaches the patch: a real line of a file it was shown, a marker in that file's own form, and no id that is
+already used. Nothing is written until you apply the patch.
+
+## License
+
+MIT

research_diff-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+research_diff/__init__.py,sha256=_WBjt6U1_3Zm173407KJ4bNfIcbGsWgvEyi-jUMyN4g,106
+research_diff/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+research_diff/agent.py,sha256=KdBlJX20FC0d610nbunhgVRxikt2MXNL4oXbPFa6nTw,6700
+research_diff/cli.py,sha256=_XXu8rf2XxOxJpzXno_95Hyk6J3xLwiAWoJ3DORA3Mc,7756
+research_diff/compare.py,sha256=8zJfCp0eJk8d8nn4KM9M7COjxWuWQm2rqsRgif0qrJY,2869
+research_diff/config.py,sha256=67EuoY3yrjaN2iTV5ot2p2WHo-N-3meUhLGaeVrt_xo,2862
+research_diff/diff.py,sha256=ivbNvevLxGhtEzAhDdwhm4_bpbTBgxC9V0Y4qxnpaac,5795
+research_diff/extract.py,sha256=997MlMEEu6MmvKv1-7pE_nZ4Wb33ThDGIxbafS9qo6I,14885
+research_diff/graph.py,sha256=nJa72RrlNByjxFUL6Ni8Rqb7CD5VwnV7SsDAPcB-LpU,4935
+research_diff/mcp_server.py,sha256=STdfXoHCPA8aA_aRgnuzzkwNq8xJTz5Rv_YJGW4SJH4,5344
+research_diff/readme.py,sha256=Q_fsfMRkJuMfYId_bxb7HdHW2d8efBa7eOoAnK5DucA,1785
+research_diff/suggest.py,sha256=lj6upLfo2D-LcOO4b_iuDUJiP1sPbgGds1voORoEUj4,8225
+research_diff/trackers.py,sha256=abm_AegEFuXD4F2dstVjaJ9UxEIPj4qQgzdXM4xdpsg,4522
+research_diff/watch.py,sha256=htjCGKM3BLb01E1TIGxDjNRPi5z-5eHe7q4SKzEhe64,2666
+research_diff-0.1.0.dist-info/METADATA,sha256=DQaQr070mt72PAZYZa6zlpgf0gCKVUduv2Ws5yUizDQ,5400
+research_diff-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+research_diff-0.1.0.dist-info/entry_points.txt,sha256=s9GaJAzGrKJPFfyAHtofKzp5cdasuDsquV6v1FXmI0w,90
+research_diff-0.1.0.dist-info/licenses/LICENSE,sha256=QHQ-0t-7_4_K7j92CTlQScHiJiDZ91DcpV6WIOIFYQE,1074
+research_diff-0.1.0.dist-info/RECORD,,

research_diff-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

research_diff-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+resdiff = research_diff.cli:main
+research-diff = research_diff.cli:main

research_diff-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 simplifiedmachine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.