@mrpatronz/nexusflow 0.2.13 → 0.2.18

package/src/commands/adapter.ts

@@ -0,0 +1,348 @@
+/**
+ * @module commands/adapter
+ * CLI commands for managing storage adapters.
+ *
+ * Usage:
+ *   nexusflow adapter list               # List all available adapters
+ *   nexusflow adapter use <name>          # Switch active adapter (prompts for config)
+ *   nexusflow adapter info <name>         # Show adapter details and current settings
+ *   nexusflow adapter init <name>         # Scaffold a new adapter plugin project
+ */
+
+import chalk from 'chalk';
+import { input, confirm } from '@inquirer/prompts';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { listStorageProviders, getStorageProvider } from '../core/adapters/registry.js';
+import { loadConfig, saveConfig } from '../core/config.js';
+import type { StorageAdapterMeta, AdapterConfigField } from '../core/ports/storage.js';
+
+/**
+ * Lists all registered storage adapters in a formatted table.
+ */
+export async function adapterListCommand(): Promise<void> {
+  const config = await loadConfig();
+  const activeName = config.storageProvider || 'local';
+  const adapters = listStorageProviders();
+
+  console.log(chalk.bold.cyan('\n📦 Available Storage Adapters\n'));
+
+  // Table header
+  const nameW = 18;
+  const dispW = 22;
+  const actW = 8;
+  console.log(
+    chalk.dim('  ') +
+    chalk.bold('Name'.padEnd(nameW)) +
+    chalk.bold('Display Name'.padEnd(dispW)) +
+    chalk.bold('Active'.padEnd(actW)) +
+    chalk.bold('Description')
+  );
+  console.log(chalk.dim('  ' + '─'.repeat(nameW + dispW + actW + 40)));
+
+  for (const adapter of adapters) {
+    const isActive = adapter.name === activeName;
+    const activeMarker = isActive ? chalk.green('  ✔') : '   ';
+    const configCount = adapter.configFields.length;
+    const configHint = configCount > 0 ? chalk.dim(` (${configCount} settings)`) : '';
+
+    console.log(
+      '  ' +
+      chalk.white(adapter.name.padEnd(nameW)) +
+      chalk.cyan(adapter.displayName.padEnd(dispW)) +
+      activeMarker.padEnd(actW) +
+      chalk.gray(adapter.description) +
+      configHint
+    );
+  }
+  console.log();
+}
+
+/**
+ * Shows detailed information about a specific adapter.
+ */
+export async function adapterInfoCommand(adapterName: string): Promise<void> {
+  const config = await loadConfig();
+  const activeName = config.storageProvider || 'local';
+
+  let meta: StorageAdapterMeta;
+  try {
+    meta = getStorageProvider(adapterName).meta;
+  } catch {
+    console.error(chalk.red(`\n✖ Adapter "${adapterName}" is not registered.\n`));
+    const adapters = listStorageProviders();
+    console.log(chalk.dim(`  Available: ${adapters.map(a => a.name).join(', ')}`));
+    return;
+  }
+
+  console.log(chalk.bold.cyan(`\n📦 Adapter: ${meta.displayName}\n`));
+  console.log(`  ${chalk.bold('Name:')}        ${meta.name}`);
+  console.log(`  ${chalk.bold('Active:')}      ${meta.name === activeName ? chalk.green('Yes') : 'No'}`);
+  console.log(`  ${chalk.bold('Description:')} ${meta.description}`);
+
+  if (meta.configFields.length > 0) {
+    console.log(`\n  ${chalk.bold('Configuration Fields:')}`);
+    const currentSettings = config.adapterConfig?.[meta.name] ?? {};
+
+    for (const field of meta.configFields) {
+      const currentValue = currentSettings[field.key];
+      const defaultStr = field.default !== undefined ? chalk.dim(` (default: ${String(field.default)})`) : '';
+      const requiredStr = field.required ? chalk.yellow(' *required') : '';
+      const valueStr = currentValue !== undefined ? chalk.green(String(currentValue)) : chalk.dim('not set');
+
+      console.log(`    ${chalk.white(field.label)} [${field.key}]${requiredStr}${defaultStr}`);
+      console.log(`      ${chalk.dim(field.description || '')}`);
+      console.log(`      Current: ${valueStr}`);
+    }
+  } else {
+    console.log(chalk.dim('\n  No configuration needed.'));
+  }
+  console.log();
+}
+
+/**
+ * Switches the active adapter and prompts for any required configuration.
+ */
+export async function adapterUseCommand(adapterName: string): Promise<void> {
+  let provider;
+  try {
+    provider = getStorageProvider(adapterName);
+  } catch {
+    console.error(chalk.red(`\n✖ Adapter "${adapterName}" is not registered.\n`));
+    const adapters = listStorageProviders();
+    console.log(chalk.dim(`  Available: ${adapters.map(a => a.name).join(', ')}`));
+    return;
+  }
+
+  const config = await loadConfig();
+  const meta = provider.meta;
+  const existingSettings = config.adapterConfig?.[meta.name] ?? {};
+  const newSettings: Record<string, unknown> = { ...existingSettings };
+
+  // Prompt for each config field
+  if (meta.configFields.length > 0) {
+    console.log(chalk.bold.cyan(`\n⚙️  Configure ${meta.displayName}\n`));
+
+    for (const field of meta.configFields) {
+      const currentValue = existingSettings[field.key];
+      const defaultValue = currentValue !== undefined ? String(currentValue) : (field.default !== undefined ? String(field.default) : undefined);
+
+      if (field.type === 'boolean') {
+        const result = await confirm({
+          message: field.label + (field.description ? chalk.dim(` — ${field.description}`) : ''),
+          default: defaultValue === 'true' || field.default === true,
+        });
+        newSettings[field.key] = result;
+      } else {
+        const result = await input({
+          message: field.label + (field.description ? chalk.dim(` — ${field.description}`) : ''),
+          default: defaultValue,
+          validate: (val) => {
+            if (field.required && !val.trim()) return `${field.label} is required`;
+            return true;
+          },
+        });
+
+        if (field.type === 'number') {
+          newSettings[field.key] = Number(result);
+        } else {
+          newSettings[field.key] = result;
+        }
+      }
+    }
+  }
+
+  // Save config
+  if (!config.adapterConfig) {
+    config.adapterConfig = {};
+  }
+  config.adapterConfig[meta.name] = newSettings;
+  config.storageProvider = meta.name;
+  await saveConfig(config);
+
+  // Apply configuration
+  if (provider.configure) {
+    provider.configure(newSettings);
+  }
+
+  console.log(chalk.green(`\n✔ Activated '${meta.displayName}' adapter.\n`));
+}
+
+/**
+ * Scaffolds a new adapter plugin project.
+ */
+export async function adapterInitCommand(adapterName: string): Promise<void> {
+  const targetDir = path.resolve(adapterName);
+
+  try {
+    await fs.access(targetDir);
+    console.error(chalk.red(`\n✖ Directory "${adapterName}" already exists.\n`));
+    return;
+  } catch {}
+
+  console.log(chalk.bold.cyan(`\n🔧 Scaffolding adapter: ${adapterName}\n`));
+
+  await fs.mkdir(path.join(targetDir, 'src'), { recursive: true });
+
+  // package.json
+  const pkg = {
+    name: `nexusflow-${adapterName}`,
+    version: '1.0.0',
+    type: 'module',
+    main: 'dist/index.js',
+    scripts: {
+      build: 'tsc',
+      dev: 'tsc --watch',
+    },
+    peerDependencies: {
+      '@mrpatronz/nexusflow': '>=0.2.0',
+    },
+    devDependencies: {
+      typescript: '^5.0.0',
+    },
+  };
+  await fs.writeFile(path.join(targetDir, 'package.json'), JSON.stringify(pkg, null, 2), 'utf8');
+
+  // tsconfig.json
+  const tsconfig = {
+    compilerOptions: {
+      target: 'ES2022',
+      module: 'Node16',
+      moduleResolution: 'Node16',
+      outDir: 'dist',
+      rootDir: 'src',
+      strict: true,
+      esModuleInterop: true,
+      declaration: true,
+    },
+    include: ['src/**/*'],
+  };
+  await fs.writeFile(path.join(targetDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2), 'utf8');
+
+  // src/index.ts — starter adapter
+  const indexContent = `/**
+ * NexusFlow Storage Adapter: ${adapterName}
+ *
+ * Implement the StoragePort interface to create a custom storage backend.
+ * See: https://github.com/antan87/NexusFlow#adapters
+ */
+
+import type { StoragePort, StorageAdapterMeta, NexusFlowPlugin } from '@mrpatronz/nexusflow';
+// If the above import fails, use relative path to nexusflow's type definitions.
+
+class ${toPascalCase(adapterName)}Adapter implements StoragePort {
+  readonly meta: StorageAdapterMeta = {
+    name: '${adapterName}',
+    displayName: '${toTitleCase(adapterName)}',
+    description: 'A custom NexusFlow storage adapter.',
+    configFields: [
+      // Add your configuration fields here, e.g.:
+      // { key: 'endpoint', label: 'API Endpoint', type: 'string', required: true, description: 'URL of the storage API' },
+    ],
+  };
+
+  configure(settings: Record<string, unknown>): void {
+    // Read your adapter-specific settings here
+  }
+
+  // ── Workspace (feature) layer ────────────────────────────
+
+  async writeWorkspaceFile(workspacePath: string, featureId: string, filename: string, content: string): Promise<void> {
+    throw new Error('Not implemented yet');
+  }
+
+  async readWorkspaceFile(workspacePath: string, featureId: string, filename: string): Promise<string> {
+    throw new Error('Not implemented yet');
+  }
+
+  async workspaceFileExists(workspacePath: string, featureId: string, filename: string): Promise<boolean> {
+    return false;
+  }
+
+  resolveWorkspaceFileUrl(workspacePath: string, featureId: string, filename: string): string {
+    return '';
+  }
+
+  // ── Base (repo) layer ────────────────────────────────────
+
+  async writeBaseFile(workspacePath: string, repoName: string, filename: string, content: string): Promise<void> {
+    throw new Error('Not implemented yet');
+  }
+
+  async readBaseFile(workspacePath: string, repoName: string, filename: string): Promise<string> {
+    throw new Error('Not implemented yet');
+  }
+
+  async baseFileExists(workspacePath: string, repoName: string, filename: string): Promise<boolean> {
+    return false;
+  }
+
+  resolveBaseFileUrl(workspacePath: string, repoName: string, filename: string): string {
+    return '';
+  }
+}
+
+const plugin: NexusFlowPlugin = {
+  name: 'nexusflow-${adapterName}',
+  version: '1.0.0',
+  register(context) {
+    context.registerStorageProvider('${adapterName}', new ${toPascalCase(adapterName)}Adapter());
+  },
+};
+
+export default plugin;
+`;
+  await fs.writeFile(path.join(targetDir, 'src', 'index.ts'), indexContent, 'utf8');
+
+  // README.md
+  const readme = `# nexusflow-${adapterName}
+
+A custom storage adapter for [NexusFlow](https://github.com/antan87/NexusFlow).
+
+## Development
+
+\`\`\`bash
+npm install
+npm run build
+\`\`\`
+
+## Usage
+
+Add to your NexusFlow config (\`~/.nexusflow/config.json\`):
+
+\`\`\`json
+{
+  "plugins": ["./path/to/nexusflow-${adapterName}/dist/index.js"],
+  "storageProvider": "${adapterName}"
+}
+\`\`\`
+
+Or activate via CLI:
+
+\`\`\`bash
+nexusflow adapter use ${adapterName}
+\`\`\`
+`;
+  await fs.writeFile(path.join(targetDir, 'README.md'), readme, 'utf8');
+
+  console.log(chalk.green('  ✔ Created package.json'));
+  console.log(chalk.green('  ✔ Created tsconfig.json'));
+  console.log(chalk.green('  ✔ Created src/index.ts (starter adapter)'));
+  console.log(chalk.green('  ✔ Created README.md'));
+  console.log(chalk.bold.green(`\n✅ Adapter scaffolded at ${targetDir}\n`));
+  console.log(chalk.dim('  Next steps:'));
+  console.log(chalk.dim(`    cd ${adapterName}`));
+  console.log(chalk.dim('    npm install'));
+  console.log(chalk.dim('    # Implement the StoragePort methods in src/index.ts'));
+  console.log(chalk.dim('    npm run build'));
+  console.log();
+}
+
+function toPascalCase(str: string): string {
+  return str.split(/[-_]/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('');
+}
+
+function toTitleCase(str: string): string {
+  return str.split(/[-_]/).map(s => s.charAt(0).toUpperCase() + s.slice(1)).join(' ');
+}

package/src/commands/add-repo.ts

@@ -148,7 +148,6 @@ export async function addRepoCommand(
     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)}`);

package/src/commands/commands.test.ts

@@ -103,7 +103,8 @@ describe('NexusFlow CLI New Commands unit tests', () => {
         expect.any(Object),
         expect.any(Array),
         mockWorkspacePath,
-        'repo-1'
+        'repo-1',
+        undefined
       );
     });
   });
@@ -141,7 +142,7 @@ describe('NexusFlow CLI New Commands unit tests', () => {
         existingAIConfigs: [],
       });
       vi.spyOn(analyzers, 'analyzeAllRepos').mockResolvedValue(mockAnalysis);
-      vi.spyOn(fs, 'access').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'access').mockResolvedValue(undefined); // covers .code-workspace + artifact checks
       vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify({ "search.useIgnoreFiles": false }));
 
       // Run doctor command

package/src/commands/config.ts

@@ -0,0 +1,52 @@
+/**
+ * @module commands/config
+ * CLI command to view and update NexusFlow configuration.
+ *
+ * Usage:
+ *   nexusflow config                           # Show current config
+ *   nexusflow config set storageProvider local  # Set a config key
+ *   nexusflow config get storageProvider        # Get a specific key
+ */
+
+import { loadConfig, saveConfig } from '../core/config.js';
+
+/**
+ * Displays the current NexusFlow configuration.
+ */
+export async function configShowCommand(): Promise<void> {
+  const config = await loadConfig();
+  console.log('\n⚙️  NexusFlow Configuration\n');
+  console.log(JSON.stringify(config, null, 2));
+  console.log();
+}
+
+/**
+ * Gets a specific configuration key.
+ */
+export async function configGetCommand(key: string): Promise<void> {
+  const config = await loadConfig();
+  const value = (config as unknown as Record<string, unknown>)[key];
+
+  if (value === undefined) {
+    console.log(`  Key "${key}" is not set.`);
+  } else {
+    console.log(`  ${key} = ${typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value)}`);
+  }
+}
+
+/**
+ * Sets a specific configuration key.
+ */
+export async function configSetCommand(key: string, value: string): Promise<void> {
+  const config = await loadConfig();
+
+  // Parse booleans and numbers
+  let parsed: unknown = value;
+  if (value === 'true') parsed = true;
+  else if (value === 'false') parsed = false;
+  else if (!isNaN(Number(value)) && value.trim() !== '') parsed = Number(value);
+
+  (config as unknown as Record<string, unknown>)[key] = parsed;
+  await saveConfig(config);
+  console.log(`  ✔ Set ${key} = ${String(parsed)}`);
+}

package/src/commands/create.ts

@@ -14,7 +14,6 @@ import { confirm } from '@inquirer/prompts';
 import { loadConfig } from '../core/config.js';
 import { scanForRepos } from '../core/scanner.js';
 import { createWorkspace } from '../core/workspace.js';
-import { packWorkspace } from '../core/packer.js';
 import { generateContextFiles } from '../generators/index.js';
 import { analyzeAllRepos } from '../analyzers/index.js';
 import { detectAIAssistants } from '../utils/detect-ai.js';
@@ -27,6 +26,7 @@ import {
   promptSelectEditor,
 } from '../utils/prompts.js';
 import type { Feature, WorkspaceContext } from '../types.js';
+import { suggestWorkflow } from '../utils/workflow-advisor.js';
 
 /**
  * Executes the full "create workspace" flow:
@@ -86,6 +86,17 @@ export async function createCommand(): Promise<void> {
     ? await confirm({ message: 'Enable Local AI Co-processor in this workspace context?', default: true })
     : false;
 
+  // ── 5.5. Suggest workflow strategy ───────────────────────────────
+  const workflowSpinner = ora('Suggesting teamwork collaboration strategy...').start();
+  let teamworkInstructions = '';
+  try {
+    const suggestion = await suggestWorkflow(description, selectedRepos, config.localLlm);
+    teamworkInstructions = suggestion.customInstructions;
+    workflowSpinner.succeed(`Auto-selected strategy for ${chalk.bold(suggestion.difficulty)} difficulty task`);
+  } catch (err) {
+    workflowSpinner.fail('Failed to suggest teamwork strategy');
+  }
+
   // ── 6. Create workspace ─────────────────────────────────────────────
   const workspacePath = path.join(config.workspacesDir, branchName);
   const feature: Feature = {
@@ -98,6 +109,7 @@ export async function createCommand(): Promise<void> {
     workspacePath,
     createdAt: new Date().toISOString(),
     localLlmEnabled,
+    teamworkInstructions,
   };
 
   const wsSpinner = ora('Creating workspace with git worktrees...').start();
@@ -124,22 +136,7 @@ export async function createCommand(): Promise<void> {
   console.log(chalk.cyan('\nGenerating AI context files...'));
   await generateContextFiles(ctx, selectedAI, workspacePath);
 
-  // ── 8.5. Pack codebase context ──────────────────────────────────────
-  if (config.packContextXml) {
-    const packSpinner = ora('Packing codebase context with Repomix...').start();
-    try {
-      const packResult = await packWorkspace(workspacePath);
-      const filesCount = packResult.outputPaths?.length || 1;
-      packSpinner.succeed(
-        `Packed codebase context into ${filesCount} file(s) (${packResult.totalFiles} files total, ${(packResult.fileSize / 1024).toFixed(2)} KB)`
-      );
-    } catch (error) {
-      packSpinner.fail('Failed to pack codebase context');
-      console.error(chalk.red(`  ${error}`));
-    }
-  } else {
-    console.log(chalk.gray('\n  ○ Skipping codebase context packing (packContextXml is disabled)'));
-  }
+  // Monolithic XML context packing removed.
 
   // ── 8. Open in editor ───────────────────────────────────────────────
   const detectedEditors = await detectEditors();

package/src/commands/desktop.ts

@@ -0,0 +1,128 @@
+/**
+ * @module commands/desktop
+ * Launches the NexusFlow desktop application (Neutralinojs).
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+
+/**
+ * Resolves the workspace root directory.
+ *
+ * Assumes the standard NexusFlow workspace layout where the `desktop/`
+ * project is a sibling of the `NexusFlow/` project under the same
+ * workspace root:
+ *
+ *   <workspace-root>/
+ *     NexusFlow/          ← this CLI project
+ *     desktop/            ← Neutralinojs desktop app
+ *       dist/nexusflow-desktop/<platform-binary>
+ *
+ * At runtime this file is compiled to `NexusFlow/dist/commands/desktop.js`,
+ * so the workspace root is three levels up.
+ */
+function resolveWorkspaceRoot(): string {
+  const thisDir = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(thisDir, '..', '..', '..');
+}
+
+/**
+ * Returns the desktop dist directory path.
+ */
+function getDesktopDistDir(): string {
+  return path.join(resolveWorkspaceRoot(), 'desktop', 'dist', 'nexusflow-desktop');
+}
+
+/**
+ * Resolves the platform-specific binary path for the desktop app.
+ *
+ * On macOS the architecture is taken into account:
+ * - arm64 → `nexusflow-desktop-mac_arm64`
+ * - x64   → prefers `nexusflow-desktop-mac_x64`, falls back to universal
+ */
+function findDesktopBinary(): string | null {
+  const desktopDistDir = getDesktopDistDir();
+  const platform = process.platform;
+  const arch = process.arch;
+  let binaryName: string;
+
+  if (platform === 'win32') {
+    binaryName = 'nexusflow-desktop-win_x64.exe';
+  } else if (platform === 'darwin') {
+    if (arch === 'arm64') {
+      binaryName = 'nexusflow-desktop-mac_arm64';
+    } else {
+      // Prefer smaller x64 binary, fall back to universal
+      const x64Path = path.join(desktopDistDir, 'nexusflow-desktop-mac_x64');
+      binaryName = existsSync(x64Path) ? 'nexusflow-desktop-mac_x64' : 'nexusflow-desktop-mac_universal';
+    }
+  } else {
+    // Linux — detect ARM architectures
+    if (arch === 'arm64') {
+      binaryName = 'nexusflow-desktop-linux_arm64';
+    } else if (arch === 'arm') {
+      binaryName = 'nexusflow-desktop-linux_armhf';
+    } else {
+      binaryName = 'nexusflow-desktop-linux_x64';
+    }
+  }
+
+  const fullPath = path.join(desktopDistDir, binaryName);
+  return existsSync(fullPath) ? fullPath : null;
+}
+
+/**
+ * Returns the expected binary path for display in the "not found" message.
+ */
+function getExpectedBinaryPath(): string {
+  const desktopDistDir = getDesktopDistDir();
+  switch (process.platform) {
+    case 'win32':
+      return path.join(desktopDistDir, 'nexusflow-desktop-win_x64.exe');
+    case 'darwin':
+      return path.join(desktopDistDir, 'nexusflow-desktop-mac_*');
+    case 'linux':
+    default:
+      return path.join(desktopDistDir, 'nexusflow-desktop-linux_x64');
+  }
+}
+
+/**
+ * Launches the NexusFlow desktop application.
+ *
+ * Spawns the process detached and unrefs it so the CLI exits immediately
+ * while the desktop app keeps running.
+ */
+export async function desktopCommand(): Promise<void> {
+  console.log(chalk.bold.cyan('\n🖥️  NexusFlow — Desktop App\n'));
+
+  const binaryPath = findDesktopBinary();
+
+  if (!binaryPath) {
+    const expectedPath = getExpectedBinaryPath();
+    console.log(chalk.yellow('Desktop binary not found at:'));
+    console.log(chalk.dim(`  ${expectedPath}\n`));
+    console.log(chalk.white('To build it, run:\n'));
+    console.log(chalk.green('  cd desktop && npm install && npm run build\n'));
+    return;
+  }
+
+  console.log(chalk.dim(`Launching ${path.basename(binaryPath)}…`));
+
+  const child = spawn(binaryPath, [], {
+    detached: true,
+    stdio: 'ignore',
+    cwd: path.dirname(binaryPath), // Required: Neutralino looks for resources.neu in cwd
+  });
+
+  child.on('error', (err) => {
+    console.error(chalk.red(`  ✖ Desktop app process error: ${err.message}`));
+  });
+
+  child.unref();
+
+  console.log(chalk.green('Desktop app launched successfully.\n'));
+}

package/src/commands/doctor.ts

@@ -211,6 +211,19 @@ export async function doctorCommand(workspaceArg?: string): Promise<void> {
     }
   }
 
+  // Check .code-workspace file exists (required for VS Code SCM to discover worktrees)
+  const workspaceName = path.basename(workspacePath);
+  const codeWorkspacePath = path.join(workspacePath, `${workspaceName}.code-workspace`);
+  try {
+    await fs.access(codeWorkspacePath);
+    console.log(`  ${chalk.green('✔')} ${workspaceName}.code-workspace exists`);
+  } catch {
+    warnings.push(
+      `Missing ${workspaceName}.code-workspace. VS Code SCM will not show changes inside repo sub-folders. Run \`nexusflow refresh\` to regenerate it.`
+    );
+    console.log(`  ${chalk.yellow('⚠')} ${workspaceName}.code-workspace is missing`);
+  }
+
   // Check VS Code Settings for search.useIgnoreFiles: false
   const vscodeSettingsPath = path.join(workspacePath, '.vscode', 'settings.json');
   try {

package/src/commands/mcp.ts

@@ -90,3 +90,5 @@ export async function mcpSetupCommand() {
     console.log(JSON.stringify({ mcpServers: { nexusflow: mcpConfig } }, null, 2));
   }
 }
