@mrpatronz/nexusflow 0.1.12 → 0.2.0

package/src/analyzers/detect-apis.ts

@@ -6,6 +6,7 @@
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { globby } from 'globby';
 
 import type { ApiEndpoint } from '../types.js';
 
@@ -77,62 +78,213 @@ async function scanOpenApiFiles(repoPath: string): Promise<ApiEndpoint[]> {
   return endpoints;
 }
 
-/** Scans source files for common route patterns. Limited to top-level files. */
-async function scanRoutePatterns(repoPath: string): Promise<ApiEndpoint[]> {
+/** Scans C# files for controllers and Minimal APIs. */
+function extractCsEndpoints(content: string, relPath: string): ApiEndpoint[] {
   const endpoints: ApiEndpoint[] = [];
 
-  // Look in common source directories
-  const sourceDirs = ['src', 'app', 'routes', 'controllers', 'Controllers', '.'];
-  const routeRegex = /\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
-  const aspnetRegex = /\[Http(Get|Post|Put|Patch|Delete)\s*\(\s*"([^"]+)"\s*\)\]/gi;
+  // 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,
+    });
+  }
 
-  for (const dir of sourceDirs) {
-    const dirPath = path.join(repoPath, dir);
+  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,
+    });
+  }
 
-    let entries: string[];
-    try {
-      entries = await fs.readdir(dirPath);
-    } catch {
-      continue;
+  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;
 
-    for (const entry of entries) {
-      const ext = path.extname(entry).toLowerCase();
-      if (!['.ts', '.js', '.cs', '.py'].includes(ext)) continue;
+  try {
+    const files = await globby(
+      ['**/*.ts', '**/*.js', '**/*.cs', '**/*.py'],
+      {
+        cwd: repoPath,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
+      }
+    );
 
-      const filePath = path.join(dirPath, entry);
+    for (const file of files) {
       try {
-        const stat = await fs.stat(filePath);
+        const stat = await fs.stat(file);
         if (!stat.isFile() || stat.size > 100_000) continue; // Skip large files
 
-        const content = await fs.readFile(filePath, 'utf-8');
-        const relPath = path.relative(repoPath, filePath);
-
-        // Express/Fastify/Hono 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,
-          });
-        }
+        const content = await fs.readFile(file, 'utf-8');
+        const relPath = path.relative(repoPath, file);
 
-        // ASP.NET style routes
-        aspnetRegex.lastIndex = 0;
-        while ((match = aspnetRegex.exec(content)) !== null) {
-          endpoints.push({
-            method: match[1]!.toUpperCase(),
-            path: match[2]!,
-            source: relPath,
-          });
+        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
   }
 
-  return endpoints;
+  // 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

@@ -7,11 +7,12 @@
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { globby } from 'globby';
 
-import type { RepoDependency } from '../types.js';
+import type { RepoDependency, ProjectAnalysis } from '../types.js';
 
 /**
- * Extracts declared dependencies from a repository's manifest files.
+ * Extracts declared dependencies from a repository's manifest files recursively.
  *
  * Supports:
  * - npm (package.json)
@@ -25,107 +26,246 @@ import type { RepoDependency } from '../types.js';
 export async function detectDependencies(repoPath: string): Promise<RepoDependency[]> {
   const deps: RepoDependency[] = [];
 
-  // ── npm ───────────────────────────────────────────────────────────
   try {
-    const raw = await fs.readFile(path.join(repoPath, 'package.json'), 'utf-8');
-    const pkg = JSON.parse(raw) as Record<string, unknown>;
+    const files = await globby(
+      ['**/package.json', '**/*.csproj', '**/requirements.txt', '**/go.mod'],
+      {
+        cwd: repoPath,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
+      }
+    );
 
-    const allDeps: Record<string, string> = {
-      ...(pkg.dependencies as Record<string, string> | undefined),
-      ...(pkg.devDependencies as Record<string, string> | undefined),
-    };
+    for (const file of files) {
+      const filename = path.basename(file);
 
-    for (const [name, version] of Object.entries(allDeps)) {
-      deps.push({ name, type: 'npm', version });
-    }
-  } catch {
-    // No package.json or parse error
-  }
+      // ── npm ───────────────────────────────────────────────────────────
+      if (filename === 'package.json') {
+        try {
+          const raw = await fs.readFile(file, 'utf-8');
+          const pkg = JSON.parse(raw) as Record<string, unknown>;
 
-  // ── NuGet (.csproj) ───────────────────────────────────────────────
-  try {
-    const entries = await fs.readdir(repoPath);
-    const csprojFiles = entries.filter((e) => e.endsWith('.csproj'));
-
-    for (const csproj of csprojFiles) {
-      const content = await fs.readFile(path.join(repoPath, csproj), '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] });
+          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 {
-    // No .csproj files
+    // Ignore errors
   }
 
-  // ── pip (requirements.txt) ────────────────────────────────────────
-  try {
-    const content = await fs.readFile(path.join(repoPath, 'requirements.txt'), '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,
-        });
-      }
+  // 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);
     }
-  } catch {
-    // No requirements.txt
   }
 
-  // ── Go (go.mod) ──────────────────────────────────────────────────
+  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 content = await fs.readFile(path.join(repoPath, 'go.mod'), 'utf-8');
-    const requireRegex = /require\s*\(([\s\S]*?)\)/g;
-    const modRegex = /^\s*([\S]+)\s+(v[\S]+)/gm;
-
-    let match: RegExpExecArray | null;
-    // Parse require blocks
-    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] });
+    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 {
-    // No go.mod
+    // Ignore errors
   }
 
