@mrpatronz/nexusflow 0.2.1 → 0.2.3

package/src/analyzers/messaging-analyzer.ts

@@ -0,0 +1,254 @@
+/**
+ * @module analyzers/messaging-analyzer
+ * Detects publishers and subscribers for pub/sub messaging topologies
+ * across multiple programming languages and frameworks.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { globby } from 'globby';
+import type { MessagingTopology, MessagePublisher, MessageSubscriber } from '../types.js';
+
+/**
+ * Analyzes messaging/event topology in a repository.
+ *
+ * Scans C#, JS/TS, Python, and Go source files for publish and subscribe
+ * patterns and extracts message/event contracts.
+ *
+ * @param repoPath - Absolute path to the repository root.
+ * @returns Detected publishers and subscribers.
+ */
+export async function analyzeMessaging(repoPath: string): Promise<MessagingTopology> {
+  const publishers: MessagePublisher[] = [];
+  const subscribers: MessageSubscriber[] = [];
+
+  try {
+    const files = await globby(
+      ['**/*.ts', '**/*.js', '**/*.cs', '**/*.py', '**/*.go'],
+      {
+        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 > 200_000) continue; // Skip large files
+
+        const content = await fs.readFile(file, 'utf-8');
+        const relPath = path.relative(repoPath, file).replace(/\\/g, '/');
+
+        if (file.endsWith('.cs')) {
+          // ── C# Messaging Patterns ────────────────────────────────────────
+
+          // MediatR notification handler
+          // INotificationHandler<MyNotification>
+          const mediatrSubRegex = /:\s*INotificationHandler\s*<\s*(\w+)\s*>/g;
+          let match: RegExpExecArray | null;
+          while ((match = mediatrSubRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // MediatR command/query handler
+          // IRequestHandler<MyRequest, MyResponse> or IRequestHandler<MyRequest>
+          const requestHandlerRegex = /:\s*IRequestHandler\s*<\s*(\w+)(?:\s*,\s*\w+)?\s*>/g;
+          while ((match = requestHandlerRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // MassTransit Consumer: IConsumer<MyMessage>
+          const massTransitSubRegex = /:\s*IConsumer\s*<\s*(\w+)\s*>/g;
+          while ((match = massTransitSubRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // NServiceBus Handler: IHandleMessages<MyMessage>
+          const nserviceBusSubRegex = /:\s*IHandleMessages\s*<\s*(\w+)\s*>/g;
+          while ((match = nserviceBusSubRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // Azure Service Bus triggers: [ServiceBusTrigger("queueOrTopicName")]
+          const sbtRegex = /\[ServiceBusTrigger\s*\(\s*"([^"]+)"(?:\s*,\s*"[^"]+")?\s*\)\]/g;
+          while ((match = sbtRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: 'ServiceBusMessage',
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // Publishers in C#
+          // .Publish<MyEvent>( or .PublishAsync<MyEvent>( or .Send<MyCommand>( or .SendAsync<MyCommand>(
+          const csPubRegex = /\b(?:Publish|PublishAsync|Send|SendAsync)\s*<\s*(\w+)\s*>\s*\(/g;
+          while ((match = csPubRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'direct/inferred',
+              publisherFile: relPath,
+            });
+          }
+          
+          const mediatorSendRegex = /\bmediator\s*\.\s*(?:Send|Publish)\s*\(\s*new\s+(\w+)\s*\(/gi;
+          while ((match = mediatorSendRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'mediator',
+              publisherFile: relPath,
+            });
+          }
+
+        } else if (file.endsWith('.ts') || file.endsWith('.js')) {
+          // ── TS/JS Messaging Patterns ─────────────────────────────────────
+
+          // EventEmitter emitters: emit('event-name', ...)
+          const tsEmitRegex = /\bemit\s*\(\s*['"`]([^'"`]+)['"`]/g;
+          let match: RegExpExecArray | null;
+          while ((match = tsEmitRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'EventEmitter',
+              publisherFile: relPath,
+            });
+          }
+
+          // EventEmitter listeners: on('event-name', ...) or addListener('event-name', ...)
+          const tsOnRegex = /\b(?:on|addListener)\s*\(\s*['"`]([^'"`]+)['"`]/g;
+          while ((match = tsOnRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // Kafka/RabbitMQ subscribe: topic: 'topic-name' inside subscription object
+          const tsSubTopicRegex = /topic\s*:\s*['"`]([^'"`]+)['"`]/g;
+          while ((match = tsSubTopicRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: 'Kafka/MQ Message',
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // BullMQ add: queue.add('job-name', ...)
+          const bullmqAddRegex = /\badd\s*\(\s*['"`]([^'"`]+)['"`]/g;
+          while ((match = bullmqAddRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'BullMQ',
+              publisherFile: relPath,
+            });
+          }
+
+        } else if (file.endsWith('.py')) {
+          // ── Python Messaging Patterns ────────────────────────────────────
+
+          // Celery task definitions: @app.task or @shared_task
+          const celeryTaskRegex = /@(?:[a-zA-Z0-9_]+\.)?(?:task|shared_task)(?:\([^)]*\))?\s*\n\s*def\s+(\w+)\s*\(/g;
+          let match: RegExpExecArray | null;
+          while ((match = celeryTaskRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: match[1]!,
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+
+          // Celery task invocations: task.delay(...) or task.apply_async(...)
+          const celeryDelayRegex = /\b(\w+)\s*\.\s*(?:delay|apply_async)\s*\(/g;
+          while ((match = celeryDelayRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'Celery',
+              publisherFile: relPath,
+            });
+          }
+
+          // RabbitMQ basic_publish: routing_key='key'
+          const pikaPublishRegex = /routing_key\s*=\s*['"`]([^'"`]+)['"`]/g;
+          while ((match = pikaPublishRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: match[1]!,
+              topicOrQueue: 'RabbitMQ',
+              publisherFile: relPath,
+            });
+          }
+
+        } else if (file.endsWith('.go')) {
+          // ── Go Messaging Patterns ────────────────────────────────────────
+
+          // Go publish/produce calls: Publish("topic", ...) or Produce("topic", ...)
+          const goPubRegex = /\b(?:Publish|Produce|Send)\s*\(\s*['"`]([^'"`]+)['"`]/g;
+          let match: RegExpExecArray | null;
+          while ((match = goPubRegex.exec(content)) !== null) {
+            publishers.push({
+              contractType: 'GoMessage',
+              topicOrQueue: match[1]!,
+              publisherFile: relPath,
+            });
+          }
+
+          // Go subscribe/consume calls: Subscribe("topic", ...) or Consume("topic", ...)
+          const goSubRegex = /\b(?:Subscribe|Consume)\s*\(\s*['"`]([^'"`]+)['"`]/g;
+          while ((match = goSubRegex.exec(content)) !== null) {
+            subscribers.push({
+              contractType: 'GoMessage',
+              handlerFile: relPath,
+              registrationFile: relPath,
+            });
+          }
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  // De-duplicate publishers & subscribers
+  const uniquePublishers: MessagePublisher[] = [];
+  const seenPub = new Set<string>();
+  for (const p of publishers) {
+    const key = `${p.contractType}:${p.topicOrQueue}:${p.publisherFile}`;
+    if (!seenPub.has(key)) {
+      seenPub.add(key);
+      uniquePublishers.push(p);
+    }
+  }
+
+  const uniqueSubscribers: MessageSubscriber[] = [];
+  const seenSub = new Set<string>();
+  for (const s of subscribers) {
+    const key = `${s.contractType}:${s.handlerFile}:${s.registrationFile}`;
+    if (!seenSub.has(key)) {
+      seenSub.add(key);
+      uniqueSubscribers.push(s);
+    }
+  }
+
+  return {
+    publishers: uniquePublishers,
+    subscribers: uniqueSubscribers,
+  };
+}

package/src/analyzers/readme-summarizer.ts

@@ -75,13 +75,18 @@ export async function extractReadmeSummary(
     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)) {
+    // Skip lines that look like: - [About](#about) or 1. [About](#about) or * 1. [Section](#section)
+    if (/^(?:[-*+]\s*|\d+\.\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)) {
+    // Skip link-only lines (e.g., "[API Docs](https://...)")
+    if (/^\[[^\]]+\]\([^)]+\)$/.test(trimmed)) {
+      continue;
+    }
+
+    // Skip standard bullet and numbered lists if we are searching for prose (e.g. at the top of README before prose)
+    if (proseLines.length === 0 && (/^[-*+]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed))) {
       continue;
     }
 

package/src/analyzers/run-analyzer.ts

@@ -0,0 +1,269 @@
+/**
+ * @module analyzers/run-analyzer
+ * Analyzes projects to discover local run configurations, entry points,
+ * database dependencies, external services, and flags shared staging/test
+ * infrastructure or committed secrets.
+ */
+
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { globby } from 'globby';
+import type { RunConfig, RunConfigEntryPoint, RunConfigDatabase, RunConfigSharedInfraWarning, RunConfigSecret } from '../types.js';
+
+/**
+ * Analyzes local run configurations, databases, and dependencies in a repository.
+ *
+ * @param repoPath - Absolute path to the repository root.
+ * @returns Run configuration analysis.
+ */
+export async function analyzeRunConfig(repoPath: string): Promise<RunConfig> {
+  const entryPoints: RunConfigEntryPoint[] = [];
+  const databases: RunConfigDatabase[] = [];
+  const sharedInfraWarnings: RunConfigSharedInfraWarning[] = [];
+  const committedSecrets: RunConfigSecret[] = [];
+  const externalDependencies: string[] = [];
+
+  const isLocalHost = (host: string): boolean => {
+    const h = host.toLowerCase().trim();
+    return (
+      h.includes('localhost') ||
+      h.includes('127.0.0.1') ||
+      h.includes('[::1]') ||
+      h.includes('(localdb)') ||
+      h === 'db' ||
+      h === 'postgres' ||
+      h === 'redis' ||
+      h === 'mongo'
+    );
+  };
+
+  try {
+    // ── 1. Entry Points Detection ──────────────────────────────────────────
+    // A. Check for C# Web/Worker apps
+    const csprojFiles = await globby('**/*.csproj', {
+      cwd: repoPath,
+      absolute: true,
+      ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
+    });
+
+    for (const file of csprojFiles) {
+      try {
+        const content = await fsp.readFile(file, 'utf-8');
+        const relPath = path.relative(repoPath, file).replace(/\\/g, '/');
+        if (content.includes('Sdk="Microsoft.NET.Sdk.Web"')) {
+          entryPoints.push({
+            projectPath: relPath,
+            type: 'aspnet',
+            command: 'dotnet run',
+          });
+        } else if (content.includes('Sdk="Microsoft.NET.Sdk.Worker"')) {
+          entryPoints.push({
+            projectPath: relPath,
+            type: 'worker',
+            command: 'dotnet run',
+          });
+        }
+      } catch {}
+    }
+
+    // B. Check for package.json (Node/JS/TS)
+    const packageJsonPath = path.join(repoPath, 'package.json');
+    try {
+      const raw = await fsp.readFile(packageJsonPath, 'utf-8');
+      const pkg = JSON.parse(raw);
+      if (pkg.scripts && (pkg.scripts.start || pkg.scripts.dev)) {
+        entryPoints.push({
+          projectPath: 'package.json',
+          type: pkg.dependencies && pkg.dependencies.next ? 'nextjs' : 'node',
+          command: pkg.scripts.dev ? 'npm run dev' : 'npm start',
+        });
+      }
+    } catch {}
+
+    // C. Check for Python/Go
+    const goModFiles = await globby('**/go.mod', { cwd: repoPath, absolute: true });
+    if (goModFiles.length > 0) {
+      entryPoints.push({
+        projectPath: path.relative(repoPath, goModFiles[0]!).replace(/\\/g, '/'),
+        type: 'go',
+        command: 'go run .',
+      });
+    }
+
+    const pyFiles = await globby(['**/requirements.txt', '**/Pipfile', '**/pyproject.toml'], { cwd: repoPath, absolute: true });
+    if (pyFiles.length > 0) {
+      entryPoints.push({
+        projectPath: path.relative(repoPath, pyFiles[0]!).replace(/\\/g, '/'),
+        type: 'python',
+        command: 'python main.py',
+      });
+    }
+
+    // ── 2. Config Files Parsing (DBs, Shared Infra, Secrets) ───────────────
+    const configFiles = await globby(
+      ['**/appsettings.json', '**/appsettings.Development.json', '**/appsettings.*.json', '**/.env', '**/.env.development', '**/.env.local'],
+      {
+        cwd: repoPath,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/bin/**', '**/obj/**', '**/dist/**', '**/out/**', '**/.git/**'],
+      }
+    );
+
+    for (const file of configFiles) {
+      try {
+        const content = await fsp.readFile(file, 'utf-8');
+        const relPath = path.relative(repoPath, file).replace(/\\/g, '/');
+
+        // Secrets Check (Universal regex for high probability secrets)
+        const secretRegex = /(?:password|pwd|secret|key|token|privatekey|accountkey|sharedaccesskey)\s*[=:]\s*['"`]?([^'";\s]{12,})['"`]?/gi;
+        let secretMatch: RegExpExecArray | null;
+        while ((secretMatch = secretRegex.exec(content)) !== null) {
+          const matchedVal = secretMatch[1]!;
+          // Skip if it looks like a placeholder
+          if (!matchedVal.includes('placeholder') && !matchedVal.includes('<your') && !matchedVal.toLowerCase().includes('your_')) {
+            committedSecrets.push({
+              file: relPath,
+              lineHint: secretMatch[0]!.split(/[=:]/)[0]!.trim(),
+            });
+          }
+        }
+
+        if (file.endsWith('.json')) {
+          const parsed = JSON.parse(content);
+          
+          // connectionStrings
+          if (parsed.ConnectionStrings) {
+            for (const [key, value] of Object.entries(parsed.ConnectionStrings)) {
+              if (typeof value === 'string') {
+                let provider = 'unknown';
+                if (value.toLowerCase().includes('sql server') || value.toLowerCase().includes('sqlexpress') || value.toLowerCase().includes('server=')) {
+                  provider = 'SQL Server';
+                }
+                if (value.toLowerCase().includes('postgresql') || value.toLowerCase().includes('port=5432')) {
+                  provider = 'PostgreSQL';
+                }
+
+                // Extract Host
+                const hostMatch = value.match(/Server=([^;]+)/i) ?? value.match(/Host=([^;]+)/i) ?? value.match(/Data Source=([^;]+)/i);
+                const host = hostMatch ? hostMatch[1]!.trim() : 'unknown';
+
+                databases.push({
+                  provider,
+                  host,
+                  configFile: relPath,
+                });
+
+                if (host !== 'unknown' && !isLocalHost(host)) {
+                  sharedInfraWarnings.push({
+                    resource: key,
+                    host,
+                    configFile: relPath,
+                    warning: `⚠️ SHARED INFRA: ${relPath} binds ConnectionString "${key}" to non-local host (${host}). Running locally may connect to shared test/production databases.`,
+                  });
+                }
+              }
+            }
+          }
+
+          // Service Bus or MQ settings
+          const rabbitRegex = /"HostName"\s*:\s*"([^"]+)"/gi;
+          let rabbitMatch: RegExpExecArray | null;
+          while ((rabbitMatch = rabbitRegex.exec(content)) !== null) {
+            const host = rabbitMatch[1]!;
+            if (!isLocalHost(host)) {
+              sharedInfraWarnings.push({
+                resource: 'RabbitMQ',
+                host,
+                configFile: relPath,
+                warning: `⚠️ SHARED INFRA: ${relPath} binds RabbitMQ host to non-local host (${host}).`,
+              });
+            }
+          }
+        } else {
+          // B. .env parsing
+          const lines = content.split('\n');
+          for (const line of lines) {
+            const cleanLine = line.trim();
+            if (cleanLine.startsWith('#') || !cleanLine.includes('=')) continue;
+
+            const [key, val] = cleanLine.split('=', 2);
+            if (!key || !val) continue;
+
+            const cleanKey = key.trim();
+            const cleanVal = val.trim().replace(/^['"]|['"]$/g, '');
+
+            // DB UrL e.g. DATABASE_URL=postgres://user:pass@host:port/db
+            if (cleanKey.includes('DATABASE_URL') || cleanKey.includes('MONGODB_URI') || cleanKey.includes('REDIS_URL')) {
+              let provider = 'unknown';
+              if (cleanVal.startsWith('postgres')) provider = 'PostgreSQL';
+              else if (cleanVal.startsWith('mongodb')) provider = 'MongoDB';
+              else if (cleanVal.startsWith('redis')) provider = 'Redis';
+
+              // Extract Host from URL
+              const hostMatch = cleanVal.match(/@([^:/]+)/);
+              const host = hostMatch ? hostMatch[1]! : cleanVal;
+
+              databases.push({
+                provider,
+                host,
+                configFile: relPath,
+              });
+
+              if (!isLocalHost(host)) {
+                sharedInfraWarnings.push({
+                  resource: cleanKey,
+                  host,
+                  configFile: relPath,
+                  warning: `⚠️ SHARED INFRA: .env variable "${cleanKey}" points to non-local host (${host}).`,
+                });
+              }
+            }
+          }
+        }
+      } catch {}
+    }
+
+  } catch {
+    // Ignore errors
+  }
+
+  // De-duplicate external dependencies / warnings
+  const uniqueInfraWarnings: RunConfigSharedInfraWarning[] = [];
+  const seenInfra = new Set<string>();
+  for (const w of sharedInfraWarnings) {
+    const key = `${w.resource}:${w.host}:${w.configFile}`;
+    if (!seenInfra.has(key)) {
+      seenInfra.add(key);
+      uniqueInfraWarnings.push(w);
+    }
+  }
+
+  const uniqueDatabases: RunConfigDatabase[] = [];
+  const seenDb = new Set<string>();
+  for (const db of databases) {
+    const key = `${db.provider}:${db.host}:${db.configFile}`;
+    if (!seenDb.has(key)) {
+      seenDb.add(key);
+      uniqueDatabases.push(db);
+    }
+  }
+
+  const uniqueSecrets: RunConfigSecret[] = [];
+  const seenSecret = new Set<string>();
+  for (const s of committedSecrets) {
+    const key = `${s.file}:${s.lineHint}`;
+    if (!seenSecret.has(key)) {
+      seenSecret.add(key);
+      uniqueSecrets.push(s);
+    }
+  }
+
+  return {
+    entryPoints,
+    databases: uniqueDatabases,
+    sharedInfraWarnings: uniqueInfraWarnings,
+    committedSecrets: uniqueSecrets,
+    externalDependencies,
+  };
+}

package/src/core/config.ts

@@ -32,7 +32,7 @@ export function getDefaultConfig(): NexusFlowConfig {
     workspacesDir: path.join(os.homedir(), 'dev', 'workspaces'),
     defaultAssistant: null,
     scanDepth: 2,
-    packContextXml: true,
+    packContextXml: false,
     excludePatterns: [
       '**/node_modules/**',
       '**/bin/**',

package/src/generators/base.ts

@@ -17,7 +17,7 @@ function formatProjectSection(analysis: ProjectAnalysis, workspacePath: string):
   lines.push(`### ${analysis.name}`);
 
   const mapPath = path.join(workspacePath, `nexusflow-map-${analysis.name}.md`).replace(/\\/g, '/');
-  lines.push(`- **Architecture Map**: [nexusflow-map-${analysis.name}.md](file:///${mapPath}) — **Instruction**: You MUST read this architecture map before exploring or modifying the \`${analysis.name}\` repository to understand its layout, API endpoints, test commands, and detected usage patterns.`);
+  lines.push(`- **Architecture Map**: [nexusflow-map-${analysis.name}.md](file:///${mapPath}) — **Instruction**: Before modifying this repository, read its architecture map. For exploration, consult the map's section index on demand.`);
 
   // Tech stack
   const { techStack } = analysis;
@@ -47,15 +47,7 @@ function formatProjectSection(analysis: ProjectAnalysis, workspacePath: string):
 
   // API endpoints
   if (analysis.endpoints.length > 0) {
-    lines.push(`- **API endpoints** (${analysis.endpoints.length} detected):`);
-    // Show up to 10 endpoints
-    const shown = analysis.endpoints.slice(0, 10);
-    for (const ep of shown) {
-      lines.push(`  - \`${ep.method} ${ep.path}\``);
-    }
-    if (analysis.endpoints.length > 10) {
-      lines.push(`  - _...and ${analysis.endpoints.length - 10} more_`);
-    }
+    lines.push(`- **API surface**: ${analysis.endpoints.length} endpoints — see architecture map for details`);
   }
 
   // Ports
@@ -128,24 +120,18 @@ ${allConfigs.join('\n')}
     if (mockCommand) parts.push(`- **Setup/Mock Command**: \`${mockCommand}\``);
     if (startCommand) parts.push(`- **Start/Run Command**: \`${startCommand}\``);
     
+    const standardCommands = [
+      'npm run test', 'npm test', 'npm t', 'yarn test', 'yarn t', 'pnpm test', 'pnpm t', 'bun test',
+      'dotnet test',
+      'pytest', 'python -m unittest', 'python -m pytest',
+      'go test', 'go test ./...',
+      'cargo test',
+    ];
+
     if (testCommand) {
-      if (testCommand === 'npm run test') {
-        const hasJs = repos.some(r => {
-          const a = analysis?.get(r.path);
-          return a?.techStack.languages.includes('typescript') || a?.techStack.languages.includes('javascript');
-        });
-        const hasCsharp = repos.some(r => {
-          const a = analysis?.get(r.path);
-          return a?.techStack.languages.includes('csharp');
-        });
-
-        if (hasCsharp && !hasJs) {
-          testCommand = 'dotnet test';
-        } else if (!hasJs && !hasCsharp) {
-          testCommand = undefined;
-        }
-      }
-      if (testCommand) {
+      const normalizedCmd = testCommand.trim().toLowerCase();
+      const isStandard = standardCommands.some(cmd => normalizedCmd === cmd || normalizedCmd.startsWith(cmd + ' '));
+      if (!isStandard) {
         parts.push(`- **Verification/Test Command**: \`${testCommand}\``);
       }
     }
@@ -163,39 +149,16 @@ ${parts.join('\n')}
     }
   }
 
-  // Check if overview.md already exists
-  const overviewFile = path.join(workspacePath, 'nexusflow-overview.md');
-  const hasOverview = fs.existsSync(overviewFile);
-
-  let taskSection = '';
-  if (hasOverview) {
-    taskSection = `## Task & Step-by-Step Maintenance
-
-The universal reference file **\`nexusflow-overview.md\`** has already been created. Your task is to:
-
-1. **Keep it Updated**: Maintain and update \`nexusflow-overview.md\` with any new architectural findings, layout changes, or assumptions.
-2. **Review Assumptions**: Ensure that inter-repo relationships and package dependencies documented there reflect the current codebase.
-3. **Address Open Questions**: If there are outstanding items in the "Clarifying Questions for the User" section, discuss them with the user.
-`;
-  } else {
-    taskSection = `## Task & Step-by-Step Initialization
+  const knowledgePath = path.join(workspacePath, 'nexusflow-knowledge.md').replace(/\\/g, '/');
 
-Your very first task upon entering this workspace is to analyze the codebase and document it in a universal reference file:
+  const taskSection = `## First Steps
 
-1. **Create \`nexusflow-overview.md\`** at the workspace root.
-2. **Project Assumptions**: For each project, write down a clear assumption of what it does, its primary tech stack, and its core responsibilities.
-3. **Inter-Repo Relationships**: Document how the repos relate:
-   - Shared libraries/packages (producers and consumers).
-   - API boundaries (which repos expose APIs, which ones consume them).
-   - Data flows and dependencies.
-4. **Clarifying Questions**: If any feature requirements, architectural patterns, or API contracts are unclear, list them explicitly under a section called **"Clarifying Questions for the User"**.
-5. **Universal Reference**: Keep this file updated. This acts as a universal reference so that any LLM assistant (Claude, Antigravity, Codex, Cursor, Copilot) joining this workspace instantly understands the project landscape.
+Your very first task upon entering this workspace is to explore the codebase and align with the user:
 
-Once you have created \`nexusflow-overview.md\` and compiled your questions, ask the user to verify your assumptions and answer your questions before proceeding to write code.
+1. **Verify Assumptions**: Open [nexusflow-knowledge.md](file:///${knowledgePath}) and fill in the **Project Assumptions** section with a brief description of what each project does, its tech stack, and responsibilities.
+2. **Raise Questions**: Document any outstanding uncertainties or architectural questions in the **Clarifying Questions for the User** section.
+3. **Obtain Approval**: Ask the user to confirm your assumptions and answer your questions before writing any code.
 `;
-  }
-
-  const knowledgePath = path.join(workspacePath, 'nexusflow-knowledge.md').replace(/\\/g, '/');
 
   return `# Multi-Repo Workspace Context