kinetic-context 0.2.1__py3-none-any.whl

kce/__init__.py

@@ -0,0 +1,5 @@
+"""kinetic-context — repository-level code context engine."""
+__version__ = "0.2.0"
+
+from .engine import KCEEngine  # noqa: F401
+from .config import KCEConfig  # noqa: F401

kce/_version.py

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

kce/assembly/__init__.py

@@ -0,0 +1,2 @@
+"""Context assembly: budget-aware hierarchical context building."""
+from __future__ import annotations

kce/assembly/context_builder.py

@@ -0,0 +1,41 @@
+"""Budget-aware hierarchical context assembly."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from ..config import KCEConfig
+from ..ingestion.chunker import CodeChunk, estimate_tokens
+
+@dataclass
+class ContextPackage:
+    system_prompt: str; repo_map: str; relevant_files: list[str]
+    primary_chunks: list[CodeChunk]; supporting_chunks: list[CodeChunk]
+    full_text: str; token_count: int; budget_used: dict = field(default_factory=dict)
+
+class ContextAssembler:
+    def __init__(self, config): self.config = config
+    def assemble(self, ranked_chunks, repo_map, file_summaries, system_prompt=""):
+        budget = self.config.context_budget_tokens
+        budgets = {"system": int(budget*0.05), "repo": int(budget*0.08), "files": int(budget*0.12), "primary": int(budget*0.60), "supporting": int(budget*0.15)}
+        deduped = self._dedup(ranked_chunks)
+        primary = []; supporting = []; used = 0; used_s = 0
+        for c in deduped:
+            ct = estimate_tokens(c.content)
+            if used + ct <= budgets["primary"]: primary.append(c); used += ct
+            elif used_s + ct <= budgets["supporting"]: supporting.append(c); used_s += ct
+        rel_files = {c.rel_path for c in primary + supporting}
+        rel_text = "\n".join(f"## {fp}\n{file_summaries.get(fp,'(no summary)')}" for fp in sorted(rel_files))
+        parts = [f"<system_prompt>\n{system_prompt}\n</system_prompt>\n"]
+        for c in primary: parts.append(f'<code_chunk role="primary" file="{c.rel_path}" lines="{c.start_line}-{c.end_line}">\n{c.content}\n</code_chunk>')
+        for c in supporting: parts.append(f'<code_chunk role="supporting" file="{c.rel_path}">\n{c.content}\n</code_chunk>')
+        parts.append(f"<relevant_files>\n{rel_text}\n</relevant_files>\n<repo_map>\n{repo_map}\n</repo_map>")
+        full = "\n\n".join(parts)
+        return ContextPackage(system_prompt=system_prompt, repo_map=repo_map, relevant_files=sorted(rel_files),
+            primary_chunks=primary, supporting_chunks=supporting, full_text=full, token_count=estimate_tokens(full),
+            budget_used={"primary": used, "supporting": used_s})
+    def _dedup(self, chunks):
+        seen_ids = set(); seen_ranges = set(); out = []
+        for c in chunks:
+            if c.chunk_id in seen_ids: continue
+            key = (c.rel_path, c.start_byte, c.end_byte)
+            if key in seen_ranges: continue
+            seen_ids.add(c.chunk_id); seen_ranges.add(key); out.append(c)
+        return out

kce/benchmark/__init__.py

@@ -0,0 +1,2 @@
+"""Benchmark datasets and metrics."""
+from __future__ import annotations

kce/benchmark/dataset.py

@@ -0,0 +1,334 @@
+"""Flask benchmark — 30 queries targeting real Flask source files.
+
+The benchmark is split across the five :class:`QueryType` categories
+to match the distribution KCE was tuned on:
+
+    *  6 IDENTIFIER_LOOKUP
+    * 11 SEMANTIC_QUESTION
+    *  5 ARCHITECTURE_QUERY
+    *  4 BUG_DIAGNOSIS
+    *  4 CODE_COMPLETION
+
+Each query carries:
+
+    * ``query``         — natural-language question
+    * ``query_type``    — expected QueryType
+    * ``gold_files``    — list of Flask source files (POSIX rel paths)
+                          that a correct answer must surface
+    * ``gold_symbols``  — optional list of symbol names that should
+                          appear in the retrieved chunks (used for
+                          finer-grained symbol-level evaluation)
+    * ``notes``         — free-text annotation
+
+The gold files are paths inside the Flask repository
+(``https://github.com/pallets/flask``); they are stable across the
+3.x line.  Where multiple files are equally correct we list them all
+and recall is computed as "fraction of gold found".
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from ..coordinator.query_coordinator import QueryType
+
+
+# --------------------------------------------------------------------------- #
+# Container
+# --------------------------------------------------------------------------- #
+@dataclass
+class BenchmarkQuery:
+    query: str
+    query_type: QueryType
+    gold_files: list[str] = field(default_factory=list)
+    gold_symbols: list[str] = field(default_factory=list)
+    notes: str = ""
+    id: str = ""
+
+
+# --------------------------------------------------------------------------- #
+# The 30 queries
+# --------------------------------------------------------------------------- #
+FLASK_BENCHMARK: list[BenchmarkQuery] = [
+    # ----------------------------------------------------------------- #
+    # IDENTIFIER_LOOKUP (6)
+    # ----------------------------------------------------------------- #
+    BenchmarkQuery(
+        id="flask-id-01",
+        query="app.config.from_object",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/config.py"],
+        gold_symbols=["from_object"],
+        notes="direct config loader",
+    ),
+    BenchmarkQuery(
+        id="flask-id-02",
+        query="Flask.run",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/app.py"],
+        gold_symbols=["run"],
+        notes="dev server entrypoint",
+    ),
+    BenchmarkQuery(
+        id="flask-id-03",
+        query="url_for",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/helpers.py", "src/flask/app.py"],
+        gold_symbols=["url_for"],
+        notes="URL builder helper",
+    ),
+    BenchmarkQuery(
+        id="flask-id-04",
+        query="request.json",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/wrappers.py", "src/flask/json"],
+        gold_symbols=["json"],
+        notes="JSON body accessor on Request",
+    ),
+    BenchmarkQuery(
+        id="flask-id-05",
+        query="g",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/globals.py", "src/flask/ctx.py"],
+        gold_symbols=["g"],
+        notes="request-scoped global namespace",
+    ),
+    BenchmarkQuery(
+        id="flask-id-06",
+        query="current_app",
+        query_type=QueryType.IDENTIFIER_LOOKUP,
+        gold_files=["src/flask/globals.py", "src/flask/ctx.py"],
+        gold_symbols=["current_app"],
+        notes="proxy to the active Flask application",
+    ),
+
+    # ----------------------------------------------------------------- #
+    # SEMANTIC_QUESTION (11)
+    # ----------------------------------------------------------------- #
+    BenchmarkQuery(
+        id="flask-sem-01",
+        query="How does Flask route an incoming HTTP request to a view function?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/app.py", "src/flask/sansio/app.py"],
+        gold_symbols=["dispatch_request", "full_dispatch_request", "url_map"],
+        notes="request dispatch flow",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-02",
+        query="How does the Flask test client work?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/testing.py", "src/flask/test.py"],
+        gold_symbols=["FlaskClient", "test_client"],
+        notes="test client wrapper around Werkzeug",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-03",
+        query="How does Flask handle URL building with url_for?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/helpers.py", "src/flask/app.py"],
+        gold_symbols=["url_for"],
+        notes="URL builder flow",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-04",
+        query="How does Flask manage the application context and request context?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/ctx.py", "src/flask/globals.py"],
+        gold_symbols=["AppContext", "RequestContext", "push", "pop"],
+        notes="context lifecycle",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-05",
+        query="How does Flask register blueprints?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/blueprints.py", "src/flask/sansio/blueprints.py", "src/flask/app.py"],
+        gold_symbols=["Blueprint", "register_blueprint"],
+        notes="blueprint registration",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-06",
+        query="How does Flask parse and validate configuration from environment variables?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/config.py"],
+        gold_symbols=["Config", "from_envvar", "from_prefixed_env"],
+        notes="config loading",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-07",
+        query="How does Flask serialise JSON responses?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/json/provider.py", "src/flask/json/__init__.py"],
+        gold_symbols=["DefaultJSONProvider", "jsonify"],
+        notes="JSON provider abstraction",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-08",
+        query="How does Flask handle sessions and signed cookies?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/sessions.py"],
+        gold_symbols=["SecureCookieSessionInterface", "SessionInterface"],
+        notes="session interface",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-09",
+        query="How does Flask implement template rendering with Jinja2?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/templating.py", "src/flask/app.py"],
+        gold_symbols=["render_template", "render_template_string", "create_jinja_environment"],
+        notes="template rendering",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-10",
+        query="How does Flask handle errors and register custom error handlers?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/app.py", "src/flask/sansio/app.py"],
+        gold_symbols=["register_error_handler", "handle_exception", "handle_http_exception"],
+        notes="error handler registration",
+    ),
+    BenchmarkQuery(
+        id="flask-sem-11",
+        query="How does Flask implement the before_request and after_request hooks?",
+        query_type=QueryType.SEMANTIC_QUESTION,
+        gold_files=["src/flask/app.py", "src/flask/sansio/scaffold.py"],
+        gold_symbols=["before_request", "after_request", "teardown_request"],
+        notes="request lifecycle hooks",
+    ),
+
+    # ----------------------------------------------------------------- #
+    # ARCHITECTURE_QUERY (5)
+    # ----------------------------------------------------------------- #
+    BenchmarkQuery(
+        id="flask-arch-01",
+        query="Show me the module structure of the Flask application class",
+        query_type=QueryType.ARCHITECTURE_QUERY,
+        gold_files=["src/flask/app.py", "src/flask/sansio/app.py"],
+        gold_symbols=["Flask", "App"],
+        notes="App class layout",
+    ),
+    BenchmarkQuery(
+        id="flask-arch-02",
+        query="What is the architecture of the Flask request and response wrappers?",
+        query_type=QueryType.ARCHITECTURE_QUERY,
+        gold_files=["src/flask/wrappers.py"],
+        gold_symbols=["Request", "Response"],
+        notes="wrapper class hierarchy",
+    ),
+    BenchmarkQuery(
+        id="flask-arch-03",
+        query="Describe the class hierarchy of the Flask session interfaces",
+        query_type=QueryType.ARCHITECTURE_QUERY,
+        gold_files=["src/flask/sessions.py"],
+        gold_symbols=["SessionInterface", "SecureCookieSessionInterface", "SessionMixin"],
+        notes="session interface inheritance",
+    ),
+    BenchmarkQuery(
+        id="flask-arch-04",
+        query="What is the module layout of the Flask JSON package?",
+        query_type=QueryType.ARCHITECTURE_QUERY,
+        gold_files=["src/flask/json/__init__.py", "src/flask/json/provider.py"],
+        gold_symbols=["provider", "JSONProvider"],
+        notes="json subpackage layout",
+    ),
+    BenchmarkQuery(
+        id="flask-arch-05",
+        query="Show me the directory structure of the Flask templating subsystem",
+        query_type=QueryType.ARCHITECTURE_QUERY,
+        gold_files=["src/flask/templating.py", "src/flask/app.py"],
+        gold_symbols=["Environment", "DispatchingJinjaLoader", "render_template"],
+        notes="templating subsystem structure",
+    ),
+
+    # ----------------------------------------------------------------- #
+    # BUG_DIAGNOSIS (4)
+    # ----------------------------------------------------------------- #
+    BenchmarkQuery(
+        id="flask-bug-01",
+        query="AttributeError: 'Flask' object has no attribute 'before_first_request' on Flask 3.x",
+        query_type=QueryType.BUG_DIAGNOSIS,
+        gold_files=["src/flask/app.py"],
+        gold_symbols=["before_first_request"],
+        notes="removed in Flask 3.x; users must use before_request",
+    ),
+    BenchmarkQuery(
+        id="flask-bug-02",
+        query="RuntimeError: Working outside of application context when accessing current_app",
+        query_type=QueryType.BUG_DIAGNOSIS,
+        gold_files=["src/flask/ctx.py", "src/flask/globals.py"],
+        gold_symbols=["AppContext", "current_app", "push"],
+        notes="context not pushed",
+    ),
+    BenchmarkQuery(
+        id="flask-bug-03",
+        query="ImportError: cannot import name 'flask' from 'flask' — circular import",
+        query_type=QueryType.BUG_DIAGNOSIS,
+        gold_files=["src/flask/__init__.py"],
+        gold_symbols=[],
+        notes="circular import in __init__",
+    ),
+    BenchmarkQuery(
+        id="flask-bug-04",
+        query="TypeError: __init__() got an unexpected keyword argument 'subdomain_matching' when creating Flask app",
+        query_type=QueryType.BUG_DIAGNOSIS,
+        gold_files=["src/flask/app.py", "src/flask/sansio/app.py"],
+        gold_symbols=["Flask", "__init__"],
+        notes="argument removed/renamed across versions",
+    ),
+
+    # ----------------------------------------------------------------- #
+    # CODE_COMPLETION (4)
+    # ----------------------------------------------------------------- #
+    BenchmarkQuery(
+        id="flask-cc-01",
+        query="Complete a Flask route that returns JSON for a GET /api/users endpoint",
+        query_type=QueryType.CODE_COMPLETION,
+        gold_files=["src/flask/app.py", "src/flask/json/__init__.py"],
+        gold_symbols=["route", "jsonify"],
+        notes="route + jsonify",
+    ),
+    BenchmarkQuery(
+        id="flask-cc-02",
+        query="Implement a Flask before_request hook that loads the current user from a session cookie",
+        query_type=QueryType.CODE_COMPLETION,
+        gold_files=["src/flask/app.py", "src/flask/ctx.py", "src/flask/sessions.py"],
+        gold_symbols=["before_request", "session"],
+        notes="auth hook",
+    ),
+    BenchmarkQuery(
+        id="flask-cc-03",
+        query="Write a Flask blueprint that registers a JSON error handler for 404",
+        query_type=QueryType.CODE_COMPLETION,
+        gold_files=["src/flask/blueprints.py", "src/flask/sansio/blueprints.py"],
+        gold_symbols=["Blueprint", "register_error_handler", "jsonify"],
+        notes="blueprint error handler",
+    ),
+    BenchmarkQuery(
+        id="flask-cc-04",
+        query="Complete a Flask CLI command that initialises the database",
+        query_type=QueryType.CODE_COMPLETION,
+        gold_files=["src/flask/cli.py", "src/flask/app.py"],
+        gold_symbols=["AppGroup", "command", "with_appcontext"],
+        notes="CLI command with appcontext",
+    ),
+]
+
+
+# --------------------------------------------------------------------------- #
+# Convenience accessors
+# --------------------------------------------------------------------------- #
+def get_benchmark() -> list[BenchmarkQuery]:
+    """Return the full Flask benchmark (30 queries)."""
+    return list(FLASK_BENCHMARK)
+
+
+def get_queries_by_type(query_type: QueryType) -> list[BenchmarkQuery]:
+    """Filter the benchmark by :class:`QueryType`."""
+    return [q for q in FLASK_BENCHMARK if q.query_type == query_type]
+
+
+def benchmark_summary() -> dict[str, int]:
+    """Return a count of queries per type."""
+    out: dict[str, int] = {}
+    for q in FLASK_BENCHMARK:
+        out[q.query_type.value] = out.get(q.query_type.value, 0) + 1
+    out["total"] = len(FLASK_BENCHMARK)
+    return out

