every-cli 0.1.0__py3-none-any.whl

every/__init__.py

@@ -0,0 +1,3 @@
+"""every - ask a yes/no question of every function in a codebase."""
+
+__version__ = "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/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.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/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

every/extract.py

@@ -0,0 +1,137 @@
+"""Split source files into judgeable units with tree-sitter; chunk what we can't parse."""
+
+from __future__ import annotations
+
+import os
+
+from tree_sitter_language_pack import get_parser
+
+from .symbols import callee_names
+from .units import Unit
+
+# Function-like node types per v1 language. JS/TS assigned functions are handled separately.
+FUNC_NODES = {
+    "python": {"function_definition"},
+    "javascript": {"function_declaration", "generator_function_declaration", "method_definition"},
+    "typescript": {"function_declaration", "generator_function_declaration", "method_definition"},
+    "tsx": {"function_declaration", "generator_function_declaration", "method_definition"},
+    "go": {"function_declaration", "method_declaration"},
+    "java": {"method_declaration", "constructor_declaration"},
+    "rust": {"function_item"},
+    "csharp": {"method_declaration", "constructor_declaration"},
+    "ruby": {"method", "singleton_method"},
+    "php": {"function_definition", "method_declaration"},
+}
+JS_LANGS = {"javascript", "typescript", "tsx"}
+ASSIGNED_FUNC_VALUES = {"arrow_function", "function_expression", "function"}
+CHUNK_LINES = 150
+MAX_UNIT_CHARS = 3450   # ~1,500 tokens at the measured ratio
+
+_parsers: dict = {}
+
+
+def parser_for(lang: str):
+    if lang not in _parsers:
+        _parsers[lang] = get_parser(lang)
+    return _parsers[lang]
+
+
+def _text(node, src: bytes) -> str:
+    return src[node.start_byte:node.end_byte].decode("utf-8", "replace")
+
+
+def _lines(node) -> tuple[int, int]:
+    start = node.start_point[0] + 1
+    end = node.end_point[0] + 1
+    if node.end_point[1] == 0 and end > start:   # node ends at a line start: don't count that line
+        end -= 1
+    return start, end
+
+
+def _name_of(node, src: bytes) -> str:
+    n = node.child_by_field_name("name")
+    return _text(n, src) if n is not None else "<anonymous>"
+
+
+def _make_unit(rel: str, lang: str, name: str, node, src: bytes, prefix: str) -> Unit:
+    full = f"{prefix}.{name}" if prefix else name
+    start, end = _lines(node)
+    text = _text(node, src)
+    if len(text) > MAX_UNIT_CHARS:
+        text = text[:MAX_UNIT_CHARS] + "\n[truncated]"
+    return Unit(id=f"{rel}:{start}:{full}", file=rel, lang=lang, name=full,
+                start_line=start, end_line=end, source=text, kind="function",
+                calls=callee_names(node, lang, src))
+
+
+def _walk(node, rel: str, lang: str, src: bytes, prefix: str, out: list) -> None:
+    """Preorder walk with an explicit stack (deep nesting must not hit the recursion limit)."""
+    stack = [(node, prefix)]
+    while stack:
+        n, pfx = stack.pop()
+        unit_name = None
+        if n.type in FUNC_NODES[lang]:
+            unit_name = _name_of(n, src)
+            out.append(_make_unit(rel, lang, unit_name, n, src, pfx))
+        elif lang in JS_LANGS and n.type in ("variable_declarator", "pair"):
+            value = n.child_by_field_name("value")
+            if value is not None and value.type in ASSIGNED_FUNC_VALUES:
+                key = n.child_by_field_name("name") or n.child_by_field_name("key")
+                unit_name = _text(key, src) if key is not None else "<anonymous>"
+                out.append(_make_unit(rel, lang, unit_name, value, src, pfx))
+        child_prefix = pfx
+        if unit_name:
+            child_prefix = f"{pfx}.{unit_name}" if pfx else unit_name
+        for child in reversed(n.children):   # reversed so the first child is popped first
+            stack.append((child, child_prefix))
+
+
+def chunk_file(rel: str, lang: str, source: str, size: int = CHUNK_LINES) -> list[Unit]:
+    lines = source.splitlines()
+    out: list[Unit] = []
+    for i in range(0, len(lines), size):
+        start, end = i + 1, min(i + size, len(lines))
+        text = "\n".join(lines[i:end])
+        if len(text) > MAX_UNIT_CHARS:
+            text = text[:MAX_UNIT_CHARS] + "\n[truncated]"
+        out.append(Unit(id=f"{rel}:{start}:chunk", file=rel, lang=lang, name=f"chunk@{start}",
+                        start_line=start, end_line=end, source=text, kind="chunk"))
+    return out
+
+
+def extract_file(rel: str, lang: str, source: str) -> list[Unit]:
+    if lang not in FUNC_NODES:
+        return chunk_file(rel, lang, source)
+    src = source.encode("utf-8")
+    tree = parser_for(lang).parse(src)
+    out: list[Unit] = []
+    _walk(tree.root_node, rel, lang, src, "", out)
+    if not out and tree.root_node.has_error:
+        return chunk_file(rel, lang, source)
+    return out
+
+
+def extract_all(root: str, files) -> tuple[list[Unit], int]:
+    """Units for all files; second value counts files that were chunked or unreadable."""
+    units: list[Unit] = []
+    unsupported = 0
+    for f in files:
+        try:
+            with open(os.path.join(root, f.path), encoding="utf-8", errors="replace") as fh:
+                source = fh.read()
+        except OSError:
+            unsupported += 1
+            continue
+        try:
+            if f.parsed and f.lang in FUNC_NODES:
+                got = extract_file(f.path, f.lang, source)
+                if got and got[0].kind == "chunk":
+                    unsupported += 1
+            else:
+                got = chunk_file(f.path, f.lang, source)
+                unsupported += 1
+        except Exception:
+            unsupported += 1
+            continue
+        units.extend(got)
+    return units, unsupported