@mrpatronz/nexusflow 0.1.9 → 0.1.10

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,139 @@ 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 analysis = await analyzeAllRepos(allRepos);
+  const ctx: WorkspaceContext = {
+    feature,
+    repos: allRepos,
+    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
@@ -353,6 +353,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 +816,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 {

package/src/utils/update-check.ts

@@ -145,3 +145,119 @@ export function printUpdateBanner(status: UpdateStatus): void {
   console.log(chalk.yellow(`└${border}┘`));
   console.log();
 }
+
+import { execa } from 'execa';
+
+export interface ToolUpdateStatus {
+  id: string;
+  name: string;
+  command: string;
+  installed: boolean;
+  currentVersion: string;
+  latestVersion: string;
+  updateAvailable: boolean;
+  updateCmd: string;
+}
+
+export async function getToolsStatus(force = false): Promise<ToolUpdateStatus[]> {
+  const currentVersion = getCurrentVersion();
+  const tools = [
+    {
+      id: 'nexusflow',
+      name: 'NexusFlow Engine',
+      command: 'nexusflow',
+      npmPackage: '@mrpatronz/nexusflow',
+      updateCmd: 'npm install -g @mrpatronz/nexusflow',
+      getCurrent: async () => currentVersion,
+    },
+    {
+      id: 'repomix',
+      name: 'Repomix (Codebase Packer)',
+      command: 'repomix',
+      npmPackage: 'repomix',
+      updateCmd: 'npm install -g repomix',
+      getCurrent: async () => {
+        try {
+          const res = await execa('repomix', ['--version'], { reject: false });
+          if (res.exitCode === 0) return res.stdout.trim();
+        } catch {}
+        try {
+          const res = await execa('npx', ['repomix', '--version'], { reject: false });
+          if (res.exitCode === 0) return res.stdout.trim();
+        } catch {}
+        return '';
+      }
+    },
+    {
+      id: 'antigravity',
+      name: 'Antigravity CLI',
+      command: 'agy',
+      npmPackage: '',
+      updateCmd: 'agy update',
+      getCurrent: async () => {
+        try {
+          const res = await execa('agy', ['--version'], { reject: false });
+          if (res.exitCode === 0) return res.stdout.trim();
+        } catch {}
+        return '';
+      }
+    },
+    {
+      id: 'claude',
+      name: 'Claude Code CLI',
+      command: 'claude',
+      npmPackage: '@anthropic-ai/claude-code',
+      updateCmd: 'npm install -g @anthropic-ai/claude-code',
+      getCurrent: async () => {
+        try {
+          const res = await execa('claude', ['--version'], { reject: false });
+          if (res.exitCode === 0) return res.stdout.trim();
+        } catch {}
+        return '';
+      }
+    }
+  ];
+
+  const results: ToolUpdateStatus[] = [];
+
+  for (const t of tools) {
+    let installed = false;
+    let currentVal = '';
+    let latestVal = '';
+    
+    try {
+      currentVal = await t.getCurrent();
+      installed = currentVal !== '';
+    } catch {}
+
+    if (installed && t.npmPackage) {
+      try {
+        const response = await fetch(`https://registry.npmjs.org/${t.npmPackage}/latest`, {
+          signal: AbortSignal.timeout(2000),
+        });
+        if (response.ok) {
+          const data = await response.json() as { version: string };
+          latestVal = data.version;
+        }
+      } catch {}
+    }
+
+    if (!latestVal) {
+      latestVal = currentVal || '1.0.0';
+    }
+
+    results.push({
+      id: t.id,
+      name: t.name,
+      command: t.command,
+      installed,
+      currentVersion: currentVal || 'Not Installed',
+      latestVersion: latestVal,
+      updateAvailable: installed && isNewerVersion(currentVal, latestVal),
+      updateCmd: t.updateCmd,
+    });
+  }
+
+  return results;
+}
+