@auto-engineer/server-implementer 0.4.2 → 0.4.3

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @auto-engineer/server-implementer@0.4.2 build /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+> @auto-engineer/server-implementer@0.4.3 build /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
 > tsc
 

package/.turbo/turbo-format.log

@@ -1,14 +1,22 @@
-
-> @auto-engineer/server-implementer@0.4.0 format /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
-> prettier --write "**/*.{js,ts,json,md,yml,yaml}" --ignore-path ../../.prettierignore
-
-CHANGELOG.md 25ms (unchanged)
-package.json 17ms (unchanged)
-src/agent/runAllSlices.ts 32ms (unchanged)
-src/agent/runFlows.ts 8ms (unchanged)
-src/agent/runSlice.ts 42ms (unchanged)
-src/agent/runTests.ts 16ms (unchanged)
-src/cli/index.ts 2ms (unchanged)
-src/prompts/systemPrompt.ts 1ms (unchanged)
-src/utils/extractCodeBlock.ts 1ms (unchanged)
-tsconfig.json 2ms (unchanged)
+
+
+> @auto-engineer/server-implementer@0.4.2 format /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+> prettier --write "**/*.{js,ts,json,md,yml,yaml}" --ignore-path ../../.prettierignore
+
+CHANGELOG.mdCHANGELOG.md 22ms (unchanged)
+package.jsonpackage.json 16ms (unchanged)
+src/agent/runAllSlices.jssrc/agent/runAllSlices.js 30ms (unchanged)
+src/agent/runAllSlices.tssrc/agent/runAllSlices.ts 39ms (unchanged)
+src/agent/runFlows.jssrc/agent/runFlows.js 3ms (unchanged)
+src/agent/runFlows.tssrc/agent/runFlows.ts 3ms (unchanged)
+src/agent/runSlice.jssrc/agent/runSlice.js 29ms (unchanged)
+src/agent/runSlice.tssrc/agent/runSlice.ts 30ms (unchanged)
+src/agent/runTests.jssrc/agent/runTests.js 6ms (unchanged)
+src/agent/runTests.tssrc/agent/runTests.ts 7ms (unchanged)
+src/cli/index.jssrc/cli/index.js 1ms (unchanged)
+src/cli/index.tssrc/cli/index.ts 2ms (unchanged)
+src/prompts/systemPrompt.jssrc/prompts/systemPrompt.js 1ms (unchanged)
+src/prompts/systemPrompt.tssrc/prompts/systemPrompt.ts 2ms (unchanged)
+src/utils/extractCodeBlock.jssrc/utils/extractCodeBlock.js 1ms (unchanged)
+src/utils/extractCodeBlock.tssrc/utils/extractCodeBlock.ts 1ms (unchanged)
+tsconfig.jsontsconfig.json 1ms (unchanged)

package/.turbo/turbo-lint.log

@@ -1,4 +1,5 @@
-
-> @auto-engineer/server-implementer@0.4.0 lint /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
-> eslint 'src/**/*.ts' --max-warnings 0 --config ../../eslint.config.ts
-
+
+
+> @auto-engineer/server-implementer@0.4.2 lint /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+> eslint 'src/**/*.ts' --max-warnings 0 --config ../../eslint.config.ts
+

package/.turbo/turbo-test.log

