@auto-engineer/server-implementer 0.11.9 → 0.11.11

package/package.json

@@ -17,8 +17,8 @@
     "debug": "^4.3.4",
     "fast-glob": "^3.3.3",
     "vite": "^5.4.1",
-    "@auto-engineer/ai-gateway": "0.11.9",
-    "@auto-engineer/message-bus": "0.11.9"
+    "@auto-engineer/ai-gateway": "0.11.11",
+    "@auto-engineer/message-bus": "0.11.11"
   },
   "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.11.9"
+    "@auto-engineer/cli": "0.11.11"
   },
-  "version": "0.11.9",
+  "version": "0.11.11",
   "scripts": {
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts",
     "test": "vitest run --reporter=dot",

package/src/commands/implement-slice.ts

@@ -88,7 +88,6 @@ function extractCodeBlock(text: string): string {
     .trim();
 }
 
-// Load all TypeScript files from the slice directory
 async function loadContextFiles(sliceDir: string): Promise<Record<string, string>> {
   const files = await fg(['*.ts'], { cwd: sliceDir });
   const context: Record<string, string> = {};
@@ -96,36 +95,58 @@ async function loadContextFiles(sliceDir: string): Promise<Record<string, string
     const absPath = path.join(sliceDir, file);
     context[file] = await readFile(absPath, 'utf-8');
   }
+
+  const sharedTypesPath = path.resolve(sliceDir, '../../../shared/types.ts');
+  if (existsSync(sharedTypesPath)) {
+    const sharedTypesContent = await readFile(sharedTypesPath, 'utf-8');
+    context['domain-shared-types.ts'] = sharedTypesContent;
+  }
+
   return context;
 }
 
