@mrpatronz/nexusflow 0.1.0

package/src/index.ts

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+/**
+ * @module index
+ * NexusFlow CLI entry point.
+ *
+ * Combines multiple repositories into a workspace with rich AI assistant
+ * context files so tools like Claude, Codex, Copilot, and Cursor understand
+ * your entire project.
+ */
+
+import { Command } from 'commander';
+
+import { createCommand } from './commands/create.js';
+import { listCommand } from './commands/list.js';
+import { openCommand } from './commands/open.js';
+import { initCommand } from './commands/init.js';
+import { startCommand } from './commands/start.js';
+import { stopCommand } from './commands/stop.js';
+import { logsCommand } from './commands/logs.js';
+import { statusCommand } from './commands/status.js';
+import { uiCommand } from './commands/ui.js';
+
+const program = new Command();
+
+program
+  .name('nexusflow')
+  .description(
+    'Combine multiple repos into a workspace with rich AI assistant context',
+  )
+  .version('0.1.0');
+
+program
+  .command('create')
+  .description(
+    'Create a new feature workspace — pick repos, pick AI assistants, generate context',
+  )
+  .action(async () => {
+    try {
+      await createCommand();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('list')
+  .alias('ls')
+  .description('List all existing workspaces')
+  .action(async () => {
+    try {
+      await listCommand();
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('open')
+  .description('Re-open an existing workspace in an editor')
+  .action(async () => {
+    try {
+      await openCommand();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('init')
+  .description('Initialize NexusFlow configuration')
+  .action(async () => {
+    try {
+      await initCommand();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('start')
+  .description('Start all services in a workspace')
+  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
+  .action(async (workspace?: string) => {
+    try {
+      await startCommand(workspace);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('stop')
+  .description('Stop all running services in a workspace')
+  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
+  .action(async (workspace?: string) => {
+    try {
+      await stopCommand(workspace);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('logs')
+  .description('Show logs from running services')
+  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
+  .option('-n, --lines <number>', 'Number of lines per service', '30')
+  .action(async (workspace: string | undefined, options: { lines: string }) => {
+    try {
+      await logsCommand(workspace, parseInt(options.lines, 10));
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Show status of running services')
+  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
+  .action(async (workspace?: string) => {
+    try {
+      await statusCommand(workspace);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('User force closed')) {
+        console.log('\nCancelled.');
+        process.exit(0);
+      }
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('ui')
+  .description('Open the web GUI dashboard for NexusFlow')
+  .option('-p, --port <number>', 'Port to run the dashboard server on', '3000')
+  .action(async (options: { port?: string }) => {
+    try {
+      await uiCommand(options);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/orchestration/detect.ts

@@ -0,0 +1,313 @@
+/**
+ * @module orchestration/detect
+ * Detects how to start each project in a workspace, and finds existing
+ * orchestration tools (Docker Compose, .NET Aspire, etc.).
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import type { ServiceConfig, OrchestrationDetection } from '../types.js';
+
+/**
+ * Detects existing orchestration tool configs in a directory.
+ *
+ * @param dir - Directory to scan (workspace root or repo root).
+ * @returns Array of detected orchestration tools.
+ */
+export async function detectOrchestrationTools(
+  dir: string,
+): Promise<OrchestrationDetection[]> {
+  const results: OrchestrationDetection[] = [];
+
+  async function scan(folder: string, prefix = '') {
+    // Docker Compose
+    const composeFiles = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yaml', 'compose.yml'];
+    for (const file of composeFiles) {
+      const filePath = path.join(folder, file);
+      try {
+        await fs.access(filePath);
+        results.push({
+          tool: 'docker-compose',
+          configPath: filePath,
+          startCommand: `docker compose -f "${prefix ? path.join(prefix, file) : file}" up -d`,
+          stopCommand: `docker compose -f "${prefix ? path.join(prefix, file) : file}" down`,
+        });
+        break; // Only use the first found
+      } catch { /* not found */ }
+    }
+
+    // .NET Aspire (look for *.AppHost directories or *.AppHost.csproj)
+    try {
+      const entries = await fs.readdir(folder);
+      for (const entry of entries) {
+        if (entry.endsWith('.AppHost') || entry.includes('AppHost')) {
+          const entryPath = path.join(folder, entry);
+          const stat = await fs.stat(entryPath);
+          if (stat.isDirectory()) {
+            // Check for .csproj inside
+            const subEntries = await fs.readdir(entryPath);
+            const csproj = subEntries.find((e) => e.endsWith('.csproj'));
+            if (csproj) {
+              const projectPath = prefix ? path.join(prefix, entry, csproj) : path.join(entry, csproj);
+              results.push({
+                tool: 'aspire',
+                configPath: path.join(entryPath, csproj),
+                startCommand: `dotnet run --project "${projectPath}"`,
+                stopCommand: 'Ctrl+C (Aspire runs in foreground)',
+              });
+            }
+          }
+        }
+      }
+    } catch { /* ignore */ }
+
+    // Tilt
+    try {
+      const tiltPath = path.join(folder, 'Tiltfile');
+      await fs.access(tiltPath);
+      results.push({
+        tool: 'tilt',
+        configPath: tiltPath,
+        startCommand: prefix ? `tilt up --file ${path.join(prefix, 'Tiltfile')}` : 'tilt up',
+        stopCommand: prefix ? `tilt down --file ${path.join(prefix, 'Tiltfile')}` : 'tilt down',
+      });
+    } catch { /* not found */ }
+
+    // Procfile
+    try {
+      const procPath = path.join(folder, 'Procfile');
+      await fs.access(procPath);
+      results.push({
+        tool: 'procfile',
+        configPath: procPath,
+        startCommand: prefix ? `honcho start -f ${path.join(prefix, 'Procfile')}` : 'honcho start',
+        stopCommand: 'Ctrl+C',
+      });
+    } catch { /* not found */ }
+
+    // Makefile
+    try {
+      const makePath = path.join(folder, 'Makefile');
+      const content = await fs.readFile(makePath, 'utf-8');
+      if (content.includes('start:') || content.includes('dev:') || content.includes('run:')) {
+        const makeCmd = prefix ? `make -C "${prefix}" dev` : 'make dev';
+        results.push({
+          tool: 'makefile',
+          configPath: makePath,
+          startCommand: makeCmd,
+          stopCommand: 'Ctrl+C',
+        });
+      }
+    } catch { /* not found */ }
+  }
+
+  // Scan root directory
+  await scan(dir);
+
+  // Scan subdirectories
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+        await scan(path.join(dir, entry.name), entry.name);
+      }
+    }
+  } catch { /* ignore */ }
+
+  return results;
+}
+
+/**
+ * Detects how to start a single project based on its manifest files.
+ *
+ * @param projectPath - Absolute path to the project directory.
+ * @param projectName - Display name of the project.
+ * @returns A ServiceConfig if a start command was detected, null otherwise.
+ */
+export async function detectServiceConfig(
+  projectPath: string,
+  projectName: string,
+): Promise<ServiceConfig | null> {
+  // ── Node.js (package.json) ────────────────────────────────────────
+  try {
+    const raw = await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(raw) as Record<string, unknown>;
+    const scripts = pkg.scripts as Record<string, string> | undefined;
+
+    if (scripts) {
+      // Priority: dev > start > serve
+      const scriptName = scripts['dev'] ? 'dev' : scripts['start'] ? 'start' : scripts['serve'] ? 'serve' : null;
+      if (scriptName) {
+        // Detect port from script content
+        const scriptContent = scripts[scriptName]!;
+        const portMatch = scriptContent.match(/--port\s+(\d+)/i) ?? scriptContent.match(/-p\s+(\d+)/);
+        const port = portMatch ? parseInt(portMatch[1]!, 10) : undefined;
+
+        return {
+          name: projectName,
+          cwd: projectPath,
+          command: 'npm',
+          args: ['run', scriptName],
+          port,
+          source: 'package.json',
+        };
+      }
+    }
+  } catch { /* no package.json */ }
+
+  // ── .NET (*.csproj) ───────────────────────────────────────────────
+  try {
+    const entries = await fs.readdir(projectPath);
+    const csproj = entries.find((e) => e.endsWith('.csproj'));
+    if (csproj) {
+      // Check launchSettings for port
+      let port: number | undefined;
+      try {
+        const raw = await fs.readFile(
+          path.join(projectPath, 'Properties', 'launchSettings.json'),
+          'utf-8',
+        );
+        const settings = JSON.parse(raw) as Record<string, unknown>;
+        const profiles = settings.profiles as Record<string, Record<string, unknown>> | undefined;
+        if (profiles) {
+          const firstProfile = Object.values(profiles)[0];
+          const appUrl = firstProfile?.applicationUrl as string | undefined;
+          if (appUrl) {
+            const portMatch = appUrl.match(/:(\d+)/);
+            if (portMatch) port = parseInt(portMatch[1]!, 10);
+          }
+        }
+      } catch { /* no launchSettings */ }
+
+      return {
+        name: projectName,
+        cwd: projectPath,
+        command: 'dotnet',
+        args: ['run'],
+        port,
+        source: 'dotnet',
+      };
+    }
+  } catch { /* ignore */ }
+
+  // ── Python ────────────────────────────────────────────────────────
+  try {
+    await fs.access(path.join(projectPath, 'manage.py'));
+    return {
+      name: projectName,
+      cwd: projectPath,
+      command: 'python',
+      args: ['manage.py', 'runserver'],
+      port: 8000,
+      source: 'python',
+    };
+  } catch { /* not Django */ }
+
+  try {
+    // Check for main.py or app.py (FastAPI/Flask)
+    const hasAppPy = await fs.access(path.join(projectPath, 'app.py')).then(() => true).catch(() => false);
+    const hasMainPy = await fs.access(path.join(projectPath, 'main.py')).then(() => true).catch(() => false);
+
+    if (hasMainPy || hasAppPy) {
+      const entryFile = hasMainPy ? 'main.py' : 'app.py';
+      const content = await fs.readFile(path.join(projectPath, entryFile), 'utf-8');
+
+      if (content.includes('FastAPI') || content.includes('fastapi')) {
+        return {
+          name: projectName,
+          cwd: projectPath,
+          command: 'uvicorn',
+          args: [`${entryFile.replace('.py', '')}:app`, '--reload'],
+          port: 8000,
+          source: 'python',
+        };
+      }
+
+      if (content.includes('Flask') || content.includes('flask')) {
+        return {
+          name: projectName,
+          cwd: projectPath,
+          command: 'python',
+          args: [entryFile],
+          port: 5000,
+          source: 'python',
+        };
+      }
+    }
+  } catch { /* ignore */ }
+
+  // ── Go ────────────────────────────────────────────────────────────
+  try {
+    await fs.access(path.join(projectPath, 'go.mod'));
+    return {
+      name: projectName,
+      cwd: projectPath,
+      command: 'go',
+      args: ['run', '.'],
+      source: 'go',
+    };
+  } catch { /* no go.mod */ }
+
+  // ── Makefile ──────────────────────────────────────────────────────
+  try {
+    const content = await fs.readFile(path.join(projectPath, 'Makefile'), 'utf-8');
+    if (content.includes('dev:')) {
+      return { name: projectName, cwd: projectPath, command: 'make', args: ['dev'], source: 'makefile' };
+    }
+    if (content.includes('run:')) {
+      return { name: projectName, cwd: projectPath, command: 'make', args: ['run'], source: 'makefile' };
+    }
+  } catch { /* no Makefile */ }
+
+  return null;
+}
+
+/**
+ * Detects service configs for all projects in a workspace.
+ *
+ * @param workspacePath - Absolute path to the workspace root.
+ * @returns Array of detected ServiceConfig objects.
+ */
+export async function detectAllServices(
+  workspacePath: string,
+): Promise<ServiceConfig[]> {
+  const services: ServiceConfig[] = [];
+
+  let entries: import('node:fs').Dirent[];
+  try {
+    entries = await fs.readdir(workspacePath, { withFileTypes: true });
+  } catch {
+    return services;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    // Skip hidden dirs and known non-project dirs
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+    const projectPath = path.join(workspacePath, entry.name);
+    const config = await detectServiceConfig(projectPath, entry.name);
+    if (config) {
+      services.push(config);
+      continue;
+    }
+
+    // If no config at the root, check first-level subdirectories of this project (e.g. nested packages)
+    try {
+      const subEntries = await fs.readdir(projectPath, { withFileTypes: true });
+      for (const subEntry of subEntries) {
+        if (!subEntry.isDirectory()) continue;
+        if (subEntry.name.startsWith('.') || subEntry.name === 'node_modules') continue;
+
+        const subProjectPath = path.join(projectPath, subEntry.name);
+        const subConfig = await detectServiceConfig(subProjectPath, `${entry.name}/${subEntry.name}`);
+        if (subConfig) {
+          services.push(subConfig);
+        }
+      }
+    } catch { /* ignore read errors */ }
+  }
+
+  return services;
+}

package/src/orchestration/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @module orchestration/index
+ * Re-exports all orchestration modules.
+ */
+
+export { detectOrchestrationTools, detectServiceConfig, detectAllServices } from './detect.js';
+export { startServices, stopServices, getServiceStatus, showLogs, loadRunningState } from './runner.js';