@mrpatronz/nexusflow 0.1.12 → 0.2.0

package/src/commands/sync.ts

@@ -11,6 +11,9 @@ import * as fs from 'node:fs/promises';
 import { loadConfig } from '../core/config.js';
 import { listWorkspaces, loadFeatureConfig } from '../core/workspace.js';
 import { getWorkspaceRepos, rebaseRepo } from '../utils/multi-git.js';
+import { analyzeAllRepos } from '../analyzers/index.js';
+import { generateContextFiles } from '../generators/index.js';
+import type { WorkspaceContext } from '../types.js';
 
 /**
  * Executes the sync command.
@@ -70,6 +73,38 @@ export async function syncCommand(workspaceArg?: string): Promise<void> {
   }
 
   console.log(`\n📊 ${chalk.bold('Summary:')} ${syncedCount} synced, ${conflictCount} conflict(s)\n`);
+
+  if (syncedCount > 0) {
+    console.log(chalk.cyan('Regenerating architecture maps and context...'));
+    try {
+      const allRepos = await Promise.all(feature.repos.map(r => {
+        const repoName = path.basename(r);
+        return {
+          name: repoName,
+          path: r,
+          defaultBranch: 'main',
+        };
+      }));
+
+      const analysis = await analyzeAllRepos(allRepos);
+      const ctx: WorkspaceContext = {
+        feature,
+        repos: allRepos,
+        analysis,
+      };
+
+      await generateContextFiles(ctx, feature.assistants, workspacePath);
+
+      const config = await loadConfig();
+      if (config.packContextXml) {
+        const { packWorkspace } = await import('../core/packer.js');
+        await packWorkspace(workspacePath);
+      }
+      console.log(chalk.green('✅ Workspace maps and contexts successfully updated.\n'));
+    } catch (error) {
+      console.error(chalk.red(`✖ Failed to regenerate maps: ${error instanceof Error ? error.message : String(error)}\n`));
+    }
+  }
 }
 
 /**

package/src/core/config.ts

@@ -32,6 +32,31 @@ export function getDefaultConfig(): NexusFlowConfig {
     workspacesDir: path.join(os.homedir(), 'dev', 'workspaces'),
     defaultAssistant: null,
     scanDepth: 2,
+    packContextXml: true,
+    excludePatterns: [
+      '**/node_modules/**',
+      '**/bin/**',
+      '**/obj/**',
+      '**/dist/**',
+      '**/out/**',
+      '**/.git/**',
+      '**/*.lock',
+      '**/package-lock.json',
+      '**/pnpm-lock.yaml',
+      '**/yarn.lock',
+      '**/*.png',
+      '**/*.jpg',
+      '**/*.jpeg',
+      '**/*.gif',
+      '**/*.svg',
+      '**/*.ico',
+      '**/*.pdf',
+      '**/*.zip',
+      '**/*.tar.gz',
+      '**/.vs/**',
+      '**/.vscode/**',
+      '**/.idea/**',
+    ],
   };
 }
 

package/src/core/graph.ts

