@mrpatronz/nexusflow 0.2.18 → 1.3.0

package/src/analyzers/detect-apis.ts

@@ -1,290 +0,0 @@
-/**
- * @module analyzers/detect-apis
- * Detects API endpoints in a repository by scanning for OpenAPI/Swagger files,
- * route patterns in common frameworks, and gRPC proto files.
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { globby } from 'globby';
-
-import type { ApiEndpoint } from '../types.js';
-
-/**
- * Detects API endpoints in a repository.
- *
- * Strategies (in order):
- * 1. Look for OpenAPI/Swagger spec files (JSON/YAML)
- * 2. Scan source files for Express/Fastify/ASP.NET route patterns
- * 3. Look for gRPC .proto files
- *
- * @param repoPath - Absolute path to the repository root.
- * @returns Array of detected {@link ApiEndpoint} objects.
- */
-export async function detectApis(repoPath: string): Promise<ApiEndpoint[]> {
-  const endpoints: ApiEndpoint[] = [];
-
-  // 1. OpenAPI/Swagger files
-  const openApiEndpoints = await scanOpenApiFiles(repoPath);
-  endpoints.push(...openApiEndpoints);
-
-  // 2. Route patterns in source files (only if no OpenAPI found)
-  if (endpoints.length === 0) {
-    const routeEndpoints = await scanRoutePatterns(repoPath);
-    endpoints.push(...routeEndpoints);
-  }
-
-  return endpoints;
-}
-
-/** Looks for OpenAPI/Swagger spec files and extracts paths. */
-async function scanOpenApiFiles(repoPath: string): Promise<ApiEndpoint[]> {
-  const candidates = [
-    'swagger.json', 'swagger.yaml', 'swagger.yml',
-    'openapi.json', 'openapi.yaml', 'openapi.yml',
-    'api-spec.json', 'api-spec.yaml', 'api-spec.yml',
-  ];
-
-  const endpoints: ApiEndpoint[] = [];
-
-  for (const filename of candidates) {
-    const filePath = path.join(repoPath, filename);
-    try {
-      const content = await fs.readFile(filePath, 'utf-8');
-
-      if (filename.endsWith('.json')) {
-        const spec = JSON.parse(content) as Record<string, unknown>;
-        const paths = spec.paths as Record<string, Record<string, unknown>> | undefined;
-
-        if (paths) {
-          for (const [routePath, methods] of Object.entries(paths)) {
-            for (const method of Object.keys(methods)) {
-              if (['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method)) {
-                endpoints.push({
-                  method: method.toUpperCase(),
-                  path: routePath,
-                  source: filename,
-                });
-              }
-            }
-          }
-        }
-      }
-    } catch {
-      // File doesn't exist or can't be parsed — skip
-    }
-  }
-
-  return endpoints;
-}
-
-/** Scans C# files for controllers and Minimal APIs. */
-function extractCsEndpoints(content: string, relPath: string): ApiEndpoint[] {
-  const endpoints: ApiEndpoint[] = [];
-
-  // 1. Controller style routing
-  const classRegex = /class\s+(\w+Controller)/gi;
-  const classes: { name: string; index: number }[] = [];
-  let classMatch: RegExpExecArray | null;
-  while ((classMatch = classRegex.exec(content)) !== null) {
-    classes.push({
-      name: classMatch[1],
-      index: classMatch.index,
-    });
-  }
-
-  const routeAttrRegex = /\[Route\s*\(\s*"([^"]*)"\s*\)\]/gi;
-  const classRoutes: { route: string; index: number }[] = [];
-  let routeMatch: RegExpExecArray | null;
-  while ((routeMatch = routeAttrRegex.exec(content)) !== null) {
-    classRoutes.push({
-      route: routeMatch[1],
-      index: routeMatch.index,
-    });
-  }
-
-  const versionAttrRegex = /\[ApiVersion\s*\(\s*["']?([^"'\s\)]+)["']?\s*\)\]/gi;
-  const apiVersions: { version: string; index: number }[] = [];
-  let versionMatch: RegExpExecArray | null;
-  while ((versionMatch = versionAttrRegex.exec(content)) !== null) {
-    apiVersions.push({
-      version: versionMatch[1],
-      index: versionMatch.index,
-    });
-  }
-
-  const controllerRoutes: {
-    route: string;
-    controllerName: string;
-    version?: string;
-    classIndex: number;
-  }[] = [];
-
-  for (const cr of classRoutes) {
-    const targetClass = classes.find(c => c.index > cr.index);
-    if (targetClass) {
-      const targetVersion = apiVersions.find(v => v.index > cr.index - 100 && v.index < targetClass.index);
-      controllerRoutes.push({
-        route: cr.route,
-        controllerName: targetClass.name,
-        version: targetVersion?.version,
-        classIndex: targetClass.index,
-      });
-    }
-  }
-
-  const httpAttrRegex = /\[Http(Get|Post|Put|Patch|Delete)(?:\s*\(\s*"([^"]*)"\s*\))?\]/gi;
-  let httpMatch: RegExpExecArray | null;
-  while ((httpMatch = httpAttrRegex.exec(content)) !== null) {
-    const method = httpMatch[1].toUpperCase();
-    const actionRoute = httpMatch[2] || '';
-    const index = httpMatch.index;
-
-    let matchedController = controllerRoutes[0];
-    for (const cr of controllerRoutes) {
-      if (cr.classIndex < index) {
-        matchedController = cr;
-      } else {
-        break;
-      }
-    }
-
-    let resolvedRoute = '';
-    if (matchedController) {
-      let baseRoute = matchedController.route;
-      const controllerBaseName = matchedController.controllerName.replace(/Controller$/i, '');
-      baseRoute = baseRoute.replace(/\[controller\]/gi, controllerBaseName);
-      
-      const ver = matchedController.version;
-      const verReplacement = ver ? 'v' + ver.split('.')[0] : 'v1';
-      baseRoute = baseRoute.replace(/\{version(:apiVersion)?\}/gi, verReplacement);
-
-      if (actionRoute) {
-        resolvedRoute = baseRoute.endsWith('/') || actionRoute.startsWith('/')
-          ? `${baseRoute}${actionRoute}`
-          : `${baseRoute}/${actionRoute}`;
-      } else {
-        resolvedRoute = baseRoute;
-      }
-    } else {
-      resolvedRoute = actionRoute;
-    }
-
-    resolvedRoute = resolvedRoute
-      .replace(/\/+/g, '/')
-      .replace(/:[a-zA-Z0-9\?]+/g, '');
-    
-    if (resolvedRoute && !resolvedRoute.startsWith('/')) {
-      resolvedRoute = '/' + resolvedRoute;
-    }
-
-    if (resolvedRoute) {
-      endpoints.push({
-        method,
-        path: resolvedRoute,
-        source: relPath,
-      });
-    }
-  }
-
-  // 2. Minimal API style routing
-  const groupRegex = /(?:const|var|let)?\s*(\w+)\s*=\s*(?:\w+)\.MapGroup\s*\(\s*"([^"]+)"/gi;
-  const groups = new Map<string, string>();
-  let groupMatch: RegExpExecArray | null;
-  while ((groupMatch = groupRegex.exec(content)) !== null) {
-    groups.set(groupMatch[1], groupMatch[2]);
-  }
-
-  const minimalApiRegex = /\b(\w+)?\.?Map(Get|Post|Put|Patch|Delete)\s*\(\s*"([^"]+)"/gi;
-  let minMatch: RegExpExecArray | null;
-  while ((minMatch = minimalApiRegex.exec(content)) !== null) {
-    const varName = minMatch[1];
-    const method = minMatch[2].toUpperCase();
-    const actionRoute = minMatch[3];
-
-    let fullPath = actionRoute;
-    if (varName && groups.has(varName)) {
-      const groupPath = groups.get(varName)!;
-      fullPath = groupPath.endsWith('/') || actionRoute.startsWith('/')
-        ? `${groupPath}${actionRoute}`
-        : `${groupPath}/${actionRoute}`;
-    }
-
-    fullPath = fullPath
-      .replace(/\/+/g, '/')
-      .replace(/:[a-zA-Z0-9\?]+/g, '');
-
-    if (fullPath && !fullPath.startsWith('/')) {
-      fullPath = '/' + fullPath;
-    }
-
-    if (fullPath) {
-      endpoints.push({
-        method,
-        path: fullPath,
-        source: relPath,
-      });
-    }
-  }
-
-  return endpoints;
-}
-
-/** Scans source files for common route patterns recursively using globby. */
-async function scanRoutePatterns(repoPath: string): Promise<ApiEndpoint[]> {
-  const endpoints: ApiEndpoint[] = [];
-  const routeRegex = /\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
-
-  try {
-    const files = await globby(
-      ['**/*.ts', '**/*.js', '**/*.cs', '**/*.py'],
-      {
-        cwd: repoPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
-      }
-    );
-
-    for (const file of files) {
-      try {
-        const stat = await fs.stat(file);
-        if (!stat.isFile() || stat.size > 100_000) continue; // Skip large files
-
-        const content = await fs.readFile(file, 'utf-8');
-        const relPath = path.relative(repoPath, file);
-
-        if (file.endsWith('.cs')) {
-          endpoints.push(...extractCsEndpoints(content, relPath));
-        } else {
-          // Express/Fastify/Hono/etc style routes
-          let match: RegExpExecArray | null;
-          routeRegex.lastIndex = 0;
-          while ((match = routeRegex.exec(content)) !== null) {
-            endpoints.push({
-              method: match[1]!.toUpperCase(),
-              path: match[2]!,
-              source: relPath,
-            });
-          }
-        }
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  // De-duplicate endpoints
-  const seen = new Set<string>();
-  const uniqueEndpoints: ApiEndpoint[] = [];
-  for (const ep of endpoints) {
-    const key = `${ep.method}:${ep.path}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      uniqueEndpoints.push(ep);
-    }
-  }
-
-  return uniqueEndpoints;
-}

package/src/analyzers/detect-deps.ts

@@ -1,315 +0,0 @@
-/**
- * @module analyzers/detect-deps
- * Detects dependencies declared in a repository by reading manifest files.
- * This is used to find potential inter-repo connections (e.g., one repo
- * consumes an npm package published by another).
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { globby } from 'globby';
-
-import type { RepoDependency, ProjectAnalysis } from '../types.js';
-
-/**
- * Extracts declared dependencies from a repository's manifest files recursively.
- *
- * Supports:
- * - npm (package.json)
- * - NuGet (*.csproj)
- * - pip (requirements.txt)
- * - Go (go.mod)
- *
- * @param repoPath - Absolute path to the repository root.
- * @returns Array of detected {@link RepoDependency} objects.
- */
-export async function detectDependencies(repoPath: string): Promise<RepoDependency[]> {
-  const deps: RepoDependency[] = [];
-
-  try {
-    const files = await globby(
-      ['**/package.json', '**/*.csproj', '**/requirements.txt', '**/go.mod'],
-      {
-        cwd: repoPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
-      }
-    );
-
-    for (const file of files) {
-      const filename = path.basename(file);
-
-      // ── npm ───────────────────────────────────────────────────────────
-      if (filename === 'package.json') {
-        try {
-          const raw = await fs.readFile(file, 'utf-8');
-          const pkg = JSON.parse(raw) as Record<string, unknown>;
-
-          const allDeps: Record<string, string> = {
-            ...(pkg.dependencies as Record<string, string> | undefined),
-            ...(pkg.devDependencies as Record<string, string> | undefined),
-          };
-
-          for (const [name, version] of Object.entries(allDeps)) {
-            deps.push({ name, type: 'npm', version });
-          }
-        } catch {
-          // Parse error or skip
-        }
-      }
-
-      // ── NuGet (.csproj) ───────────────────────────────────────────────
-      else if (filename.endsWith('.csproj')) {
-        try {
-          const content = await fs.readFile(file, 'utf-8');
-          const packageRefRegex = /<PackageReference\s+Include="([^"]+)"\s+Version="([^"]*)"/gi;
-          let match: RegExpExecArray | null;
-          while ((match = packageRefRegex.exec(content)) !== null) {
-            deps.push({ name: match[1]!, type: 'nuget', version: match[2] });
-          }
-        } catch {
-          // Skip
-        }
-      }
-
-      // ── pip (requirements.txt) ────────────────────────────────────────
-      else if (filename === 'requirements.txt') {
-        try {
-          const content = await fs.readFile(file, 'utf-8');
-          const lines = content.split('\n').filter((l) => l.trim() && !l.startsWith('#'));
-
-          for (const line of lines) {
-            const match = line.match(/^([a-zA-Z0-9_-]+)\s*([>=<~!]*\s*[\d.*]+)?/);
-            if (match) {
-              deps.push({
-                name: match[1]!,
-                type: 'pip',
-                version: match[2]?.trim() || undefined,
-              });
-            }
-          }
-        } catch {
-          // Skip
-        }
-      }
-
-      // ── Go (go.mod) ──────────────────────────────────────────────────
-      else if (filename === 'go.mod') {
-        try {
-          const content = await fs.readFile(file, 'utf-8');
-          const requireRegex = /require\s*\(([\s\S]*?)\)/g;
-          const modRegex = /^\s*([\S]+)\s+(v[\S]+)/gm;
-
-          let match: RegExpExecArray | null;
-          while ((match = requireRegex.exec(content)) !== null) {
-            const block = match[1]!;
-            let modMatch: RegExpExecArray | null;
-            modRegex.lastIndex = 0;
-            while ((modMatch = modRegex.exec(block)) !== null) {
-              deps.push({ name: modMatch[1]!, type: 'go', version: modMatch[2] });
-            }
-          }
-        } catch {
-          // Skip
-        }
-      }
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  // De-duplicate dependencies to keep context clean
-  const seen = new Set<string>();
-  const uniqueDeps: RepoDependency[] = [];
-  for (const dep of deps) {
-    const key = `${dep.type}:${dep.name}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      uniqueDeps.push(dep);
-    }
-  }
-
-  return uniqueDeps;
-}
-
-/**
- * Scans recursively for packages produced or published by the repository.
- *
- * @param repoPath - Absolute path to the repository root.
- * @returns Array of produced package metadata.
- */
-export async function detectProducedPackages(
-  repoPath: string,
-): Promise<{ name: string; type: 'npm' | 'nuget' | 'other'; version?: string; contributing?: string[] }[]> {
-  const products: { name: string; type: 'npm' | 'nuget' | 'other'; version?: string; contributing?: string[] }[] = [];
-
-  try {
-    const files = await globby(
-      ['**/package.json', '**/*.csproj'],
-      {
-        cwd: repoPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
-      }
-    );
-
-    for (const file of files) {
-      const filename = path.basename(file);
-
-      if (filename === 'package.json') {
-        try {
-          const raw = await fs.readFile(file, 'utf-8');
-          const pkg = JSON.parse(raw) as Record<string, unknown>;
-          if (pkg.name && pkg.name !== 'workspace' && !pkg.private) {
-            products.push({
-              name: pkg.name as string,
-              type: 'npm',
-              version: (pkg.version as string) || undefined,
-            });
-          }
-        } catch {
-          // Skip
-        }
-      } else if (filename.endsWith('.csproj')) {
-        try {
-          const content = await fs.readFile(file, 'utf-8');
-          const packageIdMatch = /<PackageId>([^<]+)<\/PackageId>/i.exec(content);
-          const assemblyNameMatch = /<AssemblyName>([^<]+)<\/AssemblyName>/i.exec(content);
-          const versionMatch = /<Version>([^<]+)<\/Version>/i.exec(content);
-
-          const name =
-            packageIdMatch?.[1]?.trim() ||
-            assemblyNameMatch?.[1]?.trim() ||
-            path.basename(file, '.csproj');
-
-          // Extract project references to find contributing sub-projects
-          const projRefRegex = /<ProjectReference\s+Include="([^"]+)"/gi;
-          const contributing: string[] = [];
-          let projMatch: RegExpExecArray | null;
-          while ((projMatch = projRefRegex.exec(content)) !== null) {
-            const refPath = projMatch[1];
-            const refName = path.basename(refPath, '.csproj');
-            contributing.push(refName);
-          }
-
-          products.push({
-            name,
-            type: 'nuget',
-            version: versionMatch?.[1]?.trim() || undefined,
-            contributing: contributing.length > 0 ? contributing : undefined,
-          });
-        } catch {
-          // Skip
-        }
-      }
-    }
-  } catch {
-    // Ignore errors
-  }
-
-  return products;
-}
-
-/**
- * Given analysis of multiple repos, find which repos depend on each other.
- * Returns a map of repo name → list of repo names it depends on.
- *
- * @param repoAnalyses - Map of repo path to its full analysis result.
- * @param repoNames    - Map of repo path to its name.
- * @returns Map of repo name → list of repo names it depends on.
- */
-export function findInterRepoDependencies(
-  repoAnalyses: Map<string, ProjectAnalysis>,
-  repoNames: Map<string, string>,
-): Map<string, string[]> {
-  const connections = new Map<string, string[]>();
-
-  // Map each produced package name to the repo name that produces it
-  const packageToRepo = new Map<string, string>();
-  for (const [repoPath, a] of repoAnalyses) {
-    const thisName = repoNames.get(repoPath) ?? a.name;
-    // Map the repo name itself as a produced product (for direct matching)
-    packageToRepo.set(thisName.toLowerCase(), thisName);
-    
-    if (a.produces) {
-      for (const product of a.produces) {
-        packageToRepo.set(product.name.toLowerCase(), thisName);
-        // Also map basename (e.g. Hogia.EmploymentService.Client -> Client)
-        const base = product.name.split('.').pop() ?? product.name;
-        if (base && base.length > 3) {
-          packageToRepo.set(base.toLowerCase(), thisName);
-        }
-      }
-    }
-  }
-
-  for (const [repoPath, a] of repoAnalyses) {
-    const thisName = repoNames.get(repoPath) ?? a.name;
-    const dependsOn: string[] = [];
-
-    for (const dep of a.dependencies) {
-      const depNameLower = dep.name.toLowerCase();
-      
-      // 1. Direct match with a produced package
-      if (packageToRepo.has(depNameLower)) {
-        const targetRepo = packageToRepo.get(depNameLower)!;
-        if (targetRepo !== thisName && !dependsOn.includes(targetRepo)) {
-          dependsOn.push(targetRepo);
-        }
-      } else {
-        // 2. Check if the dependency contains or is contained by a produced package name
-        for (const [prodPkg, targetRepo] of packageToRepo) {
-          if (targetRepo === thisName) continue;
-          if (depNameLower.includes(prodPkg) || prodPkg.includes(depNameLower)) {
-            if (!dependsOn.includes(targetRepo)) {
-              dependsOn.push(targetRepo);
-            }
-          }
-        }
-      }
-    }
-
-    if (dependsOn.length > 0) {
-      connections.set(thisName, dependsOn);
-    }
-  }
-
-  return connections;
-}
-
-/**
- * Scans for NuGet.config files recursively in the repository and extracts configured package source feeds.
- *
- * @param repoPath - Absolute path to the repository root.
- * @returns Array of package sources (key, value).
- */
-export async function detectNuGetFeeds(repoPath: string): Promise<{ name: string; url: string }[]> {
-  const feeds: { name: string; url: string }[] = [];
-  try {
-    const configFiles = await globby('**/NuGet.config', {
-      cwd: repoPath,
-      absolute: true,
-      ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
-    });
-
-    for (const file of configFiles) {
-      try {
-        const content = await fs.readFile(file, 'utf-8');
-        // Scan for <add key="..." value="..." /> elements under <packageSources>
-        const addRegex = /<add\s+key="([^"]+)"\s+value="([^"]+)"/gi;
-        let match: RegExpExecArray | null;
-        while ((match = addRegex.exec(content)) !== null) {
-          const key = match[1];
-          const value = match[2];
-          // Exclude default public nuget feed to keep output focused on private feeds
-          if (!key.toLowerCase().includes('nuget.org') && !value.toLowerCase().includes('api.nuget.org')) {
-            feeds.push({ name: key, url: value });
-          }
-        }
-      } catch {}
-    }
-  } catch {
-    // Ignore errors
-  }
-  return feeds;
-}

