@auto-engineer/server-implementer 0.8.12 → 0.8.14

package/package.json

@@ -17,8 +17,8 @@
     "debug": "^4.3.4",
     "fast-glob": "^3.3.3",
     "vite": "^5.4.1",
-    "@auto-engineer/message-bus": "0.8.12",
-    "@auto-engineer/ai-gateway": "0.8.12"
+    "@auto-engineer/ai-gateway": "0.8.14",
+    "@auto-engineer/message-bus": "0.8.14"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -28,9 +28,9 @@
     "glob": "^11.0.3",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3",
-    "@auto-engineer/cli": "0.8.12"
+    "@auto-engineer/cli": "0.8.14"
   },
-  "version": "0.8.12",
+  "version": "0.8.14",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/agent/runAllSlices.js

@@ -0,0 +1,11 @@
+import fg from 'fast-glob';
+import { runSlice } from './runSlice';
+import path from 'path';
+export async function runAllSlices(flowDir) {
+  const flowName = path.basename(flowDir);
+  const sliceDirs = await fg(`${flowDir}/**/*/`, { onlyDirectories: true });
+  for (const sliceDir of sliceDirs) {
+    await runSlice(sliceDir, flowName);
+  }
+  console.log('✅ All slices processed');
+}

package/src/agent/runFlows.js

@@ -0,0 +1,37 @@
+import fg from 'fast-glob';
+import path from 'path';
+import { runAllSlices } from './runAllSlices';
+import createDebug from 'debug';
+const debug = createDebug('server-impl:flows');
+const debugFlow = createDebug('server-impl:flows:flow');
+export async function runFlows(baseDir) {
+  debug('Running flows from base directory: %s', baseDir);
+  const flowDirs = await fg('*', {
+    cwd: baseDir,
+    onlyDirectories: true,
+    absolute: true,
+  });
+  debug('Found %d flow directories', flowDirs.length);
+  if (flowDirs.length > 0) {
+    debug(
+      'Flow directories: %o',
+      flowDirs.map((d) => path.basename(d)),
+    );
+  }
+  console.log(`🚀 Found ${flowDirs.length} flows`);
+  for (const flowDir of flowDirs) {
+    const flowName = path.basename(flowDir);
+    debugFlow('Processing flow: %s', flowName);
+    debugFlow('  Path: %s', flowDir);
+    console.log(`📂 Processing flow: ${flowName}`);
+    try {
+      await runAllSlices(flowDir);
+      debugFlow('Flow %s completed successfully', flowName);
+    } catch (error) {
+      debugFlow('ERROR: Flow %s failed: %O', flowName, error);
+      throw error;
+    }
+  }
+  debug('All %d flows processed successfully', flowDirs.length);
+  console.log('✅ All flows processed');
+}

package/src/agent/runSlice.js

