@tyroneross/navgator 0.2.2 → 0.9.0

package/web/.next/standalone/web/app/api/rules/route.ts

@@ -0,0 +1,213 @@
+/**
+ * API Route: /api/rules
+ *
+ * Runs architecture rules against stored components/connections.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { RulesApiResponse, RuleViolation } from "@/lib/types";
+
+/**
+ * GET /api/rules
+ */
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const projectPath = searchParams.get("path");
+
+  try {
+    const root =
+      projectPath ||
+      process.env.NAVGATOR_PROJECT_PATH ||
+      process.cwd().replace(/\/web$/, "");
+
+    const componentsDir = path.join(root, ".navgator", "architecture", "components");
+    const connectionsDir = path.join(root, ".navgator", "architecture", "connections");
+
+    // Load components
+    const components = await loadJsonDir(componentsDir);
+    const connections = await loadJsonDir(connectionsDir);
+
+    if (components.length === 0) {
+      return NextResponse.json<RulesApiResponse>({
+        success: true,
+        data: {
+          violations: [],
+          summary: { total: 0, errors: 0, warnings: 0, info: 0 },
+        },
+        source: "scan",
+      });
+    }
+
+    // Run rules inline (avoid importing from src which needs compilation)
+    const violations = runBuiltinRules(components, connections);
+
+    return NextResponse.json<RulesApiResponse>({
+      success: true,
+      data: {
+        violations,
+        summary: {
+          total: violations.length,
+          errors: violations.filter((v) => v.severity === "error").length,
+          warnings: violations.filter((v) => v.severity === "warning").length,
+          info: violations.filter((v) => v.severity === "info").length,
+        },
+      },
+      source: "scan",
+    });
+  } catch (error) {
+    console.error("Error running rules:", error);
+    return NextResponse.json<RulesApiResponse>({
+      success: false,
+      data: {
+        violations: [],
+        summary: { total: 0, errors: 0, warnings: 0, info: 0 },
+      },
+      error: error instanceof Error ? error.message : "Unknown error",
+      source: "scan",
+    });
+  }
+}
+
+async function loadJsonDir(dir: string): Promise<Record<string, unknown>[]> {
+  try {
+    const files = await fs.readdir(dir);
+    const results: Record<string, unknown>[] = [];
+    for (const file of files.filter((f) => f.endsWith(".json"))) {
+      try {
+        const content = await fs.readFile(path.join(dir, file), "utf-8");
+        results.push(JSON.parse(content));
+      } catch {
+        // Skip invalid files
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Run built-in rules against raw component/connection JSON.
+ * This mirrors the rules in src/rules.ts but works on raw JSON objects
+ * so we don't need to import from the CLI build.
+ */
+function runBuiltinRules(
+  components: Record<string, unknown>[],
+  connections: Record<string, unknown>[]
+): RuleViolation[] {
+  const violations: RuleViolation[] = [];
+
+  // Helper to get nested values
+  const getLayer = (c: Record<string, unknown>) =>
+    (c.role as Record<string, unknown> | undefined)?.layer as string | undefined;
+  const getId = (c: Record<string, unknown>) => String(c.component_id || "");
+  const getName = (c: Record<string, unknown>) => String(c.name || "?");
+  const getStatus = (c: Record<string, unknown>) => String(c.status || "active");
+  const getFromId = (c: Record<string, unknown>) =>
+    String((c.from as Record<string, unknown> | undefined)?.component_id || "");
+  const getToId = (c: Record<string, unknown>) =>
+    String((c.to as Record<string, unknown> | undefined)?.component_id || "");
+
+  // Rule: Orphan components (0 connections)
+  const connectedIds = new Set<string>();
+  for (const conn of connections) {
+    connectedIds.add(getFromId(conn));
+    connectedIds.add(getToId(conn));
+  }
+  for (const comp of components) {
+    if (!connectedIds.has(getId(comp))) {
+      violations.push({
+        rule_id: "orphan-component",
+        severity: "warning",
+        component: getName(comp),
+        message: `${getName(comp)} has no connections — may be unused or untracked`,
+        suggestion: "Verify this component is used, or remove it if not needed",
+      });
+    }
+  }
+
+  // Rule: Frontend direct DB access
+  const frontendIds = new Set(
+    components.filter((c) => getLayer(c) === "frontend").map(getId)
+  );
+  const dbIds = new Set(
+    components.filter((c) => getLayer(c) === "database").map(getId)
+  );
+  const compMap = new Map(components.map((c) => [getId(c), c]));
+
+  for (const conn of connections) {
+    if (frontendIds.has(getFromId(conn)) && dbIds.has(getToId(conn))) {
+      const from = compMap.get(getFromId(conn));
+      const to = compMap.get(getToId(conn));
+      violations.push({
+        rule_id: "frontend-direct-db",
+        severity: "error",
+        component: from ? getName(from) : undefined,
+        message: `${from ? getName(from) : "?"} (frontend) connects directly to ${to ? getName(to) : "?"} (database)`,
+        suggestion: "Add a backend API layer between frontend and database",
+      });
+    }
+  }
+
+  // Rule: Unused packages
+  for (const comp of components) {
+    if (getStatus(comp) === "unused") {
+      violations.push({
+        rule_id: "unused-package",
+        severity: "info",
+        component: getName(comp),
+        message: `${getName(comp)} is detected but unused`,
+        suggestion: `Remove with: npm uninstall ${getName(comp)}`,
+      });
+    }
+  }
+
+  // Rule: Vulnerable dependencies
+  for (const comp of components) {
+    if (getStatus(comp) === "vulnerable") {
+      violations.push({
+        rule_id: "vulnerable-dependency",
+        severity: "error",
+        component: getName(comp),
+        message: `${getName(comp)} has known security vulnerabilities`,
+        suggestion: "Run npm audit fix or update to a patched version",
+      });
+    }
+  }
+
+  // Rule: Deprecated dependencies
+  for (const comp of components) {
+    if (getStatus(comp) === "deprecated") {
+      violations.push({
+        rule_id: "deprecated-dependency",
+        severity: "warning",
+        component: getName(comp),
+        message: `${getName(comp)} is deprecated`,
+        suggestion: "Find a replacement package before it becomes unmaintained",
+      });
+    }
+  }
+
+  // Rule: Single point of failure (>5 dependents)
+  const dependentCounts = new Map<string, number>();
+  for (const conn of connections) {
+    const toId = getToId(conn);
+    dependentCounts.set(toId, (dependentCounts.get(toId) || 0) + 1);
+  }
+  for (const comp of components) {
+    const id = getId(comp);
+    if (getLayer(comp) === "backend" && (dependentCounts.get(id) || 0) > 5) {
+      violations.push({
+        rule_id: "single-point-of-failure",
+        severity: "warning",
+        component: getName(comp),
+        message: `${getName(comp)} has ${dependentCounts.get(id)} dependents — single point of failure`,
+        suggestion: "Consider adding redundancy or splitting responsibilities",
+      });
+    }
+  }
+
+  return violations;
+}

package/web/.next/standalone/web/app/api/settings/route.ts

@@ -1,7 +1,7 @@
 /**
  * API Route: /api/settings
  *
- * Loads and saves NavGator settings to .claude/settings.json
+ * Loads and saves NavGator settings to .navgator/settings.json
  */
 
 import { NextRequest, NextResponse } from "next/server";
@@ -94,7 +94,7 @@ function getSettingsPath(projectPath?: string | null): string {
     projectPath ||
     process.env.NAVGATOR_PROJECT_PATH ||
     process.cwd().replace(/\/web$/, "");
-  return path.join(root, ".claude", "settings.json");
+  return path.join(root, ".navgator", "settings.json");
 }
 
 async function loadSettings(

package/web/.next/standalone/web/app/api/status/route.ts

@@ -73,7 +73,7 @@ async function loadStatusData(projectPath?: string | null): Promise<ProjectStatu
   const root = projectPath ||
     process.env.NAVGATOR_PROJECT_PATH ||
     process.cwd().replace(/\/web$/, "");
-  const indexPath = path.join(root, ".claude", "architecture", "index.json");
+  const indexPath = path.join(root, ".navgator", "architecture", "index.json");
 
   try {
     const content = await fs.readFile(indexPath, "utf-8");

package/web/.next/standalone/web/app/api/subgraph/route.ts

@@ -0,0 +1,267 @@
+/**
+ * API Route: /api/subgraph
+ *
+ * Extracts a focused subgraph from the architecture.
+ * Mirrors src/subgraph.ts logic but works on raw JSON files.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { SubgraphApiResponse, SubgraphResult } from "@/lib/types";
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const focus = searchParams.get("focus");
+  const depth = Math.min(parseInt(searchParams.get("depth") || "2", 10), 5);
+  const layers = searchParams.get("layers");
+  const classification = searchParams.get("classification") || undefined;
+  const maxNodes = Math.min(
+    parseInt(searchParams.get("maxNodes") || "50", 10),
+    200
+  );
+  const projectPath = searchParams.get("path");
+
+  try {
+    const root =
+      projectPath ||
+      process.env.NAVGATOR_PROJECT_PATH ||
+      process.cwd().replace(/\/web$/, "");
+
+    const componentsDir = path.join(root, ".navgator", "architecture", "components");
+    const connectionsDir = path.join(root, ".navgator", "architecture", "connections");
+
+    const components = await loadJsonDir(componentsDir);
+    const connections = await loadJsonDir(connectionsDir);
+
+    if (components.length === 0) {
+      return NextResponse.json<SubgraphApiResponse>({
+        success: true,
+        data: {
+          components: [],
+          connections: [],
+          stats: { nodes: 0, edges: 0 },
+        },
+        source: "scan",
+      });
+    }
+
+    const focusList = focus
+      ? focus.split(",").map((s) => s.trim()).filter(Boolean)
+      : [];
+    const layerList = layers
+      ? layers.split(",").map((s) => s.trim()).filter(Boolean)
+      : [];
+
+    const result = extractSubgraphInline(components, connections, {
+      focus: focusList,
+      layers: layerList,
+      classification,
+      depth,
+      maxNodes,
+    });
+
+    return NextResponse.json<SubgraphApiResponse>({
+      success: true,
+      data: result,
+      source: "scan",
+    });
+  } catch (error) {
+    console.error("Error extracting subgraph:", error);
+    return NextResponse.json<SubgraphApiResponse>({
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      source: "scan",
+    });
+  }
+}
+
+async function loadJsonDir(dir: string): Promise<Record<string, unknown>[]> {
+  try {
+    const files = await fs.readdir(dir);
+    const results: Record<string, unknown>[] = [];
+    for (const file of files.filter((f) => f.endsWith(".json"))) {
+      try {
+        const content = await fs.readFile(path.join(dir, file), "utf-8");
+        results.push(JSON.parse(content));
+      } catch {
+        // Skip invalid files
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+function getId(c: Record<string, unknown>): string {
+  return String(c.component_id || "");
+}
+function getName(c: Record<string, unknown>): string {
+  return String(c.name || "?");
+}
+function getType(c: Record<string, unknown>): string {
+  return String(c.type || "");
+}
+function getLayer(c: Record<string, unknown>): string {
+  return String((c.role as Record<string, unknown> | undefined)?.layer || "");
+}
+function getFromId(c: Record<string, unknown>): string {
+  return String((c.from as Record<string, unknown> | undefined)?.component_id || "");
+}
+function getToId(c: Record<string, unknown>): string {
+  return String((c.to as Record<string, unknown> | undefined)?.component_id || "");
+}
+function getConnId(c: Record<string, unknown>): string {
+  return String(c.connection_id || "");
+}
+function getConnType(c: Record<string, unknown>): string {
+  return String(c.type || "");
+}
+
+interface SubgraphOpts {
+  focus: string[];
+  layers: string[];
+  classification?: string;
+  depth: number;
+  maxNodes: number;
+}
+
+function extractSubgraphInline(
+  components: Record<string, unknown>[],
+  connections: Record<string, unknown>[],
+  opts: SubgraphOpts
+): SubgraphResult {
+  // Synthesize virtual components for FILE: references in connections
+  const allComponents = [...components];
+  const knownIds = new Set(components.map(getId));
+  for (const conn of connections) {
+    for (const refId of [getFromId(conn), getToId(conn)]) {
+      if (refId && !knownIds.has(refId) && refId.startsWith("FILE:")) {
+        const filePath = refId.slice(5);
+        const fileName = filePath.split("/").pop() || filePath;
+        allComponents.push({
+          component_id: refId,
+          name: fileName,
+          type: "file",
+          role: { layer: "application" },
+        });
+        knownIds.add(refId);
+      }
+    }
+  }
+
+  let filteredIds = new Set<string>();
+
+  if (opts.focus.length > 0) {
+    // Resolve focus names to component IDs
+    const focusIds = new Set<string>();
+    for (const query of opts.focus) {
+      const queryLower = query.toLowerCase();
+      const match =
+        allComponents.find((c) => getName(c).toLowerCase() === queryLower) ||
+        allComponents.find((c) => getName(c).toLowerCase().includes(queryLower));
+      if (match) focusIds.add(getId(match));
+    }
+
+    if (focusIds.size === 0) {
+      return {
+        components: [],
+        connections: [],
+        stats: { nodes: 0, edges: 0 },
+      };
+    }
+
+    // BFS from focus components
+    const visited = new Set<string>(focusIds);
+    let frontier = [...focusIds];
+
+    for (let d = 0; d < opts.depth; d++) {
+      const nextFrontier: string[] = [];
+      for (const id of frontier) {
+        for (const conn of connections) {
+          if (getFromId(conn) === id && !visited.has(getToId(conn))) {
+            visited.add(getToId(conn));
+            nextFrontier.push(getToId(conn));
+          }
+          if (getToId(conn) === id && !visited.has(getFromId(conn))) {
+            visited.add(getFromId(conn));
+            nextFrontier.push(getFromId(conn));
+          }
+        }
+      }
+      frontier = nextFrontier;
+    }
+
+    filteredIds = visited;
+  } else {
+    filteredIds = new Set(allComponents.map(getId));
+  }
+
+  // Layer filter
+  if (opts.layers.length > 0) {
+    const layerSet = new Set(opts.layers);
+    for (const id of [...filteredIds]) {
+      const comp = allComponents.find((c) => getId(c) === id);
+      if (comp && !layerSet.has(getLayer(comp))) {
+        filteredIds.delete(id);
+      }
+    }
+  }
+
+  // Filter connections
+  let filteredConns = connections.filter(
+    (c) => filteredIds.has(getFromId(c)) && filteredIds.has(getToId(c))
+  );
+
+  // Classification filter
+  if (opts.classification) {
+    filteredConns = filteredConns.filter((c) => {
+      const semantic = c.semantic as Record<string, unknown> | undefined;
+      return semantic?.classification === opts.classification;
+    });
+  }
+
+  // Apply maxNodes
+  const filteredComps = allComponents.filter((c) => filteredIds.has(getId(c)));
+  const limited = filteredComps.slice(0, opts.maxNodes);
+  const limitedIds = new Set(limited.map(getId));
+  const limitedConns = filteredConns.filter(
+    (c) => limitedIds.has(getFromId(c)) && limitedIds.has(getToId(c))
+  );
+
+  // Build compact output
+  const compactComponents = limited.map((c) => ({
+    id: getId(c),
+    n: getName(c),
+    t: getType(c),
+    l: getLayer(c),
+  }));
+  const compactConnections = limitedConns.map((c) => ({
+    id: getConnId(c),
+    f: getFromId(c),
+    t: getToId(c),
+    tp: getConnType(c),
+  }));
+
+  // Generate Mermaid
+  const mermaidLines = ["graph TD", ""];
+  for (const comp of compactComponents) {
+    const safeId = comp.id.replace(/[^a-zA-Z0-9_]/g, "_");
+    const safeName = comp.n.replace(/"/g, "'").slice(0, 40);
+    mermaidLines.push(`  ${safeId}["${safeName}"]`);
+  }
+  mermaidLines.push("");
+  for (const conn of compactConnections) {
+    const sourceId = conn.f.replace(/[^a-zA-Z0-9_]/g, "_");
+    const targetId = conn.t.replace(/[^a-zA-Z0-9_]/g, "_");
+    mermaidLines.push(`  ${sourceId} --> ${targetId}`);
+  }
+
+  return {
+    components: compactComponents,
+    connections: compactConnections,
+    stats: { nodes: compactComponents.length, edges: compactConnections.length },
+    mermaid: mermaidLines.join("\n"),
+  };
+}