@@ -1,14 +1,12 @@
-
-
-> @auto-engineer/server-implementer@0.4.2 test /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
-> vitest run
-
-[?25l
- RUN  v3.2.4 /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
-
-No test files found, exiting with code 0
-
-include: **/*.specs.{js,ts}
-exclude:  **/.tmp/**, **/node_modules/**, **/dist/**
-
-[?25h
+
+> @auto-engineer/server-implementer@0.4.3 test /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+> vitest run
+
+
+ RUN  v3.2.4 /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+
+No test files found, exiting with code 0
+
+include: **/*.specs.{js,ts}
+exclude:  **/.tmp/**, **/node_modules/**, **/dist/**
+

package/.turbo/turbo-type-check.log

@@ -1,5 +1,4 @@
-
-
-> @auto-engineer/server-implementer@0.4.2 type-check /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
-> tsc --noEmit
-
+
+> @auto-engineer/server-implementer@0.4.3 type-check /Users/sam/WebstormProjects/top/auto-engineer/packages/server-implementer
+> tsc --noEmit
+

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @auto-engineer/server-implementer
 
+## 0.4.3
+
+### Patch Changes
+
+- version testing
+- Updated dependencies
+  - @auto-engineer/ai-gateway@0.4.3
+
 ## 0.4.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto-engineer/server-implementer",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -8,7 +8,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@auto-engineer/ai-gateway": "^0.4.2",
+    "@auto-engineer/ai-gateway": "^0.4.3",
     "@modelcontextprotocol/sdk": "^1.3.0",
     "fast-glob": "^3.3.3",
     "vite": "^5.4.1"

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,16 @@
+import fg from 'fast-glob';
+import path from 'path';
+import { runAllSlices } from './runAllSlices';
+export async function runFlows(baseDir) {
+  const flowDirs = await fg('*', {
+    cwd: baseDir,
+    onlyDirectories: true,
+    absolute: true,
+  });
+  console.log(`🚀 Found ${flowDirs.length} flows`);
+  for (const flowDir of flowDirs) {
+    console.log(`📂 Processing flow: ${path.basename(flowDir)}`);
+    await runAllSlices(flowDir);
+  }
+  console.log('✅ All flows processed');
+}

package/src/agent/runSlice.js

@@ -0,0 +1,328 @@
+import path from 'path';
+import fg from 'fast-glob';
+import { generateTextWithAI, getAvailableProviders } 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';
+const availableProviders = getAvailableProviders();
+const AI_PROVIDER = availableProviders[0];
+if (availableProviders.length === 0) {
+  console.error(
+    '❌ No AI providers configured. Please set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or XAI_API_KEY',
+  );
+  process.exit(1);
+}
+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, AI_PROVIDER);
+      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, AI_PROVIDER);
+  //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, AI_PROVIDER);
+    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/cli/index.js

@@ -0,0 +1,21 @@
+import 'dotenv/config';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { runFlows } from '../agent/runFlows';
+const __filename = fileURLToPath(import.meta.url);
+const isMain = process.argv[1] === __filename;
+if (isMain) {
+  const base = process.argv[2];
+  if (!base) {
+    console.error('Usage: tsx src/cli/index.ts path/to/server/root');
+    process.exit(1);
+  }
+  const serverRoot = path.resolve(base);
+  const flowsDir = path.join(serverRoot, 'src', 'domain', 'flows');
+  if (!existsSync(flowsDir)) {
+    console.error(`❌ Flows directory not found at: ${flowsDir}`);
+    process.exit(1);
+  }
+  void runFlows(flowsDir);
+}

package/src/prompts/systemPrompt.js

@@ -0,0 +1,43 @@
+export const SYSTEM_PROMPT = `
+You are a software engineer implementing missing logic in a sliced event-driven TypeScript backend. Each slice contains partially scaffolded code, and your task is to complete the logic following implementation instructions embedded in each file.
+
+Project Characteristics:
+- Architecture: sliced event-sourced CQRS (Command, Query, Reaction slices)
+- Language: TypeScript with type-graphql and Emmett
+- Each slice has scaffolded files with implementation instructions clearly marked with comments (e.g., '## IMPLEMENTATION INSTRUCTIONS ##') or TODOs.
+- Tests (e.g., *.specs.ts) must pass.
+- Type errors are not allowed.
+
+Your Goal:
+- Read the implementation instructions from the provided file.
+- Generate only the code needed to fulfill the instructions, nothing extra and provide back the whole file without the instructions.
+- Maintain immutability and adhere to functional best practices.
+- Use only the types and domain constructs already present in the slice.
+- Do not remove existing imports or types that are still referenced or required in the file.
+- Return the entire updated file, not just the modified parts and remove any TODO comments or instructions after implementing the logic
+
+Key rules:
+- Never modify code outside the TODO or instruction areas.
+- Ensure the code is production-ready and type-safe.
+- Follow the slice type conventions:
+  - **Command slice**: validate command, inspect state, emit events, never mutate state. Uses graphql mutations.
+  - **Reaction slice**: respond to events with commands.
+  - **Query slice**: maintain projections based on events, do not emit or throw. Uses graphql queries.
+- All code must be TypeScript compliant and follow functional patterns.
+- If a test exists, make it pass.
+- Keep implementations minimal and idiomatic.
+
+Avoid:
+- Adding new dependencies.
+- Refactoring unrelated code.
+- Changing the structure of already scaffolded files unless instructed.
+
+You will receive:
+- The path of the file to implement.
+- The current contents of the file, with instruction comments.
+- Other relevant files from the same slice (e.g., types, test, state, etc.).
+
+You must:
+-  Return the entire updated file (no commentary and remove all implementation instructions).
+- Ensure the output is valid TypeScript.
+`;

package/src/utils/extractCodeBlock.js

@@ -0,0 +1,6 @@
+export function extractCodeBlock(text) {
+  return text
+    .replace(/```(?:ts|typescript)?/g, '')
+    .replace(/```/g, '')
+    .trim();
+}