@@ -0,0 +1,320 @@
+import path from 'path';
+import fg from 'fast-glob';
+import { generateTextWithAI } from '@auto-engineer/ai-gateway';
+import { readFile, writeFile, access } from 'fs/promises';
+import { execa } from 'execa';
+import { SYSTEM_PROMPT } from '../prompts/systemPrompt';
+import { extractCodeBlock } from '../utils/extractCodeBlock';
+import { runTests } from './runTests';
+export async function runSlice(sliceDir, flow) {
+  const sliceName = path.basename(sliceDir);
+  console.log(`✏️ Implementing slice: ${sliceName} for flow: ${flow}`);
+  const contextFiles = await loadContextFiles(sliceDir);
+  const filesToImplement = findFilesToImplement(contextFiles);
+  for (const [targetFile] of filesToImplement) {
+    await implementFileFromAI(sliceDir, targetFile, contextFiles);
+  }
+  const result = await runTestsAndTypecheck(sliceDir);
+  reportTestAndTypecheckResults(sliceDir, flow, result);
+  if (result.success) {
+    console.log(`✅ All tests and checks passed on first attempt.`);
+    return;
+  }
+  await retryFailedFiles(sliceDir, flow, result);
+  if (result.failedTestFiles.length > 0) {
+    await retryFailedTests(sliceDir, flow, result);
+  }
+}
+async function retryFailedFiles(sliceDir, flow, initialResult) {
+  let contextFiles = await loadContextFiles(sliceDir);
+  let result = initialResult;
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    if (result.failedTypecheckFiles.length === 0) {
+      console.log(`✅ Typecheck issues resolved after attempt ${attempt - 1}`);
+      break;
+    }
+    console.log(`🔁 Typecheck retry attempt ${attempt} for ${result.failedTypecheckFiles.length} files...`);
+    contextFiles = await loadContextFiles(sliceDir);
+    for (const filePath of result.failedTypecheckFiles) {
+      const fileName = path.basename(filePath);
+      const retryPrompt = buildRetryPrompt(fileName, contextFiles, result.testErrors, result.typecheckErrors);
+      console.log(`🔧 Retrying typecheck error in ${fileName} in flow ${flow}...`);
+      const aiOutput = await generateTextWithAI(retryPrompt);
+      const cleanedCode = extractCodeBlock(aiOutput);
+      await writeFile(path.join(sliceDir, fileName), cleanedCode, 'utf-8');
+      console.log(`♻️ Updated ${fileName} to fix typecheck errors`);
+    }
+    result = await runTestsAndTypecheck(sliceDir);
+    reportTestAndTypecheckResults(sliceDir, flow, result);
+  }
+  if (result.failedTypecheckFiles.length > 0) {
+    console.log(`⚠️ Fixing tests caused typecheck errors. Retrying typecheck fixes...`);
+    const typecheckOnlyResult = {
+      ...result,
+      testErrors: '', // Clear test errors since we're only fixing typecheck
+      failedTestFiles: [], // Clear failed test files
+    };
+    result = await retryFailedFiles(sliceDir, path.basename(sliceDir), typecheckOnlyResult);
+    // After fixing typecheck, re-run everything to get fresh results
+    const freshResult = await runTestsAndTypecheck(sliceDir);
+    reportTestAndTypecheckResults(sliceDir, flow, freshResult);
+    result = freshResult;
+    if (result.failedTestFiles.length === 0) {
+      console.log(`✅ All test issues resolved after fixing type errors.`);
+    }
+  }
+  return result;
+}
+async function loadContextFiles(sliceDir) {
+  const files = await fg(['*.ts'], { cwd: sliceDir });
+  const context = {};
+  for (const file of files) {
+    const absPath = path.join(sliceDir, file);
+    context[file] = await readFile(absPath, 'utf-8');
+  }
+  return context;
+}
+function findFilesToImplement(contextFiles) {
+  return Object.entries(contextFiles).filter(
+    ([, content]) => content.includes('TODO:') || content.includes('IMPLEMENTATION INSTRUCTIONS'),
+  );
+}
+function buildInitialPrompt(targetFile, context) {
+  return `
+${SYSTEM_PROMPT}
+
+---
+📄 Target file to implement: ${targetFile}
+
+${context[targetFile]}
+
+---
+🧠 Other files in the same slice:
+${Object.entries(context)
+  .filter(([name]) => name !== targetFile)
+  .map(([name, content]) => `// File: ${name}\n${content}`)
+  .join('\n\n')}
+
+---
+Return only the whole updated file of ${targetFile}. Do not remove existing imports or types that are still referenced or required in the file. The file returned has to be production ready.
+`.trim();
+}
+function buildRetryPrompt(targetFile, context, testErrors, typeErrors) {
+  return `
+${SYSTEM_PROMPT}
+
+---
+The previous implementation of ${targetFile} caused test or type-check failures.
+
+📄 File to fix: ${targetFile}
+
+${context[targetFile]}
+
+🧠 Other files in the same slice:
+${Object.entries(context)
+  .filter(([name]) => name !== targetFile)
+  .map(([name, content]) => `// File: ${name}\n${content}`)
+  .join('\n\n')}
+
+🧪 Test errors:
+${testErrors || 'None'}
+
+📐 Typecheck errors:
+${typeErrors || 'None'}
+
+---
+Return only the corrected full contents of ${targetFile}, no commentary, no markdown.
+`.trim();
+}
+async function implementFileFromAI(sliceDir, targetFile, contextFiles) {
+  const filePath = path.join(sliceDir, targetFile);
+  const prompt = buildInitialPrompt(targetFile, contextFiles);
+  console.log(`🔮 Analysing and Implementing ${targetFile}`);
+  const aiOutput = await generateTextWithAI(prompt);
+  //console.log('AI output:', aiOutput);
+  const cleanedCode = extractCodeBlock(aiOutput);
+  await writeFile(filePath, cleanedCode, 'utf-8');
+  console.log(`♻ Implemented ${targetFile}`);
+}
+export async function runTestsAndTypecheck(sliceDir) {
+  const rootDir = await findProjectRoot(sliceDir);
+  const testResult = await runTests(sliceDir, rootDir);
+  const typecheckResult = await runTypecheck(sliceDir, rootDir);
+  return {
+    success: testResult.success && typecheckResult.success,
+    failedTestFiles: testResult.failedTestFiles,
+    failedTypecheckFiles: typecheckResult.failedTypecheckFiles,
+    testErrors: testResult.testErrors,
+    typecheckErrors: typecheckResult.typecheckErrors,
+  };
+}
+async function retryFailedTests(sliceDir, flow, result) {
+  let contextFiles = await loadContextFiles(sliceDir);
+  for (let attempt = 1; attempt <= 5; attempt++) {
+    if (result.failedTestFiles.length === 0) {
+      console.log(`✅ Test failures resolved after attempt ${attempt - 1}`);
+      break;
+    }
+    console.log(`🔁 Test retry attempt ${attempt} for ${result.failedTestFiles.length} files...`);
+    const smartPrompt = `
+${SYSTEM_PROMPT}
+---
+🧪 The current implementation has test failures.
+
+📄 Test errors:
+${result.testErrors || 'None'}
+
+🧠 Full slice context:
+${Object.entries(contextFiles)
+  .map(([name, content]) => `// File: ${name}\n${content}`)
+  .join('\n\n')}
+
+---
+Please return the full corrected content of a single file (not a test file) that should be updated to fix the failing tests.
+
+Use this format:
+\`\`\`ts
+// File: <fileName>.ts
+<corrected code>
+\`\`\`
+
+No commentary or markdown outside the code block.
+`.trim();
+    console.log('🔮 Asking AI to suggest a fix for test failures...');
+    const aiOutput = await generateTextWithAI(smartPrompt);
+    const cleaned = extractCodeBlock(aiOutput);
+    const match = cleaned.match(/^\/\/ File: (.+?)\n([\s\S]*)/m);
+    if (!match) {
+      console.warn(`⚠️ Skipping retry. AI output didn't match expected format.`);
+      break;
+    }
+    const [, fileName, code] = match;
+    const absPath = path.join(sliceDir, fileName.trim());
+    console.log('🔧 Applying AI fix to:', absPath);
+    await writeFile(absPath, code.trim(), 'utf-8');
+    console.log(`♻️ Updated ${fileName.trim()} to fix tests`);
+    contextFiles = await loadContextFiles(sliceDir);
+    result = await runTestsAndTypecheck(sliceDir);
+    reportTestAndTypecheckResults(sliceDir, flow, result);
+    // If test fix introduced a new type error, handle it before continuing
+    if (result.failedTypecheckFiles.length > 0) {
+      console.log(`⚠️ Fixing tests caused typecheck errors. Retrying typecheck fixes...`);
+      result = await retryFailedFiles(sliceDir, flow, result);
+      if (result.failedTestFiles.length === 0) {
+        console.log(`✅ All test issues resolved after fixing type errors.`);
+        break;
+      }
+    }
+    contextFiles = await loadContextFiles(sliceDir);
+  }
+  if (result.failedTestFiles.length > 0) {
+    console.error(`❌ Some test failures remain after retry attempts.`);
+    for (const file of result.failedTestFiles) {
+      console.log(`   - ${path.relative(sliceDir, file)}`);
+    }
+  }
+}
+async function runTypecheck(sliceDir, rootDir) {
+  try {
+    const result = await execa('npx', ['tsc', '--noEmit'], {
+      cwd: rootDir,
+      stdio: 'pipe',
+      reject: false,
+    });
+    const output = (result.stdout ?? '') + (result.stderr ?? '');
+    if (result.exitCode !== 0 || output.includes('error')) {
+      return await processTypecheckOutput(output, sliceDir, rootDir);
+    }
+    return { success: true, typecheckErrors: '', failedTypecheckFiles: [] };
+  } catch (err) {
+    const execaErr = err;
+    const output = (execaErr.stdout ?? '') + (execaErr.stderr ?? '');
+    console.error('TypeScript execution error:', output);
+    const files = await fg(['*.ts'], { cwd: sliceDir, absolute: true });
+    return { success: false, typecheckErrors: output, failedTypecheckFiles: files };
+  }
+}
+function getTypecheckPatterns() {
+  return [
+    /^([^:]+\.ts)\(\d+,\d+\): error/gm,
+    /error TS\d+: (.+) '([^']+\.ts)'/gm,
+    /^([^:]+\.ts):\d+:\d+\s+-\s+error/gm,
+  ];
+}
+function extractFailedFiles(output, patterns, rootDir, sliceDir) {
+  const failedFiles = new Set();
+  for (const pattern of patterns) {
+    for (const match of output.matchAll(pattern)) {
+      const filePath = match[1] ? path.resolve(rootDir, match[1]) : '';
+      const notNodeModules = !filePath.includes('node_modules');
+      const inSlice = sliceDir === undefined || filePath.startsWith(sliceDir);
+      if (notNodeModules && inSlice) {
+        failedFiles.add(filePath);
+      }
+    }
+  }
+  return Array.from(failedFiles);
+}
+async function processTypecheckOutput(output, sliceDir, rootDir) {
+  const relativePath = path.relative(rootDir, sliceDir);
+  const filtered = output
+    .split('\n')
+    .filter((line) => {
+      const hasError = line.includes('error TS') || line.includes('): error');
+      const notNodeModules = !line.includes('node_modules');
+      const hasSlicePath = line.includes(relativePath) || line.includes(sliceDir);
+      return hasError && notNodeModules && hasSlicePath;
+    })
+    .join('\n');
+  if (filtered.trim() === '') {
+    return { success: true, typecheckErrors: '', failedTypecheckFiles: [] };
+  }
+  const failedFiles = await processTypecheckFailure(filtered, rootDir, sliceDir);
+  return {
+    success: false,
+    typecheckErrors: filtered,
+    failedTypecheckFiles: failedFiles,
+  };
+}
+async function processTypecheckFailure(output, rootDir, sliceDir) {
+  const patterns = getTypecheckPatterns();
+  let failed = extractFailedFiles(output, patterns, rootDir, sliceDir);
+  if (failed.length === 0 && output.includes('error')) {
+    failed = await fg(['*.ts'], { cwd: sliceDir, absolute: true });
+  }
+  return failed;
+}
+async function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    try {
+      await access(path.join(dir, 'package.json'));
+      return dir;
+    } catch {
+      dir = path.dirname(dir);
+    }
+  }
+  throw new Error('❌ Could not find project root');
+}
+function reportTestAndTypecheckResults(sliceDir, flow, result) {
+  const sliceName = path.basename(sliceDir);
+  if (result.success) {
+    console.log(`✅ All Tests and checks passed for: ${sliceName} in flow ${flow}`);
+    return;
+  }
+  console.error(`❌ ${sliceName} in floe ${flow} failed tests or type-checks.`);
+  if (result.failedTestFiles.length) {
+    const files = result.failedTestFiles.map((f) => path.relative(sliceDir, f));
+    console.log(`🧪 Failed test files: ${files.join(', ')}`);
+    if (result.testErrors) {
+      console.log(`📝 Test errors:\n${result.testErrors}`);
+    }
+  }
+  if (result.failedTypecheckFiles.length) {
+    const files = result.failedTypecheckFiles.map((f) => path.relative(sliceDir, f));
+    console.log(`📐 Failed typecheck files: ${files.join(', ')}`);
+    if (result.typecheckErrors) {
+      console.log(`📝 Typecheck errors:\n${result.typecheckErrors}`);
+    }
+  }
+}

