purecontext-mcp 1.1.1 → 1.1.2

package/docs/dev/PHASE10_TASKS.md

@@ -1,476 +0,0 @@
-# Phase 10 — Task Breakdown
-
-**Goal**: Add framework adapters for Rust web frameworks (Axum, Actix-web, Rocket), Java backend frameworks (Spring Boot, Micronaut, Quarkus), and ORM enrichment adapters (Hibernate, SQLAlchemy, Django ORM). This phase completes the framework adapter roadmap.
-
-**Scope rationale**: These frameworks represent the most popular choices in their respective ecosystems. Rust web frameworks are increasingly adopted for high-performance services. Spring Boot dominates enterprise Java. ORM adapters enrich existing language handlers with database schema metadata, improving code understanding for data-driven applications.
-
-**Approach**: Tasks are grouped by ecosystem (Rust, Java, ORM). Within each group, adapters are independent and can be developed in parallel.
-
----
-
-## Task 80: Axum Adapter (Rust)
-
-Extract route and middleware symbols from Axum web applications. Axum uses a tower-based routing DSL.
-
-**Deliverables:**
-
-- `src/adapters/axum.ts` — implements `FrameworkAdapter`
-  - `name`: `'axum'`
-  - `extensions()`: `[]` — `.rs` files handled by Rust handler
-  - `detect(projectRoot)`:
-    - Read `Cargo.toml` — check for `axum` in `[dependencies]`
-    - Regex: `/axum\s*=/`
-  - `fileFilter(filePath)`: `.rs` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for `Router::new()` chains:
-      - `.route("/path", get(handler))` → emit kind `'route'`
-      - `.route("/path", post(handler).put(handler2))` → emit multiple routes
-      - HTTP methods: `get`, `post`, `put`, `patch`, `delete`, `head`, `options`, `trace`
-    - For each route:
-      - `frameworkMeta.http_method`: method name uppercase
-      - `frameworkMeta.route_path`: path string
-      - `frameworkMeta.axum_route: true`
-    - Scan for `.layer(...)` calls → emit kind `'middleware'`
-      - Extract middleware type from argument
-      - `frameworkMeta.axum_layer: true`
-    - Scan for `#[derive(FromRequest)]` or `impl FromRequest` → emit kind `'type'`
-      - `frameworkMeta.axum_extractor: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(axumAdapter)`
-
-**Key technical notes:**
-- Axum routes are defined via method chaining — parse the full chain
-- Path parameters use `:param` syntax: `/users/:id`
-- Nested routers via `.nest("/prefix", router)` — combine prefixes
-- Tower layers are middleware — extract type names
-
-**Verify:** Index `test/fixtures/axum-project/`. Verify routes with GET/POST extracted. Verify middleware layers extracted. Verify path parameters preserved.
-
-**Tests:** `.route()` single method, `.route()` multiple methods, path with `:param`, `.nest()` prefix, `.layer()` middleware, `FromRequest` extractor.
-
----
-
-## Task 81: Actix-web Adapter (Rust)
-
-Extract route and middleware symbols from Actix-web applications. Actix uses procedural macros for route definitions.
-
-**Deliverables:**
-
-- `src/adapters/actix-web.ts` — implements `FrameworkAdapter`
-  - `name`: `'actix-web'`
-  - `extensions()`: `[]` — `.rs` files handled by Rust handler
-  - `detect(projectRoot)`:
-    - Read `Cargo.toml` — check for `actix-web` in `[dependencies]`
-  - `fileFilter(filePath)`: `.rs` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for route attribute macros:
-      - `#[get("/path")]`, `#[post("/path")]`, etc. → emit kind `'route'`
-      - HTTP methods: `get`, `post`, `put`, `patch`, `delete`, `head`, `options`, `trace`, `connect`
-    - For each route:
-      - Extract path from attribute argument
-      - `frameworkMeta.http_method`: macro name uppercase
-      - `frameworkMeta.route_path`: path string
-      - `frameworkMeta.actix_route: true`
-    - Scan for `web::resource("/path")` / `web::scope("/prefix")` chains:
-      - `.route(web::get().to(handler))` → emit route
-    - Scan for `.wrap()` calls → emit kind `'middleware'`
-      - `frameworkMeta.actix_middleware: true`
-    - Scan for `impl FromRequest for Type` → emit kind `'type'`
-      - `frameworkMeta.actix_extractor: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(actixWebAdapter)`
-
-**Key technical notes:**
-- Actix routes can be defined via macros (`#[get]`) or programmatically (`web::resource`)
-- Extract both patterns for complete coverage
-- Path parameters use `{param}` syntax: `/users/{id}`
-- Guards add conditions to routes — note but don't extract separately
-
-**Verify:** Index `test/fixtures/actix-project/`. Verify macro-defined routes extracted. Verify programmatic routes extracted. Verify middleware extracted.
-
-**Tests:** `#[get("/path")]` macro, `#[post]` macro, `web::resource().route()` programmatic, path with `{param}`, `.wrap()` middleware, `FromRequest` impl.
-
----
-
-## Task 82: Rocket Adapter (Rust)
-
-Extract route and middleware symbols from Rocket web applications. Rocket uses procedural macros similar to Actix.
-
-**Deliverables:**
-
-- `src/adapters/rocket.ts` — implements `FrameworkAdapter`
-  - `name`: `'rocket'`
-  - `extensions()`: `[]` — `.rs` files handled by Rust handler
-  - `detect(projectRoot)`:
-    - Read `Cargo.toml` — check for `rocket` in `[dependencies]`
-  - `fileFilter(filePath)`: `.rs` files only
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - Scan for route attribute macros:
-      - `#[get("/path")]`, `#[post("/path")]`, etc. → emit kind `'route'`
-      - `#[route(GET, path = "/path")]` → emit kind `'route'`
-    - For each route:
-      - `frameworkMeta.http_method`: method from macro
-      - `frameworkMeta.route_path`: path string
-      - `frameworkMeta.rocket_route: true`
-    - Scan for `#[catch(code)]` → emit kind `'route'`
-      - `frameworkMeta.rocket_catcher: true`
-      - `frameworkMeta.status_code`: the code number
-    - Scan for `impl Fairing for Type` → emit kind `'middleware'`
-      - `frameworkMeta.rocket_fairing: true`
-    - Scan for `#[derive(FromForm)]`, `#[derive(FromRequest)]` → emit kind `'type'`
-      - `frameworkMeta.rocket_guard: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(rocketAdapter)`
-
-**Key technical notes:**
-- Rocket path parameters use `<param>` syntax: `/users/<id>`
-- Rocket fairings are lifecycle middleware (request, response, attach)
-- Error catchers (`#[catch]`) are special routes for HTTP error codes
-- Request guards are validators/extractors
-
-**Verify:** Index `test/fixtures/rocket-project/`. Verify routes extracted. Verify catchers extracted with status codes. Verify fairings extracted.
-
-**Tests:** `#[get]` macro, `#[post]` with form data, `#[route(GET, path = "...")]`, path with `<param>`, `#[catch(404)]` catcher, `Fairing` impl, `FromForm` derive.
-
----
-
-## Task 83: Spring Boot Adapter (Java)
-
-Extract route, bean, and component symbols from Spring Boot applications. Spring uses annotations extensively.
-
-**Deliverables:**
-
-- `src/adapters/spring-boot.ts` — implements `FrameworkAdapter`
-  - `name`: `'spring-boot'`
-  - `extensions()`: `[]` — `.java` files handled by Java handler
-  - `detect(projectRoot)`:
-    - Check for `pom.xml` with `spring-boot-starter` artifact
-    - OR `build.gradle` with `org.springframework.boot` dependency
-    - OR `src/main/resources/application.properties` or `application.yml`
-  - `fileFilter(filePath)`: `.java` and `.kt` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Controllers:**
-      - `@RestController` or `@Controller` on class → emit kind `'class'` with `frameworkMeta.spring_controller: true`
-      - `@RequestMapping("/prefix")` on class → capture base path
-      - `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, `@PatchMapping` on methods → emit kind `'route'`
-        - Combine class prefix with method path
-        - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.spring_route: true`
-    - **Services and components:**
-      - `@Service`, `@Component`, `@Repository` on class → emit with `frameworkMeta.spring_bean: true`
-    - **Configuration:**
-      - `@Configuration` class → emit with `frameworkMeta.spring_config: true`
-      - `@Bean` methods → emit kind `'function'` with `frameworkMeta.spring_bean: true`
-    - **Dependency injection:**
-      - `@Autowired` fields/constructors → note in metadata (don't emit separate symbol)
-    - **Scheduled tasks:**
-      - `@Scheduled` methods → emit kind `'function'` with `frameworkMeta.spring_scheduled: true`
-    - **Event listeners:**
-      - `@EventListener` methods → emit kind `'function'` with `frameworkMeta.spring_listener: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(springBootAdapter)`
-
-**Key technical notes:**
-- Spring path variables use `{param}` syntax: `/users/{id}`
-- RequestMapping can specify multiple paths and methods
-- Spring Boot apps often use Kotlin — support both Java and Kotlin files
-- Bean names default to method/class name unless specified
-
-**Verify:** Index `test/fixtures/spring-boot-project/`. Verify REST endpoints extracted with correct paths. Verify @Service and @Component beans detected. Verify @Scheduled jobs extracted.
-
-**Tests:** `@GetMapping`, `@PostMapping`, `@RequestMapping` with path, `@RestController` with class-level path, `@Service`, `@Component`, `@Bean` method, `@Scheduled`, path variable `{id}`.
-
----
-
-## Task 84: Micronaut Adapter (Java)
-
-Extract route and bean symbols from Micronaut applications. Micronaut is similar to Spring but with compile-time DI.
-
-**Deliverables:**
-
-- `src/adapters/micronaut.ts` — implements `FrameworkAdapter`
-  - `name`: `'micronaut'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check for `pom.xml` with `micronaut-*` artifacts
-    - OR `build.gradle` with `io.micronaut` dependencies
-  - `fileFilter(filePath)`: `.java`, `.kt`, `.groovy` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Controllers:**
-      - `@Controller("/prefix")` on class → emit with base path
-      - `@Get`, `@Post`, `@Put`, `@Delete`, `@Patch` on methods → emit kind `'route'`
-        - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.micronaut_route: true`
-    - **Beans:**
-      - `@Singleton`, `@Prototype`, `@Bean` → emit with `frameworkMeta.micronaut_bean: true`
-    - **Clients:**
-      - `@Client("/base")` interface → emit kind `'interface'` with `frameworkMeta.micronaut_client: true`
-    - **Scheduled:**
-      - `@Scheduled` methods → emit with `frameworkMeta.micronaut_scheduled: true`
-    - **Event listeners:**
-      - `@EventListener` methods → emit with `frameworkMeta.micronaut_listener: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(micronautAdapter)`
-
-**Key technical notes:**
-- Micronaut paths use `{param}` like Spring
-- Micronaut clients are declarative HTTP clients — useful for understanding service interactions
-- Micronaut supports Java, Kotlin, and Groovy
-
-**Verify:** Index `test/fixtures/micronaut-project/`. Verify endpoints extracted. Verify @Client interfaces extracted.
-
-**Tests:** `@Get("/path")`, `@Controller` with base path, `@Singleton` bean, `@Client` interface, `@Scheduled`.
-
----
-
-## Task 85: Quarkus Adapter (Java)
-
-Extract route and bean symbols from Quarkus applications. Quarkus uses JAX-RS annotations.
-
-**Deliverables:**
-
-- `src/adapters/quarkus.ts` — implements `FrameworkAdapter`
-  - `name`: `'quarkus'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check for `pom.xml` with `quarkus-*` artifacts
-    - OR `build.gradle` with `io.quarkus` dependencies
-  - `fileFilter(filePath)`: `.java`, `.kt` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **JAX-RS resources:**
-      - `@Path("/prefix")` on class → emit with base path
-      - `@GET`, `@POST`, `@PUT`, `@DELETE`, `@PATCH` on methods → emit kind `'route'`
-        - `frameworkMeta.http_method`, `frameworkMeta.route_path`, `frameworkMeta.quarkus_route: true`
-    - **Beans:**
-      - `@ApplicationScoped`, `@Singleton`, `@Dependent` → emit with `frameworkMeta.quarkus_bean: true`
-    - **Reactive routes:**
-      - `@Route` annotation → emit kind `'route'`
-        - `frameworkMeta.quarkus_reactive: true`
-    - **Scheduled:**
-      - `@Scheduled` methods → emit with `frameworkMeta.quarkus_scheduled: true`
-    - **REST clients:**
-      - `@RegisterRestClient` interface → emit kind `'interface'` with `frameworkMeta.quarkus_client: true`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(quarkusAdapter)`
-
-**Key technical notes:**
-- Quarkus uses JAX-RS (standard Java REST API) unlike Spring
-- Path parameters use `{param}` syntax
-- Quarkus supports both imperative and reactive programming models
-- RESTEasy reactive routes are an alternative to JAX-RS
-
-**Verify:** Index `test/fixtures/quarkus-project/`. Verify JAX-RS endpoints extracted. Verify @ApplicationScoped beans detected.
-
-**Tests:** `@Path` + `@GET`, `@POST` method, `@ApplicationScoped`, `@RegisterRestClient`, `@Scheduled`, reactive `@Route`.
-
----
-
-## Task 86: Hibernate Adapter (Java ORM)
-
-Enrich entity symbols with database schema metadata from Hibernate/JPA annotations.
-
-**Deliverables:**
-
-- `src/adapters/hibernate.ts` — implements `FrameworkAdapter`
-  - `name`: `'hibernate'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check for `hibernate-core` or `jakarta.persistence` in dependencies
-    - OR `persistence.xml` in `src/main/resources/META-INF/`
-  - `fileFilter(filePath)`: `.java`, `.kt` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Entities:**
-      - `@Entity` on class → emit kind `'class'`
-        - `frameworkMeta.hibernate_entity: true`
-        - `frameworkMeta.table_name`: from `@Table(name = "...")` or class name lowercase
-    - **Fields:**
-      - For each `@Column` field → emit kind `'const'`
-        - `frameworkMeta.column_name`: from annotation or field name
-        - `frameworkMeta.column_type`: inferred from Java type
-        - `frameworkMeta.nullable`: from `@Column(nullable = ...)`
-    - **Relationships:**
-      - `@OneToMany`, `@ManyToOne`, `@OneToOne`, `@ManyToMany` → emit kind `'const'`
-        - `frameworkMeta.relationship`: type
-        - `frameworkMeta.target_entity`: related class
-    - **IDs:**
-      - `@Id` field → add `frameworkMeta.primary_key: true`
-      - `@GeneratedValue` → add `frameworkMeta.generated: true`
-    - **Queries:**
-      - `@NamedQuery` on class → emit kind `'function'`
-        - `frameworkMeta.hibernate_query: true`
-        - `frameworkMeta.query_string`: the JPQL query
-  - `enrichMetadata(symbol)`:
-    - For existing class symbols: add entity metadata if `@Entity` present
-  - Register via `registerAdapter(hibernateAdapter)`
-
-**Key technical notes:**
-- JPA (Jakarta Persistence) and Hibernate share annotations — handle both
-- Table/column names may differ from class/field names via annotations
-- Relationships define the entity graph — useful for understanding data flow
-- Named queries are reusable JPQL snippets
-
-**Verify:** Index a project with Hibernate entities. Verify table names extracted. Verify relationship metadata present.
-
-**Tests:** `@Entity` class, `@Table` with custom name, `@Column` field, `@Id` primary key, `@OneToMany` relationship, `@NamedQuery`.
-
----
-
-## Task 87: SQLAlchemy Adapter (Python ORM)
-
-Enrich model symbols with database schema metadata from SQLAlchemy models.
-
-**Deliverables:**
-
-- `src/adapters/sqlalchemy.ts` — implements `FrameworkAdapter`
-  - `name`: `'sqlalchemy'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check `requirements.txt` or `pyproject.toml` for `sqlalchemy`
-  - `fileFilter(filePath)`: `.py` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Models:**
-      - Class inheriting from `Base` or `DeclarativeBase` → emit kind `'class'`
-        - `frameworkMeta.sqlalchemy_model: true`
-        - `frameworkMeta.table_name`: from `__tablename__` attribute
-    - **Columns:**
-      - `Column(...)` assignments → emit kind `'const'`
-        - `frameworkMeta.column_name`: field name
-        - `frameworkMeta.column_type`: from `Column(Type, ...)`
-        - `frameworkMeta.nullable`: from `nullable=False` (default True)
-        - `frameworkMeta.primary_key`: from `primary_key=True`
-    - **Relationships:**
-      - `relationship(...)` assignments → emit kind `'const'`
-        - `frameworkMeta.relationship`: type name from argument
-        - `frameworkMeta.back_populates`: if present
-    - **SQLAlchemy 2.0 style:**
-      - `mapped_column(...)` → same as Column
-      - `Mapped[Type]` type annotations → extract column type
-    - **Hybrid properties:**
-      - `@hybrid_property` decorated methods → emit kind `'const'`
-  - `enrichMetadata(symbol)`:
-    - For existing class symbols: add model metadata if inherits Base
-  - Register via `registerAdapter(sqlalchemyAdapter)`
-
-**Key technical notes:**
-- SQLAlchemy 1.x and 2.x have different syntax patterns — handle both
-- `__tablename__` is required or defaults to class name lowercase
-- Relationship patterns: one-to-many via `relationship()`, foreign keys via `Column(ForeignKey(...))`
-
-**Verify:** Index a SQLAlchemy project. Verify table names extracted. Verify column types captured.
-
-**Tests:** Model with `__tablename__`, `Column(Integer)`, `Column(String)`, `primary_key=True`, `relationship()`, SQLAlchemy 2.0 `mapped_column`, `@hybrid_property`.
-
----
-
-## Task 88: Django ORM Adapter (Python ORM)
-
-Enrich model symbols with database schema metadata from Django models.
-
-**Deliverables:**
-
-- `src/adapters/django-orm.ts` — implements `FrameworkAdapter`
-  - `name`: `'django-orm'`
-  - `extensions()`: `[]`
-  - `detect(projectRoot)`:
-    - Check for `manage.py` and `django` in dependencies
-    - OR `settings.py` with `DATABASES` config
-  - `fileFilter(filePath)`: `models.py` or `models/*.py` files
-  - `extractFrameworkSymbols(tree, source, filePath)`:
-    - **Models:**
-      - Class inheriting from `models.Model` → emit kind `'class'`
-        - `frameworkMeta.django_model: true`
-        - `frameworkMeta.table_name`: from `Meta.db_table` or `app_modelname`
-        - `frameworkMeta.app_label`: from file path
-    - **Fields:**
-      - `models.CharField(...)`, `models.IntegerField(...)`, etc. → emit kind `'const'`
-        - `frameworkMeta.field_type`: Django field class name
-        - `frameworkMeta.max_length`: for CharField
-        - `frameworkMeta.null`: from `null=True`
-        - `frameworkMeta.blank`: from `blank=True`
-    - **Relationships:**
-      - `models.ForeignKey(...)` → emit kind `'const'`
-        - `frameworkMeta.relationship`: `'foreign_key'`
-        - `frameworkMeta.target_model`: related model
-        - `frameworkMeta.on_delete`: delete behavior
-      - `models.ManyToManyField(...)`, `models.OneToOneField(...)` → similar
-    - **Managers:**
-      - `objects = CustomManager()` → emit kind `'const'`
-        - `frameworkMeta.django_manager: true`
-    - **Meta class:**
-      - Extract `verbose_name`, `ordering`, `indexes`, `constraints`
-  - `enrichMetadata(symbol)`: no-op
-  - Register via `registerAdapter(djangoOrmAdapter)`
-
-**Key technical notes:**
-- Django table names are `appname_modelname` by default
-- Field options vary by type (CharField has max_length, IntegerField doesn't)
-- `on_delete` is required for ForeignKey in Django 2.0+
-- Django uses `models.` prefix for all field types
-
-**Verify:** Index a Django project. Verify model table names derived correctly. Verify field types captured with options.
-
-**Tests:** `models.Model` class, `CharField`, `IntegerField`, `ForeignKey` with `on_delete`, `ManyToManyField`, `Meta` class with `db_table`, custom manager.
-
----
-
-## Task 89: Phase 10 Test Fixtures and Integration Tests
-
-Validate all Phase 10 adapters end-to-end.
-
-**Deliverables:**
-
-- `test/fixtures/axum-project/` — minimal Axum app
-- `test/fixtures/actix-project/` — minimal Actix-web app
-- `test/fixtures/rocket-project/` — minimal Rocket app
-- `test/fixtures/spring-boot-project/` — minimal Spring Boot app
-- `test/fixtures/micronaut-project/` — minimal Micronaut app
-- `test/fixtures/quarkus-project/` — minimal Quarkus app
-- `test/fixtures/hibernate-project/` — Java project with Hibernate entities
-- `test/fixtures/sqlalchemy-project/` — Python project with SQLAlchemy models
-- `test/fixtures/django-project/` — Django project with models
-
-- Integration tests `test/integration/phase10.test.ts`:
-  1. Axum: `.route("/path", get(handler))` → route symbol
-  2. Actix: `#[get("/path")]` macro → route symbol
-  3. Rocket: `#[get("/path")]` macro → route symbol
-  4. Rocket: `#[catch(404)]` → catcher symbol
-  5. Spring Boot: `@GetMapping` → route with path
-  6. Spring Boot: `@Service` → bean symbol
-  7. Micronaut: `@Get("/path")` → route
-  8. Quarkus: JAX-RS `@GET` → route
-  9. Hibernate: `@Entity` → model with table name
-  10. Hibernate: `@Column` → field with metadata
-  11. SQLAlchemy: model with `__tablename__` → table name
-  12. SQLAlchemy: `Column(Integer)` → typed field
-  13. Django: `models.Model` → model with table name
-  14. Django: `ForeignKey` → relationship metadata
-  15. Full suite regression: all Phase 1–9 tests still green
-
-**Verify:** `npm run test` passes entirely — all Phase 1–10 tests green.
-
----
-
-## Order of Execution
-
-```
-Task 80: Axum adapter                      █░░░░░░░░░ Rust
-Task 81: Actix-web adapter                 ██░░░░░░░░ Rust
-Task 82: Rocket adapter                    ███░░░░░░░ Rust
-Task 83: Spring Boot adapter               ████░░░░░░ Java
-Task 84: Micronaut adapter                 █████░░░░░ Java
-Task 85: Quarkus adapter                   ██████░░░░ Java   DONE
-Task 86: Hibernate adapter                 ███████░░░ ORM    DONE
-Task 87: SQLAlchemy adapter                ████████░░ ORM    DONE
-Task 88: Django ORM adapter                █████████░ ORM    DONE
-Task 89: Fixtures + integration tests      ██████████ Polish DONE
-```
-
-Tasks within ecosystem groups (Rust: 80–82, Java: 83–85, ORM: 86–88) are independent and can be parallelized. Task 89 validates everything.
-
----
-
-## Post-Phase 10: What Comes Next
-
-Phase 10 completes the framework adapter roadmap. Remaining phases focus on advanced features:
-
-- **Phase 11**: Semantic search (HNSW) for repos with > 50k symbols
-- **Phase 12**: Rate limiting and multi-tenant auth for hosted deployments
-- **Phase 13**: Web UI for exploring the symbol graph visually