@@ -128,10 +128,9 @@ export async function buildWorkspaceGraph(
 
   // 3. Add inter-repo DEPENDS_ON edges
   if (analysis) {
-    const repoAnalyses = new Map(repos.map((r) => [r.path, analysis.get(r.path)?.dependencies || []]));
     const repoNames = new Map(repos.map((r) => [r.path, r.name]));
     const { findInterRepoDependencies } = await import('../analyzers/detect-deps.js');
-    const interDeps = findInterRepoDependencies(repoAnalyses, repoNames);
+    const interDeps = findInterRepoDependencies(analysis, repoNames);
 
     for (const [caller, callees] of interDeps) {
       for (const callee of callees) {

package/src/core/packer.test.ts

@@ -64,11 +64,10 @@ describe('packWorkspace', () => {
     expect(result.totalCharacters).toBe(9001);
     expect(result.fileSize).toBeGreaterThan(0);
     
-    // Read the generated output file and verify streaming combination works
+    // Read the generated output file and verify
     const outputContent = await fs.readFile(result.outputPath, 'utf-8');
-    expect(outputContent).toContain('<workspace id="test-feature">');
-    expect(outputContent).toContain('<repository name="repo-a">');
     expect(outputContent).toContain('<file path="test.txt">mock repomix content</file>');
+    expect(result.outputPaths).toContain(result.outputPath);
     
     // Verify repomix was called correctly
     expect(repomix.runCli).toHaveBeenCalledTimes(1);
@@ -88,9 +87,8 @@ describe('packWorkspace', () => {
 
     expect(result.totalFiles).toBe(0);
     expect(result.totalCharacters).toBe(0);
-    
-    const outputContent = await fs.readFile(result.outputPath, 'utf-8');
-    expect(outputContent).not.toContain('<repository'); // Should have no repositories
+    expect(result.outputPath).toBe('');
+    expect(result.outputPaths?.length).toBe(0);
   });
 
   it('should throw if workspace feature config is not found', async () => {

package/src/core/packer.ts

@@ -1,19 +1,19 @@
 import * as fs from 'node:fs/promises';
-import { createReadStream, createWriteStream } from 'node:fs';
-import { pipeline } from 'node:stream/promises';
 import * as path from 'node:path';
 import { runCli } from 'repomix';
 import { loadFeatureConfig } from './workspace.js';
+import { loadConfig } from './config.js';
 
 export interface PackResult {
   outputPath: string;
+  outputPaths?: string[];
   totalFiles: number;
   totalCharacters: number;
   fileSize: number;
 }
 
 /**
- * Packs all repositories in a workspace into a single, compressed XML file using Repomix.
+ * Packs all repositories in a workspace into individual XML files using Repomix.
  */
 export async function packWorkspace(
   workspacePath: string,
@@ -24,19 +24,14 @@ export async function packWorkspace(
     throw new Error(`Workspace not found at ${workspacePath}`);
   }
 
+  const config = await loadConfig();
+  const ignorePatterns = (config.excludePatterns || []).join(',');
   const compress = options.compress !== false; // default true
-  const outputPath = path.join(workspacePath, 'nexusflow-context.xml');
-  
-  // Use a write stream to avoid buffering huge workspaces in memory
-  const outStream = createWriteStream(outputPath, { encoding: 'utf-8' });
-  
-  outStream.write('<?xml version="1.0" encoding="UTF-8"?>\n');
-  outStream.write(`<workspace id="${feature.id}">\n`);
-  outStream.write(`  <description><![CDATA[${feature.description}]]></description>\n`);
-  outStream.write('  <repositories>\n');
-  
+
   let totalFilesCount = 0;
   let totalCharsCount = 0;
+  let totalFileSize = 0;
+  const outputPaths: string[] = [];
 
   for (const repoPath of feature.repos) {
     const repoName = path.basename(repoPath);
@@ -48,15 +43,37 @@ export async function packWorkspace(
       continue;
     }
 
-    const tempXmlPath = path.join(workspacePath, `temp-repomix-${repoName}.xml`);
+    const outputXmlPath = path.join(workspacePath, `nexusflow-context-${repoName}.xml`);
+    const instructionsPath = path.join(worktreePath, 'repomix-instruction.md');
+
+    // Generate dynamic repomix-instruction.md for this repo
+    const mapPath = path.join(workspacePath, `nexusflow-map-${repoName}.md`).replace(/\\/g, '/');
+    const planPath = path.join(workspacePath, `nexusflow-plan.md`).replace(/\\/g, '/');
+    
+    const instructionsContent = [
+      `# AI Assistant Instructions for ${repoName}`,
+      '',
+      `This XML file contains the packed codebase for the repository \`${repoName}\` in the workspace \`${feature.id}\`.`,
+      '',
+      `When working with this code, you MUST follow these guidelines:`,
+      `1. **Explore Locally**: Do not rely on this XML snapshot as the source of truth for edits. Always use your native search, grep, and view tools on the live files in: \`${worktreePath.replace(/\\/g, '/')}\`.`,
+      `2. **Read the Architecture Map**: Before implementing any changes, read the generated map file at: [nexusflow-map-${repoName}.md](file:///${mapPath}) to understand its layout, API endpoints, test commands, and detected usage patterns.`,
+      `3. **Follow the Implementation Order**: See the phased plan at: [nexusflow-plan.md](file:///${planPath}) to avoid cross-repo dependency build ordering issues.`,
+      `4. **Git Operations**: Run git commands (status, add, commit) strictly inside the repository subdirectories (e.g. \`cd ${repoName} && git commit -m "..."\`), NOT in the workspace root.`,
+      '',
+    ].join('\n');
 
     try {
-      // Run repomix programmatically inside the worktree directory
+      // Write instructions to repo worktree root so Repomix picks it up and appends it at the end
+      await fs.writeFile(instructionsPath, instructionsContent, 'utf-8');
+
+      // Run repomix programmatically
       const result = await runCli(['.'], worktreePath, {
         style: 'xml',
-        output: tempXmlPath,
+        output: outputXmlPath,
         compress,
         quiet: true,
+        ignore: ignorePatterns,
       });
 
       if (result && result.packResult) {
@@ -64,45 +81,27 @@ export async function packWorkspace(
         totalCharsCount += result.packResult.totalCharacters;
       }
 
-      outStream.write(`    <repository name="${repoName}">\n`);
-      
-      // Stream output XML directly to avoid memory limits
-      await pipeline(
-        createReadStream(tempXmlPath, { encoding: 'utf-8' }),
-        outStream,
-        { end: false }
-      );
-      
-      outStream.write('\n    </repository>\n');
+      const stats = await fs.stat(outputXmlPath);
+      totalFileSize += stats.size;
+      outputPaths.push(outputXmlPath);
+
     } catch (error: any) {
       console.error(`Error packing repository ${repoName}:`, error.message);
     } finally {
-      // Clean up temporary XML file
+      // Clean up the temporary instruction file from the repo's worktree
       try {
-        await fs.unlink(tempXmlPath);
+        await fs.unlink(instructionsPath);
       } catch {
         // ignore
       }
     }
   }
 
-  outStream.write('  </repositories>\n');
-  outStream.write('</workspace>\n');
-  outStream.end();
-
-  // Wait for stream to finish writing
-  await new Promise<void>((resolve, reject) => {
-    outStream.on('finish', resolve);
-    outStream.on('error', reject);
-  });
-
-  const stats = await fs.stat(outputPath);
-
   return {
-    outputPath,
+    outputPath: outputPaths[0] || '',
+    outputPaths,
     totalFiles: totalFilesCount,
     totalCharacters: totalCharsCount,
-    fileSize: stats.size,
+    fileSize: totalFileSize,
   };
 }
-

package/src/core/workspace.ts

@@ -15,6 +15,7 @@ import { detectDefaultBranch } from '../utils/git.js';
 import { analyzeAllRepos } from '../analyzers/index.js';
 import { generateContextFiles } from '../generators/index.js';
 import { packWorkspace } from './packer.js';
+import { loadConfig } from './config.js';
 
 /** Name of the per-workspace manifest file. */
 const MANIFEST_FILE = 'nexusflow.json';
@@ -191,17 +192,19 @@ export async function deleteWorkspace(
 ): 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);
+    const origRepos = feature.originalRepos || [];
+    for (let i = 0; i < feature.repos.length; i++) {
+      const worktreePath = feature.repos[i]!;
+      const originalPath = origRepos[i] || worktreePath;
+      const repoName = path.basename(worktreePath);
       try {
-        await removeWorktree(repoPath, worktreePath, true);
+        await removeWorktree(originalPath, worktreePath, true);
       } catch (error) {
-        console.warn(`Warning: failed to remove worktree for ${repoName} in ${repoPath}:`, error);
+        console.warn(`Warning: failed to remove worktree for ${repoName} in ${originalPath}:`, error);
         try {
-          await execa('git', ['worktree', 'prune'], { cwd: repoPath });
+          await execa('git', ['worktree', 'prune'], { cwd: originalPath });
         } catch (pruneError) {
-          console.warn(`Warning: failed to prune worktrees in ${repoPath}:`, pruneError);
+          console.warn(`Warning: failed to prune worktrees in ${originalPath}:`, pruneError);
         }
       }
     }
@@ -253,13 +256,13 @@ export async function addRepoToWorkspace(
     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);
 
+  if (feature.repos.includes(worktreeTarget)) {
+    throw new Error(`Repository ${repoPath} is already in the workspace`);
+  }
+
   // 1. Create the worktree
   await createWorktree(
     newRepoInfo.path,
@@ -269,7 +272,11 @@ export async function addRepoToWorkspace(
   );
 
   // 2. Update manifest
-  feature.repos.push(repoPath);
+  feature.repos.push(worktreeTarget);
+  if (!feature.originalRepos) {
+    feature.originalRepos = [];
+  }
+  feature.originalRepos.push(repoPath);
   await saveFeatureConfig(workspacePath, feature);
 
   // 3. Update .gitignore at workspace root
@@ -303,5 +310,8 @@ export async function addRepoToWorkspace(
   };
 
   await generateContextFiles(ctx, feature.assistants, workspacePath);
-  await packWorkspace(workspacePath);
+  const config = await loadConfig();
+  if (config.packContextXml) {
+    await packWorkspace(workspacePath);
+  }
 }

package/src/generators/base.ts

@@ -4,16 +4,21 @@
  * use as their foundation. Now includes rich project analysis data when available.
  */
 
+import * as path from 'node:path';
+import * as fs from 'node:fs';
 import type { WorkspaceContext, ProjectAnalysis } from '../types.js';
 
 /**
  * Formats a ProjectAnalysis into a readable markdown section.
  */
-function formatProjectSection(analysis: ProjectAnalysis): string {
+function formatProjectSection(analysis: ProjectAnalysis, workspacePath: string): string {
   const lines: string[] = [];
 
   lines.push(`### ${analysis.name}`);
 
+  const mapPath = path.join(workspacePath, `nexusflow-map-${analysis.name}.md`).replace(/\\/g, '/');
+  lines.push(`- **Architecture Map**: [nexusflow-map-${analysis.name}.md](file:///${mapPath}) — **Instruction**: You MUST read this architecture map before exploring or modifying the \`${analysis.name}\` repository to understand its layout, API endpoints, test commands, and detected usage patterns.`);
+
   // Tech stack
   const { techStack } = analysis;
   if (techStack.languages.length > 0 && techStack.languages[0] !== 'other') {
@@ -74,6 +79,7 @@ function formatProjectSection(analysis: ProjectAnalysis): string {
  */
 export function buildContextContent(ctx: WorkspaceContext): string {
   const { feature, repos, analysis } = ctx;
+  const workspacePath = feature.workspacePath;
 
   // Build project sections — rich if analysis is available, simple if not
   let projectSections: string;
@@ -81,7 +87,7 @@ export function buildContextContent(ctx: WorkspaceContext): string {
   if (analysis && analysis.size > 0) {
     const sections = repos.map((r) => {
       const a = analysis.get(r.path);
-      if (a) return formatProjectSection(a);
+      if (a) return formatProjectSection(a, workspacePath);
       return `### ${r.name}\n- **Path**: \`${r.path}\``;
     });
     projectSections = sections.join('\n\n');
@@ -117,11 +123,32 @@ ${allConfigs.join('\n')}
   // Resumption commands section
   let resumptionSection = '';
   if (feature.resumption) {
-    const { testCommand, mockCommand, startCommand } = feature.resumption;
+    let { testCommand, mockCommand, startCommand } = feature.resumption;
     const parts: string[] = [];
     if (mockCommand) parts.push(`- **Setup/Mock Command**: \`${mockCommand}\``);
     if (startCommand) parts.push(`- **Start/Run Command**: \`${startCommand}\``);
-    if (testCommand) parts.push(`- **Verification/Test Command**: \`${testCommand}\``);
+    
+    if (testCommand) {
+      if (testCommand === 'npm run test') {
+        const hasJs = repos.some(r => {
+          const a = analysis?.get(r.path);
+          return a?.techStack.languages.includes('typescript') || a?.techStack.languages.includes('javascript');
+        });
+        const hasCsharp = repos.some(r => {
+          const a = analysis?.get(r.path);
+          return a?.techStack.languages.includes('csharp');
+        });
+
+        if (hasCsharp && !hasJs) {
+          testCommand = 'dotnet test';
+        } else if (!hasJs && !hasCsharp) {
+          testCommand = undefined;
+        }
+      }
+      if (testCommand) {
+        parts.push(`- **Verification/Test Command**: \`${testCommand}\``);
+      }
+    }
 
     if (parts.length > 0) {
       resumptionSection = `
@@ -136,14 +163,47 @@ ${parts.join('\n')}
     }
   }
 
+  // Check if overview.md already exists
+  const overviewFile = path.join(workspacePath, 'nexusflow-overview.md');
+  const hasOverview = fs.existsSync(overviewFile);
+
+  let taskSection = '';
+  if (hasOverview) {
+    taskSection = `## Task & Step-by-Step Maintenance
+
+The universal reference file **\`nexusflow-overview.md\`** has already been created. Your task is to:
+
+1. **Keep it Updated**: Maintain and update \`nexusflow-overview.md\` with any new architectural findings, layout changes, or assumptions.
+2. **Review Assumptions**: Ensure that inter-repo relationships and package dependencies documented there reflect the current codebase.
+3. **Address Open Questions**: If there are outstanding items in the "Clarifying Questions for the User" section, discuss them with the user.
+`;
+  } else {
+    taskSection = `## 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:
+
+1. **Create \`nexusflow-overview.md\`** at the workspace root.
+2. **Project Assumptions**: For each project, write down a clear assumption of what it does, its primary tech stack, and its core responsibilities.
+3. **Inter-Repo Relationships**: Document how the repos relate:
+   - Shared libraries/packages (producers and consumers).
+   - API boundaries (which repos expose APIs, which ones consume them).
+   - Data flows and dependencies.
+4. **Clarifying Questions**: If any feature requirements, architectural patterns, or API contracts are unclear, list them explicitly under a section called **"Clarifying Questions for the User"**.
+5. **Universal Reference**: Keep this file updated. This acts as a universal reference so that any LLM assistant (Claude, Antigravity, Codex, Cursor, Copilot) joining this workspace instantly understands the project landscape.
+
+Once you have created \`nexusflow-overview.md\` and compiled your questions, ask the user to verify your assumptions and answer your questions before proceeding to write code.
+`;
+  }
+
+  const knowledgePath = path.join(workspacePath, 'nexusflow-knowledge.md').replace(/\\/g, '/');
+
   return `# Multi-Repo Workspace Context
 
 ## Feature: ${feature.id}
 
 **Description:** ${feature.description}
 
-**Branch:** \`${feature.branchName}\`
-**Created:** ${feature.createdAt}
+> For the detailed feature specification, architecture decisions, and session memory, see [nexusflow-knowledge.md](file:///${knowledgePath}).
 
 ---
 
@@ -157,30 +217,7 @@ ${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:
-
-1. **Create \`nexusflow-overview.md\`** at the workspace root.
-2. **Project Assumptions**: For each project, write down a clear assumption of what it does, its primary tech stack, and its core responsibilities.
-3. **Inter-Repo Relationships**: Document how the repos relate:
-   - Shared libraries/packages (producers and consumers).
-   - API boundaries (which repos expose APIs, which ones consume them).
-   - Data flows and dependencies.
-4. **Clarifying Questions**: If any feature requirements, architectural patterns, or API contracts are unclear, list them explicitly under a section called **"Clarifying Questions for the User"**.
-5. **Universal Reference**: Keep this file updated. This acts as a universal reference so that any LLM assistant (Claude, Antigravity, Codex, Cursor, Copilot) joining this workspace instantly understands the project landscape.
-
-Once you have created \`nexusflow-overview.md\` and compiled your questions, ask the user to verify your assumptions and answer your questions before proceeding to write code.
-
+${taskSection}
 ---
 
 ## Guidelines

package/src/generators/index.ts

@@ -139,6 +139,23 @@ export async function generateContextFiles(
     );
   }
 
+  // Generate per-repo architecture maps
+  if (ctx.analysis) {
+    for (const repo of ctx.repos) {
+      const a = ctx.analysis.get(repo.path);
+      if (a) {
+        try {
+          const { generateRepoMap } = await import('./map-generator.js');
+          await generateRepoMap(repo, a, workspacePath);
+          console.log(chalk.green('  ✔'), `Generated Architecture Map for ${chalk.bold(repo.name)}`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(chalk.red('  ✖'), `Failed to generate Architecture Map for ${repo.name}: ${message}`);
+        }
+      }
+    }
+  }
+
   for (const assistant of assistants) {
     const entry = GENERATORS[assistant];
 

package/src/generators/map-generator.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { generateRepoMap } from './map-generator.js';
+import type { Language, Framework, ProjectAnalysis } from '../types.js';
+import * as globby from 'globby';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+vi.mock('node:fs/promises');
+vi.mock('globby');
+
+describe('generateRepoMap', () => {
+  const workspacePath = path.join(__dirname, '..', '..', 'temp-test-workspace');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should generate a markdown map file with correct structure and links', async () => {
+    // 1. Mock inputs
+    const mockRepo = {
+      name: 'test-repo',
+      path: '/original/path/test-repo',
+      defaultBranch: 'main',
+    };
+
+    const mockAnalysis: ProjectAnalysis = {
+      name: 'test-repo',
+      path: '/original/path/test-repo',
+      techStack: {
+        languages: ['typescript' as Language],
+        frameworks: ['react' as Framework],
+        buildTools: ['vite'],
+        projectType: 'frontend' as const,
+      },
+      endpoints: [
+        { method: 'GET', path: '/api/v1/users', source: 'src/controllers/users.ts' }
+      ],
+      dependencies: [
+        { name: 'react', type: 'npm' as const }
+      ],
+      ports: [],
+      readmeSummary: 'A test repository.',
+      existingAIConfigs: [],
+    };
+
+    // Mock globby returns
+    vi.spyOn(globby, 'globby').mockImplementation(async (pattern: any) => {
+      const pat = typeof pattern === 'string' ? pattern : (pattern[0] || '');
+      if (pat.includes('**/*.sln')) return [];
+      if (pat.includes('**/*.csproj')) return [];
+      if (pat.includes('package.json')) return ['package.json'];
+      if (pat.includes('SKILL.md')) return ['skills/my-skill/SKILL.md'];
+      return [];
+    });
+
+    const writtenFiles: Record<string, string> = {};
+    vi.spyOn(fs, 'writeFile').mockImplementation(async (filePath: any, content: any) => {
+      writtenFiles[filePath as string] = content as string;
+      return Promise.resolve();
+    });
+
+    // 2. Run generator
+    await generateRepoMap(mockRepo, mockAnalysis, workspacePath);
+
+    // 3. Assertions
+    const expectedOutPath = path.join(workspacePath, 'nexusflow-map-test-repo.md');
+    expect(fs.writeFile).toHaveBeenCalledTimes(1);
+    expect(writtenFiles[expectedOutPath]).toBeDefined();
+
+    const content = writtenFiles[expectedOutPath]!;
+    expect(content).toContain('# Repository Architecture Map — test-repo');
+    expect(content).toContain('package.json');
+    expect(content).toContain('my-skill');
+    expect(content).toContain('GET');
+    expect(content).toContain('/api/v1/users');
+  });
+});