kce/benchmark/django_dataset.py

@@ -0,0 +1,42 @@
+"""Django benchmark dataset — 30 queries with verified gold files."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+@dataclass
+class BenchmarkQuery:
+    qid: str; query: str; query_type: str; relevant_files: list[str]; relevant_keywords: list[str] = field(default_factory=list)
+
+DATASET = [
+    BenchmarkQuery("d01","QuerySet","identifier_lookup",["django/db/models/query.py"],["QuerySet"]),
+    BenchmarkQuery("d02","ModelBase","identifier_lookup",["django/db/models/base.py"],["ModelBase","Model"]),
+    BenchmarkQuery("d03","HttpRequest","identifier_lookup",["django/http/request.py"],["HttpRequest"]),
+    BenchmarkQuery("d04","WSGIHandler","identifier_lookup",["django/core/handlers/wsgi.py"],["WSGIHandler"]),
+    BenchmarkQuery("d05","BaseForm","identifier_lookup",["django/forms/forms.py"],["BaseForm","Form"]),
+    BenchmarkQuery("d06","URLResolver","identifier_lookup",["django/urls/resolvers.py"],["URLResolver","URLPattern"]),
+    BenchmarkQuery("d07","how does the ORM QuerySet work","semantic_question",["django/db/models/query.py"],["QuerySet","filter","iterator"]),
+    BenchmarkQuery("d08","how does the URL resolver match patterns","semantic_question",["django/urls/resolvers.py"],["URLResolver","resolve","match"]),
+    BenchmarkQuery("d09","how does Django process WSGI requests","semantic_question",["django/core/handlers/wsgi.py"],["WSGIHandler","WSGIRequest"]),
+    BenchmarkQuery("d10","how does the template engine parse and render","semantic_question",["django/template/base.py"],["Template","Token","Lexer"]),
+    BenchmarkQuery("d11","how does Django handle CSRF protection","semantic_question",["django/middleware/csrf.py"],["CSRF","token","middleware"]),
+    BenchmarkQuery("d12","how does the password hashing work","semantic_question",["django/contrib/auth/hashers.py"],["check_password","make_password","hasher"]),
+    BenchmarkQuery("d13","how does Django send email","semantic_question",["django/core/mail/__init__.py"],["send_mail","EmailMessage"]),
+    BenchmarkQuery("d14","how do database transactions work","semantic_question",["django/db/transaction.py"],["atomic","commit","rollback"]),
+    BenchmarkQuery("d15","how does form validation work","semantic_question",["django/forms/forms.py"],["BaseForm","is_valid","clean"]),
+    BenchmarkQuery("d16","how does the session backend store data","semantic_question",["django/contrib/sessions/backends/db.py"],["SessionStore","SessionBase"]),
+    BenchmarkQuery("d17","how does Django load templates","semantic_question",["django/template/loader.py"],["get_template","render_to_string"]),
+    BenchmarkQuery("d18","what is the structure of the auth models","architecture_query",["django/contrib/auth/models.py"],["User","Group","Permission"]),
+    BenchmarkQuery("d19","what are the HTTP response classes","architecture_query",["django/http/response.py"],["HttpResponse","JsonResponse"]),
+    BenchmarkQuery("d20","what validators does Django provide","architecture_query",["django/core/validators.py"],["RegexValidator","URLValidator"]),
+    BenchmarkQuery("d21","what field types does the ORM support","architecture_query",["django/db/models/fields/__init__.py"],["CharField","IntegerField"]),
+    BenchmarkQuery("d22","what is the management command structure","architecture_query",["django/core/management/base.py"],["BaseCommand","CommandError"]),
+    BenchmarkQuery("d23","TransactionManagementError atomic block","bug_diagnosis",["django/db/transaction.py"],["TransactionManagementError"]),
+    BenchmarkQuery("d24","VariableDoesNotExist template rendering error","bug_diagnosis",["django/template/base.py"],["VariableDoesNotExist"]),
+    BenchmarkQuery("d25","BadHeaderError HttpResponse header injection","bug_diagnosis",["django/http/response.py"],["BadHeaderError"]),
+    BenchmarkQuery("d26","CommandError management command failure","bug_diagnosis",["django/core/management/base.py"],["CommandError","CommandParser"]),
+    BenchmarkQuery("d27","models.ForeignKey(","code_completion",["django/db/models/fields/related.py"],["ForeignKey"]),
+    BenchmarkQuery("d28","forms.ModelForm(","code_completion",["django/forms/models.py"],["ModelForm"]),
+    BenchmarkQuery("d29","transaction.atomic(","code_completion",["django/db/transaction.py"],["atomic"]),
+    BenchmarkQuery("d30","send_mail(","code_completion",["django/core/mail/__init__.py"],["send_mail"]),
+]
+
+def load_dataset(): return list(DATASET)

kce/benchmark/flask_dataset.py

@@ -0,0 +1,42 @@
+"""Flask benchmark dataset — 30 queries."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+@dataclass
+class BenchmarkQuery:
+    qid: str; query: str; query_type: str; relevant_files: list[str]; relevant_keywords: list[str] = field(default_factory=list)
+
+DATASET = [
+    BenchmarkQuery("f01","Flask","identifier_lookup",["src/flask/app.py","src/flask/__init__.py"],["Flask"]),
+    BenchmarkQuery("f02","Blueprint","identifier_lookup",["src/flask/blueprints.py","src/flask/sansio/blueprints.py"],["Blueprint"]),
+    BenchmarkQuery("f03","request","identifier_lookup",["src/flask/globals.py","src/flask/wrappers.py"],["request"]),
+    BenchmarkQuery("f04","session","identifier_lookup",["src/flask/sessions.py","src/flask/globals.py"],["session"]),
+    BenchmarkQuery("f05","current_app","identifier_lookup",["src/flask/globals.py","src/flask/ctx.py"],["current_app"]),
+    BenchmarkQuery("f06","g","identifier_lookup",["src/flask/globals.py","src/flask/ctx.py"],["g"]),
+    BenchmarkQuery("f07","how does routing work in flask","semantic_question",["src/flask/sansio/scaffold.py","src/flask/app.py"],["route","url_map"]),
+    BenchmarkQuery("f08","how does the request context get pushed and popped","semantic_question",["src/flask/ctx.py"],["RequestContext","push","pop"]),
+    BenchmarkQuery("f09","how are templates rendered","semantic_question",["src/flask/templating.py","src/flask/helpers.py"],["render_template"]),
+    BenchmarkQuery("f10","how does the session cookie get signed and validated","semantic_question",["src/flask/sessions.py"],["SecureCookieSessionInterface","secret_key"]),
+    BenchmarkQuery("f11","how are url converters and rules defined","semantic_question",["src/flask/sansio/scaffold.py"],["url_rule","converter","url_map"]),
+    BenchmarkQuery("f12","how does flask handle json serialization and deserialization","semantic_question",["src/flask/json/__init__.py","src/flask/json/provider.py"],["JSONProvider","jsonify"]),
+    BenchmarkQuery("f13","how does the cli command registration work","semantic_question",["src/flask/cli.py"],["FlaskGroup","AppGroup","command"]),
+    BenchmarkQuery("f14","how are errors and http exceptions handled","semantic_question",["src/flask/app.py","src/flask/helpers.py"],["errorhandler","HTTPException","abort"]),
+    BenchmarkQuery("f15","how does flask read configuration from environment and files","semantic_question",["src/flask/config.py"],["Config","from_object","from_envvar"]),
+    BenchmarkQuery("f16","how do before and after request hooks work","semantic_question",["src/flask/sansio/scaffold.py","src/flask/app.py"],["before_request","after_request"]),
+    BenchmarkQuery("f17","how does the test client make requests","semantic_question",["src/flask/testing.py"],["FlaskClient","test_client"]),
+    BenchmarkQuery("f18","what is the overall architecture of the flask package","architecture_query",["src/flask/__init__.py","src/flask/app.py"],[]),
+    BenchmarkQuery("f19","what are the main building blocks of flask sansio modules","architecture_query",["src/flask/sansio/scaffold.py","src/flask/sansio/app.py","src/flask/sansio/blueprints.py"],[]),
+    BenchmarkQuery("f20","Request Response Response body wrappers","architecture_query",["src/flask/wrappers.py"],["Request","Response"]),
+    BenchmarkQuery("f21","what classes are in the json module","architecture_query",["src/flask/json/__init__.py","src/flask/json/provider.py"],["JSONProvider"]),
+    BenchmarkQuery("f22","AppContext RequestContext context hierarchy","architecture_query",["src/flask/ctx.py"],["AppContext","RequestContext"]),
+    BenchmarkQuery("f23","BadRequestKeyError 400 bad request key not found","bug_diagnosis",["src/flask/debughelpers.py","src/flask/sansio/scaffold.py"],["BadRequestKeyError"]),
+    BenchmarkQuery("f24","DebugFilesPayload files missing error","bug_diagnosis",["src/flask/debughelpers.py"],["DebugFilesPayload"]),
+    BenchmarkQuery("f25","AssertionError view function endpoint mapping required","bug_diagnosis",["src/flask/sansio/scaffold.py","src/flask/debughelpers.py"],["AssertionError","endpoint"]),
+    BenchmarkQuery("f26","RuntimeError working outside of application context","bug_diagnosis",["src/flask/ctx.py","src/flask/globals.py"],["RuntimeError","application context"]),
+    BenchmarkQuery("f27","app.route(","code_completion",["src/flask/sansio/scaffold.py","src/flask/app.py"],["route"]),
+    BenchmarkQuery("f28","render_template(","code_completion",["src/flask/templating.py"],["render_template"]),
+    BenchmarkQuery("f29","app.config.from_object(","code_completion",["src/flask/config.py"],["Config","from_object"]),
+    BenchmarkQuery("f30","session.permanent(","code_completion",["src/flask/sessions.py"],["SessionMixin","permanent"]),
+]
+
+def load_dataset(): return list(DATASET)