+
+

package/src/commands/refresh.ts

@@ -18,7 +18,7 @@ import type { WorkspaceContext } from '../types.js';
  * @param workspaceArg - Optional workspace path.
  */
 export async function refreshCommand(
-  options: { repo?: string },
+  options: { repo?: string; base?: boolean },
   workspaceArg?: string,
 ): Promise<void> {
   console.log(chalk.bold.cyan('\n🔄 NexusFlow — Refresh Workspace Context\n'));
@@ -66,19 +66,9 @@ export async function refreshCommand(
   };
 
   console.log(chalk.cyan('Regenerating context files and maps...'));
-  await generateContextFiles(ctx, feature.assistants, workspacePath, onlyRepo);
+  await generateContextFiles(ctx, feature.assistants, workspacePath, onlyRepo, options.base);
+
 
-  // If repopack context packing is enabled
-  const config = await loadConfig();
-  if (config.packContextXml) {
-    const { packWorkspace } = await import('../core/packer.js');
-    console.log(chalk.cyan('Re-packing workspace context...'));
-    try {
-      await packWorkspace(workspacePath);
-    } catch (error) {
-      console.warn(chalk.yellow(`  ⚠ Failed to repack context: ${error}`));
-    }
-  }
 
   // If handoff file exists, refresh it automatically too!
   const handoffPath = path.join(workspacePath, 'nexusflow-handoff.md');
@@ -88,7 +78,7 @@ export async function refreshCommand(
     hasHandoff = true;
   } catch {}
 
-  if (hasHandoff) {
+  if (!options.base && hasHandoff) {
     console.log(chalk.cyan('Refreshing handoff bundle...'));
     try {
       const { handoffCommand } = await import('./handoff.js');