Memory-LoRA hypernetwork for Gemma-4-E2B: code, curated data, sixview checkpoints

Hypernetwork that generates repo-specific LoRA adapters for a frozen
google/gemma-4-E2B (zero inference-time token overhead). Includes the
memory_lora package, all data/build/train/eval scripts, the aligned
6-view dataset, and the sixview_v1/v2 checkpoints.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CeUvTz4vLw4ni2ZNR6pS1p

.gitattributes

@@ -0,0 +1,2 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,51 @@
+# === Secrets & environment (NEVER commit) =================================
+.env
+.env.*
+*.key
+*.pem
+
+# === Python virtualenv & caches ===========================================
+venv/
+.venv/
+env/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.ipynb_checkpoints/
+.DS_Store
+
+# === Large raw / intermediate data we deliberately DON'T publish ===========
+# (kept local; regenerable from scripts. See README §8 Datasets inventory.)
+data/commitpack/
+data/real_code2lora/
+data/openrouter_cache/
+data/embeddings/combined_embeddings.parquet
+data/embeddings/real_code2lora_embeddings.parquet
+data/embeddings/real_code2lora_diffs.parquet
+data/embeddings/doc_embeddings.parquet
+data/qna/combined_qna.jsonl
+data/qna/real_code2lora_qna.jsonl
+data/qna/qna.jsonl
+
+# === Superseded / exploratory training runs (see README §9) ================
+# Published checkpoints are the current sixview_* line only.
+runs/full2/
+runs/full_real_v4/
+runs/full1/
+runs/full3_priority/
+runs/smoke_combined/
+runs/direct_paper/
+runs/direct_paper_v2/
+runs/direct_cah_baseline/
+runs/full_real_v1_train.log
+runs/*.log
+runs/*.npy
+runs/test_ckpt.pt
+
+# Actively-written live checkpoint (overwritten every 50 steps during training;
+# we publish a verified snapshot + the write-once timestamped checkpoints instead)
+runs/sixview_v2/head.latest.pt
+
+# === Scratch ===============================================================
+scratchpad/
+*.tmp

README.md

@@ -0,0 +1,581 @@
+# Memory-LoRA: A Hypernetwork that Writes Repo-Specific Adapters for Gemma-4-E2B
+
+> **One line:** we train a small neural network (a *hypernetwork*) that reads an
+> embedding of a codebase and **emits a LoRA adapter** for a frozen
+> `google/gemma-4-E2B`. The adapter injects repo-specific knowledge into the
+> model with **zero extra tokens at inference time** — no RAG, no context stuffing.
+> Everything runs **locally on an Apple-Silicon Mac** (M4 Pro, 64 GB).
+
+This document is the onboarding bible for the project. It covers *what* we built,
+*why* every non-obvious choice was made, *what data* we used, *every experiment we
+ran and its result*, and the **hard-won lessons** (the MPS memory leak alone cost
+us hours). Read it top to bottom once; after that use it as a reference.
+
+---
+
+## Table of Contents
+
+1. [The idea in 60 seconds](#1-the-idea-in-60-seconds)
+2. [Origin: the Code2LoRA paper](#2-origin-the-code2lora-paper)
+3. [Architecture](#3-architecture)
+4. [The target model: Gemma-4-E2B specifics](#4-the-target-model-gemma-4-e2b-specifics)
+5. [Data pipeline: the 6 views](#5-data-pipeline-the-6-views)
+6. [Data pipeline: QA generation](#6-data-pipeline-qa-generation)
+7. [What is learnable — Tier A / B / C](#7-what-is-learnable--tier-a--b--c)
+8. [Datasets inventory](#8-datasets-inventory)
+9. [Experiments & results](#9-experiments--results)
+10. [Key decisions & lessons learned](#10-key-decisions--lessons-learned)
+11. [Repository map](#11-repository-map)
+12. [How to run it](#12-how-to-run-it)
+13. [Evaluation methodology](#13-evaluation-methodology)
+14. [Costs & budget discipline](#14-costs--budget-discipline)
+15. [Current status & roadmap](#15-current-status--roadmap)
+16. [Glossary](#16-glossary)
+
+---
+
+## 1. The idea in 60 seconds
+
+A coding agent (Claude Code, Codex, etc.) is great at reasoning but knows nothing
+about *your* repo until you paste files into its context — which is slow, expensive,
+and capped by the context window. The usual fix is RAG (retrieve chunks at query
+time). We do something different and complementary:
+
+**We bake the repo's "personality" directly into the model's weights, once, as a
+LoRA adapter — and we generate that adapter with a neural network instead of
+training it.**
+
+```
+                        ┌─────────────────────────────┐
+   repo on disk ──────► │  6-view extractor + Qwen3    │ ──► 12288-d
+                        │  frozen embedding encoder    │     repo embedding
+                        └─────────────────────────────┘          │
+                                                                 ▼
+                                                   ┌──────────────────────────┐
+                                                   │  HYPERNETWORK (our head) │
+                                                   │  MLP → per-module A,B     │
+                                                   └──────────────────────────┘
+                                                                 │  LoRA weights
+                                                                 ▼
+   Q: "what layer owns auth in this repo?"  ──►  ┌──────────────────────────────┐
+                                                 │ FROZEN Gemma-4-E2B + injected │ ──► "the middleware
+                                                 │ LoRA  (zero extra tokens)     │      layer, via ..."
+                                                 └──────────────────────────────┘
+```
+
+The magic: **the hypernetwork is trained across hundreds of repos**, so it learns
+the *mapping* `repo embedding → good adapter`. At inference on a brand-new repo it
+has never seen, it embeds the repo once and produces an adapter in a single forward
+pass. This is the same reason the source paper needed 400+ repos, not 1: breadth is
+what makes the mapping generalize.
+
+---
+
+## 2. Origin: the Code2LoRA paper
+
+We reverse-engineered **Code2LoRA** (arXiv 2606.06492v1) and found its released
+code (`anonymous.4open.science/r/code2lora-6857`, MIT). The paper's contribution:
+a *static hypernetwork* that maps a **repository** embedding → a LoRA adapter for a
+frozen code LLM, evaluated on **RepoPeftBench** with IR (in-repo) / CR (cross-repo)
+splits. On a full H100 setup they report **63.8 % cross-repo Exact Match**.
+
+Our project is the **Doc2LoRA variant** the paper itself cites — hypernetwork maps a
+*document/repo view* → LoRA — reimplemented against **Gemma-4-E2B**, trained fully
+**locally on MPS** (no CUDA/H100), and extended in two directions the paper does not
+cover:
+
+- **Memory / recall**: the adapter should let the model *recall facts* about the
+  repo, not just complete code.
+- **Tech-Lead judgment**: architecture, data-flow, conventions, contracts, ops —
+  the things a 20-year senior engineer "just knows" about a codebase.
+
+We keep the paper's proven autograd trick almost verbatim (see §3) and change only
+what Gemma-4 and Apple Silicon force us to change.
+
+---
+
+## 3. Architecture
+
+Three frozen/learned pieces. Only the middle one (the head) is trained.
+
+### 3.1 Frozen encoder — `memory_lora/encoder.py`
+
+- **Qwen3-Embedding-0.6B**, frozen, no gradient flows through it.
+- Each repo view is chunked into token windows (2048 tokens, 128 overlap), each
+  chunk mean-pooled, then chunks combined with **mean + max pooling** → a **2048-d**
+  vector *per view*.
+- Embeddings are **precomputed once and cached** to parquet — the encoder never runs
+  during training.
+
+### 3.2 The hypernetwork head — `memory_lora/core.py :: MemoryLoRAHead`
+
+The only trained component. Design (kept close to the paper):
+
+- **2-layer GELU MLP trunk** (`input_dim → hidden_dim → hidden_dim`), followed by
+  **L2-normalize + √hidden_dim rescale** (stabilizes the magnitude of generated
+  weights).
+- **Per-module-type output heads**: for each target module *type* it emits an
+  `A ∈ [rank, in_features]` and `B ∈ [out_features, rank]`. **One (A,B) pair per
+  type, shared across all layers of that type** — this is what keeps the head
+  tractable (188.6 M params) instead of exploding per-layer.
+- **Squashing**: `tanh(raw) * exp(log_scale)` with a learned per-type `log_scale`
+  (init **-3.5**). This starts the generated adapter near-zero (so training begins
+  close to the base model) and lets each type learn its own output scale.
+- **Defaults**: `hidden_dim=128`, `rank=16`, `dropout=0.1`.
+  - *Why hidden_dim=128 and not the paper's 512/1024?* A 745 M-param head
+    (hidden_dim=512) barely moved eval loss (~1.9 → ~2.7) but was far heavier to
+    train on MPS. 128 cuts head size dramatically with negligible quality loss
+    locally. Bump it later on real GPUs.
+
+### 3.3 The LoRA injection — `memory_lora/core.py :: LoRA`
+
+```
+   base nn.Linear (FROZEN)              hypernetwork output
+        │                                    │
+   x ──►│ Wx  ────────────────┐              │
+        │ (input detached      +──► y = Wx + scaling · B (A x)
+        │  into base)          │              ▲   ▲
+   x ──────────────────────────┘              │   │
+                                     A,B are NON-detached tensors so
+                                     autograd flows LM-loss → head
+```
+
+Critical detail (straight from the paper's code): **A and B are plain, non-buffer
+tensor attributes, not `nn.Parameter` and not detached**, so the gradient of the LM
+loss flows *through* the injected weights *into the hypernetwork*. The base
+`nn.Linear` is frozen and its input is detached. Get this wrong and the head never
+learns.
+
+### 3.4 Shape-qualified module types — the heterogeneity fix
+
+Gemma-4-E2B is **not** a uniform stack (see §4). Two `q_proj`s can have different
+shapes. If you key the head by bare type name (`q_proj`) you get
+*"type q_proj inconsistent dims"* crashes. Fix: key by **shape-qualified type**,
+e.g. `q_proj_1536x2048` vs `q_proj_1536x4096`. The v2 run discovered **14 shape
+types** across **205 target modules**:
+
+```
+down_proj_12288x1536  down_proj_6144x1536   gate_proj_1536x12288  gate_proj_1536x6144
+k_proj_1536x256       k_proj_1536x512       o_proj_2048x1536      o_proj_4096x1536
+q_proj_1536x2048      q_proj_1536x4096      up_proj_1536x12288    up_proj_1536x6144
+v_proj_1536x256       v_proj_1536x512
+```
+
+`get_module_specs(root_prefix="model.language_model.")` restricts wrapping to the
+text decoder — the **vision and audio towers are never touched** (not even
+inspected), so the multimodal forward path stays intact and they cost only idle RAM.
+
+---
+
+## 4. The target model: Gemma-4-E2B specifics
+
+Verified by reading the actual safetensors header, not guessed:
+
+- **Real model.** Google shipped Gemma 4 in March 2026. Apache-2.0, ungated.
+  Class `Gemma4ForConditionalGeneration`, `model_type: "gemma4"`. Loaded via
+  `AutoModelForImageTextToText`.
+- **Requires `transformers >= 5.5.0.dev0`** — install from the `main` branch, not a
+  pinned PyPI release (this is the single biggest environment risk; smoke-test first).
+- **Decoder is nested**: layers live at `model.language_model.layers.{i}.*`, *not*
+  `model.layers.*`. The layer-index regex had to change accordingly.
+- **35 text layers, heterogeneous:**
+  - Aggressive KV sharing — **20 of 35 layers lack their own `k_proj`/`v_proj`**
+    (`num_kv_shared_layers=20`).
+  - **Every 5th layer is wider** (the `*_4096`, `*_12288` shape variants above).
+- **Device `mps`, precision bf16** (fall back to fp16 if unstable). No
+  `flash_attention_2` on MPS — use `sdpa`, fall back to `eager`.
+
+---
+
+## 5. Data pipeline: the 6 views
+
+`scripts/build_repo_multiview.py` clones a repo and extracts **6 complementary
+views**, embeds each with Qwen3 → 2048-d, and **concatenates to a 12288-d** repo
+vector. The views encode the different "lenses" a senior engineer uses:
+
+| View            | What it captures                                   | Source signals |
+|-----------------|----------------------------------------------------|----------------|
+| `v_graph`       | call / import / dependency structure               | AST for Python (`memory_lora/codegraph.py`); `IMPORT_RE`/`DEF_RE` regex fallback for other languages |
+| `v_arch`        | architecture & layout                              | README, folder tree |
+| `v_history`     | how the code evolved                               | `git log`, recent diffs |
+| `v_contracts`   | behavioral contracts                               | test files |
+| `v_conventions` | idioms & style                                     | representative source files |
+| `v_ops`         | build / deploy / runtime                           | CI config, Dockerfile, build files |
+
+**Multi-language from the start.** `CODE_EXTS` + regex fallbacks mean the graph view
+works for 9 languages, not just Python (this was a deliberate correction — see §10).
+Repos with < 3 code files are skipped. The build is **resume-safe** (skips repos
+already in `multiview_sources.jsonl`) and **flushes the embeddings parquet every 10
+repos**, so a crash never loses more than 10 repos of work.
+
+---
+
+## 6. Data pipeline: QA generation
+
+The repo embedding is the *input*; the *target* is repo-scoped Q&A. Two generators,
+both parallelized (`ThreadPoolExecutor`, `--workers 10`) with a **per-prompt disk
+cache** (idempotent reruns) and a `--model` flag:
+
+- **`scripts/generate_repo_scoped_qa.py`** — reads the same 6 views and asks the LLM
+  for **8–12 repo-level judgment questions** ("what layer owns X", "what convention
+  does this repo use for Y", "how does data flow through Z", "why is it structured
+  this way"). Target scope = input scope (repo-level embedding ↔ repo-level QA).
+- **`scripts/generate_commitpack_qa.py`** — **breadth** generator: one commit per
+  *distinct* repo across CommitPackFT (25k+ distinct repos), 3–4 commit-scoped
+  judgment questions (why / conventions / contracts / impact). For a hypernetwork,
+  **distinct-repo count is the currency of generalization**, so we favor 1 commit ×
+  many repos over many commits × one repo.
+
+**Discipline (both):** answers are **short judgment**, never file-path/line-number
+lists. This is deliberate — see Tier A/B/C next.
+
+**Models used (OpenRouter, OpenAI-compatible API):**
+
+| Model | Role | Notes | Cost |
+|-------|------|-------|------|
+| `google/gemini-3.6-flash` | high-quality QA | **reasoning is mandatory** → needs generous `max_tokens` (3000–4000) or it returns empty | ~$0.0021 / QA |
+| `google/gemma-4-31b-it` | bulk / cheap QA | non-reasoning, clean JSON | ~$0.001 / repo (~$1 per 1000 repos) |
+
+The OpenRouter key lives in a **git-ignored `.env` (mode 600)** and is never pasted
+into a command line.
+
+---
+
+## 7. What is learnable — Tier A / B / C
+
+A LoRA adapter has finite capacity. We classify repo knowledge by whether a LoRA can
+hold it — this drives the entire QA design:
+
+- **Tier A — Judgment & conventions** (LEARNABLE). "This repo puts business logic in
+  services, not views." Compressible, generalizes. → **This is what we train on.**
+- **Tier B — Structural gist** (LEARNABLE). "Auth flows through middleware." The kind
+  of thing, not the exact file.
+- **Tier C — Exact recall & multi-hop** (NOT reliably learnable). "Line 412 of
+  `foo.py` calls `bar()`." This needs **retrieval (RAG)**, not weights.
+
+So Memory-LoRA and RAG are **complementary**: the adapter carries Tier A/B judgment
+for free (zero tokens); RAG handles Tier C exact lookups. The QA prompts forbid exact
+file/line answers precisely so we never ask the LoRA to do a job it structurally
+can't.
+
+---
+
+## 8. Datasets inventory
+
+Everything lives under `data/` (git-ignored blobs). Sizes are approximate.
+
+| Path | What | Scale |
+|------|------|-------|
+| `data/real_code2lora/` | **RepoPeftBench** from the `code2lora` HF org — 500 Python repos, repo-commit embeddings + diffs | 73,849 repo-commit rows; ~1.2 GB |
+| `data/commitpack/multilang_commits.jsonl` | **CommitPackFT** shards, 9 languages | 25k+ distinct repos |
+| `data/docs/multiview_sources.jsonl` | 6-view `view_text` per repo (input to QA gen) | growing (1000s of repos) |
+| `data/embeddings/multiview_embeddings.parquet` | 12288-d multi-view repo embeddings | 1000+ repos |
+| `data/embeddings/aligned6_embeddings.parquet` | **assembled training inputs** (repos with ≥1 QA) | 1058 repos (current) |
+| `data/qna/repo_scoped_qa.jsonl` | repo-level judgment QA | 11,232 QA |
+| `data/qna/techlead_qa_commitpack.jsonl` | commit-scoped breadth QA | 9,245 QA |
+| `data/qna/techlead_qa.jsonl` | SWE-bench tech-lead QA | 2,786 QA |
+| `data/qna/aligned6_qna.jsonl` | **assembled training targets** | 8,540 QA (current) |
+| `data/openrouter_cache/` | per-prompt response cache | ~19 MB |
+
+**Language balancing.** SWE-bench is ~79 % Django. Left alone, the dataset was 46 %
+Django. `scripts/consolidate_qa.py` applies a **per-repo cap** (default 12–15 QA/repo)
+which collapses Django to **~2.0 %** while preserving the 2400+ distinct repos'
+diversity. `assemble_6view_dataset.py` applies the same cap when building the final
+aligned set.
+
+---
+
+## 9. Experiments & results
+
+Chronological, with the actual numbers we measured. Two families of runs.
+
+### 9.1 Reproducing the paper (single-view, real RepoPeftBench)
+
+| Run | What | Result |
+|-----|------|--------|
+| `full1` (early) | first end-to-end hypernetwork on converted real data | CR **EM 0.056–0.083**, EditSim ~0.27 — pipeline works, undertrained |
+| `sixview`/converted-real (best single-view ckpt) | after more training | **CR EM 0.524, EditSim 0.635** |
+| Paper (reference, H100) | their full run | CR EM **0.638** |
+
+**Headline:** on real code, after only ~2.4 % of one epoch of local MPS training, we
+reached **52.4 % cross-repo Exact Match** vs the paper's 63.8 % on a full H100 setup.
+The mechanism demonstrably works — the generated adapter recovers repo-specific
+identifiers the base model does not know.
+
+### 9.2 The 6-view Tech-Lead model (the current line of work)
+
+Loss is causal-LM cross-entropy on QA targets; lower is better. Three eval suites:
+`cr_val` / `cr_test` (held-out *repos*) and `ir_test` (held-out *QA* of train repos).
+
+| Run | Dataset | Best held-out `cr_test` loss | Notes |
+|-----|---------|------------------------------|-------|
+| `sixview_v1` | 515 repos / 3,988 QA (415 train repos) | **2.848** (step ~1060) | Overfit afterward: train loss fell to 1.75 while `cr_test` drifted to 3.35. Classic small-dataset ceiling. |
+| `sixview_v2` | **1,058 repos / 8,540 QA (858 train repos)** | *in progress* | Resumed from `sixview_v1/head.best.pt`; 2× the data specifically to break v1's ceiling. |
+
+`sixview_v1` metrics trajectory (from `runs/sixview_v1/metrics.jsonl`):
+
+```
+step 1245  cr_test 2.962   ir_test 2.535   (end of epoch 2 — near best)
+step 1400  cr_test 3.245   ir_test 2.593   (overfitting begins)
+step 1600  cr_test 3.352   ir_test 2.655   (train loss still falling → ceiling hit)
+```
+
+The v1→v2 story is the core empirical lesson: **the small aligned set was the
+bottleneck, not the architecture** — hence the push to build 1000+ more repos.
+
+---
+
+## 10. Key decisions & lessons learned
+
+The expensive knowledge. Read this section twice.
+
+### 10.1 ⚠️ The MPS gradient-checkpointing memory leak (the big one)
+
+**Symptom:** training with `gradient_checkpointing_enable()` (`use_reentrant=False`)
+**leaked ~12 GB per step** and OOM'd the whole machine within a few steps.
+
+**Diagnosis** (`scripts/diag_mps_leak.py`): forward-only was stable; train + checkpoint
+leaked 39 GB → 18 GB free in 2 steps. Isolated the checkpointing path as the cause.
+
+**Fix:** **`--no-gradient-checkpointing`.** We have enough unified memory to hold
+activations without it once the multimodal towers sit idle. This is documented as a
+standing memory (`mps-gradient-checkpointing-leak.md`).
+
+### 10.2 ⚠️ `psutil` RSS is blind to MPS memory
+
+Our first memory safety-net used `psutil` RSS / `ps -o rss` — it reported **< 1 GB**
+while `top` showed **55–83 GB** actually in use. MPS (GPU) allocations don't show up
+in process RSS.
+
+**Fix:** the safety check uses **`psutil.virtual_memory().available`** (system-wide)
+with a `--min-available-gb` floor (default 5). To *observe* MPS memory, use
+`top -l 1 -pid <PID> -stats mem`, not `ps`.
+
+### 10.3 Memory competition between concurrent jobs
+
+Three concurrent jobs once pushed available memory under the 10 GB floor and training
+self-stopped. **Lesson:** during MPS training, run data builds/embedding on **CPU**
+(`--device cpu`) so they don't contend for the GPU/unified memory. We now routinely
+run training (MPS) + QA gen (network) + multiview build (CPU) together without
+contention.
+
+### 10.4 Don't lose hours of training
+
+Every long run writes **checkpoints every 50 steps** (overwriting `head.latest.pt`),
+**every 30 minutes** (timestamped `head.tNNNNm.pt`), **per-epoch** (`head.epN.pt`),
+and a **`head.best.pt`** on eval improvement. Runs are launched with `nohup … &
+disown` so they survive terminal/session death. `sixview_v1` in fact survived a full
+session interruption and kept training. Resume with `--resume-from <ckpt>` (loads head
+weights; optimizer restarts fresh).
+
+### 10.5 Data-quality corrections (user-driven)
+
+- **"I still see lots of Django."** SWE-bench is Django-dominated. → per-repo cap +
+  multi-language sourcing dropped Django 46 % → 2.0 %.
+- **"It must be good for any programming language."** → 9-language diversity via
+  CommitPackFT and language-agnostic view extraction.
+- **"Where's the code context in the QA?"** → clarified the two-channel design: the
+  **repo embedding is the context channel**, the QA is only the target. They are
+  joined by `doc_id` at assembly time.
+
+### 10.6 OpenRouter gotchas
+
+- `gemini-3.6-flash` **returned empty** until we raised `max_tokens` — it's a
+  mandatory-reasoning model that spends tokens on hidden reasoning before content.
+  Reasoning **cannot be disabled** (400 error).
+- CommitPackFT's HF loader is deprecated → fetch raw `data.jsonl` directly.
+- `global MODEL` after use is a `SyntaxError` → set via `globals()["MODEL"] = ...`.
+
+### 10.7 Performance fix worth knowing
+
+Loading embeddings was 5+ min because `_list_to_f32_array` used a Python loop.
+Vectorized via `col.combine_chunks().flatten().to_numpy()` → **~220× faster**.
+
+---
+
+## 11. Repository map
+
+```
+memory_lora/                  # the library (importable package)
+  core.py                     # LoRA wrapper, MemoryLoRAHead hypernetwork,
+                              #   get_module_specs / replace_with_lora / inject_lora_weights,
+                              #   load_doc_rows / load_qna_rows
+  encoder.py                  # Qwen3 chunk + embed + mean/max pool (frozen)
+  codegraph.py                # Python AST extractor (imports, sigs, call graph)
+  data_paths.py               # local parquet/jsonl path resolver
+
+scripts/
+  build_repo_multiview.py     # clone → 6 views → 12288-d embeddings (multi-language, resume-safe)
+  generate_repo_scoped_qa.py  # repo-level judgment QA (aligned to the 6 views)
+  generate_commitpack_qa.py   # commit-scoped breadth QA across 1000s of distinct repos
+  generate_techlead_qa.py     # SWE-bench tech-lead QA
+  generate_synthetic_dataset.py  # original synthetic doc + QA generator
+  consolidate_qa.py           # per-repo cap → language/domain balancing
+  assemble_6view_dataset.py   # join embeddings ↔ all QA by repo → aligned6_{embeddings,qna}
+  augment_paraphrases.py      # QA paraphrase augmentation
+  convert_real_code2lora.py   # RepoPeftBench → our schema
+  build_doc_embeddings.py     # encoder pass over documents
+  merge_corpora.py            # combine multiple corpora
+  train_memory_lora.py        # THE trainer (MPS, one-repo-per-step, checkpoints, TensorBoard)
+  train_direct_lora.py        # baseline: plain per-repo LoRA (no hypernetwork)
+  eval_memory_lora.py         # EM / EditSim recall eval on cr/ir splits
+  show_eval_examples.py       # dump concrete base-vs-adapted examples
+  test_embed_this_repo.py     # embed the current repo (pipeline demo)
+  test_recall_this_repo.py    # query the adapted model about this repo
+  diag_mps_leak.py            # the memory-leak isolation harness
+
+data/                         # git-ignored: embeddings, qna, sources, caches
+runs/                         # git-ignored: checkpoints, logs, metrics.jsonl, tb/
+requirements.txt              # torch 2.13 (MPS), transformers@main, openai, pyarrow, tensorboard…
+.env                          # git-ignored, mode 600: OPENROUTER_API_KEY
+```
+
+---
+
+## 12. How to run it
+
+### Setup
+
+```bash
+python3 -m venv venv && source venv/bin/activate
+pip install -r requirements.txt          # installs transformers from git main
+echo "OPENROUTER_API_KEY=sk-or-..." > .env && chmod 600 .env
+```
+
+Smoke-test the environment first (gates everything): confirm `transformers` main
+loads `google/gemma-4-E2B` on `mps` and runs a text-only forward pass.
+
+### Build data
+
+```bash
+# 1) multi-view embeddings for a repo list (CPU to stay off the GPU during training)
+python scripts/build_repo_multiview.py \
+  --repos-file data/multilang_repo_list.txt --max-repos 1000 --device cpu
+
+# 2) repo-scoped QA (cheap model) — appends, resume-safe, cached
+./venv/bin/python scripts/generate_repo_scoped_qa.py \
+  --model google/gemma-4-31b-it --workers 10
+
+# 3) balance + assemble the aligned training set
+python scripts/consolidate_qa.py --per-repo-cap 12
+python scripts/assemble_6view_dataset.py
+# -> data/embeddings/aligned6_embeddings.parquet + data/qna/aligned6_qna.jsonl
+```
+
+### Train (the exact `sixview_v2` command)
+
+```bash
+nohup ./venv/bin/python scripts/train_memory_lora.py --output-dir sixview_v2 \
+  --resume-from runs/sixview_v1/head.best.pt \
+  --embeddings-path data/embeddings/aligned6_embeddings.parquet \
+  --qna-path data/qna/aligned6_qna.jsonl --epochs 100 --max-hours 8 \
+  --checkpoint-every-steps 50 --checkpoint-every-minutes 30 --epoch-ckpt-every 5 \
+  --eval-every-steps 300 --limit-eval-docs 40 --max-seq-len 512 --fixed-seq-len \
+  --max-qna-per-doc 12 --lm-micro-batch 2 --device mps --no-gradient-checkpointing \
+  --rank 16 --head-hidden-dim 128 --head-dropout 0.1 --weight-decay 0.05 \
+  --early-stop-patience 25 --lr 8e-5 --lr-total-steps 9000 --min-available-gb 5 \
+  > runs/sixview_v2_train.log 2>&1 &
+disown
+```
+
+**Flags you must not forget:** `--no-gradient-checkpointing` (the leak),
+`--device cpu` for builds during training (contention), `--min-available-gb`
+(system-wide memory floor).
+
+### Watch it
+
+```bash
+tensorboard --logdir runs/sixview_v2/tb    # train/loss, train/lr, eval/{suite}_loss
+tail -f runs/sixview_v2_train.log
+```
+
+### Evaluate & inspect
+
+```bash
+python scripts/eval_memory_lora.py --ckpt runs/sixview_v2/head.best.pt   # EM / EditSim
+python scripts/show_eval_examples.py                                     # base vs adapted
+```
+
+---
+
+## 13. Evaluation methodology
+
+- **Splits (deterministic, by `md5(repo) % 100`):** 80 % train / 10 % `cr_val` /
+  10 % `cr_test` **by repo**, so cross-repo suites are **entirely held-out
+  repositories** the hypernetwork never trained on. Within train repos, ~15 % of QA
+  is held out → `ir_test` (in-repo generalization to unseen questions of seen repos).
+- **Metrics:** causal-LM **eval loss** during training (fast, every N steps on
+  `--limit-eval-docs` docs to stay cheap on CPU), plus generation-time **Exact Match
+  (EM)** and **EditSim** for the recall eval.
+- **The proof spot-check:** query the *adapted* model with repo-specific questions and
+  confirm the *base* (un-adapted) model gets them wrong/vague — proving the
+  **adapter**, not the base model's pretraining, does the work.
+
+CPU eval of a float32 5B model is slow (~20 min for a full pass) → we cap eval docs
+(e.g. 10–40) for in-loop evals and run full EM eval separately.
+
+---
+
+## 14. Costs & budget discipline
+
+- **Spend baseline:** $31.00 (`runs/spend_baseline.txt`); ~**$33.90 total** to date;
+  ~**$11 remaining**. The project is run under explicit budget caps ("spend at most
+  $4 more") with spend-guards.
+- **Unit economics:** `gemini-3.6-flash` ≈ **$0.0021/QA**; `gemma-4-31b-it` ≈
+  **$0.001/repo (~$1 per 1000 repos)** — which is exactly why the 1000-repo expansion
+  uses the gemma model.
+- **Free levers:** the per-prompt cache makes reruns free; embedding and training are
+  local (electricity only).
+
+---
+
+## 15. Current status & roadmap
+
+**Live right now (three jobs in parallel, no contention):**
+
+- **`sixview_v2` training** — resumed from `head.best.pt` on the doubled
+  **1,058-repo / 8,540-QA** dataset (858 steps/epoch), MPS. First held-out eval at
+  step 300 tells us whether doubling the data broke v1's 2.848 ceiling.
+- **QA generation** — `gemma-4-31b-it` filling in all ~1,032 new repos for the
+  **complete** dataset (next training run).
+- **Multiview build** — cloning/embedding toward the full +1,000-new target (CPU).
+
+**Roadmap:**
+
+1. Finish the complete 1000-new-repo dataset (embeddings + QA).
+2. Assemble the full aligned set (~1,650 repos) and train **`sixview_v3`** on it.
+3. Run generation-time **EM/EditSim** on the 6-view model (base vs adapted).
+4. Push `head_hidden_dim` back up once on real GPUs; the 128 default was an
+   MPS-locality compromise.
+5. Broaden Tier-A/B QA toward agent-harness use cases (Jira/ticket tracking,
+   diff/impact reasoning) already scaffolded in `generate_techlead_qa.py`.
+
+**Open questions:**
+
+- Does the 12288-d 6-view embedding actually beat the single 2048-d view on
+  generation EM, or only on loss? (loss says yes; EM eval pending)
+- What's the real Tier-B ceiling — how much structural gist fits in rank-16?
+- Optimal per-repo QA cap for the breadth/depth trade-off.
+
+---
+
+## 16. Glossary
+
+- **Hypernetwork** — a network that outputs the weights of another network. Here:
+  repo embedding → LoRA (A,B) matrices.
+- **LoRA** — Low-Rank Adaptation: `y = Wx + scaling · B(Ax)`, with `A,B` low-rank
+  (rank 16). We *generate* A,B instead of training them per-repo.
+- **6 views** — graph / arch / history / contracts / conventions / ops; each 2048-d,
+  concatenated to 12288-d.
+- **CR / IR** — cross-repo (held-out repos) / in-repo (held-out QA of seen repos).
+- **EM / EditSim** — Exact Match / edit-distance similarity of generated vs gold.
+- **Tier A/B/C** — judgment (learnable) / structural gist (learnable) / exact recall
+  (needs RAG).
+- **MPS** — Apple's Metal Performance Shaders GPU backend for PyTorch.
+- **RepoPeftBench** — the paper's benchmark; 500 Python repos, repo-commit
+  embeddings + diffs, IR/CR splits.
+
+---
+
+*Maintained as living documentation. If you change a default, a path, or a flag,
+update the matching section here — onboarding depends on it.*

data/embeddings/aligned6_embeddings.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c86fc8e4a4abe8e47415e0ecd876627623fb02f9c9aabd3740a878319609e14
+size 68653613

data/embeddings/multiview_embeddings.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:deb4c9f45b62fb7b552f27795054cfaf4ab5a511e94350eab1651e4941fbb3a9
+size 88090938

data/multilang_repo_list.txt

@@ -0,0 +1,3150 @@
+RangeeGmbH/FreeRDP	c
+SpectoLabs/hoverfly	go
+saidie/plantuml-api	java
+teampopong/pokr.kr	javascript
+trevormunoz/katherine-anne	php
+imankulov/sentry	python
+waxpoetic/brotherly	ruby
+alerque/casile	rust
+geofffilippi/angular-cli	typescript
+pivotaltracker/PivotalCoreKit	c
+kubernetes-retired/cluster-registry	go
+palmfjord/twig-java	java
+TimBek2/phase-0	javascript
+i-lateral/silverstripe-catalogue	php
+rnyberg/pyfibot	python
+neotericdesign/pubdraft	ruby
+osa1/tiny	rust
+sebastienbarbier/sebastienbarbier.com	typescript
+melonmanchan/k-and-r	c
+jehrhardt/bowling-game-go	go
+CS2103AUG2016-T15-C1/main	java
+motion/motion	javascript
+etu/0bRSS	php
+artefactual/archivematica-history	python
+mirego/rack-locale-root-redirect	ruby
+CryZe/livesplit-core	rust
+crossroads-education/eta-front	typescript
+vespa-engine/vespa	c
+bitly/go-hostpool	go
+edx/edx-app-android	java
+tesfaldet/bluebird	javascript
+Ecodev/gims	php
+caleb531/automata	python
+jtribe/redirector	ruby
+jgilchrist/rslike	rust
+auth0-blog/ng2-dinos	typescript
+Baltoli/peggo	c
+polydawn/refmt	go
+cbornet/generator-jhipster	java
+hanford/filepizza	javascript
+spatie/laravel-permission	php
+Antiun/account-invoicing	python
+tenforwardconsulting/crantastic	ruby
+xfix/enum-map	rust
+itchio/itch	typescript
+peteruhnak/pharo-vm	c
+prometheus/client_golang	go
+Yakindu/statecharts	java
+mbland/hubot-slack-github-issues	javascript
+anawatom/lavandula	php
+ElementalAlchemist/txircd	python
+arkon/Markus	ruby
+zanesterling/fatr	rust
+rcjsuen/dockerfile-language-server-nodejs	typescript
+carp-lang/Carp	c
+jabley/cf-metrics	go
+s-case/s-case-core	java
+grncdr/node-any-db	javascript
+routetopa/auth-server-2	php
+kmee/stock-logistics-warehouse	python
+sophsec/wordlist	ruby
+sunjay/turtle	rust
+jonbern/fetch-retry	typescript
+Ultimaker/CuraEngine	c
+lucapette/deloominator	go
+smartnews/presto	java
+jonathanargentiero/istanbul-instrumenter-loader	javascript
+aedart/scaffold	php
+BT-rmartin/partner-contact	python
+davengeo/github	ruby
+matthiasbeyer/task-hookrs	rust
+rafaell-lycan/sabesp-mananciais-api	typescript
+iondbproject/iondb	c
+cburkert/go-statusbar	go
+realityforge/replicant	java
+itsananderson/cascadiafest	javascript
+herloct/pinger	php
+yuzie007/upho	python
+agrimm/resume	ruby
+zsiciarz/24daysofrust	rust
+JiraGoggles/jiragoggles-frontend	typescript
+llvm-mirror/clang	c
+ryanclarke/hugo	go
+bwyap/java-familyfeud	java
+ProseMirror/prosemirror-markdown	javascript
+Payum/Payum	php
+bfaludi/daprot	python
+joyent/lx-brand-image-tests	ruby
+dcoles/experiments	rust
+dainst/idai-components-2	typescript
+basho-labs/riak-c-client	c
+goaltools/goal	go
+flanglet/kanzi	java
+asennikov/ember-g-map	javascript
+orchestral/config	php
+angr/cle	python
+yutarody/homebrew-cask	ruby
+bash/radium	rust
+sly7-7/ember.js	typescript
+geoffgarside/cocoagit	c
+nylar/wally	go
+rigregs/ez-rules	java
+GitbookIO/plugin-katex	javascript
+Kunstmaan/KunstmaanArticleBundle	php
+jmenglund/CollectionBatchTool	python
+dphaener/kanji	ruby
+onefrankguy/chifir	rust
+PRX/publish.prx.org	typescript
+wmadill/grant-lighting	c
+jessecarl/goDLX	go
+marques-work/gocd	java
+fleetlog/gmaps-signer	javascript
+stakx-io/stakx	php
+coleifer/scout	python
+SumOfUs/Champaign	ruby
+badboy/rustup-version-name	rust
+AzureAD/microsoft-authentication-library-for-js	typescript
+MattDevo/edk2	c
+nicolasmccurdy/run	go
+cucumber/cucumber-jvm	java
+cletusw/eslint-plugin-local-rules	javascript
+Respect/Foundation	php
+hsercanatli/adaptivetuning	python
+AustenLamacraft/austenlamacraft.github.io	ruby
+google/serde_json_lenient	rust
+BibleBot/BibleBot	typescript
+elsys/po-homework	c
+perrito666/juju	go
+GlowstonePlusPlus/GlowstonePlusPlus	java
+jstransformers/jstransformer-reshape	javascript
+wandersonwhcr/romans	php
+krmaxwell/TRX	python
+vonconrad/cabinet	ruby
+jmacdonald/scribe	rust
+gamejolt/frontend-lib	typescript
+mesham/ndm	c
+VonC/gopanic	go
+b0noI/TicTacToe	java
+thoughtpalette/gulp-replace	javascript
+darimpulso/koala-framework	php
+svieira/Flask-HipPocket	python
+blinkboxbooks/common_config.rb	ruby
+diesel-rs/diesel	rust
+cardstack/cardstack	typescript
+spotify/JniHelpers	c
+jolshevski/chester	go
+sebastiansokolowski/ReservationSystem-BJ	java
+then/then-request	javascript
+M6Web/AmqpBundle	php
+capybaralet/fuel	python
+osaris/sp-gestion	ruby
+frewsxcv/tiny-http	rust
+Shopify/tinymce	typescript
+lis-epfl/MAVRIC_Library	c
+voxelbrain/pixelpixel	go
+SleeplessAcorn/DimensionallyTranscendentalTents	java
+mmalecki/package-json-dependencies-to-array	javascript
+KilikFr/TableBundle	php
+openstack/akanda-rug	python
+PRX/cms.prx.org	ruby
+fede1024/rust-rdkafka	rust
+orbitjs/orbit.js	typescript
+felipejfc/xserver-xorg-input-synaptics	c
+moncho/dry	go
+torodb/server	java
+patientslikeme/react-select-test-utils	javascript
+nicksagona/PopPHP	php
+glyph/txsni	python
+tsub/dotfiles	ruby
+lise-henry/crowbook-text-processing	rust
+glimmerjs/glimmer-vm	typescript
+fabriciofmsilva/labs	c
+art4711/bsearch	go
+tectronics/stickycode	java
+seattletimes/newsapp-template	javascript
+Becklyn/SearchBundle	php
+tiddlyweb/tiddlywebplugins.atom	python
+deep-cover/deep-cover	ruby
+Vectorious/geom-rs	rust
+agdsn/pycroft	typescript
+DBOTW/pick	c
+WarCluster/warcluster-server	go
+DadanielZ/incubator-eagle	java
+civicsource/knockout-place-picker	javascript
+khounnouk/ScnSocialAuth	php
+grimwm/py-dictobj	python
+rackspace-cookbooks/varnish	ruby
+Sgeo/hlist-old	rust
+pkarw/vue-storefront	typescript
+GPUOpen-Drivers/llvm	c
+kevinclark/indexer	go
+Distrotech/intellij-community	java
+pburtchaell/react-notification	javascript
+rogermelich/Auth	php
+amorison/qjobs	python
+silvermind/bookyt	ruby
+rlustin/lugh	rust
+anthonynsimon/parrot	typescript
+Smartling/ios-i18n	c
+julianec/justanotherircbot	go
+googleinterns/step43-2020	java
+ShieldBattery/ShieldBattery	javascript
+KRDS/Validator	php
+blancltd/blanc-basic-pages	python
+Swirrl/digitalsocial	ruby
+iankronquist/rustyvisor	rust
+kamilmysliwiec/nest	typescript
+dancxjo/spell-dollars	c
+johnny-morrice/godless	go
+prophile/ludum-dare-30	java
+SidKH/angular-starter-kit	javascript
+Sheco/cdda-itembrowser	php
+zchee/python-client	python
+jmfieldman/Mortar	ruby
+hwchen/keyring-rs	rust
+Anveio/mturk-engine	typescript
+webmaster128/botan	c
+sluceno/chuper	go
+xdrop/PassLock	java
+u-wave/hub	javascript
+markstory/mini-asset	php
+CBitLabs/django-globals	python
+jkotests/watir	ruby
+nwoeanhinnogaehr/llvm-rs	rust
+Kurtz1993/ionic-minify	typescript
+JuliaPackageMirrors/ParallelAccelerator.jl	c
+robbiev/ui	go
+loxal/FreeEthereum	java
+elliotaplant/tanks	javascript
+TypiCMS/Slides	php
+rgardner/ouimeaux	python
+project-octopus/octopodes	ruby
+rust-gnome/gtk	rust
+Jameskmonger/dependument	typescript
+nathanielng/code-templates	c
+golang/lint	go
+oscartu2/magical-kf	java
+Dynalon/Rainy	javascript
+Ben-Ho/koala-framework	php
+hsolbrig/SNOMEDToOWL	python
+azumakuniyuki/make-server	ruby
+uni-rs/uni.rs	rust
+cynicaloptimist/improved-initiative	typescript
+bbannier/ROOT	c
+go-gl/glfw	go
+hpautonomy/java-hod-client	java
+Sage/carbon	javascript
+swisnl/laravel-fulltext	php
+kevinschaul/open-in-github	python
+FlavourSys/rails-better-filters	ruby
+dskecse/rust_for_rubyists	rust
+RenovoSolutions/TypeScript-Angular-Utilities	typescript
+SteveCaine/MBTA-RestKit	c
+hackedu/website	go
+Azure-Samples/documentdb-java-todo-app	java
+kylestev/vue-animated-number	javascript
+enlim/core	php
+TangledWeb/tangled.auth	python
+bisscomm/refinerycms-products	ruby
+vhbit/lmdb-rs	rust
+JosephDuffy/josephduffy.co.uk	typescript
+tywkeene/Shell	c
+andybalholm/redwood	go
+fabiohxcx/socialbooksapi	java
+jbmusso/tinkergraph-js	javascript
+tastyigniter/TastyIgniter	php
+bbangert/retools	python
+wecohere/capacitor	ruby
+mbrubeck/rust-azure	rust
+manuth/MarkdownConverter	typescript
+jefbed/xstatus	c
+elves/elvish	go
+bsalimi/myria	java
+sqlectron/sqlectron-gui	javascript
+DanCassiano/App	php
+czpython/aldryn-faq	python
+mzazrivec/manageiq	ruby
+oli-obk/rust-pandoc	rust
+dolanmiu/docx	typescript
+bobrippling/ucc-c-compiler	c
+thoughtworks/talisman	go
+TeamTotemic/Totemic	java
+chiehwen/Node-Exercises	javascript
+TeamTyro/teamtyro.com	php
+alama/PSO2Proxy	python
+fpgentil/toy-robot-simulator	ruby
+kylewlacy/glitter	rust
+fabianweb/hue	typescript
+madf/jwtxx	c
+jaceju/go-md	go
+eshioji/trident-tutorial	java
+chi-bobolinks-2015/TheGoldenRecord	javascript
+alexcw234/feyAnthology	php
+10gen-labs/mongo-connector	python
+xpsurgery/shopping-cart	ruby
+nipunn1313/cargo	rust
+log0ymxm/node-harvest	typescript
+Zeacone/PlayPlan	c
+xgfone/go-tools	go
+tmaret/sling	java
+Plantia/app	javascript
+php-school/php-workshop	php
+makinacorpus/reportlab-ecomobile	python
+omise/girlscout	ruby
+kkawakam/rustyline	rust
+codarchlab/idai-field-client	typescript
+8l/ucc-c-compiler	c
+brettbuddin/campfire	go
+tuxetuxe/pchud	java
+flubstep/engvalues	javascript
+sampleOmont/quick	php
+devinmcgloin/advent	python
+kmerz/graveio	ruby
+indiv0/ferrum	rust
+invicticide/fractive	typescript
+appcom-interactive/MFSideMenu	c
+rocwong/neko	go
+basho/riak-java-client	java
+alphagov/static	javascript
+chriscohen/codeception-module-drupal-user-registry	php
+problemshift/kf5py	python
+reuven/modelingcommons	ruby
+nafarlee/thoughtfuck	rust
+GreenPix/dilia	typescript
+llvm-mirror/llvm	c
+oipwg/media-protocol	go
+cflint/CFLint	java
+SputterPuttRedux/storyvine_clone	javascript
+vladab/KnpTimeBundle	php
+PyO3/setuptools-rust	python
+aelogica/express_admin	ruby
+dorayakikun/alfred_jira_workflow	rust
+sMteX/WoWAnalyzer	typescript
+apple/swift-clang	c
+SpirentOrion/turnpike	go
+premkumarbalu/scsb-etl	java
+tmiller/network	javascript
+kaltar/Notify	php
+apoorvemohan/haas	python
+samasti/noosfero	ruby
+lyuboraykov/rust-exercises	rust
+arangodb/arangojs	typescript
+mnunberg/subjson	c
+equinox-io/equinox	go
+MXProgrammingClub/Chem-Helper	java
+sussol/mobile	javascript
+DoSomething/messagebroker-ds-PHP	php
+crsmithdev/arrow	python
+benjaminhyw/ArrayLists	ruby
+zummenix/mprovision	rust
+zuzusik/DefinitelyTyped	typescript
+onkwon/yaos	c
+polydawn/repeatr	go
+albertoruibal/gwt_android_emu	java
+t3b/t3b_template	javascript
+Metalaka/Central	php
+c4fcm/CLIFF-API-Client	python
+DynamoMTL/spree_gateway	ruby
+ekarlso/rust-metrics	rust
+FountainJS/generator-fountain-react	typescript
+jrobhoward/SCADAbase	c
+tendermint/tmsp	go
+kelemen/JTrim	java
+peplin/redmine_create_wiki_page	javascript
+nsams/koala-framework	php
+martinrusev/imbox	python
+PopulateTools/gobierto-dev	ruby
+SirRade/sbb-telegram-bot	rust
+akserg/ng2-toasty	typescript
+aacoppa/final	c
+gsamokovarov/jump	go
+shengmin/coding-problem	java
+holmwell/circle-blvd	javascript
+orocrm/platform	php
+favien/favien	python
+chef-cookbooks/memcached	ruby
+andschwa/rust-genetic-algorithm	rust
+blackbaud/skyux2	typescript
+tulindanil/SEUIKit	c
+dominichamon/gotrace	go
+stelar7/L4J8	java
+saurabh6790/frappe	javascript
+WellCommerce/CurrencyBundle	php
+thomwiggers/django-mongodbforms	python
+tablexi/restforce-db	ruby
+AndrewBrinker/rust-www	rust
+Microsoft/TypeScript	typescript
+approach0/search-engine	c
+duckbrain/ldss	go
+tobiasheine/Movies	java
+Mangopay/mangopay2-nodejs-sdk	javascript
+robobalasko/OpenEstateAgent	php
+anthonysandrin/kafka-utils	python
+mlomnicki/rails_event_store	ruby
+aetherknight/fractal-rs	rust
+XavierGuichet/bemoove-front	typescript
+kmuzalewska/j-pet-framework	c
+anacrolix/torrent	go
+box/mojito	java
+janga1997/Patterns	javascript
+lenar/assetic	php
+dplucenio/heat_diffusion_experiment	python
+things23/infoblox_client	ruby
+thenyeguy/oxcable	rust
+artsy/eigen	typescript
+cs50sacramento/source-code-1617	c
+Symantec/Dominator	go
+aureliano/e-docs	java
+jmeas/gistbook	javascript
+bendubuisson/silverstripe-cacheinclude	php
+bgyori/bioagents	python
+divoxx/ruby-php-serialization	ruby
+asomers/mockall	rust
+nteract/nteract	typescript
+bewuethr/stroustrup_ppp	c
+ninchat/ninchat-go	go
+blackberry/cordova-blackberry	java
+nyc-island-foxes-2016/kiwi-overflow	javascript
+webfactorybulgaria/Core	php
+plainas/tq	python
+kbrock/rubygems.org	ruby
+redox-os/kernel	rust
+Microsoft/vscode-comment	typescript
+swarmer/restnotifier	c
+bmorton/deployster	go
+helycopternicht/elazarev	java
+xdv/gatewayd	javascript
+za419/GAMR	php
+vesln/robber.py	python
+unepwcmc/SAPI	ruby
+despawnerer/langid-rs	rust
+yuki24/force	typescript
+goblint/analyzer	c
+ReactiveGo/rx	go
+cisco-system-traffic-generator/trex-java-sdk	java
+heroku/cli	javascript
+zachgibson/thewhitneypaige.com	php
+dirn/Simon	python
+walle/gas	ruby
+Marwes/embed_lang	rust
+sysgears/apollo-universal-starter-kit	typescript
+wiiudev/pyGecko	c
+brightbox/gobrightbox	go
+Shyri/long-task-service	java
+dennisfrank/patternlab-scaffolding	javascript
+wunderkraut/WunderTools	php
+plone/plone.server	python
+cysjonathan/coursemology2	ruby
+rsertelon/habitat	rust
+start/up	typescript
+skarnet/s6-rc	c
+mattheath/kraken	go
+ming13/gambit	java
+jdthomas718/ClassRat	javascript
+andreas22/omnipay-fasapay	php
+lauft/timew-report	python
+jurrick/mighty_grid	ruby
+rust-av/rust-av	rust
+seokju-na/geeks-diary	typescript
+rbsexton/sockpuppet	c
+k0pernicus/goyave	go
+Blackrush/Rocket	java
+tum-ase-33/rest-server	javascript
+rowanhill/wiremock-php	php
+AmiiThinks/amii-tf-nn	python
+yous/sawarineko	ruby
+ragnese/exercism-rust	rust
+Nersent/Wexond	typescript
+xNUTs/MIT-Mobile-for-iOS	c
+osuripple/api	go
+metova/privvy	java
+uiheros/react-native-redux-todo-list	javascript
+ppy/osu-web	php
+ludwiktrammer/django-tagging-autocomplete	python
+paulelliott/authem	ruby
+aturon/async-benches	rust
+shioyang/StatsBar	typescript
+htcondor/htcondor	c
+mojotech/situation-room	go
+KeithYokoma/Amalgam	java
+mwilliamson/mammoth.js	javascript
+talib570/LazyRecord	php
+pyinvoke/invocations	python
+rrrene/inch	ruby
+graydon/rust	rust
+treylon/node-secure-password	typescript
+SoylentGraham/libmv	c
+captncraig/caddy	go
+kierarad/gocd	java
+uw-it-aca/myuw	javascript
+jdesrosiers/resourceful	php
+jaylett/django_exceptional_middleware	python
+influitive/markety	ruby
+vojtechkral/cargo	rust
+gpbl/react-day-picker	typescript
+radare/spp	c
+magic003/alice	go
+stevenpost/beaform	java
+sindresorhus/ava	javascript
+pollopolea/core	php
+nosamanuel/dj-queryset-manager	python
+rapid7/metasploit-credential	ruby
+daboross/fern-rs	rust
+StoDevX/AAO-React-Native	typescript
+actinium/cppMatrix	c
+antham/envh	go
+bink81/java-experiments	java
+Orodan/Hilary	javascript
+barryvdh/laravel-debugbar	php
+ap--/python-oceanoptics	python
+key-amb/poloxy	ruby
+sourrust/flac	rust
+microsoft/vscode	typescript
+enverarslan/DataStructures	c
+efritz/reception	go
+ozwillo/ozwillo-kernel	java
+frocher/bnb_app	javascript
+jjjjcccjjf/davao-aguilas	php
+millerdev/django-nose	python
+alcesleo/lasp	ruby
+faern/rips	rust
+andrerpena/react-mde	typescript
+TeamVee-Kanas/android_kernel_samsung_kanas	c
+viciious/go-tarantool	go
+VKCOM/vk-java-sdk	java
+satyavh/meteor-emails	javascript
+devmophp/DevmoPHP	php
+ssanderson/interface	python
+DigitalCurationCentre/roadmap	ruby
+cosmo0920/ruroonga_command	rust
+AgentME/DefinitelyTyped	typescript
+abanaiyan/sniper	c
+polydawn/go-sup	go
+micheljung/downlords-faf-client	java
+i-lateral/silverstripe-stripe-forms	javascript
+grrr-amsterdam/garp3	php
+ryanraaum/oldowan.mtdna	python
+ctti-clinicaltrials/aact	ruby
+rust-lang/miri	rust
+influxdata/influxdb	typescript
+svn2github/webrtc-Revision-8758	c
+kusabashira/acgen	go
+i-net-software/JWebAssembly	java
+HPI-Hackathon/find-my-car	javascript
+onticsoluciones/nofraud	php
+oemof/feedinlib	python
+negativetwelve/react-native-lookback	ruby
+zonyitoo/bson-rs	rust
+DTU-R3/ArloBot	typescript
+kenhys/fake-lock-screen-pattern	c
+dylanvee/libtorrent-go	go
+Aeronica/mxTune	java
+medikoo/es5-ext	javascript
+Khan/phabricator	php
+madmaze/pytesseract	python
+thogg4/spree	ruby
+SBSTP/rust-igd	rust
+blockstack/opendig	typescript
+LTD-Beget/dovecot	c
+jimmified/jimmify-server	go
+mbrossard/cryptonit-cloud	java
+mpalourdio/SpringBootAngularHTML5	javascript
+DoSomething/rogue	php
+timraasveld/ansible-string-split-filter	python
+kstarsinic/homebrew-versions	ruby
+google/rrg	rust
+ProtonMail/WebClient	typescript
+smaccm/camkes-tool	c
+weaviate/weaviate	go
+parzonka/prm4j	java
+serverboards/serverboards	javascript
+DerManoMann/acache	php
+otknoy/michishiki_api_server	python
+eregon/mspec	ruby
+copy/v86	rust
+BeSite/jQuery.mmenu	typescript
+SiftScience/sift-ios	c
+kwagdy/koding-1	go
+steve1rm/busbymovies	java
+donlink1/jolliTestSideBar	javascript
+christopher-johnson/phabricator	php
+alexmilesyounger/ds_basics	python
+BinaryMuse/rforce-wrapper	ruby
+carols10cents/sassers	rust
+ChronusEU/lib-tminus.js	typescript
+erwango/zephyr	c
+icambridge/gomposer	go
+iychoi/biospectra	java
+stencila/node	javascript
+WWXD/WorldWeb-XD	php
+adampiskorski/lpr_poc	python
+airslie/renalware-core	ruby
+yupferris/rustendo64	rust
+sammydre/ts-for-gjs	typescript
+mcschroeder/ghc	c
+herald-it/goncord	go
+CS2103JAN2017-T16-B4/main	java
+nossas/bonde-client	javascript
+jordanv215/moparvinson-jordanpwp	php
+ranisalt/enigma	python
+GCorbel/smart_management	ruby
+pgrzesik/learning-rust	rust
+crowi/crowi	typescript
+royel21/STM32F103GNU	c
+90TechSAS/libgo-docker-guard	go
+robolectric/deckard-maven	java
+kayaelle/msol-badger	javascript
+dadish/ProcessGraphQL	php
+infOpen/ansible-role-vsftpd	python
+rapid7/sonar-client	ruby
+attilahorvath/exercism-rust	rust
+Workable/aggregator-eip	typescript
+vinamarora8/IAAI	c
+madhanrm/hcsshim	go
+OpenAMEE/amee.platform.api	java
+tomanistor/osprey	javascript
+jolantis/altair	php
+chubbymaggie/asap	python
+riyad/homebrew-cask	ruby
+Grieverheart/dsfmt-rs	rust
+videogular/videogular2	typescript
+agacek/util_libs	c
+nekikara/flagparse	go
+nisrulz/android-examples	java
+Flieral/Announcer-Service	javascript
+borNfreee/tactician-domain-events	php
+girder/girder_worker	python
+cohei/homebrew-cask	ruby
+vickenty/perl-xs	rust
+AArnott/Nerdbank.GitVersioning	typescript
+showcode/tools	c
+Anaminus/rbxmk	go
+capergroup/bayou	java
+ayrtonvwf/lite-admin	javascript
+fashionweb/moraso	php
+atiberghien/makerscience-server	python
+hakanensari/peddler	ruby
+w4tson/early-tea	rust
+ashwinr/DefinitelyTyped	typescript
+benjic/web-server	c
+daemonl/go_lib	go
+indr/335	java
+jwadhams/json-logic-js	javascript
+tehoko/lane	php
+KuChanTung/Python	python
+clappr/clappr-ios	ruby
+algorithm-ninja/task-wizard	rust
+Atyantik/react-pwa	typescript
+artem-ogre/simpson	c
+cloudfoundry/cli	go
+mickkay/MinecraftForge	java
+alfredoem/gulp-prelude	javascript
+jasny/formbuilder-angular	php
+globocom/database-as-a-service	python
+hotvulcan/whitehall	ruby
+brianp/muxed	rust
+unional/ava-fixture	typescript
+ecaselles/Kiwi	c
+pasinskim/deployments	go
+grayben/10K-item-extractor	java
+benrowe/laravel-config	javascript
+anomalylabs/users-module	php
+Stark-Mountain/meetup-facebook-bot	python
+Shopify/shipit-engine	ruby
+nbigaouette/rust-sorting	rust
+mixitconf/mixit	typescript
+grigaci/BIObjCHelpers	c
+pgombola/gomad	go
+core9/module-authentication-standard	java
+ecohealthalliance/GoodQuestion	javascript
+SlateFoundation/slate	php
+claudiopastorini/claudiopastorini.github.io	python
+linkedin/cassette	ruby
+veorq/oee	rust
+Dart-Code/Dart-Code	typescript
+conformal/spectrwm	c
+tbroyer/ocspd	go
+castle/castle-java	java
+meisyal/MIM	javascript
+Viktor-s/f	php
+b123400/purescript-ide-sublime	python
+bengler/tiramisu	ruby
+BonsaiDen/discord-bot	rust
+ecsnavarretemit/sarai-ng2	typescript
+Zaladar/PPM	c
+SteelSeries/golisp	go
+Techern/carpentersblocks	java
+martindale/fabric	javascript
+RoboJackets/apiary	php
+bshaffer/appengine-python-vm-hello	python
+jwt/ruby-jwt	ruby
+DualSpark/rust-aws	rust
+fqqb/yamcs	typescript
+jsventek/Cache	c
+rainycape/gondola	go
+obidea/semantika-cli2	java
+tightenco/ziggy	javascript
+phpgt/webengine	php
+chop-dbhi/django-webhooks	python
+stanclai/redmine_git_hosting	ruby
+mrobinson/rust-layers	rust
+dpmcmlxxvi/turf	typescript
+skarnet/skalibs	c
+irwansyahwii/Pattern-Oriented-Software-Architecture-With-Go	go
+FAForever/faf-java-api	java
+rafaelstz/regenerator	javascript
+scherersoftware/cake-monitor	php
+jwarshaw/RaspberryDrive	python
+jinutm/silverprod	ruby
+aidancully/rust	rust
+shlomiassaf/DefinitelyTyped	typescript
+Tatsh/libbinarycookies	c
+lsk-kun/lantern	go
+wbknez/schelling	java
+rogierslag/mjml	javascript
+IronSummitMedia/startbootstrap-freelancer	php
+aikramer2/spaCy	python
+patatepartie/local_apt	ruby
+Twinklebear/tray_rust	rust
+lathonez/clicker	typescript
+wistoch/meego-app-browser	c
+pachyderm/pfs	go
+nearit/Android-SDK	java
+trevormunoz/katherine-anne	javascript
+APaikens/GoalioForgotPassword	php
+alexgarciac/scrapi	python
+fgrehm/chef-dokku	ruby
+BurntSushi/regexp	rust
+raviqqe/code2d	typescript
+llvm-mirror/compiler-rt	c
+sgeb/go-tuikit	go
+thatafischer/feevale-multiuserchat-2015	java
+LLK/scratch-vm	javascript
+juriansluiman/SlmQueueBeanstalkd	php
+karel-brinda/prophyle	python
+stevenhaddox/cookbook-rvm_fw	ruby
+OJFord/tapioca	rust
+terascope/teraslice	typescript
+HenryRLee/PokerHandEvaluator	c
+FurqanSoftware/papyrus	go
+zafarella/java-design-patterns	java
+jpartogi/projexion	javascript
+sitkoru/context-cache	php
+etataurov/pytest	python
+code-management/netrc	ruby
+oconnor0/system-zero	rust
+driftyco/ionic-cli	typescript
+strazzere/dexterity	c
+vonwenm/fnlog	go
+smithkm/gcs	java
+ShawnTe/guardian	javascript
+aginev/datagrid	php
+khchine5/opal	python
+hashicorp/vault-rails	ruby
+ddevlin/rustlings	rust
+Retrospring/retrospring	typescript
+gumpt/cilium	c
+Southern/async	go
+Slikey/EffectLib	java
+c4fcm/Promise-Tracker-Builder	javascript
+friendica/friendica	php
+hatbot-team/hatbot_resources	python
+weddingparty/epicify	ruby
+DarkEld3r/match_any	rust
+bkimminich/juice-shop	typescript
+LiuShulong/Kiwi	c
+mistsys/tuntap	go
+microsoftgraph/msgraph-sdk-java	java
+TrueCar/gluestick	javascript
+Programie/AlbumShowcase	php
+ellmetha/machina-singlepageapp	python
+zettajs/ZettaKit	ruby
+jorendorff/cell-gc	rust
+orangain/kifu-notebook	typescript
+Lavesson/api-mock	c
+bragr/dns	go
+m4tx/arroch	java
+BOZ2323/virun	javascript
+cedricziel/l5-shariff	php
+seibert/numba	python
+CharlesMilam/tatalog	ruby
+Laastine/zombie-shooter	rust
+gamejolt/widgets	typescript
+sjinks/qt_eventdispatcher_epoll	c
+janos/httputils	go
+cstroe/spendhawk-java	java
+Chan4077/angular-rss-reader	javascript
+WaveHack/OpenDominion	php
+earlwlkr/POICrawler	python
+aarongustafson/jekyll-crosspost_to_medium	ruby
+wahn/Rust_Examples	rust
+graywolf336/temporary-rocketlets-ts-definition	typescript
+LuboO/iCalendar-parser_PA193_Rteam	c
+mmstick/i3gostatusbar	go
+DarkMorford/BetterThanWeagles	java
+wycats/blue-ridge	javascript
+marcoraddatz/activecollab-slack	php
+ideascube/ideascube	python
+cosmo0920/homebrew-cask-coreclr	ruby
+rust-fuzz/cargo-fuzz	rust
+the-concierge/concierge	typescript
+saminiir/level-ip	c
+dpb587/metalink	go
+AdamsTHDev/mgl-planlv-project	java
+getfrank/tachyons	javascript
+mb-projects/mbtheme-mtalents	php
+group-policy/rally	python
+tsuru/homebrew-tsuru	ruby
+danylaporte/node-rust-resemble	rust
+2muchcoffeecom/ngx-restangular	typescript
+HPCToolkit/hpctoolkit	c
+cloudfoundry/staticfile-buildpack	go
+gernd/simple-site-mon	java
+keybase/client	javascript
+WyriHaximus/TwigView	php
+funkybob/paws	python
+travis-ci/packer-templates	ruby
+Sgeo/hlist	rust
+ikr/react-period-of-stay-input	typescript
+biosbits/libffi	c
+jimthematrix/fabric	go
+billy93/forplay	java
+zdfs/bliss	javascript
+Exercise/FOQElasticaBundle	php
+analyst-collective/dbt	python
+thecartercenter/elmo	ruby
+google/tock-on-titan	rust
+NakedObjectsGroup/NakedObjectsFramework	typescript
+leapmotion/autowiring	c
+cerana/cerana	go
+ganymedes01/Et-Futurum	java
+Dermah/pulsar	javascript
+nachopro/followlink	php
+scanner-research/scanner	python
+amatriain/feedbunch	ruby
+jpypi/rustix	rust
+ruedap/alfred-font-awesome-workflow	typescript
+Tricertops/Objective-Chain	c
+brandur/sorg	go
+balazspete/crystal-game	java
+marynganga/FunSquare	javascript
+naturalsciences/Darwin	php
+ScanOC/trunk-player	python
+qnyp/smiling	ruby
+dpc/slog-rs	rust
+slackapi/node-slack-sdk	typescript
+dmtaylor/cmps111-proj4	c
+oshothebig/goflow	go
+MC-U-Team/U-Team-Core	java
+bbcyyb/on-tasks	javascript
+dilawar/ncbs-minion	php
+saltstack/salt	python
+yumingjuan/selenium	ruby
+emk/credentials	rust
+jsse-2017-ph23/web-frontend	typescript
+yamnikov-oleg/cgo-callback	c
+hajimehoshi/ebiten	go
+boundary/meter-plugin-sdk-java	java
+Darkrender/raptor-ads	javascript
+graphp/plaintext	php
+cherba/apitools	python
+theodi/csvlint	ruby
+Wandalen/wTools	rust
+romancow/ts-geometry	typescript
+simonpf/root	c
+golang/appengine	go
+jahed/crowd-play	java
+megos/asagao	javascript
+Pikkulahti/leijonaa	php
+RainCity471/lyCompiler	python
+crowdAI/crowdai	ruby
+owaspjocur/servo	rust
+KamiKillertO/vscode-colorize	typescript
+bloom-lang/c4	c
+F5Networks/k8s-bigip-ctlr	go
+gramboid/RxAppFocus	java
+ajacksified/reddit-mobile	javascript
+stratedge/passport-facebook	php
+chiphogg/vim-vtd	python
+ManageIQ/manageiq-ui-classic	ruby
+magum/rust-rosetta	rust
+google/chicago-brick	typescript
+jamespearce2006/CefSharp	c
+wickedchicken/dwd-go	go
+NUBIC/psc-mirror	java
+iTerminate/traveler	javascript
+phoenixgao/laravel-postgres-extended-schema	php
+patrickspencer/mathdeck	python
+iiet/iiet-git	ruby
+raineszm/rust-blas	rust
+tsg-ut/slackbot	typescript
+nickolasburr/git-stashd	c
+mrekucci/epi	go
+apache/commons-jexl	java
+RakanNimer/react-google-charts	javascript
+garciaf/fabbook	php
+brainwane/zulip	python
+svcastaneda/phase-0	ruby
+kkimdev/autograd	rust
+wiktor-k/infrastructure-tests	typescript
+Payshare/libsodium	c
+thaJeztah/distribution	go
+nulab/zxcvbn4j	java
+FleetOnRails/fleet-web-app	javascript
+danielsan80/MeasureBundle	php
+handroll/handroll	python
+thoughtbot/neat	ruby
+d-unseductable/ruru	rust
+deegles/cookietime	typescript
+DDVTECH/mistserver	c
+chadev/Chadev_ircbot	go
+benmfaul/XRTB	java
+tddbin/tddbin-frontend	javascript
+tailwindlabs/tailwindcss	php
+sl2017/campos	python
+teeparham/gemdiff	ruby
+servo/rust-http	rust
+SimonSchick/EliteDangerousUtils	typescript
+Kromey/roglick	c
+ninjasphere/hc	go
+EBIBioSamples/biosamples-v4	java
+worldbank-cdrp/disaster-risk-explorer	javascript
+wowtransfer/chdphp	php
+wiliamsouza/hystrix-py	python
+eventide-project/log	ruby
+godcoin/godcoin	rust
+jovotech/jovo-framework-nodejs	typescript
+dawehner/root	c
+ewbankkit/terraform	go
+ablenesi/ELTEProjectToolsTeam09	java
+RaphaelDeLaGhetto/gebo-registrant-hai	javascript
+tonightsystems/alf-cms	php
+dimagi/commcare-hq	python
+solidusio-contrib/solidus_subscriptions	ruby
+cosmo0920/ruroonga	rust
+michaelbull/zoom.ts	typescript
+shockkolate/shockk-os	c
+google/mtail	go
+SOM-st/black-diamonds	java
+codeforamerica/streetmix	javascript
+simplesamlphp/simplesamlphp-module-openid	php
+thiderman/network-kitten	python
+jspizziri/spree	ruby
+WPO-Foundation/gnirehtet	rust
+emugaya/bucketlist_frontend	typescript
+wnh/prompt_utils	c
+photoshelf/photoshelf-storage	go
+CS2103AUG2016-W14-C1/main	java
+skidding/flatris	javascript
+WeMoveEU/bsd_api	php
+kefir500/ghstats	python
+adamthedeveloper/wepay-rails	ruby
+skade/leveldb	rust
+gluons/font-awesome-openui5	typescript
+muxi/grpc	c
+keep94/Dominator	go
+c-rack/czmq	java
+gefs-plugins/fmc-requirejs	javascript
+symfony/HttpKernel	php
+JungeAlexander/cocoscore	python
+key-amb/fireap	ruby
+gyn/exercism	rust
+Discordius/Lesswrong2	typescript
+adobe/chromium	c
+mtibben/confusables	go
+mgenov/sitebricks	java
+kiwiirc/irc-framework	javascript
+swt83/php-inline	php
+ohsu-qin/qipipe	python
+railsmachine/lita-ext	ruby
+anthgur/servo	rust
+mike-north/ember-api-actions	typescript
+AppliedLogicSystems/ALSProlog	c
+materials-commons/mcstore	go
+phoenixnudt/OWL2VOWL	java
+EricCat/Node-File-Delete	javascript
+beberlei/AzureDistributionBundle	php
+sergey-dryabzhinsky/dedupsqlfs	python
+eloy/debox_server	ruby
+erickt/cargo	rust
+GoogleChrome/web-vitals	typescript
+thinnect/tos-groundlib	c
+orifinkelman/incubator-trafficcontrol	go
+imCodePartnerAB/iVIS	java
+imiric/usearch	javascript
+facilis/users	php
+t-miyamae/teuthology	python
+vinsol/Spree-Unified-Payments	ruby
+hackndev/zinc	rust
+opennode/waldur-homeport	typescript
+groonga/groonga	c
+cloudfoundry-incubator/runtime-schema	go
+dhanji/sitebricks	java
+jeremyruppel/vmplate	javascript
+VitSalis/endofcodes	php
+0xPoly/ooni-probe	python
+frc-frecon/frecon	ruby
+kassens/relay	rust
+faddiv/budget-keeper	typescript
+eaburns/pbnf	c
+yorickdewid/gocraw	go
+davido/gerrit-reviewers-plugin	java
+dollarshaveclub/ember-cli-anybar	javascript
+sgmendez/example_api_rest	php
+sorgerlab/indra	python
+bugsnag/bugsnag-js	ruby
+mhallin/juniper	rust
+drumonii/LeagueTrollBuild	typescript
+PeterWangIntel/chromium-crosswalk	c
+abiosoft/ishell	go
+fimtra/datafission	java
+pipedrive/client-nodejs	javascript
+evanmaastrigt/kwetal-workdays	php
+nvbn/thefuck	python
+fureigh/change-my-record	ruby
+serde-rs/serde	rust
+Alfresco/alfresco-ng2-components	typescript
+joel-porquet/tsar-uclibc	c
+owulveryck/google-app-example	go
+groupon/Selenium-Grid-Extras	java
+kpdecker/next.js	javascript
+million12/M12.Foundation	php
+aosp-mirror/platform_external_skia	python
+leonid-shevtsov/knife-solo	ruby
+edunham/regex	rust
+mollie/mollie-api-node	typescript
+utahiosmac/Marshal	c
+vektorlab/otter	go
+repeats/Repeat	java
+benjamn/offgrid-lights	javascript
+OParl/dev-website	php
+masasin/spirit	python
+nurelm/quickbooks_integration	ruby
+warricksothr/dft	rust
+endeavourhealth/EDS	typescript
+iTermin/app_iOS	c
+shiena/go-gitbucket	go
+philippsied/smartcard-course	java
+vekat/vcat	javascript
+M2Mobi/lunr	php
+benedicteb/outcast	python
+ashrafuzzaman/stips	ruby
+stewart/rff	rust
+debugworkbench/hydragon	typescript
+aaronmjacobs/openal-soft	c
+mgutz/logxi	go
+shineM/gh4a	java
+TarrinRos/PizzaShop	javascript
+vrap/project-b	php
+SEL-Columbia/commcare-hq	python
+thredup/sidekiq-grouping	ruby
+corragon/rust-raytracer	rust
+madigan/ncounter-ng2	typescript
+cdzombak/thingshub	c
+l1jiang/govmomi	go
+pivotal-bank/portfolio-service	java
+sblask/firefox-open-tabs-next-to-current	javascript
+hiqdev/hipanel-module-finance	php
+OCA/stock-logistics-warehouse	python
+jmespath/jmespath.rb	ruby
+philyoon/rust	rust
+V-Paranoiaque/Ellas-War	typescript
+FreeScienceCommunity/PLPlot	c
+v2tec/watchtower	go
+UweTrottmann/thetvdb-java	java
+indexzero/read-ssl	javascript
+Clidus/dumplog-website	php
+lemming52/white_knight	python
+SvetoslavKuzmanov/asteroids	ruby
+dcuddeback/libudev-rs	rust
+citizenlabsgr/voter-engagement	typescript
+aldebaran/libport	c
+ghmeier/coinage	go
+codecop/ugly-trivia-kata	java
+fernandocanizo/choodo	javascript
+axton21/voting-app	php
+egafford/sahara	python
+Joel-B-Williams/Meandr	ruby
+saulius/croaring-rs	rust
+jacobjojan/angular2-webpack-starter	typescript
+tomdev2008/energy	c
+DataDog/go-datadog-api	go
+devhub-tud/devhub-prototype	java
+nicolasmccurdy/procrastinate	javascript
+DoSomething/aurora	php
+jdevera/subdue	python
+mbj/axiom-arango-adapter	ruby
+dbrodie/rex	rust
+davidsidlinger/DefinitelyTyped	typescript
+shahedmolla/test	c
+eriol/piken	go
+kashike/SpongeAPI	java
+ForbesLindesay/thread-sleep	javascript
+michaelletzgus/nextcloud-server	php
+VirusTotal/misp-modules	python
+page-io/middleman-s3_sync	ruby
+dwillmer/rust	rust
+devonzuegel/clarity	typescript
+iree-org/iree	c
+mmcgrana/pg2librato	go
+Gamealition/SignShopExport	java
+acingraham/AwwFrame	javascript
+lwiesel/delivery-tracking	php
+benedfit/SublimeLinter-contrib-pug-lint	python
+NYULibraries/rooms	ruby
+pnkfelix/mon-artiste	rust
+DAXaholic/vscode-edifact	typescript
+redforks/thermostat	c
+albfan/gdblib	go
+OpenMods/OpenPeripheral-Addons	java
+IonicaBizau/arc-assembler	javascript
+xemlock/htmlpurifier-html5	php
+thebinarypenguin/SublimeLinter-contrib-raml-cop	python
+osu-cascades/ecotone-web	ruby
+ruma/ruma	rust
+PakL/TTVStreamerTool	typescript
+reeFridge/learn-oop-through-cpp	c
+revl/autoforge	go
+joonhocho/react-native-linkedin-sdk	java
+roschaefer/rundfunk-mitbestimmen	javascript
+hardywen/captcha	php
+csrocha/account_journal_payment_subtype	python
+yeban/sequenceserver	ruby
+GBGamer/rust	rust
+ikatyang/dts-element	typescript
+atropelando/terceiro-ano-programacao	c
+strivecast/hcl	go
+VisualDataWeb/OntoBench	java
+Leko/WEB-EGG	javascript
+bearsunday/BEAR.Resource	php
+pombreda/seascope	python
+hpcloud/unix_cli	ruby
+iKevinY/ultra	rust
+ravendb/ravendb-nodejs-client	typescript
+Roadagain/Calculator	c
+luci/luci-go	go
+NCIP/psc	java
+joaquindev/learning-mongoose	javascript
+aalfiann/reSlim	php
+tanayseven/personal_website	python
+teespring/envm	ruby
+amongil/bluenine	rust
+edhager/widget-core	typescript
+elupus/osek	c
+1and1/soma	go
+Enoro/commons-compress	java
+firebug/firebug.next	javascript
+Sylius/Cart	php
+pinry/pinry	python
+mthssdrbrg/kafka-cookbook	ruby
+ConnyOnny/Cursive-Break	rust
+grafana/grafana	typescript
+honux77/practice	c
+phalaaxx/ratemilter	go
+snowble/vertical-stepper	java
+pinittome/proxy	javascript
+romhut/criterion	php
+geelweb/laposte-python-sdk	python
+opscode-cookbooks/partial_search	ruby
+fabianschuiki/moore	rust
+fsahmad/tsuml-demo	typescript
+mihaimaruseac/dphcar	c
+billhathaway/webcounter	go
+Mahtimursut/ohtu	java
+webkom/eslint-config-webkom	javascript
+app-zap/PHPFramework	php
+phil-lopreiato/the-blue-alliance	python
+bdunne/manageiq-automation_engine	ruby
+bpowers1215/MoneyMap	rust
+Picturepark/Picturepark.SDK.TypeScript	typescript
+barbagroup/cuIBM	c
+pierrre/mangadownloader	go
+UweTrottmann/trakt-java	java
+franvarney/franvarney-api	javascript
+Parabot/BDN-V3	php
+EnvGen/toolbox	python
+gocardless/que	ruby
+dtolnay/thiserror	rust
+spinnaker/deck	typescript
+Lightricks/ocmock	c
+bdastur/utils	go
+bdezonia/zorbage	java
+georapbox/jsEssentials	javascript
+Lecturize/Laravel-Taxonomies	php
+openaustralia/publicwhip-matthew	python
+KarmaHater/WikiEduDashboard	ruby
+Ticki/libterm	rust
+denismaster/dcs	typescript
+nadirs/dmgemu	c
+nono/cozy-stack	go
+Ullink/slack4gerrit	java
+agustim/fiberfy-server	javascript
+RhubarbPHP/Website	php
+thorgate/django-project-template	python
+ontohub/ontohub	ruby
+mbrubeck/servo	rust
+sanity-io/sanity	typescript
+tjarratt/twIRCk	c
+oftc-ftw/stove	go
+elBukkit/MagicPlugin	java
+wh1tney/recordly	javascript
+okulbilisim/ojs	php
+monostable/haskell-kicad-data	python
+theresaboard/theres-a-board	ruby
+tempbottle/ProjectEulerRust	rust
+third774/ng-bootstrap-form-validation	typescript
+btrask/hash-archive	c
+rgooch/Dominator	go
+xkrogen/gobblin	java
+Syncano/syncano-dashboard	javascript
+digitalkaoz/BetterReflection	php
+OpenSpace/OpenSpace	python
+obsidian-btc/data-aggregation-index	ruby
+zaeleus/rust	rust
+hansl/devkit	typescript
+Chase-san/libspec	c
+ying32/govcl	go
+fabzo/kraken	java
+eamonnbell/sortzzi	javascript
+guzzle/guzzle3	php
+planetlabs/datalake-ingester	python
+deathwish/absinthe	ruby
+shepmaster/sxd-rust	rust
+minestarks/TypeScript	typescript
+sbc100/native_client	c
+wanelo/image-server	go
+mysangle/algorithm-study	java
+yannickglt/esreflect	javascript
+GeneaLabs/Phpgmaps	php
+yamatt/bonfiremanager	python
+integrallis/stripe_event	ruby
+ThomasColliers/age-of-rust	rust
+hychen/ke-e	typescript
+postmodern/libBERT	c
+liggitt/osin	go
+klausw/hackerskeyboard	java
+albburtsev/talaria	javascript
+Shopify/theme-sync	php
+wkentaro/chainer	python
+Shopify/Hermann	ruby
+stepancheg/rust-protobuf	rust
+BillWagner/TypeScriptAngular2	typescript
+JFLarvoire/SysToolsLib	c
+jacobsa/aws	go
+watsonarw/twu-biblioteca-andrewwatson	java
+Calvin-Huang/LiveAPIExplore-Server	javascript
+kicks-app/kicks-app-wordpress	php
+Dybov/real_estate_agency	python
+satoryu/tepco_usage_api	ruby
+shssoichiro/oxipng	rust
+Team-CHAD/DevDecks	typescript
+chaoran/fast-wait-free-queue	c
+ninjasphere/go-openzwave	go
+duckAsteroid/osgi-test	java
+mfgea/grunt-dredd	javascript
+Sylius/Currency	php
+Astroua/aws_controller	python
+henrinormak/NSDateComponents-HNExtensions	ruby
+l1048576/fbx_direct	rust
+kulshekhar/ts-jest	typescript
+Juniper/libslax	c
+cortesi/devd	go
+edaubert/jongo	java
+rubenv/grunt-mkdir	javascript
+ku2ma2/design_pattern	php
+nagilum/script.rndmov	python
+mission-of-mercy/momma_dashboard	ruby
+servo/sharegl	rust
+misoukrane/did-or-wish	typescript
+Herbstein/kernel-of-truth	c
+gcapizzi/moka	go
+n-zeplo/TW101_Exercises	java
+edi9999/jsqrcode	javascript
+DoSomething/northstar	php
+lsgunth/rapidsms	python
+srcclr/commit-watcher	ruby
+knsd/from-ascii	rust
+christophd/citrus-admin	typescript
+BeImprovised/gambit	c
+cloudfoundry-community/asp.net5-buildpack	go
+sormuras/bach	java
+thatPamIAm/weathrly	javascript
+mantisbt-plugins/source-integration	php
+yeasy/robot_tool	python
+mkllnk/openfoodnetwork	ruby
+amhk/lokatt	rust
+lit/lit.dev	typescript
+telefonicaid/fiware-cosmos-platform	c
+QuentinPerez/scaleway-cli	go
+cloudfoundry/cf-java-client	java
+WhitestormJS/whs.js	javascript
+Korko/SecretSanta.fr	php
+ShivamSarodia/ShivyC	python
+insight-meditation-center/imc-bootstrap-sass	ruby
+benstreb/astroids-rust	rust
+rishii7/vscode	typescript
+timkettering/SwitecX25	c
+containers/storage	go
+freeVM/freeVM	java
+stuartkeith/webaudiosequencer	javascript
+nordsoftware/yii-paytrail	php
+stefanklug/plata	python
+daynix/rebuild	ruby
+nickbabcock/boxcars	rust
+DSI-HUG/dejajs-components	typescript
+Luminarys/synapse	c
+celrenheit/lion	go
+bitcoin-solutions/multibit-hd	java
+Brightspace/jquery-valence-ui-more-less	javascript
+DarvinStudio/darvin-utils	php
+willdavidc/piel	python
+knapo/jquery-colorbox-rails	ruby
+kmcallister/rust	rust
+crdschurch/crds-signin-checkin	typescript
+coreux/liberrno	c
+donatj/explainer	go
+smartcommunitylab/sco.carpooling	java
+myntra/react-native	javascript
+jordandukart/islandora_xacml_editor	php
+henriquebastos/virtualenv-bootstrap	python
+chrisfinazzo/homebrew-core	ruby
+lipanski/trello-rs	rust
+yysun/apprun	typescript
+lglucin/Halide	c
+dotcominternet/platform	go
+matco/simcity	java
+jackrzhang/boardsession	javascript
+SolidInvoice/SolidInvoice	php
+ianfieldhouse/number_to_words	python
+vaneyckt/Jently	ruby
+dtolnay/syn	rust
+thenickreynolds/popcorngif	typescript
+duckinator/boreutils	c
+lukevers/go-and-hack	go
+benbenw/jmeter	java
+ufocoder/redux-universal-boilerplate	javascript
+wiltosoft/laravel	php
+sindrig/spoppy	python
+k0kubun/specinfra	ruby
+Gyscos/Cursive	rust
+webcomponents/polyfills	typescript
+GNOME/libchamplain	c
+landonia/landotube	go
+zsoltii/dss	java
+proglottis/oyster	javascript
+jonuy/dosomething	php
+rlee287/pyautoupdate	python
+alphagov/publishing-api	ruby
+am0d/rust-projects	rust
+yadomi/lastagram	typescript
+zwaldowski/AZCoreRecord	c
+kalafut/finiki	go
+Ghostlyr/MinecraftForge	java
+TheLudd/unary	javascript
+KnpLabs/KnpRadBundle	php
+bharling/django-pint	python
+TechnoGate/contao	ruby
+Nicoretti/xxd-rs	rust
+notbakaneko/osu-web	typescript
+syscoin/syscoin	c
+mingrammer/go-codelab	go
+miguel250/Robotics	java
+gldraphael/chordsheet	javascript
+benignware/wp-bootstrap-hooks	php
+jackromo/RandTerrainPy	python
+stephenbm/chef-server	ruby
+jimmycuadra/rust-etcd	rust
+pbraunstein/trackercise	typescript
+digama0/lean	c
+groob/micromdm	go
+DBCG/cql_measure_processor	java
+emberjs/ember-legacy-controllers	javascript
+silverorange/swat	php
+ayushgoel/LongShot	python
+danielfarrell/common_event_formatter	ruby
+jinnjuice/solicit	rust
+FernCreek/tinymce	typescript
+dpt/Containers	c
+schmichael/metafora	go
+jypma/lambda-behave	java
+burninggarden/pirc	javascript
+silverstripe-labs/silverstripe-environmentcheck	php
+reedstrm/Pyrseas	python
+zoocasa/geos-extensions	ruby
+Stebalien/udev-rs	rust
+kdechant/eamon	typescript
+svn2github/libpqxx	c
+maxamillion/flamingo	go
+Addepar/buck	java
+fi-ksi/web-frontend	javascript
+eustasy/browning-a-mailgun-script	php
+andylytical/brewpi-scripts	python
+milewdev/power	ruby
+ron-rs/ron	rust
+ryanluker/vscode-coverage-gutters	typescript
+Atom058/ArduinoLithiumCharger	c
+FriendlyLinuxPlayers/flip.earth	go
+hal/elemento	java
+sauravmndl/service-fabrik-broker	javascript
+nordsoftware/lumen-doctrine	php
+HHS-IntroProgramming/Multiplication-table	python
+lpichler/manageiq	ruby
+kkirstein/hdf5-rs	rust
+upfluence/oss-components	typescript
+llvm-mirror/libcxx	c
+aabizri/navitia	go
+CRollin/ptiChat	java
+gocd/gocd.github.io	javascript
+pantheon-systems/cli	php
+wyager/IHaskell	python
+leandroo/flexi_generators	ruby
+ebfe/syscall.rs	rust
+looker-open-source/embed-sdk	typescript
+dscho/dovecot	c
+walac/taskcluster-worker	go
+JetBrains/teamcity-azure-plugin	java
+khwang/plum	javascript
+bar5z6/swe2015groupl	php
+opnfv/functest	python
+gocardless/business	ruby
+carols10cents/adventofcode-rs	rust
+easyfuckingpeasy/chrome-reddit-comment-highlights	typescript
+jeremiedecock/snippets	c
+gu-bin/bosh-agent	go
+iEli2tyree011/EllyCheat	java
+mstange/cleopatra	javascript
+Piou-piou/ribs-framework	php
+amolenaar/gaphor	python
+abenson/sweep	ruby
+Armavica/99-Problems-Rust	rust
+fvilers/angular2-training	typescript
+plast-lab/cclyzer	c
+delta24/gist	go
+trivago/Heimdall.droid	java
+henrikra/gym-diary	javascript
+meng-tian/php-soap-interpreter	php
+potatolondon/contentious	python
+chefspec/chefspec	ruby
+olajep/gcc-explorer	rust
+ghidello/cli	typescript
+talk-to/Chocolate	c
+mrtazz/checkmake	go
+CCI-MIT/XCoLab	java
+fbaumgardt/arethusa	javascript
+TypiCMS/Pages	php
+pavel-paulau/perfrunner	python
+labocho/action_mailer_config	ruby
+martica/rusty	rust
+guyellis/plant-image-lambda	typescript
+ycaihua/skim-app	c
+carlmjohnson/junix	go
+havarunner/havarunner	java
+cyberkoi/discourse-spoiler-alert	javascript
+freephile/qb	php
+AlexHill/mezzanine	python
+ddrmanxbxfr/active_fulfillment	ruby
+termoshtt/ndarray-linalg	rust
+wikimigrate/wikimigrate	typescript
+zhuhaow/libnekit	c
+khlieng/name_pending	go
+StubbornJava/StubbornJava	java
+mtheoryx/react-redux-es6	javascript
+boonex/trident	php
+sassoftware/mint	python
+zuku/bmff	ruby
+mcarton/rust-plague	rust
+hjobrien/desktop	typescript
+vidya-ranganathan/algorithms	c
+brooklyncentral/brooklyn-cli	go
+ESSICS/org.csstudio.display.builder	java
+publiclab/Leaflet.DistortableImage	javascript
+mcrumm/phlack	php
+hackerspace-ntnu/website	python
+rohanpm/rcov-cobertura	ruby
+djc/askama	rust
+richmondwang/string-to-obj	typescript
+yusuga/YSProcessTimer	c
+sstark/droguedrums	go
+pentaho/pentaho-commons-xul	java
+foam-framework/foam2	javascript
+mpociot/reauthenticate	php
+paylogic/py2deb	python
+Schniz/mail	ruby
+cjgreenaway/rubbem	rust
+harksys/HawkEye	typescript
+eikel/EScript	c
+mewkiz/flac	go
+queshaw/dita-ot	java
+tijmenb/spotlight	javascript
+MelcherSt/HTweb	php
+oliverlee/antlia	python
+gmcculloug/sprint_statistics	ruby
+sacherjj/rust	rust
+DeborahK/Angular-Routing	typescript
+Staance/tailproduce	c
+life1347/fission	go
+spring-cloud/spring-cloud-cloudfoundry-service-broker	java
+1flow/1flow	javascript
+symphonists/markdown_typography	php
+voer-platform/vp.repo	python
+greg5green/homebrew-cask	ruby
+yinyanlv/runner	rust
+storybooks/storybook	typescript
+dafrito/alpha	c
+alecthomas/chroma	go
+mrdon/SAL	java
+Cwejman/martina	javascript
+ansendu/php-libevent	php
+exekias/django-achilles	python
+nju520/pry	ruby
+SirRade/homepage	rust
+dotCMS/dotJS	typescript
+globbie/knowdy	c
+ibrt/go-oauto	go
+realityforge/arez	java
+materials-commons/materialscommons.org	javascript
+kubernetes/examples	php
+ikaruswill/vector-space-model	python
+empirical-org/Empirical-Core	ruby
+cuviper/rayon	rust
+michaelgira23/MyMICDS-v2	typescript
+chmorgan/libesphttpd	c
+miketheprogrammer/go-thrust	go
+ChestShop-authors/ChestShop-3	java
+schaui6/yodalize	javascript
+wappr/digitalocean	php
+goldmann/docker-scripts	python
+CannyFoxx/gallery	ruby
+Nukesor/Pueue	rust
+googleinterns/step250-2020	typescript
+coldfix/setcapslock	c
+grooveshark/golib	go
+codenvy/plugin-datasource	java
+qgrid/ng	javascript
+emgiezet/errbitPHP	php
+tzengyuxio/python-five91	python
+eregon/rubyspec	ruby
+eqrion/cbindgen	rust
+MurhafSousli/ng2-sharebuttons	typescript
+eingaeph/pip.imbue.hood	c
+kyleterry/tenyks	go
+braintree/braintree_android	java
+substance/texture	javascript
+cachethq/Laravel-Segment	php
+Doist/todoist-python	python
+Pitt-CSC/handy	ruby
+ratel-rust/ratel-server	rust
+hasman16/rent-a-ref	typescript
+Billy4195/Simple_Chatroom	c
+instana/golang-sensor	go
+perdona/titanium_mobile	java
+tenevdev/beacon-valley-hackathon	javascript
+stdtabs/phptabs	php
+datasciencebr/serenata-toolbox	python
+pvalena/rails	ruby
+matt-thomson/github-sweep	rust
+mustpax/sortmybox	typescript
+lefou/kdepim-noakonadi	c
+barnardb/nomad	go
+mohamad-z/dnsjava	java
+MyPureCloud/skype-for-business-purecloud-app	javascript
+orchestral/resources	php
+jeanmask/opps-admin	python
+hubert/comptroller	ruby
+LukasKalbertodt/xswag-syntax-java	rust
+aredotna/ervell	typescript
+fxsjy/galaxy	c
+ymichael/sessions	go
+smartlogic/smartchat-android	java
+bbondy/bloom-filter-js	javascript
+paulboco/laravelerator	php
+fprimex/zdesk	python
+DigitalReflow/spina-projects	ruby
+cmr/ioctl	rust
+mihailik/TypeScript	typescript
+leecrest/luv	c
+wwitzel3/juju	go
+rgupta1234/jboss-eap-quickstarts	java
+bolinfest/line-ending-selector	javascript
+mfairchild365/wubbles	php
+praekelt/go-contacts-api	python
+fsek/web	ruby
+quvarxa/basic2d	rust
+studieresan/overlord	typescript
+kasper93/sanear	c
+johnny-morrice/godelbrot	go
+ralscha/eds-starter6-mongodb	java
+klambycom/Skissa-och-gissa	javascript
+dshafik/markua	php
+MisanthropicBit/bibpy	python
+ausaccessfed/saml-service	ruby
+johannhof/markdown.rs	rust
+dainst/idai-field-web	typescript
+AMechler/AliPhysics	c
+vektra/cypress	go
+bitsquare/bitsquare	java
+twisty/formsy-react-components	javascript
+monooso/glossary.craft-plugin	php
+thismachinechills/save_skype	python
+AlexLittlejohn/ALCameraViewController	ruby
+RustAudio/synth	rust
+jupyter/jupyterlab	typescript
+Icenowy/RUtil2	c
+sosedoff/envd	go
+commonmark/commonmark-java	java
+UTD-CSLLC/Door-Karma-Client	javascript
+etsy/phan	php
+lucianovdveekens/jiradoc	python
+MLSDev/the_bullet-generator	ruby
+endoli/disassemble.rs	rust
+laodice/ionic-conference-app-session2	typescript
+Checkcoin/checkcoin	c
+DarthSim/imgproxy	go
+CompilerWorks/spliceengine	java
+BBLN/data	javascript
+jlorente/yii2-notification-module	php
+ckan/ckanext-qa	python
+stas/methane	ruby
+febeling/edit-distance	rust
+toladata/TolaProfile	typescript
+simonaw/cutelyst	c
+status-im/status-go	go
+Genymobile/scrcpy	java
+ImageMarkup/isic-archive	javascript
+renothing/kanboard	php
+hyunchel/redis-dump-load	python
+ljfranklin/middleman-homepage	ruby
+pduval/rustic_hal	rust
+ngx-rocket/generator-ngx-rocket	typescript
+lechkulina/RealmsOfSteel	c
+alienth/go-fastly	go
+m039/beacon-keeper	java
+3-Round-Stones/callimachus	javascript
+Yubico/u2fval-client-php	php
+ondergetekende/python-panavatar	python
+boutil/roxml	ruby
+nabijaczleweli/chattium-oxide-lib	rust
+skatejs/skatejs	typescript
+sferik/libxml-ruby	c
+atlassian/git-lob	go
+retest/recheck	java
+GreenImp/rpg-dice-roller	javascript
+marcaube/oauth2-server	php
+tarpas/pytest-testmon	python
+ubpb/metacrunch-mab2	ruby
+dtolnay/anyhow	rust
+cloudevents/sdk-javascript	typescript
+aclements/sv6	c
+vardius/go-api-boilerplate	go
+AvaIre/AvaIre	java
+davidrayoussef/full-screen-gif-slider	javascript
+lossendae/Previously-on	php
+yola/proxyprefix	python
+alphagov/whitehall	ruby
+dirvine/rust-utp	rust
+tscholl2/smc	typescript
+hxptls/P0000	c
+kusabashira/prod	go
+telefonicaid/fiware-cosmos-platform	java
+developer239/workbox-webpack-react	javascript
+StealThisShow/StealThisTracker	php
+ScatterHQ/eliot	python
+1337807/rubygems.org	ruby
+naoty/table	rust
+Sarah-Seo/Inpad	typescript
+tizoc/chibi-shen	c
+shiftky/go-tmsh	go
+synchrotron-soleil-ica/continuous-materials	java
+lm-tools/work-you-could-do	javascript
+LidskaSila/Glow	php
+NewKnowledge/punk	python
+PagerDuty/lita-pagerduty	ruby
+ms705/nom-sql	rust
+daveross/catalogopolis-api	typescript
+MTG/essentia	c
+ninjasphere/go-ninja	go
+mrts/vaadin-javaee-clinic-patient-queue-example	java
+fma2/nyc-high-school-programs	javascript
+nailsapp/module-comment	php
+rdo-management/ironic-discoverd	python
+daxadax/quotes	ruby
+softprops/hyperlocal	rust
+jacwright/typewriter	typescript
+viccc/AHKNavigationController	c
+AdamIsrael/juju	go
+mcada/syndesis-qe	java
+openspending/subsidystories.eu	javascript
+joindin/joindin-web2	php
+igstan/redis-grep	python
+dark-panda/ncsa-parser	ruby
+glyn/jvmkill	rust
+awayjs/awayjs-player	typescript
+llvm-mirror/libclc	c
+sttts/elastic-etcd	go
+ChrisLMerrill/muse	java
+jonsuh/hamburgers	javascript
+soilby/queue-http-endpoint-bundle	php
+opencord/voltha	python
+deliveroo/ravelin-ruby	ruby
+Rust-SDL2/rust-sdl2	rust
+pancho111203/JsonFormsEditor	typescript
+xhochy/libfuzzymatch	c
+jroimartin/syscallinfo	go
+AxonFramework/AxonFramework	java
+sanity-io/sanity	javascript
+noopable/zf2	php
+xandr2/blynkapi	python
+jphager2/pakyow	ruby
+mvdnes/element76	rust
+BD2K-DDI/ddi-web-app	typescript
+MarcoFalke/bitcoin	c
+smkell/resolutionizerd	go
+ryanbrainard/shoehorn	java
+ceolter/ag-grid	javascript
+delighted/delighted-php	php
+exoanalytic/python-skyfield	python
+ekylibre/ekylibre	ruby
+hoodie/iso8601	rust
+flubstep/engvalues	typescript
+mlatham/AFToolkit	c
+kusabashira/catn	go
+NCIP/national-biomedical-image-archive	java
+bpsinc-native/src_third_party_trace-viewer	javascript
+DOut4Harambe/starter-quotes	php
+hobarrera/django-afip	python
+bboe/sync_issues	ruby
+justinas/gettext	rust
+craft-ai/most-utils	typescript
+gribozavr/swift	c
+cnejame/ygor	go
+reportportal/commons-dao	java
+Tokimon/vanillajs-helpers	javascript
+dwightwatson/autologin	php
+Connexions/cnx-publishing	python
+nycdot/transam_core	ruby
+portier/portier-broker	rust
+georgemarshall/DefinitelyTyped	typescript
+raoulh/Enna-Media-Server	c
+bobtfish/docker-consul-awsnycast	go
+vsplf/vsplf-dynamic-i18n	java
+ethan605/react-native-zero	javascript
+letsdrink/ouzo	php
+Charcoal-SE/SmokeDetector	python
+jhilde/studentinsights	ruby
+exonum/exonum	rust
+gcriva/gcriva-frontend	typescript
+gsamokovarov/chip8.c	c
+brettchalupa/dat	go
+ebi-uniprot/QuickGOBE	java
+yamb/yamb	javascript
+hypothesis/wordpress-theme-hypothesis	php
+pfmoore/invoke	python
+tutsplus/build-a-ruby-product-for-the-long-run	ruby
+gnuvince/ppbert	rust
+kactus-io/kactus	typescript
+giginet/CCMessageWindow	c
+mdlayher/goat	go
+squix78/esp8266-oled-ssd1306-font-converter	java
+navjobs/upload	javascript
+foodsharing-dev/foodsharing-api	php
+Calysto/metakernel	python
+smtlaissezfaire/active_conductor	ruby
+cwandrews/ed	rust
+flybayer/next.js	typescript
+AlexanderMazaletskiy/UICountingLabel	c
+nlopes/slack	go
+malikov/platform-android	java
+marihachi/CrystalResonance	javascript
+justcarakas/forkcms	php
+CCI-MOC/GUI-Backend	python
+marxarelli/vagrant	ruby
+mattgreen/watchexec	rust
+witheve/eve-starter	typescript
+binlaten/framework	c
+pointlander/peg	go
+aureliano/achmed	java
+taoger/highlight.js	javascript
+dilawar/moodle	php
+harvard-lil/h2o	python
+jpmat296/homebrew-cask	ruby
+uptech/alt	rust
+vvfosprojects/sovvf	typescript
+NLP/NLP	c
+fimad/ggircd	go
+ngageoint/mage-android	java
+SomeoneWeird/new.nodejs.org	javascript
+rinvex/cortex-foundation	php
+binoculars/osf.io	python
+theablefew/goodyear	ruby
+felipesere/icepick	rust
+AlexChesters/ukpd	typescript
+Morphux/lib	c
+rancherio/go-rancher	go
+jswudi/alluxio	java
+walmartlabs/circus-handlebars	javascript
+bakape/r-a-d.io	php
+kjordahl/swm	python
+indeep-xyz/ruby-insensitive-search	ruby
+eyolfson/eyl-shell	rust
+jjhampton/angular2-tour-of-heroes	typescript
+AperEntertainment/AperCommon	c
+anacrolix/missinggo	go
+folio-org/okapi	java
+sbsmith86/neue	javascript
+FlorentMetz/flotz	php
+tomv564/LSP	python
+icyflame/cutouts	ruby
+graememcc/netStack	rust
+scania/corporate-ui	typescript
+embox/embox	c
+giancosta86/caravel	go
+Otanikotani/jacoco-parser	java
+rakuten-frontend/rff-gulp	javascript
+castlegateit/cgit-wp-breadcrumb-nav-menu	php
+thomasballinger/tmuxp	python
+cenit-io/cenit	ruby
+opp11/calcr	rust
+abraham/nutmeg-cli	typescript
+ijacquez/libyaul	c
+airbrake/gobrake	go
+mikera/magic	java
+matrix-org/matrix-react-sdk	javascript
+shopixco/magento-clixgalore	php
+philipdexter/vx	python
+Eric-Guo/refinerycms	ruby
+aepsil0n/rust	rust
+azkurban/ng2	typescript
+chubbymaggie/asap	c
+trasa/watchmud	go
+Team08DatabaseProject/Healthy-Food-Ltd.	java
+AbhilashSrivastava/haraka_sniffer	javascript
+zburke/omnipay-bluepay	php
+OnroerendErfgoed/crabpy	python
+upinetree/nicorepo	ruby
+matthiasbeyer/imag	rust
+hslayers/hslayers-ng	typescript
+yenWu/DDNS	c
+kayex/chalmers-chop	go
+testpress/android	java
+unexpectedjs/unexpected	javascript
+memborsky/irexinc.org	php
+gviot/nadis	python
+scotdalton/dayglo	ruby
+antifuchs/chars	rust
+xaverh/vscode-clang-format-provider	typescript
+natsys/mariadb_10.2	c
+vanng822/aguin	go
+davidmaignan/JDrive	java
+lakrme/atom-levels	javascript
+Osiruss/ForumTest	php
+moreati/b-prefix-all-the-doctests	python
+yonahforst/react-native-permissions	ruby
+rust-lang/reference	rust
+steveukx/git-js	typescript
+achingupta/arm-trusted-firmware	c
+tv42/becky	go
+juve/corral	java
+watilde/npm-report	javascript
+fluxbb/commonmark	php
+rudeb0t/DjangoAllowDeny	python
+aliyun-beta/aliyun-openapi-ruby-sdk	ruby
+hch12907/wiz	rust
+sauli6692/ibc-server	typescript
+rgde/lz4mt	c
+divtxt/raft-consensus	go
+yichen0831/SpaceMission	java
+PonteIneptique/arethusa	javascript
+Metrique/laravel-building	php
+bodbdigr/restea	python
+landrito/google-cloud-ruby	ruby
+lise-henry/crowbook	rust
+nodeswork/sbase	typescript
+tdenniston/Halide	c
+go-task/task	go
+jakriz/derrick	java
+TheBeastOfCaerbannog/kinospartak-bot	javascript
+opdavies/sculpin	php
+7ws/django-emailer	python
+wsmoak/chargify-examples	ruby
+Fraser999/sodiumoxide	rust
+akorchev/odata2openapi	typescript
+nerdishbynature/octokit.swift	c
+Chasego/cod	go
+stefan-ka/dddsample-core	java
+sharaal/dnode	javascript
+remxcode/laravel-base	php
+mandiant/ioc_writer	python
+tumblr/ostrichpoll	ruby
+squid-lang/squid	rust
+JakeSidSmith/sensible-canvas-interface	typescript
+jordemort/e17	c
+yumaikas/PISC-mirror	go
+spark/photon-tinker-android	java
+torbenbrodt/smarthome	javascript
+BNETDocs/bnetdocs-web	php
+cloudify-cosmo/tosca-vcloud-plugin	python
+opsb/patchstream	ruby
+jroesch/rust	rust
+landonepps/vscode	typescript
+dtzWill/ipcopter	c
+CloudyKit/jet	go
+gr8pefish/OpenGlider	java
+controversial/controversial.io	javascript
+guillaumebriday/laravel-blog	php
+alisaifee/flask-limiter	python
+tim-group/stackbuilder	ruby
+rustoscript/french-press	rust
+tbragaf/ng2-seed	typescript
+rvandegrift/e	c
+jonlawlor/matrixexp	go
+liachmodded/Railcraft-API	java
+sakmas/RetainerReport	javascript
+nekodex/osu-web	php
+xmunoz/sodapy	python
+joshmcarthur/disclosure	ruby
+1tgr/rust-os	rust
+aranja/tux	typescript
+google/perfetto	c
+Thomasdezeeuw/tools	go
+project-ncl/dependency-analysis	java
+adamsea/recipes-api	javascript
+svpernova09/SvperCRM	php
+mass-project/mass_api_client	python
+kif-ev/oskiosk-server	ruby
+KokaKiwi/rust	rust
+scottohara/loot	typescript
+klaaspieter/APIClient	c
+kubernetes/apiextensions-apiserver	go
+googleinterns/step57-2020	java
+InTeXration/InTeXration-Server	javascript
+digitalkaoz/ivory-http-adapter	php
+gsarma/ChannelWorm	python
+dijonkitchen/shopping-api	ruby
+japaric/rustc-builtins	rust
+artsy/metaphysics	typescript
+xistoso/CppSharp	c
+dgageot/getme	go
+ivargrimstad/mvc-samples	java
+richarddewit/random-quotes	javascript
+davidtsadler/ebay-sdk-trading	php
+markbrough/exchangerates	python
+degica/barcelona	ruby
+rust-lang/libc	rust
+Dia6lo/Mechanism	typescript
+Geek-1001/Clue	c
+royvandewater/go-to-hell	go
+dimagi/commcare	java
+theredcat/forge	javascript
+kayladnls/doctrine-additions	php
+TangledWeb/tangled.sqlalchemy	python
+slawosz/rubinius	ruby
+mneumann/lindenmayer-system	rust
+Cinergix/rxdata	typescript
+Aufree/phphub-ios	c
+runner-mei/goal	go
+jaxbot/android-preconditioning-leaf	java
+airycanon/Ghost-Admin	javascript
+lokothodida/php-simplequery	php
+FlipperPA/wagtailpress	python
+talk-to/NSData-TDTImageMIMEDetection	ruby
+anastasia-tarasova/indy-sdk	rust
+AyaMorisawa/node-powerful	typescript
+ssp/Pester	c
+maruel/dlibox	go
+kuujo/copycat	java
+ASzc/selfish-youtube	javascript
+Hexanet/LogBundle	php
+TangledWeb/tangled.website	python
+SergXIIIth/vxod	ruby
+Danite/NainEngine	rust
+surveyjs/surveyjs	typescript
+podio/podio-objc	c
+simonjjones/atc	go
+sveinnfannar/finagle	java
+matrix-org/matrix-appservice-irc	javascript
+Hng-X/linxer	php
+sedders123/phial	python
+5xRuby/rubyconftw-cfp	ruby
+daschl/grok	rust
+RickCarlino/farmbot-web-app	typescript
+qnu/qfs	c
+anacrolix/dht	go
+bearing/dosenet-apps	java
+MaxWhere/electron	javascript
+neonbug/meexo	php
+JrGoodle/clowder	python
+handcrafted/foundation	ruby
+chriskrycho/lightning-rs	rust
+marvinhagemeister/mobx-form-reactions	typescript
+GaloisInc/halvm-ghc	c
+localhots/satan	go
+tcat-tamu/auth	java
+jonkemp/wizard-mvc	javascript
+libgraviton/graviton	php
+kevgathuku/top40	python
+nyc-mud-turtles-2015/nghborly	ruby
+dtolnay/quote	rust
+briandk/transcriptase	typescript
+adammurdoch/native-platform	c
+thoas/picfit	go
+joshsh/twitlogic	java
+DTL-FAIRData/FAIRifier	javascript
+Adldap2/Adldap2-laravel	php
+erikrose/blessings	python
+CrewLabs/tinplate	ruby
+jmacdonald/luthor	rust
+MadaraUchiha/se-chat-dark-theme-plus	typescript
+8l/scc	c
+mmcdole/gofeed	go
+adamski8/MyWeather	java
+jerelmiller/redux-simple-auth	javascript
+pfaocle/codeception-module-drupal-user-registry	php
+yola/auth_tkt	python
+mubi/user_preferences	ruby
+j16r/rust	rust
+AyaMorisawa/Disskey	typescript
+waysome/libreset	c
+pivotal-cf/cf-rabbitmq-release	go
+SpineEventEngine/core-java	java
+hanamura/gulp-minisite	javascript
+nooku/nooku-platform	php
+consbio/parserutils	python
+akshaykarle/veewee	ruby
+tov/libffi-rs	rust
+frt/happyscheduler	typescript
+jackromo/CNoodle	c
+moovweb/tritium	go
+facebook/litho	java
+adube/ngeo	javascript
+makeandship/acf-elasticsearch	php
+archsh/tg2ext.express	python
+brainopia/flow	ruby
+gentoo90/winreg-rs	rust
+virtuoushub/game-off-2016	typescript
+PaystackHQ/paystack-ios	c
+jimmidyson/minishift	go
+JRebirth/JRebirth	java
+madrobby/scripty2	javascript
+njam/denkmal.org	php
+MichaelYusko/Bot-Chucky	python
+jakerenzella/doubtfire-api	ruby
+sakeven/rust-rosetta	rust
+arusakov/DefinitelyTyped	typescript
+mtulio/kb	c
+cybozu-go/log	go
+rebasar/lunchy	java
+cedaro/cedaro-wp-theme-config	javascript
+mattsah/bustle	php
+ryanmcdermott/birdseed	python
+arkency/rails_event_store	ruby
+jedisct1/sodiumoxide	rust
+gluons/vue-thailand-address	typescript
+APCVSRepo/sdl_ios	c
+xqin/miniflux	go
+Brokkonaut/CubeQuest	java
+Turistforeningen/Hytteadmin	javascript
+activecollab/databasestructure	php
+mociepka/saleor	python
+turboladen/playful	ruby
+maghoff/bart	rust
+reactivestack/cookies	typescript
+e-mission/cordova-server-sync	c
+pivotal-cf-experimental/bosh-bootloader	go
+CapOM/ChromiumGStreamerBackend	java
+DoctorMcKay/node-steam-tradeoffer-manager	javascript
+ampproject/amp-toolbox-php	php
+GallopLabs/facebook-ads-api	python
+et/clamshell	ruby
+szeged/servo	rust
+Romakita/ts-express-decorators	typescript
+guilherme-pg/lyra2	c
+exercism/cli	go
+CDRussell/CasterRxJava	java
+ffont/freesound-explorer	javascript
+yapici/Inventory-Management-System	php
+rail/releasetasks	python
+dhemery/latex-markdown	ruby
+aldanor/typeinfo	rust
+rootulp/exercism	typescript
+cmr/seL4	c
+tardisx/discord-auto-upload	go
+MacroData/skyprint	java
+AyaNakazawa/business_card_bank	javascript
+kielabokkie/dotenv-diff	php
+sebdah/yayson	python
+WikiEducationFoundation/WikiEduDashboard	ruby
+nbigaouette/gitlab-api-rs	rust
+jupl/astraea	typescript
+mfrey/RIOT	c
+google/wuffs	go
+jenkinsci/codedx-plugin	java
+ScottMaclure/scott-cv	javascript
+omise/omise-magento	php
+serge-sans-paille/gast	python
+mnipper/rails_survey	ruby
+tohou/diesel	rust
+joelgeorgev/file-hash-verifier	typescript
+chaitanyav/cprograms	c
+pivotal-cf/cred-alert	go
+Zaggy1024/MinecraftForge	java
+nickmccurdy/purespec	javascript
+bryanlatten/docker-php	php
+adlibre/django-bcp	python
+beni55/falcor-1	ruby
+kjgorman/basiccms.rs	rust
+jiahaog/Nativefier	typescript
+joeljk13/Timer	c
+drewsetski/koding	go
+TeamWertarbyte/craften-launcher	java
+pluggerjs/plugger	javascript
+GeniusTS/preferences	php
+ayushgoel/mstranslator	python
+chef/em-winrm	ruby
+samdoshi/portmidi-rs	rust
+kiswa/TaskBoard	typescript
+fujunwei/chromium-crosswalk	c
+UserStack/ustackweb	go
+jitsi/jitsi	java
+HermanFassett/project-osiris-website	javascript
+symfony/security-core	php
+gilesbrown/python-icapservice	python
+rubyforgood/diaper	ruby
+kwantam/rust	rust
+pd4d10/intelli-octo	typescript
+KristFoundation/Programs	c
+jrupac/goliath	go
+quarkusio/quarkus	java
+gaearon/redux	javascript
+DarvinStudio/DarvinAdminBundle	php
+nigma/dj-cmd	python
+gds-attic/contact-o-tron	ruby
+rsaarelm/magog	rust
+ipatalas/vscode-postfix-ts	typescript
+jmurzy/nodegit	c
+pkg/browser	go
+filestack/filestack-java	java
+spherelot/teamboard-api	javascript
+souldigital/silverstripe-userforms	php
+srittau/rouver	python
+theodi/panopticon	ruby
+Wallacoloo/serde_osc	rust
+Goyatuzo/LurkerBot	typescript
+tbporter/http-server	c
+datawire/telepresence	go
+IchorPowered/Latch	java
+itsananderson/burden	javascript
+occitech/Occitech_ShopyMind	php
+VirgilSecurity/virgil-sdk-python	python
+Arie/serveme	ruby
+aepsil0n/graphics	rust
+MikeBull94/aurelia-hacker-news	typescript
+haxpor/playbasis-ios	c
+vrischmann/rdbtools	go
+scenarioo/scenarioo-selenium-demo	java
+mafintosh/protocol-buffers-schema	javascript
+BKWLD/upchuck	php
+verilylifesciences/analysis-py-utils	python
+fakefs/fakefs	ruby
+CensoredUsername/dynasm-rs	rust
+WorldBrain/WebMemex	typescript
+altMITgcm/MITgcm66h	c
+Logiraptor/oak	go
+pholser/junit-quickcheck	java
+UKHomeOffice/passports-prototype	javascript
+Simovative/zeus	php
+compunova/kozinaki	python
+t-morgan/sequel	ruby
+ghotiphud/rust-rosetta	rust
+eskatos/gradle-command-action	typescript
+yitian134/chromium	c
+materials-commons/materials	go
+theworldbright/SoundLocker	java
+otacke/h5p-agamotto	javascript
+frqnck/apix	php
+wangjohn/zinc_cli	python
+thekompanee/fuubar	ruby
+steveklabnik/rust_example	rust
+PioneerCode/pioneer-tree	typescript
+Jtalk/kopete-fork-xep0136	c
+keybase/client	go
+jimmyli97/mathosphere	java
+ohmanger/userscripts	javascript
+MTon/api	php
+SCUEvals/scuevals-api	python
+alphagov/manuals-publisher	ruby
+yasuyuky/ghteam-auth	rust
+ngako/angular2-poc	typescript
+daukantas/octokit.objc	c
+rafaeljusto/gddoexp	go
+jpaoletti/java-presentation-manager	java
+yangmillstheory/chunkify	javascript
+digitoimistodude/air	php
+ifduyue/urlfetch	python
+danielwestendorf/blow_pipe	ruby
+sgrif/diesel	rust
+algorithm-ninja/task-wizard	typescript
+Vector35/binaryninja-api	c
+mscoutermarsh/exercism_coveralls	go
+aislab-hevs/magpie	java
+PrasannaVenkadesh/portia	javascript
+hfcorriez/pagon	php
+cychiang/mafan	python
+Promoboxx/cookbooks_public	ruby
+nodakai/rust-static_assert_macro	rust
+Clever/node-process-metrics	typescript
+rbld/rebuild	c
+matt-royal/cf-acceptance-tests	go
+jerome79/OG-Platform	java
+codarchlab/idai-field-client	javascript
+at15/MissAtomicBomb	php
+mcmtroffaes/pathlib2	python
+jawj/passenger	ruby
+olson-sean-k/plexus	rust
+ospatil/generator-node-typescript	typescript
+nickelsberry/AXStretchableHeaderTabViewController	c
+lxc/lxd	go
+nallar/TickThreading	java
+hjtoday/CBoard	javascript
+DanTheDJ/multitenant	php
+tilezen/scoville	python
+BBC-News/alephant-renderer	ruby
+stallmanifold/rust-multiboot2	rust
+WeAreWizards/crumpets	typescript
+Raizlabs/BonMot	c
+facesea/banshee	go
+jpodeszwik/mifos	java
+firebug/tracing-console	javascript
+highway-accident/tracker	php
+pczerkas/captainhook	python
+mirego/bourgeois	ruby
+rprichard/rust	rust
+artfuldev/RIoT	typescript
+laarmen/lua_debug	c
+ranjithamca/gru	go
+ProxyPrint/proxyprint-kitchen	java
+yajinni/WoWAnalyzer	javascript
+nimbusoftltd/parrot	php
+benedictpaten/cactus	python
+kolorahl/warden-token	ruby
+ttokutake/kic	rust
+uwdata/vega-lite	typescript
+hgl888/chromium-crosswalk-efl	c
+pierreozoux/guides	go
+vespa-engine/vespa	java
+umasudhan/weather	javascript
+navarr/advent-of-code	php
+caktus/django-pagelets	python
+jnunemaker/httparty	ruby
+gifnksm/rust	rust
+joelgeorgev/react-checkbox-tree	typescript
+NiVZ78/concentricity	c
+HeiaHeia/trello-bot	go
+epimorphics/dclib	java
+metidia/waterline	javascript
+denkmal/denkmal.org	php
+suminb/urwid-stackedwidget	python
+jamesotron/MrDarcy	ruby
+tilpner/ilc	rust
+jbrowneuk/jblog	typescript
+ring-lang/ring	c
+go-interpreter/wagon	go
+conveyal/gtfs-data-manager	java
+rawrsome/firebase-simple-login	javascript
+mitchfizz05/Sphinx	php
+alphagov/stagecraft	python
+renewablefunding/huddle	ruby
+gustavla/numeric	rust
+inad9300/Soil	typescript
+jvns/kernel-module-fun	c
+cjcjameson/fly	go
+KILFaT/BudgetKeeper	java
+MyEtherWallet/MyEtherWallet	javascript
+rocketeers/rocketeer	php
+Connexions/cnx-authoring	python
+clhynfield/vagrant-ansible-osx	ruby
+way-cooler/way-cooler	rust
+disjukr/jews	typescript
+Zlacki/slackboat	c
+Cepave/open-falcon-backend	go
+athy/fape	java
+maxdome/maxdome-node	javascript
+dimitriacosta/html	php
+agoragames/py-eventsocket	python
+ilackarms/manageiq	ruby
+olson-sean-k/bismuth	rust
+Alberthaff/ngx-papaparse	typescript
+TolikH/ofp	c
+mistifyio/mistify-operator-admin	go
+ksoichiro/spring-boot-practice	java
+unkhz/almost-static-site	javascript
+moazam1/telegram-bot-sdk	php
+evoja/docker-Github-Gitlab-Auto-Deploy	python
+joeosburn/cannon	ruby
+DimaKudosh/difflib	rust
+Hersir88/Babylon.js	typescript
+GNOME/json-glib	c
+oakmound/oak	go
+damianham/react-native-audio-kit	java
+jonkemp/inline-css	javascript
+r3oath/hive	php
+incuna/feincms-extensions	python
+k1w1/rendered-multi-select	ruby
+bluss/quickcheck	rust
+oster/mute	typescript
+JuudeDemos/fb-adb	c
+pivotal-cf-experimental/destiny	go
+electrum/presto-hive-apache	java
+derektliu/Picky-Notes	javascript
+FriendsOfCake/CakePdf	php
+zmbq/djqgrid	python
+djsegal/julia_observer	ruby
+Techern/Netherrack	rust
+SevereOverfl0w/Unicorn-UI-Kit	typescript
+libfirm/libfirm	c
+danstis/Plex-Sync	go
+DevOpsDistilled/OpERP	java
+getninjas/gaiden	javascript
+cs278/bank-modulus	php
+kevinconway/rpmvenv	python
+cyber-dojo/web	ruby
+gadomski/sdc-rs	rust
+ABAPlan/abaplan-core	typescript
+learnclang/1-helloworld	c
+Roadagain/Chess	go
+Axway/ats-framework	java
+wooken/mptlog	javascript
+hannesvdvreken/guzzle-debugbar	php
+maxzheng/workspace-tools	python
+dplarson/gitlabhq	ruby
+emk/rust-cld2	rust
+crossroads-education/eta-cli	typescript
+Phyllostachys/junkcode	c
+kl4w/terraform	go
+cs3250-team6/msubanner	java
+darthjee/frog	javascript
+mkusher/padawan.php	php
+thsnr/gygax	python
+gavinlaking/troo	ruby
+klutzy/suruga	rust
+FarmBot/farmbot-web-app	typescript
+ZoranPandovski/al-go-rithms	c
+pivotal-cf-experimental/vizzini	go
+bcgit/bc-java	java
+vikpe/react-webpack-typescript-starter	javascript
+Hackathonners/swap	php
+theislab/dca	python
+hopshadoop/chef-glassfish	ruby
+nicokoch/gl-rs	rust
+artsy/reaction	typescript
+en90/pkg	c
+kingsamchen/Eureka	go
+pagarme/pagarme-java	java
+razh/osc-dev	javascript
+nicklaw5/twitch-api-php	php
+iamwucheng/xml_models2	python
+bobbytables/gemfiler	ruby
+klingtnet/rosc	rust
+jvilk/doppio-demo	typescript
+apple/swift-llvm	c
+weaveworks/flux	go
+gradle/gradle	java
+gaearon/normalizr	javascript
+fniephaus/SimpleDropboxUploader	php
+divio/django-cas	python
+isadaqah/irc-hipchat-integration	ruby
+mvdnes/rboy	rust
+yinxin630/fiora	typescript
+tiennou/objective-git	c
+li-ang/influxdb	go
+gogradle/gogradle	java
+Sleavely/OTWorlds	javascript
+hugomelo/ralsp	php
+johnpaulett/txHL7	python
+amateurhuman/active_esp	ruby
+jcolag/CommonCalendar	rust
+shamblesides/rpnow	typescript
+happyponyland/smallrl	c
+krasun/ProjectEulerSolutions	go
+janosgyerik/java-tools	java
+jeremija/peer-calls	javascript
+srayner/zend-db	php
+twig/django-taggit	python
+cegeka/puppet-rabbitmq	ruby
+tdaede/mpv-rice	rust
+mauve/vscode-terraform	typescript
+AltSysrq/tgl	c
+rafaeljribeiro/geocoder	go
+pushtechnology/diffusion-transform	java
+simplyianm/classtime	javascript
+NZRS/dnscheck	php
+gasman/Willow	python
+SpringMT/worker_scoreboard	ruby
+iKevinY/ghoti.rs	rust
+imribarr-compit/ng2-bootstrap	typescript
+blinkboxbooks/blinkbox-network.objc	c
+antontsv/twilio	go
+Bananeweizen/cgeo	java
+zillding/hangouts	javascript
+ashfordl/blog	php
+smarkets/statprof	python
+ArchimedesPi/printit	ruby
+solson/rin	rust
+Dynalon/redux-pattern-with-rx	typescript
+spewspew/TAOCP	c
+messagebird/go-rest-api	go
+kiorpesc/CS1622-Project3	java
+ExchangeCore/Concrete5-CKEditor	javascript
+persand/sfdaycgn2011	php
+360youlun/cmsplugin-bootstrap-carousel	python
+NUBIC/dagnabit	ruby
+andars/rust-calculator	rust
+to2mbn/skinview3d	typescript
+anton-simakov/ASFeedly	c
+holygeek/translator	go
+itszootime/geojson-java	java
+google/site-kit-wp	javascript
+osuripple/ripple	php
+ceball/param	python
+biow0lf/evemonk	ruby
+erik/sketches	rust
+concord-consortium/building-models	typescript
+blueseaguo/ios-library	c
+arapov/pile	go
+ratan12/Atarashii	java
+martindale/melody	javascript
+ffsantos92/bens-penhorados	php
+associazionepoltronieri/blender-ap	python
+paulmolin42/mjmr	ruby
+mario-kr/imag	rust
+Rebilly/ReDoc	typescript
+cinnamoncoin/Feathercoin	c
+sosedoff/howdy	go
+SteveWinfield/IDK-Server-Java	java
+ardeshirj/atom	javascript
+palmtreephp/canonical-url-bundle	php
+wikilinks/sift	python
+rwehresmann/stack_helper	ruby
+aochagavia/Serve	rust
+atomiks/tippyjs	typescript
+candy7393/VTK	c
+scipipe/scipipe	go
+Lydwen/CentralTrafficLightManagement-SmartCity	java
+tejasbubane/xecmascript	javascript
+richardhinkamp/giveandgo-website	php
+DesertBot/DesertBot	python
+benjaminhyw/rails-online-shop	ruby
+sfackler/rust-postgres	rust
+jonaskello/tslint-immutable	typescript
+appsembler/edx-app-ios	c
+jmalonzo/project-euler-solutions	go
+rhuss/sundrio	java
+lucy-marko/centrepoint	javascript
+Lab2Comp4711/comp4711-lab02	php
+4degrees/segue	python
+AnimaGUS-minerva/www	ruby
+Shraddha512/servo	rust
+sobstel/golazon	typescript
+Furkanzmc/StateManager	c
+ava-labs/avalanchego	go
+RBMHTechnology/apidoc-server	java
+pshendry/DevQuest	javascript
+aaaaadrien/marjo21	php
+holdenweb/nbtools	python
+nhocki/version_gemfile	ruby
+leonardinius/rust-guide	rust
+wishtack/ng-steroids	typescript
+charsyam/hiredis	c
+benjojo/aprs.go	go
+JEEventStore/JEECQRS	java
+Fluidbyte/ColtJS	javascript
+donatj/CorpusPHP	php
+openhealthcare/opal-referral	python
+listia/con_air	ruby
+Drakulix/zwreec	rust
+aaldaber/owid-grapher	typescript
+malensek/3RVX	c
+hashicorp/terraform	go
+tbrooks8/Precipice	java
+digabi/math-editor	javascript
+meanbee/articles-to-podcast	php
+BansheeMediaPlayer/bockbuild	python
+zhoutong/interapp	ruby
+mcpherrinm/baudot	rust
+kesarion/angular2-air-datepicker	typescript
+fsavje/scclust	c
+bahlo/godisc	go
+vivo-project/VIVO	java
+visionmedia/node-progress	javascript
+alberanid/bookmarks	php
+elacuesta/scrapy	python
+davidleach/onebody	ruby
+bvinc83/lz4-rs	rust
+CAAL/CAAL	typescript
+lees0414/EUproject	c
+jpfuentes2/go-env	go
+pmcs/nassau	java
+jsonmvc/jsonmvc	javascript
+pH7Software/pH7-Social-Dating-CMS	php
+mbr/flask-appconfig	python
+tomekw/yaml_converters	ruby
+0xd4d/iced	rust
+fyoudine/three.js	typescript
+whoshuu/cpr	c
+opentable/sous	go
+johanbrook/watchme	java
+msanatan/GitHubProjects	javascript
+sakara/PazWork	php
+ninjawil/weather-station	python
+taskrabbit/makara	ruby
+Hoverbear/rust-rosetta	rust
+Jameskmonger/isaac-crypto	typescript
+metora/MesaGLSLCompiler	c
+carlosbrando/lunchy	go
+jedrz/slisp	java
+mthmulders/lin2go	javascript
+futurable/backend	php
+sunlightlabs/thezombies	python
+kaosf/apns-s3	ruby
+mehcode/config-rs	rust
+DorianGrey/ng2-webpack-template	typescript
+google/skia	c
+cpmech/gosl	go
+monkey2000/Wikidata-Toolkit	java
+mozilla/openbadges-discovery	javascript
+Palethorn/Yeah	php
+PanDAWMS/panda-bigmon-atlas	python
+nguyenquangminh0711/ruby-sensor	ruby
+petertseng/exercism-rust	rust
+UITools/saleor	typescript
+danluu/setjmp-longjmp-ucontext-snippets	c
+jroimartin/tgbot	go
+GoogleCloudPlatform/appengine-gcs-client	java
+taylorzane/noflo-ui	javascript
+FreshRSS/update.freshrss.org	php
+varunarya10/oslo.i18n	python
+luwei2012/BlurryModalSegue	ruby
+theemathas/binary_turk	rust
+syuilo/Misskey	typescript
+delwink/libpatts	c
+cixtor/slackapi	go
+njmube/OpERP	java
+antoinechalifour/Reddix	javascript
+jonnybarnes/jonnybarnes.uk	php
+jefrailey/basic-scraper	python
+ywzw2013/CKRefreshControl	ruby
+Razaekel/noise-rs	rust
+artfuldev/tictactoe-ai	typescript
+cinode/cpptestapp	c
+shurcooL/go	go
+SEARCH-NCJIS/nibrs	java
+disquisition/serve	javascript
+laravel-zero/framework	php
+udibr/fuel	python
+hightower/cash_flow_analysis	ruby
+kinghajj/minimax-rs	rust
+ryohey/signal	typescript
+vortexntnu/rov-control	c
+concourse/concourse	go
+martijn-heil/KingdomEssentials	java
+ryym/babel-rewire-wrapper	javascript
+EugenZi/oro-platform-app	php
+haridsv/fabric	python
+guerrero/homebrew-cask	ruby
+alexwlchan/safari.rs	rust
+online-poker/poker-html-client	typescript
+giuliopaci/acopost	c
+abustany/go	go
+yuvraaz/android-push-notification	java
+BAJ-/robot-breakout	javascript
+sebastiaanluca/laravel-modules	php
+gadventures/gapipy	python
+bimmlerd/homebrew-versions	ruby
+imazen/imageflow	rust
+nmarsden/make-em-green	typescript
+hlnd/nrf51-simple-radio	c
+npe9/noahevans-go9	go
+sebhoss/annotated-contracts	java
+bustlelabs/content-kit-editor	javascript
+jeroendelau/slim-basic-auth	php
+sk-/python2.7-type-annotator	python
+unboxed/hrcomply-demo	ruby
+rhysd/git-brws	rust
+emc-mongoose/console	typescript
+prajnashi/ffmpeg	c
+callpraths/gorobdd	go
+detectiveframework/detective	java
+znetstar/broadway	javascript
+plattinum09/CMS_SENTRY	php
+mythmon/kitsune	python
+zwaldowski/BlocksKit	ruby
+sevagh/pqrs	rust
+wikiwi/react-jss-theme	typescript
+fgouget/spice	c
+ggoblin/goblin	go
+PDXFinder/pdxfinder	java
+freezy-sk/bootlint	javascript
+google/site-kit-wp	php
+j4mie/django-activelink	python
+bryckbost/memdash	ruby
+willsalz/actors	rust
+chipster/chipster-web	typescript
+kopasiak/gt	c
+cloudfoundry-incubator/cf-test-helpers	go
+bf8086/alluxio	java
+zarazi/movies-listie	javascript
+bauhausphp/package-container	php
+jwg4/flask-autodoc	python
+mygulamali/compare-sunrise-gems	ruby
+rootulp/exercism	rust
+CodeForCharlotte/cmpd-holiday-gift-backend	typescript
+cs2103aug2014-w10-1c/main	c
+RobinUS2/xyzfs	go
+MovingBlocks/Terasology	java
+rhysd/node-client	javascript
+leocavalcante/siler	php
+EmadMokhtar/halaqat	python
+Erol/specter	ruby
+muktakosh/unicorn	rust
+FoalTS/foal	typescript
+zhangzhehust/htcondor	c
+robdimsdale/wl	go
+stickfigure/gstrap-gae	java
+camayak/contentapi-medium-node	javascript
+timegridio/timegrid	php
+EDUlib/edx-platform	python
+bengler/tootsie	ruby
+phaazon/ion	rust
+MyMICDS/MyMICDS-v2-Angular	typescript
+JohnReid/myrrh	c
+DanShu93/trainspotter	go
+HubSpot/jackson-datatype-protobuf	java
+pedro-lucas/node-pdfbox	javascript
+dannyvankooten/vat.php	php
+Graylog2/graylog-ansible-role	python
+peter-murach/tty	ruby
+erickt/rust	rust
+pratheekhegde/a2-redux	typescript
+CodethinkLabs/ofc	c
+peteretelej/saf	go
+GerritCodeReview/gerrit	java
+ise-ethereum/on-chain-chess	javascript
+wpsvse/wpackagist	php
+armab/st2contrib	python
+ReadyResponder/ReadyResponder	ruby
+mayah/rust-puyoai	rust
+Urigo/angular-meteor	typescript
+mnaza/themis	c
+cloudfoundry-incubator/guardian-release	go
+weisJ/darklaf	java
+pirelenito/unbubble	javascript
+nailsapp/module-email	php
+KrzysztofSendor/dactyl	python
+MortadaAK/ProMotion	ruby
+gluon-lang/try_gluon	rust
+srackham/rimu	typescript
+hujiajie/pa-chromium	c
+tedsuo/ifrit	go
+scijava/scijava-jupyter-kernel	java
+gish/friskis-slack-booking	javascript
+bound1ess/adviser	php
+nurav/balrog	python
+nibua-r/testext	ruby
+PhilipDaniels/qork	rust
+Jigsaw-Code/outline-server	typescript
+pavelkryukov/putty-aes-ni	c
+pekim/gotk3	go
+ferreusveritas/Growing-Trees	java
+folio-org/stripes-core	javascript
+xiidea/EasyAuditBundle	php
+Pierre-Sassoulas/django-survey	python
+thii/homebrew-cask	ruby
+Acizza/anitrack	rust
+bluebirrrrd/nau-timetable	typescript
+ecalvovi/AliRoot	c
+mortdeus/goblin	go
+liujed/polyglot-eclipse	java
+facebook/draft-js	javascript
+Luceos/core	php
+microsoft/dpu-utils	python
+eonum/drg-search	ruby
+nvzqz/static-assertions-rs	rust
+Ecafracs/flatthirteen	typescript
+ppy/osu-framework	c
+Urethramancer/lbapi	go
+davidsusu/tree-printer	java
+nissoh/core	javascript
+billmn/gorilla	php
+PersonalGenomesOrg/open-humans	python
+ledermann/docker-rails	ruby
+xiph/rav1e	rust
+gamliela/starter-react-mobx-css-modules	typescript
+skarnet/s6-linux-init	c
+qasim/what-class-is-this	go
+aNNiMON/JECP	java
+ONSdigital/florence	javascript
+alfaproject/omnipay-skrill	php
+vayan/external-video	python
+rehanone/puppet-git	ruby
+tempbottle/rust-peg	rust
+nekodex/osu-web	typescript
+crontab/libobjc2	c
+zombiezen/go-log	go
+Suseika/collections-utils	java
+MichaelKohler/mozilla-watcher	javascript
+dafik/CodeGen	php
+simonjbeaumont/xcp-rrdd	python
+braintree/braintree-web-drop-in	ruby
+GuzTech/tray_rust	rust
+kawamon/hue	typescript
+jpoirier/picoc	c
+cloudfoundry-incubator/nsync	go
+robertoschwald/cas	java
+formidable-coffee/masterfully	javascript
+dweidner/laravel-goutte	php
+lozadaOmr/ansible-admin	python
+pinzolo/redmine_persist_wfmt	ruby
+adeschamps/lcm	rust
+sheldarr/Votenger	typescript
+ryepdx/keyphrase	c
+monzo/typhon	go
+aleph-zero/presto	java
+npmcomponent/ramitos-midway	javascript
+nordsoftware/lumen-core	php
+ulikoehler/UliEngineering	python
+dtan4/organicat	ruby
+Zamicol/Challenge	rust
+Flatline4/Flatline4	typescript
+echonest/libechonest	c
+PufferPanel/PufferPanel	go
+microprofile/microprofile-conference	java
+jamen/craze	javascript
+facile-it/paraunit	php
+kxxoling/fabric	python
+zurb/inky-rb	ruby
+musoke/inspirer	rust
+dragma/styled-bootstrap-grid	typescript
+AAChartModel/AAChartKit	c
+rancher/rancher	go
+InnovateUKGitHub/innovation-funding-service	java
+etopian/codebox-package-menubar	javascript
+Radvance/Radvance	php
+EmilStenstrom/nephele	python
+sandro/ephemeral_response	ruby
+spacejam/sled	rust
+molstar/molstar	typescript
+qtmediahub/sasquatch	c
+firestudios/qor-example	go
+ryanbrainard/richsobjects	java
+SentinelsOfMagic/SentinelsOfMagic	javascript
+unl/UNL_UCBCN_System	php
+chingc/DJRivals	python
+joeyates/ruby-sun-times	ruby
+terminalcloud/libnetfilter_queue	rust
+larsvanbraam/vue-transition-component	typescript
+isbadawi/badavi	c
+ianopolous/go-ipfs	go
+scottfrederick/spring-boot	java
+burningtomatoes/Bitsmashers	javascript
+dkgndec/DrupalConsole	php
+docsbox/docsbox	python
+Teino1978-Corp/Teino1978-Corp-kaminari	ruby
+fanderzon/rocket-api	rust
+rtsjs/rts	typescript
+darkbuck/Halide	c
+go-gl/gl	go
+gabrielavara/music-player	java
+weepower/wee-core	javascript
+dxw/php-missing	php
+uva-financial-engineering/cifer-tournament	python
+moneyadviceservice/mas-feedback	ruby
+crumblingstatue/rust-libnotify-sys	rust
+nrlquaker/nfov	typescript
+qsctr/vex-4194b-2016	c
+spacedock-io/registry	go
+Steveice10/MCProtocolLib	java
+CVBDL/EagleEye-App	javascript
+tmingos/sassy-roots	php
+OSGConnect/freesurfer_workflow	python
+mirego/hanzo	ruby
+Logicalshift/tame-tree	rust
+bradyholt/aspnet-core-react-template	typescript
+willpatterson/HOPSTACK	c
+bernardolins/clustereasy	go
+fhoeben/hsac-fitnesse-fixtures	java
+manifoldco/torus-cli	javascript
+DNepovim/kraj-praha	php
+aaronkurtz/bricky	python
+ifosch/skyed	ruby
+aptos-labs/aptos-core	rust
+shiftkey/desktop	typescript
+IFTTT/JazzHands	c
+resourced/resourced-master	go
+mrdon/AMPS	java
+dkrathi457/app	javascript
+hernantas/MangaReader	php
+worldforge/libwfut	python
+k0nserv/Humus	ruby
+jzhu98/telescope	rust
+paypac/node-concierge	typescript
+adobe-rnd/cordova-osx	c
+ephemeralsnow/packer	go
+mkarneim/luamod	java
+sigurdga/barteby	javascript
+kjhoerr/august-offensive	php
+churchlab/millstone	python
+matiaskorhonen/libpixel-ruby	ruby
+jonas-schievink/sneeze	rust
+tjoskar/ng2-lazyload-image	typescript
+netzimme/mbed-os	c
+myodc/go-micro	go
+pzn/clipapp	java
+mozilla/webmaker-app-cordova	javascript
+GrottoPress/jentil	php
+asteroide/immo_spider	python
+crepe/creperie	ruby
+snewt/bnf	rust
+Dkendal/battle_snake	typescript
+leovegetium/Trabalho-P	c
+rancher/k3s	go
+holandajunior/workaday	java
+squarewave/addons-frontend	javascript
+anqh/anqh	php
+odoo-chile/l10n_cl_account_vat_ledger	python
+ValiMail/griddler	ruby
+gchp/termbox-sys	rust
+polyaxon/polyaxon	typescript
+k0gaMSX/kcc	c
+lstolyarov/terraform	go
+Syncleus/aparapi	java
+rowanoulton/prefix-matches	javascript
+LaurentEsc/Laravel-Subdomain-Localization	php
+jeenalee/sklearn_pmml	python
+mahimahi42/microblogger	ruby
+minijackson/INF-4301A	rust
+robak86/neography	typescript
+cxd4/trig	c
+ccirello/gochatbot	go
+Arabidopsis-Information-Portal/intermine	java
+escaip/smart_bike	javascript
+symfony-cmf/Resource	php
+attenzione/SublimeLinter-scss-lint	python
+syncrou/manageiq	ruby
+dwrensha/capnproto-rust	rust
+arthot/calque	typescript
+filom/ASN1Decoder	c
+otoolep/raft	go
+apache/jmeter	java
+kiboit/phast	javascript
+vanderlee/PHPSwaggerGen	php
+pudo/spendb	python
+dtan4/c2y	ruby
+qdot/systray-rs	rust
+tsvetie/nativescript-cli	typescript
+kazmasaurus/CRToast	c
+wrapp/wrapplog	go
+malucs-developer/Android-Simulator	java
+bassettmb/slack-bot-dev	javascript
+imabug/raddb	php
+hackebrot/cibopath	python
+ruby/spec	ruby
+dinfuehr/rust	rust
+SaschaNaz/TypeScript	typescript
+greenplum-db/gpdb	c
+v4lproik/no-name	go
+rwinch/spring-security	java
+mzrimsek/resume_site	javascript
+alexweissman/UserFrosting	php
+mokieyue/mopidy	python
+chronogolf/lightspeed_restaurant	ruby
+ajroetker/rustc-serialize	rust
+gund/ng-http-interceptor	typescript
+BGWoodward/FishDetector	c
+melange-app/melange	go
+Team694/joebot	java
+CartoDB/Windshaft-cartodb	javascript
+biplobice/concrete5	php
+textbook/flask-forecaster	python
+heavenstudio/spree_pag_seguro	ruby
+keeperofdakeys/asn1-rs	rust
+BitGo/BitGoJS	typescript
+bespider/STTweetLabel	c
+asobti/kube-monkey	go
+VinnyQ/blueflood	java
+benefitcloud/ember-uploader	javascript
+wesley1001/Kurogo-Mobile-Web	php
+ncareol/spatialdb	python
+giedomak/table_cloth	ruby
+dati91/servo	rust
+t123yh/simple-sandbox	typescript
+cxa/MenuItemKit	c
+liam-middlebrook/csh-plug	go
+TehSAUCE/imagej	java
+MacPaw/eslint-config-webservices	javascript
+ponkrit/developer-test	php
+fna/owning-a-home-api	python
+lukeredpath/xcodesnippets	ruby
+stepancheg/rust-ide-rust	rust
+trustpilot/skift	typescript
+UrbanCompass/RMGallery	c
+scode/saltybox	go
+sake/bouncycastle-java	java
+intervention-engine/frontend	javascript
+siad007/json-schema	php
+gitpython-developers/GitPython	python
+solidusio-contrib/solidus_easypost	ruby
+bolinfest/serde-jsonrc	rust
+influxdb/influxdb	typescript
+anagromataf/Fountain	c
+Dirbaio/btcd	go
+outofcoffee/testcontainers-java	java
+TripleSpeeder/StandingOrderDapp	javascript
+jimmythongtran/recipe_tracker	php
+spyder-ide/qtawesome	python
+samvera/hyrax	ruby
+habitat-sh/habitat	rust
+j-f1/forked-desktop	typescript
+CollegeBart/bart-sdl-engine-e16	c
+StroblIndustries/codeutilsShared	go
+inbloom/secure-data-service	java
+tidepool-org/blip	javascript
+burnflare/CrowdBuy	php
+ravel-net/ravel	python
+postmodern/kramdown-man	ruby
+oxcable/oxcable	rust
+zentol/flink	typescript
+Gluttton/PslRK	c
+elwinar/adeptus	go
+kaltsimon/Chasing-Pictures-front-end	java
+bitclaw/apptmnt	javascript
+jeffersonmartin/code-examples	php
+humangeo/preflyt	python
+julik/mal	ruby
+mneumann/expression-rs	rust
+thehyve/glowing-bear	typescript
+robertmaynard/Sandbox	c
+mrekucci/euler	go
+HubSpot/jinjava	java
+pd4d10/tiza	javascript
+listabierta/census-ahoraencomun	php
+ucb-sts/sts	python
+backus/guard-rubocop	ruby
+ggez/ggez	rust
+dl988/quedro	typescript
+mk12/morse	c
+didip/tollbooth	go
+smalecki/motech	java
+dtekcth/dfotose	javascript
+mdlayher/wavepipe	php
+jlaunonen/kirppu	python
+dhensby/silverstripe-cms	ruby
+exe-dealer/rust-md5	rust
+goloveychuk/tsruntime	typescript
+rubenk/burp	c
+opencontainers/runc	go
+kits-ab/gakusei	java
+virtool/virtool	javascript
+phalcon/zephir	php
+matthiask/towel	python
+slate-studio/openapi-rails	ruby
+lowRISC/opentitan	rust
+dsebastien/DefinitelyTyped	typescript
+HalCanary/skia-hc	c
+mongrelion/gapp	go
+openmhealth/sample-data-generator	java
+amos-ws16/amos-ws16-arrowjs-server	javascript
+edvinaskrucas/counter-laravel	php
+jmiserez/sts	python
+amatsuda/nested_scaffold	ruby
+tsion/miri	rust
+sgtoj/cw-manage-slack-bot	typescript
+mlaz/mynewt-core	c
+buchgr/bazel-remote	go
+pilot51/voicenotify	java
+eJRF/ejrf	javascript
+stof/symfony	php
+teonlamont/mne-python	python
+twitter/twurl	ruby
+dylanmckay/protocol	rust
+amalshehu/angular-tour-of-heroes	typescript
+thomaskeck/root	c
+flynn-examples/go-flynn-example	go
+Microsoft/ApplicationInsights-Android	java
+mrkmarron/ChakraCore	javascript
+engram-design/FieldManager	php
+EinsamHauer/graphite-web-iow	python
+gina-alaska/ttnmanager	ruby
+Boddlnagg/rustup.rs	rust
+cannoneyed/fiddle	typescript
+dslab-epfl/asap	c
+go-playground/generate	go
+proxer/ProxerLibJava	java
+sgmap/mes-aides-ui	javascript
+jolantis/artlantis	php
+OCA/contract	python
+rasnom/sorryyoufeelthatway	ruby
+dtolnay/cxx	rust
+formigio/angular-frontend	typescript
+mundue/MMTrackingController	c
+guildencrantz/ask_nest	go
+hpautonomy/find	java
+shioyang/EmotionalReader	javascript
+atehnix/laravel-stubs	php
+spreadflow/spreadflow-core	python
+costolo/chain	ruby
+pacman82/odbc-sys	rust
+github/webauthn-json	typescript
+coreboot/chrome-ec	c
+projectatomic/buildah	go
+helun/Ektorp	java
+cysjonathan/coursemology2	javascript
+webfactory/content-mapping-sourceadapter-propel	php
+djangogirlstaipei/eshop	python
+benwbrum/fromthepage	ruby
+adRichter/plantex	rust
+artivilla/desktop	typescript
+deniscostadsc/playground	c
+willfaught/gockle	go
+danshannon/javastrava-test	java
+coryhouse/react-slingshot	javascript
+sparkframework/spark	php
+99designs/colorific	python
+r7kamura/altria-simple_cov	ruby
+nathanrosspowell/rust_guessing_game	rust
+murmur76/beyond.ts	typescript
+abusalimov/SublimeCImproved	c
+Versent/saml2aws	go
+QuickBlox/quickblox-android-sdk	java
+Jameskmonger/dependument	javascript
+LogicAndTrick/twhl	php
+revng/llvmcpy	python
+eric/metriks_log_webhook	ruby
+mulkieran/stratisd	rust
+BillWagner/WorkingWithTypeScript	typescript
+ferrous26/cs452-flaming-meme	c
+rootulp/exercism	go
+smalldatalab/omh-dsu	java
+dimkarakostas/unimeet	javascript
+symfony/security-bundle	php
+Antrikshy/reddit2Kindle	python
+moneyadviceservice/middleman-i18n-markdown	ruby
+tzkhan/roman-rust	rust
+xtina-starr/reaction	typescript
+thoughtbot/BotKit	c
+ziutek/thread	go
+rajdavies/fabric8	java
+vigetlabs/microcosm	javascript
+whathejoe/lms-m4g4	php
+foliant-docs/foliant	python
+mongodb/mongoid	ruby
+burtonageo/rebind	rust
+wishtack/wishtack-steroids	typescript
+aaronriekenberg/openbsd_cproxy	c
+ftcjeff/AirlineCode-go	go
+RoboZonky/robozonky	java
+dmitriiabramov/esfmt	javascript
+artesaos/laravel-linkedin	php
+estebistec/django-twitter-bootstrap	python
+aruprakshit/sync	ruby
+zslayton/cron	rust
+dkocich/osm-pt-ngx-leaflet	typescript
+pressel/mpi4py	c
+anthonyrego/gosmf	go
+Charling-Huang/birt	java
+hellsgate1001/waypoints	javascript
+renyuneyun/core	php
+Antojitos/chalupas	python
+Validic/validic	ruby
+mijnadres/serde_elm	rust
+artsy/force-public	typescript
+reupen/mmh	c
+btobolaski/terraform-provider-linode	go
+bogdansolga/nokia-spring-boot-training	java
+testlnord/wurfelspiel	javascript
+fullybaked/pslackr	php
+MasonM/hssonline-conference	python
+pch/lastfm-client	ruby
+oakes/neovim-rs	rust
+cookingfox/stibble-api-client-angular	typescript
+hikoLab/pebcessing	c
+soudy/eparser	go
+yingyun001/ovirt-engine	java
+mg4tv/mg4tv-web	javascript
+tux-rampage/zend-di	php
+2baOrNot2ba/dreamBeam	python
+chrisvanheuveln/cisco-network-node-utils	ruby
+DaGenix/rust-crypto	rust
+jordwest/news-feed-eradicator	typescript
+ytaben/WakeOnLanRelay	c
+mattn/go-mastodon	go
+steria/skuldsku	java
+cristiana214/cristianachavez214-cristianachavez	javascript
+ob-ivan/sd-currency	php
+k4nar/inbox	python
+chrishunt/github-auth	ruby
+tum-rt/emoji-feedback	rust
+thecjharries/slim-ace	typescript
+bbockelm/condor-network-accounting	c
+qskycolor/gofrontend	go
+Monospark/ActionControl	java
+slightly-askew/portfolio-2017	javascript
+digitickets/omnipay-verifone-web-service	php
+ctsit/nacculator	python
+emodeqidao/Kiwi	ruby
+aopicier/cryptopals-rust	rust
+sdeleuze/mixit	typescript
+fergul/Cache	c
+declanshanaghy/bbqberry	go
+Hypersonic/Starlorn	java
+var-bin/reactjs-training	javascript
+joshmassey/sga-itracker	php
+kytos/python-openflow	python
+spatchcock/calc-json-ruby	ruby
+bitwalker/rustcalc	rust
+what3words/w3w-node-wrapper	typescript
+GNOME/telepathy-account-widgets	c
+resumic/schema	go
+kryptnostic/rhizome	java
+topherauyeung/portfolio	javascript
+EOL/eol_php_code	php
+victorpoluceno/xwing	python
+jiajiawang/load_more	ruby
+hoodie/rust-email	rust
+jchakra/discord-raider	typescript
+k4rtik/btp-gvn	c
+torinos-io/api	go
+veyndan/paper-for-reddit	java
+alphagov/notifications-admin	javascript
+ProjetPP/PPP-Wikidata	php
+Stratoscale/skipper	python
+uhoh-itsmaciek/pg-quilter	ruby
+cobalt-org/cobalt.rs	rust
+Ragg-/Delir	typescript
+ROCm-Developer-Tools/HIP	c
+hashicorp/go-getter	go
+philipphager/disclosure-android-app	java
+jlord/git-it-electron	javascript
+armadito/armadito-glpi	php
+SUSE/azurectl	python
+kolorahl/acls	ruby
+LesPepitos/gist	rust
+neild3r/vscode-php-docblocker	typescript
+matayoshi/tools	c
+emicklei/melrose	go
+CA-APM/ca-apm-fieldpack-asm	java
+dev-brutus/427	javascript
+sabre-io/vobject	php
+pinax/django-waitinglist	python
+logentries/le_ruby	ruby
+jhelwig/homers	rust
+chunye/azure-functions-ux	typescript

data/repo_list.txt

@@ -0,0 +1,800 @@
+imankulov/sentry
+rnyberg/pyfibot
+artefactual/archivematica-history
+caleb531/automata
+Antiun/account-invoicing
+ElementalAlchemist/txircd
+kmee/stock-logistics-warehouse
+BT-rmartin/partner-contact
+yuzie007/upho
+bfaludi/daprot
+angr/cle
+jmenglund/CollectionBatchTool
+coleifer/scout
+hsercanatli/adaptivetuning
+krmaxwell/TRX
+svieira/Flask-HipPocket
+capybaralet/fuel
+openstack/akanda-rug
+glyph/txsni
+tiddlyweb/tiddlywebplugins.atom
+grimwm/py-dictobj
+amorison/qjobs
+blancltd/blanc-basic-pages
+zchee/python-client
+CBitLabs/django-globals
+rgardner/ouimeaux
+hsolbrig/SNOMEDToOWL
+kevinschaul/open-in-github
+TangledWeb/tangled.auth
+bbangert/retools
+czpython/aldryn-faq
+alama/PSO2Proxy
+10gen-labs/mongo-connector
+makinacorpus/reportlab-ecomobile
+devinmcgloin/advent
+problemshift/kf5py
+PyO3/setuptools-rust
+apoorvemohan/haas
+crsmithdev/arrow
+c4fcm/CLIFF-API-Client
+martinrusev/imbox
+favien/favien
+thomwiggers/django-mongodbforms
+anthonysandrin/kafka-utils
+dplucenio/heat_diffusion_experiment
+bgyori/bioagents
+plainas/tq
+vesln/robber.py
+dirn/Simon
+plone/plone.server
+lauft/timew-report
+AmiiThinks/amii-tf-nn
+ludwiktrammer/django-tagging-autocomplete
+pyinvoke/invocations
+jaylett/django_exceptional_middleware
+nosamanuel/dj-queryset-manager
+ap--/python-oceanoptics
+millerdev/django-nose
+ssanderson/interface
+ryanraaum/oldowan.mtdna
+oemof/feedinlib
+madmaze/pytesseract
+timraasveld/ansible-string-split-filter
+otknoy/michishiki_api_server
+alexmilesyounger/ds_basics
+adampiskorski/lpr_poc
+ranisalt/enigma
+infOpen/ansible-role-vsftpd
+chubbymaggie/asap
+girder/girder_worker
+atiberghien/makerscience-server
+KuChanTung/Python
+globocom/database-as-a-service
+Stark-Mountain/meetup-facebook-bot
+claudiopastorini/claudiopastorini.github.io
+b123400/purescript-ide-sublime
+bshaffer/appengine-python-vm-hello
+chop-dbhi/django-webhooks
+jwarshaw/RaspberryDrive
+aikramer2/spaCy
+alexgarciac/scrapi
+karel-brinda/prophyle
+etataurov/pytest
+khchine5/opal
+hatbot-team/hatbot_resources
+ellmetha/machina-singlepageapp
+seibert/numba
+earlwlkr/POICrawler
+ideascube/ideascube
+group-policy/rally
+funkybob/paws
+analyst-collective/dbt
+scanner-research/scanner
+ScanOC/trunk-player
+saltstack/salt
+cherba/apitools
+RainCity471/lyCompiler
+chiphogg/vim-vtd
+patrickspencer/mathdeck
+brainwane/zulip
+handroll/handroll
+sl2017/campos
+wiliamsouza/hystrix-py
+dimagi/commcare-hq
+thiderman/network-kitten
+kefir500/ghstats
+JungeAlexander/cocoscore
+ohsu-qin/qipipe
+sergey-dryabzhinsky/dedupsqlfs
+t-miyamae/teuthology
+0xPoly/ooni-probe
+sorgerlab/indra
+nvbn/thefuck
+aosp-mirror/platform_external_skia
+masasin/spirit
+benedicteb/outcast
+SEL-Columbia/commcare-hq
+OCA/stock-logistics-warehouse
+lemming52/white_knight
+egafford/sahara
+jdevera/subdue
+VirusTotal/misp-modules
+benedfit/SublimeLinter-contrib-pug-lint
+thebinarypenguin/SublimeLinter-contrib-raml-cop
+csrocha/account_journal_payment_subtype
+pombreda/seascope
+tanayseven/personal_website
+pinry/pinry
+geelweb/laposte-python-sdk
+phil-lopreiato/the-blue-alliance
+EnvGen/toolbox
+openaustralia/publicwhip-matthew
+thorgate/django-project-template
+monostable/haskell-kicad-data
+OpenSpace/OpenSpace
+planetlabs/datalake-ingester
+yamatt/bonfiremanager
+wkentaro/chainer
+Dybov/real_estate_agency
+Astroua/aws_controller
+nagilum/script.rndmov
+lsgunth/rapidsms
+yeasy/robot_tool
+ShivamSarodia/ShivyC
+stefanklug/plata
+willdavidc/piel
+henriquebastos/virtualenv-bootstrap
+ianfieldhouse/number_to_words
+sindrig/spoppy
+rlee287/pyautoupdate
+bharling/django-pint
+jackromo/RandTerrainPy
+ayushgoel/LongShot
+reedstrm/Pyrseas
+andylytical/brewpi-scripts
+HHS-IntroProgramming/Multiplication-table
+wyager/IHaskell
+opnfv/functest
+amolenaar/gaphor
+potatolondon/contentious
+pavel-paulau/perfrunner
+AlexHill/mezzanine
+sassoftware/mint
+hackerspace-ntnu/website
+paylogic/py2deb
+oliverlee/antlia
+voer-platform/vp.repo
+exekias/django-achilles
+ikaruswill/vector-space-model
+goldmann/docker-scripts
+tzengyuxio/python-five91
+Doist/todoist-python
+datasciencebr/serenata-toolbox
+jeanmask/opps-admin
+fprimex/zdesk
+praekelt/go-contacts-api
+MisanthropicBit/bibpy
+thismachinechills/save_skype
+lucianovdveekens/jiradoc
+ckan/ckanext-qa
+hyunchel/redis-dump-load
+ondergetekende/python-panavatar
+tarpas/pytest-testmon
+yola/proxyprefix
+ScatterHQ/eliot
+NewKnowledge/punk
+rdo-management/ironic-discoverd
+igstan/redis-grep
+opencord/voltha
+xandr2/blynkapi
+exoanalytic/python-skyfield
+hobarrera/django-afip
+Connexions/cnx-publishing
+Charcoal-SE/SmokeDetector
+pfmoore/invoke
+Calysto/metakernel
+CCI-MOC/GUI-Backend
+harvard-lil/h2o
+binoculars/osf.io
+kjordahl/swm
+tomv564/LSP
+thomasballinger/tmuxp
+philipdexter/vx
+OnroerendErfgoed/crabpy
+gviot/nadis
+moreati/b-prefix-all-the-doctests
+rudeb0t/DjangoAllowDeny
+bodbdigr/restea
+7ws/django-emailer
+mandiant/ioc_writer
+cloudify-cosmo/tosca-vcloud-plugin
+alisaifee/flask-limiter
+xmunoz/sodapy
+mass-project/mass_api_client
+gsarma/ChannelWorm
+markbrough/exchangerates
+TangledWeb/tangled.sqlalchemy
+FlipperPA/wagtailpress
+TangledWeb/tangled.website
+sedders123/phial
+JrGoodle/clowder
+kevgathuku/top40
+erikrose/blessings
+yola/auth_tkt
+consbio/parserutils
+archsh/tg2ext.express
+MichaelYusko/Bot-Chucky
+ryanmcdermott/birdseed
+mociepka/saleor
+GallopLabs/facebook-ads-api
+rail/releasetasks
+sebdah/yayson
+serge-sans-paille/gast
+adlibre/django-bcp
+ayushgoel/mstranslator
+gilesbrown/python-icapservice
+nigma/dj-cmd
+srittau/rouver
+VirgilSecurity/virgil-sdk-python
+verilylifesciences/analysis-py-utils
+compunova/kozinaki
+wangjohn/zinc_cli
+SCUEvals/scuevals-api
+ifduyue/urlfetch
+cychiang/mafan
+mcmtroffaes/pathlib2
+tilezen/scoville
+pczerkas/captainhook
+benedictpaten/cactus
+caktus/django-pagelets
+suminb/urwid-stackedwidget
+alphagov/stagecraft
+Connexions/cnx-authoring
+agoragames/py-eventsocket
+evoja/docker-Github-Gitlab-Auto-Deploy
+incuna/feincms-extensions
+zmbq/djqgrid
+kevinconway/rpmvenv
+maxzheng/workspace-tools
+thsnr/gygax
+theislab/dca
+iamwucheng/xml_models2
+divio/django-cas
+johnpaulett/txHL7
+twig/django-taggit
+gasman/Willow
+smarkets/statprof
+360youlun/cmsplugin-bootstrap-carousel
+ceball/param
+associazionepoltronieri/blender-ap
+wikilinks/sift
+DesertBot/DesertBot
+4degrees/segue
+holdenweb/nbtools
+openhealthcare/opal-referral
+BansheeMediaPlayer/bockbuild
+elacuesta/scrapy
+mbr/flask-appconfig
+ninjawil/weather-station
+sunlightlabs/thezombies
+PanDAWMS/panda-bigmon-atlas
+varunarya10/oslo.i18n
+jefrailey/basic-scraper
+udibr/fuel
+haridsv/fabric
+gadventures/gapipy
+sk-/python2.7-type-annotator
+mythmon/kitsune
+j4mie/django-activelink
+jwg4/flask-autodoc
+EmadMokhtar/halaqat
+EDUlib/edx-platform
+Graylog2/graylog-ansible-role
+armab/st2contrib
+KrzysztofSendor/dactyl
+nurav/balrog
+Pierre-Sassoulas/django-survey
+microsoft/dpu-utils
+PersonalGenomesOrg/open-humans
+vayan/external-video
+simonjbeaumont/xcp-rrdd
+lozadaOmr/ansible-admin
+ulikoehler/UliEngineering
+kxxoling/fabric
+EmilStenstrom/nephele
+chingc/DJRivals
+docsbox/docsbox
+uva-financial-engineering/cifer-tournament
+OSGConnect/freesurfer_workflow
+aaronkurtz/bricky
+worldforge/libwfut
+churchlab/millstone
+asteroide/immo_spider
+odoo-chile/l10n_cl_account_vat_ledger
+jeenalee/sklearn_pmml
+attenzione/SublimeLinter-scss-lint
+pudo/spendb
+hackebrot/cibopath
+mokieyue/mopidy
+textbook/flask-forecaster
+ncareol/spatialdb
+fna/owning-a-home-api
+gitpython-developers/GitPython
+spyder-ide/qtawesome
+ravel-net/ravel
+humangeo/preflyt
+ucb-sts/sts
+jlaunonen/kirppu
+matthiask/towel
+jmiserez/sts
+teonlamont/mne-python
+EinsamHauer/graphite-web-iow
+OCA/contract
+spreadflow/spreadflow-core
+djangogirlstaipei/eshop
+99designs/colorific
+revng/llvmcpy
+Antrikshy/reddit2Kindle
+foliant-docs/foliant
+estebistec/django-twitter-bootstrap
+Antojitos/chalupas
+MasonM/hssonline-conference
+2baOrNot2ba/dreamBeam
+k4nar/inbox
+ctsit/nacculator
+kytos/python-openflow
+victorpoluceno/xwing
+Stratoscale/skipper
+SUSE/azurectl
+pinax/django-waitinglist
+paulfanelli/planet_alignment
+jmcclell/django-bootstrap-pagination
+SUNET/eduid-webapp
+jiaaro/pydub
+srittau/python-htmlgen
+marcoslhc/xyvio
+zestyping/q
+epsy/clize
+lawlesst/vivo-rdflib-sparqlstore
+storecast/barrel
+mwilliamson/whack
+toastdriven/restless
+Empiria/matador
+daltonserey/tst
+whilp/python-script
+smly/ume
+richo/groundstation
+MetaMemoryT/aiozmq
+Z2PackDev/TBmodels
+igordejanovic/textX
+pbs/cmsplugin-filer
+google/python-lakeside
+jbergant/endpoints-proto-datastore
+cqse/teamscale-client-python
+f00f-nyc/cityhall-python
+ProjetPP/ExamplePPPModule-Python
+cjhutto/bsd
+svanoort/pyresttest
+pmclanahan/urlwait
+durden/nikeplus
+veo-labs/nose-progressive
+isghe/chainpoint
+AndBicScadMedia/blueprint
+garydonovan/google-maps-services-python
+infoxchange/ixwsauth
+andrasmaroy/pconf
+aditweb/django-socialregistration
+bugra/l1
+eugeniy/pytest-tornado
+juanriaza/django-rest-framework-msgpack
+justin8/portinus
+mayfield/ecmcli
+saulshanabrook/django-simpleimages
+williamboman/matrix-angular-sdk
+FutureSharks/invokust
+nitishr/PyHamcrest
+nvdv/vprof
+luci/recipes-py
+freevoid/yawf
+christopher18/Celsearch
+lpancescu/atlas-lint
+alexm92/sentry
+petrjasek/superdesk-ntb
+mpkato/interleaving
+kapadia/rasterio
+gbouvignies/chemex
+google/nogotofail
+sapcc/monasca-agent
+bert9bert/statsmodels
+mopidy/mopidy-soundcloud
+scrapinghub/shub
+alexef/pygobject
+talons/talons
+easy-as-python/django-webmention
+ryankask/django-discoverage
+davidfischer/warehouse
+idjaw/netman
+rahulbohra/Python-Basic
+eriol/circuits
+sarutobi/ritmserdtsa
+eunchong/build
+DistributedSystemsGroup/zoe
+citrix-openstack-build/oslo.versionedobjects
+lamby/debian-devel-changes-bot
+suclearnub/discordgrapher
+samcheck/PyMedia
+stepan-perlov/pgup
+rootulp/exercism
+larrybradley/photutils
+osahp/forecastonishing
+alphagov/notifications-api
+onitake/Uranium
+keybar/keybar
+richard-willdooit/odoo-product-configurator
+taeram/idiocy
+leaffan/pynhldb
+liumengjun/django-static-precompiler
+derricw/asciisciit
+AliGhahraei/nao-classroom
+ChromeDevTools/devtools-frontend
+allenai/deep_qa
+brightchen/Impala
+pyhmsa/pyhmsa-gui
+jpbottaro/anna
+scolby33/OCSPdash
+guillaume-philippon/aquilon
+stefan-caraiman/cloudbase-init-ci
+fwalch/python-client
+google/skia-buildbot
+MarquisLP/gamehappy
+paolodedios/tensorflow
+abanaiyan/sniper
+watchdogpolska/bliski_publikator
+openego/oeplatform
+jaapverloop/massa
+mvexel/maproulette
+atindale/business-glossary
+ionitadaniel19/testframeworksevolution
+rth/PyAbel
+sunng87/jip
+delinhabit/django-rest-framework
+sampadsaha5/sympy
+josephbisch/the-blue-alliance
+globus/globus-cli
+muun/bitforge
+josuemontano/api-starter
+ged/mongrel2
+L1ghtn1ng/usaf
+torchbox/wagtail
+adrienbrunet/fanfare_cuc
+homeworkprod/byceps
+SalesforceFoundation/Cumulus
+seler/djoauth2
+ryan-roemer/django-cloud-browser
+atheiste/django-bit-category
+SUNET/SATOSA
+jonathanslenders/python-prompt-toolkit
+CompassionCH/compassion-switzerland
+srct/whats-open
+StackStorm/st2
+HIIT/hybra-core
+GuillaumeDerval/INGInious
+kwagyeman/openmv
+pradyunsg/pip
+benschmaus/catapult
+shubhamdhama/zulip
+ministryofjustice/cla_backend
+puttarajubr/commcare-hq
+oldani/nanodegree-blog
+hmoco/osf.io
+gamezdaniel/mswl-dt-2013
+LINKIWI/linkr
+rtrembecky/roots
+appliedx/edx-platform
+zimolzak/Raspberry-Pi-newbie
+OpenTreeOfLife/phylesystem-api
+AlexandreProenca/backend-morandofloripa
+msultan/mdtraj
+kwadraterry/GPGPU-LUT
+conjure-up/conjure-up
+mattstibbs/blockbuster-server
+mvpgomes/shopit-app
+svetlyak40wt/django-dzenlog
+mariocesar/django-rocket
+madebymany/isthetoiletfree
+DeBortoliWines/Bika-LIMS
+xcgd/account_streamline
+1flow/1flow
+redhat-developer-tooling/vagrant-installers
+SanaMobile/sana.protocol_builder
+Foxboron/Frank
+AustinRochford/s3img-ipython-magic
+victorhahncastell/atlassian_permissions
+maxamillion/autocloud
+MrHarcombe/python-gpiozero
+UMD-DRASTIC/drastic
+OpenTreeOfLife/opentree
+pegasus-isi/pegasus
+gdit-cnd/RAPID
+Floobits/plugin-common-python
+cpcloud/dynd-python
+Authentise/git-release
+israelg99/eva
+openxc/openxc-python
+solidrails/mongrel2
+jwg4/qual
+sonofatailor/django-oscar
+stoeps13/ibmcnx2
+Vnet-as/falcon-hateoas
+azaroth42/iiif-harvester
+montefra/dodocs
+MarkusH/django-nap
+uccser/cs4teachers
+veatch/elasticsearch-py
+sdg-mit/gitless
+cjcardinale/climlab
+sorgerlab/belpy
+OCA/reporting-engine
+tylerdave/devpi-builder
+onepercentclub/onepercentclub-site
+AtteqCom/zsl
+mitar/django-mongo-auth
+LinuxTeam-teilar/cronos.teilar.gr
+boklm/tbb-testsuite
+jr-garcia/AssimpCy
+sussexstudent/falmer
+meebo/greins
+GuidoBR/python-skyfield
+cfobel/si-prefix
+jaraco/irc
+misttechnologies/selenium
+wicksy/laptop-build
+maxsocl/oldmailer
+mchelem/cref2
+anttipalola/alexa
+bopo/django-socialregistration
+percyfal/snakemake-rules
+GaretJax/sphinx-autobuild
+IL2HorusTeam/il2fb-ds-airbridge
+caktus/rapidsms-decisiontree-app
+timhberry/openam-flask-decorator
+nryant/twokenize_py
+lazygunner/xunleipy
+novafloss/populous
+mdmintz/SeleniumBase
+Linaro/lava-server
+PSU-OIT-ARC/django-arcutils
+openstack/nova
+willy-claes/django-react
+Jitsusama/lets-do-dns
+nerevu/riko
+alphagov/performanceplatform-collector
+aymara/verbenet-editor
+rcmachado/pysuru
+achabotl/pambox
+BakeCode/performance-testing
+frx0119/django-orderable-inlines
+thaim/ansible
+minoue/miExecutor
+zolech/zabbix-mesos-template
+mperignon/bmi-delta
+praekelt/molo-gem
+YeoLab/anchor
+slashk/goldstone-server
+DataDog/dogapi
+ioO/billjobs
+globocom/dbaas-zabbix
+Khilo84/Py-StackExchange
+philgyford/django-ditto
+metachris/py2app
+hhursev/recipe-scraper
+myles/me-api
+eXma/meet-and-eat-registration-system
+ryansturmer/gitmake
+kmike/django-widget-tweaks
+CO600GOL/Game_of_life
+grigorisg9gr/pyutils
+jambonrose/DjangoUnleashed-1.8
+aflc/editdistance
+kwhanalytics/rdtools
+ekumenlabs/terminus
+fanglinfang/myuw
+sixty-north/python-transducers
+mozilla/normandy
+andialbrecht/sentry-comments
+Alem/django-jfu
+sloede/pyglab
+agarone-mm/scholastic-demo
+vintasoftware/cdrf.co
+FreeMusicNinja/api.freemusic.ninja
+rmoorman/qotr
+timvandermeij/sentiment-analysis
+chipx86/reviewboard
+hotpxl/canonicalization-server
+caktus/rapidsms-tropo
+samuel/kokki
+DemocracyClub/electionleaflets
+renalreg/radar
+germn/python-for-android
+zsiciarz/django-pgallery
+jokimies/django-pj-budget
+lises/sheldon
+caseyjlaw/flaskigm
+mininet/mininet
+registerguard/django-newswall
+ibackus/custom_python_packages
+madr/utsokt
+building4theweb/soundem-api
+shichao-an/soundmeter
+phss/notes-cli
+euanlau/django-betainvite
+bow/pytest-pipeline
+alejandrodob/mamba
+dudepare/bedrock
+MidwestFurryFandom/mff-rams-plugin
+Teknologforeningen/teknologr.io
+christophmeissner/lagesonum
+nickodell/morse-code
+0101/djangoembed
+caktus/django-opendebates
+TUD-OS/gem5-dtu
+Commonists/CommonsDownloader
+kalaboster/stringer
+alphagov/digitalmarketplace-api
+nerdzeu/NERDZCrush
+hgl888/chromium-crosswalk-efl
+opencivicdata/scrapers-ca
+rapidpro/casepro
+alphagov/digitalmarketplace-admin-frontend
+eliteraspberries/minipkg
+gogoair/foremast
+spgill/bitnigma
+jberkenbilt/qpdf
+stephenmcd/hg-github
+maximkulkin/marshmallow
+tdphillips/campaigns
+jinty/van.contactology
+matslindh/kimochi-consumer
+honnibal/spaCy
+botify-labs/python-simple-workflow
+damonkelley/django-name
+kfdm/promgen
+us-ignite/us_ignite
+sassoftware/rbm
+rutube/djonet
+HKuz/Test_Code
+Yelp/paasta
+bogdal/freepacktbook
+OpenMined/PySyft
+daniell/django-import-export
+opennode/nodeconductor
+DataViva/dataviva-site
+WalkingMachine/sara_behaviors
+astronaut1712/taiga-back
+laurentbristiel/robotframework-needle
+mpirnat/django-tutorial-v2
+brosner/django-notification
+rsalmaso/django-allauth
+zzz0072/Python_Exercises
+Alweezy/alvin-mutisya-dojo-project
+CAPU-ENG/CAPUHome-API
+MoyTW/RL_Arena_Experiment
+bowen0701/algorithms_data_structures
+murphyke/avocado
+praba230890/junction
+yanqd0/csft
+zimolzak/poker-experiments
+eliran-stratoscale/rackattack-api
+mrlolethan/MinecraftUsernameToUUID
+OPWEN/opwen-webapp
+uvNikita/appstats
+cropleyb/pentai
+gunthercox/ChatterBot
+andburn/python-unitypack
+PnEcrins/GeoNature
+onepercentclub/bluebottle
+summernote/django-summernote
+zsiciarz/variablestars.net
+manhhomienbienthuy/pythondotorg
+Squareys/PyDDL
+PatrikValkovic/grammpy
+mitsuhiko/sentry
+Clyde-fare/cclib_bak
+andrewlin16/duckbot
+weijia/djangoautoconf
+BertrandBordage/django-terms
+schwa-lab/dr-apps-python
+ppb/ppb-vector
+svetlyak40wt/python-cl-conditions
+aman-iitj/scipy
+MaxLikelihood/CODE
+zhenzhai/edx-platform
+lihui7115/ChromiumGStreamerBackend
+cloudtools/troposphere
+carsonmcdonald/glacier-cmd
+gsnbng/erpnext
+tm-kn/farmers-api
+edx/ecommerce-api-client
+DesertBus/txircd
+e-mission/e-mission-server
+wahuneke/django-stripe-payments
+briansuhr/slowburn
+GETLIMS/LIMS-Backend
+robintw/scikit-image
+it-projects-llc/website-addons
+acgetchell/causal-sets-explorer
+MarauderXtreme/sipa
+CameronLonsdale/lantern
+stan-dev/pystan
+DigitalGlobe/gbdxtools
+treyhunner/django-email-log
+OCA/connector
+open2c/cooltools
+Schevo/kiwi
+silas/rock
+JohnVinyard/featureflow
+umbc-hackafe/htcpcp
+boluny/cray
+DavidNorman/tensorflow
+drougge/wwwwellpapp
+Clinical-Genomics/scout
+RNAcentral/rnacentral-webcode
+ByteCommander/ChatExchange6
+windmill/windmill
+mcmontero/tinyAPI
+jraede/dd-agent
+WyohKnott/image-comparison-sources
+jaraco/jaraco.logging
+pgollakota/django-chartit
+Frojd/wagtail-geo-widget
+sunlightlabs/hanuman
+jcarbaugh/django-wellknown
+igordejanovic/parglare
+iraquitan/udacity-fsnd-p4-conference-app
+vintasoftware/django-role-permissions
+j00bar/django-widgy
+mayfield/cellulario
+ghostwords/chameleon-crawler
+YabinHu/miniflow
+moyogo/fontbakery
+chocopoche/mangopay2-python-sdk
+jaraco/jaraco.classes
+jitseniesen/spyder-memory-profiler
+karan/TPB
+shakib609/gitcloner
+Daksh/sugar-toolkit-gtk3
+weecology/mete-spatial
+Secheron/compassion-switzerland
+redice/graphite-web
+DasIch/logbook
+recklessromeo/otm-core
+pabletos/Hubot-Warframe
+nagareproject/core
+fujita-shintaro/mkdocs
+zsiciarz/pyaavso
+openfisca/openfisca-tunisia
+ISISComputingGroup/EPICS-inst_servers
+emory-libraries/django-eultheme
+hyperion-rt/hyperion
+cardstack/cardstack
+bltravis/django-alphabetfilter
+zhangguiyu/django-hierarchical-auth
+fmfi-svt-deadlock/hw-testing
+spennihana/h2o-3
+pastas/pasta
+dkdndes/django-flatpages-example
+p2pu/learning-circles
+nikdoof/test-auth
+vmalavolta/fabix
+dtrip/.ubuntu
+egenerat/flight-manager
+robotenique/RandomAccessMemory
+RDFLib/rdflib
+pudo/storyweb
+benjamindean/furi-kura
+alphagov/ghtools
+shad7/trakt.py
+jaraco/hgtools
+gbowerman/azurerm
+sussman/zvm

memory_lora/codegraph.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""AST-based codebase graph representation.
+
+New data representation beyond what the Code2LoRA paper used (raw file
+chunks, mean+max pooled). This module extracts a STRUCTURAL summary of a
+Python codebase -- imports (dependency edges between files), class
+hierarchies, function/method signatures, and a best-effort call graph --
+and serializes it into compact text sections. Those sections are fed
+through the SAME frozen embedding pipeline as raw code
+(``memory_lora.encoder.embed_document`` already accepts a list of
+``(section_name, section_text)`` tuples), so a repository can be embedded
+from BOTH its raw source text and its structural graph, without any
+change to the encoder or hypernetwork.
+
+Why this matters for "recall codebases": raw-text chunking captures
+surface content (docstrings, comments, literal code) but dilutes the
+signal that actually matters for API-level questions -- "what does
+function X take", "what inherits from Y", "who imports Z". A compact
+graph serialization puts that signal in a small number of dense tokens
+instead of burying it across thousands of raw-code tokens.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+@dataclass
+class FunctionSig:
+    name: str
+    args: List[str]
+    returns: Optional[str]
+    is_method: bool = False
+    decorators: List[str] = field(default_factory=list)
+    calls: List[str] = field(default_factory=list)  # best-effort, unresolved names
+
+
+@dataclass
+class ClassSig:
+    name: str
+    bases: List[str]
+    methods: List[FunctionSig] = field(default_factory=list)
+
+
+@dataclass
+class FileGraph:
+    path: str
+    imports: List[str]
+    import_froms: List[Tuple[str, List[str]]]  # (module, [names])
+    classes: List[ClassSig]
+    functions: List[FunctionSig]  # module-level only
+
+
+def _annotation_to_str(node: Optional[ast.AST]) -> Optional[str]:
+    if node is None:
+        return None
+    try:
+        return ast.unparse(node)
+    except Exception:  # noqa: BLE001
+        return None
+
+
+def _arg_to_str(a: ast.arg) -> str:
+    ann = _annotation_to_str(a.annotation)
+    return f"{a.arg}: {ann}" if ann else a.arg
+
+
+def _extract_calls(node: ast.AST) -> List[str]:
+    calls = []
+    for n in ast.walk(node):
+        if isinstance(n, ast.Call):
+            f = n.func
+            if isinstance(f, ast.Name):
+                calls.append(f.id)
+            elif isinstance(f, ast.Attribute):
+                calls.append(f.attr)
+    # dedupe, keep order
+    seen = set()
+    out = []
+    for c in calls:
+        if c not in seen:
+            seen.add(c)
+            out.append(c)
+    return out[:20]  # cap -- this is a signal, not a full trace
+
+
+def _function_sig(node, is_method: bool = False) -> FunctionSig:
+    args = [_arg_to_str(a) for a in node.args.args]
+    returns = _annotation_to_str(node.returns)
+    decorators = [_annotation_to_str(d) or "" for d in node.decorator_list]
+    return FunctionSig(
+        name=node.name, args=args, returns=returns, is_method=is_method,
+        decorators=[d for d in decorators if d], calls=_extract_calls(node),
+    )
+
+
+def extract_file_graph(source: str, path: str) -> Optional[FileGraph]:
+    """Parse one Python file's source into a :class:`FileGraph`.
+    Returns None on a syntax error (skip the file, don't crash the repo)."""
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        return None
+
+    imports: List[str] = []
+    import_froms: List[Tuple[str, List[str]]] = []
+    classes: List[ClassSig] = []
+    functions: List[FunctionSig] = []
+
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.Import):
+            imports.extend(a.name for a in node.names)
+        elif isinstance(node, ast.ImportFrom):
+            mod = node.module or ("." * node.level)
+            import_froms.append((mod, [a.name for a in node.names]))
+        elif isinstance(node, ast.ClassDef):
+            bases = [_annotation_to_str(b) or "?" for b in node.bases]
+            methods = [
+                _function_sig(n, is_method=True)
+                for n in node.body
+                if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+            ]
+            classes.append(ClassSig(name=node.name, bases=bases, methods=methods))
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            functions.append(_function_sig(node, is_method=False))
+
+    return FileGraph(path=path, imports=imports, import_froms=import_froms,
+                      classes=classes, functions=functions)
+
+
+def serialize_file_graph(g: FileGraph) -> str:
+    """Compact text serialization -- dense signature summary, not prose."""
+    lines = [f"# {g.path}"]
+    if g.imports:
+        lines.append("imports: " + ", ".join(g.imports))
+    for mod, names in g.import_froms:
+        lines.append(f"from {mod} import " + ", ".join(names))
+    for c in g.classes:
+        base_str = f"({', '.join(c.bases)})" if c.bases else ""
+        lines.append(f"class {c.name}{base_str}:")
+        for m in c.methods:
+            dec = "".join(f"@{d} " for d in m.decorators)
+            args = ", ".join(m.args)
+            ret = f" -> {m.returns}" if m.returns else ""
+            calls = f"  # calls: {', '.join(m.calls[:6])}" if m.calls else ""
+            lines.append(f"  {dec}def {m.name}({args}){ret}{calls}")
+    for fn in g.functions:
+        dec = "".join(f"@{d} " for d in fn.decorators)
+        args = ", ".join(fn.args)
+        ret = f" -> {fn.returns}" if fn.returns else ""
+        calls = f"  # calls: {', '.join(fn.calls[:6])}" if fn.calls else ""
+        lines.append(f"{dec}def {fn.name}({args}){ret}{calls}")
+    return "\n".join(lines)
+
+
+def extract_repo_graph_sections(
+    repo_dir: Path, max_files: int = 200, skip_dirs: Optional[set] = None,
+) -> List[Tuple[str, str]]:
+    """Walk a repo, extract + serialize each .py file's structural graph.
+    Returns ``[(section_name, section_text), ...]`` -- directly usable as
+    the ``sections`` argument to ``memory_lora.encoder.embed_document``,
+    alongside (or instead of) raw-text sections.
+    """
+    skip_dirs = skip_dirs or {".git", "__pycache__", ".venv", "venv", "node_modules",
+                               "build", "dist", ".tox", ".mypy_cache"}
+    sections: List[Tuple[str, str]] = []
+    n = 0
+    for path in sorted(repo_dir.rglob("*.py")):
+        if any(part in skip_dirs for part in path.parts):
+            continue
+        try:
+            source = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        rel = str(path.relative_to(repo_dir))
+        g = extract_file_graph(source, rel)
+        if g is None:
+            continue
+        if not (g.imports or g.import_froms or g.classes or g.functions):
+            continue  # empty file, no structural signal
+        sections.append((f"graph:{rel}", serialize_file_graph(g)))
+        n += 1
+        if n >= max_files:
+            break
+    return sections
+
+
+def extract_repo_dependency_summary(repo_dir: Path, skip_dirs: Optional[set] = None) -> str:
+    """One dense paragraph: which files import which other in-repo modules.
+    A cheap approximation of a dependency graph edge list, useful as a
+    single extra section capturing repo-wide (not per-file) structure."""
+    skip_dirs = skip_dirs or {".git", "__pycache__", ".venv", "venv", "node_modules"}
+    edges: List[str] = []
+    module_names = set()
+    files = [p for p in repo_dir.rglob("*.py") if not any(part in skip_dirs for part in p.parts)]
+    for p in files:
+        mod = str(p.relative_to(repo_dir)).replace("/", ".").removesuffix(".py")
+        module_names.add(mod)
+
+    for p in files:
+        try:
+            source = p.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(source)
+        except (SyntaxError, ValueError, OSError):
+            continue
+        rel = str(p.relative_to(repo_dir))
+        for node in ast.walk(tree):
+            if isinstance(node, ast.ImportFrom) and node.module:
+                if node.module in module_names or any(m.startswith(node.module + ".") for m in module_names):
+                    edges.append(f"{rel} -> {node.module}")
+    return "dependency edges:\n" + "\n".join(edges[:300]) if edges else ""
+
+
+__all__ = [
+    "FunctionSig", "ClassSig", "FileGraph",
+    "extract_file_graph", "serialize_file_graph",
+    "extract_repo_graph_sections", "extract_repo_dependency_summary",
+]

memory_lora/core.py

@@ -0,0 +1,434 @@
+#!/usr/bin/env python3
+"""Shared building blocks for the Memory-LoRA hypernetwork.
+
+Forked from Code2LoRA's ``hypernetwork/code2lora_core.py`` (Hotsko et al.,
+"Code2LoRA: Hypernetwork-Generated Adapters for Code Language Models under
+Software Evolution", MIT-licensed code release). Same core trick, different
+target model and conditioning input:
+
+* Code2LoRA:   repository embedding -> LoRA adapter for Qwen2.5-Coder-1.5B
+* Memory-LoRA: document embedding   -> LoRA adapter for google/gemma-4-E2B
+
+The ``MemoryLoRAHead`` (renamed from ``Code2LoRAHead``, architecture
+unchanged) outputs ONE (A, B) pair per LoRA module *type* (q_proj, k_proj,
+v_proj, o_proj, gate_proj, up_proj, down_proj), shared across every target
+transformer layer -- not per-layer. This keeps the head's parameter count
+tractable for local (MPS) training.
+
+Gemma-4-E2B specifics (verified against the model's actual safetensors
+header, not guessed):
+
+* Decoder is nested at ``model.language_model.layers.{i}.*`` -- NOT
+  ``model.layers.{i}.*`` like Qwen2.5-Coder. ``get_module_specs`` below
+  matches on ``language_model\\.layers\\.(\\d+)\\.``, not ``model\\.layers``.
+* Module type names are identical to Code2LoRA's defaults:
+  q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj.
+* Only ``model.language_model.*`` is ever touched. ``vision_tower`` and
+  ``audio_tower`` are left completely alone -- irrelevant to text recall and
+  risky to perturb.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.dataset as pads
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+# ---------------------------------------------------------------------------
+# LoRA module + injection (unchanged from Code2LoRA -- architecture-agnostic)
+# ---------------------------------------------------------------------------
+
+class LoRA(nn.Module):
+    """Wraps an ``nn.Linear`` with an additive low-rank update.
+
+    Forward: ``y = base(x) + scaling * (x @ A^T) @ B^T``, where per-batch
+    A: ``[rank, in_features]`` and B: ``[out_features, rank]`` come from an
+    external hypernet via :meth:`set_lora_weights`.
+
+    IMPORTANT autograd contract: A and B are kept as **plain attributes**,
+    not buffers, and stored **without detaching**, so the LM loss's backward
+    graph flows through them straight into the hypernet parameters that
+    produced them. The base ``nn.Linear`` is frozen and its forward sees a
+    detached copy of the input to avoid building an autograd graph through
+    the (much larger) frozen LLM weights.
+    """
+
+    def __init__(self, base: nn.Linear, in_features: int, out_features: int,
+                 rank: int, alpha: float):
+        super().__init__()
+        self.base = base
+        for p in self.base.parameters():
+            p.requires_grad = False
+        self.in_features = in_features
+        self.out_features = out_features
+        self.rank = rank
+        self.scaling = float(alpha) / float(max(1, rank))
+        self.A: Optional[torch.Tensor] = None  # [rank, in_features]
+        self.B: Optional[torch.Tensor] = None  # [out_features, rank]
+
+    def set_lora_weights(self, A: torch.Tensor, B: torch.Tensor) -> None:
+        self.A = A
+        self.B = B
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        y = self.base(x)
+        if self.A is None or self.B is None:
+            return y
+        x_f32 = x.detach().to(torch.float32)
+        A = self.A.to(torch.float32)
+        B = self.B.to(torch.float32)
+        delta = F.linear(F.linear(x_f32, A), B) * self.scaling
+        return y + delta.to(dtype=y.dtype)
+
+
+@dataclass
+class ModuleSpec:
+    full_name: str   # e.g. 'model.language_model.layers.5.self_attn.q_proj'
+    layer_idx: int
+    type: str        # e.g. 'q_proj'
+    in_features: int
+    out_features: int
+
+
+# Gemma-4-E2B nests its text decoder here (verified via safetensors header).
+DEFAULT_ROOT_PREFIX = "model.language_model."
+_LAYER_IDX_RE = re.compile(r"\blanguage_model\.layers\.(\d+)\.")
+
+
+def get_module_specs(model: nn.Module, target_module_types: List[str],
+                      root_prefix: str = DEFAULT_ROOT_PREFIX
+                      ) -> List[ModuleSpec]:
+    """Discover every nn.Linear under ``root_prefix`` whose name contains one
+    of ``target_module_types`` and return one :class:`ModuleSpec` per match,
+    sorted by (layer_idx, full_name).
+
+    Restricting to ``root_prefix`` is what keeps ``vision_tower`` /
+    ``audio_tower`` untouched even though they also contain q_proj/k_proj/
+    v_proj/o_proj-named linears.
+
+    Gemma-4-E2B is architecturally heterogeneous across layers (unlike
+    Qwen2.5-Coder, which Code2LoRA was built for): every 5th layer is a
+    wider "full_attention" layer (q_proj/o_proj 2x the width of the
+    "sliding_attention" layers), and 20 of the 35 layers have NO k_proj/
+    v_proj at all -- they reuse an earlier layer's KV cache
+    (``num_kv_shared_layers=20`` in the model config). A LoRA (A, B) pair
+    can only be shared across modules of IDENTICAL shape, so ``.type`` here
+    is ``"{module_name}_{in}x{out}"`` (shape-qualified), not just the raw
+    module name -- e.g. ``"q_proj_1536x2048"`` vs ``"q_proj_1536x4096"``
+    end up as distinct hypernetwork output heads. Layers with no matching
+    module (e.g. k_proj on a KV-shared layer) simply produce no spec for
+    that layer, which is architecturally correct: there is nothing to
+    adapt there since that layer never computes its own K/V.
+    """
+    specs: List[ModuleSpec] = []
+    for name, m in model.named_modules():
+        if root_prefix and not name.startswith(root_prefix):
+            continue
+        match_type = next(
+            (t for t in target_module_types if t in name), None
+        )
+        if match_type is None:
+            continue
+        if not isinstance(m, nn.Linear):
+            continue
+        m_layer = _LAYER_IDX_RE.search(name)
+        layer_idx = int(m_layer.group(1)) if m_layer else -1
+        shape_qualified_type = f"{match_type}_{m.in_features}x{m.out_features}"
+        specs.append(ModuleSpec(
+            full_name=name,
+            layer_idx=layer_idx,
+            type=shape_qualified_type,
+            in_features=int(m.in_features),
+            out_features=int(m.out_features),
+        ))
+    specs.sort(key=lambda s: (s.layer_idx, s.full_name))
+    return specs
+
+
+def replace_with_lora(model: nn.Module, specs: List[ModuleSpec],
+                       rank: int, alpha: float) -> None:
+    """Replace each target ``nn.Linear`` in ``model`` with a :class:`LoRA`
+    wrapper. Idempotent."""
+    named = dict(model.named_modules())
+    device = next(model.parameters()).device
+    dtype = next(model.parameters()).dtype
+    for sp in specs:
+        parent_name, attr = sp.full_name.rsplit(".", 1)
+        orig = getattr(named[parent_name], attr)
+        if isinstance(orig, LoRA):
+            continue
+        assert isinstance(orig, nn.Linear), \
+            f"{sp.full_name} is not nn.Linear (got {type(orig)})"
+        wrapped = LoRA(orig, sp.in_features, sp.out_features,
+                        rank, alpha).to(device=device, dtype=dtype)
+        setattr(named[parent_name], attr, wrapped)
+
+
+def inject_lora_weights(model: nn.Module, specs: List[ModuleSpec],
+                         head_out: Dict[str, Dict[str, torch.Tensor]],
+                         batch_index: int = 0) -> None:
+    """Push ``head_out["A"][type]`` and ``head_out["B"][type]`` into the
+    wrapper :class:`LoRA` modules for every spec sharing that type."""
+    A_by_type = head_out["A"]
+    B_by_type = head_out["B"]
+    named = dict(model.named_modules())
+    for sp in specs:
+        named[sp.full_name].set_lora_weights(
+            A_by_type[sp.type][batch_index],
+            B_by_type[sp.type][batch_index],
+        )
+
+
+def discover_module_types_and_dims(specs: List[ModuleSpec]
+                                    ) -> Dict[str, Tuple[int, int]]:
+    """Return {type_name: (in_features, out_features)} -- one entry per
+    target module type. Assumes all instances of the same type share dims."""
+    type_dims: Dict[str, Tuple[int, int]] = {}
+    for sp in specs:
+        if sp.type in type_dims:
+            assert type_dims[sp.type] == (sp.in_features, sp.out_features), \
+                f"type {sp.type} appears with inconsistent dims"
+            continue
+        type_dims[sp.type] = (sp.in_features, sp.out_features)
+    return type_dims
+
+
+# ---------------------------------------------------------------------------
+# Shared LoRA generation head (= Code2LoRAHead, renamed; architecture unchanged)
+# ---------------------------------------------------------------------------
+
+class MemoryLoRAHead(nn.Module):
+    """Maps a document-context embedding to a LoRA adapter in one forward
+    pass.
+
+    Input  : ctx ``[B, input_dim]`` -- a single document embedding.
+    Output : ``{"A": {type: [B, rank, in_f]}, "B": {type: [B, out_f, rank]}}``,
+             one (A, B) pair per LoRA module *type*, shared across all
+             target transformer layers.
+
+    Args:
+        input_dim   : Context-vector dim (2048, matches the Qwen3-Embedding
+                      weighted-mean + max-pool concat from ``encoder.py``).
+        type_dims   : ``{type: (in_features, out_features)}`` for each LoRA
+                      module type (q_proj, v_proj, gate_proj, ...).
+        hidden_dim  : Trunk hidden dimension. Default 128 -- deliberately
+                      small: with only ~165 training documents (~3K QA
+                      pairs), a 745M-param head (hidden_dim=512, the
+                      original default) overfits within ~2 epochs (train
+                      loss -> 0.4 while held-out cr_val/cr_test loss rises
+                      from ~1.9 to ~2.7). hidden_dim=128 cuts head size
+                      roughly 4x; combine with --head-dropout and higher
+                      weight decay for further regularization.
+        rank        : LoRA rank ``r``.
+        init_log_scale : Initial log-scale for tanh squashing. -3.5 gives
+                         output magnitudes ~0.03 at init -> tiny LoRA delta.
+        dropout     : Dropout applied after each trunk GELU. 0.0 (paper's
+                      original setting) had no regularization at all;
+                      nonzero here specifically to counter the overfitting
+                      observed on this project's much smaller corpus.
+    """
+
+    def __init__(
+        self,
+        input_dim: int,
+        type_dims: Dict[str, Tuple[int, int]],
+        hidden_dim: int = 128,
+        rank: int = 16,
+        init_log_scale: float = -3.5,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.rank = rank
+        self.dropout = dropout
+        self.type_dims = dict(type_dims)
+        self.types = sorted(type_dims.keys())
+
+        self.trunk = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+        )
+
+        self.heads_A = nn.ModuleDict({
+            t: nn.Linear(hidden_dim, rank * type_dims[t][0])
+            for t in self.types
+        })
+        self.heads_B = nn.ModuleDict({
+            t: nn.Linear(hidden_dim, type_dims[t][1] * rank)
+            for t in self.types
+        })
+        self.log_scale_A = nn.ParameterDict({
+            t: nn.Parameter(torch.tensor(init_log_scale)) for t in self.types
+        })
+        self.log_scale_B = nn.ParameterDict({
+            t: nn.Parameter(torch.tensor(init_log_scale)) for t in self.types
+        })
+
+    def forward(self, ctx: torch.Tensor) -> Dict[str, Dict[str, torch.Tensor]]:
+        if ctx.dim() == 3:
+            ctx = torch.max(ctx, dim=1).values
+        h = self.trunk(ctx.float())
+        h = F.normalize(h, p=2, dim=-1) * math.sqrt(self.hidden_dim)
+
+        A_out: Dict[str, torch.Tensor] = {}
+        B_out: Dict[str, torch.Tensor] = {}
+        for t in self.types:
+            in_f, out_f = self.type_dims[t]
+            A_raw = self.heads_A[t](h).view(-1, self.rank, in_f)
+            B_raw = self.heads_B[t](h).view(-1, out_f, self.rank)
+            scale_A = torch.exp(self.log_scale_A[t]).clamp(1e-5, 0.3)
+            scale_B = torch.exp(self.log_scale_B[t]).clamp(1e-5, 0.3)
+            A_out[t] = torch.tanh(A_raw) * scale_A
+            B_out[t] = torch.tanh(B_raw) * scale_B
+        return {"A": A_out, "B": B_out}
+
+    def config_dict(self) -> Dict[str, Any]:
+        return {
+            "input_dim": self.input_dim,
+            "hidden_dim": self.hidden_dim,
+            "rank": self.rank,
+            "dropout": self.dropout,
+            "types": self.types,
+            "type_dims": {t: list(v) for t, v in self.type_dims.items()},
+        }
+
+
+# ---------------------------------------------------------------------------
+# Parquet loaders -- documents + recall QA pairs
+# ---------------------------------------------------------------------------
+
+def _list_to_f32_array(col, dim: int) -> np.ndarray:
+    """Vectorized fixed-width-list -> ndarray. The naive per-row Python
+    loop (``for i, v in enumerate(col.to_pylist()): out[i] = v``) does
+    dim * n_rows individual scalar assignments in pure Python -- fine at
+    ~200 rows, but at real-corpus scale (74K rows x 2048 dims = 151M
+    scalar ops) it single-handedly took 5+ minutes just to load
+    embeddings before training could even start. pyarrow's own flatten()
+    + numpy reshape does the same conversion in C.
+    """
+    if len(col) == 0:
+        return np.zeros((0, dim), dtype=np.float32)
+    flat = col.combine_chunks().flatten() if hasattr(col, "combine_chunks") else col.flatten()
+    arr = flat.to_numpy(zero_copy_only=False).astype(np.float32, copy=False)
+    return arr.reshape(len(col), dim)
+
+
+@dataclass
+class DocRow:
+    doc_id: str
+    doc_version: str          # constant "v1" for static (non-evolving) docs
+    split: str                # "train" | "cr_val" | "cr_test" (cross-corpus)
+    doc_embedding: np.ndarray  # fp32 [2048]
+
+
+@dataclass
+class QnaRow:
+    doc_id: str
+    doc_version: str
+    split: str                 # cross-corpus split, inherited from DocRow
+    qna_split: str              # "train" | "held_out" (in-corpus split)
+    question: str
+    prefix: str
+    target: str
+
+
+def load_doc_rows(parquet_path: Path,
+                   splits: Optional[List[str]] = None,
+                   embedding_col: str = "doc_embedding",
+                   ) -> List[DocRow]:
+    needed = ["doc_id", "doc_version", "split", embedding_col]
+    ds = pads.dataset(str(parquet_path), format="parquet")
+    flt = None
+    if splits:
+        flt = pc.is_in(pads.field("split"),
+                        value_set=pa.array(splits, type=pa.string()))
+    table = ds.to_table(columns=needed, filter=flt)
+    n = table.num_rows
+    if n == 0:
+        return []
+    dim = len(table.column(embedding_col)[0].as_py())
+    embs = _list_to_f32_array(table.column(embedding_col), dim)
+    doc_col = table.column("doc_id").to_pylist()
+    ver_col = table.column("doc_version").to_pylist()
+    split_col = table.column("split").to_pylist()
+    rows: List[DocRow] = []
+    for i in range(n):
+        rows.append(DocRow(
+            doc_id=doc_col[i], doc_version=ver_col[i],
+            split=split_col[i] or "",
+            doc_embedding=embs[i],
+        ))
+    return rows
+
+
+def load_qna_rows(jsonl_path: Path,
+                   splits: Optional[List[str]] = None,
+                   qna_splits: Optional[List[str]] = None,
+                   doc_ids: Optional[List[str]] = None,
+                   ) -> List[QnaRow]:
+    """QnA pairs are written as JSONL by ``generate_synthetic_dataset.py``
+    (one row per line, cheap to append incrementally during generation) --
+    unlike doc embeddings, which are batch-written parquet. Filters are
+    applied in Python; at the scale of this project (low thousands of rows)
+    that's simpler and fast enough."""
+    import json as _json
+
+    splits_set = set(splits) if splits else None
+    qna_splits_set = set(qna_splits) if qna_splits else None
+    doc_ids_set = set(doc_ids) if doc_ids else None
+
+    rows: List[QnaRow] = []
+    with open(jsonl_path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            d = _json.loads(line)
+            if splits_set and d.get("split") not in splits_set:
+                continue
+            if qna_splits_set and d.get("qna_split") not in qna_splits_set:
+                continue
+            if doc_ids_set and d.get("doc_id") not in doc_ids_set:
+                continue
+            rows.append(QnaRow(
+                doc_id=d.get("doc_id", ""),
+                doc_version=d.get("doc_version", "v1"),
+                split=d.get("split", ""),
+                qna_split=d.get("qna_split", ""),
+                question=d.get("question", ""),
+                prefix=d.get("prefix", ""),
+                target=d.get("target", ""),
+            ))
+    return rows
+
+
+__all__ = [
+    "LoRA",
+    "ModuleSpec",
+    "DEFAULT_ROOT_PREFIX",
+    "get_module_specs",
+    "replace_with_lora",
+    "inject_lora_weights",
+    "discover_module_types_and_dims",
+    "MemoryLoRAHead",
+    "DocRow",
+    "QnaRow",
+    "load_doc_rows",
+    "load_qna_rows",
+]

memory_lora/data_paths.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Local data path resolution for Memory-LoRA.
+
+Unlike Code2LoRA's ``data_paths.py`` (which lazily ``snapshot_download``s from
+the ``code2lora/`` HF org), everything here is generated locally via
+OpenRouter and never leaves the machine unless the user chooses to publish
+it -- so this just resolves to ``<repo_root>/data/``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DATA_ROOT = REPO_ROOT / "data"
+
+DOCS_DIR = DATA_ROOT / "docs"          # raw generated documents (jsonl)
+EMBEDDINGS_DIR = DATA_ROOT / "embeddings"  # doc embeddings parquet
+QNA_DIR = DATA_ROOT / "qna"            # recall QA pairs parquet
+CACHE_DIR = DATA_ROOT / "openrouter_cache"  # raw OpenRouter responses, keyed by prompt hash
+RUNS_DIR = REPO_ROOT / "runs"          # training checkpoints + metrics
+
+
+def ensure_dirs() -> None:
+    for d in (DOCS_DIR, EMBEDDINGS_DIR, QNA_DIR, CACHE_DIR, RUNS_DIR):
+        d.mkdir(parents=True, exist_ok=True)
+
+
+__all__ = [
+    "REPO_ROOT", "DATA_ROOT", "DOCS_DIR", "EMBEDDINGS_DIR", "QNA_DIR",
+    "CACHE_DIR", "RUNS_DIR", "ensure_dirs",
+]

memory_lora/encoder.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""Frozen document encoder for the Memory-LoRA hypernetwork.
+
+Forked from Code2LoRA's ``create_dataset/embed_repos.py`` chunk/pool
+pipeline (mean-pool chunks -> file vector -> weighted-mean+max repo vector),
+retargeted from "repo files" to "document sections":
+
+* Code2LoRA:   file_i        -> chunks -> mean-pool -> file vector
+               repo          -> weighted-mean+max over file vectors
+* Memory-LoRA: doc_section_i -> chunks -> mean-pool -> section vector
+               doc           -> weighted-mean+max over section vectors
+
+Same frozen encoder as the paper (Qwen3-Embedding-0.6B), same reasoning for
+the weighting (content-distinctiveness via cosine-distance-from-mean +
+log-size normalization) -- multi-section documents (e.g. the Code2LoRA paper
+chunked into abstract/method/results/limitations) benefit from it exactly
+the way multi-file repos did. Single-section synthetic fact-sheets degenerate
+gracefully to a near-uniform weighting over their own chunks.
+
+No gradient ever flows through this encoder; embeddings are precomputed once
+and cached to parquet by ``scripts/build_doc_embeddings.py``.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from transformers import AutoModel, AutoTokenizer
+
+DEFAULT_EMBED_MODEL = "Qwen/Qwen3-Embedding-0.6B"
+
+# Section-name heuristics (loose analogue of Code2LoRA's path up/down-weight
+# lists). Neutral by default for synthetic single-section documents; the
+# upweighted names matter for the multi-section Code2LoRA-paper document.
+SECTION_UPWEIGHT = [
+    r"abstract", r"result", r"conclusion", r"contribution",
+]
+SECTION_DOWNWEIGHT = [
+    r"acknowledg", r"reference", r"appendix",
+]
+
+MIN_CHARS_FOR_FULL_WEIGHT = 200  # sections shorter than this are downweighted
+
+
+# ---------------------------------------------------------------------------
+# Chunking
+# ---------------------------------------------------------------------------
+
+def chunk_token_ids(token_ids: List[int], chunk_tokens: int, overlap: int) -> List[List[int]]:
+    """Produce overlapping token windows (identical to Code2LoRA's version)."""
+    if chunk_tokens <= 0:
+        raise ValueError("chunk_tokens must be > 0")
+    if overlap >= chunk_tokens:
+        raise ValueError("chunk_overlap must be < chunk_tokens")
+    chunks: List[List[int]] = []
+    step = chunk_tokens - overlap
+    n = len(token_ids)
+    if n == 0:
+        return chunks
+    for start in range(0, n, step):
+        end = min(start + chunk_tokens, n)
+        window = token_ids[start:end]
+        if len(window) < 16:
+            continue
+        chunks.append(window)
+        if end >= n:
+            break
+    return chunks
+
+
+# ---------------------------------------------------------------------------
+# Embedding model wrapper
+# ---------------------------------------------------------------------------
+
+@torch.inference_mode()
+def embed_texts(
+    model: AutoModel,
+    tokenizer: AutoTokenizer,
+    texts: List[str],
+    device: str,
+    batch_size: int,
+    max_length: int,
+) -> torch.Tensor:
+    """Return embeddings [N, D] using mean pooling over last_hidden_state."""
+    all_vecs = []
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i:i + batch_size]
+        enc = tokenizer(
+            batch, padding=True, truncation=True,
+            max_length=max_length, return_tensors="pt",
+        )
+        enc = {k: v.to(device) for k, v in enc.items()}
+        out = model(**enc)
+        last = out.last_hidden_state  # [B, T, H]
+        mask = enc["attention_mask"].unsqueeze(-1)  # [B, T, 1]
+        mean = (last * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1)
+        all_vecs.append(mean.detach().cpu())
+    if not all_vecs:
+        return torch.empty((0, model.config.hidden_size))
+    return torch.cat(all_vecs, dim=0)
+
+
+# ---------------------------------------------------------------------------
+# Pooling: chunks -> section -> document
+# ---------------------------------------------------------------------------
+
+def pool_section_embeddings(chunk_embs: torch.Tensor) -> Optional[torch.Tensor]:
+    """chunk_embs [K, D] -> section_emb [D]"""
+    if chunk_embs.numel() == 0:
+        return None
+    return chunk_embs.mean(dim=0)
+
+
+def _section_name_bonus(section_name: str) -> float:
+    s = section_name.lower()
+    bonus = 0.0
+    for pat in SECTION_DOWNWEIGHT:
+        if re.search(pat, s):
+            bonus -= 0.25
+            break
+    for pat in SECTION_UPWEIGHT:
+        if re.search(pat, s):
+            bonus += 0.15
+            break
+    return bonus
+
+
+def compute_section_weights(
+    section_embs: torch.Tensor,          # [S, D]
+    section_char_counts: torch.Tensor,   # [S]
+    section_names: List[str],
+    a_distinct: float,
+    b_size: float,
+    tau: float,
+) -> torch.Tensor:
+    """
+    Whole-doc, all-sections weighting:
+      distinct_i = 1 - cos(s_i, mean_s)
+      size_i     = normalized log(1+chars)
+      score_i    = a_distinct * distinct_i + b_size * size_i + name_bonus_i + tiny_section_penalty
+      w          = softmax(score / tau)
+    Returns: w [S] sum=1
+    """
+    f_norm = F.normalize(section_embs, p=2, dim=-1)
+    mean_f = F.normalize(f_norm.mean(dim=0, keepdim=True), p=2, dim=-1)
+    cos = (f_norm * mean_f).sum(dim=-1).clamp(-1, 1)
+    distinct = 1.0 - cos
+
+    chars = section_char_counts.float().clamp(min=1)
+    log_chars = torch.log1p(chars)
+    if log_chars.numel() > 1:
+        lo, hi = log_chars.min(), log_chars.max()
+        size01 = (log_chars - lo) / (hi - lo + 1e-8)
+    else:
+        size01 = torch.ones_like(log_chars)
+
+    name_bonus = torch.tensor([_section_name_bonus(n) for n in section_names],
+                               dtype=torch.float32)
+    tiny_scale = (chars / float(MIN_CHARS_FOR_FULL_WEIGHT)).clamp(max=1.0)
+    tiny_bonus = torch.log(tiny_scale + 1e-6)
+
+    score = (a_distinct * distinct.cpu() + b_size * size01.cpu()
+             + name_bonus + 0.15 * tiny_bonus.cpu())
+    return torch.softmax(score / max(tau, 1e-6), dim=0)
+
+
+def pool_doc_embedding_weighted(
+    section_embs: torch.Tensor,          # [S, D]
+    section_char_counts: torch.Tensor,   # [S]
+    section_names: List[str],
+    a_distinct: float = 1.0,
+    b_size: float = 0.5,
+    tau: float = 0.5,
+    alpha_mean: float = 1.0,
+    beta_max: float = 1.0,
+) -> Optional[torch.Tensor]:
+    """Aggregate section embeddings into one document vector:
+    concat(alpha_mean * weighted_mean, beta_max * max) -> [2D]. No final
+    L2 normalization (matches Code2LoRA's repo-vector convention)."""
+    if section_embs.numel() == 0:
+        return None
+    w = compute_section_weights(
+        section_embs, section_char_counts, section_names,
+        a_distinct, b_size, tau,
+    ).to(section_embs.dtype)
+    wmean = (section_embs * w.unsqueeze(-1)).sum(dim=0)
+    vmax = section_embs.max(dim=0).values
+    return torch.cat([alpha_mean * wmean, beta_max * vmax], dim=0)
+
+
+# ---------------------------------------------------------------------------
+# Main pipeline per document
+# ---------------------------------------------------------------------------
+
+def embed_document(
+    sections: List[Tuple[str, str]],   # [(section_name, section_text), ...]
+    model: AutoModel,
+    tokenizer: AutoTokenizer,
+    device: str,
+    chunk_tokens: int = 4096,
+    chunk_overlap: int = 512,
+    batch_size: int = 4,
+    a_distinct: float = 1.0,
+    b_size: float = 0.5,
+    tau: float = 0.5,
+    alpha_mean: float = 1.0,
+    beta_max: float = 1.0,
+) -> Optional[torch.Tensor]:
+    """One document = list of (name, text) sections (single-element for a
+    plain synthetic fact-sheet; multi-element for the chunked paper).
+    Returns a [2D] embedding, or None if the document had no usable text."""
+    section_vectors: List[torch.Tensor] = []
+    section_names: List[str] = []
+    section_char_counts: List[int] = []
+
+    for name, text in sections:
+        text = (text or "").strip()
+        if not text:
+            continue
+        ids = tokenizer.encode(text, add_special_tokens=False)
+        windows = chunk_token_ids(ids, chunk_tokens=chunk_tokens, overlap=chunk_overlap)
+        if not windows:
+            continue
+        chunks = [tokenizer.decode(w, skip_special_tokens=True) for w in windows]
+        chunk_embs = embed_texts(
+            model=model, tokenizer=tokenizer, texts=chunks,
+            device=device, batch_size=batch_size, max_length=chunk_tokens,
+        )
+        svec = pool_section_embeddings(chunk_embs)
+        if svec is None:
+            continue
+        section_vectors.append(svec)
+        section_names.append(name)
+        section_char_counts.append(len(text))
+
+    if not section_vectors:
+        return None
+
+    section_embs = torch.stack(section_vectors, dim=0)
+    char_t = torch.tensor(section_char_counts, dtype=torch.int64)
+    return pool_doc_embedding_weighted(
+        section_embs, char_t, section_names,
+        a_distinct=a_distinct, b_size=b_size, tau=tau,
+        alpha_mean=alpha_mean, beta_max=beta_max,
+    )
+
+
+def load_encoder(model_name: str = DEFAULT_EMBED_MODEL, device: str = "mps"):
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModel.from_pretrained(model_name, torch_dtype=torch.float32)
+    model.to(device)
+    model.eval()
+    return model, tokenizer
+
+
+__all__ = [
+    "DEFAULT_EMBED_MODEL",
+    "chunk_token_ids",
+    "embed_texts",
+    "pool_section_embeddings",
+    "compute_section_weights",
+    "pool_doc_embedding_weighted",
+    "embed_document",
+    "load_encoder",
+]

requirements.txt

@@ -0,0 +1,22 @@
+# Memory-LoRA for google/gemma-4-E2B -- local (MPS) requirements.
+#
+# transformers must be installed from the main/dev branch: as of writing,
+# Gemma4ForConditionalGeneration (model_type "gemma4") is not yet in a
+# pinned PyPI release (the model's own config.json requires
+# transformers_version >= 5.5.0.dev0).
+#
+#   pip install "git+https://github.com/huggingface/transformers.git"
+#
+# torch installs the MPS-enabled build automatically on macOS (no separate
+# index-url needed for Apple Silicon).
+
+torch==2.13.0
+transformers @ git+https://github.com/huggingface/transformers.git
+accelerate==1.14.0
+numpy==2.5.1
+pyarrow==25.0.0
+tqdm==4.69.0
+sentencepiece==0.2.2
+protobuf==7.35.1
+tensorboard==2.21.0
+openai==2.48.0

runs/sixview_v1/head.best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42b3ca944c28284e7c391bb15347765cc183edad70f9fc01eca7d52b47d81fc9
+size 754581207

runs/sixview_v1/head.latest.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de50128411b62dbe548aa778de92946a5cb27d9c7ed6dd00fb0e04dbe3fddc9e
+size 754581395

runs/sixview_v1/metrics.jsonl

@@ -0,0 +1,11 @@
+{"step": 200, "epoch": 0, "end_of_epoch": false, "eval_loss": 3.073296190737905, "suites": {"cr_val": {"eval_loss": 3.073296190737905, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 3.0465956268583674, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 3.2239975754518686, "n_docs": 25, "n_tokens": 805}}}
+{"step": 400, "epoch": 0, "end_of_epoch": false, "eval_loss": 2.938264944642251, "suites": {"cr_val": {"eval_loss": 2.938264944642251, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.890953134488421, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.889070537964009, "n_docs": 25, "n_tokens": 805}}}
+{"step": 415, "epoch": 0, "end_of_epoch": true, "eval_loss": 2.925391464855528, "suites": {"cr_val": {"eval_loss": 2.925391464855528, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.8815196507705547, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.8640587694156245, "n_docs": 25, "n_tokens": 805}}}
+{"step": 600, "epoch": 1, "end_of_epoch": false, "eval_loss": 2.9148157247074997, "suites": {"cr_val": {"eval_loss": 2.9148157247074997, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.8689732771771497, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.7616432108494067, "n_docs": 25, "n_tokens": 805}}}
+{"step": 800, "epoch": 1, "end_of_epoch": false, "eval_loss": 2.8480377581749394, "suites": {"cr_val": {"eval_loss": 2.8480377581749394, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.8288494332162752, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.6785004036026714, "n_docs": 25, "n_tokens": 805}}}
+{"step": 830, "epoch": 1, "end_of_epoch": true, "eval_loss": 2.885955327256572, "suites": {"cr_val": {"eval_loss": 2.885955327256572, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.8312791101489303, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.668821378228087, "n_docs": 25, "n_tokens": 805}}}
+{"step": 1000, "epoch": 2, "end_of_epoch": false, "eval_loss": 3.0374551723996475, "suites": {"cr_val": {"eval_loss": 3.0374551723996475, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.9976756136774148, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.6696533814720484, "n_docs": 25, "n_tokens": 805}}}
+{"step": 1200, "epoch": 2, "end_of_epoch": false, "eval_loss": 3.0449040086767853, "suites": {"cr_val": {"eval_loss": 3.0449040086767853, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 3.0007799045652925, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.596094616525662, "n_docs": 25, "n_tokens": 805}}}
+{"step": 1245, "epoch": 2, "end_of_epoch": true, "eval_loss": 3.019029198608677, "suites": {"cr_val": {"eval_loss": 3.019029198608677, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 2.9622069910368136, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.534812292623224, "n_docs": 25, "n_tokens": 805}}}
+{"step": 1400, "epoch": 3, "end_of_epoch": false, "eval_loss": 3.3129004250276033, "suites": {"cr_val": {"eval_loss": 3.3129004250276033, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 3.2453028188683466, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.5926491863238885, "n_docs": 25, "n_tokens": 805}}}
+{"step": 1600, "epoch": 3, "end_of_epoch": false, "eval_loss": 3.4394415961478866, "suites": {"cr_val": {"eval_loss": 3.4394415961478866, "n_docs": 40, "n_tokens": 6170}, "cr_test": {"eval_loss": 3.3522856792662634, "n_docs": 40, "n_tokens": 5901}, "ir_test": {"eval_loss": 2.655274886281594, "n_docs": 25, "n_tokens": 805}}}

runs/sixview_v2/head.snapshot.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38bf91d46b037d1df7f8827e6ab2a05b0e5d76f69b3bfd880b67d46fde06a8a6
+size 754581395

runs/sixview_v2/head.t0030m.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74cdb1549d14d59c18110ff7b9a50334158e7332e9dd118ae139bdd5e664086f
+size 754581395

scripts/assemble_6view_dataset.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""Assemble the final ALIGNED 6-view training dataset by joining the
+multi-view embeddings (inputs, doc_id = 'owner/repo') to ALL tech-lead QA
+(targets) matched by repo name (commitpack/swe QA carry 'owner/repo@commit'
+-> stripped to 'owner/repo'). This turns 132 repo-scoped-only aligned repos
+into 515 aligned repos (~4000 QA) -- the best use of what we built.
+
+Splits (per repo, deterministic): 80% train / 10% cr_val / 10% cr_test, so
+the hypernetwork is evaluated on held-out repos it never trained on. Within
+train repos, ~15% of QA -> qna_split=held_out (feeds ir_test).
+
+Per-repo QA cap keeps any single repo (e.g. django) from dominating.
+
+Output: data/embeddings/aligned6_embeddings.parquet
+        data/qna/aligned6_qna.jsonl
+"""
+from __future__ import annotations
+import json, hashlib, random, sys
+from collections import defaultdict
+from pathlib import Path
+import pyarrow as pa, pyarrow.parquet as pq
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import EMBEDDINGS_DIR, QNA_DIR
+
+PER_REPO_CAP = 20
+
+def split_of(repo: str) -> str:
+    h = int(hashlib.md5(repo.encode()).hexdigest(), 16) % 100
+    if h < 10: return "cr_test"
+    if h < 20: return "cr_val"
+    return "train"
+
+def main():
+    rng = random.Random(3407)
+    mv = pq.read_table(EMBEDDINGS_DIR / "multiview_embeddings.parquet").to_pylist()
+    mv_by_repo = {}
+    for r in mv:                      # dedupe by repo (keep first)
+        mv_by_repo.setdefault(r["doc_id"], r)
+    mv_repos = set(mv_by_repo)
+
+    qa_by_repo = defaultdict(list)
+    for f in ["repo_scoped_qa.jsonl", "techlead_qa_commitpack.jsonl", "techlead_qa.jsonl"]:
+        p = QNA_DIR / f
+        if not p.exists(): continue
+        for l in open(p):
+            d = json.loads(l); repo = d["doc_id"].split("@")[0]
+            if repo in mv_repos:
+                qa_by_repo[repo].append(d)
+
+    # embeddings with splits (only repos that have >=1 QA are trainable/evaluable)
+    emb_rows = []
+    for repo, r in mv_by_repo.items():
+        if repo not in qa_by_repo: continue
+        emb_rows.append({"doc_id": repo, "doc_version": "head", "split": split_of(repo),
+                         "category": "aligned6", "doc_embedding": r["doc_embedding"]})
+    t = pa.table({k: [e[k] for e in emb_rows] for k in
+                  ["doc_id", "doc_version", "split", "category", "doc_embedding"]})
+    pq.write_table(t, EMBEDDINGS_DIR / "aligned6_embeddings.parquet")
+
+    # qna with qna_split
+    n_qa = 0
+    from collections import Counter
+    split_ct = Counter()
+    with (QNA_DIR / "aligned6_qna.jsonl").open("w") as out:
+        for repo, rows in qa_by_repo.items():
+            sp = split_of(repo)
+            if len(rows) > PER_REPO_CAP:
+                rows = rng.sample(rows, PER_REPO_CAP)
+            for i, d in enumerate(rows):
+                if sp == "train":
+                    qsplit = "held_out" if rng.random() < 0.15 else "train"
+                else:
+                    qsplit = "held_out"   # cr_val/cr_test: all held out
+                out.write(json.dumps({"doc_id": repo, "doc_version": "head",
+                    "split": sp, "qna_split": qsplit, "aspect": d.get("aspect", "?"),
+                    "question": d.get("question", ""), "prefix": d["prefix"],
+                    "target": d["target"], "lang": d.get("lang", "unknown")}) + "\n")
+                n_qa += 1
+                split_ct[sp] += 1
+
+    print(f"aligned6 dataset: {len(emb_rows)} repos (embeddings) | {n_qa} QA")
+    print(f"  repo splits: {Counter(split_of(r) for r in qa_by_repo)}")
+    print(f"  QA by split: {dict(split_ct)}")
+    print(f"  -> aligned6_embeddings.parquet + aligned6_qna.jsonl")
+
+if __name__ == "__main__":
+    main()

scripts/augment_paraphrases.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Augment a document's QA pairs with paraphrased variants of the SAME facts.
+
+Why: the direct-LoRA experiment on the Code2LoRA paper doc (runs/direct_paper)
+converged to train_loss=0.0 but only hit 33% exact-match on its OWN training
+questions at free-generation time, with several wrong answers collapsing to
+the same recycled string (e.g. "47.4%" answering four different percentage
+questions). With ~1 phrasing per fact and ~18 facts total, the model found a
+shortcut (a few frequently-reinforced answers) instead of learning to
+discriminate between questions. Multiple paraphrases of the SAME fact force
+the model to actually condition on question content rather than pattern-
+match a training-set shortcut.
+
+This does NOT introduce new facts -- it takes the existing (question,
+answer) pairs for a document and asks the model to rephrase the QUESTION
+several different ways while keeping the answer identical.
+
+Usage:
+    python scripts/augment_paraphrases.py --doc-id code2lora_paper --n-paraphrases 5
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import List
+
+from openai import OpenAI
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR, CACHE_DIR, ensure_dirs  # noqa: E402
+from generate_synthetic_dataset import (  # noqa: E402
+    CachedClient, _load_dotenv, DEFAULT_GEN_MODEL, OPENROUTER_BASE_URL,
+)
+
+_load_dotenv(REPO_ROOT / ".env")
+
+PARAPHRASE_SYSTEM = (
+    "You rewrite a factual question in N different ways while keeping its "
+    "meaning and the correct short answer completely unchanged. Output a "
+    "JSON array of N strings, each a differently-phrased question that "
+    "still has the exact same answer as the original. Vary sentence "
+    "structure, word choice, and question format (e.g. direct question, "
+    "'what value/number', fill-in-the-blank style) -- but never change what "
+    "is being asked. Output ONLY the JSON array, no prose."
+)
+
+
+def gen_paraphrases(client: CachedClient, model: str, question: str, answer: str, n: int) -> List[str]:
+    prompt = f"Original question: {question}\nCorrect answer: {answer.strip()}\nGenerate {n} paraphrases."
+    raw = client.chat(
+        model=model,
+        messages=[
+            {"role": "system", "content": PARAPHRASE_SYSTEM},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.8,
+        max_tokens=800,
+    )
+    match = re.search(r"\[.*\]", raw, re.DOTALL)
+    if not match:
+        return []
+    try:
+        items = json.loads(match.group(0))
+    except json.JSONDecodeError:
+        return []
+    return [q.strip() for q in items if isinstance(q, str) and q.strip()]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--doc-id", required=True)
+    ap.add_argument("--n-paraphrases", type=int, default=5)
+    ap.add_argument("--gen-model", default=DEFAULT_GEN_MODEL)
+    ap.add_argument("--held-out-fraction", type=float, default=0.15,
+                     help="Fraction of NEW paraphrases assigned to "
+                          "qna_split=held_out (rest go to train, since the "
+                          "goal here is more train-time exposure per fact).")
+    args = ap.parse_args()
+
+    ensure_dirs()
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+    if not api_key:
+        raise SystemExit("OPENROUTER_API_KEY not set (expected in .env)")
+    client = CachedClient(OpenAI(base_url=OPENROUTER_BASE_URL, api_key=api_key), cache_dir=CACHE_DIR)
+
+    qna_path = QNA_DIR / "qna.jsonl"
+    rows = [json.loads(l) for l in qna_path.open()]
+    doc_rows = [r for r in rows if r["doc_id"] == args.doc_id and r["qna_split"] == "train"]
+    print(f"Found {len(doc_rows)} existing train QA pairs for {args.doc_id}", flush=True)
+
+    import random
+    rng = random.Random(3407)
+    new_rows = []
+    for r in doc_rows:
+        question = r["question"] if r.get("question") else r["prefix"].removeprefix("Q: ").removesuffix("\nA:")
+        paraphrases = gen_paraphrases(client, args.gen_model, question, r["target"], args.n_paraphrases)
+        for pq in paraphrases:
+            qna_split = "held_out" if rng.random() < args.held_out_fraction else "train"
+            new_rows.append({
+                "doc_id": r["doc_id"], "doc_version": r["doc_version"], "split": r["split"],
+                "qna_split": qna_split, "question": pq,
+                "prefix": f"Q: {pq}\nA:", "target": r["target"],
+            })
+        print(f"  {question[:60]!r} -> {len(paraphrases)} paraphrases", flush=True)
+
+    with qna_path.open("a") as f:
+        for row in new_rows:
+            f.write(json.dumps(row) + "\n")
+    print(f"\nAppended {len(new_rows)} paraphrased QA pairs to {qna_path}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/build_doc_embeddings.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Embed every document in data/docs/documents.jsonl with the frozen
+Qwen3-Embedding-0.6B encoder (memory_lora/encoder.py) and write
+data/embeddings/doc_embeddings.parquet.
+
+Mirrors Code2LoRA's ``create_dataset/build_repo_state_embeddings_shard.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+from tqdm import tqdm
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import DOCS_DIR, EMBEDDINGS_DIR, ensure_dirs  # noqa: E402
+from memory_lora.encoder import DEFAULT_EMBED_MODEL, embed_document, load_encoder  # noqa: E402
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--embed-model", default=DEFAULT_EMBED_MODEL)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--chunk-tokens", type=int, default=4096)
+    ap.add_argument("--chunk-overlap", type=int, default=512)
+    args = ap.parse_args()
+
+    ensure_dirs()
+    docs_path = DOCS_DIR / "documents.jsonl"
+    out_path = EMBEDDINGS_DIR / "doc_embeddings.parquet"
+
+    device = args.device if (args.device != "mps" or torch.backends.mps.is_available()) else "cpu"
+    print(f"Loading encoder {args.embed_model} on {device} ...", flush=True)
+    model, tokenizer = load_encoder(args.embed_model, device=device)
+
+    docs = [json.loads(l) for l in docs_path.open()]
+    print(f"{len(docs)} documents to embed", flush=True)
+
+    rows = []
+    for d in tqdm(docs):
+        sections = [(s["name"], s["text"]) for s in d["sections"]]
+        vec = embed_document(
+            sections, model, tokenizer, device,
+            chunk_tokens=args.chunk_tokens, chunk_overlap=args.chunk_overlap,
+        )
+        if vec is None:
+            print(f"  [warn] no embedding for {d['doc_id']}, skipping", flush=True)
+            continue
+        rows.append({
+            "doc_id": d["doc_id"],
+            "doc_version": d["doc_version"],
+            "split": d["split"],
+            "category": d["category"],
+            "doc_embedding": vec.numpy().astype("float32").tolist(),
+        })
+
+    table = pa.table({
+        "doc_id": [r["doc_id"] for r in rows],
+        "doc_version": [r["doc_version"] for r in rows],
+        "split": [r["split"] for r in rows],
+        "category": [r["category"] for r in rows],
+        "doc_embedding": [r["doc_embedding"] for r in rows],
+    })
+    pq.write_table(table, out_path)
+    dim = len(rows[0]["doc_embedding"]) if rows else 0
+    print(f"Wrote {len(rows)} embeddings (dim={dim}) -> {out_path}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/build_repo_multiview.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Build REAL 6-view repo inputs locally: clone repos, extract the 6
+tech-lead views from each full tree, embed each view with the frozen Qwen
+encoder, concat -> one multi-view repo vector. Also emit a compact per-view
+TEXT summary per repo (so generate_repo_scoped_qa.py can produce
+scope-aligned targets from the SAME views the embedding sees).
+
+Views (each -> Qwen mean+max = 2048-d; 6 views -> 12288-d input vector;
+head input_dim is set to match, "~8k" was always approximate):
+  v_graph      : AST call/import graph (codegraph.py) + dependency edges
+  v_arch       : READMEs, top-level docstrings, folder tree
+  v_history    : git log --oneline + sampled commit diffs  ("the why")
+  v_contracts  : test files + type-annotated signatures
+  v_conventions: sampled source files (naming/idioms)
+  v_ops        : Dockerfile / CI yaml / pyproject / setup / .env.example
+
+Streaming design: load encoder ONCE, then per repo {clone shallow -> extract
+-> embed -> save -> delete clone} so disk and memory stay bounded. Clone
+failures / oversized / non-Python repos are skipped gracefully.
+
+Usage:
+  python scripts/build_repo_multiview.py --repos-file data/repo_list.txt --limit 3
+  python scripts/build_repo_multiview.py --repos-file data/repo_list.txt --max-repos 250
+"""
+from __future__ import annotations
+import argparse, json, os, re, shutil, subprocess, sys, tempfile, time
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import numpy as np, torch
+
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import EMBEDDINGS_DIR, DOCS_DIR, ensure_dirs  # noqa: E402
+from memory_lora.encoder import load_encoder, embed_document  # noqa: E402
+from memory_lora.codegraph import extract_repo_graph_sections, extract_repo_dependency_summary  # noqa: E402
+
+SKIP = {".git", "__pycache__", ".venv", "venv", "node_modules", "build", "dist",
+        ".tox", ".mypy_cache", "vendor", "third_party", "target", ".next"}
+VIEWS = ["v_graph", "v_arch", "v_history", "v_contracts", "v_conventions", "v_ops"]
+
+# language-agnostic file classification
+CODE_EXTS = {".py", ".js", ".jsx", ".ts", ".tsx", ".java", ".go", ".rs", ".c",
+             ".h", ".cc", ".cpp", ".hpp", ".php", ".rb", ".kt", ".swift", ".scala", ".cs"}
+TEST_HINTS = ("test", "spec", "_test.", ".test.", "tests/")
+# import-statement patterns per common language (for the non-Python graph fallback)
+IMPORT_RE = re.compile(
+    r"^\s*(?:import\s+[^\n;]+|from\s+[^\n]+import[^\n]+|#include\s*[<\"][^>\"]+[>\"]|"
+    r"use\s+[^\n;]+|require\s*\(?[^\n)]+\)?|package\s+[^\n;]+)", re.MULTILINE)
+DEF_RE = re.compile(
+    r"^\s*(?:def\s+\w+|class\s+\w+|func\s+\w+|function\s+\w+|fn\s+\w+|"
+    r"(?:public|private|protected|static|\s)+\w[\w<>\[\]]*\s+\w+\s*\(|"
+    r"type\s+\w+|struct\s+\w+|interface\s+\w+|export\s+(?:default\s+)?(?:function|class|const)\s+\w+)",
+    re.MULTILINE)
+
+
+def run(cmd: List[str], cwd=None, timeout=120) -> Tuple[int, str]:
+    try:
+        r = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True,
+                           errors="ignore", timeout=timeout)
+        return r.returncode, r.stdout
+    except Exception:  # noqa: BLE001
+        return 1, ""
+
+
+def clone(name: str, dest: Path, depth=80) -> bool:
+    url = f"https://github.com/{name}.git"
+    code, _ = run(["git", "clone", "--depth", str(depth), "--quiet", url, str(dest)], timeout=180)
+    return code == 0 and dest.exists()
+
+
+def _read(p: Path, n=8000) -> str:
+    try: return p.read_text(errors="ignore")[:n]
+    except OSError: return ""
+
+
+def _folder_tree(root: Path, max_lines=120) -> str:
+    lines = []
+    for p in sorted(root.rglob("*")):
+        if any(s in p.parts for s in SKIP): continue
+        rel = p.relative_to(root)
+        if len(rel.parts) > 3: continue
+        lines.append(str(rel) + ("/" if p.is_dir() else ""))
+        if len(lines) >= max_lines: break
+    return "\n".join(lines)
+
+
+def extract_views(repo: Path) -> Dict[str, List[Tuple[str, str]]]:
+    """Return {view_name: [(section_name, text), ...]} for the 6 views."""
+    v: Dict[str, List[Tuple[str, str]]] = {k: [] for k in VIEWS}
+
+    # v_graph: Python AST call/import graph (when present) + language-agnostic
+    # regex import/definition summary so non-Python repos still get structure.
+    v["v_graph"] = extract_repo_graph_sections(repo, max_files=50, skip_dirs=SKIP)
+    dep = extract_repo_dependency_summary(repo, skip_dirs=SKIP)
+    if dep: v["v_graph"].append(("dependency_edges", dep))
+    if len(v["v_graph"]) < 3:  # non-Python (or thin): regex-extract imports/defs
+        code = [p for p in repo.rglob("*")
+                if p.suffix.lower() in CODE_EXTS and not any(s in p.parts for s in SKIP)][:60]
+        imports, defs = [], []
+        for p in code:
+            t = _read(p, 6000)
+            imports += IMPORT_RE.findall(t)[:8]
+            defs += [f"{p.name}: {m.strip()[:80]}" for m in DEF_RE.findall(t)[:6]]
+        if imports: v["v_graph"].append(("imports", "\n".join(imports[:120])))
+        if defs: v["v_graph"].append(("definitions", "\n".join(defs[:120])))
+
+    # v_arch: READMEs, folder tree, package docstrings
+    for pat in ["README*", "ARCHITECTURE*", "docs/*.md", "*/__init__.py"]:
+        for p in list(repo.glob(pat))[:4]:
+            if p.is_file(): v["v_arch"].append((f"arch:{p.name}", _read(p, 6000)))
+    v["v_arch"].append(("folder_tree", _folder_tree(repo)))
+
+    # v_history: git log + a few diffs
+    _, log = run(["git", "-C", str(repo), "log", "--oneline", "-80"])
+    if log: v["v_history"].append(("git_log", log[:6000]))
+    _, shas = run(["git", "-C", str(repo), "log", "--format=%H", "-6"])
+    for sha in [s for s in shas.split() if s][:5]:
+        _, diff = run(["git", "-C", str(repo), "show", "--stat", "-p", sha])
+        if diff: v["v_history"].append((f"diff:{sha[:8]}", diff[:3000]))
+
+    # v_contracts: test files (any language) + typed signatures
+    tests = [p for p in repo.rglob("*")
+             if p.suffix.lower() in CODE_EXTS and not any(s in p.parts for s in SKIP)
+             and any(h in str(p).lower() for h in TEST_HINTS)][:10]
+    for p in tests:
+        v["v_contracts"].append((f"test:{p.name}", _read(p, 4000)))
+
+    # v_conventions: sampled source files (any language, non-test)
+    srcs = [p for p in repo.rglob("*")
+            if p.suffix.lower() in CODE_EXTS and not any(s in p.parts for s in SKIP)
+            and not any(h in str(p).lower() for h in TEST_HINTS)][:12]
+    for p in srcs:
+        v["v_conventions"].append((f"src:{p.name}", _read(p, 3500)))
+
+    # v_ops: build/CI/config
+    for pat in ["Dockerfile*", ".github/workflows/*.y*ml", "pyproject.toml",
+                "setup.py", "setup.cfg", "requirements*.txt", "Makefile", ".env.example",
+                "docker-compose*.y*ml", "tox.ini"]:
+        for p in list(repo.glob(pat))[:3]:
+            if p.is_file(): v["v_ops"].append((f"ops:{p.name}", _read(p, 4000)))
+    return v
+
+
+def summarize_views_text(views: Dict[str, List[Tuple[str, str]]], per_view=1400) -> Dict[str, str]:
+    """Compact text per view for QA generation (scope-aligned to embedding)."""
+    out = {}
+    for k, secs in views.items():
+        joined = "\n".join(f"# {n}\n{t}" for n, t in secs)
+        out[k] = joined[:per_view]
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repos-file", required=True)
+    ap.add_argument("--max-repos", type=int, default=250)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--out-emb", default=str(EMBEDDINGS_DIR / "multiview_embeddings.parquet"))
+    ap.add_argument("--out-src", default=str(DOCS_DIR / "multiview_sources.jsonl"))
+    args = ap.parse_args()
+    ensure_dirs()
+
+    target = args.limit if args.limit else args.max_repos
+    # accept "repo" or "repo<TAB>lang" lines; keep the lang tag if present
+    name_lang = []
+    for l in open(args.repos_file):
+        l = l.strip()
+        if not l: continue
+        parts = l.split("\t")
+        name_lang.append((parts[0], parts[1] if len(parts) > 1 else "unknown"))
+    name_lang = name_lang[: target * 3]  # oversample for clone failures
+    names = [n for n, _ in name_lang]
+    lang_of = dict(name_lang)
+
+    device = args.device if (args.device != "mps" or torch.backends.mps.is_available()) else "cpu"
+    print(f"Loading Qwen encoder on {device} ...", flush=True)
+    enc_model, enc_tok = load_encoder(device=device)
+
+    # resume-safe: skip repos already done
+    done = set()
+    if Path(args.out_src).exists():
+        done = {json.loads(l)["repo"] for l in open(args.out_src)}
+    src_f = open(args.out_src, "a")
+
+    import pyarrow as pa, pyarrow.parquet as pq
+    emb_rows = []
+    # load existing embeddings if resuming
+    if Path(args.out_emb).exists():
+        t = pq.read_table(args.out_emb).to_pylist()
+        emb_rows = t
+
+    n_done = 0; t0 = time.time()
+    for name in names:
+        if n_done >= target: break
+        if name in done: continue
+        tmp = Path(tempfile.mkdtemp(prefix="rmv_"))
+        try:
+            if not clone(name, tmp / "r"):
+                continue
+            repo = tmp / "r"
+            # skip repos with too little code (any language)
+            codefiles = [p for p in repo.rglob("*")
+                         if p.suffix.lower() in CODE_EXTS and not any(s in p.parts for s in SKIP)]
+            if len(codefiles) < 3:
+                continue
+            views = extract_views(repo)
+            # embed each view -> mean+max 2048; concat 6 -> 12288
+            vecs = []
+            for vk in VIEWS:
+                secs = views[vk] or [("empty", "none")]
+                vv = embed_document(secs, enc_model, enc_tok, device,
+                                    chunk_tokens=2048, chunk_overlap=128, batch_size=2)
+                vecs.append(vv.numpy().astype("float32") if vv is not None else np.zeros(2048, "float32"))
+            full = np.concatenate(vecs)  # 12288
+            doc_id = name  # repo-scoped
+            emb_rows.append({"doc_id": doc_id, "doc_version": "head", "split": "train",
+                             "category": "real_repo_multiview", "doc_embedding": full.tolist()})
+            src_f.write(json.dumps({"repo": name, "doc_id": doc_id,
+                                    "lang": lang_of.get(name, "unknown"),
+                                    "view_text": summarize_views_text(views)}) + "\n")
+            src_f.flush()
+            n_done += 1
+            if n_done % 10 == 0:
+                rate = n_done / max(1e-9, (time.time() - t0) / 60)
+                # periodic parquet flush
+                _flush(emb_rows, args.out_emb, pa, pq)
+                print(f"  {n_done} repos done ({rate:.1f}/min) dim={full.shape[0]} latest={name}", flush=True)
+        finally:
+            shutil.rmtree(tmp, ignore_errors=True)
+
+    _flush(emb_rows, args.out_emb, pa, pq)
+    src_f.close()
+    print(f"\nDone. {n_done} repos -> {args.out_emb} (dim={len(emb_rows[0]['doc_embedding']) if emb_rows else 0})", flush=True)
+
+
+def _flush(rows, path, pa, pq):
+    if not rows: return
+    t = pa.table({k: [r[k] for r in rows] for k in
+                  ["doc_id", "doc_version", "split", "category", "doc_embedding"]})
+    pq.write_table(t, path)
+
+
+if __name__ == "__main__":
+    main()

scripts/consolidate_qa.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Consolidate all tech-lead QA sources into one balanced training file with
+a PER-REPO CAP, so no single repo/domain dominates. This is what fixes the
+Django problem: SWE-bench inherently has ~5 Python repos (django-dominated)
+with thousands of QA already generated; capping per repo collapses django
+from ~2200 to <=CAP while keeping the 700+ distinct repos' diversity.
+
+Reads: data/qna/techlead_qa.jsonl, techlead_qa_commitpack.jsonl,
+       repo_scoped_qa.jsonl  (+ optional multilang tags)
+Writes: data/qna/techlead_consolidated.jsonl
+"""
+from __future__ import annotations
+import argparse, json, glob, random, sys
+from collections import Counter, defaultdict
+from pathlib import Path
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR
+
+def repo_of(doc_id): return doc_id.split("@")[0]
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--per-repo-cap", type=int, default=15)
+    ap.add_argument("--out", default=str(QNA_DIR / "techlead_consolidated.jsonl"))
+    args = ap.parse_args()
+    rng = random.Random(3407)
+
+    files = [QNA_DIR / "techlead_qa.jsonl", QNA_DIR / "techlead_qa_commitpack.jsonl",
+             QNA_DIR / "repo_scoped_qa.jsonl"]
+    by_repo = defaultdict(list)
+    for f in files:
+        if not f.exists(): continue
+        for l in open(f):
+            try: d = json.loads(l)
+            except json.JSONDecodeError: continue
+            by_repo[repo_of(d["doc_id"])].append(d)
+
+    kept = []
+    for repo, rows in by_repo.items():
+        if len(rows) > args.per_repo_cap:
+            rows = rng.sample(rows, args.per_repo_cap)
+        kept.extend(rows)
+    rng.shuffle(kept)
+
+    with open(args.out, "w") as fo:
+        for d in kept: fo.write(json.dumps(d) + "\n")
+
+    langs = Counter(d.get("lang", "python?") for d in kept)
+    repos = Counter(repo_of(d["doc_id"]) for d in kept)
+    django = sum(v for k, v in repos.items() if "django" in k.lower())
+    print(f"consolidated: {len(kept)} QA | {len(repos)} distinct repos | cap={args.per_repo_cap}/repo")
+    print(f"  django share: {django} ({100*django/max(1,len(kept)):.1f}%)  <- was 46%")
+    print(f"  langs: {dict(langs)}")
+    print(f"  top repos: {repos.most_common(5)}")
+    print(f"  -> {args.out}")
+
+if __name__ == "__main__":
+    main()

scripts/convert_real_code2lora.py

@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+"""Convert the REAL Code2LoRA/RepoPeftBench datasets into our local schema.
+
+Sources (downloaded from HF under data/real_code2lora/):
+  * code2lora-evo             -- PRIMARY. Full per-commit history for all
+    400 train + 49 cr_val + 51 cr_test repos (58,617 commit rows for train
+    alone), each with repo_state_embedding (2048-d), diff_embedding
+    (2048-d, embeds production_code_diff), and the literal
+    production_code_diff text. QnA files (train/ir_val/ir_test/cr_val/
+    cr_test) carry assertion_event_type + old_target -- i.e. this is real
+    diff/change data, not just static snapshots.
+  * code2lora-static-anchor   -- supplementary: qna/train.parquet has the
+    static-track anchor-based QnAs (different extraction protocol than
+    evo's train QnAs -- both are valid, kept as separate rows).
+  * repopeftbench-ood         -- 92-repo temporal holdout, used only for
+    held-out evaluation, never trained on.
+
+Output (appended, not overwritten, so re-running is additive-safe against
+accidental double-runs is NOT guaranteed -- this script always rewrites
+its own output files from scratch):
+  data/embeddings/real_code2lora_embeddings.parquet
+      doc_id = f"{repo_id}@{commit_sha[:10]}", doc_embedding = repo_state_embedding
+  data/qna/real_code2lora_qna.jsonl
+      one row per assertion-completion task, joined against the embeddings
+      above via the real (repo_id, commit_sha) pair (never guessed).
+  data/embeddings/real_code2lora_diffs.parquet
+      doc_id = f"{repo_id}@{commit_sha[:10]}", diff_embedding, and the raw
+      production_code_diff text -- kept SEPARATE from repo_state so a
+      future "what changed at this commit" task can condition on the diff
+      specifically rather than the whole-repo snapshot.
+
+Usage:
+    python scripts/convert_real_code2lora.py
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Dict, Set, Tuple
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import DATA_ROOT, EMBEDDINGS_DIR, QNA_DIR, ensure_dirs  # noqa: E402
+
+REAL_ROOT = DATA_ROOT / "real_code2lora"
+EVO_ROOT = REAL_ROOT / "code2lora-evo"
+ANCHOR_ROOT = REAL_ROOT / "code2lora-static-anchor"
+OOD_ROOT = REAL_ROOT / "repopeftbench-ood"
+
+
+def _doc_id(repo_id: str, commit_sha: str) -> str:
+    return f"{repo_id}@{str(commit_sha)[:10]}"
+
+
+def convert_embeddings_and_diffs() -> Set[Tuple[str, str]]:
+    """evo/commits/{split}.parquet -> repo-state embeddings AND diff
+    embeddings (kept in separate output files). Returns the set of
+    (repo_id, commit_sha) pairs with a real embedding, for the QnA join."""
+    emb_rows, diff_rows = [], []
+    valid_keys: Set[Tuple[str, str]] = set()
+    seen_ids: Set[str] = set()
+
+    for split_file, split_label in [
+        ("train.parquet", "train"), ("cr_val.parquet", "cr_val"), ("cr_test.parquet", "cr_test"),
+    ]:
+        path = EVO_ROOT / "commits" / split_file
+        if not path.exists():
+            print(f"  [skip] {path} not found", flush=True)
+            continue
+        table = pq.read_table(path, columns=[
+            "repo_id", "commit_sha", "repo_state_embedding", "diff_embedding", "production_code_diff",
+        ])
+        n = table.num_rows
+        repo_col = table.column("repo_id").to_pylist()
+        sha_col = table.column("commit_sha").to_pylist()
+        emb_col = table.column("repo_state_embedding").to_pylist()
+        diff_emb_col = table.column("diff_embedding").to_pylist()
+        diff_text_col = table.column("production_code_diff").to_pylist()
+        for i in range(n):
+            key = (repo_col[i], sha_col[i])
+            valid_keys.add(key)
+            doc_id = _doc_id(*key)
+            if doc_id not in seen_ids:
+                seen_ids.add(doc_id)
+                emb_rows.append({
+                    "doc_id": doc_id, "doc_version": sha_col[i],
+                    "split": split_label, "category": "real_code_repo",
+                    "doc_embedding": emb_col[i],
+                })
+            if diff_emb_col[i] is not None:
+                diff_rows.append({
+                    "doc_id": doc_id, "doc_version": sha_col[i], "split": split_label,
+                    "diff_embedding": diff_emb_col[i],
+                    "diff_text": (diff_text_col[i] or "")[:4000],
+                })
+        print(f"  evo {split_label}: {n} (repo, commit) rows, {len(set(repo_col))} unique repos", flush=True)
+
+    # supplementary: OOD holdout (from static-anchor, evo has no OOD split)
+    ood_file = OOD_ROOT / "ood_test.parquet"
+    if ood_file.exists():
+        table = pq.read_table(ood_file)
+        if "repo_state_embedding" in table.column_names:
+            n = table.num_rows
+            repo_col = table.column("repo_id").to_pylist()
+            sha_col = table.column("commit_sha").to_pylist()
+            emb_col = table.column("repo_state_embedding").to_pylist()
+            for i in range(n):
+                key = (repo_col[i], sha_col[i])
+                valid_keys.add(key)
+                doc_id = _doc_id(*key)
+                if doc_id not in seen_ids:
+                    seen_ids.add(doc_id)
+                    emb_rows.append({
+                        "doc_id": doc_id, "doc_version": sha_col[i],
+                        "split": "cr_test", "category": "real_code_repo_ood",
+                        "doc_embedding": emb_col[i],
+                    })
+            print(f"  ood: {n} (repo, commit) rows, {len(set(repo_col))} unique repos", flush=True)
+
+    emb_table = pa.table({
+        "doc_id": [r["doc_id"] for r in emb_rows],
+        "doc_version": [r["doc_version"] for r in emb_rows],
+        "split": [r["split"] for r in emb_rows],
+        "category": [r["category"] for r in emb_rows],
+        "doc_embedding": [r["doc_embedding"] for r in emb_rows],
+    })
+    emb_path = EMBEDDINGS_DIR / "real_code2lora_embeddings.parquet"
+    pq.write_table(emb_table, emb_path)
+    print(f"Wrote {len(emb_rows)} real repo embeddings -> {emb_path}", flush=True)
+
+    diff_table = pa.table({
+        "doc_id": [r["doc_id"] for r in diff_rows],
+        "doc_version": [r["doc_version"] for r in diff_rows],
+        "split": [r["split"] for r in diff_rows],
+        "diff_embedding": [r["diff_embedding"] for r in diff_rows],
+        "diff_text": [r["diff_text"] for r in diff_rows],
+    })
+    diff_path = EMBEDDINGS_DIR / "real_code2lora_diffs.parquet"
+    pq.write_table(diff_table, diff_path)
+    print(f"Wrote {len(diff_rows)} real diff embeddings -> {diff_path}", flush=True)
+
+    return valid_keys
+
+
+def convert_qna(valid_keys: Set[Tuple[str, str]]) -> int:
+    """evo/qna/{split}.parquet (primary) + static-anchor/qna/train.parquet
+    (supplementary static-track anchors) -> our jsonl rows, joined against
+    valid_keys (only keep QnAs whose (repo_id, commit_sha) has a real
+    embedding)."""
+    out_path = QNA_DIR / "real_code2lora_qna.jsonl"
+    n_written, n_dropped = 0, 0
+
+    sources = [
+        (EVO_ROOT / "qna" / "train.parquet", "train", "train"),
+        (EVO_ROOT / "qna" / "ir_val.parquet", "train", "held_out"),
+        (EVO_ROOT / "qna" / "ir_test.parquet", "train", "held_out"),
+        (EVO_ROOT / "qna" / "cr_val.parquet", "cr_val", "held_out"),
+        (EVO_ROOT / "qna" / "cr_test.parquet", "cr_test", "held_out"),
+        (ANCHOR_ROOT / "qna" / "train.parquet", "train", "train"),
+    ]
+    with out_path.open("w") as f:
+        for path, doc_split, qna_split in sources:
+            if not path.exists():
+                print(f"  [skip] {path} not found", flush=True)
+                continue
+            table = pq.read_table(path, columns=["repo_id", "commit_sha", "prefix", "target"])
+            n = table.num_rows
+            repo_col = table.column("repo_id").to_pylist()
+            sha_col = table.column("commit_sha").to_pylist()
+            prefix_col = table.column("prefix").to_pylist()
+            target_col = table.column("target").to_pylist()
+            kept = 0
+            for i in range(n):
+                key = (repo_col[i], sha_col[i])
+                if key not in valid_keys:
+                    n_dropped += 1
+                    continue
+                f.write(json.dumps({
+                    "doc_id": _doc_id(repo_col[i], sha_col[i]), "doc_version": sha_col[i],
+                    "split": doc_split, "qna_split": qna_split,
+                    "question": "", "prefix": prefix_col[i], "target": target_col[i],
+                }) + "\n")
+                n_written += 1
+                kept += 1
+            print(f"  {path.parent.parent.name}/{path.name}: {kept}/{n} QnAs matched "
+                  f"-> split={doc_split} qna_split={qna_split}", flush=True)
+    print(f"Wrote {n_written} real QnA pairs ({n_dropped} dropped, no matching "
+          f"embedding) -> {out_path}", flush=True)
+    return n_written
+
+
+def main() -> None:
+    ensure_dirs()
+    print("Converting real repo + diff embeddings (from code2lora-evo)...", flush=True)
+    valid_keys = convert_embeddings_and_diffs()
+    print(f"\n{len(valid_keys)} valid (repo, commit) embedding keys found.\n", flush=True)
+    print("Converting real QnA pairs (joined against real embeddings)...", flush=True)
+    n_qna = convert_qna(valid_keys)
+    print(f"\nDone: {len(valid_keys)} real repo-commit docs, {n_qna} real QnA pairs.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/diag_mps_leak.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Isolated MPS memory-leak diagnostic.
+
+Runs a minimal train-step loop on REAL code prefixes and prints
+system-available memory after every single operation, aborting the moment
+it crosses a hard floor. Tests one variable at a time (gradient
+checkpointing on/off, empty_cache on/off) so we can pinpoint what actually
+leaks, without the full training harness in the way.
+"""
+from __future__ import annotations
+import argparse, json, sys, time
+from pathlib import Path
+import psutil, torch, torch.nn.functional as F
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.core import (MemoryLoRAHead, get_module_specs, discover_module_types_and_dims,
+                               inject_lora_weights, replace_with_lora, DEFAULT_ROOT_PREFIX)
+from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+TARGET_MODULES = ["q_proj","k_proj","v_proj","o_proj","up_proj","gate_proj","down_proj"]
+
+def avail_gb(): return psutil.virtual_memory().available / 1e9
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--grad-checkpoint", action="store_true")
+    ap.add_argument("--empty-cache-every", type=int, default=0, help="0=never")
+    ap.add_argument("--steps", type=int, default=10)
+    ap.add_argument("--seq-len", type=int, default=512)
+    ap.add_argument("--micro-batch", type=int, default=2)
+    ap.add_argument("--floor-gb", type=float, default=22.0)
+    ap.add_argument("--train", action="store_true", help="do backward (else forward-only)")
+    args = ap.parse_args()
+    device = torch.device("mps")
+
+    print(f"[cfg] grad_ckpt={args.grad_checkpoint} empty_cache_every={args.empty_cache_every} "
+          f"train={args.train} seq={args.seq_len} mb={args.micro_batch}", flush=True)
+    print(f"[mem] start avail={avail_gb():.1f}GB", flush=True)
+
+    tok = AutoTokenizer.from_pretrained("google/gemma-4-E2B")
+    if tok.pad_token is None: tok.pad_token = tok.eos_token
+    model = AutoModelForImageTextToText.from_pretrained(
+        "google/gemma-4-E2B", torch_dtype=torch.bfloat16, attn_implementation="sdpa").to(device)
+    model.eval()
+    for p in model.parameters(): p.requires_grad = False
+    print(f"[mem] after model load avail={avail_gb():.1f}GB", flush=True)
+    if args.grad_checkpoint:
+        model.config.use_cache = False
+        model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
+        print("  gradient checkpointing ON", flush=True)
+
+    specs = get_module_specs(model, TARGET_MODULES, root_prefix=DEFAULT_ROOT_PREFIX)
+    type_dims = discover_module_types_and_dims(specs)
+    replace_with_lora(model, specs, rank=16, alpha=32.0)
+    head = MemoryLoRAHead(input_dim=2048, type_dims=type_dims, hidden_dim=512, rank=16).to(device)
+    print(f"[mem] after head+lora avail={avail_gb():.1f}GB", flush=True)
+
+    # real prefixes
+    prefixes, targets = [], []
+    with open(REPO_ROOT / "data/qna/real_code2lora_qna.jsonl") as f:
+        for line in f:
+            d = json.loads(line); prefixes.append(d["prefix"]); targets.append(d["target"])
+            if len(prefixes) >= args.steps * args.micro_batch: break
+    ctx = torch.randn(1, 2048, device=device)
+
+    for step in range(args.steps):
+        if avail_gb() < args.floor_gb:
+            print(f"[ABORT] avail={avail_gb():.1f}GB < floor {args.floor_gb} at step {step}", flush=True)
+            break
+        i0 = step * args.micro_batch
+        ps = prefixes[i0:i0+args.micro_batch]; ts = targets[i0:i0+args.micro_batch]
+        ids_list, lab_list = [], []
+        for p, t in zip(ps, ts):
+            tids = tok(t + (tok.eos_token or ""), add_special_tokens=False)["input_ids"]
+            pids = tok(p, add_special_tokens=False)["input_ids"]
+            budget = max(8, args.seq_len - len(tids)); pids = pids[-budget:]
+            ids = pids + tids; lab = [-100]*len(pids) + list(tids)
+            ids_list.append(torch.tensor(ids)); lab_list.append(torch.tensor(lab))
+        L = args.seq_len
+        pad = tok.pad_token_id or 0
+        def lp(x, v): return F.pad(x, (L-x.size(0),0), value=v) if x.size(0)<=L else x[-L:]
+        input_ids = torch.stack([lp(t,pad) for t in ids_list]).to(device)
+        labels = torch.stack([lp(t,-100) for t in lab_list]).to(device)
+        attn = (input_ids != pad).long().to(device)
+        head_out = head(ctx); inject_lora_weights(model, specs, head_out, batch_index=0)
+        if args.train:
+            out = model(input_ids=input_ids, attention_mask=attn, labels=labels)
+            (out.loss).backward()
+            head.zero_grad(set_to_none=True)
+        else:
+            with torch.no_grad():
+                out = model(input_ids=input_ids, attention_mask=attn, labels=labels)
+        loss_val = out.loss.item()
+        del head_out, out
+        if args.empty_cache_every and step % args.empty_cache_every == 0:
+            torch.mps.empty_cache()
+        print(f"[step {step}] loss={loss_val:.3f} avail={avail_gb():.1f}GB", flush=True)
+    print(f"[done] final avail={avail_gb():.1f}GB", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/eval_memory_lora.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Evaluate a trained Memory-LoRA head: recall EM/EditSim on held-out QA,
+split into in-corpus (ir_test) and cross-corpus (cr_val/cr_test), plus a
+manual spot-check comparing the LoRA-adapted model against the bare base
+model on hand-picked Code2LoRA-paper questions (proof the adapter, not
+general pretraining, is doing the recall).
+
+Forked from Code2LoRA's evaluation metrics (EM after whitespace collapsing
++ trailing-punctuation removal with relaxed prefix matching; EditSim via
+difflib.SequenceMatcher).
+
+Usage:
+    python scripts/eval_memory_lora.py --checkpoint runs/full1/head.best.pt
+"""
+
+from __future__ import annotations
+
+import argparse
+import difflib
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+import torch
+from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import EMBEDDINGS_DIR, QNA_DIR  # noqa: E402
+from memory_lora.core import (  # noqa: E402
+    MemoryLoRAHead,
+    DEFAULT_ROOT_PREFIX,
+    get_module_specs,
+    inject_lora_weights,
+    load_doc_rows,
+    load_qna_rows,
+    replace_with_lora,
+)
+
+DEFAULT_MODEL = "google/gemma-4-E2B"
+DEFAULT_TARGET_MODULES = [
+    "q_proj", "k_proj", "v_proj", "o_proj",
+    "up_proj", "gate_proj", "down_proj",
+]
+
+SPOT_CHECK_QUESTIONS = [
+    ("What LoRA rank does Code2LoRA's static hypernetwork use?", "16"),
+    ("How many trainable parameters does Code2LoRA-Static have?", "720 million"),
+    ("What is the cross-repo exact match of Code2LoRA-Static on the static track?", "63.8%"),
+    ("How many Python repositories are in RepoPeftBench?", "604"),
+    ("What is the base LLM used in Code2LoRA's experiments?", "Qwen2.5-Coder-1.5B"),
+]
+
+
+def normalize(s: str) -> str:
+    s = s.strip().rstrip(".,;:!?")
+    s = re.sub(r"\s+", " ", s)
+    return s.lower()
+
+
+def exact_match(pred: str, target: str) -> bool:
+    p, t = normalize(pred), normalize(target)
+    return p == t or p.startswith(t) or t.startswith(p)
+
+
+def edit_sim(pred: str, target: str) -> float:
+    return difflib.SequenceMatcher(None, normalize(pred), normalize(target)).ratio()
+
+
+@torch.no_grad()
+def generate(base_model, tokenizer, prefix: str, device, max_new_tokens: int = 12) -> str:
+    """Greedy-decode the answer, then truncate at the first newline.
+
+    Without this the model frequently keeps going past the answer into a
+    hallucinated ``\\nQ: <next question>`` continuation (base models without
+    an EOS-triggering chat template rarely stop cleanly on a bare
+    completion prompt); comparing the *untruncated* string against the gold
+    answer would mark an otherwise-correct short answer wrong just because
+    of what it rambled into afterward.
+    """
+    enc = tokenizer(prefix, return_tensors="pt").to(device)
+    out = base_model.generate(
+        **enc, max_new_tokens=max_new_tokens, do_sample=False,
+        pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id,
+    )
+    gen_ids = out[0][enc["input_ids"].shape[1]:]
+    text = tokenizer.decode(gen_ids, skip_special_tokens=True)
+    return text.split("\n")[0]
+
+
+def load_head_and_model(checkpoint: Path, model_name: str, target_modules: List[str],
+                         root_prefix: str, device: torch.device, dtype: torch.dtype,
+                         attn_implementation: str):
+    ckpt = torch.load(checkpoint, map_location="cpu")
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    base_model = AutoModelForImageTextToText.from_pretrained(
+        model_name, torch_dtype=dtype, attn_implementation=attn_implementation,
+    ).to(device)
+    base_model.eval()
+    for p in base_model.parameters():
+        p.requires_grad = False
+
+    specs = get_module_specs(base_model, target_modules, root_prefix=root_prefix)
+    rank = ckpt["config"]["rank"]
+    alpha = ckpt["args"].get("alpha", 32.0)
+    replace_with_lora(base_model, specs, rank=rank, alpha=alpha)
+
+    head = MemoryLoRAHead(
+        input_dim=ckpt["config"]["input_dim"],
+        type_dims={k: tuple(v) for k, v in ckpt["config"]["type_dims"].items()},
+        hidden_dim=ckpt["config"]["hidden_dim"],
+        rank=rank,
+    ).to(device)
+    head.load_state_dict(ckpt["state_dict"])
+    head.eval()
+    return base_model, head, specs, tokenizer
+
+
+def eval_suite(base_model, head, specs, tokenizer, doc_rows, qnas_by_doc, device,
+                max_qna_per_doc: int = 20) -> Dict[str, float]:
+    n_em, n_total, sum_editsim = 0, 0, 0.0
+    for dr in doc_rows:
+        pairs = qnas_by_doc.get(dr.doc_id, [])[:max_qna_per_doc]
+        if not pairs:
+            continue
+        ctx = torch.from_numpy(dr.doc_embedding).to(device).unsqueeze(0)
+        head_out = head(ctx)
+        inject_lora_weights(base_model, specs, head_out, batch_index=0)
+        for p in pairs:
+            pred = generate(base_model, tokenizer, p["prefix"], device)
+            target = p["target"]
+            if exact_match(pred, target):
+                n_em += 1
+            sum_editsim += edit_sim(pred, target)
+            n_total += 1
+    return {
+        "em": n_em / max(n_total, 1),
+        "editsim": sum_editsim / max(n_total, 1),
+        "n": n_total,
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--checkpoint", required=True)
+    ap.add_argument("--embeddings-path", default=str(EMBEDDINGS_DIR / "doc_embeddings.parquet"))
+    ap.add_argument("--qna-path", default=str(QNA_DIR / "qna.jsonl"))
+    ap.add_argument("--model-name", default=DEFAULT_MODEL)
+    ap.add_argument("--target-modules", nargs="+", default=DEFAULT_TARGET_MODULES)
+    ap.add_argument("--root-prefix", default=DEFAULT_ROOT_PREFIX)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"])
+    ap.add_argument("--attn-implementation", default="sdpa", choices=["sdpa", "eager"])
+    ap.add_argument("--suites", nargs="+", default=["cr_val", "cr_test", "ir_test"])
+    ap.add_argument("--max-qna-per-doc", type=int, default=20)
+    ap.add_argument("--limit-docs", type=int, default=0,
+                     help="Random-sample at most N docs per suite (fixed seed) "
+                          "for a fast estimate -- cr_test has thousands of real "
+                          "repos, far too many to greedy-generate on CPU.")
+    ap.add_argument("--skip-spot-check", action="store_true")
+    args = ap.parse_args()
+
+    device = torch.device(args.device if (args.device != "mps" or torch.backends.mps.is_available()) else "cpu")
+    dtype = {"bfloat16": torch.bfloat16, "float16": torch.float16, "float32": torch.float32}[args.dtype]
+
+    base_model, head, specs, tokenizer = load_head_and_model(
+        Path(args.checkpoint), args.model_name, args.target_modules,
+        args.root_prefix, device, dtype, args.attn_implementation,
+    )
+
+    all_docs = load_doc_rows(Path(args.embeddings_path))
+    all_qnas = load_qna_rows(Path(args.qna_path))
+    qnas_by_doc_all = {}
+    qnas_held_out_by_doc = {}
+    for q in all_qnas:
+        qnas_by_doc_all.setdefault(q.doc_id, []).append({"prefix": q.prefix, "target": q.target})
+        if q.qna_split == "held_out":
+            qnas_held_out_by_doc.setdefault(q.doc_id, []).append({"prefix": q.prefix, "target": q.target})
+    train_docs = [d for d in all_docs if d.split == "train"]
+
+    results: Dict[str, Any] = {}
+    for suite in args.suites:
+        if suite in ("cr_val", "cr_test"):
+            rows, q_by_doc = [d for d in all_docs if d.split == suite], qnas_by_doc_all
+        elif suite == "ir_test":
+            rows, q_by_doc = train_docs, qnas_held_out_by_doc
+        else:
+            continue
+        if args.limit_docs and len(rows) > args.limit_docs:
+            import random as _r
+            rows = _r.Random(3407).sample(rows, args.limit_docs)
+        print(f"Evaluating {suite} ({len(rows)} docs) ...", flush=True)
+        m = eval_suite(base_model, head, specs, tokenizer, rows, q_by_doc, device,
+                        max_qna_per_doc=args.max_qna_per_doc)
+        results[suite] = m
+        print(f"  {suite}: EM={m['em']:.3f} EditSim={m['editsim']:.3f} n={m['n']}", flush=True)
+
+    print(json.dumps(results, indent=2))
+
+    if not args.skip_spot_check:
+        print("\n=== Spot check: base model vs. LoRA-adapted, Code2LoRA paper facts ===", flush=True)
+        paper_doc = next((d for d in all_docs if d.doc_id == "code2lora_paper"), None)
+        if paper_doc is None:
+            print("  [skip] code2lora_paper doc not found in embeddings", flush=True)
+        else:
+            ctx = torch.from_numpy(paper_doc.doc_embedding).to(device).unsqueeze(0)
+            head_out = head(ctx)
+            for q, gold in SPOT_CHECK_QUESTIONS:
+                prefix = f"Q: {q}\nA:"
+                # base: zero out LoRA (A=B=None) by re-wrapping without injection
+                for sp in specs:
+                    named = dict(base_model.named_modules())
+                    named[sp.full_name].A = None
+                    named[sp.full_name].B = None
+                base_pred = generate(base_model, tokenizer, prefix, device)
+                inject_lora_weights(base_model, specs, head_out, batch_index=0)
+                adapted_pred = generate(base_model, tokenizer, prefix, device)
+                print(f"Q: {q}")
+                print(f"  gold:    {gold}")
+                print(f"  base:    {base_pred!r}")
+                print(f"  adapted: {adapted_pred!r}")
+                print()
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_commitpack_qa.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""Breadth generator: judgment QA from CommitPackFT commits across THOUSANDS
+of DISTINCT repos (25k distinct repos in the python shard alone).
+
+Complements generate_techlead_qa.py (SWE-bench), which is deep but spans only
+~12 repos. For a HYPERNETWORK, distinct-repo count is the currency of
+generalization -- so this takes ~1 commit per NEW repo to maximize breadth,
+not many commits of the same repo.
+
+Commit-scope judgment aspects (a single small commit rarely shows whole-system
+architecture, so we skip that): why / conventions / contracts / impact.
+Same Tier-A/B discipline: short judgment answers, no exact file/line lists.
+gemini-3.6-flash reasoning is mandatory -> generous max_tokens.
+
+Usage:
+  python scripts/generate_commitpack_qa.py --limit 3
+  python scripts/generate_commitpack_qa.py --max-repos 2500 --per-repo 1
+"""
+from __future__ import annotations
+import argparse, hashlib, json, os, re, sys, time
+from pathlib import Path
+from typing import Dict, List
+from openai import OpenAI
+
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR, DOCS_DIR, CACHE_DIR, ensure_dirs  # noqa: E402
+
+def _load_dotenv(p: Path):
+    if p.exists():
+        for line in p.read_text().splitlines():
+            if "=" in line and not line.strip().startswith("#"):
+                k, v = line.split("=", 1); os.environ.setdefault(k.strip(), v.strip())
+_load_dotenv(REPO_ROOT / ".env")
+
+MODEL = "google/gemini-3.6-flash"
+BASE_URL = "https://openrouter.ai/api/v1"
+SHARD = REPO_ROOT / "data" / "commitpack" / "multilang_commits.jsonl"
+
+SYSTEM = (
+ "You are a staff engineer writing onboarding Q&A about a single real commit. "
+ "Given the commit message and the before/after file contents, produce a JSON "
+ "array of 3-4 objects with keys 'aspect','question','answer'. aspect in: "
+ "why, conventions, contracts, impact. Rules: (1) test JUDGMENT/understanding, "
+ "not trivia. (2) answers SHORT -- one phrase/sentence, no file paths or line "
+ "numbers. (3) 'why' = rationale/trade-off; 'impact' = the KIND of behavior/"
+ "contract affected, not a file list; 'conventions' = the idiom/style this "
+ "change follows. (4) ground answers in the actual change; invent nothing. "
+ "Output ONLY the JSON array."
+)
+
+def cache_key(*p): return hashlib.sha256("||".join(p).encode()).hexdigest()[:24]
+
+def gen_qa(client, ctx, cache_dir, retries=4) -> List[Dict]:
+    cf = cache_dir / f"cpqa_{cache_key(MODEL, ctx)}.json"
+    if cf.exists():
+        raw = cf.read_text()
+    else:
+        last = None
+        for a in range(retries):
+            try:
+                r = client.chat.completions.create(model=MODEL,
+                    messages=[{"role": "system", "content": SYSTEM},
+                              {"role": "user", "content": ctx}],
+                    max_tokens=3000, temperature=0.6)
+                raw = r.choices[0].message.content or ""; cf.write_text(raw); break
+            except Exception as e:  # noqa: BLE001
+                last = e; time.sleep(2 ** a)
+        else:
+            return []
+    m = re.search(r"\[.*\]", raw, re.DOTALL)
+    if not m: return []
+    try: items = json.loads(m.group(0))
+    except json.JSONDecodeError: return []
+    out = []
+    for it in items:
+        q = (it.get("question") or "").strip(); a = (it.get("answer") or "").strip()
+        asp = (it.get("aspect") or "general").strip()
+        if q and a and len(a) < 240: out.append({"aspect": asp, "question": q, "answer": a})
+    return out
+
+def build_ctx(d) -> str:
+    def clip(s, n): return (s or "")[:n]
+    return (f"REPO: {d['repos'].split(',')[0]}  FILE: {d.get('new_file','')}\n"
+            f"COMMIT: {clip(d.get('subject'),120)}\n{clip(d.get('message'),500)}\n\n"
+            f"BEFORE:\n{clip(d.get('old_contents'),1800)}\n\n"
+            f"AFTER:\n{clip(d.get('new_contents'),1800)}")
+
+def main():
+    import threading
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--max-repos", type=int, default=2500)
+    ap.add_argument("--per-repo", type=int, default=1)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--model", default=MODEL)
+    ap.add_argument("--workers", type=int, default=10,
+                     help="Concurrent OpenRouter requests. Sequential gen was "
+                          "~10x too slow for 3k+ repos; the API handles "
+                          "concurrency fine and the per-prompt cache keeps it "
+                          "idempotent.")
+    args = ap.parse_args()
+    globals()["MODEL"] = args.model
+    ensure_dirs()
+    key = os.environ.get("OPENROUTER_API_KEY")
+    if not key: raise SystemExit("OPENROUTER_API_KEY not set")
+    client = OpenAI(base_url=BASE_URL, api_key=key)
+
+    target = args.limit if args.limit else args.max_repos
+    # select one commit per distinct repo (breadth), up to target
+    seen: Dict[str, int] = {}
+    tasks = []
+    for line in open(SHARD):
+        if len(tasks) >= target: break
+        try: d = json.loads(line)
+        except json.JSONDecodeError: continue
+        repo = d["repos"].split(",")[0]
+        if seen.get(repo, 0) >= args.per_repo: continue
+        seen[repo] = seen.get(repo, 0) + 1
+        tasks.append(d)
+
+    qna_f = (QNA_DIR / "techlead_qa_commitpack.jsonl").open("a")
+    src_f = (DOCS_DIR / "techlead_sources_commitpack.jsonl").open("a")
+    lock = threading.Lock()
+    n_docs = [0]; n_qa = [0]; t0 = time.time()
+
+    def work(d):
+        repo = d["repos"].split(",")[0]
+        qas = gen_qa(client, build_ctx(d), CACHE_DIR)
+        if not qas: return
+        doc_id = f"{repo}@{d['commit'][:10]}"
+        with lock:
+            src_f.write(json.dumps({"doc_id": doc_id, "repo": repo, "base_commit": d["commit"],
+                        "context": build_ctx(d), "source": "commitpackft", "lang": d.get("lang","python")}) + "\n")
+            for qa in qas:
+                qna_f.write(json.dumps({"doc_id": doc_id, "doc_version": d["commit"],
+                    "split": "train", "qna_split": "train", "aspect": qa["aspect"],
+                    "question": qa["question"], "prefix": f"Q: {qa['question']}\nA:",
+                    "target": " " + qa["answer"], "lang": d.get("lang","python")}) + "\n")
+                n_qa[0] += 1
+            n_docs[0] += 1
+            if n_docs[0] % 50 == 0:
+                rate = n_docs[0] / max(1e-9, (time.time() - t0) / 60)
+                print(f"  {n_docs[0]} repos, {n_qa[0]} QA ({rate:.1f} repo/min)", flush=True)
+
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        for _ in as_completed([ex.submit(work, d) for d in tasks]):
+            pass
+    qna_f.close(); src_f.close()
+    print(f"\nDone. {n_docs[0]} DISTINCT repos -> {n_qa[0]} judgment-QA pairs.", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/generate_repo_scoped_qa.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Generate REPO-SCOPED judgment QA from the SAME 6 views that
+build_repo_multiview.py embedded -- so target scope matches input scope
+(a repo-level embedding must be paired with repo-level questions, not
+commit-scoped ones). Reads data/docs/multiview_sources.jsonl (per-repo
+view_text) and writes data/qna/repo_scoped_qa.jsonl keyed by the same
+doc_id (= repo name).
+
+gemini-3.6-flash: reasoning mandatory -> generous max_tokens.
+Tier-A/B discipline: judgment answers, short, no exact file/line lists.
+
+Usage:
+  python scripts/generate_repo_scoped_qa.py --limit 3
+  python scripts/generate_repo_scoped_qa.py
+"""
+from __future__ import annotations
+import argparse, hashlib, json, os, re, sys, time
+from pathlib import Path
+from typing import Dict, List
+from openai import OpenAI
+
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR, DOCS_DIR, CACHE_DIR, ensure_dirs  # noqa: E402
+
+def _load_dotenv(p: Path):
+    if p.exists():
+        for line in p.read_text().splitlines():
+            if "=" in line and not line.strip().startswith("#"):
+                k, v = line.split("=", 1); os.environ.setdefault(k.strip(), v.strip())
+_load_dotenv(REPO_ROOT / ".env")
+MODEL = "google/gemini-3.6-flash"; BASE_URL = "https://openrouter.ai/api/v1"
+
+SYSTEM = (
+ "You are a 20-year tech lead writing onboarding Q&A for a NEW engineer joining "
+ "a repository. You are given 6 views of the repo: its call/import graph, "
+ "architecture (readme/tree), git history, test contracts, code conventions, "
+ "and ops/build config. Produce a JSON array of 8-12 objects with keys "
+ "'aspect','question','answer'. aspect in: architecture, data_flow, why, "
+ "contracts, conventions, impact, ops. Rules: (1) questions are REPO-LEVEL and "
+ "test JUDGMENT a senior would have ('what layer owns X', 'what convention does "
+ "this repo use for Y', 'how does data flow through Z', 'why is this structured "
+ "this way'), NOT trivia about one commit. (2) answers SHORT -- one phrase or "
+ "sentence, copyable, NO file-path or line-number lists. (3) 'impact' = the KIND "
+ "of thing that breaks/changes, not an exact file enumeration. (4) ground every "
+ "answer in the provided views; invent nothing. Output ONLY the JSON array."
+)
+
+def ckey(*p): return hashlib.sha256("||".join(p).encode()).hexdigest()[:24]
+
+def gen(client, ctx, cache_dir, retries=4) -> List[Dict]:
+    cf = cache_dir / f"rsqa_{ckey(MODEL, ctx)}.json"
+    if cf.exists():
+        raw = cf.read_text()
+    else:
+        last = None
+        for a in range(retries):
+            try:
+                r = client.chat.completions.create(model=MODEL,
+                    messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": ctx}],
+                    max_tokens=4000, temperature=0.6)
+                raw = r.choices[0].message.content or ""; cf.write_text(raw); break
+            except Exception as e:  # noqa: BLE001
+                last = e; time.sleep(2 ** a)
+        else:
+            return []
+    m = re.search(r"\[.*\]", raw, re.DOTALL)
+    if not m: return []
+    try: items = json.loads(m.group(0))
+    except json.JSONDecodeError: return []
+    out = []
+    for it in items:
+        q = (it.get("question") or "").strip(); a = (it.get("answer") or "").strip()
+        asp = (it.get("aspect") or "general").strip()
+        if q and a and len(a) < 240: out.append({"aspect": asp, "question": q, "answer": a})
+    return out
+
+def build_ctx(repo: str, vt: Dict[str, str]) -> str:
+    parts = [f"REPOSITORY: {repo}\n"]
+    for k in ["v_arch", "v_graph", "v_history", "v_contracts", "v_conventions", "v_ops"]:
+        parts.append(f"=== {k} ===\n{vt.get(k,'')}\n")
+    return "\n".join(parts)
+
+def main():
+    import threading
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--sources", default=str(DOCS_DIR / "multiview_sources.jsonl"))
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--model", default=MODEL)
+    ap.add_argument("--workers", type=int, default=10)
+    args = ap.parse_args()
+    globals()["MODEL"] = args.model
+    ensure_dirs()
+    key = os.environ.get("OPENROUTER_API_KEY")
+    if not key: raise SystemExit("OPENROUTER_API_KEY not set")
+    client = OpenAI(base_url=BASE_URL, api_key=key)
+
+    src = [json.loads(l) for l in open(args.sources)]
+    if args.limit: src = src[: args.limit]
+    outp = QNA_DIR / "repo_scoped_qa.jsonl"
+    done = set()
+    if outp.exists():
+        done = {json.loads(l)["doc_id"] for l in open(outp)}
+    todo = [r for r in src if r["doc_id"] not in done]
+    out_f = outp.open("a")
+    lock = threading.Lock()
+    n_docs = [0]; n_qa = [0]; t0 = time.time()
+
+    def work(row):
+        doc_id = row["doc_id"]
+        qas = gen(client, build_ctx(row["repo"], row["view_text"]), CACHE_DIR)
+        if not qas: return
+        with lock:
+            for qa in qas:
+                out_f.write(json.dumps({"doc_id": doc_id, "doc_version": "head",
+                    "split": "train", "qna_split": "train", "aspect": qa["aspect"],
+                    "question": qa["question"], "prefix": f"Q: {qa['question']}\nA:",
+                    "target": " " + qa["answer"], "lang": row.get("lang", "unknown")}) + "\n")
+                n_qa[0] += 1
+            n_docs[0] += 1
+            if n_docs[0] % 25 == 0:
+                print(f"  {n_docs[0]}/{len(todo)} repos, {n_qa[0]} QA "
+                      f"({n_docs[0]/max(1e-9,(time.time()-t0)/60):.1f}/min)", flush=True)
+
+    with ThreadPoolExecutor(max_workers=args.workers) as ex:
+        for _ in as_completed([ex.submit(work, r) for r in todo]):
+            pass
+    out_f.close()
+    print(f"\nDone. {n_docs[0]} repos -> {n_qa[0]} repo-scoped judgment QA.", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/generate_synthetic_dataset.py

@@ -0,0 +1,545 @@
+#!/usr/bin/env python3
+"""Generate the Memory-LoRA training corpus via OpenRouter.
+
+Produces two local parquet-backed artifacts under ``data/``:
+
+  data/docs/documents.jsonl   -- one row per document (id, category, topic,
+                                  cross-corpus split, list of (section, text))
+  data/qna/qna.jsonl          -- one row per recall QA pair (doc_id, split,
+                                  qna_split, question, prefix, target)
+
+Four document categories, all seeded to contain specific, checkable facts
+(numbers, names, claims) so recall is gradeable by exact-match, mirroring
+Code2LoRA's assertion-completion targets:
+
+  paper              -- the REAL Code2LoRA paper, chunked into sections
+                        (not synthetic -- hand-authored below from the
+                        paper we already read in full).
+  coding_agent_harness -- synthetic docs about capabilities that help coding
+                        agents / CLI tools (Claude Code, Codex, etc.) handle
+                        large codebases: context injection, repo indexing,
+                        diffing, static analysis, self-improvement loops.
+  agile_pm           -- synthetic docs about agile project tracking: Jira
+                        ticket lifecycles, sprints, story points, velocity,
+                        epics, standups, retrospectives, burndown.
+  general            -- broad diverse synthetic fact-sheets, needed so the
+                        hypernetwork's document->LoRA mapping generalizes
+                        (breadth requirement, same reason Code2LoRA needed
+                        400+ repos rather than 1).
+
+OpenRouter is OpenAI-API compatible -- plain ``openai`` client,
+base_url=https://openrouter.ai/api/v1. Key read from OPENROUTER_API_KEY
+(loaded from a local .env, never hardcoded/committed).
+
+Usage:
+    python scripts/generate_synthetic_dataset.py --limit 3     # smoke test
+    python scripts/generate_synthetic_dataset.py --n-per-category 60
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import random
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from openai import OpenAI
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import DOCS_DIR, QNA_DIR, CACHE_DIR, ensure_dirs  # noqa: E402
+
+
+def _load_dotenv(path: Path) -> None:
+    if not path.exists():
+        return
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        os.environ.setdefault(k.strip(), v.strip())
+
+
+_load_dotenv(REPO_ROOT / ".env")
+
+DEFAULT_GEN_MODEL = "qwen/qwen-2.5-7b-instruct"
+OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
+
+
+# ---------------------------------------------------------------------------
+# Cache-wrapped OpenRouter call
+# ---------------------------------------------------------------------------
+
+def _cache_key(model: str, messages: List[Dict[str, str]], **kwargs) -> str:
+    payload = json.dumps({"model": model, "messages": messages, **kwargs},
+                          sort_keys=True)
+    return hashlib.sha256(payload.encode()).hexdigest()[:24]
+
+
+class CachedClient:
+    def __init__(self, client: OpenAI, cache_dir: Path):
+        self.client = client
+        self.cache_dir = cache_dir
+
+    def chat(self, model: str, messages: List[Dict[str, str]],
+             temperature: float = 0.9, max_tokens: int = 2000,
+             retries: int = 4) -> str:
+        key = _cache_key(model, messages, temperature=temperature,
+                          max_tokens=max_tokens)
+        cache_file = self.cache_dir / f"{key}.txt"
+        if cache_file.exists():
+            return cache_file.read_text()
+        last_err: Optional[Exception] = None
+        for attempt in range(retries):
+            try:
+                resp = self.client.chat.completions.create(
+                    model=model, messages=messages,
+                    temperature=temperature, max_tokens=max_tokens,
+                )
+                text = resp.choices[0].message.content or ""
+                cache_file.write_text(text)
+                return text
+            except Exception as e:  # noqa: BLE001
+                last_err = e
+                wait = 2 ** attempt
+                print(f"  [warn] OpenRouter call failed ({e}); retry in {wait}s",
+                      flush=True)
+                time.sleep(wait)
+        raise RuntimeError(f"OpenRouter call failed after {retries} retries: {last_err}")
+
+
+# ---------------------------------------------------------------------------
+# Topic seeds per category (kept diverse -> the hypernetwork sees breadth)
+# ---------------------------------------------------------------------------
+
+CODING_AGENT_TOPICS = [
+    "repository-level context injection strategies for LLM coding agents",
+    "incremental static analysis caching for large monorepos",
+    "test-impact analysis to select which tests to rerun after a diff",
+    "dependency graph indexing for cross-file code navigation",
+    "safe automated refactoring patterns for renaming across a codebase",
+    "context window budget management when an agent reads many files",
+    "self-improvement loops where a coding agent revises its own tool use",
+    "diffing and patch-application strategies for multi-file edits",
+    "detecting and avoiding regressions when an agent edits shared utilities",
+    "code search ranking heuristics for retrieval-augmented coding agents",
+    "sandboxing and permission models for autonomous coding agents",
+    "long-horizon planning for agents building complex multi-module programs",
+    "memory architectures that let an agent recall project conventions",
+    "strategies for agents to keep a mental model of a large codebase in sync",
+    "CLI tool design patterns for developer-facing coding agents",
+    "evaluating coding agent reliability on multi-step programming tasks",
+    "handling build system and dependency resolution errors autonomously",
+    "techniques for agents to summarize large pull requests for review",
+    "version-control-aware agent workflows (branches, rebases, conflicts)",
+    "strategies for agents to write and maintain their own regression tests",
+]
+
+AGILE_PM_TOPICS = [
+    "Jira ticket lifecycle states and transition rules",
+    "sprint planning and story point estimation techniques",
+    "velocity tracking and forecasting sprint capacity",
+    "epic and subtask hierarchy conventions in agile tracking tools",
+    "daily standup meeting structure and anti-patterns",
+    "sprint retrospective formats and action item follow-through",
+    "burndown and burnup chart interpretation",
+    "backlog grooming and prioritization frameworks (MoSCoW, WSJF)",
+    "definition of done and acceptance criteria best practices",
+    "kanban WIP limits and flow efficiency metrics",
+    "cross-team dependency tracking in scaled agile (SAFe, LeSS)",
+    "bug triage severity/priority labeling conventions",
+    "release planning and versioning cadences",
+    "stakeholder reporting cadences and status update formats",
+    "agile ceremonies for distributed/remote teams",
+]
+
+PROJECT_STATUS_TOPICS = [
+    "a web app team's sprint status: open tickets, in-progress work, recent commits",
+    "a data pipeline team's current sprint: blocked tickets, recent diffs, on-call rotation",
+    "a mobile app team's release cycle: feature tickets, QA status, code review queue",
+    "an API service team's incident + sprint status: hotfix tickets, recent deploys",
+    "an ML training infra team's sprint: experiment tickets, recent config diffs",
+    "a platform team's migration project: tracked subtasks, rollout percentage, blockers",
+    "a devtools team's backlog grooming outcome: prioritized tickets, recent PRs merged",
+    "a security team's remediation sprint: CVE tickets, patch status, recent commits",
+    "a frontend team's design-system rollout: component tickets, adoption tracking",
+    "a backend team's database migration sprint: schema tickets, rollback plan, diffs",
+]
+
+PROJECT_STATUS_SYSTEM = (
+    "You write a realistic internal project-status snapshot for a software "
+    "team, combining a Jira-style ticket board with recent code activity. "
+    "Invent a plausible project/repo name, then include: (1) 6-10 tickets, "
+    "each with a ticket key (e.g. PROJ-1234), status (To Do/In Progress/In "
+    "Review/Done/Blocked), assignee name, story points, and a one-line "
+    "description; (2) a sprint summary (sprint number, dates, velocity, "
+    "burndown status); (3) a 'recent changes' section describing 2-4 "
+    "specific code changes (file names, what changed, why) as if summarizing "
+    "recent commits/diffs; (4) any current blockers or risks. Every fact "
+    "(ticket key, status, assignee, points, sprint number, file name) must "
+    "be specific and consistent so it can be tested for recall. 400-700 "
+    "words. No markdown headers, structured prose with clear labels."
+)
+
+
+def gen_project_status_document(client: CachedClient, model: str, topic: str) -> str:
+    prompt = f"Write a project-status snapshot for: {topic}."
+    return client.chat(
+        model=model,
+        messages=[
+            {"role": "system", "content": PROJECT_STATUS_SYSTEM},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.9,
+        max_tokens=1400,
+    )
+
+
+GENERAL_TOPICS = [
+    "the history and mechanics of a fictional national park's geology",
+    "the biology of a deep-sea bioluminescent organism",
+    "the engineering of a suspension bridge's cable system",
+    "the brewing process and quality control of specialty coffee",
+    "the orbital mechanics of a hypothetical exoplanet system",
+    "the supply chain logistics of a regional produce cooperative",
+    "the architecture of a public transit signaling system",
+    "the culinary traditions of a fictional coastal fishing village",
+    "the manufacturing process of a specific alloy used in aerospace",
+    "the ecology of a wetland restoration project",
+    "the governance structure of a municipal water utility",
+    "the training regimen of competitive long-distance cyclists",
+    "the archival practices of a rare-book conservation lab",
+    "the acoustics engineering of a concert hall renovation",
+    "the logistics of a regional disaster-relief supply network",
+    "the taxonomy and care requirements of a rare orchid genus",
+    "the operations of a small-batch letterpress printing studio",
+    "the hydrology of an urban stormwater management system",
+    "the production pipeline of a stop-motion animation studio",
+    "the maintenance schedule of a commercial wind turbine farm",
+]
+
+DOC_GEN_SYSTEM = (
+    "You write dense, factual reference documents. Every document must contain "
+    "15-30 SPECIFIC, VERIFIABLE facts: exact numbers, named entities, precise "
+    "claims, thresholds, or procedures. Avoid vague generalities. Write "
+    "300-800 words. Do not use markdown headers; write flowing prose "
+    "paragraphs. Invent plausible specifics (names, numbers, dates) when the "
+    "topic is fictional/hypothetical -- consistency within the document "
+    "matters more than real-world accuracy."
+)
+
+QA_GEN_SYSTEM = (
+    "You extract recall test questions from a reference document. Given the "
+    "document, produce a JSON array of 15-25 objects, each with keys "
+    "'question' and 'answer'. Each question must test recall of ONE specific "
+    "fact stated in the document (a number, name, threshold, or precise "
+    "claim). The answer must be SHORT (1-8 words, ideally a number, name, or "
+    "short phrase) and must be copyable verbatim or near-verbatim from the "
+    "document. Do not ask yes/no questions. Do not ask questions requiring "
+    "reasoning beyond direct recall. Output ONLY the JSON array, no prose."
+)
+
+
+def gen_document(client: CachedClient, model: str, category: str, topic: str) -> str:
+    prompt = (
+        f"Write a reference document about: {topic}.\n"
+        f"Category: {category}."
+    )
+    return client.chat(
+        model=model,
+        messages=[
+            {"role": "system", "content": DOC_GEN_SYSTEM},
+            {"role": "user", "content": prompt},
+        ],
+        temperature=0.9,
+        max_tokens=1200,
+    )
+
+
+def gen_qna(client: CachedClient, model: str, doc_text: str) -> List[Dict[str, str]]:
+    raw = client.chat(
+        model=model,
+        messages=[
+            {"role": "system", "content": QA_GEN_SYSTEM},
+            {"role": "user", "content": doc_text},
+        ],
+        temperature=0.3,
+        max_tokens=2000,
+    )
+    match = re.search(r"\[.*\]", raw, re.DOTALL)
+    if not match:
+        return []
+    try:
+        items = json.loads(match.group(0))
+    except json.JSONDecodeError:
+        return []
+    out = []
+    for it in items:
+        q = (it.get("question") or "").strip()
+        a = (it.get("answer") or "").strip()
+        if q and a and len(a) < 200:
+            out.append({"question": q, "answer": a})
+    return out
+
+
+# ---------------------------------------------------------------------------
+# The Code2LoRA paper -- real document, hand-chunked into sections (from the
+# paper we already read in full; not regenerated by an LLM).
+# ---------------------------------------------------------------------------
+
+def code2lora_paper_sections() -> List[Dict[str, str]]:
+    return [
+        {"name": "abstract", "text": (
+            "Code2LoRA is a hypernetwork framework that generates repository-"
+            "specific LoRA adapters, effectively injecting repository "
+            "knowledge with zero inference-time token overhead. Code2LoRA "
+            "supports two usage scenarios: Code2LoRA-Static converts a "
+            "single repository snapshot into an adapter; Code2LoRA-Evo "
+            "maintains an adapter backed by a GRU hidden state updated per "
+            "code diff. The authors build RepoPeftBench, a benchmark of 604 "
+            "Python repositories with two tracks: a static track with 40K "
+            "training and 12K test assertion-completion tasks, and an "
+            "evolution track with 215K commit-derived training and 87K "
+            "commit-derived test tasks. On the static track, Code2LoRA-"
+            "Static achieves 63.8% cross-repo and 66.2% in-repo exact match, "
+            "matching the per-repository LoRA upper bound; on the evolution "
+            "track, Code2LoRA-Evo achieves 60.3% cross-repo exact match, "
+            "+5.2 percentage points over a single shared LoRA."
+        )},
+        {"name": "method_architecture", "text": (
+            "Code2LoRA has three components: a shared repository encoder "
+            "that maps repository-level context to dense embeddings, a "
+            "hypernetwork that maps those embeddings to LoRA weights, and a "
+            "base LLM that receives the generated adapter. Only the "
+            "hypernetwork is trained. The repository encoder uses a frozen "
+            "Qwen3-Embedding-0.6B model: each file is divided into 4096-"
+            "token chunks with 512-token overlap, embedded, and mean-pooled "
+            "to produce a file vector of dimension 1024. The repository "
+            "embedding is the concatenation of a weighted mean and a max "
+            "pool of file vectors, giving a 2048-dimensional vector. "
+            "Code2LoRA-Static's hypernetwork has a 2-layer MLP trunk with "
+            "GELU activation, hidden dimension 1024, followed by dedicated "
+            "output heads per module type. LoRA matrices use rank r=16 and "
+            "alpha=32, targeting seven module types (q_proj, k_proj, "
+            "v_proj, o_proj, gate_proj, up_proj, down_proj) shared across "
+            "all 28 transformer layers of the base model. Code2LoRA-Static "
+            "has approximately 720 million trainable parameters. Code2LoRA-"
+            "Evo adds a 1-layer GRU with hidden size 2048 that aggregates "
+            "sequential diff embeddings into a hidden state, which "
+            "substitutes for the static embedding in the same shared head; "
+            "Code2LoRA-Evo has approximately 745 million trainable "
+            "parameters, using truncated backpropagation through time with "
+            "a window of K=16 steps."
+        )},
+        {"name": "benchmark_repopeftbench", "text": (
+            "RepoPeftBench comprises 604 Python repositories drawn from "
+            "GitHub: 512 in-distribution repositories (requiring at least "
+            "300 stars) and a 92-repository temporal out-of-distribution "
+            "holdout created strictly after the 2025-04-01 scrape cutoff. "
+            "The in-distribution set is partitioned into cross-repo (103 "
+            "held-out repositories: 51 validation, 52 test) and in-repo "
+            "(409 training repositories) splits. The task is assertion "
+            "completion: given a structured prefix from a test file "
+            "(imports, enclosing class, helper methods, test body up to the "
+            "assertion), the model predicts the expected value of the "
+            "assertion. The static track draws 39,612 training and 11,636 "
+            "test tasks from repository snapshots. The evolution track "
+            "replays commit history, yielding 215,129 training and 86,793 "
+            "test tasks derived from commits. Evaluation metrics are Exact "
+            "Match (EM), Edit Similarity, and CodeBLEU. The base LLM used "
+            "in all experiments is Qwen2.5-Coder-1.5B, loaded in bfloat16, "
+            "trained on a single H100 80GB GPU using the TRL library."
+        )},
+        {"name": "results_static_track", "text": (
+            "On RepoPeftBench's static track, Code2LoRA-Static achieves "
+            "63.8% cross-repo exact match, 9.9 percentage points above the "
+            "strongest baseline (full fine-tuning plus RAG, at 53.9%). "
+            "Other baselines score lower: RAG with k=3 reaches 39.7% EM, "
+            "Dependency-Resolved Context reaches 48.2% EM, full fine-tuning "
+            "alone reaches 51.4% EM, and a single shared LoRA reaches 47.4% "
+            "EM. On in-repo evaluation, Code2LoRA-Static reaches 66.2% EM, "
+            "matching the per-repository LoRA upper bound of 64.0% EM "
+            "without any per-repository training. A strengthened Text2LoRA "
+            "baseline, matched on input modality and target-module "
+            "coverage, reaches only 45.8% EM on cross-repo, isolating the "
+            "Text2LoRA hypernetwork head itself as the bottleneck."
+        )},
+        {"name": "results_evolution_track", "text": (
+            "On the evolution track, which evaluates on commit-derived "
+            "prefixes, Code2LoRA-Evo is the strongest method on both "
+            "splits: 60.3% cross-repo EM and 64.5% in-repo EM, a gain of "
+            "5.2 percentage points over a single shared LoRA on cross-repo. "
+            "Code2LoRA-Evo's in-repo EM of 64.5% exceeds the per-repository "
+            "LoRA upper bound of 64.2% without any per-repository training. "
+            "Code2LoRA-Static, evaluated on the same commit-derived inputs "
+            "as a within-framework reference, drops to 55.7% cross-repo EM "
+            "and 60.6% in-repo EM, markedly below its static-track "
+            "performance, showing that snapshot-based adaptation goes "
+            "stale as a repository accumulates commits. On the 92-"
+            "repository temporal out-of-distribution holdout, Code2LoRA-"
+            "Evo achieves the highest exact match at 74.1%, ahead of "
+            "Code2LoRA-Static at 72.2% and a single shared LoRA at 72.3%."
+        )},
+        {"name": "efficiency", "text": (
+            "Code2LoRA-Static and Code2LoRA-Evo generate a repository-"
+            "specific adapter in under 10 milliseconds per repository with "
+            "zero extra inference tokens, versus approximately 1,500 extra "
+            "tokens per query for RAG with k=3, and approximately 500 to "
+            "2,000 extra tokens per query for Dependency-Resolved Context. "
+            "Full fine-tuning requires about 4 hours of training and adds "
+            "3.1 gigabytes of storage per repository; per-repository LoRA "
+            "requires about 5 minutes of training and 32 megabytes of "
+            "storage per repository. In contrast, Code2LoRA-Static's "
+            "hypernetwork adds a fixed 679 megabytes of storage shared "
+            "across all repositories, and Code2LoRA-Evo adds 65 megabytes, "
+            "independent of how many repositories are served."
+        )},
+        {"name": "limitations", "text": (
+            "The Code2LoRA paper's limitations section notes the evaluation "
+            "is restricted to Python repositories, a single frozen backbone "
+            "(Qwen2.5-Coder-1.5B), and one downstream task (assertion "
+            "completion). The reported 74.1% out-of-distribution exact "
+            "match may be partially inflated because assertion targets in "
+            "the post-cutoff OOD repositories are systematically shorter "
+            "(median 7 characters) than in the cross-repo and in-repo test "
+            "sets (median 12-13 characters). The LoRA-generation "
+            "hypernetwork dominates the trainable parameter count -- "
+            "approximately 720 million for Code2LoRA-Static and 745 "
+            "million for Code2LoRA-Evo -- so the evolution-track finding "
+            "is most directly supported at the 1.5-billion-parameter "
+            "backbone scale."
+        )},
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Splits + orchestration
+# ---------------------------------------------------------------------------
+
+def assign_cross_corpus_split(rng: random.Random) -> str:
+    r = rng.random()
+    if r < 0.8:
+        return "train"
+    if r < 0.9:
+        return "cr_val"
+    return "cr_test"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gen-model", default=DEFAULT_GEN_MODEL)
+    ap.add_argument("--n-per-category", type=int, default=60,
+                     help="Docs to generate per synthetic category "
+                          "(coding_agent_harness, agile_pm, general).")
+    ap.add_argument("--limit", type=int, default=0,
+                     help="If set, overrides --n-per-category to a small "
+                          "number for a cheap smoke test.")
+    ap.add_argument("--only-categories", nargs="+", default=[],
+                     help="Restrict generation to these categories (e.g. "
+                          "--only-categories project_status), instead of "
+                          "regenerating the whole corpus. Also skips the "
+                          "paper doc when set.")
+    ap.add_argument("--skip-paper", action="store_true")
+    ap.add_argument("--seed", type=int, default=3407)
+    args = ap.parse_args()
+
+    ensure_dirs()
+
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+    if not api_key:
+        raise SystemExit("OPENROUTER_API_KEY not set (expected in .env)")
+
+    client = CachedClient(
+        OpenAI(base_url=OPENROUTER_BASE_URL, api_key=api_key),
+        cache_dir=CACHE_DIR,
+    )
+    rng = random.Random(args.seed)
+
+    n_per_cat = args.limit if args.limit else args.n_per_category
+
+    docs_path = DOCS_DIR / "documents.jsonl"
+    qna_path = QNA_DIR / "qna.jsonl"
+    docs_f = docs_path.open("a")
+    qna_f = qna_path.open("a")
+
+    doc_counter = 0
+    qna_counter = 0
+
+    def emit_doc(doc_id: str, category: str, topic: str,
+                 sections: List[Dict[str, str]], split: str) -> None:
+        nonlocal doc_counter, qna_counter
+        docs_f.write(json.dumps({
+            "doc_id": doc_id, "doc_version": "v1", "category": category,
+            "topic": topic, "split": split, "sections": sections,
+        }) + "\n")
+        doc_counter += 1
+
+        full_text = "\n\n".join(s["text"] for s in sections)
+        qnas = gen_qna(client, args.gen_model, full_text)
+        n_qna = len(qnas)
+        for i, qa in enumerate(qnas):
+            qna_split = "train" if rng.random() < 0.8 else "held_out"
+            qna_f.write(json.dumps({
+                "doc_id": doc_id, "doc_version": "v1", "split": split,
+                "qna_split": qna_split,
+                "question": qa["question"],
+                "prefix": f"Q: {qa['question']}\nA:",
+                "target": " " + qa["answer"],
+            }) + "\n")
+            qna_counter += 1
+        print(f"  [{category}] {doc_id} ({topic[:50]}...) -> {n_qna} QAs, split={split}",
+              flush=True)
+
+    # 1. The real Code2LoRA paper -- always included, always in train split
+    # (we WANT it memorized, not held out for cross-corpus generalization
+    # testing -- that's the whole point of this build).
+    if not args.skip_paper and not args.only_categories:
+        print("=== paper (real, hand-authored sections) ===", flush=True)
+        emit_doc("code2lora_paper", "paper", "Code2LoRA paper",
+                 code2lora_paper_sections(), split="train")
+
+    # 2. Synthetic categories
+    topic_lists = {
+        "coding_agent_harness": CODING_AGENT_TOPICS,
+        "agile_pm": AGILE_PM_TOPICS,
+        "project_status": PROJECT_STATUS_TOPICS,
+        "general": GENERAL_TOPICS,
+    }
+    if args.only_categories:
+        topic_lists = {k: v for k, v in topic_lists.items() if k in args.only_categories}
+    for category, topics in topic_lists.items():
+        print(f"=== {category} ({n_per_cat} docs) ===", flush=True)
+        for i in range(n_per_cat):
+            topic = topics[i % len(topics)]
+            if i >= len(topics):
+                topic = f"{topic} (variant {i // len(topics) + 1}, different specifics)"
+            doc_id = f"{category}_{i:04d}"
+            split = assign_cross_corpus_split(rng)
+            try:
+                if category == "project_status":
+                    text = gen_project_status_document(client, args.gen_model, topic)
+                else:
+                    text = gen_document(client, args.gen_model, category, topic)
+            except RuntimeError as e:
+                print(f"  [error] skipping {doc_id}: {e}", flush=True)
+                continue
+            sections = [{"name": "body", "text": text}]
+            emit_doc(doc_id, category, topic, sections, split)
+
+    docs_f.close()
+    qna_f.close()
+    print(f"\nDone. {doc_counter} documents, {qna_counter} QA pairs written to:")
+    print(f"  {docs_path}")
+    print(f"  {qna_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_techlead_qa.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Generate high-quality, judgment-shaped "Tech Lead" QA from REAL GitHub
+data (SWE-bench: real issues + fix patches + test patches + PR discussion),
+via OpenRouter google/gemini-3.6-flash.
+
+Design decisions baked in from this session's analysis:
+- Targets are TIER-A/B *judgment* QA only (why / architecture / data-flow /
+  contracts / conventions / impact-NARRATIVE), never Tier-C exact-recall
+  ("list the precise files+lines") which a LoRA can only hallucinate.
+- Answers are SHORT (a phrase/sentence) so they're compressible into a
+  weight-delta and gradeable.
+- Each example is keyed to doc_id = "{repo}@{base_commit[:10]}" so it can
+  later be tied to a repo-state embedding for hypernetwork training.
+- gemini-3.6-flash is a REASONING model: reasoning is mandatory and cannot
+  be disabled, and it consumes completion tokens BEFORE content -- so
+  max_tokens must be generous (default 3500) or content comes back empty.
+
+Usage:
+  python scripts/generate_techlead_qa.py --limit 3          # smoke test
+  python scripts/generate_techlead_qa.py --max-instances 1200
+"""
+from __future__ import annotations
+import argparse, hashlib, json, os, re, sys, time
+from pathlib import Path
+from typing import Dict, List
+from openai import OpenAI
+
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR, DOCS_DIR, CACHE_DIR, ensure_dirs  # noqa: E402
+
+def _load_dotenv(p: Path):
+    if p.exists():
+        for line in p.read_text().splitlines():
+            if "=" in line and not line.strip().startswith("#"):
+                k, v = line.split("=", 1); os.environ.setdefault(k.strip(), v.strip())
+_load_dotenv(REPO_ROOT / ".env")
+
+MODEL = "google/gemini-3.6-flash"
+BASE_URL = "https://openrouter.ai/api/v1"
+
+SYSTEM = (
+ "You are a staff engineer writing onboarding Q&A about a real code change. "
+ "Given an issue, its fix patch, the test patch, and any discussion, produce "
+ "a JSON array of 5-8 objects with keys 'aspect', 'question', 'answer'. "
+ "aspect must be one of: architecture, data_flow, why, contracts, conventions, "
+ "impact. Rules: (1) Questions test JUDGMENT and UNDERSTANDING, not memorized "
+ "trivia. (2) Answers are SHORT -- one phrase or one sentence, copyable, no "
+ "lists of file paths or line numbers. (3) 'why' questions explain the "
+ "rationale/trade-off. 'impact' questions describe the KIND of thing affected "
+ "(a behavior, a contract), NOT an exact file enumeration. (4) Ground every "
+ "answer in the provided change; do not invent APIs. Output ONLY the JSON array."
+)
+
+def cache_key(*parts) -> str:
+    return hashlib.sha256("||".join(parts).encode()).hexdigest()[:24]
+
+def gen_qa(client, ctx: str, cache_dir: Path, retries=4) -> List[Dict]:
+    key = cache_key(MODEL, ctx)
+    cf = cache_dir / f"tlqa_{key}.json"
+    if cf.exists():
+        raw = cf.read_text()
+    else:
+        last = None
+        for a in range(retries):
+            try:
+                r = client.chat.completions.create(
+                    model=MODEL,
+                    messages=[{"role": "system", "content": SYSTEM},
+                              {"role": "user", "content": ctx}],
+                    max_tokens=3500, temperature=0.6)
+                raw = r.choices[0].message.content or ""
+                cf.write_text(raw); break
+            except Exception as e:  # noqa: BLE001
+                last = e; time.sleep(2 ** a)
+        else:
+            print(f"    [warn] failed: {last}", flush=True); return []
+    m = re.search(r"\[.*\]", raw, re.DOTALL)
+    if not m: return []
+    try:
+        items = json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return []
+    out = []
+    for it in items:
+        q = (it.get("question") or "").strip()
+        a = (it.get("answer") or "").strip()
+        asp = (it.get("aspect") or "general").strip()
+        if q and a and len(a) < 240:
+            out.append({"aspect": asp, "question": q, "answer": a})
+    return out
+
+def build_ctx(row) -> str:
+    def clip(s, n): return (s or "")[:n]
+    return (f"REPO: {row['repo']}\n"
+            f"ISSUE:\n{clip(row.get('problem_statement'),1500)}\n\n"
+            f"DISCUSSION:\n{clip(row.get('hints_text'),800)}\n\n"
+            f"FIX PATCH:\n{clip(row.get('patch'),2500)}\n\n"
+            f"TEST PATCH:\n{clip(row.get('test_patch'),1200)}")
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--max-instances", type=int, default=1200)
+    ap.add_argument("--limit", type=int, default=0, help="smoke-test cap")
+    ap.add_argument("--split", default="test")
+    args = ap.parse_args()
+    ensure_dirs()
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+    if not api_key: raise SystemExit("OPENROUTER_API_KEY not set")
+    client = OpenAI(base_url=BASE_URL, api_key=api_key)
+
+    from datasets import load_dataset
+    ds = load_dataset("princeton-nlp/SWE-bench", split=args.split, streaming=True)
+
+    n_max = args.limit if args.limit else args.max_instances
+    qna_f = (QNA_DIR / "techlead_qa.jsonl").open("a")
+    src_f = (DOCS_DIR / "techlead_sources.jsonl").open("a")
+    n_docs = n_qa = 0
+    t0 = time.time()
+    for row in ds:
+        if n_docs >= n_max: break
+        doc_id = f"{row['repo']}@{row['base_commit'][:10]}"
+        ctx = build_ctx(row)
+        qas = gen_qa(client, ctx, CACHE_DIR)
+        if not qas: continue
+        # store the source context so a repo-state embedding can be built later
+        src_f.write(json.dumps({"doc_id": doc_id, "repo": row["repo"],
+                                "base_commit": row["base_commit"], "context": ctx}) + "\n")
+        for qa in qas:
+            qna_f.write(json.dumps({
+                "doc_id": doc_id, "doc_version": row["base_commit"],
+                "split": "train", "qna_split": "train",
+                "aspect": qa["aspect"], "question": qa["question"],
+                "prefix": f"Q: {qa['question']}\nA:", "target": " " + qa["answer"],
+            }) + "\n")
+            n_qa += 1
+        n_docs += 1
+        if n_docs % 10 == 0:
+            rate = n_docs / max(1e-9, (time.time() - t0) / 60)
+            print(f"  {n_docs} instances, {n_qa} QA ({rate:.1f} inst/min) latest={doc_id}", flush=True)
+    qna_f.close(); src_f.close()
+    print(f"\nDone. {n_docs} real instances -> {n_qa} judgment-QA pairs.", flush=True)
+    print(f"  {QNA_DIR/'techlead_qa.jsonl'}\n  {DOCS_DIR/'techlead_sources.jsonl'}", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/merge_corpora.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""Merge the real Code2LoRA/RepoPeftBench corpus (73,849 real repo-commit
+docs, 443,798 real assertion-completion QnAs) with our synthetic corpus
+(211 docs: the Code2LoRA paper + coding-agent-harness + agile/Jira +
+general fact-sheets) into one combined training set for the hypernetwork.
+
+Output:
+    data/embeddings/combined_embeddings.parquet
+    data/qna/combined_qna.jsonl
+
+Usage:
+    python scripts/merge_corpora.py
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import EMBEDDINGS_DIR, QNA_DIR, ensure_dirs  # noqa: E402
+
+
+def merge_embeddings() -> int:
+    synthetic_path = EMBEDDINGS_DIR / "doc_embeddings.parquet"
+    real_path = EMBEDDINGS_DIR / "real_code2lora_embeddings.parquet"
+    out_path = EMBEDDINGS_DIR / "combined_embeddings.parquet"
+
+    tables = []
+    for p, label in [(synthetic_path, "synthetic"), (real_path, "real")]:
+        if not p.exists():
+            print(f"  [skip] {p} not found", flush=True)
+            continue
+        t = pq.read_table(p)
+        print(f"  {label}: {t.num_rows} rows, columns={t.column_names}", flush=True)
+        tables.append(t.select(["doc_id", "doc_version", "split", "category", "doc_embedding"]))
+
+    combined = pa.concat_tables(tables)
+    pq.write_table(combined, out_path)
+    print(f"Wrote {combined.num_rows} combined embeddings -> {out_path}", flush=True)
+    return combined.num_rows
+
+
+def merge_qna() -> int:
+    synthetic_path = QNA_DIR / "qna.jsonl"
+    real_path = QNA_DIR / "real_code2lora_qna.jsonl"
+    out_path = QNA_DIR / "combined_qna.jsonl"
+
+    n = 0
+    with out_path.open("w") as out:
+        for p, label in [(synthetic_path, "synthetic"), (real_path, "real")]:
+            if not p.exists():
+                print(f"  [skip] {p} not found", flush=True)
+                continue
+            count = 0
+            with p.open() as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    out.write(line + "\n")
+                    count += 1
+                    n += 1
+            print(f"  {label}: {count} QnA rows", flush=True)
+    print(f"Wrote {n} combined QnA pairs -> {out_path}", flush=True)
+    return n
+
+
+def main() -> None:
+    ensure_dirs()
+    print("Merging embeddings...", flush=True)
+    n_docs = merge_embeddings()
+    print("\nMerging QnA...", flush=True)
+    n_qna = merge_qna()
+    print(f"\nCombined corpus: {n_docs} documents, {n_qna} QnA pairs.", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/show_eval_examples.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Show concrete held-out examples: for a few cr_test docs (both REAL repos
+and synthetic), inject the hypernetwork-generated adapter and print
+question -> gold vs base-model vs adapted-model prediction, so we can SEE
+what the eval actually measured. CPU-only."""
+from __future__ import annotations
+import json, random, sys
+from pathlib import Path
+import numpy as np, torch
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.core import (MemoryLoRAHead, get_module_specs, replace_with_lora,
+                               inject_lora_weights, load_doc_rows, load_qna_rows, DEFAULT_ROOT_PREFIX)
+from transformers import AutoModelForImageTextToText, AutoTokenizer
+TM = ["q_proj","k_proj","v_proj","o_proj","up_proj","gate_proj","down_proj"]
+
+@torch.no_grad()
+def gen(model, tok, prefix, n=12):
+    enc = tok(prefix, return_tensors="pt")
+    out = model.generate(**enc, max_new_tokens=n, do_sample=False,
+                         pad_token_id=tok.pad_token_id or tok.eos_token_id)
+    return tok.decode(out[0][enc["input_ids"].shape[1]:], skip_special_tokens=True).split("\n")[0]
+
+def main():
+    ckpt = torch.load("runs/full_real_v4/head.best.pt", map_location="cpu")
+    tok = AutoTokenizer.from_pretrained("google/gemma-4-E2B")
+    if tok.pad_token is None: tok.pad_token = tok.eos_token
+    print("loading base model on CPU...", flush=True)
+    model = AutoModelForImageTextToText.from_pretrained("google/gemma-4-E2B",
+        torch_dtype=torch.float32, attn_implementation="eager", low_cpu_mem_usage=True)
+    model.eval()
+    for p in model.parameters(): p.requires_grad = False
+    specs = get_module_specs(model, TM, root_prefix=DEFAULT_ROOT_PREFIX)
+    replace_with_lora(model, specs, rank=ckpt["config"]["rank"], alpha=ckpt["args"].get("alpha",32.0))
+    head = MemoryLoRAHead(input_dim=ckpt["config"]["input_dim"],
+        type_dims={k:tuple(v) for k,v in ckpt["config"]["type_dims"].items()},
+        hidden_dim=ckpt["config"]["hidden_dim"], rank=ckpt["config"]["rank"])
+    head.load_state_dict(ckpt["state_dict"]); head.eval()
+
+    docs = load_doc_rows("data/embeddings/combined_embeddings.parquet")
+    qnas = load_qna_rows("data/qna/combined_qna.jsonl")
+    by_doc = {}
+    for q in qnas:
+        if q.split == "cr_test": by_doc.setdefault(q.doc_id, []).append(q)
+    doc_by_id = {d.doc_id: d for d in docs}
+
+    real = [d for d in by_doc if "@" in d and d in doc_by_id]      # real repos
+    synth = [d for d in by_doc if "@" not in d and d in doc_by_id] # synthetic
+    rng = random.Random(1)
+    picks = rng.sample(real, min(4,len(real))) + rng.sample(synth, min(2,len(synth)))
+    named = dict(model.named_modules())
+
+    for doc_id in picks:
+        d = doc_by_id[doc_id]
+        kind = "REAL REPO" if "@" in doc_id else "SYNTHETIC"
+        ctx = torch.from_numpy(d.doc_embedding).unsqueeze(0)
+        head_out = head(ctx)
+        pairs = by_doc[doc_id][:2]
+        print(f"\n========== [{kind}] {doc_id} ==========", flush=True)
+        for q in pairs:
+            for sp in specs: named[sp.full_name].A=None; named[sp.full_name].B=None
+            base = gen(model, tok, q.prefix)
+            inject_lora_weights(model, specs, head_out, batch_index=0)
+            adapt = gen(model, tok, q.prefix)
+            ok = adapt.strip().rstrip('.').lower().startswith(q.target.strip().rstrip('.').lower()) or \
+                 q.target.strip().lower().startswith(adapt.strip().lower())
+            print(f"  Q: {q.prefix.strip()[:90].replace(chr(10),' ')}", flush=True)
+            print(f"     gold={q.target.strip()!r}  base={base.strip()!r}  adapted={adapt.strip()!r}  {'OK' if ok else 'X'}", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/test_embed_this_repo.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Step A of the side recall-test: embed THIS repo (gemma4-hack) with the
+frozen encoder in a short-lived, low-memory process, save the 2048-d vector
+to disk, and exit -- so the big base-model process (Step B) never has the
+encoder resident at the same time. CPU-only to avoid competing with the
+live MPS training run."""
+from __future__ import annotations
+import sys, gc
+from pathlib import Path
+import numpy as np
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.encoder import load_encoder, embed_document
+from memory_lora.codegraph import extract_repo_graph_sections, extract_repo_dependency_summary
+
+def main():
+    skip = {".git","venv","__pycache__","data","runs",".mypy_cache","scratchpad"}
+    print("Extracting codegraph sections from this repo...", flush=True)
+    graph_sections = extract_repo_graph_sections(REPO_ROOT, max_files=60, skip_dirs=skip)
+    dep = extract_repo_dependency_summary(REPO_ROOT, skip_dirs=skip)
+    sections = list(graph_sections)
+    if dep:
+        sections.append(("dependency_graph", dep))
+    # also add a few raw key files for content signal
+    for rel in ["memory_lora/core.py", "memory_lora/encoder.py", "scripts/train_memory_lora.py",
+                 "memory_lora/codegraph.py", "requirements.txt"]:
+        p = REPO_ROOT / rel
+        if p.exists():
+            sections.append((f"raw:{rel}", p.read_text(errors="ignore")))
+    print(f"  {len(sections)} sections", flush=True)
+
+    print("Loading encoder on CPU...", flush=True)
+    model, tok = load_encoder(device="cpu")
+    vec = embed_document(sections, model, tok, "cpu", chunk_tokens=2048, chunk_overlap=256, batch_size=2)
+    del model, tok; gc.collect()
+    if vec is None:
+        print("FAILED: no embedding", flush=True); return
+    out = REPO_ROOT / "runs" / "this_repo_emb.npy"
+    np.save(out, vec.numpy().astype("float32"))
+    print(f"Saved repo embedding {tuple(vec.shape)} -> {out}", flush=True)
+
+if __name__ == "__main__":
+    main()

scripts/test_recall_this_repo.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Step B of the side recall-test. Loads base Gemma-4-E2B on CPU, generates
+a LoRA for THIS repo from its precomputed embedding (Step A) via the
+currently-training hypernetwork's latest checkpoint, and compares base vs
+adapted completions on prompts drawn from this repo's own code.
+
+CPU-only (never touches the live MPS training). Peak memory ~= just the
+base model (~10GB) since the encoder already ran and exited in Step A.
+
+Note on interpretation: the hypernetwork was trained on pytest
+ASSERTION-COMPLETION over real repos, and THIS repo is unseen (true
+cross-repo test). Prompts are shaped to probe whether the generated
+adapter biases the frozen model toward this repo's specific identifiers/
+values vs the base model's generic guess.
+"""
+from __future__ import annotations
+import sys
+from pathlib import Path
+import numpy as np, torch
+HERE = Path(__file__).resolve().parent; REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.core import (MemoryLoRAHead, get_module_specs, replace_with_lora,
+                               inject_lora_weights, DEFAULT_ROOT_PREFIX)
+from transformers import AutoModelForImageTextToText, AutoTokenizer
+
+TARGET_MODULES = ["q_proj","k_proj","v_proj","o_proj","up_proj","gate_proj","down_proj"]
+
+# Prompts drawn from THIS repo's actual code / conventions. Each is cut right
+# before a repo-specific value the adapter should help recall.
+PROMPTS = [
+    ("from memory_lora.core import MemoryLoRAHead\n"
+     "def test_default_rank():\n"
+     "    head = MemoryLoRAHead(input_dim=2048, type_dims={})\n"
+     "    assert head.rank ==", "16"),
+    ("# memory_lora/core.py sets the LoRA injection root for Gemma-4-E2B\n"
+     "DEFAULT_ROOT_PREFIX =", '"model.language_model."'),
+    ("# memory_lora/encoder.py default frozen embedding model\n"
+     "DEFAULT_EMBED_MODEL =", '"Qwen/Qwen3-Embedding-0.6B"'),
+    ("# scripts/train_memory_lora.py base model being adapted\n"
+     "DEFAULT_MODEL =", '"google/gemma-4-E2B"'),
+    ("from memory_lora.core import MemoryLoRAHead\n"
+     "def test_hidden_dim():\n"
+     "    h = MemoryLoRAHead(input_dim=2048, type_dims={})\n"
+     "    assert h.hidden_dim ==", "128"),
+    ("# the seven attention/MLP projection types Memory-LoRA targets\n"
+     "DEFAULT_TARGET_MODULES = [\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",", '"up_proj"'),
+]
+
+
+@torch.no_grad()
+def gen(model, tok, prefix, max_new=14):
+    enc = tok(prefix, return_tensors="pt")
+    out = model.generate(**enc, max_new_tokens=max_new, do_sample=False,
+                          pad_token_id=tok.pad_token_id or tok.eos_token_id)
+    return tok.decode(out[0][enc["input_ids"].shape[1]:], skip_special_tokens=True).split("\n")[0]
+
+
+def main():
+    print("Loading base google/gemma-4-E2B on CPU (bounded ~10GB)...", flush=True)
+    tok = AutoTokenizer.from_pretrained("google/gemma-4-E2B")
+    if tok.pad_token is None: tok.pad_token = tok.eos_token
+    model = AutoModelForImageTextToText.from_pretrained(
+        "google/gemma-4-E2B", torch_dtype=torch.float32, low_cpu_mem_usage=True)
+    model.eval()
+    for p in model.parameters(): p.requires_grad = False
+    print("  loaded.", flush=True)
+
+    ckpt = torch.load(REPO_ROOT / "runs" / "test_ckpt.pt", map_location="cpu")
+    specs = get_module_specs(model, TARGET_MODULES, root_prefix=DEFAULT_ROOT_PREFIX)
+    replace_with_lora(model, specs, rank=ckpt["config"]["rank"], alpha=ckpt["args"].get("alpha", 32.0))
+    head = MemoryLoRAHead(input_dim=ckpt["config"]["input_dim"],
+                          type_dims={k: tuple(v) for k, v in ckpt["config"]["type_dims"].items()},
+                          hidden_dim=ckpt["config"]["hidden_dim"], rank=ckpt["config"]["rank"])
+    head.load_state_dict(ckpt["state_dict"]); head.eval()
+
+    repo_emb = torch.from_numpy(np.load(REPO_ROOT / "runs" / "this_repo_emb.npy")).unsqueeze(0)
+    head_out = head(repo_emb)
+    print(f"  generated adapter for THIS repo (unseen). "
+          f"training step in checkpoint: {ckpt['args'].get('epochs','?')} epochs cfg\n", flush=True)
+
+    named = dict(model.named_modules())
+    for prefix, gold in PROMPTS:
+        # base: no adapter
+        for sp in specs:
+            named[sp.full_name].A = None; named[sp.full_name].B = None
+        base = gen(model, tok, prefix)
+        # adapted: inject this repo's generated LoRA
+        inject_lora_weights(model, specs, head_out, batch_index=0)
+        adapted = gen(model, tok, prefix)
+        tag = prefix.strip().split("\n")[-1][:55]
+        print(f"PROMPT: ...{tag}", flush=True)
+        print(f"  gold:    {gold}", flush=True)
+        print(f"  base:    {base!r}", flush=True)
+        print(f"  adapted: {adapted!r}", flush=True)
+        print(flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_direct_lora.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Train a standalone, directly-parameterized LoRA adapter on priority
+document(s) -- NOT hypernetwork-generated.
+
+Why this exists (see runs/full1, runs/full2, runs/full3_priority logs):
+a single hypernetwork trunk shared across 165+ documents cannot
+simultaneously (a) generalize broadly across the corpus and (b) reliably
+memorize any one document's specific facts -- three separate interventions
+(bigger head, oversampling) each improved (b) only by making (a) collapse
+faster, because they all perturb the SAME shared trunk weights.
+
+This script sidesteps the tension entirely for content we don't need
+zero-shot generalization on (documents we already have and specifically
+want memorized, e.g. the Code2LoRA paper): instead of a hypernetwork
+mapping embedding->weights, the LoRA A/B matrices are ordinary
+``nn.Parameter`` tensors trained directly via backprop on exactly the
+QA pairs for the selected doc_id(s) -- standard PEFT-style fine-tuning,
+with the same LoRA wrapper class (``memory_lora.core.LoRA``) and the same
+frozen Gemma-4-E2B target modules as the hypernetwork path, so results are
+directly comparable and the diagnostic single-doc runs (which proved this
+converges to correct multi-fact recall) apply unchanged.
+
+Usage:
+    python scripts/train_direct_lora.py --output-dir direct_paper \\
+        --doc-ids code2lora_paper --epochs 300
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoModelForImageTextToText, AutoTokenizer, get_cosine_schedule_with_warmup
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import QNA_DIR, RUNS_DIR, ensure_dirs  # noqa: E402
+from memory_lora.core import (  # noqa: E402
+    DEFAULT_ROOT_PREFIX,
+    discover_module_types_and_dims,
+    get_module_specs,
+    load_qna_rows,
+    replace_with_lora,
+)
+
+DEFAULT_MODEL = "google/gemma-4-E2B"
+DEFAULT_TARGET_MODULES = [
+    "q_proj", "k_proj", "v_proj", "o_proj",
+    "up_proj", "gate_proj", "down_proj",
+]
+
+
+def _tokenize_lm_batch(tokenizer, prefixes: List[str], targets: List[str],
+                        max_seq_len: int = 384) -> Dict[str, torch.Tensor]:
+    eos = tokenizer.eos_token or ""
+    input_ids_list, labels_list = [], []
+    for p, t in zip(prefixes, targets):
+        t_ids = tokenizer(t + eos, add_special_tokens=False)["input_ids"]
+        if not t_ids:
+            continue
+        prefix_budget = max(8, max_seq_len - len(t_ids))
+        p_ids_full = tokenizer(p, add_special_tokens=False)["input_ids"]
+        p_ids = p_ids_full[-prefix_budget:] if len(p_ids_full) > prefix_budget else p_ids_full
+        ids = p_ids + t_ids
+        labels = ([-100] * len(p_ids)) + list(t_ids)
+        input_ids_list.append(torch.tensor(ids, dtype=torch.long))
+        labels_list.append(torch.tensor(labels, dtype=torch.long))
+    if not input_ids_list:
+        return {}
+    L = max(t.size(0) for t in input_ids_list)
+    pad_id = tokenizer.pad_token_id or 0
+
+    def _lpad(x, val):
+        return F.pad(x, (L - x.size(0), 0), value=val)
+
+    input_ids = torch.stack([_lpad(t, pad_id) for t in input_ids_list], 0)
+    labels = torch.stack([_lpad(t, -100) for t in labels_list], 0)
+    attn_list = [torch.ones(t.size(0), dtype=torch.long) for t in input_ids_list]
+    attn = torch.stack([_lpad(t, 0) for t in attn_list], 0)
+    return {"input_ids": input_ids, "labels": labels, "attention_mask": attn}
+
+
+def init_direct_lora_params(model: nn.Module, specs, rank: int, device, dtype) -> Dict[str, Dict[str, nn.Parameter]]:
+    """Give each LoRA wrapper its OWN trainable (A, B), instead of an
+    externally-injected tensor from a hypernetwork. B initialized to zero
+    (standard LoRA init) so the adapter starts as a no-op."""
+    named = dict(model.named_modules())
+    params: Dict[str, Dict[str, nn.Parameter]] = {}
+    for sp in specs:
+        lora_mod = named[sp.full_name]
+        A = nn.Parameter(torch.randn(rank, sp.in_features, device=device, dtype=torch.float32) * 0.01)
+        B = nn.Parameter(torch.zeros(sp.out_features, rank, device=device, dtype=torch.float32))
+        lora_mod.set_lora_weights(A, B)
+        params[sp.full_name] = {"A": A, "B": B}
+    return params
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--qna-path", default=str(QNA_DIR / "qna.jsonl"))
+    ap.add_argument("--output-dir", required=True)
+    ap.add_argument("--model-name", default=DEFAULT_MODEL)
+    ap.add_argument("--target-modules", nargs="+", default=DEFAULT_TARGET_MODULES)
+    ap.add_argument("--root-prefix", default=DEFAULT_ROOT_PREFIX)
+    ap.add_argument("--doc-ids", nargs="+", default=[],
+                     help="Train a single direct LoRA jointly on the union "
+                          "of these documents' QnAs (use one doc_id for a "
+                          "dedicated per-document adapter).")
+    ap.add_argument("--doc-ids-file", default="",
+                     help="Alternative to --doc-ids: path to a file with "
+                          "whitespace-separated doc_ids. Avoids shell "
+                          "word-splitting pitfalls (e.g. zsh does not "
+                          "word-split unquoted $VAR by default) for large "
+                          "doc-id lists.")
+    ap.add_argument("--rank", type=int, default=32)
+    ap.add_argument("--alpha", type=float, default=64.0)
+    ap.add_argument("--epochs", type=int, default=300)
+    ap.add_argument("--lr", type=float, default=3e-4)
+    ap.add_argument("--weight-decay", type=float, default=0.0)
+    ap.add_argument("--warmup-ratio", type=float, default=0.05)
+    ap.add_argument("--max-grad-norm", type=float, default=1.0)
+    ap.add_argument("--max-seq-len", type=int, default=384)
+    ap.add_argument("--lm-micro-batch", type=int, default=4)
+    ap.add_argument("--eval-every-epochs", type=int, default=10)
+    ap.add_argument("--epoch-ckpt-every", type=int, default=25)
+    ap.add_argument("--seed", type=int, default=3407)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"])
+    ap.add_argument("--attn-implementation", default="sdpa", choices=["sdpa", "eager"])
+    ap.add_argument("--gradient-checkpointing", action="store_true", default=True)
+    ap.add_argument("--no-gradient-checkpointing", dest="gradient_checkpointing", action="store_false")
+    args = ap.parse_args()
+
+    out_dir = Path(args.output_dir)
+    if not out_dir.is_absolute():
+        out_dir = RUNS_DIR / out_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    ensure_dirs()
+
+    device = torch.device(args.device if (args.device != "mps" or torch.backends.mps.is_available()) else "cpu")
+    dtype = {"bfloat16": torch.bfloat16, "float16": torch.float16, "float32": torch.float32}[args.dtype]
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+
+    if args.doc_ids_file:
+        file_ids = Path(args.doc_ids_file).read_text().split()
+        doc_ids = set(args.doc_ids) | set(file_ids)
+    else:
+        doc_ids = set(args.doc_ids)
+    if not doc_ids:
+        raise SystemExit("No --doc-ids or --doc-ids-file provided.")
+    print(f"Training a direct (non-hypernetwork) LoRA jointly on: {sorted(doc_ids)}", flush=True)
+    all_qnas = load_qna_rows(Path(args.qna_path))
+    train_qnas = [q for q in all_qnas if q.doc_id in doc_ids and q.qna_split == "train"]
+    held_out_qnas = [q for q in all_qnas if q.doc_id in doc_ids and q.qna_split == "held_out"]
+    print(f"  {len(train_qnas)} train QAs, {len(held_out_qnas)} held-out QAs", flush=True)
+    if not train_qnas:
+        raise SystemExit("No train QnAs found for the given --doc-ids.")
+
+    print(f"Loading {args.model_name} ...", flush=True)
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    base_model = AutoModelForImageTextToText.from_pretrained(
+        args.model_name, torch_dtype=dtype, attn_implementation=args.attn_implementation,
+    ).to(device)
+    base_model.eval()
+    for p in base_model.parameters():
+        p.requires_grad = False
+    if args.gradient_checkpointing:
+        base_model.config.use_cache = False
+        base_model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
+        print("  gradient checkpointing: ON", flush=True)
+
+    specs = get_module_specs(base_model, args.target_modules, root_prefix=args.root_prefix)
+    type_dims = discover_module_types_and_dims(specs)
+    print(f"  discovered {len(specs)} target modules, {len(type_dims)} shape-types", flush=True)
+    replace_with_lora(base_model, specs, rank=args.rank, alpha=args.alpha)
+    lora_params = init_direct_lora_params(base_model, specs, args.rank, device, dtype)
+    all_params = [p for pair in lora_params.values() for p in pair.values()]
+    n_params = sum(p.numel() for p in all_params)
+    print(f"  direct LoRA trainable params: {n_params / 1e6:.2f}M "
+          f"(rank={args.rank}, {len(specs)} modules)", flush=True)
+
+    optim = torch.optim.AdamW(all_params, lr=args.lr, weight_decay=args.weight_decay)
+    total_steps = args.epochs
+    warmup_steps = max(1, int(total_steps * args.warmup_ratio))
+    sched = get_cosine_schedule_with_warmup(optim, warmup_steps, total_steps)
+
+    def _save(name: str) -> Path:
+        out = out_dir / f"lora.{name}.pt"
+        state = {full_name: {"A": pair["A"].detach().cpu(), "B": pair["B"].detach().cpu()}
+                  for full_name, pair in lora_params.items()}
+        torch.save({"lora": state, "rank": args.rank, "alpha": args.alpha,
+                     "doc_ids": sorted(doc_ids), "target_modules": args.target_modules,
+                     "root_prefix": args.root_prefix}, out)
+        return out
+
+    @torch.no_grad()
+    def _eval_held_out() -> float:
+        if not held_out_qnas:
+            return float("nan")
+        base_model.eval()
+        total_loss, total_tok = 0.0, 0
+        prefixes = [q.prefix for q in held_out_qnas]
+        targets = [q.target for q in held_out_qnas]
+        for i in range(0, len(prefixes), args.lm_micro_batch):
+            j = min(i + args.lm_micro_batch, len(prefixes))
+            batch = _tokenize_lm_batch(tokenizer, prefixes[i:j], targets[i:j], max_seq_len=args.max_seq_len)
+            if not batch:
+                continue
+            batch = {k: v.to(device) for k, v in batch.items()}
+            out = base_model(**batch)
+            ntok = (batch["labels"] != -100).sum().item()
+            total_loss += out.loss.item() * ntok
+            total_tok += ntok
+        return total_loss / max(total_tok, 1)
+
+    prefixes_all = [q.prefix for q in train_qnas]
+    targets_all = [q.target for q in train_qnas]
+    metrics_log: List[Dict[str, Any]] = []
+    t0 = time.time()
+    for epoch in range(args.epochs):
+        order = list(range(len(prefixes_all)))
+        random.shuffle(order)
+        prefixes = [prefixes_all[i] for i in order]
+        targets = [targets_all[i] for i in order]
+        loss_acc, n_tok_seen = 0.0, 0
+        for i in range(0, len(prefixes), args.lm_micro_batch):
+            j = min(i + args.lm_micro_batch, len(prefixes))
+            batch = _tokenize_lm_batch(tokenizer, prefixes[i:j], targets[i:j], max_seq_len=args.max_seq_len)
+            if not batch:
+                continue
+            batch = {k: v.to(device) for k, v in batch.items()}
+            out = base_model(**batch)
+            ntok = (batch["labels"] != -100).sum().item()
+            loss = out.loss * ntok
+            loss.backward()
+            loss_acc += loss.detach().item()
+            n_tok_seen += ntok
+        torch.nn.utils.clip_grad_norm_(all_params, args.max_grad_norm)
+        optim.step()
+        sched.step()
+        optim.zero_grad(set_to_none=True)
+
+        avg = loss_acc / max(n_tok_seen, 1)
+        elapsed = (time.time() - t0) / 60
+        if epoch % 10 == 0 or epoch == args.epochs - 1:
+            print(f"[ep{epoch}] train_loss={avg:.4f} lr={sched.get_last_lr()[0]:.2e} elapsed={elapsed:.1f}m", flush=True)
+
+        if epoch % max(1, args.eval_every_epochs) == 0 or epoch == args.epochs - 1:
+            held_out_loss = _eval_held_out()
+            print(f"  [eval] ep{epoch} held_out_loss={held_out_loss:.4f}", flush=True)
+            metrics_log.append({"epoch": epoch, "train_loss": avg, "held_out_loss": held_out_loss})
+            (out_dir / "metrics.jsonl").open("a").write(json.dumps(metrics_log[-1]) + "\n")
+
+        if epoch % max(1, args.epoch_ckpt_every) == 0 or epoch == args.epochs - 1:
+            p = _save(f"ep{epoch}")
+            print(f"  [ckpt] -> {p}", flush=True)
+        _save("latest")
+
+    print(f"\nDirect LoRA training done. Final train_loss={avg:.4f}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_memory_lora.py

@@ -0,0 +1,668 @@
+#!/usr/bin/env python3
+"""Train the Memory-LoRA hypernetwork on google/gemma-4-E2B.
+
+Forked from Code2LoRA's ``hypernetwork/train_code2lora_static_v2.py``
+(direct-projection trainer), retargeted:
+
+  * repo embedding  -> doc embedding   (memory_lora/encoder.py output)
+  * Qwen2.5-Coder    -> google/gemma-4-E2B (memory_lora/core.py target modules)
+  * cuda + flash_attn2 -> mps + sdpa (falls back to eager)
+  * no wandb/TRL      -> plain PyTorch loop + TensorBoard (SummaryWriter)
+
+Same core trick as the paper: only the hypernetwork head is trained; the
+base LLM is frozen (gradient-checkpointed for memory headroom); LoRA A/B
+tensors are non-detached so the causal-LM loss's backward graph flows
+straight into the head's parameters.
+
+Usage:
+    python scripts/train_memory_lora.py --output-dir runs/pilot1 \\
+        --limit-train-docs 5 --epochs 1        # smoke test
+
+    python scripts/train_memory_lora.py --output-dir runs/full1
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import psutil
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.tensorboard import SummaryWriter
+from transformers import (
+    AutoModelForImageTextToText,
+    AutoTokenizer,
+    get_cosine_schedule_with_warmup,
+)
+
+HERE = Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent
+sys.path.insert(0, str(REPO_ROOT))
+from memory_lora.data_paths import EMBEDDINGS_DIR, QNA_DIR, RUNS_DIR, ensure_dirs  # noqa: E402
+from memory_lora.core import (  # noqa: E402
+    MemoryLoRAHead,
+    DEFAULT_ROOT_PREFIX,
+    discover_module_types_and_dims,
+    get_module_specs,
+    inject_lora_weights,
+    load_doc_rows,
+    load_qna_rows,
+    replace_with_lora,
+)
+
+DEFAULT_MODEL = "google/gemma-4-E2B"
+DEFAULT_TARGET_MODULES = [
+    "q_proj", "k_proj", "v_proj", "o_proj",
+    "up_proj", "gate_proj", "down_proj",
+]
+
+
+# ---------------------------------------------------------------------------
+# Dataset & batching
+# ---------------------------------------------------------------------------
+
+class DocDataset:
+    """One example = one document with its train-split QnAs."""
+
+    def __init__(
+        self,
+        docs_by_id: Dict[str, Dict[str, Any]],
+        qnas_by_doc: Dict[str, List[Dict[str, str]]],
+        doc_ids: List[str],
+        max_qna_per_doc: int = 32,
+        seed: int = 3407,
+    ):
+        self.doc_ids = list(doc_ids)
+        self.docs = docs_by_id
+        self.qnas = qnas_by_doc
+        self.max_qna = max_qna_per_doc
+        self.rng = random.Random(seed)
+
+    def __len__(self) -> int:
+        return len(self.doc_ids)
+
+    def __getitem__(self, idx: int) -> Optional[Dict[str, Any]]:
+        d = self.doc_ids[idx]
+        pairs = list(self.qnas.get(d, []))
+        if not pairs:
+            return None
+        if len(pairs) > self.max_qna:
+            pairs = self.rng.sample(pairs, self.max_qna)
+        return {"doc_id": d, "embedding": self.docs[d]["emb"], "qnas": pairs}
+
+
+def _tokenize_lm_batch(tokenizer, prefixes: List[str], targets: List[str],
+                        max_seq_len: int = 2048,
+                        fixed_len: bool = False) -> Dict[str, torch.Tensor]:
+    """Causal-LM batch with the loss masked on prefix tokens. Keeps the
+    rightmost prefix tokens on overflow; targets are never truncated.
+
+    fixed_len: pad every batch to EXACTLY max_seq_len instead of the
+    batch's own local max length. Real code prefixes vary widely (100-1024+
+    tokens across different repos), so per-batch padding produces a new
+    tensor shape almost every document. On MPS this repeatedly triggered
+    unbounded memory growth (observed: a run that stayed under 13GB on
+    homogeneous-length synthetic docs hit 70+GB and got OS-killed within
+    ~10 documents of real, variable-length code) -- MPS's caching allocator
+    does not appear to reliably reclaim/reuse blocks across many distinct
+    shapes the way CUDA's does. Fixing every batch to one shape avoids the
+    allocator ever seeing a new size after the first batch. Slightly wastes
+    compute on padding for short sequences; that trade is worth it for
+    system stability.
+    """
+    eos = tokenizer.eos_token or ""
+    input_ids_list: List[torch.Tensor] = []
+    labels_list: List[torch.Tensor] = []
+    for p, t in zip(prefixes, targets):
+        t_ids = tokenizer(t + eos, add_special_tokens=False)["input_ids"]
+        if not t_ids:
+            continue
+        prefix_budget = max(8, max_seq_len - len(t_ids))
+        p_ids_full = tokenizer(p, add_special_tokens=False)["input_ids"]
+        p_ids = p_ids_full[-prefix_budget:] if len(p_ids_full) > prefix_budget else p_ids_full
+        ids = p_ids + t_ids
+        labels = ([-100] * len(p_ids)) + list(t_ids)
+        input_ids_list.append(torch.tensor(ids, dtype=torch.long))
+        labels_list.append(torch.tensor(labels, dtype=torch.long))
+    if not input_ids_list:
+        return {}
+    local_max = max(t.size(0) for t in input_ids_list)
+    L = max(max_seq_len, local_max) if fixed_len else local_max
+    pad_id = tokenizer.pad_token_id or 0
+
+    def _lpad(x, val):
+        return F.pad(x, (L - x.size(0), 0), value=val)
+
+    input_ids = torch.stack([_lpad(t, pad_id) for t in input_ids_list], 0)
+    labels = torch.stack([_lpad(t, -100) for t in labels_list], 0)
+    attn_list = [torch.ones(t.size(0), dtype=torch.long) for t in input_ids_list]
+    attn = torch.stack([_lpad(t, 0) for t in attn_list], 0)
+    return {"input_ids": input_ids, "labels": labels, "attention_mask": attn}
+
+
+# ---------------------------------------------------------------------------
+# Eval
+# ---------------------------------------------------------------------------
+
+@torch.no_grad()
+def evaluate_suite(
+    base_model: nn.Module, head: MemoryLoRAHead, specs, tokenizer,
+    doc_rows: List[Any], qnas_by_doc: Dict[str, List[Dict[str, str]]],
+    *, device: torch.device, max_seq_len: int = 512,
+    lm_micro_batch: int = 4, max_qna_per_doc: int = 32,
+    fixed_len: bool = False,
+) -> Dict[str, float]:
+    base_model.eval()
+    head.eval()
+    total_loss = 0.0
+    total_tokens = 0
+    n_docs = 0
+    for dr in doc_rows:
+        pairs = qnas_by_doc.get(dr.doc_id)
+        if not pairs:
+            continue
+        if len(pairs) > max_qna_per_doc:
+            pairs = pairs[:max_qna_per_doc]
+        ctx = torch.from_numpy(dr.doc_embedding).to(device).unsqueeze(0)
+        head_out = head(ctx)
+        inject_lora_weights(base_model, specs, head_out, batch_index=0)
+        prefixes = [p["prefix"] for p in pairs]
+        targets = [p["target"] for p in pairs]
+        for i in range(0, len(prefixes), lm_micro_batch):
+            j = min(i + lm_micro_batch, len(prefixes))
+            batch = _tokenize_lm_batch(tokenizer, prefixes[i:j], targets[i:j],
+                                        max_seq_len=max_seq_len, fixed_len=fixed_len)
+            if not batch:
+                continue
+            batch = {k: v.to(device) for k, v in batch.items()}
+            out = base_model(**batch)
+            loss = out.loss
+            ntok = (batch["labels"] != -100).sum().item()
+            total_loss += loss.item() * ntok
+            total_tokens += ntok
+        n_docs += 1
+    avg = total_loss / max(total_tokens, 1)
+    return {"eval_loss": avg, "n_docs": n_docs, "n_tokens": total_tokens}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def _docs_by_id(doc_rows) -> Dict[str, Dict[str, Any]]:
+    return {dr.doc_id: {"emb": dr.doc_embedding} for dr in doc_rows}
+
+
+def _group_qnas_by_doc(rows) -> Dict[str, List[Dict[str, str]]]:
+    out: Dict[str, List[Dict[str, str]]] = {}
+    for qr in rows:
+        out.setdefault(qr.doc_id, []).append({"prefix": qr.prefix, "target": qr.target})
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                  formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--embeddings-path", default=str(EMBEDDINGS_DIR / "doc_embeddings.parquet"))
+    ap.add_argument("--qna-path", default=str(QNA_DIR / "qna.jsonl"))
+    ap.add_argument("--output-dir", required=True)
+    ap.add_argument("--model-name", default=DEFAULT_MODEL)
+    ap.add_argument("--target-modules", nargs="+", default=DEFAULT_TARGET_MODULES)
+    ap.add_argument("--root-prefix", default=DEFAULT_ROOT_PREFIX)
+
+    ap.add_argument("--rank", type=int, default=16)
+    ap.add_argument("--alpha", type=float, default=32.0)
+    ap.add_argument("--head-hidden-dim", type=int, default=128,
+                     help="Kept small deliberately -- with ~165 training "
+                          "docs, the paper's 512-1024 hidden dim overfits "
+                          "within ~2 epochs (see memory_lora/core.py docstring).")
+    ap.add_argument("--head-dropout", type=float, default=0.1)
+
+    ap.add_argument("--epochs", type=int, default=3)
+    ap.add_argument("--lr", type=float, default=1e-4)
+    ap.add_argument("--weight-decay", type=float, default=0.05)
+    ap.add_argument("--warmup-ratio", type=float, default=0.03)
+    ap.add_argument("--lr-total-steps", type=int, default=0,
+                     help="Override the cosine LR schedule's total-step "
+                          "target with a realistic estimate of what "
+                          "--max-hours will actually cover, instead of "
+                          "steps_per_epoch * epochs (which assumes the run "
+                          "finishes a full epoch -- unrealistic at "
+                          "tens-of-thousands-of-docs scale). 0 = use the "
+                          "epoch-based calculation.")
+    ap.add_argument("--max-grad-norm", type=float, default=1.0)
+    ap.add_argument("--early-stop-patience", type=int, default=8,
+                     help="Stop after this many consecutive evals with no "
+                          "improvement on --primary-eval-suite. 0 = disabled.")
+
+    ap.add_argument("--max-qna-per-doc", type=int, default=32)
+    ap.add_argument("--lm-micro-batch", type=int, default=4)
+    ap.add_argument("--max-seq-len", type=int, default=512)
+    ap.add_argument("--fixed-seq-len", action="store_true", default=True,
+                     help="Pad every batch to exactly --max-seq-len instead "
+                          "of each batch's own local max length. See "
+                          "_tokenize_lm_batch docstring: on MPS, varying "
+                          "tensor shapes across many real-code documents "
+                          "of wildly different lengths caused unbounded "
+                          "memory growth (a run went from healthy to "
+                          "OS-killed within ~10 documents). Costs some "
+                          "wasted padding compute; worth it for stability.")
+    ap.add_argument("--no-fixed-seq-len", dest="fixed_seq_len", action="store_false")
+
+    ap.add_argument("--eval-every-steps", type=int, default=50)
+    ap.add_argument("--eval-suites", nargs="+", default=["cr_val", "cr_test", "ir_test"])
+    ap.add_argument("--limit-eval-docs", type=int, default=200,
+                     help="Cap docs per eval suite (random sample, fixed "
+                          "seed) for speed at real-corpus scale -- e.g. "
+                          "cr_val alone can be 8,600+ real repo-commit "
+                          "docs; evaluating all of them every eval cycle "
+                          "would dominate wall-clock time. 0 = no cap "
+                          "(matches the paper's own --limit-eval-snapshots).")
+    ap.add_argument("--primary-eval-suite", default="cr_val")
+    ap.add_argument("--log-every-iters", type=int, default=10)
+
+    ap.add_argument("--seed", type=int, default=3407)
+    ap.add_argument("--device", default="mps")
+    ap.add_argument("--dtype", default="bfloat16", choices=["bfloat16", "float16", "float32"])
+    ap.add_argument("--attn-implementation", default="sdpa", choices=["sdpa", "eager"])
+    ap.add_argument("--limit-train-docs", type=int, default=0)
+    ap.add_argument("--priority-doc-ids", nargs="+", default=[],
+                     help="doc_ids to oversample within the shared "
+                          "multi-document head (--priority-oversample "
+                          "extra passes per epoch), instead of raising "
+                          "global head capacity -- raising rank/hidden_dim "
+                          "fixes within-document fact interference but "
+                          "makes the whole corpus overfit faster (see "
+                          "runs/full2 diagnosis); oversampling gives "
+                          "specific documents more gradient signal without "
+                          "changing capacity or hurting the rest.")
+    ap.add_argument("--priority-oversample", type=int, default=5,
+                     help="How many times to repeat each --priority-doc-ids "
+                          "entry per epoch's shuffled training order.")
+    ap.add_argument("--only-doc-ids", nargs="+", default=[],
+                     help="Restrict training (and, if present in this set, "
+                          "ir_test eval) to exactly these doc_ids. Used for "
+                          "single-document capacity diagnostics -- e.g. can "
+                          "the architecture memorize ONE document's facts "
+                          "when not sharing hypernetwork capacity across "
+                          "165 others?")
+    ap.add_argument("--gradient-checkpointing", action="store_true", default=True)
+    ap.add_argument("--no-gradient-checkpointing", dest="gradient_checkpointing", action="store_false")
+    ap.add_argument("--max-hours", type=float, default=0.0,
+                     help="Wall-clock training budget in hours. 0 = unlimited "
+                          "(stop only after --epochs). Checked once per doc "
+                          "iteration; when exceeded, saves a final checkpoint "
+                          "and stops cleanly (does not just get killed mid-write).")
+    ap.add_argument("--min-available-gb", type=float, default=15.0,
+                     help="Hard safety floor: stop (with a final "
+                          "checkpoint) if SYSTEM-WIDE available memory "
+                          "(psutil.virtual_memory().available -- NOT this "
+                          "process's own RSS, which undercounts MPS "
+                          "memory on Apple Silicon) drops below this many "
+                          "GB. Checked every 2 iterations. 0 = disabled.")
+    ap.add_argument("--checkpoint-every-steps", type=int, default=50,
+                     help="Overwrite head.latest.pt every N optimizer steps "
+                          "so a crash/kill never loses more than N steps of "
+                          "progress. Overwrites (doesn't accumulate files), "
+                          "so it's disk-safe even for a 3GB head. 0=disabled.")
+    ap.add_argument("--checkpoint-every-minutes", type=float, default=30.0,
+                     help="Save a timestamped checkpoint every N minutes of "
+                          "wall-clock time, independent of eval/epoch "
+                          "boundaries. 0 = disabled (epoch-end saves only).")
+    ap.add_argument("--epoch-ckpt-every", type=int, default=10,
+                     help="Only write a NEW numbered head.epN.pt every N "
+                          "epochs (head.latest.pt still updates every "
+                          "epoch). Each checkpoint is a full head save "
+                          "(hundreds of MB) -- with many small/fast epochs "
+                          "(e.g. a tiny single-document run), saving one "
+                          "per epoch can fill the disk in minutes.")
+    ap.add_argument("--resume-from", default="",
+                     help="Path to a head.*.pt checkpoint to load weights "
+                          "from before training starts (optimizer/scheduler "
+                          "restart fresh; only head weights are resumed).")
+    args = ap.parse_args()
+
+    out_dir = Path(args.output_dir)
+    if not out_dir.is_absolute():
+        out_dir = RUNS_DIR / out_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    ensure_dirs()
+
+    device = torch.device(args.device if (args.device != "mps" or torch.backends.mps.is_available()) else "cpu")
+    dtype = {"bfloat16": torch.bfloat16, "float16": torch.float16, "float32": torch.float32}[args.dtype]
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed)
+
+    tb = SummaryWriter(log_dir=str(out_dir / "tb"))
+
+    # ---- Load embeddings + QnAs ----
+    print("Loading document embeddings ...", flush=True)
+    all_docs = load_doc_rows(Path(args.embeddings_path))
+    only_ids = set(args.only_doc_ids) if args.only_doc_ids else None
+    train_docs = [d for d in all_docs if d.split == "train"]
+    if only_ids:
+        train_docs = [d for d in train_docs if d.doc_id in only_ids]
+    if args.limit_train_docs:
+        train_docs = train_docs[: args.limit_train_docs]
+    print(f"  {len(train_docs)} train docs (of {len(all_docs)} total)", flush=True)
+
+    print("Loading QnAs ...", flush=True)
+    all_qnas = load_qna_rows(Path(args.qna_path))
+    if only_ids:
+        all_qnas = [q for q in all_qnas if q.doc_id in only_ids]
+    train_qnas = [q for q in all_qnas if q.qna_split == "train"]
+    qnas_train = _group_qnas_by_doc(train_qnas)
+    docs_by_id = _docs_by_id(train_docs)
+    doc_ids = [d for d in docs_by_id if d in qnas_train]
+    print(f"  {sum(len(v) for v in qnas_train.values())} train QA pairs across {len(doc_ids)} docs", flush=True)
+
+    if args.priority_doc_ids and args.priority_oversample > 1:
+        extra = []
+        for pid in args.priority_doc_ids:
+            if pid in doc_ids:
+                extra.extend([pid] * (args.priority_oversample - 1))
+            else:
+                print(f"  [warn] --priority-doc-ids {pid!r} not in training set, skipping", flush=True)
+        doc_ids = doc_ids + extra
+        print(f"  oversampled {args.priority_doc_ids} x{args.priority_oversample} "
+              f"-> {len(doc_ids)} entries/epoch", flush=True)
+
+    ds = DocDataset(docs_by_id, qnas_train, doc_ids,
+                     max_qna_per_doc=args.max_qna_per_doc, seed=args.seed)
+
+    # ---- Build LLM, discover modules, wrap them ----
+    print(f"Loading {args.model_name} ...", flush=True)
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    base_model = AutoModelForImageTextToText.from_pretrained(
+        args.model_name, torch_dtype=dtype,
+        attn_implementation=args.attn_implementation,
+    ).to(device)
+    base_model.eval()
+    for p in base_model.parameters():
+        p.requires_grad = False
+    if args.gradient_checkpointing:
+        base_model.config.use_cache = False
+        try:
+            base_model.gradient_checkpointing_enable(
+                gradient_checkpointing_kwargs={"use_reentrant": False})
+            print("  gradient checkpointing: ON", flush=True)
+        except Exception as e:  # noqa: BLE001
+            print(f"  [warn] gradient checkpointing unavailable: {e}", flush=True)
+
+    specs = get_module_specs(base_model, args.target_modules, root_prefix=args.root_prefix)
+    type_dims = discover_module_types_and_dims(specs)
+    print(f"  discovered {len(specs)} target modules, {len(type_dims)} types: {sorted(type_dims)}", flush=True)
+    if not specs:
+        raise SystemExit(
+            f"No modules matched root_prefix={args.root_prefix!r} + "
+            f"{args.target_modules}. Inspect base_model.named_modules() and "
+            f"pass --root-prefix explicitly."
+        )
+    replace_with_lora(base_model, specs, rank=args.rank, alpha=args.alpha)
+
+    head = MemoryLoRAHead(
+        input_dim=train_docs[0].doc_embedding.shape[0],
+        type_dims=type_dims,
+        hidden_dim=args.head_hidden_dim,
+        rank=args.rank,
+        dropout=args.head_dropout,
+    ).to(device)
+    if args.resume_from:
+        ckpt = torch.load(args.resume_from, map_location=device)
+        head.load_state_dict(ckpt["state_dict"])
+        print(f"  resumed head weights from {args.resume_from}", flush=True)
+    n_head_params = sum(p.numel() for p in head.parameters())
+    print(f"  head params: {n_head_params / 1e6:.1f}M", flush=True)
+
+    optim = torch.optim.AdamW(head.parameters(), lr=args.lr, weight_decay=args.weight_decay)
+    steps_per_epoch = max(1, len(ds))
+    if args.lr_total_steps:
+        # At real-corpus scale (tens of thousands of docs), --max-hours will
+        # cut training off long before steps_per_epoch * epochs is reached,
+        # so a schedule calibrated to full-epoch coverage would barely start
+        # annealing from its LR peak. Calibrate to the realistically
+        # achievable step count instead.
+        total_steps = args.lr_total_steps
+    else:
+        total_steps = steps_per_epoch * args.epochs
+    warmup_steps = max(1, int(total_steps * args.warmup_ratio))
+    sched = get_cosine_schedule_with_warmup(optim, warmup_steps, total_steps)
+
+    # ---- Eval suites ----
+    eval_suites: Dict[str, Dict[str, Any]] = {}
+    print("Loading eval suites ...", flush=True)
+    qnas_by_doc_all = _group_qnas_by_doc(all_qnas)
+    qnas_held_out_by_doc = _group_qnas_by_doc([q for q in all_qnas if q.qna_split == "held_out"])
+    eval_rng = random.Random(args.seed)
+    for suite in args.eval_suites:
+        if suite in ("cr_val", "cr_test"):
+            rows = [d for d in all_docs if d.split == suite]
+            q_by_doc = qnas_by_doc_all
+        elif suite == "ir_test":
+            rows = train_docs
+            q_by_doc = qnas_held_out_by_doc
+        else:
+            continue
+        if args.limit_eval_docs and len(rows) > args.limit_eval_docs:
+            rows = eval_rng.sample(rows, args.limit_eval_docs)
+        eval_suites[suite] = {"doc_rows": rows, "qnas_by_doc": q_by_doc}
+        n_q = sum(len(q_by_doc.get(d.doc_id, [])) for d in rows)
+        print(f"  {suite}: {len(rows)} docs, {n_q} qnas", flush=True)
+
+    # ---- Train ----
+    metrics_log: List[Dict[str, Any]] = []
+    best_eval = float("inf")
+    global_step = 0
+    t0 = time.time()
+    last_ckpt_wall = t0
+    budget_seconds = args.max_hours * 3600.0 if args.max_hours > 0 else float("inf")
+    ckpt_interval_seconds = args.checkpoint_every_minutes * 60.0 if args.checkpoint_every_minutes > 0 else float("inf")
+    stop_training = False
+    patience_counter = 0
+    for epoch in range(args.epochs):
+        if stop_training:
+            break
+        order = list(range(len(ds)))
+        random.shuffle(order)
+        head.train()
+        running_loss, running_n = 0.0, 0
+        for it, di in enumerate(order):
+            now = time.time()
+            if now - t0 >= budget_seconds:
+                print(f"  [budget] {args.max_hours:.2f}h training budget reached "
+                      f"(epoch {epoch}, it {it}/{len(order)}) -- stopping.", flush=True)
+                stop_training = True
+                break
+            if now - last_ckpt_wall >= ckpt_interval_seconds:
+                mins = int((now - t0) / 60)
+                p = _save_ckpt(out_dir, head, type_dims, args, name=f"t{mins:04d}m")
+                _save_ckpt(out_dir, head, type_dims, args, name="latest")
+                print(f"  [ckpt] periodic ({args.checkpoint_every_minutes:.0f}min interval) -> {p}", flush=True)
+                last_ckpt_wall = now
+            if args.min_available_gb > 0 and it % 2 == 0:
+                # IMPORTANT: this checks SYSTEM-WIDE available memory
+                # (psutil.virtual_memory), not this process's own RSS.
+                # psutil.Process().memory_info().rss -- like `ps -o rss` --
+                # does NOT reliably capture MPS/GPU-resident allocations
+                # on Apple Silicon: a run was observed at 55-83GB actual
+                # usage (per `top`'s MEM column, corroborated by system
+                # vm_stat showing genuine memory exhaustion) while RSS
+                # reported under 1GB the whole time. System-wide available
+                # memory is the metric that's actually reliable here.
+                available_gb = psutil.virtual_memory().available / 1e9
+                if available_gb < args.min_available_gb:
+                    print(f"  [safety] system available memory {available_gb:.1f}GB "
+                          f"below --min-available-gb {args.min_available_gb:.1f}GB "
+                          f"(epoch {epoch}, it {it}) -- saving and stopping to "
+                          f"protect system stability.", flush=True)
+                    _save_ckpt(out_dir, head, type_dims, args, name="latest")
+                    stop_training = True
+                    break
+            sample = ds[di]
+            if sample is None:
+                continue
+            ctx = torch.from_numpy(sample["embedding"]).to(device).unsqueeze(0)
+            qnas = sample["qnas"]
+            prefixes = [q["prefix"] for q in qnas]
+            targets = [q["target"] for q in qnas]
+            micro_batches = []
+            for i in range(0, len(prefixes), args.lm_micro_batch):
+                j = min(i + args.lm_micro_batch, len(prefixes))
+                b = _tokenize_lm_batch(tokenizer, prefixes[i:j], targets[i:j],
+                                        max_seq_len=args.max_seq_len, fixed_len=args.fixed_seq_len)
+                if b:
+                    micro_batches.append({k: v.to(device) for k, v in b.items()})
+            if not micro_batches:
+                continue
+            n_tok_seen, loss_acc = 0, 0.0
+            for mb_idx, batch in enumerate(micro_batches):
+                if args.min_available_gb > 0 and mb_idx % 3 == 0:
+                    # Same system-wide check as the per-document one below,
+                    # but INSIDE the micro-batch loop too: observed runaway
+                    # growth can blow past a safe threshold within a
+                    # single document's micro-batches, before the
+                    # per-document check would ever fire.
+                    available_gb = psutil.virtual_memory().available / 1e9
+                    if available_gb < args.min_available_gb:
+                        print(f"  [safety] system available memory {available_gb:.1f}GB "
+                              f"below --min-available-gb {args.min_available_gb:.1f}GB "
+                              f"mid-document (epoch {epoch}, it {it}, micro-batch "
+                              f"{mb_idx}) -- saving and stopping immediately.", flush=True)
+                        _save_ckpt(out_dir, head, type_dims, args, name="latest")
+                        stop_training = True
+                        break
+                head_out = head(ctx)
+                inject_lora_weights(base_model, specs, head_out, batch_index=0)
+                out = base_model(**batch)
+                ntok = (batch["labels"] != -100).sum().item()
+                loss = out.loss * ntok
+                loss.backward()
+                loss_acc += loss.detach().item()
+                n_tok_seen += ntok
+                del head_out, out, loss
+            if stop_training:
+                break
+            if n_tok_seen == 0:
+                continue
+            if device.type == "mps" and it % 5 == 0:
+                # MPS's caching allocator is markedly less aggressive about
+                # returning freed blocks to the OS than CUDA's -- on a
+                # unified-memory Mac (CPU and GPU share physical RAM,
+                # unlike a discrete-GPU box with isolated VRAM) that cache
+                # growth directly threatens the whole system, not just this
+                # process. Without this, a real-corpus run OOM'd the OS
+                # itself (83GB RSS, process state "stuck", heavy swapping)
+                # within the first ~10 minutes.
+                torch.mps.empty_cache()
+
+            torch.nn.utils.clip_grad_norm_(head.parameters(), args.max_grad_norm)
+            optim.step()
+            sched.step()
+            optim.zero_grad(set_to_none=True)
+            global_step += 1
+
+            if args.checkpoint_every_steps > 0 and global_step % args.checkpoint_every_steps == 0:
+                _save_ckpt(out_dir, head, type_dims, args, name="latest")
+
+            running_loss += loss_acc
+            running_n += n_tok_seen
+            if it % max(1, args.log_every_iters) == 0:
+                avg = running_loss / max(running_n, 1)
+                elapsed = (time.time() - t0) / 60
+                print(f"[ep{epoch} it{it}/{len(order)} step{global_step}] "
+                      f"loss={avg:.4f} lr={sched.get_last_lr()[0]:.2e} elapsed={elapsed:.1f}m", flush=True)
+                tb.add_scalar("train/loss", avg, global_step)
+                tb.add_scalar("train/lr", sched.get_last_lr()[0], global_step)
+                running_loss, running_n = 0.0, 0
+
+            if (args.eval_every_steps > 0 and global_step > 0
+                    and global_step % args.eval_every_steps == 0
+                    and it + 1 != len(order)):
+                # The `it + 1 != len(order)` guard skips a redundant eval when
+                # eval_every_steps happens to equal (a multiple of) steps-per-
+                # epoch -- the unconditional end-of-epoch eval below would
+                # otherwise double-count this exact step in the early-stop
+                # patience counter every epoch.
+                prev_best = best_eval
+                best_eval = _do_eval(args, base_model, head, specs, tokenizer, eval_suites,
+                                      device, out_dir, metrics_log, best_eval, global_step, epoch, tb)
+                patience_counter = 0 if best_eval < prev_best else patience_counter + 1
+                if args.early_stop_patience > 0 and patience_counter >= args.early_stop_patience:
+                    print(f"  [early-stop] no improvement on {args.primary_eval_suite} for "
+                          f"{patience_counter} evals -- stopping.", flush=True)
+                    stop_training = True
+                    break
+
+        _save_ckpt(out_dir, head, type_dims, args, name="latest")
+        if epoch % max(1, args.epoch_ckpt_every) == 0:
+            ep_path = _save_ckpt(out_dir, head, type_dims, args, name=f"ep{epoch}")
+            print(f"  [ckpt] end-of-epoch ep{epoch} -> {ep_path}", flush=True)
+        else:
+            print(f"  [ckpt] end-of-epoch ep{epoch} -> (latest.pt only)", flush=True)
+        prev_best = best_eval
+        best_eval = _do_eval(args, base_model, head, specs, tokenizer, eval_suites,
+                              device, out_dir, metrics_log, best_eval, global_step, epoch, tb,
+                              end_of_epoch=True)
+        patience_counter = 0 if best_eval < prev_best else patience_counter + 1
+        if args.early_stop_patience > 0 and patience_counter >= args.early_stop_patience:
+            print(f"  [early-stop] no improvement on {args.primary_eval_suite} for "
+                  f"{patience_counter} evals -- stopping.", flush=True)
+            stop_training = True
+
+    tb.close()
+    print(f"\nTraining done. Best primary eval = {best_eval:.4f}", flush=True)
+
+
+def _save_ckpt(out_dir: Path, head: MemoryLoRAHead, type_dims, args, name: str = "latest") -> Path:
+    out = out_dir / f"head.{name}.pt"
+    torch.save({
+        "state_dict": head.state_dict(),
+        "config": head.config_dict(),
+        "type_dims": type_dims,
+        "args": vars(args),
+    }, out)
+    return out
+
+
+def _do_eval(args, base_model, head, specs, tokenizer, eval_suites, device, out_dir,
+             metrics_log, best_eval, global_step, epoch, tb, end_of_epoch: bool = False) -> float:
+    suite_metrics: Dict[str, Dict[str, float]] = {}
+    for name, suite in eval_suites.items():
+        m = evaluate_suite(base_model, head, specs, tokenizer,
+                            suite["doc_rows"], suite["qnas_by_doc"],
+                            device=device, max_seq_len=args.max_seq_len,
+                            lm_micro_batch=args.lm_micro_batch,
+                            max_qna_per_doc=args.max_qna_per_doc,
+                            fixed_len=args.fixed_seq_len)
+        suite_metrics[name] = m
+        print(f"  [eval {name}] step={global_step} loss={m['eval_loss']:.4f} "
+              f"docs={m['n_docs']} tok={m['n_tokens']}", flush=True)
+        tb.add_scalar(f"eval/{name}_loss", m["eval_loss"], global_step)
+    primary = suite_metrics.get(args.primary_eval_suite)
+    primary_loss = primary["eval_loss"] if primary else float("inf")
+    row = {"step": global_step, "epoch": epoch, "end_of_epoch": end_of_epoch,
+           "eval_loss": primary_loss, "suites": suite_metrics}
+    metrics_log.append(row)
+    (out_dir / "metrics.jsonl").open("a").write(json.dumps(row) + "\n")
+    if primary_loss < best_eval:
+        best_eval = primary_loss
+        p = _save_ckpt(out_dir, head, head.type_dims, args, name="best")
+        print(f"  [ckpt] best updated -> {p} (loss={primary_loss:.4f})", flush=True)
+    _save_ckpt(out_dir, head, head.type_dims, args, name="latest")
+    head.train()
+    return best_eval
+
+
+if __name__ == "__main__":
+    main()