kce/benchmark/metrics.py

@@ -0,0 +1,26 @@
+"""IR metrics: Recall@k, MRR, nDCG, Context F1."""
+import math
+
+def recall_at_k(retrieved, relevant, k):
+    if not relevant: return 0.0
+    return len(set(retrieved[:k]) & set(relevant)) / len(relevant)
+
+def mrr(retrieved, relevant):
+    for i, f in enumerate(retrieved, 1):
+        if f in set(relevant): return 1.0 / i
+    return 0.0
+
+def ndcg_at_k(retrieved, relevant, k):
+    rel = set(relevant); dcg = 0.0
+    for i, f in enumerate(retrieved[:k], 1):
+        if f in rel: dcg += 1.0 / math.log2(i + 1)
+    n_rel = min(len(relevant), k)
+    idcg = sum(1.0 / math.log2(i + 1) for i in range(1, n_rel + 1))
+    return dcg / idcg if idcg > 0 else 0.0
+
+def context_f1(retrieved, gold, k=10):
+    g = set(gold); r = set(retrieved[:k])
+    if not g: return {"recall": 0.0, "precision": 0.0, "f1": 0.0}
+    c = len(g & r); R = c / len(g); P = c / len(r) if r else 0.0
+    f1 = 2*R*P/(R+P) if R+P > 0 else 0.0
+    return {"recall": R, "precision": P, "f1": f1}