@mrpatronz/nexusflow 0.2.13 → 0.2.17

package/src/core/packer.test.ts

@@ -1,99 +1,99 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { packWorkspace } from './packer.js';
-import * as workspace from './workspace.js';
-import * as repomix from 'repomix';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Mock dependencies
-vi.mock('./workspace.js');
-vi.mock('repomix');
-
-describe('packWorkspace', () => {
-  const workspacePath = path.join(__dirname, '..', '..', 'temp-test-workspace');
-
-  beforeEach(async () => {
-    await fs.mkdir(workspacePath, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(workspacePath, { recursive: true, force: true });
-    vi.clearAllMocks();
-  });
-
-  it('should successfully pack a workspace and stream repomix output', async () => {
-    // 1. Mock the workspace config
-    const mockFeature = {
-      id: 'test-feature',
-      description: 'Test description',
-      repos: [path.join(workspacePath, 'repo-a')]
-    };
-    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature as any);
-
-    // Create fake repo directory so fs.access passes
-    await fs.mkdir(path.join(workspacePath, 'repo-a'), { recursive: true });
-
-    // 2. Mock repomix runCli
-    vi.spyOn(repomix, 'runCli').mockImplementation(async (dirs, cwd, options) => {
-      // Create the expected output file to simulate repomix success
-      if (options && options.output) {
-        await fs.writeFile(options.output as string, '<file path="test.txt">mock repomix content</file>\n', 'utf-8');
-      }
-      return {
-        packResult: {
-          totalFiles: 42,
-          totalCharacters: 9001,
-          totalTokens: 100,
-          fileCharCounts: {},
-          fileTokenCounts: {}
-        },
-        suspiciousFilesResults: [],
-        config: {} as any
-      } as any;
-    });
-
-    // 3. Run the packer
-    const result = await packWorkspace(workspacePath);
-
-    // 4. Assertions
-    expect(result.totalFiles).toBe(42);
-    expect(result.totalCharacters).toBe(9001);
-    expect(result.fileSize).toBeGreaterThan(0);
-    
-    // Read the generated output file and verify
-    const outputContent = await fs.readFile(result.outputPath, 'utf-8');
-    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);
-  });
-
-  it('should skip repos that do not exist', async () => {
-    const mockFeature = {
-      id: 'test-feature',
-      description: 'Test description',
-      repos: [path.join(workspacePath, 'non-existent-repo')]
-    };
-    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature as any);
-    
-    // We intentionally don't create the directory 'non-existent-repo'
-
-    const result = await packWorkspace(workspacePath);
-
-    expect(result.totalFiles).toBe(0);
-    expect(result.totalCharacters).toBe(0);
-    expect(result.outputPath).toBe('');
-    expect(result.outputPaths?.length).toBe(0);
-  });
-
-  it('should throw if workspace feature config is not found', async () => {
-    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(null);
-
-    await expect(packWorkspace(workspacePath)).rejects.toThrow(/Workspace not found/);
-  });
-});
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { packWorkspace } from './packer.js';
+import * as workspace from './workspace.js';
+import * as repomix from 'repomix';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Mock dependencies
+vi.mock('./workspace.js');
+vi.mock('repomix');
+
+describe('packWorkspace', () => {
+  const workspacePath = path.join(__dirname, '..', '..', 'temp-test-workspace');
+
+  beforeEach(async () => {
+    await fs.mkdir(workspacePath, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(workspacePath, { recursive: true, force: true });
+    vi.clearAllMocks();
+  });
+
+  it('should successfully pack a workspace and stream repomix output', async () => {
+    // 1. Mock the workspace config
+    const mockFeature = {
+      id: 'test-feature',
+      description: 'Test description',
+      repos: [path.join(workspacePath, 'repo-a')]
+    };
+    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature as any);
+
+    // Create fake repo directory so fs.access passes
+    await fs.mkdir(path.join(workspacePath, 'repo-a'), { recursive: true });
+
+    // 2. Mock repomix runCli
+    vi.spyOn(repomix, 'runCli').mockImplementation(async (dirs, cwd, options) => {
+      // Create the expected output file to simulate repomix success
+      if (options && options.output) {
+        await fs.writeFile(options.output as string, '<file path="test.txt">mock repomix content</file>\n', 'utf-8');
+      }
+      return {
+        packResult: {
+          totalFiles: 42,
+          totalCharacters: 9001,
+          totalTokens: 100,
+          fileCharCounts: {},
+          fileTokenCounts: {}
+        },
+        suspiciousFilesResults: [],
+        config: {} as any
+      } as any;
+    });
+
+    // 3. Run the packer
+    const result = await packWorkspace(workspacePath);
+
+    // 4. Assertions
+    expect(result.totalFiles).toBe(42);
+    expect(result.totalCharacters).toBe(9001);
+    expect(result.fileSize).toBeGreaterThan(0);
+    
+    // Read the generated output file and verify
+    const outputContent = await fs.readFile(result.outputPath, 'utf-8');
+    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);
+  });
+
+  it('should skip repos that do not exist', async () => {
+    const mockFeature = {
+      id: 'test-feature',
+      description: 'Test description',
+      repos: [path.join(workspacePath, 'non-existent-repo')]
+    };
+    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(mockFeature as any);
+    
+    // We intentionally don't create the directory 'non-existent-repo'
+
+    const result = await packWorkspace(workspacePath);
+
+    expect(result.totalFiles).toBe(0);
+    expect(result.totalCharacters).toBe(0);
+    expect(result.outputPath).toBe('');
+    expect(result.outputPaths?.length).toBe(0);
+  });
+
+  it('should throw if workspace feature config is not found', async () => {
+    vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue(null);
+
+    await expect(packWorkspace(workspacePath)).rejects.toThrow(/Workspace not found/);
+  });
+});