-// Find files that need implementation
-function findFilesToImplement(contextFiles: Record<string, string>, hasErrors: boolean): Array<[string, string]> {
-  if (hasErrors) {
-    return Object.entries(contextFiles);
+const IMPLEMENTATION_MARKER = '// @auto-implement';
+
+function hasImplementationMarker(content: string): boolean {
+  return content.includes(IMPLEMENTATION_MARKER);
+}
+
+function addImplementationMarker(content: string): string {
+  if (hasImplementationMarker(content)) {
+    return content;
   }
-  return Object.entries(contextFiles).filter(
-    ([, content]) => content.includes('TODO:') || content.includes('IMPLEMENTATION INSTRUCTIONS'),
+  return `${IMPLEMENTATION_MARKER}\n${content}`;
+}
+
+function needsImplementation(content: string): boolean {
+  return (
+    hasImplementationMarker(content) || content.includes('TODO:') || content.includes('IMPLEMENTATION INSTRUCTIONS')
   );
 }
 
-// System prompt for AI implementation
+function findFilesToImplement(contextFiles: Record<string, string>): Array<[string, string]> {
+  return Object.entries(contextFiles).filter(([, content]) => hasImplementationMarker(content));
+}
+
 const SYSTEM_PROMPT = `
 You are a software engineer implementing missing logic in a sliced event-driven TypeScript server. 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
+- Language: TypeScript with type-graphql and @event-driven-io/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.
+- The domain uses shared enums defined in domain/shared/types.ts for type-safe values. When a field type is an enum (e.g., Status), you MUST use enum constants (e.g., Status.IN_PROGRESS) instead of string literals (e.g., 'in_progress').
 
 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.
+- CRITICAL: When a field has an enum type (e.g., status: Status), you MUST use the enum constant (e.g., Status.IN_PROGRESS) NOT a string literal (e.g., 'in_progress'). Check domain-shared-types.ts for the exact enum constant names.
 - Do not remove existing imports or types that are still referenced or required in the file.
+- Preserve index signatures like [key: string]: unknown as they are required for TypeScript compatibility.
 - Return the entire updated file, not just the modified parts and remove any TODO comments or instructions after implementing the logic
 
 Key rules:
@@ -138,24 +159,61 @@ Key rules:
 - All code must be TypeScript compliant and follow functional patterns.
 - If a test exists, make it pass.
 - Keep implementations minimal and idiomatic.
+- CRITICAL: When assigning values to enum-typed fields, use the enum constant name from domain-shared-types.ts. For example, if Status enum has IN_PROGRESS = 'in_progress', use Status.IN_PROGRESS not 'in_progress'.
 
 Avoid:
 - Adding new dependencies.
 - Refactoring unrelated code.
 - Changing the structure of already scaffolded files unless instructed.
+- Using string literals for enum-typed fields. ALWAYS use the enum constant from domain-shared-types.ts (e.g., if status field type is Status and Status enum defines IN_PROGRESS = 'in_progress', use Status.IN_PROGRESS not the string 'in_progress').
 
 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.).
+- Shared domain types including enum definitions (domain-shared-types.ts).
 
 You must:
 -  Return the entire updated file (no commentary and remove all implementation instructions).
 - Ensure the output is valid TypeScript.
+- Use enum constants from domain-shared-types.ts when appropriate.
+`;
+
+function extractEnumExamples(sharedTypesContent: string): string {
+  const enumMatches = sharedTypesContent.matchAll(/export enum (\w+) \{([^}]+)\}/g);
+  const examples: string[] = [];
+
+  for (const match of enumMatches) {
+    const enumName = match[1];
+    const enumBody = match[2];
+    const firstConstant = enumBody.match(/\s*(\w+)\s*=\s*['"]([^'"]+)['"]/);
+
+    if (firstConstant !== null) {
+      const constantName = firstConstant[1];
+      const constantValue = firstConstant[2];
+      examples.push(`  - ${enumName}.${constantName} (NOT '${constantValue}')`);
+    }
+  }
+
+  if (examples.length === 0) {
+    return '';
+  }
+
+  return `
+📌 CRITICAL: Enum Usage Examples from Your Context:
+${examples.join('\n')}
+
+Pattern: Always use EnumName.CONSTANT_NAME for enum-typed fields.
+Never use string literals like 'pending' or 'Pending' when an enum constant exists.
 `;
+}
 
-// Build prompt for initial implementation
 function buildInitialPrompt(targetFile: string, context: Record<string, string>): string {
+  const sharedTypes = context['domain-shared-types.ts'];
+  const sliceFiles = Object.entries(context).filter(
+    ([name]) => name !== targetFile && name !== 'domain-shared-types.ts',
+  );
+
   return `
 ${SYSTEM_PROMPT}
 
@@ -164,20 +222,32 @@ ${SYSTEM_PROMPT}
 
 ${context[targetFile]}
 
----
+${
+  sharedTypes !== undefined
+    ? `---
+📦 Shared domain types (available via import from '../../../shared'):
+${sharedTypes}
+
+${extractEnumExamples(sharedTypes)}
+IMPORTANT: Use enum constants (e.g., Status.PENDING) instead of string literals (e.g., 'pending') when working with enum types.
+
+`
+    : ''
+}---
 🧠 Other files in the same slice:
-${Object.entries(context)
-  .filter(([name]) => name !== targetFile)
-  .map(([name, content]) => `// File: ${name}\n${content}`)
-  .join('\n\n')}
+${sliceFiles.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.
+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. Remember to use enum constants from domain-shared-types.ts instead of string literals.
 `.trim();
 }
 
-// Build prompt for retry with context
 function buildRetryPrompt(targetFile: string, context: Record<string, string>, previousOutputs: string): string {
+  const sharedTypes = context['domain-shared-types.ts'];
+  const sliceFiles = Object.entries(context).filter(
+    ([name]) => name !== targetFile && name !== 'domain-shared-types.ts',
+  );
+
   return `
 ${SYSTEM_PROMPT}
 
@@ -190,18 +260,69 @@ ${previousOutputs}
 
 ${context[targetFile]}
 
+${
+  sharedTypes !== undefined
+    ? `---
+📦 Shared domain types (available via import from '../../../shared'):
+${sharedTypes}
+
+${extractEnumExamples(sharedTypes)}
+IMPORTANT: Use enum constants (e.g., Status.PENDING) instead of string literals (e.g., 'pending') when working with enum types.
+
+`
+    : ''
+}---
 🧠 Other files in the same slice:
-${Object.entries(context)
-  .filter(([name]) => name !== targetFile)
-  .map(([name, content]) => `// File: ${name}\n${content}`)
-  .join('\n\n')}
+${sliceFiles.map(([name, content]) => `// File: ${name}\n${content}`).join('\n\n')}
 
 ---
-Return only the corrected full contents of ${targetFile}, no commentary, no markdown.
+Return only the corrected full contents of ${targetFile}, no commentary, no markdown. Remember to use enum constants from domain-shared-types.ts instead of string literals.
 `.trim();
 }
 
-// Main implementation function
+async function addMarkersToFiles(slicePath: string, contextFiles: Record<string, string>): Promise<void> {
+  const filesToMark = Object.entries(contextFiles).filter(([, content]) => needsImplementation(content));
+  debugProcess(`Found ${filesToMark.length} files needing implementation markers`);
+
+  for (const [filename, content] of filesToMark) {
+    if (!hasImplementationMarker(content)) {
+      const markedContent = addImplementationMarker(content);
+      await writeFile(path.join(slicePath, filename), markedContent, 'utf-8');
+      contextFiles[filename] = markedContent;
+      debugProcess(`Added implementation marker to ${filename}`);
+    }
+  }
+}
+
+async function implementFile(
+  slicePath: string,
+  targetFile: string,
+  contextFiles: Record<string, string>,
+  retryContext?: { previousOutputs?: string; attemptNumber?: number },
+): Promise<void> {
+  debugProcess(`Implementing ${targetFile}`);
+
+  const previousOutputs = retryContext?.previousOutputs;
+  const isRetry = previousOutputs !== undefined && previousOutputs.length > 0;
+  const prompt = isRetry
+    ? buildRetryPrompt(targetFile, contextFiles, previousOutputs)
+    : buildInitialPrompt(targetFile, contextFiles);
+
+  if (isRetry) {
+    debugProcess(`Using retry prompt for attempt #${retryContext?.attemptNumber ?? 2}`);
+  }
+
+  const aiOutput = await generateTextWithAI(prompt, { maxTokens: 8000 });
+  let cleanedCode = extractCodeBlock(aiOutput);
+  cleanedCode = addImplementationMarker(cleanedCode);
+
+  const filePath = path.join(slicePath, targetFile);
+  await writeFile(filePath, cleanedCode, 'utf-8');
+  debugProcess(`Successfully implemented ${targetFile}`);
+
+  contextFiles[targetFile] = cleanedCode;
+}
+
 async function implementSlice(
   slicePath: string,
   context?: { previousOutputs?: string; attemptNumber?: number },
@@ -211,46 +332,23 @@ async function implementSlice(
   debugProcess(`Implementing slice: ${sliceName}`);
 
   try {
-    // Load all context files
     const contextFiles = await loadContextFiles(slicePath);
     debugProcess(`Loaded ${Object.keys(contextFiles).join(', ')} files from slice`);
-    const hasErrors = Boolean(context?.previousOutputs);
-    const filesToImplement = findFilesToImplement(contextFiles, hasErrors);
-    debugProcess(`Found ${filesToImplement.length} files needing implementation`);
-    const implementedFiles: string[] = [];
+
+    await addMarkersToFiles(slicePath, contextFiles);
+
+    const filesToImplement = findFilesToImplement(contextFiles);
+    debugProcess(`Found ${filesToImplement.length} files with markers to implement`);
 
     if (filesToImplement.length === 0) {
-      debugProcess('No files with TODO or IMPLEMENTATION INSTRUCTIONS found, and no errors found');
+      debugProcess('No files with markers found');
       return { success: true, filesImplemented: [] };
     }
 
-    // Implement each file that needs it
+    const implementedFiles: string[] = [];
     for (const [targetFile] of filesToImplement) {
-      debugProcess(`Implementing ${targetFile}`);
-
-      let prompt: string;
-      if (context !== undefined && context.previousOutputs !== undefined && context.previousOutputs.length > 0) {
-        // Use retry prompt if we have previous context
-        prompt = buildRetryPrompt(targetFile, contextFiles, context.previousOutputs);
-        debugProcess(`Using retry prompt for attempt #${context.attemptNumber ?? 2}`);
-      } else {
-        // Use initial prompt for first attempt
-        prompt = buildInitialPrompt(targetFile, contextFiles);
-      }
-
-      // Generate implementation with AI
-      const aiOutput = await generateTextWithAI(prompt);
-      const cleanedCode = extractCodeBlock(aiOutput);
-
-      // Write the implemented file
-      const filePath = path.join(slicePath, targetFile);
-      await writeFile(filePath, cleanedCode, 'utf-8');
-
-      debugProcess(`Successfully implemented ${targetFile}`);
+      await implementFile(slicePath, targetFile, contextFiles, context);
       implementedFiles.push(targetFile);
-
-      // Update context for next file
-      contextFiles[targetFile] = cleanedCode;
     }
 
     return { success: true, filesImplemented: implementedFiles };
@@ -323,7 +421,6 @@ function logRetryContext(context: { previousOutputs?: string; attemptNumber?: nu
 export async function handleImplementSliceCommand(
   command: ImplementSliceCommand,
 ): Promise<SliceImplementedEvent | SliceImplementationFailedEvent> {
-  // Handle both 'slicePath' and 'path' parameters for backward compatibility
   const rawData = command.data as ImplementSliceCommand['data'] & { path?: string };
   const slicePath = rawData.slicePath ?? rawData.path;
   const { context } = command.data;
@@ -367,5 +464,4 @@ export async function handleImplementSliceCommand(
   }
 }
 
-// Default export is the command handler
 export default commandHandler;