+
+ )}
+
+
+
+
+
+
+
+ + 👁️ REVIEW MODE +
++ You are viewing a preview of this audit. This content is under review and not yet published. +
+ {prNumber && ( ++ Preview from PR #{prNumber} +
+ )} +
{children}
diff --git a/content/course/assignments/capstone.mdx b/content/course/assignments/capstone.mdx
index 43b7f82c..4adf8be1 100644
--- a/content/course/assignments/capstone.mdx
+++ b/content/course/assignments/capstone.mdx
@@ -5,10 +5,6 @@ due: 'Week 16'
points: 300
---
-
-
# Capstone Project: Textbook Contribution & Implementation
diff --git a/content/course/assignments/scratch-1.mdx b/content/course/assignments/scratch-1.mdx
index 2b1f2bce..cdb5636d 100644
--- a/content/course/assignments/scratch-1.mdx
+++ b/content/course/assignments/scratch-1.mdx
@@ -5,11 +5,6 @@ due: 'Sunday, February 1, 9:00 AM MST'
points: 100
---
-⚠️ DRAFT: NOT YET ASSIGNED
-This assignment is still under review and subject to change. Do not begin work until this notice is removed.
-
-
-
# Scratch-1: The Transformer Backbone
**Focus**: Implementing the $O(1)$ engine of the VLA stack.
@@ -187,7 +182,9 @@ When I removed the causal mask, the following happened:
### Pass Level (B): 70-89 points
- ✅ Successful implementation of the backbone
-- ✅ Loss converges on the synthetic dataset (< 1.0)
+- ✅ Loss shows clear convergence (appreciable decrease from initial loss)
+ - Expected: Initial loss ~3-4, Final loss ~1.9-2.2
+ - Model should demonstrate learning, not achieve arbitrary threshold
- ✅ Attention maps visualization included
- ✅ Causal mask audit completed
- ✅ Code is clean and documented
@@ -307,6 +304,13 @@ A: Check:
2. Is the learning rate too high? (Try 1e-4)
3. Are gradients exploding? (Enable gradient clipping)
+**Q: What loss should I expect?**
+A: With correct implementation on the synthetic trajectory dataset:
+- **Initial loss**: ~3-4 (near random guessing for 256-way classification)
+- **Final loss**: ~1.9-2.2 (showing clear learning)
+- **Key metric**: Appreciable decrease indicating the model learns patterns
+- The action encoding represents direction + magnitude toward target, which is learnable but not trivial
+
## 11. Deadline
**Due**: Sunday, February 1, 9:00 AM MST
diff --git a/content/course/submissions/scratch-1/images_tr/attn_map.png b/content/course/submissions/scratch-1/images_tr/attn_map.png
new file mode 100644
index 00000000..22448e4f
Binary files /dev/null and b/content/course/submissions/scratch-1/images_tr/attn_map.png differ
diff --git a/content/course/submissions/scratch-1/images_tr/attn_map_wo_mask.png b/content/course/submissions/scratch-1/images_tr/attn_map_wo_mask.png
new file mode 100644
index 00000000..5ed453ab
Binary files /dev/null and b/content/course/submissions/scratch-1/images_tr/attn_map_wo_mask.png differ
diff --git a/content/course/submissions/scratch-1/images_tr/loss_curve-sin.png b/content/course/submissions/scratch-1/images_tr/loss_curve-sin.png
new file mode 100644
index 00000000..3ed24f2b
Binary files /dev/null and b/content/course/submissions/scratch-1/images_tr/loss_curve-sin.png differ
diff --git a/content/course/submissions/scratch-1/images_tr/loss_curve.png b/content/course/submissions/scratch-1/images_tr/loss_curve.png
new file mode 100644
index 00000000..f9be9cb3
Binary files /dev/null and b/content/course/submissions/scratch-1/images_tr/loss_curve.png differ
diff --git a/content/course/submissions/scratch-1/images_tr/loss_curve_without_mask.png b/content/course/submissions/scratch-1/images_tr/loss_curve_without_mask.png
new file mode 100644
index 00000000..11b38974
Binary files /dev/null and b/content/course/submissions/scratch-1/images_tr/loss_curve_without_mask.png differ
diff --git a/content/course/submissions/scratch-1/thanushraam.mdx b/content/course/submissions/scratch-1/thanushraam.mdx
new file mode 100644
index 00000000..affdda95
--- /dev/null
+++ b/content/course/submissions/scratch-1/thanushraam.mdx
@@ -0,0 +1,296 @@
+---
+title: "Scratch-1 Submission: Thanushraam Suresh Kumar"
+
+student: "Thanushraam Suresh Kumar"
+
+date: "2026-02-01"
+---
+
+# Scratch-1: The Transformer Backbone
+
+## Loss Curve
+
+
+
+The model converged after 2820 iterations or 10 epochs with final training loss of 1.9652 and validation loss of 1.9769.
+
+## Attention Visualization
+
+
+
+The attention map visualization shows clear lower-triangular structure which means that causal mask I applied was successful.
+Unlike the unmasked case where attention patterns appear scattered and tokens can attend to future positions, the masked model
+restricts each token to attending only to itself and previous tokens. A strong diagonal band shows that tokens place high weight
+on themselves and very recent context, while attention weights gradually decrease as distance from the diagonal increases.
+This fading pattern reflects a recency bias, which is expected in sequential modeling tasks.
+
+## The Audit: Removing the Causal Mask
+
+When comparing training behavior with and without the causal mask, the difference in loss dynamics is huge. Without the mask,
+the training loss drops from an initial value of approximately 5.5 all the way down to ~0.05. This extremely low final loss
+indicates that the model is effectively seeing the ground-truth future tokens during training, allowing it to trivially copy
+the next token rather than predict it. Without the mask, attention is unrestricted, meaning token t can directly attend to
+tokens t+1, t+2, and beyond. Since the training objective is next-token prediction, the model can simply read the ground-truth
+answer from the future position and copy it. This creates information leakage, turning the task into trivial reconstruction
+rather than autoregressive modeling.
+
+
+
+
+
+The attention visualization confirms this behavior. Instead of a lower-triangular structure, attention spreads across future
+positions, showing that tokens strongly attend to positions to their right.
+
+### Why the Model "Cheats"
+Autoregressive models rely on the principle that each token must be predicted using only past context.
+The causal mask enforces this by restricting attention to previous positions. Removing it breaks this constraint,
+allowing the model to access the exact token it is supposed to predict. The resulting low loss therefore reflects
+shortcut learning, not genuine sequence understanding.
+
+## Extras
+### KV Cache Inference
+To evaluate the impact of KV caching I ran inference on two different input and compared the inference times.
+First, for a prompt length of 50 and 500 generated tokens, the no-cache configuration
+averaged 2139.95 ms (ran 5 times), while with KV cache it averaged 1612.92 ms, yielding a 1.33× speedup.
+For a longer rollout with prompt length 200 and 1000 generated tokens, the no-cache version averaged 4206.06 ms compared to
+3234.18 ms with KV cache, corresponding to a 1.30× speedup. In both cases, KV cache consistently reduced inference time,
+and the absolute time savings increased with longer sequences (about 0.53 seconds saved in the shorter setting versus
+nearly 1 second saved in the longer one), this demonstrates that caching becomes increasingly beneficial as generation length grows.
+
+### Sinusoidal vs ROPE
+I tried to implement Sinusoidal and compare it with RoPE in terms of training and validation loss along with their inference time for
+two different context length.
+At short context length (prompt = 50), sinusoidal positional encoding showed slightly lower inference time (1769.65 ms)
+compared to RoPE (2078.67 ms). However, RoPE achieved better modeling performance, reaching a lower validation loss (1.9678)
+than sinusoidal encoding (2.0447) and converging faster during training.
+The sinusoidal loss curve shows slower convergence and consistently higher loss than RoPE
+
+
+At longer context length (prompt = 200), RoPE outperformed sinusoidal encoding in both modeling quality and efficiency.
+RoPE reached a validation loss of 1.9651, compared to 2.0348 for sinusoidal encoding. In inference without caching, RoPE
+required 2089.14 ms, while sinusoidal encoding took 2782.25 ms (≈ 1.33× slower).
+
+## Code Highlights
+
+### Efficient QKV Projection and Multi-Head Reshaping
+
+Instead of separate layers for Q, K, and V, a single projection is used and then split:
+
+```
+qkv = self.qkv_proj(x) # (B, T, 3D)
+q, k, v = qkv.chunk(3, dim=-1)
+
+q = q.reshape(B, T, H, Hd).transpose(1, 2) # (B, H, T, Hd)
+k = k.reshape(B, T, H, Hd).transpose(1, 2)
+v = v.reshape(B, T, H, Hd).transpose(1, 2)
+```
+---
+
+### Rotary Positional Embeddings (RoPE)
+
+Positional information is injected by **rotating Q and K**, rather than adding absolute position vectors:
+
+```
+cos = self.cos_cached[position_offset:position_offset+seq_len]
+sin = self.sin_cached[position_offset:position_offset+seq_len]
+
+cos = cos[None, None, :, :]
+sin = sin[None, None, :, :]
+
+q_rot = (q * cos) + (self.rotate_half(q) * sin)
+k_rot = (k * cos) + (self.rotate_half(k) * sin)
+```
+
+This embeds **relative positional structure directly in attention**.
+
+---
+
+### Causal Masking
+
+A lower-triangular mask is applied before softmax:
+
+```
+causal = torch.tril(torch.ones(seq_len, seq_len, device=x.device, dtype=torch.bool))
+scores = scores.masked_fill(~causal, float("-inf"))
+```
+---
+
+### Scaled Dot-Product Attention
+
+The attention core follows the standard Transformer pipeline:
+
+```
+scores = (q @ k.transpose(-2, -1)) * self.scale
+attn = F.softmax(scores, dim=-1)
+attn = self.attn_dropout(attn)
+
+out = attn @ v
+out = out.transpose(1, 2).contiguous().view(B, T, D)
+out = self.out_proj(out)
+```
+
+---
+
+### Attention Map
+
+For visualization the attention map:
+
+```
+if not self.training:
+ self.last_attn = attn.detach().cpu()
+```
+
+---
+
+### KV Cache Implementation
+
+Instead of recomputing attention over the entire prefix at every step, previously computed keys and values are stored and reused.
+
+#### Cache Allocation
+
+```
+if past_kv is None:
+ max_len = self.max_seq_len
+ k_cache = torch.empty(B, H, max_len, Hd, device=x.device)
+ v_cache = torch.empty_like(k_cache)
+ pos = 0
+else:
+ k_cache, v_cache, pos = past_kv
+```
+
+#### Writing New Tokens into Cache
+
+```
+k_cache[:, :, pos:pos+seq_len, :] = k
+v_cache[:, :, pos:pos+seq_len, :] = v
+```
+
+Only the new token projections are computed.
+
+
+#### Using Cached Prefix
+
+```
+k = k_cache[:, :, :pos+seq_len, :]
+v = v_cache[:, :, :pos+seq_len, :]
+scores = (q @ k.transpose(-2, -1)) * self.scale
+```
+
+Attention now runs against **all previous tokens** without recomputing their projections.
+
+
+
+#### Updated Cache Returned
+
+```
+present_kv = (k_cache, v_cache, pos + seq_len)
+return out, present_kv
+```
+---
+### Sinusoidal Positional Encoding Implementation
+
+
+In my sinusoidal positional encoding implementation, positional information is added **directly to token embeddings** before
+the transformer blocks:
+
+```python
+x = self.token_embedding(input_ids)
+x = x + self.pos_emb[:x.size(1), :].unsqueeze(0)
+```
+
+The positional embedding matrix is precomputed once:
+
+```python
+self.pe = self.build_sinusoidal_pos_emb(max_seq_len, dim, device="cuda")
+self.register_buffer("pos_emb", self.pe, persistent=False)
+```
+
+**Important Behavior During Generation**
+
+During generation, I use a **cropped context window**:
+
+```python
+input_context = input_ids if input_ids.size(1) <= self.max_seq_len else input_ids[:, -self.max_seq_len:]
+```
+
+Because of this, the positional encoding applied at each forward pass is:
+
+```python
+self.pos_emb[:context_length]
+```
+
+This means that **position indices restart from 0** whenever the context window is cropped.
+So tokens at later stages of generation are assigned positions relative to the window rather than their absolute position in the full sequence.
+
+
+## Challenges and Solutions
+
+1. Dataset understanding: Initially, the structure of the dataset was confusing,
+ particularly how states, actions, and targets aligned for next-token prediction.
+ By printing tensor shapes and inspecting sample sequences, I verified the sequence
+ dimensions and confirmed the correct autoregressive setup (predicting action t+1 from action t).
+
+2. KV cache performance: My first KV cache implementation was unexpectedly slower than the
+ no-cache baseline. This was due to inefficiencies such as suboptimal mask computation and
+ non-optimal buffer usage. After improving the masking logic and using pre-allocated key/value
+ buffers correctly, KV caching produced consistent inference speedups, especially for longer
+ sequences.
+
+3. Attention visualization: At first, I wasn’t sure how to visualize the attention maps.
+ After referring to a few online resources, I learned how to extract and detach the attention
+ weights from the model. By storing the detached attention matrix during a forward pass,
+ I was able to visualize the attention patterns for a single input sequence. [reference blog](!https://alessiodevoto.github.io/vit-attention/)
+
+## References
+1. https://huggingface.co/blog/not-lain/kv-caching
+2. https://www.kaggle.com/code/aisuko/causal-self-attention
+3. https://alessiodevoto.github.io/vit-attention/
+4. https://medium.com/ai-insights-cobet/rotary-positional-embeddings-a-detailed-look-and-comprehensive-understanding-4ff66a874d83
+5. https://medium.com/@lepicardhugo/how-transformers-encode-position-pe-rope-made-simple-024d5e03fa03
+6. https://www.youtube.com/watch?v=GQPOtyITy54
+
+## Sample Output
+```
+Using device: cuda
+dataset keys dict_keys(['states', 'actions'])
+Epoch 0 | Batch 100/282 | Loss 3.4397 | perplexity 31.1783
+Epoch 0 | Batch 200/282 | Loss 2.5887 | perplexity 13.3130
+Epoch 1/10 - Loss: 3.2790
+Epoch 1: train 3.2790 | val 2.3331 | val_perplexity 10.3101
+Epoch 1 | Batch 100/282 | Loss 2.2714 | perplexity 9.6934
+Epoch 1 | Batch 200/282 | Loss 2.1437 | perplexity 8.5313
+Epoch 2/10 - Loss: 2.2153
+Epoch 2: train 2.2153 | val 2.0984 | val_perplexity 8.1527
+Epoch 2 | Batch 100/282 | Loss 2.0614 | perplexity 7.8570
+Epoch 2 | Batch 200/282 | Loss 2.0887 | perplexity 8.0743
+Epoch 3/10 - Loss: 2.0842
+Epoch 3: train 2.0842 | val 2.0381 | val_perplexity 7.6761
+Epoch 3 | Batch 100/282 | Loss 1.9957 | perplexity 7.3575
+Epoch 3 | Batch 200/282 | Loss 2.0274 | perplexity 7.5945
+Epoch 4/10 - Loss: 2.0412
+Epoch 4: train 2.0412 | val 2.0139 | val_perplexity 7.4923
+Epoch 4 | Batch 100/282 | Loss 2.0546 | perplexity 7.8034
+Epoch 4 | Batch 200/282 | Loss 2.0366 | perplexity 7.6647
+Epoch 5/10 - Loss: 2.0176
+Epoch 5: train 2.0176 | val 1.9938 | val_perplexity 7.3435
+Epoch 5 | Batch 100/282 | Loss 1.9758 | perplexity 7.2124
+Epoch 5 | Batch 200/282 | Loss 1.9989 | perplexity 7.3807
+Epoch 6/10 - Loss: 2.0011
+Epoch 6: train 2.0011 | val 1.9882 | val_perplexity 7.3026
+Epoch 6 | Batch 100/282 | Loss 2.0455 | perplexity 7.7333
+Epoch 6 | Batch 200/282 | Loss 1.9885 | perplexity 7.3045
+Epoch 7/10 - Loss: 1.9901
+Epoch 7: train 1.9901 | val 1.9798 | val_perplexity 7.2412
+Epoch 7 | Batch 100/282 | Loss 1.9672 | perplexity 7.1505
+Epoch 7 | Batch 200/282 | Loss 1.9944 | perplexity 7.3476
+Epoch 8/10 - Loss: 1.9802
+Epoch 8: train 1.9802 | val 1.9738 | val_perplexity 7.1983
+Epoch 8 | Batch 100/282 | Loss 1.9764 | perplexity 7.2166
+Epoch 8 | Batch 200/282 | Loss 1.9743 | perplexity 7.2013
+Epoch 9/10 - Loss: 1.9722
+Epoch 9: train 1.9722 | val 1.9699 | val_perplexity 7.1700
+Epoch 9 | Batch 100/282 | Loss 1.9751 | perplexity 7.2074
+Epoch 9 | Batch 200/282 | Loss 1.9751 | perplexity 7.2074
+Epoch 10/10 - Loss: 1.9662
+Epoch 10: train 1.9662 | val 1.9661 | val_perplexity 7.1426
+```
\ No newline at end of file
diff --git a/data/trajectories.pkl b/data/trajectories.pkl
new file mode 100644
index 00000000..d5b55493
Binary files /dev/null and b/data/trajectories.pkl differ
diff --git a/grading_reports/GRADING_REPORT.md b/grading_reports/GRADING_REPORT.md
new file mode 100644
index 00000000..242abb8b
--- /dev/null
+++ b/grading_reports/GRADING_REPORT.md
@@ -0,0 +1,66 @@
+
+### 🤖 Chris's Grading Assistant - Feedback Report
+
+**Student:** @Tr0612
+**PR:** #35
+**Branch:** `scratch-1-thanushraam`
+
+Hi! I've reviewed your submission. Here's what I found:
+
+---
+
+## 📊 Component Feedback
+
+### ✅ Causal Self-Attention
+
+✅ Perfect! Your causal mask correctly prevents future token leakage.
+
+✅ Test passed.
+
+### ✅ RMSNorm
+
+✅ RMSNorm implemented correctly with proper normalization and learnable scale.
+
+✅ Test passed.
+
+### ✅ Training Loop
+
+✅ Excellent! Your model trains successfully and loss converges.
+
+### ✅ RoPE Embeddings
+
+✅ RoPE correctly applied to Q and K tensors.
+
+### ✅ Model Architecture
+
+✅ Model forward pass works end-to-end with correct output shapes.
+
+✅ Model has the expected number of trainable parameters.
+
+### ✅ Code Quality
+
+Your code imports and runs cleanly. Nice! ✨
+
+---
+
+## 📝 Documentation & Analysis
+
+✅ Report submitted! I found:
+- `content/course/submissions/scratch-1/thanushraam.mdx`
+- `README.md`
+
+Your instructor will review the quality of your analysis.
+
+---
+
+## 🎯 Mastery Features Detected
+
+I noticed you implemented:
+- KV-Caching implementation
+- RoPE vs Sinusoidal ablation study
+
+Great work going beyond the requirements! Your instructor will verify implementation quality.
+
+---
+
+> *Grading is automated but reviewed by an instructor. If you have questions, reach out on Slack!*
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..e4141170
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,42 @@
+[project]
+name = "vla-foundations"
+version = "0.1.0"
+description = "VLA Foundations Course - Private Instructor Repository"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+dependencies = [
+ "torch>=2.0.0",
+ "torchvision",
+ "numpy>=1.24.0",
+ "pytest>=7.0.0",
+ "pytest-html>=4.0.0",
+]
+
+[[tool.uv.index]]
+name = "pytorch-cu118"
+url = "https://download.pytorch.org/whl/cu118"
+explicit = true
+
+[tool.uv.sources]
+torch = [{ index = "pytorch-cu118" }]
+torchvision = [{ index = "pytorch-cu118" }]
+
+[tool.hatch.build.targets.wheel]
+packages = []
+
+[tool.pytest.ini_options]
+markers = [
+ "internal: internal grading tests (never public)",
+ "rigor: rigorous grading tests",
+ "gradient: gradient flow tests",
+ "fidelity: output comparison tests",
+ "training: training convergence tests",
+ "mastery: optional mastery-level features (DINOv2, KV-cache, etc.)",
+]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+
+[dependency-groups]
+dev = []
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 00000000..ea7a96da
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,13 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+markers =
+ public: Tests that students can see and run
+ internal: Internal grading tests (never public)
+ rigor: Rigorous validation tests for grading
+ gradient: Tests for gradient flow validation
+ fidelity: Tests for output quality validation
+ training: Tests for training convergence
+ mastery: Optional mastery-level features (DINOv2, KV-cache, etc.)
diff --git a/scripts/README.md b/scripts/README.md
new file mode 100644
index 00000000..0e328843
--- /dev/null
+++ b/scripts/README.md
@@ -0,0 +1,49 @@
+# CI/CD Scripts
+
+**Critical infrastructure scripts** used in GitHub Actions workflows.
+
+## Contents
+
+### Production Scripts
+
+- **`manage_solutions.py`** - Inject/reset assignment solutions (used in testing)
+- **`sanitize.sh`** - Main sanitization pipeline for public sync
+- **`_sanitize_todos.py`** - Remove solution hints from code
+- **`audit_linter.py`** - Validate paper audit MDX files
+
+### Usage in CI/CD
+
+| Script | Workflow | Purpose |
+|--------|----------|---------|
+| `audit_linter.py` | `vla-audit.yml` | Validate audit frontmatter |
+| `sanitize.sh` | `sync-to-public.yml` | Remove private content |
+| `_sanitize_todos.py` | `sync-to-public.yml` | Strip solution hints |
+| `manage_solutions.py` | (local testing) | Inject/reset solutions |
+
+### Critical Requirements
+
+1. **Fail-Safe**: All scripts must return non-zero exit codes on failure
+2. **Idempotent**: Can be run multiple times safely
+3. **Validated**: Must pass linting before sync
+4. **Documented**: Clear error messages and usage
+
+## Development Scripts
+
+Local development helpers are in `scripts/dev/`. These are **not** used in CI/CD.
+
+## Modification Guidelines
+
+Changes to scripts in this directory affect production workflows. Always:
+
+1. Test locally first
+2. Verify exit codes
+3. Check GitHub Actions logs
+4. Update documentation
+
+## Security
+
+These scripts handle sensitive operations:
+- `sanitize.sh` - Removes private content before public sync
+- `manage_solutions.py` - Manages private solutions
+
+Never commit secrets or tokens to these scripts.
diff --git a/scripts/audit_linter.py b/scripts/audit_linter.py
index 8ecfa1b8..ff1952a6 100755
--- a/scripts/audit_linter.py
+++ b/scripts/audit_linter.py
@@ -32,6 +32,62 @@ def check_semantic_breaks(file_path):
)
return errors
+def validate_frontmatter(file_path, content, lines):
+ """Validate YAML frontmatter contains required fields."""
+ errors = []
+
+ # Extract frontmatter
+ if not content.startswith('---'):
+ errors.append(
+ f"{file_path}: Missing YAML frontmatter. File must start with '---' followed by "
+ "title, author, paper, and topic fields."
+ )
+ return errors
+
+ # Find the end of frontmatter
+ frontmatter_end = None
+ for i, line in enumerate(lines[1:], start=1):
+ if line.strip() == '---':
+ frontmatter_end = i
+ break
+
+ if frontmatter_end is None:
+ errors.append(
+ f"{file_path}: Malformed YAML frontmatter. Missing closing '---'."
+ )
+ return errors
+
+ frontmatter_lines = lines[1:frontmatter_end]
+ frontmatter_text = '\n'.join(frontmatter_lines)
+
+ # Required fields for audit MDX files
+ required_fields = ['title', 'author', 'topic', 'paper']
+
+ for field in required_fields:
+ # Check if field exists (case-insensitive)
+ if not any(line.strip().lower().startswith(f'{field}:') for line in frontmatter_lines):
+ errors.append(
+ f"{file_path}: Missing required frontmatter field: '{field}'"
+ )
+
+ # Validate field values are not empty
+ for line in frontmatter_lines:
+ stripped = line.strip()
+ if ':' in stripped:
+ field_name, field_value = stripped.split(':', 1)
+ field_name = field_name.strip().lower()
+ field_value = field_value.strip()
+
+ if field_name in required_fields:
+ # Check for empty values or placeholder values
+ if not field_value or field_value in ['""', "''", 'null', 'TBD', 'TODO']:
+ errors.append(
+ f"{file_path}: Empty or placeholder value for required field: '{field_name}'"
+ )
+
+ return errors
+
+
def check_mdx_syntax(file_path):
"""Check for MDX-specific syntax issues."""
with open(file_path, 'r', encoding='utf-8') as f:
@@ -40,12 +96,8 @@ def check_mdx_syntax(file_path):
errors = []
- # Check 1: Must have YAML frontmatter at the start
- if not content.startswith('---'):
- errors.append(
- f"{file_path}: Missing YAML frontmatter. File must start with '---' followed by "
- "title, author, paper, and topic fields."
- )
+ # Check 1: Validate frontmatter fields
+ errors.extend(validate_frontmatter(file_path, content, lines))
# Check 2: No HTML comments (should use JSX-style {/* */})
if '⚠️ DRAFT: NOT YET ASSIGNED
-This assignment is still under review and subject to change. Do not begin work until this notice is removed.
-