package/src/core/packer.ts

@@ -1,107 +1,107 @@
-import * as fs from 'node:fs/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 individual XML files using Repomix.
- */
-export async function packWorkspace(
-  workspacePath: string,
-  options: { compress?: boolean } = {}
-): Promise<PackResult> {
-  const feature = await loadFeatureConfig(workspacePath);
-  if (!feature) {
-    throw new Error(`Workspace not found at ${workspacePath}`);
-  }
-
-  const config = await loadConfig();
-  const ignorePatterns = (config.excludePatterns || []).join(',');
-  const compress = options.compress !== false; // default true
-
-  let totalFilesCount = 0;
-  let totalCharsCount = 0;
-  let totalFileSize = 0;
-  const outputPaths: string[] = [];
-
-  for (const repoPath of feature.repos) {
-    const repoName = path.basename(repoPath);
-    const worktreePath = path.join(workspacePath, repoName);
-
-    try {
-      await fs.access(worktreePath);
-    } catch {
-      continue;
-    }
-
-    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 {
-      // 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: outputXmlPath,
-        compress,
-        quiet: true,
-        ignore: ignorePatterns,
-      });
-
-      if (result && result.packResult) {
-        totalFilesCount += result.packResult.totalFiles;
-        totalCharsCount += result.packResult.totalCharacters;
-      }
-
-      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 the temporary instruction file from the repo's worktree
-      try {
-        await fs.unlink(instructionsPath);
-      } catch {
-        // ignore
-      }
-    }
-  }
-
-  return {
-    outputPath: outputPaths[0] || '',
-    outputPaths,
-    totalFiles: totalFilesCount,
-    totalCharacters: totalCharsCount,
-    fileSize: totalFileSize,
-  };
-}
+import * as fs from 'node:fs/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 individual XML files using Repomix.
+ */
+export async function packWorkspace(
+  workspacePath: string,
+  options: { compress?: boolean } = {}
+): Promise<PackResult> {
+  const feature = await loadFeatureConfig(workspacePath);
+  if (!feature) {
+    throw new Error(`Workspace not found at ${workspacePath}`);
+  }
+
+  const config = await loadConfig();
+  const ignorePatterns = (config.excludePatterns || []).join(',');
+  const compress = options.compress !== false; // default true
+
+  let totalFilesCount = 0;
+  let totalCharsCount = 0;
+  let totalFileSize = 0;
+  const outputPaths: string[] = [];
+
+  for (const repoPath of feature.repos) {
+    const repoName = path.basename(repoPath);
+    const worktreePath = path.join(workspacePath, repoName);
+
+    try {
+      await fs.access(worktreePath);
+    } catch {
+      continue;
+    }
+
+    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 {
+      // 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: outputXmlPath,
+        compress,
+        quiet: true,
+        ignore: ignorePatterns,
+      });
+
+      if (result && result.packResult) {
+        totalFilesCount += result.packResult.totalFiles;
+        totalCharsCount += result.packResult.totalCharacters;
+      }
+
+      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 the temporary instruction file from the repo's worktree
+      try {
+        await fs.unlink(instructionsPath);
+      } catch {
+        // ignore
+      }
+    }
+  }
+
+  return {
+    outputPath: outputPaths[0] || '',
+    outputPaths,
+    totalFiles: totalFilesCount,
+    totalCharacters: totalCharsCount,
+    fileSize: totalFileSize,
+  };
+}

