@mrpatronz/nexusflow 0.2.13 → 0.2.18

package/src/generators/plan-generator.ts

@@ -7,6 +7,7 @@
 import path from 'node:path';
 import fse from 'fs-extra';
 import chalk from 'chalk';
+import { writeWorkspaceFile } from '../core/storage.js';
 import type {
   WorkspaceContext,
   ProjectAnalysis,
@@ -187,8 +188,10 @@ export async function generateImplementationPlan(
           .map((n) => `- ${n}`),
         '',
       ];
-      await fse.outputFile(
-        path.join(workspacePath, 'nexusflow-plan.md'),
+      await writeWorkspaceFile(
+        workspacePath,
+        feature.id,
+        'nexusflow-plan.md',
         lines.join('\n'),
       );
       console.log(chalk.green('  ✔'), 'Generated nexusflow-plan.md');
@@ -420,8 +423,7 @@ export async function generateImplementationPlan(
     md.push('');
 
     // ── Write file ──────────────────────────────────────────────────────
-    const outPath = path.join(workspacePath, 'nexusflow-plan.md');
-    await fse.outputFile(outPath, md.join('\n'));
+    await writeWorkspaceFile(workspacePath, feature.id, 'nexusflow-plan.md', md.join('\n'));
     console.log(chalk.green('  ✔'), 'Generated nexusflow-plan.md');
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/src/index.ts

@@ -20,16 +20,21 @@ import { stopCommand } from './commands/stop.js';
 import { logsCommand } from './commands/logs.js';
 import { statusCommand } from './commands/status.js';
 import { uiCommand } from './commands/ui.js';
+import { tuiCommand } from './commands/tui.js';
 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 { loadConfig } from './core/config.js';
+import { loadPlugins } from './core/plugins/loader.js';
 import { addRepoCommand } from './commands/add-repo.js';
 import { mcpRunCommand, mcpSetupCommand } from './commands/mcp.js';
 import { handoffCommand } from './commands/handoff.js';
 import { refreshCommand } from './commands/refresh.js';
 import { doctorCommand } from './commands/doctor.js';
+import { desktopCommand } from './commands/desktop.js';
+import { configShowCommand, configGetCommand, configSetCommand } from './commands/config.js';
+import { adapterListCommand, adapterUseCommand, adapterInfoCommand, adapterInitCommand } from './commands/adapter.js';
 import { getCurrentVersion, checkForUpdates, printUpdateBanner } from './utils/update-check.js';
 
 const program = new Command();
@@ -177,7 +182,9 @@ 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 }) => {
+  .option('-d, --daemon', 'Run the dashboard server in the background (daemon mode)')
+  .option('--server-only', 'Start the dashboard server without opening the browser')
+  .action(async (options: { port?: string; daemon?: boolean; serverOnly?: boolean }) => {
     try {
       await uiCommand(options);
     } catch (error) {
@@ -186,6 +193,34 @@ program
     }
   });
 
+program
+  .command('dashboard')
+  .alias('dash')
+  .description('Instantly open the web GUI dashboard in your default browser')
+  .option('-p, --port <number>', 'Port to run the dashboard server on', '3000')
+  .action(async (options: { port?: string }) => {
+    try {
+      await uiCommand({ ...options, daemon: true });
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+
+program
+  .command('tui')
+  .description('Open the interactive terminal GUI (TUI) dashboard')
+  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
+  .action(async (workspace?: string) => {
+    try {
+      await tuiCommand({ workspace });
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
 program
   .command('sync')
   .description('Sync all repositories in a workspace')
@@ -240,23 +275,7 @@ program
     }
   });
 
-program
-  .command('pack')
-  .description('Pack the workspace codebase into a single token-efficient XML file for AI consumption')
-  .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
-  .option('--no-compress', 'Do not compress files (strip comments, empty lines)')
-  .action(async (workspace: string | undefined, options: { compress?: boolean }) => {
-    try {
-      await packCommand(workspace, options);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes('User force closed')) {
-        console.log('\nCancelled.');
-        process.exit(0);
-      }
-      console.error(error);
-      process.exit(1);
-    }
-  });
+// Pack command removed.
 
 program
   .command('remove')
@@ -313,7 +332,8 @@ program
   .description('Refresh workspace context, maps, plans and handoff files')
   .argument('[workspace]', 'Path to workspace (auto-detects from CWD)')
   .option('-r, --repo <repo>', 'Only refresh the map for a specific repository')
-  .action(async (workspace: string | undefined, options: { repo?: string }) => {
+  .option('-b, --base', 'Only refresh base-layer maps and codebase knowledge from main')
+  .action(async (workspace: string | undefined, options: { repo?: string; base?: boolean }) => {
     try {
       await refreshCommand(options, workspace);
     } catch (error) {
@@ -335,6 +355,133 @@ program
     }
   });
 
+program
+  .command('desktop')
+  .description('Launch the NexusFlow desktop application')
+  .action(async () => {
+    try {
+      await desktopCommand();
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+// Config command group
+const configCmd = program.command('config').description('View and update NexusFlow configuration');
+
+configCmd
+  .command('show')
+  .description('Display the current configuration')
+  .action(async () => {
+    try {
+      await configShowCommand();
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+configCmd
+  .command('get')
+  .description('Get a specific configuration key')
+  .argument('<key>', 'Configuration key to read')
+  .action(async (key: string) => {
+    try {
+      await configGetCommand(key);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+configCmd
+  .command('set')
+  .description('Set a configuration key to a value')
+  .argument('<key>', 'Configuration key to set')
+  .argument('<value>', 'Value to assign')
+  .action(async (key: string, value: string) => {
+    try {
+      await configSetCommand(key, value);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+// Default action when 'nexusflow config' is run without a subcommand
+configCmd.action(async () => {
+  try {
+    await configShowCommand();
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+
+// Adapter command group
+const adapterCmd = program.command('adapter').description('Manage storage adapters — list, switch, configure, or create new ones');
+
+adapterCmd
+  .command('list')
+  .description('List all available storage adapters')
+  .action(async () => {
+    try {
+      await adapterListCommand();
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+adapterCmd
+  .command('use')
+  .description('Switch to a different storage adapter (prompts for config if needed)')
+  .argument('<name>', 'Adapter name to activate')
+  .action(async (name: string) => {
+    try {
+      await adapterUseCommand(name);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+adapterCmd
+  .command('info')
+  .description('Show detailed information about an adapter')
+  .argument('<name>', 'Adapter name to inspect')
+  .action(async (name: string) => {
+    try {
+      await adapterInfoCommand(name);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+adapterCmd
+  .command('init')
+  .description('Scaffold a new adapter plugin project')
+  .argument('<name>', 'Name for the new adapter')
+  .action(async (name: string) => {
+    try {
+      await adapterInitCommand(name);
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+// Default action when 'nexusflow adapter' is run without a subcommand
+adapterCmd.action(async () => {
+  try {
+    await adapterListCommand();
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+
 const mcp = program.command('mcp').description('Manage the NexusFlow MCP Server for AI assistants');
 
 mcp
@@ -378,5 +525,15 @@ program.hook('postAction', async (thisCommand, actionCommand) => {
   }
 });
 
-program.parse();
+async function bootstrap() {
+  try {
+    const config = await loadConfig();
+    if (config.plugins && config.plugins.length > 0) {
+      await loadPlugins(program, config.plugins);
+    }
+  } catch {}
+  await program.parseAsync(process.argv);
+}
+
+bootstrap();
 

package/src/server.test.ts

@@ -9,7 +9,8 @@ import * as localAi from './utils/local-ai.js';
 import * as updateCheck from './utils/update-check.js';
 import * as analyzers from './analyzers/index.js';
 import * as generators from './generators/index.js';
-import * as packer from './core/packer.js';
+import * as workflows from './utils/workflows.js';
+import * as detectAi from './utils/detect-ai.js';
 
 // Mock dependencies
 vi.mock('node:fs/promises');
@@ -21,7 +22,10 @@ vi.mock('./utils/local-ai.js');
 vi.mock('./utils/update-check.js');
 vi.mock('./analyzers/index.js');
 vi.mock('./generators/index.js');
-vi.mock('./core/packer.js');
+vi.mock('./utils/workflows.js');
+vi.mock('./utils/detect-ai.js', () => ({
+  detectAIAssistants: vi.fn().mockResolvedValue([])
+}));
 
 describe('Server API Endpoints Unit Tests', () => {
   beforeEach(() => {
@@ -200,6 +204,25 @@ describe('Server API Endpoints Unit Tests', () => {
     });
   });
 
+  describe('GET /api/adapters', () => {
+    it('should return all registered storage adapters with meta', async () => {
+      const response = await app.request('/api/adapters');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.adapters).toBeDefined();
+      expect(Array.isArray(data.adapters)).toBe(true);
+      // It should include at least 'local', 'central-vault', and 'obsidian'
+      const names = data.adapters.map((a: any) => a.name);
+      expect(names).toContain('local');
+      expect(names).toContain('central-vault');
+      expect(names).toContain('obsidian');
+
+      const obsidian = data.adapters.find((a: any) => a.name === 'obsidian');
+      expect(obsidian.displayName).toBe('Obsidian Vault');
+      expect(obsidian.configFields.length).toBeGreaterThan(0);
+    });
+  });
+
   describe('POST /api/config', () => {
     it('should validate endpoint domain safety', async () => {
       const response = await app.request('/api/config', {
@@ -215,7 +238,7 @@ describe('Server API Endpoints Unit Tests', () => {
 
       expect(response.status).toBe(400);
       const data = await response.json();
-      expect(data.error).toContain('Local AI endpoint must be localhost, 127.0.0.1, or a private LAN IP.');
+      expect(data.error).toContain('Local AI endpoint must be HTTPS, localhost, 127.0.0.1, or a private LAN IP.');
     });
 
     it('should save safe endpoint and config', async () => {
@@ -360,22 +383,22 @@ describe('Server API Endpoints Unit Tests', () => {
       const response = await app.request('/api/updates/install', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ toolId: 'repomix' })
+        body: JSON.stringify({ toolId: 'nexusflow' })
       });
 
       expect(response.status).toBe(200);
       const data = await response.json();
       expect(data.success).toBe(true);
       expect(data.output).toBe('Successfully updated');
-      expect(execa).toHaveBeenCalledWith('npm', ['install', '-g', 'repomix'], expect.any(Object));
+      expect(execa).toHaveBeenCalledWith('npm', ['install', '-g', '@mrpatronz/nexusflow'], expect.any(Object));
     });
   });
 
   describe('POST /api/workspace', () => {
-    it('should complete workspace creation successfully when packContextXml is false', async () => {
+    it('should complete workspace creation successfully', async () => {
       vi.spyOn(config, 'loadConfig').mockResolvedValue({
         workspacesDir: '/mock/workspaces',
-        packContextXml: false
+        storageProvider: 'local'
       } as any);
 
       vi.spyOn(workspace, 'createWorkspace').mockResolvedValue('/mock/workspaces/test-ws-creation-no-pack');
@@ -413,52 +436,183 @@ describe('Server API Endpoints Unit Tests', () => {
       expect(text).toContain('"progress":100');
     });
 
-    it('should complete workspace creation successfully when packContextXml is true', async () => {
-      vi.spyOn(config, 'loadConfig').mockResolvedValue({
-        workspacesDir: '/mock/workspaces',
-        packContextXml: true
-      } as any);
+    // XML context packing tests removed.
+  });
 
-      vi.spyOn(workspace, 'createWorkspace').mockResolvedValue('/mock/workspaces/test-ws-creation-with-pack');
-      vi.spyOn(analyzers, 'analyzeAllRepos').mockResolvedValue(new Map());
-      vi.spyOn(generators, 'generateContextFiles').mockResolvedValue(undefined);
-      vi.spyOn(packer, 'packWorkspace').mockResolvedValue({
-        outputPath: '/mock/workspace/nexusflow-context.xml',
-        totalFiles: 5,
-        totalCharacters: 1000,
-        fileSize: 5120
+  describe('Workflows Templates API', () => {
+    it('GET /api/workflows/templates should return list of templates', async () => {
+      vi.spyOn(workflows, 'getWorkflowTemplates').mockResolvedValue([
+        { id: 'test-id', name: 'Test Name', description: 'Test Desc', content: 'Test Content', custom: false }
+      ]);
+
+      const response = await app.request('/api/workflows/templates');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({
+        templates: [
+          { id: 'test-id', name: 'Test Name', description: 'Test Desc', content: 'Test Content', custom: false }
+        ]
       });
+    });
 
-      const response = await app.request('/api/workspace', {
+    it('POST /api/workflows/templates should create or update template', async () => {
+      vi.spyOn(workflows, 'saveWorkflowTemplate').mockResolvedValue({
+        id: 'test-id',
+        name: 'Test Name',
+        description: 'Test Desc',
+        content: 'Test Content',
+        custom: true
+      });
+
+      const response = await app.request('/api/workflows/templates', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ id: 'old-id', name: 'Test Name', content: 'Test Content' })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+      expect(data.template.id).toBe('test-id');
+      expect(workflows.saveWorkflowTemplate).toHaveBeenCalledWith('Test Name', 'Test Content', 'old-id');
+    });
+
+    it('DELETE /api/workflows/templates/:id should delete template', async () => {
+      vi.spyOn(workflows, 'getWorkflowTemplates').mockResolvedValue([
+        { id: 'test-id', name: 'Test Name', description: 'Test Desc', content: 'Test Content', custom: true }
+      ]);
+      vi.spyOn(workflows, 'deleteWorkflowTemplate').mockResolvedValue(undefined);
+
+      const response = await app.request('/api/workflows/templates/test-id', {
+        method: 'DELETE'
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+      expect(workflows.deleteWorkflowTemplate).toHaveBeenCalledWith('test-id');
+    });
+
+    it('POST /api/workflows/templates/:id/analyze should run inspection with comment', async () => {
+      vi.mocked(detectAi.detectAIAssistants).mockResolvedValue([
+        { name: 'antigravity', displayName: 'Antigravity', detected: true, command: 'agy' }
+      ]);
+      
+      vi.mocked(execa).mockResolvedValue({
+        exitCode: 0,
+        stdout: 'Review result: Success\n=== SUGGESTED IMPROVEMENT START ===\n# Refined Strategy\n=== SUGGESTED IMPROVEMENT END ==='
+      } as any);
+
+      const response = await app.request('/api/workflows/templates/test-id/analyze', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          branchName: 'test-ws-creation-with-pack',
-          description: 'A test workspace',
-          repos: [{ name: 'repo-1', path: '/mock/repo-1' }],
-          assistants: ['antigravity']
+          content: 'My Strategy guidelines',
+          assistant: 'antigravity',
+          comment: 'Check for timeouts'
         })
       });
 
       expect(response.status).toBe(200);
       const data = await response.json();
-      expect(data.success).toBe(true);
-      expect(data.jobId).toBe('test-ws-creation-with-pack');
+      expect(data.analysis).toContain('Review result: Success');
+      expect(data.suggestedImprovement).toBe('# Refined Strategy');
+      expect(execa).toHaveBeenCalled();
+      
+      const calledArgs = vi.mocked(execa).mock.calls[0][1];
+      expect(JSON.stringify(calledArgs)).toContain('Check for timeouts');
+    });
 
-      // Wait a brief tick for the background job to execute
-      await new Promise((resolve) => setTimeout(resolve, 50));
+    describe('POST /api/workspace/suggest-workflow', () => {
+      it('should suggest a workflow using heuristics when local LLM is disabled', async () => {
+        vi.spyOn(config, 'loadConfig').mockResolvedValue({
+          version: '1.0',
+          devDir: '/dev',
+          workspacesDir: '/dev/workspaces',
+          defaultAssistant: null,
+          scanDepth: 2,
+          localLlm: { enabled: false, provider: 'ollama', endpoint: 'http://localhost:11434', model: 'qwen' }
+        });
+
+        const response = await app.request('/api/workspace/suggest-workflow', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            description: 'Fix a typo in README.md and update comments',
+            repos: [{ name: 'my-project', path: '/dev/my-project', defaultBranch: 'main' }]
+          })
+        });
+
+        expect(response.status).toBe(200);
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.difficulty).toBe('simple');
+        expect(data.suggestedWorkflowId).toBe('solo-developer');
+        expect(data.customInstructions).toContain('Solo Developer');
+      });
 
-      expect(workspace.createWorkspace).toHaveBeenCalled();
-      expect(analyzers.analyzeAllRepos).toHaveBeenCalled();
-      expect(generators.generateContextFiles).toHaveBeenCalled();
-      expect(packer.packWorkspace).toHaveBeenCalled();
+      it('should suggest a complex workflow when description contains complex keywords', async () => {
+        vi.spyOn(config, 'loadConfig').mockResolvedValue({
+          version: '1.0',
+          devDir: '/dev',
+          workspacesDir: '/dev/workspaces',
+          defaultAssistant: null,
+          scanDepth: 2,
+          localLlm: { enabled: false, provider: 'ollama', endpoint: 'http://localhost:11434', model: 'qwen' }
+        });
+
+        const response = await app.request('/api/workspace/suggest-workflow', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            description: 'Refactor database schema and migrate data to postgres',
+            repos: [{ name: 'my-project', path: '/dev/my-project', defaultBranch: 'main' }]
+          })
+        });
+
+        expect(response.status).toBe(200);
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.difficulty).toBe('complex');
+        expect(data.suggestedWorkflowId).toBe('plan-implement-review');
+        expect(data.customInstructions).toContain('Plan, Implement, Review');
+      });
 
-      // Read status via SSE stream route
-      const streamResponse = await app.request('/api/workspace/create-stream/test-ws-creation-with-pack');
-      expect(streamResponse.status).toBe(200);
-      const text = await streamResponse.text();
-      expect(text).toContain('"status":"completed"');
-      expect(text).toContain('"progress":100');
+      it('should call local LLM and return suggested workflow when LLM is enabled', async () => {
+        vi.spyOn(config, 'loadConfig').mockResolvedValue({
+          version: '1.0',
+          devDir: '/dev',
+          workspacesDir: '/dev/workspaces',
+          defaultAssistant: null,
+          scanDepth: 2,
+          localLlm: { enabled: true, provider: 'ollama', endpoint: 'http://localhost:11434', model: 'qwen' }
+        });
+
+        vi.spyOn(localAi, 'callLocalLlm').mockResolvedValue(JSON.stringify({
+          difficulty: 'moderate',
+          rationale: 'LLM selected moderate strategy.',
+          suggestedWorkflowId: 'research-verify',
+          customInstructions: '# LLM Custom Instructions'
+        }));
+
+        const response = await app.request('/api/workspace/suggest-workflow', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            description: 'Implement new UI component',
+            repos: [{ name: 'my-project', path: '/dev/my-project', defaultBranch: 'main' }]
+          })
+        });
+
+        expect(response.status).toBe(200);
+        const data = await response.json();
+        expect(data.success).toBe(true);
+        expect(data.difficulty).toBe('moderate');
+        expect(data.rationale).toBe('LLM selected moderate strategy.');
+        expect(data.suggestedWorkflowId).toBe('research-verify');
+        expect(data.customInstructions).toBe('# LLM Custom Instructions');
+        expect(localAi.callLocalLlm).toHaveBeenCalled();
+      });
     });
   });
 });