@tyroneross/navgator 0.2.0 → 0.2.1

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

@@ -0,0 +1,221 @@
+/**
+ * API Route: /api/projects
+ *
+ * Manages the project registry at ~/.navgator/projects.json
+ * GET  - List all registered projects with validation
+ * POST - Register or remove a project
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+interface RegisteredProject {
+  path: string;
+  name: string;
+  addedAt: number;
+  lastScan: number | null;
+}
+
+interface ProjectRegistry {
+  version: 1;
+  projects: RegisteredProject[];
+}
+
+interface ProjectWithStatus extends RegisteredProject {
+  hasArchitecture: boolean;
+  componentCount: number;
+  connectionCount: number;
+  lastScanFormatted: string | null;
+}
+
+// =============================================================================
+// REGISTRY PATH
+// =============================================================================
+
+const REGISTRY_DIR = path.join(os.homedir(), ".navgator");
+const REGISTRY_PATH = path.join(REGISTRY_DIR, "projects.json");
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+async function loadRegistry(): Promise<ProjectRegistry> {
+  try {
+    const content = await fs.readFile(REGISTRY_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, projects: [] };
+  }
+}
+
+async function saveRegistry(registry: ProjectRegistry): Promise<void> {
+  await fs.mkdir(REGISTRY_DIR, { recursive: true });
+  await fs.writeFile(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
+}
+
+function extractProjectName(projectPath: string): string {
+  try {
+    const packageJsonPath = path.join(projectPath, "package.json");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const packageJson = require(packageJsonPath);
+    if (packageJson.name) {
+      return packageJson.name
+        .replace(/[-_]/g, " ")
+        .replace(/\b\w/g, (c: string) => c.toUpperCase())
+        .trim();
+    }
+  } catch {
+    // fall through
+  }
+  const segments = projectPath.split(path.sep).filter(Boolean);
+  return (segments[segments.length - 1] || "project")
+    .replace(/[-_]/g, " ")
+    .replace(/\b\w/g, (c: string) => c.toUpperCase())
+    .trim();
+}
+
+function formatRelativeTime(timestamp: number): string {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  if (hours < 24) return `${hours}h ago`;
+  if (days < 7) return `${days}d ago`;
+  return new Date(timestamp).toLocaleDateString();
+}
+
+async function enrichProject(project: RegisteredProject): Promise<ProjectWithStatus> {
+  const indexPath = path.join(project.path, ".claude", "architecture", "index.json");
+  try {
+    const content = await fs.readFile(indexPath, "utf-8");
+    const index = JSON.parse(content);
+    return {
+      ...project,
+      name: extractProjectName(project.path),
+      hasArchitecture: true,
+      componentCount: index.stats?.total_components || 0,
+      connectionCount: index.stats?.total_connections || 0,
+      lastScan: index.last_scan || project.lastScan,
+      lastScanFormatted: index.last_scan ? formatRelativeTime(index.last_scan) : null,
+    };
+  } catch {
+    return {
+      ...project,
+      hasArchitecture: false,
+      componentCount: 0,
+      connectionCount: 0,
+      lastScanFormatted: project.lastScan ? formatRelativeTime(project.lastScan) : null,
+    };
+  }
+}
+
+// =============================================================================
+// GET /api/projects
+// =============================================================================
+
+export async function GET() {
+  try {
+    const registry = await loadRegistry();
+
+    // Enrich each project with live status
+    const projects = await Promise.all(
+      registry.projects.map((p) => enrichProject(p))
+    );
+
+    return NextResponse.json({
+      success: true,
+      data: { projects },
+    });
+  } catch (error) {
+    console.error("Error loading projects:", error);
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : "Unknown error" },
+      { status: 500 }
+    );
+  }
+}
+
+// =============================================================================
+// POST /api/projects
+// =============================================================================
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { action, path: projectPath } = body as { action: "add" | "remove"; path: string };
+
+    if (!projectPath) {
+      return NextResponse.json(
+        { success: false, error: "Missing project path" },
+        { status: 400 }
+      );
+    }
+
+    const resolvedPath = path.resolve(projectPath);
+    const registry = await loadRegistry();
+
+    if (action === "add") {
+      // Check if directory exists
+      try {
+        await fs.access(resolvedPath);
+      } catch {
+        return NextResponse.json(
+          { success: false, error: `Directory not found: ${resolvedPath}` },
+          { status: 400 }
+        );
+      }
+
+      // Don't add duplicates
+      if (registry.projects.some((p) => p.path === resolvedPath)) {
+        return NextResponse.json({
+          success: true,
+          message: "Project already registered",
+        });
+      }
+
+      registry.projects.push({
+        path: resolvedPath,
+        name: extractProjectName(resolvedPath),
+        addedAt: Date.now(),
+        lastScan: null,
+      });
+
+      await saveRegistry(registry);
+
+      return NextResponse.json({
+        success: true,
+        message: `Registered ${resolvedPath}`,
+      });
+    }
+
+    if (action === "remove") {
+      registry.projects = registry.projects.filter((p) => p.path !== resolvedPath);
+      await saveRegistry(registry);
+
+      return NextResponse.json({
+        success: true,
+        message: `Removed ${resolvedPath}`,
+      });
+    }
+
+    return NextResponse.json(
+      { success: false, error: `Unknown action: ${action}` },
+      { status: 400 }
+    );
+  } catch (error) {
+    console.error("Error updating projects:", error);
+    return NextResponse.json(
+      { success: false, error: error instanceof Error ? error.message : "Unknown error" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,328 @@
+/**
+ * API Route: /api/prompts
+ *
+ * Returns LLM call and prompt data from NavGator scans.
+ * Supports both real scan data and demo mode.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs/promises";
+import * as path from "path";
+import {
+  transformScanResultWithDefaults,
+  generateDemoData,
+  type PromptScanResult,
+} from "@/lib/transform";
+import type { PromptsApiResponse } from "@/lib/types";
+
+const execAsync = promisify(exec);
+
+// Cache for scan results (keyed by project path)
+const promptsCache = new Map<string, { data: PromptsApiResponse["data"]; timestamp: number }>();
+const CACHE_TTL = 60000; // 1 minute cache
+
+/**
+ * GET /api/prompts
+ *
+ * Query params:
+ * - path: Project path to scan (optional, defaults to parent of web dir)
+ * - demo: If "true", returns demo data
+ * - refresh: If "true", bypasses cache
+ */
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const demoMode = searchParams.get("demo") === "true";
+  const refresh = searchParams.get("refresh") === "true";
+  const projectPath = searchParams.get("path");
+
+  // Demo mode - return synthetic data
+  if (demoMode) {
+    const demoData = generateDemoData();
+    return NextResponse.json<PromptsApiResponse>({
+      success: true,
+      data: demoData,
+      source: "mock",
+    });
+  }
+
+  const cacheKey = projectPath || "__default__";
+  const cached = promptsCache.get(cacheKey);
+
+  // Check cache
+  if (!refresh && cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return NextResponse.json<PromptsApiResponse>({
+      success: true,
+      data: cached.data,
+      source: "cache",
+    });
+  }
+
+  try {
+    // Try to load scan results from NavGator storage
+    const data = await loadScanData(projectPath);
+
+    if (data) {
+      promptsCache.set(cacheKey, { data, timestamp: Date.now() });
+
+      return NextResponse.json<PromptsApiResponse>({
+        success: true,
+        data,
+        source: "scan",
+      });
+    }
+
+    // No scan data available - check if user explicitly wants demo
+    if (demoMode) {
+      const demoData = generateDemoData();
+      return NextResponse.json<PromptsApiResponse>({
+        success: true,
+        data: demoData,
+        source: "mock",
+      });
+    }
+
+    // Return empty state - prompt user to run setup
+    return NextResponse.json<PromptsApiResponse>({
+      success: true,
+      data: {
+        calls: [],
+        prompts: [],
+        summary: {
+          totalCalls: 0,
+          totalPrompts: 0,
+          byProvider: {},
+          byModel: {},
+          byCategory: {},
+          templatesCount: 0,
+          withToolsCount: 0,
+        },
+      },
+      source: "scan",
+      error: "No scan data found. Run `navgator setup` to scan your project.",
+    });
+  } catch (error) {
+    console.error("Error loading prompt data:", error);
+
+    // Return empty state on error
+    return NextResponse.json<PromptsApiResponse>({
+      success: false,
+      data: {
+        calls: [],
+        prompts: [],
+        summary: {
+          totalCalls: 0,
+          totalPrompts: 0,
+          byProvider: {},
+          byModel: {},
+          byCategory: {},
+          templatesCount: 0,
+          withToolsCount: 0,
+        },
+      },
+      source: "scan",
+      error: error instanceof Error ? error.message : "Unknown error",
+    });
+  }
+}
+
+/**
+ * POST /api/prompts
+ *
+ * Trigger a new scan and return results
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const projectPath = body.path;
+
+    // Run NavGator scan
+    const scanResult = await runNavGatorScan(projectPath);
+
+    if (scanResult) {
+      const data = transformScanResultWithDefaults(scanResult);
+      const postCacheKey = projectPath || "__default__";
+      promptsCache.set(postCacheKey, { data, timestamp: Date.now() });
+
+      return NextResponse.json<PromptsApiResponse>({
+        success: true,
+        data,
+        source: "scan",
+      });
+    }
+
+    return NextResponse.json<PromptsApiResponse>(
+      {
+        success: false,
+        error: "Scan produced no results",
+        source: "scan",
+      },
+      { status: 500 }
+    );
+  } catch (error) {
+    console.error("Error running scan:", error);
+    return NextResponse.json<PromptsApiResponse>(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Scan failed",
+        source: "scan",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+// =============================================================================
+// DATA LOADING
+// =============================================================================
+
+async function loadScanData(
+  projectPath?: string | null
+): Promise<PromptsApiResponse["data"] | null> {
+  // Priority: query param > env var > NavGator directory
+  const root = projectPath ||
+    process.env.NAVGATOR_PROJECT_PATH ||
+    process.cwd().replace(/\/web$/, "");
+
+  // Try to load from NavGator storage
+  const storagePaths = [
+    path.join(root, ".claude", "architecture", "prompts.json"),
+    path.join(root, ".navgator", "prompts.json"),
+  ];
+
+  for (const storagePath of storagePaths) {
+    try {
+      const content = await fs.readFile(storagePath, "utf-8");
+      const scanResult: PromptScanResult = JSON.parse(content);
+      return transformScanResultWithDefaults(scanResult);
+    } catch {
+      // File doesn't exist or isn't valid JSON
+      continue;
+    }
+  }
+
+  // Try to load from component files
+  const componentsDir = path.join(root, ".claude", "architecture", "components");
+  try {
+    const files = await fs.readdir(componentsDir);
+    const promptFiles = files.filter((f) => f.includes("prompt") && f.endsWith(".json"));
+
+    if (promptFiles.length > 0) {
+      const prompts = await Promise.all(
+        promptFiles.map(async (file) => {
+          const content = await fs.readFile(path.join(componentsDir, file), "utf-8");
+          return JSON.parse(content);
+        })
+      );
+
+      // Convert component format to prompt format
+      const scanResult = componentsToScanResult(prompts);
+      return transformScanResultWithDefaults(scanResult);
+    }
+  } catch {
+    // Directory doesn't exist
+  }
+
+  return null;
+}
+
+async function runNavGatorScan(
+  projectPath?: string
+): Promise<PromptScanResult | null> {
+  // Priority: query param > env var > NavGator directory
+  const root = projectPath ||
+    process.env.NAVGATOR_PROJECT_PATH ||
+    process.cwd().replace(/\/web$/, "");
+
+  // Validate path to prevent command injection
+  if (!/^[a-zA-Z0-9._\s\/~-]+$/.test(root)) {
+    console.warn("Invalid project path, skipping CLI scan");
+    return null;
+  }
+
+  try {
+    // Try running navgator CLI
+    const { stdout } = await execAsync(
+      `cd "${root}" && npx navgator prompts --json`,
+      { timeout: 30000 }
+    );
+
+    return JSON.parse(stdout);
+  } catch (error) {
+    console.warn("NavGator CLI not available, trying direct scan...");
+
+    // Direct scan via built scanner is not available in Next.js context
+    // The scanner must be run via CLI: `navgator scan --prompts`
+    console.warn("Direct scan not available in web context. Use CLI: navgator scan --prompts");
+    return null;
+  }
+}
+
+// =============================================================================
+// CONVERSION HELPERS
+// =============================================================================
+
+interface ArchitectureComponent {
+  component_id: string;
+  name: string;
+  type: string;
+  metadata?: Record<string, unknown>;
+  source?: { config_files?: string[]; confidence?: number };
+  tags?: string[];
+  timestamp?: number;
+}
+
+function componentsToScanResult(
+  components: ArchitectureComponent[]
+): PromptScanResult {
+  const prompts = components
+    .filter((c) => c.type === "prompt")
+    .map((c) => ({
+      id: c.component_id,
+      name: c.name,
+      location: {
+        file: c.source?.config_files?.[0] || "unknown",
+        lineStart: 1,
+        lineEnd: 1,
+        functionName: c.name,
+      },
+      messages: [
+        {
+          role: "user" as const,
+          content: String(c.metadata?.userTemplate || c.metadata?.systemPrompt || ""),
+        },
+      ],
+      rawContent: String(c.metadata?.userTemplate || c.metadata?.systemPrompt || ""),
+      isTemplate: Boolean(c.metadata?.variables),
+      variables: ((c.metadata?.variables as string[]) || []).map((v) => ({
+        name: v,
+        pattern: `{{${v}}}`,
+      })),
+      provider: c.metadata?.provider
+        ? {
+            provider: c.metadata.provider as "openai" | "anthropic" | "unknown",
+            model: c.metadata.model as string | undefined,
+          }
+        : undefined,
+      usedBy: [],
+      purpose: c.metadata?.purpose as string | undefined,
+      tags: c.tags || [],
+      category: c.metadata?.category as PromptScanResult["prompts"][0]["category"],
+      confidence: c.source?.confidence || 0.8,
+      detectionMethod: "heuristic" as const,
+      timestamp: c.timestamp || Date.now(),
+    }));
+
+  return {
+    prompts,
+    summary: {
+      totalPrompts: prompts.length,
+      byProvider: {},
+      byCategory: {},
+      templatesCount: prompts.filter((p) => p.isTemplate).length,
+      withToolsCount: 0,
+    },
+    warnings: [],
+  };
+}

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

@@ -0,0 +1,108 @@
+/**
+ * API Route: /api/scan
+ *
+ * Triggers a NavGator scan and returns combined results.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+interface ScanResponse {
+  success: boolean;
+  message: string;
+  timestamp: string;
+  results?: {
+    components?: number;
+    connections?: number;
+    prompts?: number;
+  };
+  error?: string;
+}
+
+/**
+ * POST /api/scan
+ *
+ * Triggers a full NavGator scan
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}));
+    const projectPath = body.path || process.cwd().replace(/\/web$/, "");
+    const includePrompts = body.prompts !== false;
+
+    // Validate project path to prevent command injection
+    if (!/^[a-zA-Z0-9._\s\/~-]+$/.test(projectPath)) {
+      return NextResponse.json<ScanResponse>(
+        { success: false, message: "Invalid project path", timestamp: new Date().toISOString(), error: "Path contains invalid characters" },
+        { status: 400 }
+      );
+    }
+
+    // Build the scan command
+    let command = `cd "${projectPath}" && npx navgator scan`;
+    if (includePrompts) {
+      command += " --prompts";
+    }
+
+    // Run the scan
+    const { stdout, stderr } = await execAsync(command, { timeout: 60000 });
+
+    // Parse results from output
+    const componentMatch = stdout.match(/Components:\s*(\d+)/);
+    const connectionMatch = stdout.match(/Connections:\s*(\d+)/);
+    const promptMatch = stdout.match(/Prompts:\s*(\d+)/);
+
+    return NextResponse.json<ScanResponse>({
+      success: true,
+      message: "Scan completed successfully",
+      timestamp: new Date().toISOString(),
+      results: {
+        components: componentMatch ? parseInt(componentMatch[1]) : undefined,
+        connections: connectionMatch ? parseInt(connectionMatch[1]) : undefined,
+        prompts: promptMatch ? parseInt(promptMatch[1]) : undefined,
+      },
+    });
+  } catch (error) {
+    console.error("Scan error:", error);
+
+    return NextResponse.json<ScanResponse>(
+      {
+        success: false,
+        message: "Scan failed",
+        timestamp: new Date().toISOString(),
+        error: error instanceof Error ? error.message : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET /api/scan
+ *
+ * Returns scan status/health
+ */
+export async function GET() {
+  try {
+    const projectPath = process.cwd().replace(/\/web$/, "");
+
+    // Check if NavGator is available
+    const { stdout } = await execAsync(`cd "${projectPath}" && npx navgator --version`, {
+      timeout: 10000,
+    });
+
+    return NextResponse.json({
+      available: true,
+      version: stdout.trim(),
+      projectPath,
+    });
+  } catch {
+    return NextResponse.json({
+      available: false,
+      message: "NavGator CLI not available. Install with: npm install -g navgator",
+    });
+  }
+}