package/src/core/scanner.test.ts

@@ -1,61 +1,61 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { scanForRepos } from './scanner.js';
-import * as gitUtils from '../utils/git.js';
-
-vi.mock('node:fs/promises');
-vi.mock('../utils/git.js');
-
-describe('scanner core module', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should return repository info if the root dir is a git repo', async () => {
-    vi.mocked(gitUtils.isGitRepo).mockResolvedValue(true);
-    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
-
-    const result = await scanForRepos('/mock/dev', 2);
-
-    expect(result).toEqual([
-      { name: 'dev', path: '/mock/dev', defaultBranch: 'main' }
-    ]);
-    expect(gitUtils.isGitRepo).toHaveBeenCalledWith('/mock/dev');
-  });
-
-  it('should recursively scan subdirectories up to limit and return repos found', async () => {
-    // Root is not a git repo
-    vi.mocked(gitUtils.isGitRepo).mockImplementation(async (dir) => {
-      const normalized = dir.replace(/\\/g, '/');
-      return normalized === '/mock/dev/repo1' || normalized === '/mock/dev/sub/repo2';
-    });
-    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
-
-    // Root directory entries
-    vi.mocked(fs.readdir).mockImplementation(async (dir: any) => {
-      const normalized = dir.replace(/\\/g, '/');
-      if (normalized === '/mock/dev') {
-        return [
-          { name: 'repo1', isDirectory: () => true },
-          { name: 'sub', isDirectory: () => true },
-          { name: 'ignored_file.txt', isDirectory: () => false },
-          { name: 'node_modules', isDirectory: () => true },
-        ] as any[];
-      }
-      if (normalized === '/mock/dev/sub') {
-        return [
-          { name: 'repo2', isDirectory: () => true },
-        ] as any[];
-      }
-      return [];
-    });
-
-    const result = await scanForRepos('/mock/dev', 2);
-
-    expect(result).toEqual([
-      { name: 'repo1', path: path.join('/mock/dev', 'repo1'), defaultBranch: 'main' },
-      { name: 'repo2', path: path.join('/mock/dev', 'sub', 'repo2'), defaultBranch: 'main' }
-    ]);
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { scanForRepos } from './scanner.js';
+import * as gitUtils from '../utils/git.js';
+
+vi.mock('node:fs/promises');
+vi.mock('../utils/git.js');
+
+describe('scanner core module', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return repository info if the root dir is a git repo', async () => {
+    vi.mocked(gitUtils.isGitRepo).mockResolvedValue(true);
+    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
+
+    const result = await scanForRepos('/mock/dev', 2);
+
+    expect(result).toEqual([
+      { name: 'dev', path: '/mock/dev', defaultBranch: 'main' }
+    ]);
+    expect(gitUtils.isGitRepo).toHaveBeenCalledWith('/mock/dev');
+  });
+
+  it('should recursively scan subdirectories up to limit and return repos found', async () => {
+    // Root is not a git repo
+    vi.mocked(gitUtils.isGitRepo).mockImplementation(async (dir) => {
+      const normalized = dir.replace(/\\/g, '/');
+      return normalized === '/mock/dev/repo1' || normalized === '/mock/dev/sub/repo2';
+    });
+    vi.mocked(gitUtils.detectDefaultBranch).mockResolvedValue('main');
+
+    // Root directory entries
+    vi.mocked(fs.readdir).mockImplementation(async (dir: any) => {
+      const normalized = dir.replace(/\\/g, '/');
+      if (normalized === '/mock/dev') {
+        return [
+          { name: 'repo1', isDirectory: () => true },
+          { name: 'sub', isDirectory: () => true },
+          { name: 'ignored_file.txt', isDirectory: () => false },
+          { name: 'node_modules', isDirectory: () => true },
+        ] as any[];
+      }
+      if (normalized === '/mock/dev/sub') {
+        return [
+          { name: 'repo2', isDirectory: () => true },
+        ] as any[];
+      }
+      return [];
+    });
+
+    const result = await scanForRepos('/mock/dev', 2);
+
+    expect(result).toEqual([
+      { name: 'repo1', path: path.join('/mock/dev', 'repo1'), defaultBranch: 'main' },
+      { name: 'repo2', path: path.join('/mock/dev', 'sub', 'repo2'), defaultBranch: 'main' }
+    ]);
+  });
+});