package/src/agent/runTests.js

@@ -0,0 +1,100 @@
+import path from 'path';
+import fg from 'fast-glob';
+import { execa } from 'execa';
+import { existsSync } from 'fs';
+import { unlink } from 'fs/promises';
+import { readFile } from 'fs/promises';
+// eslint-disable-next-line complexity
+export async function runTests(sliceDir, rootDir) {
+  console.log(`🔍 Running tests in ${path.basename(sliceDir)}...`);
+  const testFiles = await fg(['*.spec.ts', '*.specs.ts'], { cwd: sliceDir });
+  if (testFiles.length === 0) {
+    console.warn(`⚠️ No test files found in ${sliceDir}`);
+    return { success: true, testErrors: '', failedTestFiles: [] };
+  } else {
+    console.log(`🔍 Found test files in ${path.basename(sliceDir)}:`, testFiles);
+  }
+  const relativePaths = testFiles.map((f) => path.join(sliceDir, f).replace(`${rootDir}/`, ''));
+  const reportPath = path.join(sliceDir, 'vitest-results.json');
+  try {
+    const { stdout, stderr } = await execa(
+      'npx',
+      ['vitest', 'run', '--reporter=json', `--outputFile=${reportPath}`, ...relativePaths],
+      {
+        cwd: rootDir,
+        stdio: 'pipe',
+        reject: false,
+      },
+    );
+    // Wait a bit for the file to be written
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    // Check if the report file exists and read it
+    if (existsSync(reportPath)) {
+      try {
+        const reportRaw = await readFile(reportPath, 'utf-8');
+        const report = JSON.parse(reportRaw);
+        const testResults = report.testResults ?? [];
+        const failedFiles = testResults
+          .filter((r) => r.status === 'failed')
+          .map((r) => {
+            const fileName = r.name ?? r.file;
+            if (!fileName) {
+              console.warn('⚠️ Skipping test result with missing name or file:', r);
+              return path.join(sliceDir, 'unknown');
+            }
+            return path.join(sliceDir, path.basename(fileName));
+          });
+        const failedTestSummaries = testResults
+          .filter((r) => r.status === 'failed')
+          .map((r) => {
+            const fileName = path.basename(r.name ?? r.file ?? 'unknown');
+            if (r.assertionResults.length > 0) {
+              const lines = r.assertionResults
+                .filter((a) => a.status === 'failed')
+                .map((a) => `❌ ${a.fullName}\n${a.failureMessages?.join('\n') ?? ''}`);
+              return `📄 ${fileName}\n${lines.join('\n')}`;
+            }
+            // fallback: use top-level message
+            if ('message' in r && typeof r.message === 'string' && r.message.trim() !== '') {
+              return `📄 ${fileName}\n${r.message}`;
+            }
+            return `📄 ${fileName}\n⚠️ Test suite failed but no assertion or error message found.`;
+          })
+          .join('\n\n');
+        return {
+          success: failedFiles.length === 0,
+          testErrors: failedTestSummaries || stdout || stderr || 'Tests failed but no error details available',
+          failedTestFiles: failedFiles,
+        };
+      } catch (parseErr) {
+        console.error('Failed to parse test results:', parseErr);
+        return {
+          success: false,
+          testErrors: stdout || stderr || 'Failed to parse test results',
+          failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+        };
+      }
+    } else {
+      // No report file, use stdout/stderr
+      return {
+        success: false,
+        testErrors: stdout || stderr || 'Test execution failed - no report generated',
+        failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+      };
+    }
+  } catch (err) {
+    const execaErr = err;
+    const output = (execaErr.stdout ?? '') + (execaErr.stderr ?? '');
+    console.error('Test execution error:', output);
+    return {
+      success: false,
+      testErrors: output || 'Test execution failed with no output',
+      failedTestFiles: testFiles.map((f) => path.join(sliceDir, f)),
+    };
+  } finally {
+    // Clean up the report file
+    if (existsSync(reportPath)) {
+      await unlink(reportPath).catch(() => {});
+    }
+  }
+}

