@mrpatronz/nexusflow 0.2.19 → 1.3.1

package/src/commands/adapter.ts

@@ -1,348 +0,0 @@
-/**
- * @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

@@ -1,156 +0,0 @@
-/**
- * @module commands/add-repo
- * Adds a repository to an existing NexusFlow workspace.
- */
-
-import chalk from 'chalk';
-import ora from 'ora';
-import { select, search } 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 = cwdFeature.workspacePath;
-      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 search({
-        message: 'Search and select a workspace to add a repository to:',
-        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;
-      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 search({
-      message: 'Search and select a repository to add:',
-      source: async (input) => {
-        const query = (input || '').toLowerCase();
-        const filtered = availableRepos.filter(
-          (r) =>
-            r.name.toLowerCase().includes(query) ||
-            r.path.toLowerCase().includes(query)
-        );
-        return filtered.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();
-  } catch (error) {
-    spinner.fail(`Failed to add repository: ${error instanceof Error ? error.message : String(error)}`);
-    console.log();
-  }
-}

package/src/commands/commands.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { handoffCommand } from './handoff.js';
-import { refreshCommand } from './refresh.js';
-import { doctorCommand } from './doctor.js';
-import * as workspace from '../core/workspace.js';
-import * as multiGit from '../utils/multi-git.js';
-import * as analyzers from '../analyzers/index.js';
-import * as generators from '../generators/index.js';
-
-vi.mock('node:fs/promises');
-vi.mock('execa');
-vi.mock('../core/workspace.js');
-vi.mock('../utils/multi-git.js');
-vi.mock('../analyzers/index.js');
-vi.mock('../generators/index.js');
-
-describe('NexusFlow CLI New Commands unit tests', () => {
-  const mockWorkspacePath = path.resolve('/mock/workspace');
-  const repo1Path = path.join(mockWorkspacePath, 'repo-1');
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('handoffCommand', () => {
-    it('should generate a handoff bundle with repository status, branch and suggested files', async () => {
-      const mockFeature = {
-        id: 'test-feature',
-        branchName: 'test-feature-branch',
-        description: 'Test Feature description',
-        repos: [repo1Path],
-        originalRepos: [path.resolve('/mock/repo-1')],
-        assistants: ['claude' as const],
-        workspacePath: mockWorkspacePath,
-        createdAt: new Date().toISOString(),
-      };
-
-      vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature);
-      vi.spyOn(multiGit, 'getRepoStatus').mockResolvedValue({
-        hasChanges: true,
-        changedFiles: ['src/file1.ts'],
-        summary: '1 file changed',
-      });
-      
-      const mockAnalysis = new Map();
-      mockAnalysis.set(repo1Path, {
-        name: 'repo-1',
-        path: repo1Path,
-        techStack: { languages: ['typescript'], frameworks: [], buildTools: [], projectType: 'backend' },
-        endpoints: [],
-        dependencies: [],
-        ports: [],
-        readmeSummary: 'README summary',
-        existingAIConfigs: [],
-      });
-      vi.spyOn(analyzers, 'analyzeAllRepos').mockResolvedValue(mockAnalysis);
-
-      const writtenFiles: Record<string, string> = {};
-      vi.spyOn(fs, 'writeFile').mockImplementation(async (filePath: any, content: any) => {
-        writtenFiles[path.resolve(filePath as string)] = content as string;
-        return Promise.resolve();
-      });
-
-      // Run handoff command
-      await handoffCommand(mockWorkspacePath);
-
-      const expectedHandoffPath = path.resolve(path.join(mockWorkspacePath, 'nexusflow-handoff.md'));
-      expect(fs.writeFile).toHaveBeenCalled();
-      expect(writtenFiles[expectedHandoffPath]).toBeDefined();
-
-      const content = writtenFiles[expectedHandoffPath]!;
-      expect(content).toContain('# NexusFlow Handoff Bundle — test-feature-branch');
-      expect(content).toContain('repo-1');
-      expect(content).toContain('1 file changed');
-      expect(content).toContain('src/file1.ts');
-    });
-  });
-
-  describe('refreshCommand', () => {
-    it('should trigger context regeneration and optional repack', async () => {
-      const mockFeature = {
-        id: 'test-feature',
-        branchName: 'test-feature-branch',
-        description: 'Test Feature description',
-        repos: [repo1Path],
-        originalRepos: [path.resolve('/mock/repo-1')],
-        assistants: ['claude' as const],
-        workspacePath: mockWorkspacePath,
-        createdAt: new Date().toISOString(),
-      };
-
-      vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature);
-      vi.spyOn(analyzers, 'analyzeAllRepos').mockResolvedValue(new Map());
-      vi.spyOn(generators, 'generateContextFiles').mockResolvedValue(undefined);
-
-      // Run refresh command with repo filter
-      await refreshCommand({ repo: 'repo-1' }, mockWorkspacePath);
-
-      expect(analyzers.analyzeAllRepos).toHaveBeenCalled();
-      expect(generators.generateContextFiles).toHaveBeenCalledWith(
-        expect.any(Object),
-        expect.any(Array),
-        mockWorkspacePath,
-        'repo-1',
-        undefined
-      );
-    });
-  });
-
-  describe('doctorCommand', () => {
-    it('should complete health check successfully', async () => {
-      const mockFeature = {
-        id: 'test-feature',
-        branchName: 'test-feature-branch',
-        description: 'Test Feature description',
-        repos: [repo1Path],
-        originalRepos: [path.resolve('/mock/repo-1')],
-        assistants: ['claude' as const],
-        workspacePath: mockWorkspacePath,
-        createdAt: new Date().toISOString(),
-      };
-
-      vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature);
-      vi.spyOn(fs, 'stat').mockResolvedValue({ isDirectory: () => true } as any);
-      vi.spyOn(multiGit, 'getRepoStatus').mockResolvedValue({
-        hasChanges: false,
-        changedFiles: [],
-        summary: 'Clean',
-      });
-
-      const mockAnalysis = new Map();
-      mockAnalysis.set(repo1Path, {
-        name: 'repo-1',
-        path: repo1Path,
-        techStack: { languages: ['typescript'], frameworks: [], buildTools: [], projectType: 'backend' },
-        endpoints: [],
-        dependencies: [],
-        ports: [],
-        readmeSummary: 'README summary',
-        existingAIConfigs: [],
-      });
-      vi.spyOn(analyzers, 'analyzeAllRepos').mockResolvedValue(mockAnalysis);
-      vi.spyOn(fs, 'access').mockResolvedValue(undefined); // covers .code-workspace + artifact checks
-      vi.spyOn(fs, 'readFile').mockResolvedValue(JSON.stringify({ "search.useIgnoreFiles": false }));
-
-      // Run doctor command
-      await doctorCommand(mockWorkspacePath);
-
-      expect(workspace.loadFeatureConfig).toHaveBeenCalledWith(mockWorkspacePath);
-      expect(fs.stat).toHaveBeenCalledWith(repo1Path);
-      expect(analyzers.analyzeAllRepos).toHaveBeenCalled();
-    });
-  });
-});