@mrpatronz/nexusflow 0.2.12 → 0.2.13

package/src/commands/refresh.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { select } from '@inquirer/prompts';
+import { select, search } from '@inquirer/prompts';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 
@@ -117,7 +117,7 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
   }
 
   const cwdFeature = await loadFeatureConfig(process.cwd());
-  if (cwdFeature) return process.cwd();
+  if (cwdFeature) return cwdFeature.workspacePath;
 
   const config = await loadConfig();
   const workspaces = await listWorkspaces(config.workspacesDir);
@@ -127,12 +127,20 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
     return null;
   }
 
-  const selected = await select({
-    message: 'Select a workspace to refresh:',
-    choices: workspaces.map((ws) => ({
-      name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
-      value: ws.workspacePath,
-    })),
+  const selected = await search({
+    message: 'Search and select a workspace to refresh:',
+    source: async (input) => {
+      const query = (input || '').toLowerCase();
+      const filtered = workspaces.filter(
+        (ws) =>
+          ws.branchName.toLowerCase().includes(query) ||
+          ws.workspacePath.toLowerCase().includes(query)
+      );
+      return filtered.map((ws) => ({
+        name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
+        value: ws.workspacePath,
+      }));
+    },
   });
 
   return selected;

package/src/commands/remove.ts

@@ -5,7 +5,7 @@
 
 import chalk from 'chalk';
 import ora from 'ora';
-import { select, confirm } from '@inquirer/prompts';
+import { select, confirm, search } from '@inquirer/prompts';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 
@@ -52,12 +52,20 @@ export async function removeCommand(workspaceArg?: string): Promise<void> {
       return;
     }
 
-    const selected = await select({
-      message: 'Select a workspace to delete:',
-      choices: workspaces.map((ws) => ({
-        name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
-        value: ws,
-      })),
+    const selected = await search({
+      message: 'Search and select a workspace to delete:',
+      source: async (input) => {
+        const query = (input || '').toLowerCase();
+        const filtered = workspaces.filter(
+          (ws) =>
+            ws.branchName.toLowerCase().includes(query) ||
+            ws.workspacePath.toLowerCase().includes(query)
+        );
+        return filtered.map((ws) => ({
+          name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
+          value: ws,
+        }));
+      },
     });
 
     workspacePath = selected.workspacePath;

package/src/commands/start.ts

@@ -93,7 +93,7 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
 
   // Check if CWD is a workspace
   const cwdFeature = await loadFeatureConfig(process.cwd());
-  if (cwdFeature) return process.cwd();
+  if (cwdFeature) return cwdFeature.workspacePath;
 
   // Otherwise, list workspaces and let user pick
   const config = await loadConfig();

package/src/commands/status.ts

@@ -32,7 +32,7 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
   if (workspaceArg) return workspaceArg;
 
   const cwdFeature = await loadFeatureConfig(process.cwd());
-  if (cwdFeature) return process.cwd();
+  if (cwdFeature) return cwdFeature.workspacePath;
 
   const config = await loadConfig();
   const workspaces = await listWorkspaces(config.workspacesDir);

package/src/commands/stop.ts

@@ -33,7 +33,7 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
   if (workspaceArg) return workspaceArg;
 
   const cwdFeature = await loadFeatureConfig(process.cwd());
-  if (cwdFeature) return process.cwd();
+  if (cwdFeature) return cwdFeature.workspacePath;
 
   const config = await loadConfig();
   const workspaces = await listWorkspaces(config.workspacesDir);

package/src/commands/sync.ts

@@ -4,7 +4,7 @@
  */
 
 import chalk from 'chalk';
-import { select } from '@inquirer/prompts';
+import { select, search } from '@inquirer/prompts';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
 
@@ -123,7 +123,7 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
   }
 
   const cwdFeature = await loadFeatureConfig(process.cwd());
-  if (cwdFeature) return process.cwd();
+  if (cwdFeature) return cwdFeature.workspacePath;
 
   const config = await loadConfig();
   const workspaces = await listWorkspaces(config.workspacesDir);
@@ -133,12 +133,20 @@ async function resolveWorkspace(workspaceArg?: string): Promise<string | null> {
     return null;
   }
 
-  const selected = await select({
-    message: 'Select a workspace to sync:',
-    choices: workspaces.map((ws) => ({
-      name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
-      value: ws.workspacePath,
-    })),
+  const selected = await search({
+    message: 'Search and select a workspace to sync:',
+    source: async (input) => {
+      const query = (input || '').toLowerCase();
+      const filtered = workspaces.filter(
+        (ws) =>
+          ws.branchName.toLowerCase().includes(query) ||
+          ws.workspacePath.toLowerCase().includes(query)
+      );
+      return filtered.map((ws) => ({
+        name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
+        value: ws.workspacePath,
+      }));
+    },
   });
 
   return selected;

package/src/core/workspace.ts

@@ -82,6 +82,27 @@ export async function createWorkspace(
     console.warn('Warning: Failed to create .vscode/settings.json:', error);
   }
 
+  // Create .cursor/mcp.json for workspace-local Cursor MCP configuration
+  try {
+    const cursorDir = path.join(workspacePath, '.cursor');
+    await fs.mkdir(cursorDir, { recursive: true });
+    const cursorMcp = {
+      "mcpServers": {
+        "nexusflow": {
+          "command": "npx",
+          "args": ["-y", "@mrpatronz/nexusflow", "mcp", "run", workspacePath]
+        }
+      }
+    };
+    await fs.writeFile(
+      path.join(cursorDir, 'mcp.json'),
+      JSON.stringify(cursorMcp, null, 2) + '\n',
+      'utf-8'
+    );
+  } catch (error) {
+    console.warn('Warning: Failed to create .cursor/mcp.json:', error);
+  }
+
   // Create a worktree for each repo inside the workspace.
   for (const repo of repos) {
     const worktreeTarget = path.join(workspacePath, repo.name);
@@ -173,8 +194,10 @@ export async function saveFeatureConfig(
 export async function loadFeatureConfig(
   workspacePath: string,
 ): Promise<Feature | null> {
-  const manifestPath = path.join(workspacePath, MANIFEST_FILE);
+  const rootDir = await findWorkspaceRoot(workspacePath);
+  if (!rootDir) return null;
 
+  const manifestPath = path.join(rootDir, MANIFEST_FILE);
   try {
     const raw = await fs.readFile(manifestPath, 'utf-8');
     return JSON.parse(raw) as Feature;
@@ -183,6 +206,30 @@ export async function loadFeatureConfig(
   }
 }
 
+/**
+ * Traverses up parent directories to find a directory containing `nexusflow.json`.
+ *
+ * @param startPath - Path to start searching from.
+ * @returns Absolute path to the workspace root directory, or null if not found.
+ */
+export async function findWorkspaceRoot(startPath: string): Promise<string | null> {
+  let current = path.resolve(startPath);
+  while (true) {
+    const manifestPath = path.join(current, MANIFEST_FILE);
+    try {
+      await fs.access(manifestPath);
+      return current;
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) {
+        break; // Reached root directory
+      }
+      current = parent;
+    }
+  }
+  return null;
+}
+
 /**
  * Resolves a repo path to a full RepoInfo object.
  *

package/src/generators/index.ts

@@ -178,6 +178,7 @@ export async function generateContextFiles(
     }
   }
 
+  // Generate configuration for each selected assistant
   for (const assistant of assistants) {
     const entry = GENERATORS[assistant];
 
@@ -196,6 +197,25 @@ export async function generateContextFiles(
     }
   }
 
+  // Ensure AGENTS.md is always generated if it is not already generated as a primary assistant file,
+  // since it is the universal standard for AI coding agents.
+  const hasAgentsGen = assistants.includes('antigravity') || assistants.includes('codex');
+  if (!hasAgentsGen) {
+    try {
+      await generateAntigravityConfig(ctx, workspacePath);
+      console.log(
+        chalk.green('  ✔'),
+        `Generated fallback ${chalk.bold('AGENTS.md')} for harness context`,
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(
+        chalk.red('  ✖'),
+        `Failed to generate fallback AGENTS.md: ${message}`,
+      );
+    }
+  }
+
 
   // Generate implementation plan from dependency analysis (if analysis data available)
   try {

package/src/orchestration/runner.ts

@@ -1,22 +1,19 @@
 /**
  * @module orchestration/runner
  * Manages the lifecycle of services — start, stop, status, and log streaming.
- * Spawns child processes and tracks them via a state file.
+ * Uses PM2 for process management.
  */
 
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { spawn, type ChildProcess } from 'node:child_process';
 import chalk from 'chalk';
+import { execa } from 'execa';
 
 import type { ServiceConfig, RunningService, RunningState } from '../types.js';
 
 /** Name of the state file that tracks running services. */
 const STATE_FILE = '.nexusflow-running.json';
 
-/** Active child processes tracked in memory. */
-const activeProcesses = new Map<string, ChildProcess>();
-
 /**
  * Returns the path to the running-state file for a workspace.
  */
@@ -25,12 +22,39 @@ function getStatePath(workspacePath: string): string {
 }
 
 /**
- * Loads the running state from disk.
+ * Loads the running state from disk, syncing active status with PM2.
  */
 export async function loadRunningState(workspacePath: string): Promise<RunningState | null> {
   try {
     const raw = await fs.readFile(getStatePath(workspacePath), 'utf-8');
-    return JSON.parse(raw) as RunningState;
+    const state = JSON.parse(raw) as RunningState;
+
+    try {
+      // Query current PM2 process list to verify actual running status
+      const { stdout } = await execa('npx', ['pm2', 'jlist']);
+      const pm2List = JSON.parse(stdout);
+      const workspaceId = path.basename(workspacePath);
+      const prefix = `nexusflow-${workspaceId}-`;
+
+      const activeServices = state.services.map((service) => {
+        const uniqueName = `${prefix}${service.name}`;
+        const pm2App = pm2List.find((app: any) => app.name === uniqueName);
+        const running = pm2App && pm2App.pm2_env?.status === 'online';
+        return {
+          ...service,
+          pid: running ? (pm2App.pid || service.pid) : 0,
+        };
+      }).filter((service) => service.pid > 0);
+
+      return {
+        ...state,
+        services: activeServices,
+        updatedAt: new Date().toISOString(),
+      };
+    } catch {
+      // Fallback to cached state on disk if PM2 query fails
+      return state;
+    }
   } catch {
     return null;
   }
@@ -56,20 +80,7 @@ async function clearRunningState(workspacePath: string): Promise<void> {
 }
 
 /**
- * Checks if a process with the given PID is still running.
- */
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Starts all services in the given list.
- * Each service is spawned as a detached child process.
+ * Starts all services in the given list using PM2.
  *
  * @param services      - Services to start.
  * @param workspacePath - Workspace root path.
@@ -84,63 +95,66 @@ export async function startServices(
   await fs.mkdir(logDir, { recursive: true });
 
   const runningServices: RunningService[] = [];
+  const workspaceId = path.basename(workspacePath);
 
   for (const service of services) {
     const logFile = path.join(logDir, `${service.name}.log`);
     const portStr = service.port ? ` on port ${service.port}` : '';
+    const uniqueName = `nexusflow-${workspaceId}-${service.name}`;
 
     console.log(
-      chalk.cyan(`  Starting ${chalk.bold(service.name)}${portStr}...`),
+      chalk.cyan(`  Starting ${chalk.bold(service.name)}${portStr} under PM2...`),
     );
     console.log(
       chalk.dim(`    ${service.command} ${service.args.join(' ')} (in ${service.cwd})`),
     );
 
     try {
-      // Ensure parent directory for this log file exists (supports nested names)
+      // Ensure parent directory for this log file exists
       await fs.mkdir(path.dirname(logFile), { recursive: true });
-      // Open log file for writing
-      const logFd = await fs.open(logFile, 'w');
-      const logStream = logFd.createWriteStream();
-
-      const child = spawn(service.command, service.args, {
-        cwd: service.cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        detached: true,
-        shell: true,
-      });
-
-      // Pipe stdout and stderr to log file
-      child.stdout?.pipe(logStream);
-      child.stderr?.pipe(logStream);
-
-      child.on('error', (err) => {
-        console.error(chalk.red(`  ✖ ${service.name} error: ${err.message}`));
-      });
-
-      child.on('exit', (code) => {
-        if (code !== null && code !== 0) {
-          console.log(chalk.yellow(`  ⚠ ${service.name} exited with code ${code}`));
-        }
-        activeProcesses.delete(service.name);
-      });
-
-      // Don't wait for the child to finish
-      child.unref();
-
-      if (child.pid) {
-        activeProcesses.set(service.name, child);
+
+      // Delete any existing PM2 configuration with the same name to avoid duplicate starts
+      await execa('npx', ['pm2', 'delete', uniqueName], { reject: false });
+
+      // Start the service using PM2 as a direct process execution
+      await execa('npx', [
+        'pm2',
+        'start',
+        service.command,
+        '--name',
+        uniqueName,
+        '--cwd',
+        service.cwd,
+        '-o',
+        logFile,
+        '-e',
+        logFile,
+        '--interpreter',
+        'none',
+        '--',
+        ...service.args
+      ]);
+
+      // Retrieve the real PID from PM2
+      const { stdout } = await execa('npx', ['pm2', 'jlist']);
+      const pm2List = JSON.parse(stdout);
+      const pm2App = pm2List.find((app: any) => app.name === uniqueName);
+      const pid = pm2App?.pid || 0;
+
+      if (pid) {
         runningServices.push({
           name: service.name,
-          pid: child.pid,
+          pid,
           config: service,
           startedAt: new Date().toISOString(),
         });
-        console.log(chalk.green(`  ✔ ${service.name} started (PID: ${child.pid})`));
+        console.log(chalk.green(`  ✔ ${service.name} started under PM2 (PID: ${pid})`));
+      } else {
+        console.warn(chalk.yellow(`  ⚠ Started ${service.name} but could not resolve PID from PM2.`));
       }
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      console.error(chalk.red(`  ✖ Failed to start ${service.name}: ${msg}`));
+      console.error(chalk.red(`  ✖ Failed to start ${service.name} via PM2: ${msg}`));
     }
   }
 
@@ -155,79 +169,69 @@ export async function startServices(
 }
 
 /**
- * Stops all services for a workspace.
+ * Stops all services for a workspace under PM2.
  *
  * @param workspacePath - Workspace root path.
  */
 export async function stopServices(workspacePath: string): Promise<void> {
-  const state = await loadRunningState(workspacePath);
+  const workspaceId = path.basename(workspacePath);
+  const prefix = `nexusflow-${workspaceId}-`;
 
-  if (!state || state.services.length === 0) {
-    console.log(chalk.yellow('  No running services found.'));
-    return;
-  }
+  console.log(chalk.cyan(`  Stopping all services under PM2 for workspace: ${workspaceId}...`));
 
-  for (const service of state.services) {
-    // Try in-memory process first
-    const child = activeProcesses.get(service.name);
-    if (child && child.pid) {
-      try {
-        // Kill the process group (negative PID kills group on Unix, taskkill on Windows)
-        if (process.platform === 'win32') {
-          spawn('taskkill', ['/pid', String(child.pid), '/f', '/t'], { stdio: 'ignore' });
-        } else {
-          process.kill(-child.pid, 'SIGTERM');
-        }
-        console.log(chalk.green(`  ✔ Stopped ${service.name} (PID: ${service.pid})`));
-        activeProcesses.delete(service.name);
-        continue;
-      } catch {
-        // Fall through to PID-based kill
-      }
-    }
+  try {
+    const { stdout } = await execa('npx', ['pm2', 'jlist']);
+    const pm2List = JSON.parse(stdout);
+    const targetApps = pm2List.filter((app: any) => app.name && app.name.startsWith(prefix));
 
-    // Fall back to PID from state file
-    if (isProcessRunning(service.pid)) {
-      try {
-        if (process.platform === 'win32') {
-          spawn('taskkill', ['/pid', String(service.pid), '/f', '/t'], { stdio: 'ignore' });
-        } else {
-          process.kill(service.pid, 'SIGTERM');
-        }
-        console.log(chalk.green(`  ✔ Stopped ${service.name} (PID: ${service.pid})`));
-      } catch {
-        console.log(chalk.yellow(`  ⚠ Could not stop ${service.name} (PID: ${service.pid})`));
-      }
+    if (targetApps.length === 0) {
+      console.log(chalk.yellow('  No running services found for this workspace.'));
     } else {
-      console.log(chalk.dim(`  ${service.name} already stopped`));
+      for (const app of targetApps) {
+        console.log(chalk.dim(`    Stopping PM2 process: ${app.name}`));
+        await execa('npx', ['pm2', 'delete', app.name], { reject: false });
+      }
+      console.log(chalk.green(`  ✔ All services stopped.`));
     }
+  } catch (error: any) {
+    console.error(chalk.red(`  ✖ Failed to stop services via PM2: ${error.message}`));
   }
 
   await clearRunningState(workspacePath);
 }
 
 /**
- * Shows the status of all services in a workspace.
+ * Shows the status of all services in a workspace by querying PM2.
  *
  * @param workspacePath - Workspace root path.
  */
 export async function getServiceStatus(workspacePath: string): Promise<void> {
-  const state = await loadRunningState(workspacePath);
+  const workspaceId = path.basename(workspacePath);
+  const prefix = `nexusflow-${workspaceId}-`;
 
-  if (!state || state.services.length === 0) {
-    console.log(chalk.yellow('  No services tracked for this workspace.'));
-    return;
-  }
+  try {
+    const { stdout } = await execa('npx', ['pm2', 'jlist']);
+    const pm2List = JSON.parse(stdout);
+    const targetApps = pm2List.filter((app: any) => app.name && app.name.startsWith(prefix));
 
-  for (const service of state.services) {
-    const running = isProcessRunning(service.pid);
-    const status = running ? chalk.green('● running') : chalk.red('● stopped');
-    const portStr = service.config.port ? ` :${service.config.port}` : '';
-    const since = new Date(service.startedAt).toLocaleTimeString();
+    if (targetApps.length === 0) {
+      console.log(chalk.yellow('  No running services found for this workspace in PM2.'));
+      return;
+    }
 
-    console.log(
-      `  ${status} ${chalk.bold(service.name)}${chalk.dim(portStr)} (PID: ${service.pid}, since ${since})`,
-    );
+    for (const app of targetApps) {
+      const name = app.name.substring(prefix.length);
+      const running = app.pm2_env?.status === 'online';
+      const status = running ? chalk.green('● running') : chalk.red(`● ${app.pm2_env?.status || 'stopped'}`);
+      const pid = app.pid || 'N/A';
+      const uptime = app.pm2_env?.pm_uptime ? new Date(app.pm2_env.pm_uptime).toLocaleTimeString() : 'unknown';
+
+      console.log(
+        `  ${status} ${chalk.bold(name)} (PID: ${pid}, since ${uptime})`,
+      );
+    }
+  } catch (error: any) {
+    console.error(chalk.red(`  ✖ Failed to query PM2 status: ${error.message}`));
   }
 }
 

package/src/server.ts

@@ -46,7 +46,7 @@ const guiPath = path.join(__dirname, 'gui');
 export const app = new Hono();
 
 // Allowed editor binaries/scripts to prevent command injection
-const ALLOWED_EDITORS = new Set(['code', 'code-insiders', 'cursor', 'agy', 'idea', 'charm', 'webstorm', 'subl', 'nano', 'vim', 'nvim', 'emacs']);
+const ALLOWED_EDITORS = new Set(['code', 'code-insiders', 'cursor', 'antigravity', 'agy', 'idea', 'charm', 'webstorm', 'subl', 'nano', 'vim', 'nvim', 'emacs']);
 
 // Enable CORS for frontend dev server
 app.use('/api/*', cors());
@@ -700,6 +700,63 @@ app.get('/api/workspace/:id/changes', async (c) => {
   }
 });
 
+// 13_diff. Get git diff for a specific file in workspace sub-repositories
+app.get('/api/workspace/:id/changes/diff', async (c) => {
+  try {
+    const id = c.req.param('id');
+    const repoName = c.req.query('repo');
+    const filePath = c.req.query('file');
+
+    if (!repoName || !filePath) {
+      return c.json({ error: 'Missing repo or file query parameter.' }, 400);
+    }
+
+    const config = await loadConfig();
+    const workspacePath = path.join(config.workspacesDir, id);
+    const worktreePath = path.join(workspacePath, repoName);
+
+    // Security check: ensure path is within workspace directory
+    const resolvedPath = path.resolve(worktreePath);
+    if (!resolvedPath.startsWith(path.resolve(workspacePath))) {
+      return c.json({ error: 'Invalid repository path.' }, 400);
+    }
+
+    let diff = '';
+    
+    // Check git status for the file to know if it's untracked
+    try {
+      const { stdout: statusOut } = await execa('git', ['status', '--porcelain', '--', filePath], { cwd: worktreePath });
+      const statusLine = statusOut.trim();
+      const isUntracked = statusLine.startsWith('??');
+      
+      if (isUntracked) {
+        const result = await execa('git', ['diff', '--no-index', '--', '/dev/null', filePath], {
+          cwd: worktreePath,
+          reject: false
+        });
+        diff = result.stdout || result.stderr || '';
+      } else {
+        const result = await execa('git', ['diff', 'HEAD', '--', filePath], {
+          cwd: worktreePath,
+          reject: false
+        });
+        diff = result.stdout || result.stderr || '';
+      }
+    } catch (e) {
+      const result = await execa('git', ['diff', 'HEAD', '--', filePath], {
+        cwd: worktreePath,
+        reject: false
+      });
+      diff = result.stdout || result.stderr || '';
+    }
+
+    return c.json({ diff });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // 13a. Get workspace knowledge (nexusflow-knowledge.md)
 app.get('/api/workspace/:id/knowledge', async (c) => {
   try {