@mrpatronz/nexusflow 0.1.11 → 0.2.0

package/src/analyzers/readme-summarizer.ts

@@ -6,12 +6,11 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 
-/** Maximum chars to extract from README for summary. */
-const MAX_SUMMARY_LENGTH = 800;
-
 /**
  * Reads a repository's README.md and extracts the first meaningful
- * section as a summary. Looks for README.md (case-insensitive).
+ * prose paragraph as a summary. Looks for README.md (case-insensitive).
+ *
+ * It automatically strips badges, TOC lists, headers, HTML tags, and redacts ClientIDs/Secrets.
  *
  * @param repoPath - Absolute path to the repository root.
  * @returns The extracted summary text, or null if no README is found.
@@ -35,34 +34,64 @@ export async function extractReadmeSummary(
 
   if (!content) return null;
 
-  // Strip badges, images, and HTML at the top
+  // 1. Strip code blocks to avoid false matching on secrets/prose
+  content = content.replace(/```[\s\S]*?```/g, '');
+
+  // 2. Scrub ClientIDs/Secrets/Credentials
+  // Match standard secret/ID patterns: GUIDs, client_id/secret variables, hex keys
+  const clientSecretsRegex = /(client_id|client_secret|appid|secret|password|key|token|credential)\s*[:=]\s*["']?[a-zA-Z0-9-_\/\+\.]{16,}["']?/gi;
+  const guidRegex = /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/g;
+  
+  content = content
+    .replace(clientSecretsRegex, (match, p1) => `${p1}: [REDACTED]`)
+    .replace(guidRegex, '[REDACTED_ID]');
+
+  // 3. Process line-by-line to find the first prose paragraph
   const lines = content.split('\n');
-  const meaningfulLines: string[] = [];
-  let foundContent = false;
+  const proseLines: string[] = [];
 
   for (const line of lines) {
     const trimmed = line.trim();
 
-    // Skip empty lines before content starts
-    if (!foundContent && !trimmed) continue;
-
-    // Skip badge lines ([![...](...)]) and image lines (![...](...)
-    if (trimmed.startsWith('[![') || (trimmed.startsWith('![') && trimmed.includes('http'))) continue;
+    // Skip empty lines
+    if (!trimmed) {
+      if (proseLines.length > 0) {
+        // We found a paragraph and hit an empty line. Let's finish!
+        break;
+      }
+      continue;
+    }
 
     // Skip HTML tags
     if (trimmed.startsWith('<') && trimmed.endsWith('>')) continue;
 
+    // Skip badges
+    if (trimmed.startsWith('[![') || (trimmed.startsWith('![') && trimmed.includes('http'))) continue;
+
     // Skip horizontal rules
     if (/^(-{3,}|={3,}|\*{3,})$/.test(trimmed)) continue;
 
-    foundContent = true;
-    meaningfulLines.push(line);
+    // Skip headers (Markdown # )
+    if (trimmed.startsWith('#')) continue;
+
+    // Detect Table of Contents (TOC) lists
+    // Skip lines that look like: - [About](#about) or * 1. [Section](#section)
+    if (/^[-*+]\s*(\d+\.)?\s*\[[^\]]+\]\(#[^)]+\)/.test(trimmed)) {
+      continue;
+    }
+
+    // Skip standard bullet lists if we are searching for prose (e.g. at the top of README before prose)
+    if (proseLines.length === 0 && /^[-*+]\s+/.test(trimmed)) {
+      continue;
+    }
 
-    // Stop after we have enough content
-    const currentLength = meaningfulLines.join('\n').length;
-    if (currentLength >= MAX_SUMMARY_LENGTH) break;
+    // Accumulate prose lines
+    proseLines.push(line);
   }
 
-  const summary = meaningfulLines.join('\n').slice(0, MAX_SUMMARY_LENGTH).trim();
-  return summary || null;
+  const summary = proseLines.join(' ').replace(/\s+/g, ' ').trim();
+  if (!summary) return null;
+  
+  // Limit the summary to a concise paragraph (first 250 characters)
+  return summary.length > 250 ? summary.slice(0, 250) + '...' : summary;
 }

package/src/analyzers/tech-stack.ts

@@ -6,19 +6,10 @@
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { globby } from 'globby';
 
 import type { TechStack, Language, Framework, ProjectType } from '../types.js';
 
-/** Check if a file exists in a directory. */
-async function fileExists(dir: string, filename: string): Promise<boolean> {
-  try {
-    await fs.access(path.join(dir, filename));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /** Safely read and parse a JSON file. Returns null on failure. */
 async function readJson(filePath: string): Promise<Record<string, unknown> | null> {
   try {
@@ -29,227 +20,264 @@ async function readJson(filePath: string): Promise<Record<string, unknown> | nul
   }
 }
 
-/** Check if any file matching a glob-like pattern exists. */
-async function hasFileWithExtension(dir: string, ext: string): Promise<boolean> {
-  try {
-    const entries = await fs.readdir(dir);
-    return entries.some((e) => e.endsWith(ext));
-  } catch {
-    return false;
-  }
-}
-
 /**
- * Detects the tech stack of a repository by inspecting its root directory
- * for manifest files, config files, and project structures.
+ * Detects the tech stack of a repository by recursively inspecting its
+ * contents for manifest files, config files, and project structures.
  *
  * @param repoPath - Absolute path to the repository root.
  * @returns A {@link TechStack} object describing the detected stack.
  */
 export async function detectTechStack(repoPath: string): Promise<TechStack> {
-  const languages: Language[] = [];
-  const frameworks: Framework[] = [];
-  const buildTools: string[] = [];
-  let projectType: ProjectType = 'other';
-
-  // ── Node.js / JavaScript / TypeScript ──────────────────────────────
-  const hasPackageJson = await fileExists(repoPath, 'package.json');
-  if (hasPackageJson) {
-    const pkg = await readJson(path.join(repoPath, 'package.json'));
-
-    // Detect TypeScript vs JavaScript
-    const hasTsConfig = await fileExists(repoPath, 'tsconfig.json');
-    if (hasTsConfig) {
-      languages.push('typescript');
-    } else {
-      languages.push('javascript');
-    }
+  const languages = new Set<Language>();
+  const frameworks = new Set<Framework>();
+  const buildTools = new Set<string>();
+  const projectTypes = new Set<ProjectType>();
 
-    if (pkg) {
-      const allDeps = {
-        ...(pkg.dependencies as Record<string, string> | undefined),
-        ...(pkg.devDependencies as Record<string, string> | undefined),
-      };
-
-      // Frameworks
-      if (allDeps['next']) { frameworks.push('nextjs'); projectType = 'fullstack'; }
-      if (allDeps['react'] && !allDeps['next']) { frameworks.push('react'); projectType = 'frontend'; }
-      if (allDeps['@angular/core']) { frameworks.push('angular'); projectType = 'frontend'; }
-      if (allDeps['vue']) { frameworks.push('vue'); projectType = 'frontend'; }
-      if (allDeps['svelte']) { frameworks.push('svelte'); projectType = 'frontend'; }
-      if (allDeps['express']) { frameworks.push('express'); projectType = 'backend'; }
-      if (allDeps['@nestjs/core']) { frameworks.push('nestjs'); projectType = 'backend'; }
-      if (allDeps['fastify']) { frameworks.push('fastify'); projectType = 'backend'; }
-      if (allDeps['hono']) { frameworks.push('hono'); projectType = 'backend'; }
-
-      // Build tools
-      if (allDeps['vite'] || allDeps['@vitejs/plugin-react']) buildTools.push('vite');
-      if (allDeps['webpack']) buildTools.push('webpack');
-      if (allDeps['esbuild']) buildTools.push('esbuild');
-      if (allDeps['rollup']) buildTools.push('rollup');
-      if (allDeps['turbo']) buildTools.push('turborepo');
-      if (allDeps['nx']) buildTools.push('nx');
-
-      // Project type heuristics
-      if (pkg.bin) projectType = 'cli';
-      if (pkg.main && !pkg.bin && frameworks.length === 0) projectType = 'library';
+  try {
+    const files = await globby([
+      '**/package.json',
+      '**/tsconfig.json',
+      '**/*.csproj',
+      '**/*.sln',
+      '**/requirements.txt',
+      '**/pyproject.toml',
+      '**/setup.py',
+      '**/go.mod',
+      '**/pom.xml',
+      '**/build.gradle',
+      '**/build.gradle.kts',
+      '**/Cargo.toml',
+      '**/Gemfile',
+      '**/composer.json',
+      '**/Dockerfile',
+      '**/docker-compose.yml',
+      '**/docker-compose.yaml',
+      '**/compose.yaml',
+      '**/compose.yml',
+    ], {
+      cwd: repoPath,
+      absolute: true,
+      ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
+    });
+
+    const fileMap = new Map<string, string[]>();
+    for (const file of files) {
+      const name = path.basename(file);
+      let list = fileMap.get(name);
+      if (!list) {
+        list = [];
+        fileMap.set(name, list);
+      }
+      list.push(file);
     }
-  }
 
-  // ── .NET / C# ─────────────────────────────────────────────────────
-  const hasCsproj = await hasFileWithExtension(repoPath, '.csproj');
-  const hasSln = await hasFileWithExtension(repoPath, '.sln');
-  if (hasCsproj || hasSln) {
-    languages.push('csharp');
-
-    // Try to detect ASP.NET or Blazor from csproj content
-    try {
-      const entries = await fs.readdir(repoPath);
-      const csprojFile = entries.find((e) => e.endsWith('.csproj'));
-      if (csprojFile) {
-        const content = await fs.readFile(path.join(repoPath, csprojFile), 'utf-8');
-        if (content.includes('Microsoft.NET.Sdk.Web')) {
-          frameworks.push('aspnet');
-          projectType = 'backend';
-        }
-        if (content.includes('Microsoft.NET.Sdk.BlazorWebAssembly') || content.includes('Blazor')) {
-          frameworks.push('blazor');
-          projectType = 'frontend';
+    // ── Node.js / JavaScript / TypeScript ──────────────────────────────
+    const packageJsons = fileMap.get('package.json') || [];
+    if (packageJsons.length > 0) {
+      const tsconfigs = fileMap.get('tsconfig.json') || [];
+      if (tsconfigs.length > 0) {
+        languages.add('typescript');
+      } else {
+        languages.add('javascript');
+      }
+
+      for (const pj of packageJsons) {
+        const pkg = await readJson(pj);
+        if (pkg) {
+          const allDeps = {
+            ...(pkg.dependencies as Record<string, string> | undefined),
+            ...(pkg.devDependencies as Record<string, string> | undefined),
+          };
+
+          // Frameworks
+          if (allDeps['next']) { frameworks.add('nextjs'); projectTypes.add('fullstack'); }
+          if (allDeps['react'] && !allDeps['next']) { frameworks.add('react'); projectTypes.add('frontend'); }
+          if (allDeps['@angular/core']) { frameworks.add('angular'); projectTypes.add('frontend'); }
+          if (allDeps['vue']) { frameworks.add('vue'); projectTypes.add('frontend'); }
+          if (allDeps['svelte']) { frameworks.add('svelte'); projectTypes.add('frontend'); }
+          if (allDeps['express']) { frameworks.add('express'); projectTypes.add('backend'); }
+          if (allDeps['@nestjs/core']) { frameworks.add('nestjs'); projectTypes.add('backend'); }
+          if (allDeps['fastify']) { frameworks.add('fastify'); projectTypes.add('backend'); }
+          if (allDeps['hono']) { frameworks.add('hono'); projectTypes.add('backend'); }
+
+          // Build tools
+          if (allDeps['vite'] || allDeps['@vitejs/plugin-react']) buildTools.add('vite');
+          if (allDeps['webpack']) buildTools.add('webpack');
+          if (allDeps['esbuild']) buildTools.add('esbuild');
+          if (allDeps['rollup']) buildTools.add('rollup');
+          if (allDeps['turbo']) buildTools.add('turborepo');
+          if (allDeps['nx']) buildTools.add('nx');
+
+          // Project type heuristics
+          if (pkg.bin) projectTypes.add('cli');
+          if (pkg.main && !pkg.bin && frameworks.size === 0) projectTypes.add('library');
         }
       }
-    } catch {
-      // Ignore read errors
     }
 
-    buildTools.push('dotnet');
-  }
+    // ── .NET / C# ─────────────────────────────────────────────────────
+    const csprojFiles = files.filter((f) => f.endsWith('.csproj'));
+    const slnFiles = files.filter((f) => f.endsWith('.sln'));
+    if (csprojFiles.length > 0 || slnFiles.length > 0) {
+      languages.add('csharp');
+      buildTools.add('dotnet');
 
-  // ── Python ────────────────────────────────────────────────────────
-  const hasPyproject = await fileExists(repoPath, 'pyproject.toml');
-  const hasRequirements = await fileExists(repoPath, 'requirements.txt');
-  const hasSetupPy = await fileExists(repoPath, 'setup.py');
-  if (hasPyproject || hasRequirements || hasSetupPy) {
-    languages.push('python');
-
-    // Try to detect frameworks from requirements
-    try {
-      let content = '';
-      if (hasRequirements) {
-        content = await fs.readFile(path.join(repoPath, 'requirements.txt'), 'utf-8');
-      } else if (hasPyproject) {
-        content = await fs.readFile(path.join(repoPath, 'pyproject.toml'), 'utf-8');
+      for (const csproj of csprojFiles) {
+        try {
+          const content = await fs.readFile(csproj, 'utf-8');
+          if (content.includes('Microsoft.NET.Sdk.Web')) {
+            frameworks.add('aspnet');
+            projectTypes.add('backend');
+          }
+          if (content.includes('Microsoft.NET.Sdk.BlazorWebAssembly') || content.includes('Blazor')) {
+            frameworks.add('blazor');
+            projectTypes.add('frontend');
+          }
+        } catch {}
       }
-      const lower = content.toLowerCase();
-      if (lower.includes('django')) { frameworks.push('django'); projectType = 'backend'; }
-      if (lower.includes('flask')) { frameworks.push('flask'); projectType = 'backend'; }
-      if (lower.includes('fastapi')) { frameworks.push('fastapi'); projectType = 'backend'; }
-    } catch {
-      // Ignore
     }
 
-    if (hasPyproject) buildTools.push('pyproject');
-    if (hasSetupPy) buildTools.push('setuptools');
-  }
+    // ── Python ────────────────────────────────────────────────────────
+    const pyprojectTomls = fileMap.get('pyproject.toml') || [];
+    const requirementsTxts = fileMap.get('requirements.txt') || [];
+    const setupPys = fileMap.get('setup.py') || [];
+
+    if (pyprojectTomls.length > 0 || requirementsTxts.length > 0 || setupPys.length > 0) {
+      languages.add('python');
 
-  // ── Go ────────────────────────────────────────────────────────────
-  const hasGoMod = await fileExists(repoPath, 'go.mod');
-  if (hasGoMod) {
-    languages.push('go');
-    buildTools.push('go');
-
-    try {
-      const content = await fs.readFile(path.join(repoPath, 'go.mod'), 'utf-8');
-      if (content.includes('github.com/gin-gonic/gin')) {
-        frameworks.push('gin');
-        projectType = 'backend';
+      for (const reqFile of [...requirementsTxts, ...pyprojectTomls]) {
+        try {
+          const content = await fs.readFile(reqFile, 'utf-8');
+          const lower = content.toLowerCase();
+          if (lower.includes('django')) { frameworks.add('django'); projectTypes.add('backend'); }
+          if (lower.includes('flask')) { frameworks.add('flask'); projectTypes.add('backend'); }
+          if (lower.includes('fastapi')) { frameworks.add('fastapi'); projectTypes.add('backend'); }
+        } catch {}
       }
-    } catch {
-      // Ignore
+
+      if (pyprojectTomls.length > 0) buildTools.add('pyproject');
+      if (setupPys.length > 0) buildTools.add('setuptools');
     }
-  }
 
-  // ── Java ──────────────────────────────────────────────────────────
-  const hasPom = await fileExists(repoPath, 'pom.xml');
-  const hasGradle = await fileExists(repoPath, 'build.gradle');
-  const hasGradleKts = await fileExists(repoPath, 'build.gradle.kts');
-  if (hasPom || hasGradle || hasGradleKts) {
-    languages.push('java');
-    if (hasPom) buildTools.push('maven');
-    if (hasGradle || hasGradleKts) buildTools.push('gradle');
-
-    try {
-      let content = '';
-      if (hasPom) {
-        content = await fs.readFile(path.join(repoPath, 'pom.xml'), 'utf-8');
-      } else if (hasGradle) {
-        content = await fs.readFile(path.join(repoPath, 'build.gradle'), 'utf-8');
+    // ── Go ────────────────────────────────────────────────────────────
+    const goMods = fileMap.get('go.mod') || [];
+    if (goMods.length > 0) {
+      languages.add('go');
+      buildTools.add('go');
+
+      for (const goMod of goMods) {
+        try {
+          const content = await fs.readFile(goMod, 'utf-8');
+          if (content.includes('github.com/gin-gonic/gin')) {
+            frameworks.add('gin');
+            projectTypes.add('backend');
+          }
+        } catch {}
       }
-      if (content.includes('spring')) {
-        frameworks.push('spring');
-        projectType = 'backend';
+    }
+
+    // ── Java ──────────────────────────────────────────────────────────
+    const poms = fileMap.get('pom.xml') || [];
+    const gradles = fileMap.get('build.gradle') || [];
+    const gradleKts = fileMap.get('build.gradle.kts') || [];
+
+    if (poms.length > 0 || gradles.length > 0 || gradleKts.length > 0) {
+      languages.add('java');
+      if (poms.length > 0) buildTools.add('maven');
+      if (gradles.length > 0 || gradleKts.length > 0) buildTools.add('gradle');
+
+      for (const f of [...poms, ...gradles, ...gradleKts]) {
+        try {
+          const content = await fs.readFile(f, 'utf-8');
+          if (content.includes('spring')) {
+            frameworks.add('spring');
+            projectTypes.add('backend');
+          }
+        } catch {}
       }
-    } catch {
-      // Ignore
     }
-  }
 
-  // ── Rust ──────────────────────────────────────────────────────────
-  const hasCargo = await fileExists(repoPath, 'Cargo.toml');
-  if (hasCargo) {
-    languages.push('rust');
-    buildTools.push('cargo');
-  }
+    // ── Rust ──────────────────────────────────────────────────────────
+    const cargoTomls = fileMap.get('Cargo.toml') || [];
+    if (cargoTomls.length > 0) {
+      languages.add('rust');
+      buildTools.add('cargo');
+    }
+
+    // ── Ruby ──────────────────────────────────────────────────────────
+    const gemfiles = fileMap.get('Gemfile') || [];
+    if (gemfiles.length > 0) {
+      languages.add('ruby');
+      buildTools.add('bundler');
 
-  // ── Ruby ──────────────────────────────────────────────────────────
-  const hasGemfile = await fileExists(repoPath, 'Gemfile');
-  if (hasGemfile) {
-    languages.push('ruby');
-    buildTools.push('bundler');
-
-    try {
-      const content = await fs.readFile(path.join(repoPath, 'Gemfile'), 'utf-8');
-      if (content.includes('rails')) {
-        frameworks.push('rails');
-        projectType = 'backend';
+      for (const gemfile of gemfiles) {
+        try {
+          const content = await fs.readFile(gemfile, 'utf-8');
+          if (content.includes('rails')) {
+            frameworks.add('rails');
+            projectTypes.add('backend');
+          }
+        } catch {}
       }
-    } catch {
-      // Ignore
     }
-  }
 
-  // ── PHP ───────────────────────────────────────────────────────────
-  const hasComposer = await fileExists(repoPath, 'composer.json');
-  if (hasComposer) {
-    languages.push('php');
-    buildTools.push('composer');
-
-    const composer = await readJson(path.join(repoPath, 'composer.json'));
-    if (composer) {
-      const req = composer.require as Record<string, string> | undefined;
-      if (req?.['laravel/framework']) {
-        frameworks.push('laravel');
-        projectType = 'backend';
+    // ── PHP ───────────────────────────────────────────────────────────
+    const composerJsons = fileMap.get('composer.json') || [];
+    if (composerJsons.length > 0) {
+      languages.add('php');
+      buildTools.add('composer');
+
+      for (const comp of composerJsons) {
+        const composer = await readJson(comp);
+        if (composer) {
+          const req = composer.require as Record<string, string> | undefined;
+          if (req?.['laravel/framework']) {
+            frameworks.add('laravel');
+            projectTypes.add('backend');
+          }
+        }
       }
     }
-  }
 
-  // ── Docker ────────────────────────────────────────────────────────
-  if (await fileExists(repoPath, 'Dockerfile')) {
-    buildTools.push('docker');
+    // ── Docker ────────────────────────────────────────────────────────
+    const dockerfiles = fileMap.get('Dockerfile') || [];
+    if (dockerfiles.length > 0) {
+      buildTools.add('docker');
+    }
+    const hasCompose = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yaml', 'compose.yml'].some(
+      (name) => (fileMap.get(name) || []).length > 0
+    );
+    if (hasCompose) {
+      buildTools.add('docker-compose');
+    }
+
+  } catch {
+    // Ignore errors during glob/analysis
   }
-  if (await fileExists(repoPath, 'docker-compose.yml') || await fileExists(repoPath, 'compose.yaml')) {
-    buildTools.push('docker-compose');
+
+  // Fallback language
+  if (languages.size === 0) {
+    languages.add('other');
   }
 
-  // Fallback
-  if (languages.length === 0) {
-    languages.push('other');
+  // Heuristic for overall projectType
+  let finalProjectType: ProjectType = 'other';
+  if (projectTypes.has('fullstack') || (projectTypes.has('frontend') && projectTypes.has('backend'))) {
+    finalProjectType = 'fullstack';
+  } else if (projectTypes.has('frontend')) {
+    finalProjectType = 'frontend';
+  } else if (projectTypes.has('backend')) {
+    finalProjectType = 'backend';
+  } else if (projectTypes.has('library')) {
+    finalProjectType = 'library';
+  } else if (projectTypes.has('cli')) {
+    finalProjectType = 'cli';
   }
 
   return {
-    languages,
-    frameworks,
-    buildTools,
-    projectType,
+    languages: Array.from(languages),
+    frameworks: Array.from(frameworks),
+    buildTools: Array.from(buildTools),
+    projectType: finalProjectType,
   };
 }

package/src/commands/create.ts

@@ -88,7 +88,8 @@ export async function createCommand(): Promise<void> {
     id: branchName,
     branchName,
     description,
-    repos: selectedRepos.map((r) => r.path),
+    repos: selectedRepos.map((r) => path.join(workspacePath, r.name)),
+    originalRepos: selectedRepos.map((r) => r.path),
     assistants: selectedAI,
     workspacePath,
     createdAt: new Date().toISOString(),
@@ -119,15 +120,20 @@ export async function createCommand(): Promise<void> {
   await generateContextFiles(ctx, selectedAI, workspacePath);
 
   // ── 8.5. Pack codebase context ──────────────────────────────────────
-  const packSpinner = ora('Packing codebase context with Repomix...').start();
-  try {
-    const packResult = await packWorkspace(workspacePath);
-    packSpinner.succeed(
-      `Packed codebase context (${packResult.totalFiles} files, ${(packResult.fileSize / 1024).toFixed(2)} KB)`
-    );
-  } catch (error) {
-    packSpinner.fail('Failed to pack codebase context');
-    console.error(chalk.red(`  ${error}`));
+  if (config.packContextXml) {
+    const packSpinner = ora('Packing codebase context with Repomix...').start();
+    try {
+      const packResult = await packWorkspace(workspacePath);
+      const filesCount = packResult.outputPaths?.length || 1;
+      packSpinner.succeed(
+        `Packed codebase context into ${filesCount} file(s) (${packResult.totalFiles} files total, ${(packResult.fileSize / 1024).toFixed(2)} KB)`
+      );
+    } catch (error) {
+      packSpinner.fail('Failed to pack codebase context');
+      console.error(chalk.red(`  ${error}`));
+    }
+  } else {
+    console.log(chalk.gray('\n  ○ Skipping codebase context packing (packContextXml is disabled)'));
   }
 
   // ── 8. Open in editor ───────────────────────────────────────────────