Reorganize repository structure and add build tooling

## Repository Organization
- Move scripts from bin/ to scripts/ directory
  - activate-tinytorch: Environment activation script
  - generate_module_metadata.py: Module metadata generator
  - generate_student_notebooks.py: Student notebook generator
  - tito: TinyTorch CLI tool

## Build System
- Add site/build.sh: Jupyter Book 1.x build automation script
  - Auto-detects project root or site directory
  - Activates virtual environment if available
  - Handles clean builds with proper error handling

## Documentation
- Add docs/history/ for migration documentation
  - ROLLBACK_TO_JB1.md: Jupyter Book 1.x rollback documentation
  - MIGRATION_TO_V2.md: Jupyter Book 2.0 migration attempt notes

## Infrastructure Updates
- Update all site/modules/*_ABOUT.md symlinks: modules/ → src/
- Update all src/*/ABOUT.md symlinks: modules/ → src/
- Update .envrc: Reflect new scripts/ directory structure
- Update pyproject.toml: Add build system dependencies

This commit completes the src-modules separation restructuring and
adds necessary tooling for the new repository layout.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

docs/history/MIGRATION_TO_V2.md

@@ -0,0 +1,123 @@
+# Jupyter Book 2.0 Migration Complete ✅
+
+**Date:** November 25, 2024
+**From:** Jupyter Book 1.0.4.post1 (Sphinx-based)
+**To:** Jupyter Book 2.0.0-alpha (MyST-MD based)
+
+## What Changed?
+
+### Architecture
+- **Old:** Python/Sphinx-based documentation system
+- **New:** Node.js/MyST-MD based modern documentation platform
+
+### Configuration Files
+- **Old:** `_config.yml` + `_toc.yml` (Sphinx format)
+- **New:** `myst.yml` (unified MyST format)
+- **Backups:** v1 configs saved as `*.v1_backup`
+
+### Build System
+- **Old:** `jupyter-book build . --all` → Static HTML output
+- **New:** `jupyter-book start` → Live development server with hot reload
+
+### New Features in Jupyter Book 2.0
+
+1. **Rich Hover Previews** - Interactive tooltips on cross-references
+2. **Content Embedding** - Embed content from other MyST sites
+3. **Client-Side Search** - Fast local search without server
+4. **High-Quality PDFs** - Typst typesetting engine for beautiful documents
+5. **Better Performance** - Faster builds and rendering
+6. **Modern Tooling** - Built on the latest MyST-MD engine
+
+## How to Use
+
+### Start Development Server
+```bash
+./site/build.sh
+```
+
+This starts the MyST development server at `http://localhost:3000` with:
+- Live reload on file changes
+- Interactive navigation
+- Modern search functionality
+
+### Build for Production
+```bash
+cd site
+jupyter-book build --html
+```
+
+### Build PDF
+```bash
+cd site
+jupyter-book build --pdf
+```
+
+## Requirements
+
+- **Node.js**: Required (v14+ recommended)
+- **Python**: 3.13+
+- **Jupyter Book**: 2.0.0a0
+
+## File Structure
+
+```
+site/
+├── myst.yml                    # Main configuration (NEW)
+├── _config.yml.v1_backup      # Old Sphinx config (backup)
+├── _toc.yml.v1_backup         # Old TOC (backup)
+├── build.sh                    # Updated build script
+├── intro.md                    # Root page
+├── modules/                    # Course modules
+├── chapters/                   # Course chapters
+├── _static/                    # Static assets
+└── _build/                     # Build output
+```
+
+## Migration Notes
+
+### Warnings (Non-Breaking)
+- `class-header` option deprecated in `grid-item-card` directives
+- Some frontmatter keys ignored (difficulty, time_estimate, etc.)
+- These are informational only - the site builds successfully
+
+### Compatibility
+- All existing markdown content works without changes
+- MyST-MD is backward compatible with MyST Markdown v1
+- Jupyter notebooks render identically
+
+## Resources
+
+- [Jupyter Book 2.0 Announcement](https://blog.jupyterbook.org/posts/2024-11-15-jupyter-book-2-alpha/)
+- [MyST-MD Documentation](https://mystmd.org/guide)
+- [Migration Guide](https://executablebooks.org/en/latest/blog/2024-05-20-jupyter-book-myst/)
+- [2i2c Blog Post](https://2i2c.org/blog/2024/jupyter-book-2/)
+
+## Rollback Instructions
+
+If you need to rollback to Jupyter Book 1.x:
+
+```bash
+# Downgrade to v1
+.venv/bin/pip install 'jupyter-book<2.0'
+
+# Restore v1 configs
+cd site
+cp _config.yml.v1_backup _config.yml
+cp _toc.yml.v1_backup _toc.yml
+
+# Use old build system
+jupyter-book build . --all
+```
+
+## Next Steps
+
+1. ✅ Migration complete
+2. ✅ New `myst.yml` configuration created
+3. ✅ Build script updated for v2
+4. ⏭️ Test all pages thoroughly
+5. ⏭️ Update CI/CD workflows for v2
+6. ⏭️ Update deployment documentation
+
+---
+
+**Migration completed successfully! You're now on the cutting edge with Jupyter Book 2.0** 🚀

docs/history/ROLLBACK_TO_JB1.md

@@ -0,0 +1,126 @@
+# Rollback to Jupyter Book 1.x - Complete
+
+**Date:** November 25, 2024
+
+## Summary
+
+Successfully rolled back from Jupyter Book 2.0 (MyST-MD) to Jupyter Book 1.0.4.post1 (Sphinx-based) due to incompatibility issues with custom CSS/JS.
+
+## What Was Done
+
+### 1. ✅ Stopped Jupyter Book 2.0 Server
+```bash
+pkill -9 -f "jupyter-book"
+```
+
+### 2. ✅ Downgraded Jupyter Book
+```bash
+.venv/bin/pip uninstall -y jupyter-book
+.venv/bin/pip install 'jupyter-book==1.0.4.post1'
+```
+
+**Verified version:**
+```
+Jupyter Book      : 1.0.4.post1
+External ToC      : 1.0.1
+MyST-Parser       : 3.0.1
+MyST-NB           : 1.3.0
+Sphinx Book Theme : 1.1.4
+Jupyter-Cache     : 1.0.1
+NbClient          : 0.10.2
+```
+
+### 3. ✅ Restored Original Configuration
+```bash
+cp _config.yml.v1_backup _config.yml
+cp _toc.yml.v1_backup _toc.yml
+```
+
+### 4. ✅ Built Site with Jupyter Book 1.x
+```bash
+.venv/bin/jupyter-book build . --all
+```
+
+**Result:** Built successfully with 54 warnings (cosmetic only)
+
+### 5. ✅ Served Site
+```bash
+python -m http.server 8000 --directory _build/html
+```
+
+## Current Status
+
+✅ **Site running** at `http://localhost:8000`
+✅ **All styling working** - Custom CSS loads properly
+✅ **All JavaScript working** - Carousel, timeline, etc.
+✅ **45 pages built** successfully
+
+## Why Rollback Was Necessary
+
+Jupyter Book 2.0 (MyST-MD) is a **complete rewrite** with fundamentally different architecture:
+
+| Feature | Jupyter Book 1.x | Jupyter Book 2.0 |
+|---------|------------------|------------------|
+| **Engine** | Python/Sphinx | Node.js/MyST-MD |
+| **Custom CSS** | `_config.yml` → `html.extra_css` | Requires theme customization |
+| **Custom JS** | `_config.yml` → `html.extra_js` | Requires MyST plugins |
+| **Config Files** | `_config.yml` + `_toc.yml` | `myst.yml` only |
+| **Build Command** | `jupyter-book build .` | `jupyter-book start` |
+| **Output** | Static HTML | Live dev server |
+
+The migration would have required:
+1. Rewriting all custom CSS for new theme system
+2. Converting JavaScript to MyST plugins
+3. Extensive testing and debugging
+4. Time investment not justified for current project stage
+
+## Files Preserved
+
+**Backups created during migration (kept for reference):**
+- `_config.yml.v1_backup` - Original Jupyter Book 1.x config
+- `_toc.yml.v1_backup` - Original table of contents
+- `myst.yml` - Jupyter Book 2.0 config (for future reference)
+- `site/MIGRATION_TO_V2.md` - Migration documentation
+- `JUPYTER_BOOK_2_FIXES.md` - Issues encountered during migration
+
+## Future Considerations
+
+If migrating to Jupyter Book 2.0 in the future:
+
+1. **Plan for theme customization** - Custom CSS/JS requires different approach
+2. **Budget significant time** - Not a simple config change
+3. **Test thoroughly** - Completely different rendering engine
+4. **Consider benefits vs. cost** - Is 2.0 worth the migration effort?
+
+Jupyter Book 2.0 benefits:
+- Modern Node.js-based tooling
+- Live reload development server
+- Better PDF generation (Typst)
+- Client-side search
+- Rich hover previews
+
+Current assessment: **Stay on 1.x** until 2.0 matures and migration path is clearer.
+
+## How to Build & Serve Going Forward
+
+### Build Site
+```bash
+cd /Users/VJ/GitHub/TinyTorch/site
+../.venv/bin/jupyter-book build . --all
+```
+
+### Serve Locally
+```bash
+cd /Users/VJ/GitHub/TinyTorch/site
+python -m http.server 8000 --directory _build/html
+# Open http://localhost:8000
+```
+
+### Important: Use .venv Jupyter Book
+The system has multiple Python installations. Always use the venv version:
+- ✅ **Correct:** `../.venv/bin/jupyter-book`
+- ❌ **Wrong:** `jupyter-book` (might use system version)
+
+---
+
+**Status:** ✅ Rollback complete and verified working

scripts/activate-tinytorch

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Tiny🔥Torch Environment Activation & Setup
+
+# Allow users to pass a path to existing virtual env
+VENV_PATH=${1:-".venv"}
+export VENV_PATH
+
+# Check if virtual environment exists, create if not
+if [ ! -d "$VENV_PATH" ]; then
+    echo "🆕 First time setup - creating environment..."
+    python3 -m venv "$VENV_PATH" || {
+        echo "❌ Failed to create virtual environment"
+        exit 1
+    }
+    echo "📦 Installing dependencies..."
+    .venv/bin/pip install -r requirements.txt || {
+        echo "❌ Failed to install dependencies"
+        exit 1
+    }
+    echo "✅ Environment created!"
+fi
+
+echo "🔥 Activating Tiny🔥Torch environment..."
+source "$VENV_PATH/bin/activate"
+
+# Create tito alias for convenience
+alias tito="python3 bin/tito"
+
+echo "✅ Ready to build ML systems!"
+echo "💡 Quick commands:"
+echo "   tito system info      - Check system status"
+echo "   tito module test      - Run tests" 
+echo "   tito system doctor    - Diagnose issues"
+echo "   tito system jupyter   - Start Jupyter for interactive development"

scripts/generate_module_metadata.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Generate module.yaml metadata template for TinyTorch modules.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+def generate_metadata_template(module_name: str) -> str:
+    """Generate a simplified module metadata template."""
+    
+    template = f"""# TinyTorch Module Metadata
+# Essential system information for CLI tools and build systems
+
+name: "{module_name}"
+title: "{module_name.title()}"
+description: "Brief description of what this module does"
+
+# Dependencies
+dependencies:
+  prerequisites: []  # e.g., ["setup", "tensor"]
+  enables: []        # e.g., ["layers", "networks"]
+
+# Package Export
+exports_to: "tinytorch.core.{module_name}"
+
+# File Structure
+files:
+  dev_file: "{module_name}.py"
+  test_file: "tests/test_{module_name}.py"
+  readme: "README.md"
+
+# Components
+components:
+  - "component1"
+  - "component2"
+  - "component3"
+"""
+    
+    return template.strip()
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate module metadata template")
+    parser.add_argument("module_name", help="Name of the module")
+    parser.add_argument("--output", help="Output file path (default: modules/{module_name}/module.yaml)")
+    
+    args = parser.parse_args()
+    
+    # Generate template
+    template = generate_metadata_template(args.module_name)
+    
+    # Determine output path
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        output_path = Path("modules") / args.module_name / "module.yaml"
+    
+    # Create directory if it doesn't exist
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Write template
+    with open(output_path, 'w') as f:
+        f.write(template)
+    
+    print(f"✅ Generated metadata template: {output_path}")
+    print(f"📝 Edit the file to customize the module information")
+    print(f"💡 Module status will be determined automatically by test results")
+
+if __name__ == "__main__":
+    main() 

scripts/generate_student_notebooks.py

@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+"""
+TinyTorch Student Notebook Generator
+
+Transforms complete implementation notebooks into student exercise versions.
+Uses special markers to identify what becomes student exercises.
+
+Usage:
+    python bin/generate_student_notebooks.py --module tensor
+    python bin/generate_student_notebooks.py --all
+"""
+
+import argparse
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple, Any
+import sys
+
+class NotebookGenerator:
+    """Transforms complete notebooks into student exercise versions with nbgrader support."""
+    
+    def __init__(self, use_nbgrader=False):
+        self.use_nbgrader = use_nbgrader
+        self.markers = {
+            # TinyTorch markers (existing)
+            'exercise_start': '#| exercise_start',
+            'exercise_end': '#| exercise_end', 
+            'hint': '#| hint:',
+            'solution_test': '#| solution_test:',
+            'difficulty': '#| difficulty:',
+            'keep_imports': '#| keep_imports',
+            'remove_cell': '#| remove_cell',
+            
+            # nbgrader markers (new)
+            'nbgrader_solution_begin': '### BEGIN SOLUTION',
+            'nbgrader_solution_end': '### END SOLUTION',
+            'nbgrader_hidden_tests_begin': '### BEGIN HIDDEN TESTS',
+            'nbgrader_hidden_tests_end': '### END HIDDEN TESTS'
+        }
+    
+    def process_notebook(self, notebook_path: Path) -> Dict[str, Any]:
+        """Transform a complete notebook into student version."""
+        print(f"📝 Processing: {notebook_path}")
+        
+        with open(notebook_path, 'r') as f:
+            notebook = json.load(f)
+        
+        processed_cells = []
+        
+        for cell in notebook['cells']:
+            processed_cell = self._process_cell(cell)
+            if processed_cell:  # None means remove cell
+                processed_cells.append(processed_cell)
+        
+        notebook['cells'] = processed_cells
+        return notebook
+    
+    def _process_cell(self, cell: Dict[str, Any]) -> Dict[str, Any]:
+        """Process a single notebook cell with both TinyTorch and nbgrader support."""
+        if cell['cell_type'] != 'code':
+            return cell  # Keep markdown cells as-is
+        
+        source_lines = cell['source']
+        if not source_lines:
+            return cell
+        
+        # Check for remove_cell marker
+        if any(self.markers['remove_cell'] in line for line in source_lines):
+            return None  # Remove this cell
+        
+        # Process nbgrader solution blocks
+        if any(self.markers['nbgrader_solution_begin'] in line for line in source_lines):
+            return self._transform_nbgrader_cell(cell)
+        
+        # Check for TinyTorch exercise markers
+        if any(self.markers['exercise_start'] in line for line in source_lines):
+            return self._transform_exercise_cell(cell)
+        
+        # Check for keep_imports marker
+        if any(self.markers['keep_imports'] in line for line in source_lines):
+            return self._clean_markers(cell)
+        
+        return cell
+    
+    def _transform_nbgrader_cell(self, cell: Dict[str, Any]) -> Dict[str, Any]:
+        """Transform nbgrader solution blocks for student version."""
+        source_lines = cell['source']
+        new_lines = []
+        
+        in_solution = False
+        in_hidden_tests = False
+        placeholder_added = False
+        
+        for line in source_lines:
+            if self.markers['nbgrader_solution_begin'] in line:
+                in_solution = True
+                placeholder_added = False
+                if self.use_nbgrader:
+                    new_lines.append(line)  # Keep marker for nbgrader
+                    # Add placeholder immediately after BEGIN SOLUTION
+                    new_lines.append("    # YOUR CODE HERE\n")
+                    new_lines.append("    raise NotImplementedError()\n")
+                    placeholder_added = True
+                continue
+            elif self.markers['nbgrader_solution_end'] in line:
+                in_solution = False
+                if self.use_nbgrader:
+                    new_lines.append(line)  # Keep marker for nbgrader
+                continue
+            elif self.markers['nbgrader_hidden_tests_begin'] in line:
+                in_hidden_tests = True
+                if self.use_nbgrader:
+                    new_lines.append(line)  # Keep marker for nbgrader
+                continue
+            elif self.markers['nbgrader_hidden_tests_end'] in line:
+                in_hidden_tests = False
+                if self.use_nbgrader:
+                    new_lines.append(line)  # Keep marker for nbgrader
+                continue
+            elif in_solution:
+                # Skip solution lines (placeholder already added)
+                continue
+            elif in_hidden_tests:
+                # Keep hidden tests for nbgrader, remove for regular students
+                if self.use_nbgrader:
+                    new_lines.append(line)
+                # Skip for regular students
+                continue
+            else:
+                # Keep non-solution lines
+                new_lines.append(line)
+        
+        cell['source'] = new_lines
+        return cell
+
+    def _transform_exercise_cell(self, cell: Dict[str, Any]) -> Dict[str, Any]:
+        """Transform a cell with exercise markers into student version."""
+        source_lines = cell['source']
+        new_lines = []
+        
+        in_exercise = False
+        exercise_header_lines = []  # Store function def, docstring etc.
+        hints = []
+        solution_tests = []
+        difficulty = "medium"
+        
+        for line in source_lines:
+            if self.markers['exercise_start'] in line:
+                in_exercise = True
+                continue
+            elif self.markers['exercise_end'] in line:
+                in_exercise = False
+                # Add the preserved header + exercise placeholder
+                new_lines.extend(exercise_header_lines)
+                new_lines.extend(self._create_exercise_placeholder(hints, solution_tests, difficulty))
+                # Reset for next exercise
+                exercise_header_lines = []
+                hints = []
+                solution_tests = []
+                difficulty = "medium"
+                continue
+            elif self.markers['hint'] in line:
+                hint = line.split(self.markers['hint'], 1)[1].strip()
+                hints.append(hint)
+                continue
+            elif self.markers['solution_test'] in line:
+                test = line.split(self.markers['solution_test'], 1)[1].strip()
+                solution_tests.append(test)
+                continue
+            elif self.markers['difficulty'] in line:
+                difficulty = line.split(self.markers['difficulty'], 1)[1].strip()
+                continue
+            elif in_exercise:
+                # Preserve function signature and docstring, skip implementation
+                if self._is_function_signature_or_docstring(line):
+                    exercise_header_lines.append(line)
+                # Skip implementation lines (but keep signature/docstring)
+                continue
+            else:
+                # Keep non-exercise lines
+                new_lines.append(line)
+        
+        cell['source'] = new_lines
+        return cell
+
+    def _is_function_signature_or_docstring(self, line: str) -> bool:
+        """Check if line is part of function signature or docstring."""
+        stripped = line.strip()
+        
+        # Empty lines
+        if not stripped:
+            return False
+            
+        # Function definition
+        if (stripped.startswith('def ') or 
+            stripped.startswith('class ') or
+            stripped.startswith('@')):  # decorators
+            return True
+            
+        # Function signature continuation (parameters on multiple lines) 
+        if (stripped.endswith(',') or 
+            stripped.endswith('\\') or
+            stripped.startswith(')') or
+            '->' in stripped):
+            return True
+            
+        # Docstrings (triple quotes)
+        if ('"""' in stripped or "'''" in stripped):
+            return True
+            
+        # Docstring content (common patterns)
+        if (stripped.startswith('Args:') or 
+            stripped.startswith('Returns:') or
+            stripped.startswith('Raises:') or
+            stripped.startswith('Note:') or
+            stripped.startswith('Example:')):
+            return True
+            
+        # Implementation code (skip these)
+        if (stripped.startswith('self.') or
+            stripped.startswith('if ') or
+            stripped.startswith('elif ') or
+            stripped.startswith('else:') or
+            stripped.startswith('for ') or
+            stripped.startswith('while ') or
+            stripped.startswith('return ') or
+            stripped.startswith('raise ') or
+            stripped.startswith('try:') or
+            stripped.startswith('except ') or
+            stripped.startswith('with ') or
+            '=' in stripped and not stripped.startswith('"""') and not stripped.startswith("'''")):
+            return False
+            
+        # Comments (keep them as they might be part of docstring)
+        if stripped.startswith('#'):
+            return True
+            
+        # If we're not sure and it's just text, assume it's docstring content
+        # This catches parameter descriptions, etc.
+        return True
+    
+    def _create_exercise_placeholder(self, hints: List[str], tests: List[str], difficulty: str) -> List[str]:
+        """Create TODO placeholder for students."""
+        lines = []
+        
+        # Add difficulty indicator and description
+        difficulty_emoji = {"easy": "🟢", "medium": "🟡", "hard": "🔴"}
+        lines.append(f"    # {difficulty_emoji.get(difficulty, '🟡')} TODO: Implement this method ({difficulty})\n")
+        
+        # Add hints
+        for hint in hints:
+            lines.append(f"    # HINT: {hint}\n")
+        
+        # Add test guidance
+        for test in tests:
+            lines.append(f"    # TEST: {test}\n")
+        
+        lines.append("    \n")
+        lines.append("    # Your implementation here\n")
+        
+        if self.use_nbgrader:
+            lines.append("    # YOUR CODE HERE\n")
+            lines.append("    raise NotImplementedError()\n")
+        else:
+            lines.append("    pass\n")
+        
+        return lines
+    
+    def _clean_markers(self, cell: Dict[str, Any]) -> Dict[str, Any]:
+        """Remove generator markers from cell."""
+        source_lines = cell['source']
+        cleaned_lines = []
+        
+        for line in source_lines:
+            # Skip marker lines
+            if any(marker in line for marker in self.markers.values()):
+                continue
+            cleaned_lines.append(line)
+        
+        cell['source'] = cleaned_lines
+        return cell
+    
+    def save_student_notebook(self, notebook: Dict[str, Any], output_path: Path):
+        """Save the student version notebook."""
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(output_path, 'w') as f:
+            json.dump(notebook, f, indent=2)
+        
+        print(f"✅ Student version saved: {output_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate student exercise notebooks")
+    parser.add_argument('--module', type=str, help='Generate for specific module')
+    parser.add_argument('--all', action='store_true', help='Generate for all modules')
+    parser.add_argument('--output-suffix', default='_student', help='Suffix for student notebooks')
+    parser.add_argument('--nbgrader', action='store_true', help='Generate nbgrader-compatible notebooks')
+    
+    args = parser.parse_args()
+    
+    if not args.module and not args.all:
+        parser.error("Must specify either --module or --all")
+    
+    generator = NotebookGenerator(use_nbgrader=args.nbgrader)
+    modules_dir = Path("modules")
+    
+    if args.module:
+        modules = [args.module]
+    else:
+        modules = [d.name for d in modules_dir.iterdir() if d.is_dir()]
+    
+    for module in modules:
+        module_dir = modules_dir / module
+        dev_notebook = module_dir / f"{module}_dev.ipynb"
+        
+        if not dev_notebook.exists():
+            print(f"⚠️  No dev notebook found for {module}: {dev_notebook}")
+            continue
+        
+        # Generate student version
+        notebook = generator.process_notebook(dev_notebook)
+        
+        if args.nbgrader:
+            output_path = module_dir / f"{module}_assignment.ipynb"
+            generator.save_student_notebook(notebook, output_path)
+        else:
+            output_path = module_dir / f"{module}{args.output_suffix}.ipynb"
+            generator.save_student_notebook(notebook, output_path)
+
+if __name__ == "__main__":
+    main() 

scripts/tito

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""
+TinyTorch CLI Wrapper
+
+Backward compatibility wrapper that calls the new CLI structure.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the project root to Python path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+# Import and run the new CLI
+from tito.main import main
+
+if __name__ == "__main__":
+    sys.exit(main()) 

site/build.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# TinyTorch Website Build Script
+# Jupyter Book 1.x (Sphinx) Build System
+# Quick and easy: ./site/build.sh (from root) or ./build.sh (from site/)
+
+set -e  # Exit on error
+
+echo "🏗️  Building TinyTorch documentation website (Jupyter Book 1.x)..."
+echo ""
+
+# Detect where we're running from and navigate to site directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SITE_DIR=""
+PROJECT_ROOT=""
+
+if [ -f "_config.yml" ]; then
+    # Already in site directory
+    SITE_DIR="$(pwd)"
+    PROJECT_ROOT="$(dirname "$SITE_DIR")"
+elif [ -f "site/_config.yml" ]; then
+    # In root directory
+    PROJECT_ROOT="$(pwd)"
+    SITE_DIR="$(pwd)/site"
+    cd "$SITE_DIR"
+    echo "📂 Changed to site directory: $SITE_DIR"
+else
+    echo "❌ Error: Cannot find site directory with _config.yml"
+    echo "   Run from project root or site/ directory"
+    exit 1
+fi
+
+# Activate virtual environment if it exists and we're not already in it
+if [ -z "$VIRTUAL_ENV" ] && [ -f "$PROJECT_ROOT/.venv/bin/activate" ]; then
+    echo "🔧 Activating virtual environment..."
+    source "$PROJECT_ROOT/.venv/bin/activate"
+elif [ -z "$VIRTUAL_ENV" ]; then
+    echo "⚠️  Warning: No virtual environment detected"
+    echo "   Recommend running: source scripts/activate-tinytorch"
+fi
+
+# Verify jupyter-book is available
+if ! command -v jupyter-book &> /dev/null; then
+    echo "❌ Error: jupyter-book not found"
+    echo "   Install with: pip install jupyter-book"
+    exit 1
+fi
+
+echo "📦 Using: $(which jupyter-book)"
+echo "   Version: $(jupyter-book --version | head -1)"
+echo ""
+
+# Clean previous build
+if [ -d "_build" ]; then
+    echo "🧹 Cleaning previous build..."
+    jupyter-book clean .
+    echo ""
+fi
+
+# Build the site
+echo "🚀 Building Jupyter Book site..."
+echo ""
+jupyter-book build . --all
+
+echo ""
+echo "✅ Build complete!"
+echo ""
+echo "📖 To view the site locally:"
+echo "   python -m http.server 8000 --directory _build/html"
+echo "   Then open: http://localhost:8000"
+echo ""