@mrpatronz/nexusflow 0.2.13 → 0.2.17

package/src/utils/workflows.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getWorkflowTemplates, saveWorkflowTemplate, deleteWorkflowTemplate } from './workflows.js';
+
+vi.mock('node:fs/promises');
+vi.mock('node:os', () => ({
+  homedir: () => '/mock/home'
+}));
+
+describe('Workflows Utility Unit Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('saveWorkflowTemplate', () => {
+    it('should save a template and extract its name from H1 header', async () => {
+      vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+
+      const result = await saveWorkflowTemplate('My Temp Name', '# Final Strategy Name\n\nStrategy Content');
+
+      expect(fs.mkdir).toHaveBeenCalledWith(path.join('/mock/home', '.nexusflow', 'workflows'), { recursive: true });
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join('/mock/home', '.nexusflow', 'workflows', 'final-strategy-name.md'),
+        '# Final Strategy Name\n\nStrategy Content',
+        'utf-8'
+      );
+      expect(result).toEqual({
+        id: 'final-strategy-name',
+        name: 'Final Strategy Name',
+        description: 'Strategy Content',
+        content: '# Final Strategy Name\n\nStrategy Content',
+        custom: true
+      });
+    });
+
+    it('should add H1 header if not present', async () => {
+      vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+
+      const result = await saveWorkflowTemplate('My Temp Name', 'Strategy Content');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        path.join('/mock/home', '.nexusflow', 'workflows', 'my-temp-name.md'),
+        '# My Temp Name\n\nStrategy Content',
+        'utf-8'
+      );
+      expect(result.id).toBe('my-temp-name');
+    });
+
+    it('should clean up originalId file if template is renamed', async () => {
+      vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+      vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+
+      const result = await saveWorkflowTemplate('New Name', '# New Name\n\nContent', 'old-id');
+
+      expect(fs.unlink).toHaveBeenCalledWith(path.join('/mock/home', '.nexusflow', 'workflows', 'old-id.md'));
+      expect(result.id).toBe('new-name');
+    });
+  });
+
+  describe('deleteWorkflowTemplate', () => {
+    it('should delete template file', async () => {
+      vi.spyOn(fs, 'unlink').mockResolvedValue(undefined);
+
+      await deleteWorkflowTemplate('some-id');
+
+      expect(fs.unlink).toHaveBeenCalledWith(path.join('/mock/home', '.nexusflow', 'workflows', 'some-id.md'));
+    });
+
+    it('should ignore ENOENT error', async () => {
+      const error = new Error('File not found') as any;
+      error.code = 'ENOENT';
+      vi.spyOn(fs, 'unlink').mockRejectedValue(error);
+
+      await expect(deleteWorkflowTemplate('some-id')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('getWorkflowTemplates', () => {
+    it('should load and merge built-in and user templates', async () => {
+      vi.spyOn(fs, 'mkdir').mockResolvedValue(undefined);
+      // Mock readdir to return files
+      vi.spyOn(fs, 'readdir').mockImplementation(async (dirPath) => {
+        if (dirPath.toString().includes('.nexusflow')) {
+          return ['custom-one.md'] as any;
+        }
+        return ['solo-developer.md'] as any;
+      });
+
+      // Mock readFile
+      vi.spyOn(fs, 'readFile').mockImplementation(async (filePath) => {
+        if (filePath.toString().includes('custom-one.md')) {
+          return '# Custom One\n\nDescription content.' as any;
+        }
+        return '# Solo Developer\n\nOverride content.' as any;
+      });
+
+      const templates = await getWorkflowTemplates();
+
+      expect(templates.length).toBe(2);
+      expect(templates.find(t => t.id === 'custom-one')).toEqual({
+        id: 'custom-one',
+        name: 'Custom One',
+        description: 'Description content.',
+        content: '# Custom One\n\nDescription content.',
+        custom: true
+      });
+    });
+  });
+});

package/src/utils/workflows.ts

@@ -0,0 +1,178 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export interface WorkflowTemplate {
+  id: string;
+  name: string;
+  description: string;
+  content: string;
+  custom: boolean;
+}
+
+function parseMarkdownTemplate(id: string, content: string): Omit<WorkflowTemplate, 'id' | 'custom'> {
+  const lines = content.split('\n');
+  let name = id.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
+  let description = '';
+
+  // Extract name from the first H1 header (# Name)
+  for (const line of lines) {
+    if (line.startsWith('# ')) {
+      name = line.substring(2).trim();
+      break;
+    }
+  }
+
+  // Extract description from the first non-empty text paragraph below the H1 header
+  let foundHeader = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('# ')) {
+      foundHeader = true;
+      continue;
+    }
+    if (foundHeader && trimmed.length > 0 && !trimmed.startsWith('#') && !trimmed.startsWith('>')) {
+      description = trimmed;
+      // Truncate to first sentence or 120 chars
+      const sentenceEnd = description.indexOf('.');
+      if (sentenceEnd !== -1) {
+        description = description.substring(0, sentenceEnd + 1);
+      }
+      if (description.length > 120) {
+        description = description.substring(0, 117) + '...';
+      }
+      break;
+    }
+  }
+
+  // Fallbacks for built-in templates if none extracted
+  if (!description) {
+    if (id === 'plan-implement-review') {
+      description = 'Lead planner designs, Code Implementer subagent writes edits, and Code Reviewer subagent tests & reviews in a loop.';
+    } else if (id === 'research-verify') {
+      description = 'Research specialist subagent analyzes codebase, followed by test-driven developer subagent implementation.';
+    } else if (id === 'solo-developer') {
+      description = 'Direct coding and verification by the primary agent without subagent delegation overhead.';
+    } else {
+      description = 'Custom user-defined teamwork strategy.';
+    }
+  }
+
+  return { name, description, content };
+}
+
+async function loadTemplatesFromDir(dirPath: string, custom: boolean): Promise<WorkflowTemplate[]> {
+  const templates: WorkflowTemplate[] = [];
+  try {
+    const files = await fs.readdir(dirPath);
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue;
+      const id = path.basename(file, '.md');
+      const content = await fs.readFile(path.join(dirPath, file), 'utf-8');
+      const parsed = parseMarkdownTemplate(id, content);
+      templates.push({
+        id,
+        custom,
+        ...parsed,
+      });
+    }
+  } catch (error) {
+    // Only log if directory exists (ignoring non-existent custom folder log spam)
+    if ((error as any).code !== 'ENOENT') {
+      console.error(`Failed to read templates from ${dirPath}:`, error);
+    }
+  }
+  return templates;
+}
+
+export async function getWorkflowTemplates(): Promise<WorkflowTemplate[]> {
+  const builtInDir = path.resolve(__dirname, '../resources/workflows');
+  const userDir = path.join(os.homedir(), '.nexusflow', 'workflows');
+
+  // Ensure user custom workflows directory exists so they can find it easily
+  try {
+    await fs.mkdir(userDir, { recursive: true });
+  } catch {}
+
+  const [builtInTemplates, userTemplates] = await Promise.all([
+    loadTemplatesFromDir(builtInDir, false),
+    loadTemplatesFromDir(userDir, true)
+  ]);
+
+  // Merge templates (user custom templates override built-in if they share the same ID)
+  const templateMap = new Map<string, WorkflowTemplate>();
+  
+  for (const t of builtInTemplates) {
+    templateMap.set(t.id, t);
+  }
+  for (const t of userTemplates) {
+    templateMap.set(t.id, t);
+  }
+
+  return Array.from(templateMap.values());
+}
+
+export async function saveWorkflowTemplate(name: string, content: string, originalId?: string): Promise<WorkflowTemplate> {
+  const userDir = path.join(os.homedir(), '.nexusflow', 'workflows');
+  await fs.mkdir(userDir, { recursive: true });
+
+  // Extract name from the first H1 header (# Name) in content if present
+  let parsedName = name;
+  const lines = content.split('\n');
+  for (const line of lines) {
+    if (line.trim().startsWith('# ')) {
+      parsedName = line.trim().substring(2).trim();
+      break;
+    }
+  }
+
+  const id = parsedName
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '');
+
+  if (!id) {
+    throw new Error('Invalid template name');
+  }
+
+  // Ensure content starts with "# <Name>" header so it parses correctly next time
+  let fileContent = content.trim();
+  if (!fileContent.startsWith('# ')) {
+    fileContent = `# ${parsedName}\n\n${fileContent}`;
+  }
+
+  const filePath = path.join(userDir, `${id}.md`);
+  await fs.writeFile(filePath, fileContent, 'utf-8');
+
+  // If we are editing an existing custom template and the ID changed, delete the old file
+  if (originalId && originalId !== id) {
+    const oldPath = path.join(userDir, `${originalId}.md`);
+    try {
+      await fs.unlink(oldPath);
+    } catch {}
+  }
+
+  const parsed = parseMarkdownTemplate(id, fileContent);
+  return {
+    id,
+    custom: true,
+    ...parsed,
+  };
+}
+
+export async function deleteWorkflowTemplate(id: string): Promise<void> {
+  const userDir = path.join(os.homedir(), '.nexusflow', 'workflows');
+  const filePath = path.join(userDir, `${id}.md`);
+  
+  try {
+    await fs.unlink(filePath);
+  } catch (error) {
+    if ((error as any).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+}

package/tsconfig.json

@@ -1,19 +1,19 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -1,14 +1,14 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    exclude: [
-      '**/node_modules/**',
-      '**/dist/**',
-      '**/cypress/**',
-      '**/.{idea,git,cache,output,temp}/**',
-      '**/scratch/**',
-      '**/gui/**'
-    ]
-  }
-});
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    exclude: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/cypress/**',
+      '**/.{idea,git,cache,output,temp}/**',
+      '**/scratch/**',
+      '**/gui/**'
+    ]
+  }
+});