package/src/commands/implement-server.js

@@ -0,0 +1,100 @@
+import { defineCommandHandler } from '@auto-engineer/message-bus';
+import path from 'path';
+import { existsSync } from 'fs';
+import { runFlows } from '../agent/runFlows';
+import createDebug from 'debug';
+const debug = createDebug('server-impl:command');
+const debugHandler = createDebug('server-impl:command:handler');
+const debugProcess = createDebug('server-impl:command:process');
+const debugResult = createDebug('server-impl:command:result');
+export const commandHandler = defineCommandHandler({
+  name: 'ImplementServer',
+  alias: 'implement:server',
+  description: 'AI implements server TODOs and tests',
+  category: 'implement',
+  fields: {
+    serverDirectory: {
+      description: 'Server directory path',
+      required: true,
+    },
+  },
+  examples: ['$ auto implement:server --server-directory=./server'],
+  handle: async (command) => {
+    debug('CommandHandler executing for ImplementServer');
+    const result = await handleImplementServerCommandInternal(command);
+    if (result.type === 'ServerImplemented') {
+      debug('Command handler completed: success');
+      debug('✅ Server implementation completed successfully');
+      if (result.data.flowsImplemented > 0) {
+        debug('   %d flows implemented', result.data.flowsImplemented);
+      }
+    } else {
+      debug('Command handler completed: failure - %s', result.data.error);
+      debug('❌ Server implementation failed: %s', result.data.error);
+    }
+    return result;
+  },
+});
+async function handleImplementServerCommandInternal(command) {
+  const { serverDirectory } = command.data;
+  debug('Handling ImplementServerCommand');
+  debug('  Server directory: %s', serverDirectory);
+  debug('  Request ID: %s', command.requestId);
+  debug('  Correlation ID: %s', command.correlationId ?? 'none');
+  try {
+    const serverRoot = path.resolve(serverDirectory);
+    const flowsDir = path.join(serverRoot, 'src', 'domain', 'flows');
+    debugHandler('Resolved paths:');
+    debugHandler('  Server root: %s', serverRoot);
+    debugHandler('  Flows directory: %s', flowsDir);
+    if (!existsSync(flowsDir)) {
+      debugHandler('ERROR: Flows directory not found at %s', flowsDir);
+      return {
+        type: 'ServerImplementationFailed',
+        data: {
+          serverDirectory,
+          error: `Flows directory not found at: ${flowsDir}`,
+        },
+        timestamp: new Date(),
+        requestId: command.requestId,
+        correlationId: command.correlationId,
+      };
+    }
+    debugProcess('Starting flow runner for directory: %s', flowsDir);
+    // Run the flows directly without spawning
+    await runFlows(flowsDir);
+    debugProcess('Flow runner completed successfully');
+    // For now, we don't have a way to count flows, so we'll use 0
+    // This could be enhanced by having runFlows return statistics
+    const flowsImplemented = 0;
+    debugResult('Process succeeded');
+    debugResult('Flows implemented: %d', flowsImplemented);
+    const successEvent = {
+      type: 'ServerImplemented',
+      data: {
+        serverDirectory,
+        flowsImplemented,
+      },
+      timestamp: new Date(),
+      requestId: command.requestId,
+      correlationId: command.correlationId,
+    };
+    debugResult('Returning success event: ServerImplemented');
+    return successEvent;
+  } catch (error) {
+    debug('ERROR: Exception caught: %O', error);
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    return {
+      type: 'ServerImplementationFailed',
+      data: {
+        serverDirectory,
+        error: errorMessage,
+      },
+      timestamp: new Date(),
+      requestId: command.requestId,
+      correlationId: command.correlationId,
+    };
+  }
+}
+// Default export is the command handler
+export default commandHandler;