septum 0.1.3 → 0.1.4

package/README.md

@@ -2,6 +2,7 @@
 
 > **Deterministic Bounded-Context & Anti-Poisoning Architecture Guard for AI Coding Agents.**
 
+[![Version: 0.1.4](https://img.shields.io/badge/Version-0.1.4-blue)](package.json)
 [![Runtime: Bun](https://img.shields.io/badge/Runtime-Bun-black?logo=bun)](https://bun.sh)
 [![Protocol: Model Context Protocol](https://img.shields.io/badge/Protocol-MCP-green)](https://modelcontextprotocol.io/)
 [![Database: SQLite WAL](https://img.shields.io/badge/Database-SQLite%20(bun:sqlite)-003B57?logo=sqlite)](https://sqlite.org/)
@@ -63,6 +64,7 @@ Add Septum to your MCP client (`mcp.json` or `claude_desktop_config.json`):
 | `septum query [domain]` | Inspect domain catalog, archetypes, and public signatures |
 | `septum locate <query>` | Locate symbol, class, interface, method, or error source |
 | `septum slice <route\|intent>` | Trace end-to-end vertical execution slice for route/intent |
+| `septum topology [action]` | Inspect 6-layer environment topology plane & distributed nodes |
 | `septum feature status\|clear` | Manage active feature lease and editing scope |
 | `septum serve` | Launch stdio MCP server for AI coding agents |
 
@@ -72,12 +74,13 @@ Add Septum to your MCP client (`mcp.json` or `claude_desktop_config.json`):
 
 All tools expose typed schemas automatically via the Model Context Protocol:
 
+- **Self-Aware Environment Topology (`septum_get_environment_topology`):** Maps and verifies the 6-layer production architecture (Edge/WAF, Gateway/Web Server, Host, Runtime, Storage/Cache, Telemetry) and distributed entities with cross-layer invariants.
 - **Whole-Project Telescope (`septum_get_domain_catalog`):** Returns macro architecture maps in < 400 tokens.
-- **Vertical Slice Tracer (`septum_trace_vertical_slice`):** Traces execution chains (*Ingress ➔ Validation ➔ Orchestration ➔ Domain ➔ Egress*) across frameworks.
+- **Omni-Trigger Vertical Slice Tracer (`septum_trace_vertical_slice`):** Traces execution chains across HTTP routes, queue jobs, console commands, and event listeners (*Ingress ➔ Validation ➔ Orchestration ➔ Domain ➔ Egress*).
 - **Pre-Flight Boundary Guard (`septum_check_boundary`):** Validates proposed edits and imports against bounded-context rules.
 - **Scope Locking (`septum_get_feature_context` / `septum_clear_feature_context`):** Locks active feature scope to eliminate context drift.
 - **Symbol & Blast Radius (`septum_locate_symbol`, `septum_get_symbol`, `septum_get_symbol_impact`):** Resolves call chains, signatures, and refactoring impact.
-- **God Function Detector (`septum_get_symbol_hotspots`):** Surfaces oversized functions/methods by physical lines-of-code.
+- **God Function & Nesting Detector (`septum_get_symbol_hotspots`):** Surfaces oversized functions/methods ranked by physical lines, cyclomatic nesting depth, and composite risk score.
 - **Dynamic Topology (`septum_register_domain`):** Registers or updates domains and boundary rules on-the-fly.
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "septum",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Deterministic Bounded-Context, Structural File Catalog & Anti-Poisoning Partition for AI Agents",
   "type": "module",
   "main": "src/index.ts",

package/src/cli/commands/slice.ts

@@ -20,57 +20,15 @@ export async function handleSliceCommand(
       return;
     }
 
-    if (result.found && result.slice) {
-      const s = result.slice;
-      console.log(`\n=================================================`);
-      console.log(`  VERTICAL SLICE: ${s.route.method} ${s.route.uri}`);
-      console.log(`=================================================`);
-      if (s.route.name) {
-        console.log(`  • Route Name:   ${s.route.name}`);
-      }
-
-      if (s.request) {
-        console.log(`\n  • Request Validation:`);
-        console.log(`      Class: ${s.request.class} (${s.request.file || "inline"})`);
-        const rules = Object.keys(s.request.rules);
-        if (rules.length > 0) {
-          console.log(`      Rules:`);
-          for (const r of rules) {
-            console.log(`        - ${r}: ${s.request.rules[r]}`);
-          }
-        }
-      }
-
-      console.log(`\n  • Controller Action:`);
-      console.log(`      Class:  ${s.controller.class}@${s.controller.action}`);
-      console.log(`      Target: ${s.controller.file || "unknown"}:${s.controller.line}`);
-
-      if (s.model) {
-        console.log(`\n  • Model:`);
-        console.log(`      Class:    ${s.model.class} (${s.model.file || "unknown"})`);
-        if (s.model.fillable && s.model.fillable.length > 0) {
-          console.log(`      Fillable: [${s.model.fillable.join(", ")}]`);
-        }
-        if (s.model.casts && Object.keys(s.model.casts).length > 0) {
-          console.log(`      Casts:    ${JSON.stringify(s.model.casts)}`);
-        }
-      }
-
-      if (s.frontend) {
-        console.log(`\n  • Frontend Target:`);
-        console.log(`      Page:  ${s.frontend.target}`);
-        if (s.frontend.props.length > 0) {
-          console.log(`      Props: [${s.frontend.props.join(", ")}]`);
-        }
-      }
-
+    if (result.found) {
+      console.log(`\n${result.message}\n`);
       if (result.alternatives && result.alternatives.length > 0) {
-        console.log(`\n  • Alternative Matches:`);
+        console.log(`  • Alternative Matches:`);
         for (const alt of result.alternatives) {
           console.log(`      - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}`);
         }
+        console.log(``);
       }
-      console.log(`\n=================================================\n`);
     } else {
       console.log(`\n❌ Vertical Slice Not Found:`);
       console.log(`   Query:   ${result.query}`);

package/src/cli/commands/topology.ts

@@ -0,0 +1,119 @@
+import { SeptumDatabase } from "../../core/database/client.ts";
+import { SeptumRepository } from "../../core/database/repository.ts";
+import { EnvironmentDetector } from "../../core/topology/environment-detector.ts";
+import type { EnvironmentLayer, TopologyNode } from "../../core/topology/types.ts";
+
+export async function handleTopologyCommand(
+  subcommand?: string,
+  arg1?: string,
+  arg2?: string,
+  arg3?: string,
+  arg4?: string
+): Promise<void> {
+  const cwd = process.cwd();
+  const db = new SeptumDatabase();
+  const repo = new SeptumRepository(db.raw);
+
+  if (subcommand === "resolve" && arg1 && arg2) {
+    const layer = arg1.toLowerCase() as EnvironmentLayer;
+    const platform = arg2;
+    // Fix: Preserve existing constraints instead of overwriting with empty array
+    const existing = repo.environment.getLayer(layer);
+    repo.environment.saveLayer({
+      layer,
+      platform,
+      canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
+      status: "VERIFIED",
+      detected_from: ["CLI Manual Resolution"],
+      constraints: existing?.constraints && existing.constraints.length > 0 ? existing.constraints : [
+        `Configured manually as '${platform}'.`
+      ],
+    });
+    console.log(`[Septum Topology] Layer '${layer}' successfully verified as '${platform}' in SQLite SSOT.\n`);
+  } else if (subcommand === "add-node" && arg1 && arg2 && arg3) {
+    const nodeId = arg1;
+    const layer = arg2.toLowerCase() as EnvironmentLayer;
+    const platform = arg3;
+    const domainOrIp = arg4;
+
+    const node: TopologyNode = {
+      id: nodeId,
+      layer,
+      name: nodeId,
+      platform,
+      canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
+      domain_or_ip: domainOrIp,
+      status: "VERIFIED",
+      detected_from: ["CLI Manual Node Resolution"],
+      constraints: [`Node added manually with platform '${platform}'.`],
+    };
+    repo.environment.saveNode(node);
+    console.log(`[Septum Topology] Node '${nodeId}' (${layer.toUpperCase()}) added to distributed topology graph.\n`);
+  } else if (subcommand === "remove-node" && arg1) {
+    repo.environment.deleteNode(arg1);
+    console.log(`[Septum Topology] Node '${arg1}' removed from distributed topology graph.\n`);
+  } else if (subcommand === "clear") {
+    repo.environment.clearAll();
+    console.log("[Septum Topology] Cleared environment topology and nodes in SQLite SSOT.\n");
+  }
+
+  const topology = EnvironmentDetector.detect(cwd, repo);
+
+  console.log("================================================================================");
+  console.log("🌐 SEPTUM SELF-AWARE ENVIRONMENT TOPOLOGY PLANE");
+  console.log("================================================================================");
+  console.log(`Overall Status:   ${topology.overall_status}`);
+  console.log(`Topology Mode:    ${topology.is_distributed ? "DISTRIBUTED MULTI-NODE GRAPH" : "MONOLITHIC SINGLE-NODE"}`);
+  console.log(`Summary:          ${topology.architectural_summary}\n`);
+
+  if (topology.nodes.length > 0) {
+    console.log("--- DISTRIBUTED TOPOLOGY NODES ---");
+    for (const node of topology.nodes) {
+      const statusIcon = node.status === "VERIFIED" ? "✓ [VERIFIED]" : node.status === "DETECTED" ? "• [DETECTED]" : "? [AMBIGUOUS]";
+      const domainStr = node.domain_or_ip ? ` @ ${node.domain_or_ip}` : "";
+      const roleStr = node.role ? ` [Role: ${node.role}]` : "";
+      console.log(`  ${statusIcon} ${node.id.padEnd(20)} (${node.layer.toUpperCase()}): ${node.platform}${domainStr}${roleStr}`);
+      if (node.connected_to && node.connected_to.length > 0) {
+        console.log(`      ➔ Connected to: ${node.connected_to.join(", ")}`);
+      }
+      if (node.constraints && node.constraints.length > 0) {
+        for (const c of node.constraints) {
+          console.log(`      - ${c}`);
+        }
+      }
+    }
+    console.log("");
+  }
+
+  console.log("--- 6-LAYER PRODUCTION SUMMARY PLANE ---");
+  for (const [layerKey, info] of Object.entries(topology.layers)) {
+    const statusIcon = info.status === "VERIFIED" ? "✓ [VERIFIED]" : info.status === "DETECTED" ? "• [DETECTED]" : "? [AMBIGUOUS]";
+    console.log(`  ${statusIcon} ${layerKey.toUpperCase().padEnd(10)}: ${info.platform || "Unresolved"}`);
+  }
+
+  if (topology.interplays.length > 0) {
+    console.log("\n--- CROSS-LAYER & DISTRIBUTED INVARIANTS ---");
+    for (const interplay of topology.interplays) {
+      console.log(`  ⚡ ${interplay.title} (${interplay.involved_layers.join(" ➔ ")})`);
+      console.log(`     Rule:   ${interplay.risk_or_rule}`);
+      console.log(`     Action: ${interplay.required_action}`);
+    }
+  }
+
+  if (topology.pending_inquiries.length > 0) {
+    console.log("\n--- PENDING ARCHITECTURAL INQUIRIES ---");
+    console.log("Action Required: Please clarify these ambiguous layers/nodes for your AI Agent:\n");
+    for (const inquiry of topology.pending_inquiries) {
+      console.log(`  ❓ ${inquiry}`);
+    }
+    console.log("\nTip: To resolve an inquiry or add distributed nodes, run:");
+    console.log("  septum topology resolve <layer> \"<Platform Name>\"");
+    console.log("  septum topology add-node <id> <layer> \"<Platform Name>\" [domain_or_ip]");
+    console.log("Example:");
+    console.log("  septum topology add-node host:vps-worker host \"Ubuntu 24.04 (Dedicated Worker)\" 10.0.0.6");
+  }
+
+  console.log("================================================================================\n");
+
+  db.close();
+}

package/src/cli/index.ts

@@ -5,6 +5,7 @@ import { handleCheckCommand } from "./commands/check.ts";
 import { handleHookCommand } from "./commands/hook.ts";
 import { handleIngestCommand } from "./commands/ingest.ts";
 import { handleInitCommand } from "./commands/init.ts";
+import { handleTopologyCommand } from "./commands/topology.ts";
 import { handleLocateCommand } from "./commands/locate.ts";
 import { handleQueryCommand } from "./commands/query.ts";
 import { handleServeCommand } from "./commands/serve.ts";
@@ -112,6 +113,12 @@ export async function runCLI(argv: string[]): Promise<void> {
         break;
       }
 
+      case "topology":
+      case "env": {
+        await handleTopologyCommand(positionals[1], positionals[2], positionals[3], positionals[4], positionals[5]);
+        break;
+      }
+
       case "feature": {
         const sub = positionals[1];
         if (sub === "clear") {
@@ -188,6 +195,10 @@ COMMANDS:
     feature [status|clear] View or release active feature context session lock
     hook [subhook]        Internal pre-tool guardrail hook (e.g. pre-write)
 
+  Environment & Topology:
+    topology [action]     Inspect 6-layer environment topology & distributed nodes
+                          Subcommands: resolve <layer> <platform>, add-node, remove-node, clear
+
   Daemon & Protocol:
     serve                 Start Model Context Protocol (MCP) server over stdio
 

package/src/core/database/repositories/environment.repository.ts

@@ -0,0 +1,207 @@
+import type { Database } from "bun:sqlite";
+import type { CanonicalPlatformTag, EnvironmentLayer, EnvironmentLayerInfo, TopologyNode } from "../../topology/types.ts";
+
+export class EnvironmentRepository {
+  constructor(private db: Database) {}
+
+  public getLayer(layer: EnvironmentLayer): EnvironmentLayerInfo | null {
+    const row = this.db
+      .query<{
+        layer: string;
+        platform: string | null;
+        status: string;
+        detected_from_json: string;
+        constraints_json: string;
+        unresolved_inquiry: string | null;
+      }, [string]>("SELECT * FROM environment_topology WHERE layer = ?")
+      .get(layer);
+
+    if (!row) return null;
+    return {
+      layer: row.layer as EnvironmentLayer,
+      platform: row.platform ?? undefined,
+      status: row.status as any,
+      detected_from: JSON.parse(row.detected_from_json || "[]"),
+      constraints: JSON.parse(row.constraints_json || "[]"),
+      unresolved_inquiry: row.unresolved_inquiry ?? undefined,
+    };
+  }
+
+  public getAllLayers(): Record<EnvironmentLayer, EnvironmentLayerInfo> {
+    const rows = this.db
+      .query<{
+        layer: string;
+        platform: string | null;
+        status: string;
+        detected_from_json: string;
+        constraints_json: string;
+        unresolved_inquiry: string | null;
+      }, []>("SELECT * FROM environment_topology")
+      .all();
+
+    const result: Partial<Record<EnvironmentLayer, EnvironmentLayerInfo>> = {};
+    for (const row of rows) {
+      result[row.layer as EnvironmentLayer] = {
+        layer: row.layer as EnvironmentLayer,
+        platform: row.platform ?? undefined,
+        status: row.status as any,
+        detected_from: JSON.parse(row.detected_from_json || "[]"),
+        constraints: JSON.parse(row.constraints_json || "[]"),
+        unresolved_inquiry: row.unresolved_inquiry ?? undefined,
+      };
+    }
+    return result as Record<EnvironmentLayer, EnvironmentLayerInfo>;
+  }
+
+  public saveLayer(info: EnvironmentLayerInfo): void {
+    this.db
+      .query(
+        `INSERT INTO environment_topology (
+          layer, platform, status, detected_from_json, constraints_json, unresolved_inquiry, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(layer) DO UPDATE SET
+          platform = excluded.platform,
+          status = excluded.status,
+          detected_from_json = excluded.detected_from_json,
+          constraints_json = excluded.constraints_json,
+          unresolved_inquiry = excluded.unresolved_inquiry,
+          updated_at = CURRENT_TIMESTAMP`
+      )
+      .run(
+        info.layer,
+        info.platform ?? null,
+        info.status,
+        JSON.stringify(info.detected_from ?? []),
+        JSON.stringify(info.constraints ?? []),
+        info.unresolved_inquiry ?? null
+      );
+  }
+
+  public clearAll(): void {
+    this.db.run("DELETE FROM environment_topology");
+    this.db.run("DELETE FROM environment_nodes");
+  }
+
+  // Node CRUD operations for Multi-Node Topology
+  public getNode(id: string): TopologyNode | null {
+    const row = this.db
+      .query<{
+        id: string;
+        layer: string;
+        name: string;
+        platform: string;
+        canonical_tag: string;
+        domain_or_ip: string | null;
+        role: string | null;
+        status: string;
+        detected_from_json: string;
+        constraints_json: string;
+        connected_to_json: string;
+        unresolved_inquiry: string | null;
+      }, [string]>("SELECT * FROM environment_nodes WHERE id = ?")
+      .get(id);
+
+    if (!row) return null;
+    return this.mapNodeRow(row);
+  }
+
+  public getAllNodes(): TopologyNode[] {
+    const rows = this.db
+      .query<{
+        id: string;
+        layer: string;
+        name: string;
+        platform: string;
+        canonical_tag: string;
+        domain_or_ip: string | null;
+        role: string | null;
+        status: string;
+        detected_from_json: string;
+        constraints_json: string;
+        connected_to_json: string;
+        unresolved_inquiry: string | null;
+      }, []>("SELECT * FROM environment_nodes ORDER BY layer, id")
+      .all();
+
+    return rows.map((r) => this.mapNodeRow(r));
+  }
+
+  public getNodesByLayer(layer: EnvironmentLayer): TopologyNode[] {
+    const rows = this.db
+      .query<{
+        id: string;
+        layer: string;
+        name: string;
+        platform: string;
+        canonical_tag: string;
+        domain_or_ip: string | null;
+        role: string | null;
+        status: string;
+        detected_from_json: string;
+        constraints_json: string;
+        connected_to_json: string;
+        unresolved_inquiry: string | null;
+      }, [string]>("SELECT * FROM environment_nodes WHERE layer = ? ORDER BY id")
+      .all(layer);
+
+    return rows.map((r) => this.mapNodeRow(r));
+  }
+
+  public saveNode(node: TopologyNode): void {
+    this.db
+      .query(
+        `INSERT INTO environment_nodes (
+          id, layer, name, platform, canonical_tag, domain_or_ip, role, status,
+          detected_from_json, constraints_json, connected_to_json, unresolved_inquiry, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(id) DO UPDATE SET
+          layer = excluded.layer,
+          name = excluded.name,
+          platform = excluded.platform,
+          canonical_tag = excluded.canonical_tag,
+          domain_or_ip = excluded.domain_or_ip,
+          role = excluded.role,
+          status = excluded.status,
+          detected_from_json = excluded.detected_from_json,
+          constraints_json = excluded.constraints_json,
+          connected_to_json = excluded.connected_to_json,
+          unresolved_inquiry = excluded.unresolved_inquiry,
+          updated_at = CURRENT_TIMESTAMP`
+      )
+      .run(
+        node.id,
+        node.layer,
+        node.name,
+        node.platform,
+        node.canonical_tag || "unspecified",
+        node.domain_or_ip ?? null,
+        node.role ?? null,
+        node.status,
+        JSON.stringify(node.detected_from ?? []),
+        JSON.stringify(node.constraints ?? []),
+        JSON.stringify(node.connected_to ?? []),
+        node.unresolved_inquiry ?? null
+      );
+  }
+
+  public deleteNode(id: string): void {
+    this.db.query("DELETE FROM environment_nodes WHERE id = ?").run(id);
+  }
+
+  private mapNodeRow(row: any): TopologyNode {
+    return {
+      id: row.id,
+      layer: row.layer as EnvironmentLayer,
+      name: row.name,
+      platform: row.platform,
+      canonical_tag: (row.canonical_tag as CanonicalPlatformTag) || "unspecified",
+      domain_or_ip: row.domain_or_ip ?? undefined,
+      role: row.role ?? undefined,
+      status: row.status as any,
+      detected_from: JSON.parse(row.detected_from_json || "[]"),
+      constraints: JSON.parse(row.constraints_json || "[]"),
+      connected_to: JSON.parse(row.connected_to_json || "[]"),
+      unresolved_inquiry: row.unresolved_inquiry ?? undefined,
+    };
+  }
+}

package/src/core/database/repositories/symbol.repository.ts

@@ -17,12 +17,13 @@ export class SymbolRepository {
     if (symbols.length === 0) return;
 
     const stmt = this.db.query(
-      `INSERT INTO symbols (file_id, name, kind, signature, visibility, line_start, line_end, line_count) 
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      `INSERT INTO symbols (file_id, name, kind, signature, visibility, line_start, line_end, line_count, nesting_depth) 
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
     );
 
     for (const sym of symbols) {
       const lineCount = sym.line_count ?? Math.max(1, sym.line_end - sym.line_start + 1);
+      const nestingDepth = sym.nesting_depth ?? 1;
       stmt.run(
         fileId,
         sym.name,
@@ -31,7 +32,8 @@ export class SymbolRepository {
         sym.visibility,
         sym.line_start,
         sym.line_end,
-        lineCount
+        lineCount,
+        nestingDepth
       );
     }
   }
@@ -98,6 +100,7 @@ export class SymbolRepository {
           line_start: r.line_start,
           line_end: r.line_end,
           line_count: r.line_count ?? (r.line_end - r.line_start + 1),
+          nesting_depth: r.nesting_depth ?? 1,
         },
       }));
     }
@@ -225,12 +228,16 @@ export class SymbolRepository {
 
   public getHotspotSymbols(options: {
     minLines?: number;
+    minNesting?: number;
     kind?: SymbolKind;
     domain?: string;
     limit?: number;
-  } = {}): Array<SymbolRecord & { file_path: string; domain_name: string }> {
-    const minLines = options.minLines ?? 30;
+    sortBy?: "lines" | "nesting" | "risk_score";
+  } = {}): Array<SymbolRecord & { file_path: string; domain_name: string; risk_score: number }> {
+    const minLines = options.minLines ?? 0;
+    const minNesting = options.minNesting ?? 1;
     const limit = options.limit ?? 50;
+    const sortBy = options.sortBy ?? "risk_score";
 
     let sql = `
       SELECT 
@@ -243,15 +250,16 @@ export class SymbolRepository {
         s.line_start,
         s.line_end,
         s.line_count,
+        s.nesting_depth,
         f.path AS file_path,
         d.name AS domain_name
       FROM symbols s
       JOIN files f ON s.file_id = f.id
       JOIN domains d ON f.domain_id = d.id
-      WHERE s.line_count >= ?
+      WHERE s.line_count >= ? AND s.nesting_depth >= ?
     `;
 
-    const params: any[] = [minLines];
+    const params: any[] = [minLines, minNesting];
 
     if (options.kind) {
       sql += " AND s.kind = ?";
@@ -263,10 +271,21 @@ export class SymbolRepository {
       params.push(options.domain);
     }
 
-    sql += " ORDER BY s.line_count DESC, s.name ASC LIMIT ?";
+    if (sortBy === "nesting") {
+      sql += " ORDER BY s.nesting_depth DESC, s.line_count DESC, s.name ASC LIMIT ?";
+    } else if (sortBy === "lines") {
+      sql += " ORDER BY s.line_count DESC, s.nesting_depth DESC, s.name ASC LIMIT ?";
+    } else {
+      sql += " ORDER BY (s.line_count * (1.0 + s.nesting_depth * 0.3)) DESC, s.nesting_depth DESC, s.name ASC LIMIT ?";
+    }
     params.push(limit);
 
-    return this.db.query<any, any[]>(sql).all(...params);
+    const rows = this.db.query<any, any[]>(sql).all(...params);
+    return rows.map((r) => ({
+      ...r,
+      nesting_depth: r.nesting_depth ?? 1,
+      risk_score: Math.round((r.line_count ?? 1) * (1.0 + (r.nesting_depth ?? 1) * 0.3)),
+    }));
   }
 
   public getSymbolDetails(

package/src/core/database/repository.ts

@@ -32,6 +32,7 @@ export type {
 } from "../../types/index.ts";
 import { DependencyRepository } from "./repositories/dependency.repository.ts";
 import { DomainRepository } from "./repositories/domain.repository.ts";
+import { EnvironmentRepository } from "./repositories/environment.repository.ts";
 import { FileRepository } from "./repositories/file.repository.ts";
 import { MetaRepository } from "./repositories/meta.repository.ts";
 import { SymbolRepository } from "./repositories/symbol.repository.ts";
@@ -44,6 +45,7 @@ export class SeptumRepository {
   public readonly symbols: SymbolRepository;
   public readonly dependencies: DependencyRepository;
   public readonly meta: MetaRepository;
+  public readonly environment: EnvironmentRepository;
 
   constructor(private db: Database) {
     this.domains = new DomainRepository(db);
@@ -51,6 +53,7 @@ export class SeptumRepository {
     this.symbols = new SymbolRepository(db);
     this.dependencies = new DependencyRepository(db);
     this.meta = new MetaRepository(db);
+    this.environment = new EnvironmentRepository(db);
   }
 
   public runInTransaction<T>(fn: () => T): T {
@@ -212,10 +215,12 @@ export class SeptumRepository {
 
   public getHotspotSymbols(options: {
     minLines?: number;
+    minNesting?: number;
     kind?: SymbolKind;
     domain?: string;
     limit?: number;
-  } = {}): Array<SymbolRecord & { file_path: string; domain_name: string }> {
+    sortBy?: "lines" | "nesting" | "risk_score";
+  } = {}): Array<SymbolRecord & { file_path: string; domain_name: string; risk_score: number }> {
     return this.symbols.getHotspotSymbols(options);
   }