@mrpatronz/nexusflow 0.1.9 → 0.1.11

package/src/commands/add-repo.ts

@@ -0,0 +1,141 @@
+/**
+ * @module commands/add-repo
+ * Adds a repository to an existing NexusFlow workspace.
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { select } from '@inquirer/prompts';
+import * as path from 'node:path';
+
+import { loadConfig } from '../core/config.js';
+import { scanForRepos } from '../core/scanner.js';
+import { listWorkspaces, loadFeatureConfig, addRepoToWorkspace } from '../core/workspace.js';
+
+/**
+ * Executes the add-repo command.
+ *
+ * @param repoPathArg - Optional repository path to add.
+ * @param workspaceArg - Optional workspace path or name.
+ */
+export async function addRepoCommand(
+  repoPathArg?: string,
+  workspaceArg?: string,
+): Promise<void> {
+  console.log(chalk.bold.cyan('\n➕ NexusFlow — Adding Repository to Workspace\n'));
+
+  const config = await loadConfig();
+
+  // 1. Resolve workspace
+  let workspacePath: string | null = null;
+  let workspaceName = '';
+
+  if (workspaceArg) {
+    const resolvedPath = path.isAbsolute(workspaceArg)
+      ? workspaceArg
+      : path.resolve(config.workspacesDir, workspaceArg);
+
+    try {
+      const manifest = await loadFeatureConfig(resolvedPath);
+      if (manifest) {
+        workspacePath = resolvedPath;
+        workspaceName = manifest.branchName;
+      }
+    } catch {}
+
+    if (!workspacePath) {
+      const directPath = path.join(config.workspacesDir, workspaceArg);
+      const manifest = await loadFeatureConfig(directPath);
+      if (manifest) {
+        workspacePath = directPath;
+        workspaceName = manifest.branchName;
+      } else {
+        console.error(chalk.red(`✖ Invalid workspace: No nexusflow.json found at ${workspaceArg}`));
+        return;
+      }
+    }
+  } else {
+    const cwdFeature = await loadFeatureConfig(process.cwd());
+    if (cwdFeature) {
+      workspacePath = process.cwd();
+      workspaceName = cwdFeature.branchName;
+    } else {
+      const workspaces = await listWorkspaces(config.workspacesDir);
+      if (workspaces.length === 0) {
+        console.log(chalk.yellow('No workspaces found.\n'));
+        return;
+      }
+
+      const selected = await select({
+        message: 'Select a workspace to add a repository to:',
+        choices: workspaces.map((ws) => ({
+          name: `${ws.branchName} ${chalk.dim(`(${ws.repos.length} repos)`)}`,
+          value: ws,
+        })),
+      });
+
+      workspacePath = selected.workspacePath;
+      workspaceName = selected.branchName;
+    }
+  }
+
+  if (!workspacePath) return;
+
+  const feature = await loadFeatureConfig(workspacePath);
+  if (!feature) {
+    console.error(chalk.red('✖ Failed to load workspace configuration.'));
+    return;
+  }
+
+  // 2. Resolve repository to add
+  let repoPathToAdd = '';
+
+  if (repoPathArg) {
+    repoPathToAdd = path.resolve(repoPathArg);
+  } else {
+    const scanSpinner = ora('Scanning for projects...').start();
+    let repos = [];
+    try {
+      repos = await scanForRepos(config.devDir, config.scanDepth);
+      scanSpinner.succeed(`Found ${chalk.bold(repos.length)} projects in ${config.devDir}`);
+    } catch (error) {
+      scanSpinner.fail('Failed to scan for projects');
+      console.error(error);
+      return;
+    }
+
+    const availableRepos = repos.filter(
+      (r) => !feature.repos.includes(r.path)
+    );
+
+    if (availableRepos.length === 0) {
+      console.log(chalk.yellow('All scanned repositories are already in the workspace.\n'));
+      return;
+    }
+
+    repoPathToAdd = await select({
+      message: 'Select a repository to add:',
+      choices: availableRepos.map((r) => ({
+        name: `${r.name} ${chalk.dim(`(${r.path})`)}`,
+        value: r.path,
+      })),
+    });
+  }
+
+  const repoName = path.basename(repoPathToAdd);
+  const spinner = ora(`Adding ${repoName} to workspace ${workspaceName}...`).start();
+
+  try {
+    await addRepoToWorkspace(workspacePath, repoPathToAdd);
+    spinner.succeed(`Successfully added ${chalk.bold(repoName)} to workspace ${chalk.bold(workspaceName)}`);
+    console.log(chalk.dim('  - Checked out git worktree'));
+    console.log(chalk.dim('  - Updated nexusflow.json and .gitignore'));
+    console.log(chalk.dim('  - Re-analyzed workspace codebases'));
+    console.log(chalk.dim('  - Regenerated LLM instruction context files'));
+    console.log(chalk.dim('  - Repacked codebase context using Repomix'));
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed to add repository: ${error instanceof Error ? error.message : String(error)}`);
+    console.log();
+  }
+}

package/src/commands/create.ts

@@ -107,10 +107,14 @@ export async function createCommand(): Promise<void> {
 
   // ── 7. Analyze projects ─────────────────────────────────────────────
   console.log(chalk.cyan('\nAnalyzing projects...'));
-  const analysis = await analyzeAllRepos(selectedRepos);
+  const workspaceRepos = selectedRepos.map((repo) => ({
+    ...repo,
+    path: path.join(workspacePath, repo.name),
+  }));
+  const analysis = await analyzeAllRepos(workspaceRepos);
 
   // ── 8. Generate AI context files ────────────────────────────────────
-  const ctx: WorkspaceContext = { feature, repos: selectedRepos, analysis };
+  const ctx: WorkspaceContext = { feature, repos: workspaceRepos, analysis };
   console.log(chalk.cyan('\nGenerating AI context files...'));
   await generateContextFiles(ctx, selectedAI, workspacePath);
 

package/src/commands/remove.ts

@@ -0,0 +1,90 @@
+/**
+ * @module commands/remove
+ * Deletes a NexusFlow workspace and cleanly removes/prunes its git worktrees.
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { select, confirm } from '@inquirer/prompts';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+
+import { loadConfig } from '../core/config.js';
+import { listWorkspaces, deleteWorkspace } from '../core/workspace.js';
+
+/**
+ * Executes the remove command.
+ *
+ * @param workspaceArg - Optional workspace path or branch name from CLI.
+ */
+export async function removeCommand(workspaceArg?: string): Promise<void> {
+  console.log(chalk.bold.red('\n🗑️ NexusFlow — Deleting Workspace\n'));
+
+  const config = await loadConfig();
+  let workspacePath: string | null = null;
+  let workspaceName = '';
+
+  if (workspaceArg) {
+    const resolvedPath = path.isAbsolute(workspaceArg)
+      ? workspaceArg
+      : path.resolve(config.workspacesDir, workspaceArg);
+
+    try {
+      await fs.access(resolvedPath);
+      workspacePath = resolvedPath;
+      workspaceName = path.basename(resolvedPath);
+    } catch {
+      const directPath = path.join(config.workspacesDir, workspaceArg);
+      try {
+        await fs.access(directPath);
+        workspacePath = directPath;
+        workspaceName = workspaceArg;
+      } catch {
+        console.error(chalk.red(`✖ Workspace not found: ${workspaceArg}`));
+        return;
+      }
+    }
+  } else {
+    const workspaces = await listWorkspaces(config.workspacesDir);
+
+    if (workspaces.length === 0) {
+      console.log(chalk.yellow('No workspaces found.\n'));
+      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,
+      })),
+    });
+
+    workspacePath = selected.workspacePath;
+    workspaceName = selected.branchName;
+  }
+
+  if (!workspacePath) return;
+
+  const confirmDelete = await confirm({
+    message: `Are you absolutely sure you want to delete the workspace "${workspaceName}"?\n  This will FORCE remove all associated git worktrees and delete the folder from disk.`,
+    default: false,
+  });
+
+  if (!confirmDelete) {
+    console.log(chalk.yellow('\nCancelled.\n'));
+    return;
+  }
+
+  const spinner = ora('Deleting workspace and pruning git worktrees...').start();
+
+  try {
+    await deleteWorkspace(workspacePath);
+    spinner.succeed(`Successfully deleted workspace ${chalk.bold(workspaceName)}`);
+    console.log();
+  } catch (error) {
+    spinner.fail(`Failed to delete workspace ${workspaceName}`);
+    console.error(chalk.red(`  ${error instanceof Error ? error.message : String(error)}`));
+    console.log();
+  }
+}

package/src/core/workspace.ts

@@ -9,8 +9,12 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { execa } from 'execa';
 
-import type { Feature, RepoInfo } from '../types.js';
-import { createWorktree } from './worktree.js';
+import type { Feature, RepoInfo, WorkspaceContext } from '../types.js';
+import { createWorktree, removeWorktree } from './worktree.js';
+import { detectDefaultBranch } from '../utils/git.js';
+import { analyzeAllRepos } from '../analyzers/index.js';
+import { generateContextFiles } from '../generators/index.js';
+import { packWorkspace } from './packer.js';
 
 /** Name of the per-workspace manifest file. */
 const MANIFEST_FILE = 'nexusflow.json';
@@ -161,3 +165,143 @@ export async function loadFeatureConfig(
     return null;
   }
 }
+
+/**
+ * Resolves a repo path to a full RepoInfo object.
+ *
+ * @param repoPath - Absolute path to the original repository.
+ */
+export async function resolveRepoInfo(repoPath: string): Promise<RepoInfo> {
+  const defaultBranch = await detectDefaultBranch(repoPath);
+  return {
+    name: path.basename(repoPath),
+    path: repoPath,
+    defaultBranch,
+  };
+}
+
+/**
+ * Deletes a workspace cleanly, removing all associated git worktrees first,
+ * then deleting the directory from disk.
+ *
+ * @param workspacePath - Absolute path to the workspace directory.
+ */
+export async function deleteWorkspace(
+  workspacePath: string,
+): Promise<void> {
+  const feature = await loadFeatureConfig(workspacePath);
+  if (feature) {
+    for (const repoPath of feature.repos) {
+      const repoName = path.basename(repoPath);
+      const worktreePath = path.join(workspacePath, repoName);
+      try {
+        await removeWorktree(repoPath, worktreePath, true);
+      } catch (error) {
+        console.warn(`Warning: failed to remove worktree for ${repoName} in ${repoPath}:`, error);
+        try {
+          await execa('git', ['worktree', 'prune'], { cwd: repoPath });
+        } catch (pruneError) {
+          console.warn(`Warning: failed to prune worktrees in ${repoPath}:`, pruneError);
+        }
+      }
+    }
+  } else {
+    // Manifest is missing. Try to detect worktrees by scanning subdirectories
+    try {
+      const entries = await fs.readdir(workspacePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const subPath = path.join(workspacePath, entry.name);
+          const gitFilePath = path.join(subPath, '.git');
+          try {
+            const stat = await fs.stat(gitFilePath);
+            if (stat.isFile()) {
+              const content = await fs.readFile(gitFilePath, 'utf-8');
+              const match = content.match(/gitdir:\s*(.+)\.git\/worktrees/);
+              if (match && match[1]) {
+                const mainRepoPath = path.resolve(match[1].trim());
+                await removeWorktree(mainRepoPath, subPath, true);
+              }
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+
+  // Delete the directory itself
+  try {
+    await fs.rm(workspacePath, { recursive: true, force: true });
+  } catch (error) {
+    console.error(`Failed to delete workspace directory ${workspacePath}:`, error);
+    throw error;
+  }
+}
+
+/**
+ * Adds a repository to an existing workspace.
+ *
+ * @param workspacePath - Absolute path to the workspace directory.
+ * @param repoPath - Absolute path to the repository to add.
+ */
+export async function addRepoToWorkspace(
+  workspacePath: string,
+  repoPath: string,
+): Promise<void> {
+  const feature = await loadFeatureConfig(workspacePath);
+  if (!feature) {
+    throw new Error(`Workspace manifest not found at ${workspacePath}`);
+  }
+
+  if (feature.repos.includes(repoPath)) {
+    throw new Error(`Repository ${repoPath} is already in the workspace`);
+  }
+
+  const newRepoInfo = await resolveRepoInfo(repoPath);
+  const worktreeTarget = path.join(workspacePath, newRepoInfo.name);
+
+  // 1. Create the worktree
+  await createWorktree(
+    newRepoInfo.path,
+    worktreeTarget,
+    feature.branchName,
+    newRepoInfo.defaultBranch,
+  );
+
+  // 2. Update manifest
+  feature.repos.push(repoPath);
+  await saveFeatureConfig(workspacePath, feature);
+
+  // 3. Update .gitignore at workspace root
+  try {
+    const gitignorePath = path.join(workspacePath, '.gitignore');
+    let gitignoreContent = '';
+    try {
+      gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+    } catch {}
+
+    const entry = `/${newRepoInfo.name}/`;
+    if (!gitignoreContent.includes(entry)) {
+      gitignoreContent = gitignoreContent.trim() + '\n' + entry + '\n';
+      await fs.writeFile(gitignorePath, gitignoreContent, 'utf-8');
+    }
+  } catch (error) {
+    console.warn('Warning: Failed to update .gitignore:', error);
+  }
+
+  // 4. Re-run analysis, update configs, and repack workspace
+  const allRepos = await Promise.all(feature.repos.map(resolveRepoInfo));
+  const workspaceRepos = allRepos.map((repo) => ({
+    ...repo,
+    path: path.join(workspacePath, repo.name),
+  }));
+  const analysis = await analyzeAllRepos(workspaceRepos);
+  const ctx: WorkspaceContext = {
+    feature,
+    repos: workspaceRepos,
+    analysis,
+  };
+
+  await generateContextFiles(ctx, feature.assistants, workspacePath);
+  await packWorkspace(workspacePath);
+}

package/src/core/worktree.ts

@@ -90,14 +90,22 @@ export async function createWorktree(
 /**
  * Removes an existing git worktree.
  *
- * Runs `git worktree remove <worktreePath>` from the main repo.
+ * Runs `git worktree remove [--force] <worktreePath>` from the main repo.
  *
  * @param repoPath     - Absolute path to the main repo checkout.
  * @param worktreePath - Absolute path to the worktree to remove.
+ * @param force        - Whether to force removal (cleanly removes modified files).
  */
 export async function removeWorktree(
   repoPath: string,
   worktreePath: string,
+  force = false,
 ): Promise<void> {
-  await execa('git', ['worktree', 'remove', worktreePath], { cwd: repoPath });
+  const args = ['worktree', 'remove'];
+  if (force) {
+    args.push('--force');
+  }
+  args.push(worktreePath);
+  await execa('git', args, { cwd: repoPath });
 }
+

package/src/generators/base.ts

@@ -157,6 +157,15 @@ ${existingConfigsSection}
 ${resumptionSection}
 ---
 
+## Codebase Context (Repomix)
+
+A packed, token-efficient version of the entire multi-repo codebase is automatically generated and updated at the workspace root:
+- **File**: \`nexusflow-context.xml\`
+- **Purpose**: Contains the aggregated source code and structure of all projects in the workspace.
+- **Usage**: You can read this file directly to understand relationships or search for code patterns across all projects without needing to manually traverse directories.
+
+---
+
 ## Task & Step-by-Step Initialization
 
 Your very first task upon entering this workspace is to analyze the codebase and document it in a universal reference file:

package/src/index.ts

@@ -24,6 +24,8 @@ import { syncCommand } from './commands/sync.js';
 import { commitCommand } from './commands/commit.js';
 import { diffCommand } from './commands/diff.js';
 import { packCommand } from './commands/pack.js';
+import { removeCommand } from './commands/remove.js';
+import { addRepoCommand } from './commands/add-repo.js';
 import { mcpRunCommand, mcpSetupCommand } from './commands/mcp.js';
 import { getCurrentVersion, checkForUpdates, printUpdateBanner } from './utils/update-check.js';
 
@@ -253,6 +255,43 @@ program
     }
   });
 
+program
+  .command('remove')
+  .alias('rm')
+  .description('Delete a workspace and cleanly prune/remove its git worktrees')
+  .argument('[workspace]', 'Workspace name or path')
+  .action(async (workspace?: string) => {
+    try {
+      await removeCommand(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('add-repo')
+  .alias('add')
+  .description('Add a repository to an existing workspace and update configurations')
+  .argument('[repo-path]', 'Path to the repository to add')
+  .argument('[workspace]', 'Workspace name or path')
+  .action(async (repoPath?: string, workspace?: string) => {
+    try {
+      await addRepoCommand(repoPath, 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);
+    }
+  });
+
 const mcp = program.command('mcp').description('Manage the NexusFlow MCP Server for AI assistants');
 
 mcp

package/src/server.ts

@@ -15,7 +15,7 @@ import { execa } from 'execa';
 
 import { loadConfig, saveConfig, getConfigDir } from './core/config.js';
 import { scanForRepos } from './core/scanner.js';
-import { createWorkspace, listWorkspaces, loadFeatureConfig } from './core/workspace.js';
+import { createWorkspace, listWorkspaces, loadFeatureConfig, deleteWorkspace, addRepoToWorkspace } from './core/workspace.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
 import { packWorkspace } from './core/packer.js';
@@ -30,7 +30,7 @@ import {
   stopServices,
   loadRunningState,
 } from './orchestration/index.js';
-import { checkForUpdates, getCurrentVersion } from './utils/update-check.js';
+import { checkForUpdates, getCurrentVersion, getToolsStatus } from './utils/update-check.js';
 import type { Feature, RepoInfo, WorkspaceContext } from './types.js';
 
 // Resolve static files directory
@@ -220,14 +220,18 @@ async function runCreationJob(jobId: string, body: any, config: any) {
 
     // Step 2: Analyze repos
     updateJobStep(jobId, 'analysis', 'running', 'Analyzing projects and dependencies...');
-    const analysis = await analyzeAllRepos(body.repos);
+    const workspaceRepos = body.repos.map((repo: any) => ({
+      ...repo,
+      path: path.join(workspacePath, repo.name),
+    }));
+    const analysis = await analyzeAllRepos(workspaceRepos);
     updateJobStep(jobId, 'analysis', 'completed', 'Project analysis complete.');
 
     // Step 3: Generate AI context files
     updateJobStep(jobId, 'context', 'running', 'Generating AI context files...');
     const ctx: WorkspaceContext = {
       feature,
-      repos: body.repos,
+      repos: workspaceRepos,
       analysis,
     };
     await generateContextFiles(ctx, body.assistants, workspacePath);
@@ -353,6 +357,37 @@ app.get('/api/workspace/create-stream/:jobId', async (c) => {
   });
 });
 
+// 7.6. Delete workspace
+app.delete('/api/workspace/:id', async (c) => {
+  try {
+    const id = decodeURIComponent(c.req.param('id'));
+    const config = await loadConfig();
+    const workspacePath = path.join(config.workspacesDir, id);
+
+    await deleteWorkspace(workspacePath);
+    return c.json({ success: true });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// 7.7. Add repo to workspace
+app.post('/api/workspace/:id/repo', async (c) => {
+  try {
+    const id = decodeURIComponent(c.req.param('id'));
+    const { repoPath } = await c.req.json() as { repoPath: string };
+    const config = await loadConfig();
+    const workspacePath = path.join(config.workspacesDir, id);
+
+    await addRepoToWorkspace(workspacePath, repoPath);
+    return c.json({ success: true });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // 8. Open workspace in editor
 app.post('/api/open-editor', async (c) => {
   try {
@@ -785,6 +820,46 @@ app.get('/api/update-status', async (c) => {
   }
 });
 
+// 17.5. Check tools updates status
+app.get('/api/updates/tools', async (c) => {
+  try {
+    const force = c.req.query('force') === 'true';
+    const status = await getToolsStatus(force);
+    return c.json(status);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// 17.6. Install updates for a specific tool
+app.post('/api/updates/install', async (c) => {
+  try {
+    const { toolId } = await c.req.json() as { toolId: string };
+    const tools = [
+      { id: 'nexusflow', cmd: 'npm', args: ['install', '-g', '@mrpatronz/nexusflow'] },
+      { id: 'repomix', cmd: 'npm', args: ['install', '-g', 'repomix'] },
+      { id: 'antigravity', cmd: 'agy', args: ['update'] },
+      { id: 'claude', cmd: 'npm', args: ['install', '-g', '@anthropic-ai/claude-code'] },
+    ];
+
+    const target = tools.find(t => t.id === toolId);
+    if (!target) {
+      return c.json({ error: 'Tool not found' }, 404);
+    }
+
+    const result = await execa(target.cmd, target.args, { reject: false });
+    if (result.exitCode === 0) {
+      return c.json({ success: true, output: result.stdout });
+    } else {
+      return c.json({ error: `Update failed: ${result.stderr || result.stdout}` }, 500);
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return c.json({ error: msg }, 500);
+  }
+});
+
 // 18. Pack workspace codebase and download
 app.get('/api/workspace/:id/pack', async (c) => {
   try {