package/src/analyzers/detect-existing.ts

@@ -1,74 +0,0 @@
-/**
- * @module analyzers/detect-existing
- * Detects existing AI assistant configuration files in a repository.
- * These are merged into the generated workspace context to preserve
- * repo-specific instructions.
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-
-import type { ExistingAIConfig } from '../types.js';
-
-/** Maximum chars to include as a content preview. */
-const PREVIEW_LENGTH = 500;
-
-/** Known AI config file locations. */
-const AI_CONFIG_FILES = [
-  { assistant: 'claude' as const, relativePath: 'CLAUDE.md' },
-  { assistant: 'claude' as const, relativePath: 'CLAUDE.local.md' },
-  { assistant: 'agents' as const, relativePath: 'AGENTS.md' },
-  { assistant: 'copilot' as const, relativePath: '.github/copilot-instructions.md' },
-  { assistant: 'cursor' as const, relativePath: '.cursorrules' },
-];
-
-/**
- * Scans a repository for existing AI assistant configuration files.
- *
- * @param repoPath - Absolute path to the repository root.
- * @returns Array of detected {@link ExistingAIConfig} objects.
- */
-export async function detectExistingAIConfigs(
-  repoPath: string,
-): Promise<ExistingAIConfig[]> {
-  const results: ExistingAIConfig[] = [];
-
-  for (const config of AI_CONFIG_FILES) {
-    const filePath = path.join(repoPath, config.relativePath);
-
-    try {
-      const content = await fs.readFile(filePath, 'utf-8');
-      results.push({
-        assistant: config.assistant,
-        relativePath: config.relativePath,
-        contentPreview: content.slice(0, PREVIEW_LENGTH),
-      });
-    } catch {
-      // File doesn't exist — skip
-    }
-  }
-
-  // Also check for Cursor rules directory
-  const cursorRulesDir = path.join(repoPath, '.cursor', 'rules');
-  try {
-    const entries = await fs.readdir(cursorRulesDir);
-    const mdcFiles = entries.filter((e) => e.endsWith('.mdc'));
-
-    for (const mdc of mdcFiles) {
-      try {
-        const content = await fs.readFile(path.join(cursorRulesDir, mdc), 'utf-8');
-        results.push({
-          assistant: 'cursor',
-          relativePath: `.cursor/rules/${mdc}`,
-          contentPreview: content.slice(0, PREVIEW_LENGTH),
-        });
-      } catch {
-        // Skip unreadable files
-      }
-    }
-  } catch {
-    // No .cursor/rules directory
-  }
-
-  return results;
-}