every-cli 0.1.0__tar.gz

every_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 soufiane
+
+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.

every_cli-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: every-cli
+Version: 0.1.0
+Summary: Ask a yes/no question of every function in a codebase. Ranked answers in seconds, for cents.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sufianetaouil/every
+Project-URL: Issues, https://github.com/sufianetaouil/every/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tree-sitter>=0.25
+Requires-Dist: tree-sitter-language-pack>=1.15
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# every
+
+**Ask a yes/no question of every function in a codebase. Ranked answers in seconds, for cents.**
+
+```
+$ every "catches an exception and then ignores it" ./my-api
+
+scanned 1,842 functions in 214 files ...   3.1s   $0.03   class: body
+
+ 0.93  src/payments/webhook.py:88     handle_stripe_event
+ 0.88  src/auth/session.py:141        refresh_token
+ 0.84  src/jobs/retry.py:22           _run_once
+ 0.79  src/db/pool.py:57              _reconnect
+ 0.52  src/utils/cache.py:19          get                (below 0.75)
+
+ 4 hits >= 0.75 out of 1,842 functions
+```
+
+`every` is grep whose pattern is a question. It is **not** embedding search: it does not
+find code *similar to* your words. It judges the question against **every function** and
+returns the probability that the answer is yes.
+
+It runs on [TypeSafe AI's Jev](https://typesafe.ai), a model that returns typed decisions
+with probabilities instead of generating text. That is what makes judging 5,000 functions
+cost about seven cents and take about fifteen seconds (measured: 1,302 functions of
+`gin-gonic/gin` in 3.7 s for $0.018).
+
+## Install
+
+```
+pip install every-cli          # installs the `every` command
+export TYPESAFE_API_KEY=...      # PowerShell: $env:TYPESAFE_API_KEY="..."
+every --selftest                # 20 labelled functions, one request; prints recall / false positives / AUROC
+```
+
+### No Jev access yet?
+
+`every` needs a Jev API key. If you don't have one, **join the hosted-tier waitlist:**
+https://github.com/sufianetaouil/every/discussions/1 — enough signups and we build the
+hosted version (no key, no setup). Meanwhile, `examples/recorded/` has real runs you can read.
+
+## What leaves your machine
+
+The source of every function in the files `every` scans is sent to TypeSafe's API
+(`api.typesafe.ai`) to be judged. Nothing else is sent. The local cache
+`.every/cache.json` stores only `sha256(question, unit text) -> score`, never source.
+Don't point `every` at code you can't send to a third party.
+
+## Usage
+
+```
+every "<question>" <path> [--above 0.75] [--top 20] [--json] [--yes] [--no-cache]
+```
+
+Questions that work well are about **one function at a time**:
+
+- "builds SQL by string concatenation"
+- "reads request data without checking authentication"
+- "returns a user record that still contains the password hash"
+- "is a test that doesn't assert anything"
+- "retries in a loop with no upper bound"
+
+`every` classifies your question first. If it needs a function's callers and callees, it
+includes them. If it needs whole-program data flow, results are marked
+`coverage: partial` — it will not pretend.
+
+`--json` (automatic when piping) prints `{"results": [...], "meta": {...}}`; `meta` has
+tokens, cost, requests and timing. Scores are cached in `.every/` so a re-run or a
+refined question only pays for what's new.
+
+## Languages
+
+Function-level: Python, JavaScript, TypeScript/TSX, Go, Java, Rust, C#, Ruby, PHP.
+Other source files (C/C++, Kotlin, Swift, Scala, shell, SQL, …) are judged as 150-line chunks.
+
+## How it works
+
+1. `tree-sitter` splits the repo into functions.
+2. Each function goes into **its own** Jev question (never a shared list — positional
+   lookup degrades past ~16 items; embedding per question is flat to 128+).
+3. ~110 questions per request, 4 requests in flight, ~$0.00001 per function
+   (~300 input tokens each, measured on `psf/requests` and `gin-gonic/gin`).
+4. Scores are ranked; anything within ±0.10 of the threshold is asked again and averaged.
+
+Measured against the bundled labelled set (`every --selftest`, 10 functions that swallow
+errors, 10 that don't, live `jev-latest` on 2026-09-16): **recall 10/10, AUROC 1.000**;
+positives scored 0.82–0.98, negatives 0.05–0.29 — except one deliberately borderline
+negative (a retry loop that discards every failure but the last) at 0.68. The default
+`--above 0.75` sits in that gap. This is 20 hand-written functions, not a benchmark; it
+shows the model separates the two sets, not how it will score your question.
+
+## Limits, honestly
+
+- One function at a time. Cross-file questions get callers/callees; whole-program
+  data flow is out of scope for v1 and is labelled partial.
+- The ranking is the reliable part; the absolute numbers move with the question. Broad
+  questions ("makes a network request") put most of an HTTP library above 0.75; narrow
+  ones put a handful. Read the top of the list and set `--above` from that.
+- No explanations. Jev returns a probability, not a sentence.
+
+MIT.

every_cli-0.1.0/README.md

@@ -0,0 +1,101 @@
+# every
+
+**Ask a yes/no question of every function in a codebase. Ranked answers in seconds, for cents.**
+
+```
+$ every "catches an exception and then ignores it" ./my-api
+
+scanned 1,842 functions in 214 files ...   3.1s   $0.03   class: body
+
+ 0.93  src/payments/webhook.py:88     handle_stripe_event
+ 0.88  src/auth/session.py:141        refresh_token
+ 0.84  src/jobs/retry.py:22           _run_once
+ 0.79  src/db/pool.py:57              _reconnect
+ 0.52  src/utils/cache.py:19          get                (below 0.75)
+
+ 4 hits >= 0.75 out of 1,842 functions
+```
+
+`every` is grep whose pattern is a question. It is **not** embedding search: it does not
+find code *similar to* your words. It judges the question against **every function** and
+returns the probability that the answer is yes.
+
+It runs on [TypeSafe AI's Jev](https://typesafe.ai), a model that returns typed decisions
+with probabilities instead of generating text. That is what makes judging 5,000 functions
+cost about seven cents and take about fifteen seconds (measured: 1,302 functions of
+`gin-gonic/gin` in 3.7 s for $0.018).
+
+## Install
+
+```
+pip install every-cli          # installs the `every` command
+export TYPESAFE_API_KEY=...      # PowerShell: $env:TYPESAFE_API_KEY="..."
+every --selftest                # 20 labelled functions, one request; prints recall / false positives / AUROC
+```
+
+### No Jev access yet?
+
+`every` needs a Jev API key. If you don't have one, **join the hosted-tier waitlist:**
+https://github.com/sufianetaouil/every/discussions/1 — enough signups and we build the
+hosted version (no key, no setup). Meanwhile, `examples/recorded/` has real runs you can read.
+
+## What leaves your machine
+
+The source of every function in the files `every` scans is sent to TypeSafe's API
+(`api.typesafe.ai`) to be judged. Nothing else is sent. The local cache
+`.every/cache.json` stores only `sha256(question, unit text) -> score`, never source.
+Don't point `every` at code you can't send to a third party.
+
+## Usage
+
+```
+every "<question>" <path> [--above 0.75] [--top 20] [--json] [--yes] [--no-cache]
+```
+
+Questions that work well are about **one function at a time**:
+
+- "builds SQL by string concatenation"
+- "reads request data without checking authentication"
+- "returns a user record that still contains the password hash"
+- "is a test that doesn't assert anything"
+- "retries in a loop with no upper bound"
+
+`every` classifies your question first. If it needs a function's callers and callees, it
+includes them. If it needs whole-program data flow, results are marked
+`coverage: partial` — it will not pretend.
+
+`--json` (automatic when piping) prints `{"results": [...], "meta": {...}}`; `meta` has
+tokens, cost, requests and timing. Scores are cached in `.every/` so a re-run or a
+refined question only pays for what's new.
+
+## Languages
+
+Function-level: Python, JavaScript, TypeScript/TSX, Go, Java, Rust, C#, Ruby, PHP.
+Other source files (C/C++, Kotlin, Swift, Scala, shell, SQL, …) are judged as 150-line chunks.
+
+## How it works
+
+1. `tree-sitter` splits the repo into functions.
+2. Each function goes into **its own** Jev question (never a shared list — positional
+   lookup degrades past ~16 items; embedding per question is flat to 128+).
+3. ~110 questions per request, 4 requests in flight, ~$0.00001 per function
+   (~300 input tokens each, measured on `psf/requests` and `gin-gonic/gin`).
+4. Scores are ranked; anything within ±0.10 of the threshold is asked again and averaged.
+
+Measured against the bundled labelled set (`every --selftest`, 10 functions that swallow
+errors, 10 that don't, live `jev-latest` on 2026-09-16): **recall 10/10, AUROC 1.000**;
+positives scored 0.82–0.98, negatives 0.05–0.29 — except one deliberately borderline
+negative (a retry loop that discards every failure but the last) at 0.68. The default
+`--above 0.75` sits in that gap. This is 20 hand-written functions, not a benchmark; it
+shows the model separates the two sets, not how it will score your question.
+
+## Limits, honestly
+
+- One function at a time. Cross-file questions get callers/callees; whole-program
+  data flow is out of scope for v1 and is labelled partial.
+- The ranking is the reliable part; the absolute numbers move with the question. Broad
+  questions ("makes a network request") put most of an HTTP library above 0.75; narrow
+  ones put a handful. Read the top of the list and set `--above` from that.
+- No explanations. Jev returns a probability, not a sentence.
+
+MIT.

every_cli-0.1.0/every/__init__.py

@@ -0,0 +1,3 @@
+"""every - ask a yes/no question of every function in a codebase."""
+
+__version__ = "0.1.0"

every_cli-0.1.0/every/cache.py

@@ -0,0 +1,65 @@
+"""Per-repo score cache so re-runs and refined questions only pay for new judgments."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+
+AUTOSAVE_EVERY = 50
+
+
+class Cache:
+    def __init__(self, root: str, enabled: bool = True) -> None:
+        self.enabled = enabled
+        self.dir = os.path.join(root, ".every")
+        self.path = os.path.join(self.dir, "cache.json")
+        self.data: dict = {}
+        self.hits = 0
+        self._dirty = 0
+        if enabled and os.path.isfile(self.path):
+            try:
+                with open(self.path, encoding="utf-8") as fh:
+                    self.data = json.load(fh)
+            except (OSError, ValueError):
+                self.data = {}
+            if not isinstance(self.data, dict):
+                self.data = {}
+
+    @staticmethod
+    def key(question: str, mode: str, text: str) -> str:
+        norm = " ".join(question.lower().split())
+        return hashlib.sha256(f"{norm}\x00{mode}\x00{text}".encode("utf-8")).hexdigest()
+
+    def get(self, key: str):
+        if not self.enabled:
+            return None
+        score = self.data.get(key)
+        if score is not None:
+            self.hits += 1
+        return score
+
+    def put(self, key: str, score: float) -> None:
+        if not self.enabled:
+            return
+        self.data[key] = score
+        self._dirty += 1
+        if self._dirty >= AUTOSAVE_EVERY:
+            self.save()
+
+    def save(self) -> None:
+        if not self.enabled:
+            return
+        try:
+            os.makedirs(self.dir, exist_ok=True)
+            ignore = os.path.join(self.dir, ".gitignore")
+            if not os.path.isfile(ignore):
+                with open(ignore, "w", encoding="utf-8") as fh:
+                    fh.write("*\n")
+            tmp = self.path + ".tmp"
+            with open(tmp, "w", encoding="utf-8") as fh:
+                json.dump(self.data, fh)
+            os.replace(tmp, self.path)
+        except OSError:
+            return
+        self._dirty = 0

every_cli-0.1.0/every/classify.py

@@ -0,0 +1,23 @@
+"""Decide how much context a question needs before we look at any code (Layer 1)."""
+
+from __future__ import annotations
+
+from .judge import Judge
+
+CLASSES = {
+    "body": "Answerable by reading one function's own source code, with no other code.",
+    "neighborhood": "Needs the function plus what it directly calls or what directly calls it.",
+    "global": "Needs reasoning across many functions or files: data flow, reachability, "
+              "or configuration that lives elsewhere in the repository.",
+}
+INSTRUCTIONS = (
+    "A tool will ask this question about every function in a code repository, one "
+    "function at a time. Choose how much surrounding code is needed to answer it "
+    "reliably for a single function."
+)
+DEFAULT = "neighborhood"
+
+
+def classify(question: str, judge: Judge) -> str:
+    choice = judge.choice({"question": question}, INSTRUCTIONS, CLASSES)
+    return choice if choice in CLASSES else DEFAULT

every_cli-0.1.0/every/cli.py

@@ -0,0 +1,239 @@
+"""every - ask a yes/no question of every function in a codebase."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import time
+from collections import Counter
+
+from . import __version__
+from .cache import Cache
+from .classify import classify
+from .discover import discover
+from .extract import extract_all
+from .judge import Item, Judge, Unauthorized, pack
+from .neighborhood import stage1_text, stage2_text
+from .report import build_rows, render_json, render_table, select_rows
+from .symbols import SymbolIndex
+from .units import DEFAULT_ABOVE, REQUEST_FIXED_TOKENS, USD_PER_INPUT_TOKEN
+
+WAITLIST_URL = os.environ.get("EVERY_WAITLIST_URL", "https://github.com/sufianetaouil/every/discussions/1")
+NO_KEY_MESSAGE = (
+    "every runs on TypeSafe Jev and needs TYPESAFE_API_KEY.\n"
+    "No access yet? Join the hosted-tier waitlist: {url}\n"
+)
+CANDIDATE_FLOOR = 0.30
+CANDIDATE_CAP = 200
+CONFIRM_ABOVE_USD = 1.0
+
+
+def parse_args(argv):
+    p = argparse.ArgumentParser(prog="every",
+                                description="Ask a yes/no question of every function in a codebase.")
+    p.add_argument("question", nargs="?", help="a yes/no question about a single function")
+    p.add_argument("path", nargs="?", help="directory to scan")
+    p.add_argument("--above", type=float, default=DEFAULT_ABOVE,
+                  help="score at/above which a result is a hit (default 0.50)")
+    p.add_argument("--top", type=int, default=20, help="rows to show (default 20)")
+    p.add_argument("--json", action="store_true", help="JSON output (automatic when stdout is not a TTY)")
+    p.add_argument("--yes", action="store_true", help="skip the cost confirmation")
+    p.add_argument("--no-cache", action="store_true", help="ignore and do not write .every/cache.json")
+    p.add_argument("--depth", type=int, default=4, help=argparse.SUPPRESS)
+    p.add_argument("--budget", type=int, default=45_000, help=argparse.SUPPRESS)
+    p.add_argument("--selftest", action="store_true", help="run the bundled labelled set and print metrics")
+    p.add_argument("--version", action="store_true")
+    return p.parse_args(argv)
+
+
+def make_repo_card(root: str, files, units) -> dict:
+    langs = Counter(f.lang for f in files).most_common(3)
+    top_level = sorted({f.path.split("/")[0] for f in files if "/" in f.path})[:12]
+    return {"name": os.path.basename(os.path.abspath(root)) or root,
+            "languages": [l for l, _ in langs], "top_level": top_level,
+            "files": len(files), "functions": len(units)}
+
+
+def _payload(u, text: str) -> dict:
+    return {"file": u.file, "name": u.name, "language": u.lang, "kind": u.kind,
+            "lines": f"{u.start_line}-{u.end_line}", "source": text}
+
+
+def _estimate(items, budget: int) -> tuple[int, float]:
+    tokens = sum(it.est for it in items) + REQUEST_FIXED_TOKENS * max(1, len(pack(items, budget)))
+    return tokens, tokens * USD_PER_INPUT_TOKEN
+
+
+def _meta(args, root, files, units, unsupported, cls, coverage, stats, seconds, partial, cache_hits,
+         model) -> dict:
+    return {
+        "question": args.question, "class": cls, "coverage": coverage, "path": root,
+        "files": len(files), "units": len(units), "unsupported_files": unsupported,
+        "requests": stats.requests if stats else 0, "input_tokens": stats.input_tokens if stats else 0,
+        "output_tokens": stats.output_tokens if stats else 0,
+        "cost_usd": (stats.input_tokens if stats else 0) * USD_PER_INPUT_TOKEN, "seconds": seconds,
+        "above": args.above, "partial": partial, "cache_hits": cache_hits,
+        "failed_units": stats.failed if stats else 0, "model": model,
+    }
+
+
+def confirm_cost(est_cost: float, err) -> bool:
+    """Ask on stderr; refuse cleanly when stdin is not interactive."""
+    stdin = sys.stdin
+    if not (hasattr(stdin, "isatty") and stdin.isatty()):
+        print(f"estimated cost ${est_cost:.2f} exceeds ${CONFIRM_ABOVE_USD:.2f}; "
+              f"re-run with --yes to proceed", file=err)
+        return False
+    print(f"estimated cost ${est_cost:.2f} - proceed? [y/N] ", file=err, end="", flush=True)
+    try:
+        answer = stdin.readline()
+    except (EOFError, OSError):
+        return False
+    return answer.strip().lower() in ("y", "yes")
+
+
+def run_query(args, judge: Judge, out, err) -> int:
+    root = os.path.abspath(args.path)
+    files = discover(root)
+    units, unsupported = extract_all(root, files)
+    if not units:
+        print("no functions found", file=err)
+        rows = []
+        meta = _meta(args, root, files, units, unsupported, "body", "full", None, 0.0, False, 0,
+                    judge_model(judge))
+        use_json = args.json or not (hasattr(out, "isatty") and out.isatty())
+        if use_json:
+            print(render_json(select_rows(rows, args.above, args.top), meta), file=out)
+        else:
+            color = hasattr(out, "isatty") and out.isatty()
+            print(render_table(rows, meta, args.above, args.top, color), file=out)
+        return 0
+    index = SymbolIndex(units)
+    scores: dict = {}
+    stage: dict = {}
+    keys: dict = {}
+    by_id = {u.id: u for u in units}
+    cache = Cache(root, enabled=not args.no_cache)
+    cls = "neighborhood"
+    coverage = "partial"
+    items1 = []
+    stats = None
+    partial = False
+    t0 = time.perf_counter()
+
+    def prepare(candidates, mode, text_for):
+        items = []
+        for u in candidates:
+            text = text_for(u)
+            k = Cache.key(args.question, mode, text)
+            cached = cache.get(k)
+            if cached is not None:
+                scores[u.id] = cached
+                stage[u.id] = int(mode[-1])
+                continue
+            keys[u.id] = k
+            items.append(Item(u.id, _payload(u, text)))
+        return items
+
+    def on_result(got):
+        for uid, s in got.items():
+            scores[uid] = s
+            cache.put(keys[uid], s)
+
+    try:
+        cls = classify(args.question, judge)
+        coverage = "partial" if cls == "global" else "full"
+        repo_card = make_repo_card(root, files, units)
+
+        text1 = (lambda u: u.source) if cls == "body" else (lambda u: stage1_text(u, index))
+        items1 = prepare(units, f"{cls}:1", text1)
+        est_tokens, est_cost = _estimate(items1, args.budget)
+        print(f"scanned {len(units):,} functions in {len(files):,} files   class: {cls}   "
+              f"~{est_tokens:,} tokens ~${est_cost:.3f}" + ("   (from cache)" if not items1 else ""), file=err)
+        if est_cost > CONFIRM_ABOVE_USD and not args.yes:
+            if not confirm_cost(est_cost, err):
+                return 2
+
+        t0 = time.perf_counter()
+        for it in items1:
+            stage[it.id] = 1
+        if cls == "body":
+            s1, stats = judge.judge_with_reask(items1, args.question, repo_card, above=args.above, on_result=on_result)
+        else:
+            s1, stats = judge.judge(items1, args.question, repo_card, on_result=on_result)
+        scores.update(s1)
+        for uid, s in s1.items():
+            if uid in keys:
+                cache.put(keys[uid], s)
+        if cls != "body":
+            cands = [by_id[uid] for uid, s in scores.items() if s >= CANDIDATE_FLOOR]
+            cands.sort(key=lambda u: -scores[u.id])
+            cands = cands[:CANDIDATE_CAP]
+            items2 = prepare(cands, f"{cls}:2", lambda u: stage2_text(u, index))
+            for it in items2:
+                stage[it.id] = 2
+            s2, stats2 = judge.judge_with_reask(items2, args.question, repo_card, above=args.above, on_result=on_result)
+            scores.update(s2)
+            for uid, s in s2.items():
+                if uid in keys:
+                    cache.put(keys[uid], s)
+            stats = stats.merge(stats2)
+    except KeyboardInterrupt:
+        partial = True
+    finally:
+        cache.save()
+    seconds = time.perf_counter() - t0
+
+    rows = build_rows(units, scores, stage)
+    meta = _meta(args, root, files, units, unsupported, cls, coverage, stats, seconds, partial,
+                cache.hits, judge_model(judge))
+    if stats and stats.last_error:
+        print(f"error: {stats.last_error}", file=err)
+    use_json = args.json or not (hasattr(out, "isatty") and out.isatty())
+    if use_json:
+        print(render_json(select_rows(rows, args.above, args.top), meta), file=out)
+    else:
+        color = hasattr(out, "isatty") and out.isatty()
+        print(render_table(rows, meta, args.above, args.top, color), file=out)
+    return 130 if partial else 0
+
+
+def judge_model(judge: Judge) -> str:
+    from .judge import MODEL
+    return MODEL
+
+
+def main(argv=None, out=None, err=None) -> int:
+    out = out or sys.stdout
+    err = err or sys.stderr
+    args = parse_args(argv)
+    if args.version:
+        print(f"every {__version__}", file=out)
+        return 0
+    key = os.environ.get("TYPESAFE_API_KEY")
+    if not key:
+        print(NO_KEY_MESSAGE.format(url=WAITLIST_URL), file=err, end="")
+        return 2
+    judge = Judge(key, depth=args.depth, budget=args.budget)
+    if args.selftest:
+        from .selftest import run_selftest
+        return run_selftest(judge, out)
+    if not args.question or not args.path:
+        print("usage: every \"<question>\" <path>", file=err)
+        return 2
+    try:
+        return run_query(args, judge, out, err)
+    except KeyboardInterrupt:
+        print("interrupted", file=err)
+        return 130
+    except Unauthorized:
+        print("API key rejected (HTTP 401/403). Check TYPESAFE_API_KEY.", file=err)
+        return 2
+    except Exception as e:
+        print(f"error: {type(e).__name__}: {e}", file=err)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

every_cli-0.1.0/every/discover.py

@@ -0,0 +1,96 @@
+"""List the source files worth judging and decide how each will be split."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+
+# v1 languages with a function-level node map in extract.py.
+PARSED = {
+    ".py": "python",
+    ".js": "javascript", ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+    ".ts": "typescript", ".tsx": "tsx",
+    ".go": "go",
+    ".java": "java",
+    ".rs": "rust",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".php": "php",
+}
+# Recognised source, but judged as 150-line chunks in v1.
+CHUNKED = {
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".hpp": "cpp",
+    ".kt": "kotlin", ".swift": "swift", ".scala": "scala",
+    ".sh": "shell", ".bash": "shell", ".sql": "sql", ".m": "objc",
+    ".lua": "lua", ".pl": "perl", ".ex": "elixir", ".exs": "elixir",
+    ".erl": "erlang", ".dart": "dart",
+}
+EXCLUDE_DIRS = {
+    "node_modules", "vendor", "dist", "build", ".git", ".every", "__pycache__",
+    ".venv", "venv", "target", "bin", "obj", ".tox", ".mypy_cache", ".pytest_cache",
+}
+MAX_BYTES = 1_000_000
+GENERATED_SUFFIXES = (".lock", ".map", ".pb.go", "_pb2.py", ".generated.ts", ".g.cs")
+
+
+@dataclass
+class SourceFile:
+    path: str      # relative to root, forward slashes
+    lang: str
+    parsed: bool   # True -> tree-sitter units; False -> chunk fallback
+
+
+def language_for(path: str) -> tuple[str, bool] | None:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in PARSED:
+        return PARSED[ext], True
+    if ext in CHUNKED:
+        return CHUNKED[ext], False
+    return None
+
+
+def is_generated(path: str) -> bool:
+    name = os.path.basename(path).lower()
+    return ".min." in name or name.endswith(GENERATED_SUFFIXES)
+
+
+def _git_files(root: str) -> list[str] | None:
+    try:
+        r = subprocess.run(["git", "-C", root, "ls-files", "-z"], capture_output=True, timeout=60)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if r.returncode != 0:
+        return None
+    return [p for p in r.stdout.decode("utf-8", "replace").split("\0") if p]
+
+
+def _walk_files(root: str) -> list[str]:
+    out = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in EXCLUDE_DIRS]
+        for f in filenames:
+            rel = os.path.relpath(os.path.join(dirpath, f), root)
+            out.append(rel.replace(os.sep, "/"))
+    return out
+
+
+def discover(root: str) -> list[SourceFile]:
+    files = _git_files(root) if os.path.exists(os.path.join(root, ".git")) else None
+    if files is None:
+        files = _walk_files(root)
+    out: list[SourceFile] = []
+    for rel in sorted(files):
+        if any(part in EXCLUDE_DIRS for part in rel.split("/")[:-1]):
+            continue
+        info = language_for(rel)
+        if info is None or is_generated(rel):
+            continue
+        try:
+            size = os.path.getsize(os.path.join(root, rel))
+        except OSError:
+            continue   # tracked in git but missing on disk
+        if size == 0 or size > MAX_BYTES:
+            continue
+        out.append(SourceFile(rel, info[0], info[1]))
+    return out