-  return deps;
+  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 detected dependencies.
+ * @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, RepoDependency[]>,
+  repoAnalyses: Map<string, ProjectAnalysis>,
   repoNames: Map<string, string>,
 ): Map<string, string[]> {
-  const nameSet = new Set(repoNames.values());
   const connections = new Map<string, string[]>();
 
-  for (const [repoPath, deps] of repoAnalyses) {
-    const thisName = repoNames.get(repoPath) ?? repoPath;
+  // 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 deps) {
-      // Check if the dependency name matches another repo name
-      // (e.g., an npm package name matching a repo folder name)
-      const depBaseName = dep.name.split('/').pop() ?? dep.name;
-      if (nameSet.has(depBaseName) && depBaseName !== thisName) {
-        dependsOn.push(depBaseName);
+    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);
+            }
+          }
+        }
       }
     }
 
@@ -136,3 +276,40 @@ export function findInterRepoDependencies(
 
   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/index.ts

@@ -10,7 +10,7 @@ import ora from 'ora';
 import type { ProjectAnalysis, RepoInfo } from '../types.js';
 import { detectTechStack } from './tech-stack.js';
 import { detectApis } from './detect-apis.js';
-import { detectDependencies } from './detect-deps.js';
+import { detectDependencies, detectProducedPackages, detectNuGetFeeds } from './detect-deps.js';
 import { detectPorts } from './detect-ports.js';
 import { detectExistingAIConfigs } from './detect-existing.js';
 import { extractReadmeSummary } from './readme-summarizer.js';
@@ -23,11 +23,13 @@ import { extractReadmeSummary } from './readme-summarizer.js';
  * @returns Full analysis result.
  */
 export async function analyzeRepo(repo: RepoInfo): Promise<ProjectAnalysis> {
-  const [techStack, endpoints, dependencies, ports, existingAIConfigs, readmeSummary] =
+  const [techStack, endpoints, dependencies, produces, nugetFeeds, ports, existingAIConfigs, readmeSummary] =
     await Promise.all([
       detectTechStack(repo.path),
       detectApis(repo.path),
       detectDependencies(repo.path),
+      detectProducedPackages(repo.path),
+      detectNuGetFeeds(repo.path),
       detectPorts(repo.path),
       detectExistingAIConfigs(repo.path),
       extractReadmeSummary(repo.path),
@@ -39,6 +41,8 @@ export async function analyzeRepo(repo: RepoInfo): Promise<ProjectAnalysis> {
     techStack,
     endpoints,
     dependencies,
+    produces,
+    nugetFeeds,
     ports,
     existingAIConfigs,
     readmeSummary,
@@ -79,7 +83,7 @@ export async function analyzeAllRepos(
 // Re-export individual analyzers
 export { detectTechStack } from './tech-stack.js';
 export { detectApis } from './detect-apis.js';
-export { detectDependencies, findInterRepoDependencies } from './detect-deps.js';
+export { detectDependencies, findInterRepoDependencies, detectNuGetFeeds } from './detect-deps.js';
 export { detectPorts } from './detect-ports.js';
 export { detectExistingAIConfigs } from './detect-existing.js';
 export { extractReadmeSummary } from './readme-summarizer.js';