@auto-engineer/server-implementer 1.139.0 → 1.140.1

package/src/commands/implement-slice.ts

@@ -17,10 +17,10 @@ const debugHandler = createDebug('auto:server-implementer:slice:handler');
 const debugProcess = createDebug('auto:server-implementer:slice:process');
 const debugResult = createDebug('auto:server-implementer:slice:result');
 
-export type ImplementSliceCommand = Command<
-  'ImplementSlice',
+export type ImplementMomentCommand = Command<
+  'ImplementMoment',
   {
-    slicePath: string;
+    momentPath: string;
     context?: {
       previousOutputs?: string;
       attemptNumber?: number;
@@ -31,36 +31,36 @@ export type ImplementSliceCommand = Command<
   }
 >;
 
-export type SliceImplementedEvent = Event<
-  'SliceImplemented',
+export type MomentImplementedEvent = Event<
+  'MomentImplemented',
   {
-    slicePath: string;
+    momentPath: string;
     filesImplemented: string[];
   }
 >;
 
-export type SliceImplementationFailedEvent = Event<
-  'SliceImplementationFailed',
+export type MomentImplementationFailedEvent = Event<
+  'MomentImplementationFailed',
   {
-    slicePath: string;
+    momentPath: string;
     error: string;
   }
 >;
 
-export type ImplementSliceEvents = SliceImplementedEvent | SliceImplementationFailedEvent;
+export type ImplementMomentEvents = MomentImplementedEvent | MomentImplementationFailedEvent;
 
 export const commandHandler = defineCommandHandler<
-  ImplementSliceCommand,
-  (command: ImplementSliceCommand) => Promise<SliceImplementedEvent | SliceImplementationFailedEvent>
+  ImplementMomentCommand,
+  (command: ImplementMomentCommand) => Promise<MomentImplementedEvent | MomentImplementationFailedEvent>
 >({
-  name: 'ImplementSlice',
-  displayName: 'Implement Slice',
+  name: 'ImplementMoment',
+  displayName: 'Implement Moment',
   alias: 'implement:slice',
   description: 'AI implements a specific server slice',
   category: 'implement',
   icon: 'layers',
   fields: {
-    slicePath: {
+    momentPath: {
       description: 'Path to the slice directory to implement',
       required: true,
     },
@@ -74,24 +74,26 @@ export const commandHandler = defineCommandHandler<
     },
   },
   examples: [
-    '$ auto implement:slice --slice-path=./server/src/domain/flows/seasonal-assistant/enters-shopping-criteria-into-assistant',
+    '$ auto implement:slice --slice-path=./server/src/domain/narratives/seasonal-assistant/enters-shopping-criteria-into-assistant',
   ],
   events: [
-    { name: 'SliceImplemented', displayName: 'Slice Implemented' },
-    { name: 'SliceImplementationFailed', displayName: 'Slice Implementation Failed' },
+    { name: 'MomentImplemented', displayName: 'Moment Implemented' },
+    { name: 'MomentImplementationFailed', displayName: 'Moment Implementation Failed' },
   ],
-  handle: async (command: ImplementSliceCommand): Promise<SliceImplementedEvent | SliceImplementationFailedEvent> => {
-    debug('CommandHandler executing for ImplementSlice');
-    const result = await handleImplementSliceCommand(command);
+  handle: async (
+    command: ImplementMomentCommand,
+  ): Promise<MomentImplementedEvent | MomentImplementationFailedEvent> => {
+    debug('CommandHandler executing for ImplementMoment');
+    const result = await handleImplementMomentCommand(command);
 
-    if (result.type === 'SliceImplemented') {
+    if (result.type === 'MomentImplemented') {
       debug('Command handler completed: success');
-      debug('✅ Slice implementation completed successfully');
-      debug('   Slice: %s', path.basename(result.data.slicePath));
+      debug('✅ Moment implementation completed successfully');
+      debug('   Moment: %s', path.basename(result.data.momentPath));
       debug('   Files implemented: %d', result.data.filesImplemented.length);
     } else {
       debug('Command handler completed: failure - %s', result.data.error);
-      debug('❌ Slice implementation failed: %s', result.data.error);
+      debug('❌ Moment implementation failed: %s', result.data.error);
     }
     return result;
   },
@@ -155,14 +157,14 @@ Return only the corrected full contents of ${targetFile}, no commentary, no mark
 `.trim();
 }
 
-async function addMarkersToFiles(slicePath: string, contextFiles: Record<string, string>): Promise<void> {
+async function addMarkersToFiles(momentPath: 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');
+      await writeFile(path.join(momentPath, filename), markedContent, 'utf-8');
       contextFiles[filename] = markedContent;
       debugProcess(`Added implementation marker to ${filename}`);
     }
@@ -170,7 +172,7 @@ async function addMarkersToFiles(slicePath: string, contextFiles: Record<string,
 }
 
 async function implementFile(
-  slicePath: string,
+  momentPath: string,
   targetFile: string,
   contextFiles: Record<string, string>,
   retryContext?: { previousOutputs?: string; attemptNumber?: number },
@@ -196,27 +198,27 @@ async function implementFile(
   let cleanedCode = extractCodeBlock(aiOutput);
   cleanedCode = addImplementationMarker(cleanedCode);
 
-  const filePath = path.join(slicePath, targetFile);
+  const filePath = path.join(momentPath, targetFile);
   await writeFile(filePath, cleanedCode, 'utf-8');
   debugProcess(`Successfully implemented ${targetFile}`);
 
   contextFiles[targetFile] = cleanedCode;
 }
 
-async function implementSlice(
-  slicePath: string,
+async function implementMoment(
+  momentPath: string,
   context?: { previousOutputs?: string; attemptNumber?: number },
   aiOptions?: { maxTokens?: number },
 ): Promise<{ success: boolean; filesImplemented: string[]; error?: string }> {
-  const sliceName = path.basename(slicePath);
+  const momentName = path.basename(momentPath);
 
-  debugProcess(`Implementing slice: ${sliceName}`);
+  debugProcess(`Implementing slice: ${momentName}`);
 
   try {
-    const contextFiles = await loadContextFiles(slicePath);
+    const contextFiles = await loadContextFiles(momentPath);
     debugProcess(`Loaded ${Object.keys(contextFiles).join(', ')} files from slice`);
 
-    await addMarkersToFiles(slicePath, contextFiles);
+    await addMarkersToFiles(momentPath, contextFiles);
 
     const filesToImplement = findFilesToImplement(contextFiles, hasImplementationMarker);
     debugProcess(`Found ${filesToImplement.length} files with markers to implement`);
@@ -228,7 +230,7 @@ async function implementSlice(
 
     const implementedFiles: string[] = [];
     for (const [targetFile] of filesToImplement) {
-      await implementFile(slicePath, targetFile, contextFiles, context, aiOptions);
+      await implementFile(momentPath, targetFile, contextFiles, context, aiOptions);
       implementedFiles.push(targetFile);
     }
 
@@ -240,12 +242,12 @@ async function implementSlice(
   }
 }
 
-function logCommandDebugInfo(command: ImplementSliceCommand, resolvedSlicePath?: string): void {
-  const rawData = command.data as ImplementSliceCommand['data'] & { path?: string };
-  const slicePath = rawData.slicePath ?? rawData.path;
+function logCommandDebugInfo(command: ImplementMomentCommand, resolvedMomentPath?: string): void {
+  const rawData = command.data as ImplementMomentCommand['data'] & { path?: string };
+  const momentPath = rawData.momentPath ?? rawData.path;
   const { context } = command.data;
-  debug('Handling ImplementSliceCommand');
-  debug('  Slice path: %s', resolvedSlicePath ?? slicePath);
+  debug('Handling ImplementMomentCommand');
+  debug('  Moment path: %s', resolvedMomentPath ?? momentPath);
   debug('  Context provided: %s', context ? 'yes' : 'no');
   if (context) {
     debug('  Attempt number: %d', context.attemptNumber ?? 1);
@@ -255,16 +257,16 @@ function logCommandDebugInfo(command: ImplementSliceCommand, resolvedSlicePath?:
 }
 
 function createFailedEvent(
-  command: ImplementSliceCommand,
+  command: ImplementMomentCommand,
   error: string,
-  resolvedSlicePath?: string,
-): SliceImplementationFailedEvent {
-  const rawData = command.data as ImplementSliceCommand['data'] & { path?: string };
-  const slicePath = resolvedSlicePath ?? rawData.slicePath ?? rawData.path;
+  resolvedMomentPath?: string,
+): MomentImplementationFailedEvent {
+  const rawData = command.data as ImplementMomentCommand['data'] & { path?: string };
+  const momentPath = resolvedMomentPath ?? rawData.momentPath ?? rawData.path;
   return {
-    type: 'SliceImplementationFailed',
+    type: 'MomentImplementationFailed',
     data: {
-      slicePath,
+      momentPath,
       error,
     },
     timestamp: new Date(),
@@ -274,16 +276,16 @@ function createFailedEvent(
 }
 
 function createSuccessEvent(
-  command: ImplementSliceCommand,
+  command: ImplementMomentCommand,
   filesImplemented: string[],
-  resolvedSlicePath?: string,
-): SliceImplementedEvent {
-  const rawData = command.data as ImplementSliceCommand['data'] & { path?: string };
-  const slicePath = resolvedSlicePath ?? rawData.slicePath ?? rawData.path;
+  resolvedMomentPath?: string,
+): MomentImplementedEvent {
+  const rawData = command.data as ImplementMomentCommand['data'] & { path?: string };
+  const momentPath = resolvedMomentPath ?? rawData.momentPath ?? rawData.path;
   return {
-    type: 'SliceImplemented',
+    type: 'MomentImplemented',
     data: {
-      slicePath,
+      momentPath,
       filesImplemented,
     },
     timestamp: new Date(),
@@ -299,35 +301,35 @@ function logRetryContext(context: { previousOutputs?: string; attemptNumber?: nu
   }
 }
 
-export async function handleImplementSliceCommand(
-  command: ImplementSliceCommand,
-): Promise<SliceImplementedEvent | SliceImplementationFailedEvent> {
-  const rawData = command.data as ImplementSliceCommand['data'] & { path?: string };
-  const slicePath = rawData.slicePath ?? rawData.path;
+export async function handleImplementMomentCommand(
+  command: ImplementMomentCommand,
+): Promise<MomentImplementedEvent | MomentImplementationFailedEvent> {
+  const rawData = command.data as ImplementMomentCommand['data'] & { path?: string };
+  const momentPath = rawData.momentPath ?? rawData.path;
   const { context } = command.data;
   const aiOptions = command.data.aiOptions;
 
-  if (slicePath === undefined || slicePath === null || slicePath === '') {
-    debugHandler('ERROR: No slice path provided. Expected slicePath or path parameter');
-    return createFailedEvent(command, 'No slice path provided. Expected slicePath parameter');
+  if (momentPath === undefined || momentPath === null || momentPath === '') {
+    debugHandler('ERROR: No slice path provided. Expected momentPath or path parameter');
+    return createFailedEvent(command, 'No slice path provided. Expected momentPath parameter');
   }
 
-  logCommandDebugInfo(command, slicePath);
+  logCommandDebugInfo(command, momentPath);
 
   try {
-    const sliceRoot = path.resolve(slicePath);
+    const sliceRoot = path.resolve(momentPath);
     debugHandler('Resolved paths:');
-    debugHandler('  Slice root: %s', sliceRoot);
+    debugHandler('  Moment root: %s', sliceRoot);
 
     if (!existsSync(sliceRoot)) {
-      debugHandler('ERROR: Slice directory not found at %s', sliceRoot);
-      return createFailedEvent(command, `Slice directory not found at: ${sliceRoot}`, sliceRoot);
+      debugHandler('ERROR: Moment directory not found at %s', sliceRoot);
+      return createFailedEvent(command, `Moment directory not found at: ${sliceRoot}`, sliceRoot);
     }
 
     debugProcess('Starting slice implementation for: %s', sliceRoot);
     logRetryContext(context);
 
-    const result = await implementSlice(sliceRoot, context, aiOptions);
+    const result = await implementMoment(sliceRoot, context, aiOptions);
 
     if (!result.success) {
       return createFailedEvent(command, result.error ?? 'Implementation failed', sliceRoot);
@@ -336,13 +338,13 @@ export async function handleImplementSliceCommand(
     debugResult('Process succeeded');
     debugResult('Files implemented: %d', result.filesImplemented.length);
     debugResult('Files: %s', result.filesImplemented.join(', '));
-    debugResult('Returning success event: SliceImplemented');
+    debugResult('Returning success event: MomentImplemented');
 
     return createSuccessEvent(command, result.filesImplemented, sliceRoot);
   } catch (error) {
     debug('ERROR: Exception caught: %O', error);
     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-    return createFailedEvent(command, errorMessage, slicePath);
+    return createFailedEvent(command, errorMessage, momentPath);
   }
 }
 

package/src/index.ts

@@ -1,8 +1,8 @@
 import { commandHandler as implementServerHandler } from './commands/implement-server';
-import { commandHandler as implementSliceHandler } from './commands/implement-slice';
+import { commandHandler as implementMomentHandler } from './commands/implement-slice';
 
-export const COMMANDS = [implementServerHandler, implementSliceHandler];
-export { implementServerHandler, implementSliceHandler };
+export const COMMANDS = [implementServerHandler, implementMomentHandler];
+export { implementServerHandler, implementMomentHandler };
 export type {
   ImplementServerCommand,
   ImplementServerEvents,
@@ -10,9 +10,9 @@ export type {
   ServerImplementedEvent,
 } from './commands/implement-server';
 export {
-  handleImplementSliceCommand,
-  type ImplementSliceCommand,
-  type ImplementSliceEvents,
-  type SliceImplementationFailedEvent,
-  type SliceImplementedEvent,
+  handleImplementMomentCommand,
+  type ImplementMomentCommand,
+  type ImplementMomentEvents,
+  type MomentImplementationFailedEvent,
+  type MomentImplementedEvent,
 } from './commands/implement-slice';

package/src/prompts/systemPrompt.ts

@@ -5,7 +5,7 @@ You are a software engineer implementing @auto-implement files in a sliced event
 
 - Architecture: event-sourced CQRS with @event-driven-io/emmett
 - Language: TypeScript with type-graphql
-- Sliced structure: Command, Reaction, Query slices
+- Structured moments: Command, Reaction, Query moments
 - Each slice has scaffolded files with implementation instructions marked with comments or TODOs
 
 ## 2. TASK

package/src/utils/buildContextSections.specs.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { buildContextSections } from './buildContextSections';
 
 describe('buildContextSections', () => {
-  it('separates shared files, slice files, and spec files into labeled sections', () => {
+  it('separates shared files, moment files, and spec files into labeled sections', () => {
     const context: Record<string, string> = {
       'decide.ts': 'export function decide() {}',
       'state.ts': 'export type State = {}',
@@ -20,7 +20,7 @@ describe('buildContextSections', () => {
         'export type Foo = string;',
         '',
         '---',
-        '🧠 Other files in the same slice:',
+        '🧠 Other files in the same moment:',
         '// File: state.ts',
         'export type State = {}',
         '',
@@ -41,7 +41,7 @@ describe('buildContextSections', () => {
     const result = buildContextSections('decide.ts', context);
 
     expect(result).toBe(
-      ['---', '🧠 Other files in the same slice:', '// File: state.ts', 'export type State = {}'].join('\n'),
+      ['---', '🧠 Other files in the same moment:', '// File: state.ts', 'export type State = {}'].join('\n'),
     );
   });
 
@@ -62,7 +62,7 @@ describe('buildContextSections', () => {
         'export type Foo = string;',
         '',
         '---',
-        '🧠 Other files in the same slice:',
+        '🧠 Other files in the same moment:',
         '// File: evolve.ts',
         'export function evolve() {}',
       ].join('\n'),
@@ -88,14 +88,14 @@ describe('buildContextSections', () => {
         'Use Status.ACTIVE not "active"',
         '',
         '---',
-        '🧠 Other files in the same slice:',
+        '🧠 Other files in the same moment:',
         '// File: evolve.ts',
         'export function evolve() {}',
       ].join('\n'),
     );
   });
 
-  it('excludes target file from slice files section', () => {
+  it('excludes target file from moment files section', () => {
     const context: Record<string, string> = {
       'decide.ts': 'export function decide() {}',
       'evolve.ts': 'export function evolve() {}',

package/src/utils/buildContextSections.ts

@@ -5,7 +5,7 @@ export function buildContextSections(
 ): string {
   const sharedFiles = Object.entries(context).filter(([name]) => name.startsWith('shared/'));
   const specs = Object.entries(context).filter(([name]) => name.endsWith('.specs.ts'));
-  const sliceFiles = Object.entries(context).filter(
+  const momentFiles = Object.entries(context).filter(
     ([name]) => name !== targetFile && !name.startsWith('shared/') && !name.endsWith('.specs.ts'),
   );
 
@@ -18,8 +18,8 @@ export function buildContextSections(
     result += '\n\n';
   }
 
-  result += `---\n🧠 Other files in the same slice:\n`;
-  result += sliceFiles.map(([name, content]) => `// File: ${name}\n${content}`).join('\n\n');
+  result += `---\n🧠 Other files in the same moment:\n`;
+  result += momentFiles.map(([name, content]) => `// File: ${name}\n${content}`).join('\n\n');
 
   if (specs.length > 0) {
     result += `\n\n---\n🧪 Test specifications (READ-ONLY reference):\n`;

package/src/utils/loadContextFiles.specs.ts

@@ -5,26 +5,26 @@ import { loadContextFiles } from './loadContextFiles';
 
 describe('loadContextFiles', () => {
   let tmpDir: string;
-  let sliceDir: string;
+  let momentDir: string;
   let sharedDir: string;
 
   beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(import.meta.dirname, '.tmp-'));
     sharedDir = path.join(tmpDir, 'shared');
-    sliceDir = path.join(tmpDir, 'src', 'slices', 'some-slice');
-    await fs.mkdir(sliceDir, { recursive: true });
+    momentDir = path.join(tmpDir, 'src', 'moments', 'some-moment');
+    await fs.mkdir(momentDir, { recursive: true });
   });
 
   afterEach(async () => {
     await fs.rm(tmpDir, { recursive: true, force: true });
   });
 
-  it('loads all .ts files from slice directory including specs', async () => {
-    await fs.writeFile(path.join(sliceDir, 'decide.ts'), 'export function decide() {}');
-    await fs.writeFile(path.join(sliceDir, 'state.ts'), 'export type State = {}');
-    await fs.writeFile(path.join(sliceDir, 'decide.specs.ts'), 'it("works", () => {})');
+  it('loads all .ts files from moment directory including specs', async () => {
+    await fs.writeFile(path.join(momentDir, 'decide.ts'), 'export function decide() {}');
+    await fs.writeFile(path.join(momentDir, 'state.ts'), 'export type State = {}');
+    await fs.writeFile(path.join(momentDir, 'decide.specs.ts'), 'it("works", () => {})');
 
-    const result = await loadContextFiles(sliceDir);
+    const result = await loadContextFiles(momentDir);
 
     expect(result).toEqual({
       'decide.ts': 'export function decide() {}',
@@ -35,10 +35,10 @@ describe('loadContextFiles', () => {
 
   it('integrates shared context files with real filenames', async () => {
     await fs.mkdir(sharedDir, { recursive: true });
-    await fs.writeFile(path.join(sliceDir, 'decide.ts'), 'export function decide() {}');
+    await fs.writeFile(path.join(momentDir, 'decide.ts'), 'export function decide() {}');
     await fs.writeFile(path.join(sharedDir, 'types.ts'), 'export type Foo = string;');
 
-    const result = await loadContextFiles(sliceDir);
+    const result = await loadContextFiles(momentDir);
 
     expect(result).toEqual({
       'decide.ts': 'export function decide() {}',
@@ -46,8 +46,8 @@ describe('loadContextFiles', () => {
     });
   });
 
-  it('returns empty record for empty slice directory', async () => {
-    const result = await loadContextFiles(sliceDir);
+  it('returns empty record for empty moment directory', async () => {
+    const result = await loadContextFiles(momentDir);
 
     expect(result).toEqual({});
   });

package/src/utils/loadContextFiles.ts

@@ -3,13 +3,13 @@ import path from 'node:path';
 import fg from 'fast-glob';
 import { loadSharedContext } from './loadSharedContext';
 
-export async function loadContextFiles(sliceDir: string): Promise<Record<string, string>> {
-  const files = await fg(['*.ts'], { cwd: sliceDir });
+export async function loadContextFiles(momentDir: string): Promise<Record<string, string>> {
+  const files = await fg(['*.ts'], { cwd: momentDir });
   const context: Record<string, string> = {};
   for (const file of files) {
-    context[file] = await readFile(path.join(sliceDir, file), 'utf-8');
+    context[file] = await readFile(path.join(momentDir, file), 'utf-8');
   }
-  const sharedFiles = await loadSharedContext(sliceDir);
+  const sharedFiles = await loadSharedContext(momentDir);
   Object.assign(context, sharedFiles);
   return context;
 }

package/src/utils/loadSharedContext.specs.ts

@@ -5,14 +5,14 @@ import { loadSharedContext } from './loadSharedContext';
 
 describe('loadSharedContext', () => {
   let tmpDir: string;
-  let sliceDir: string;
+  let momentDir: string;
   let sharedDir: string;
 
   beforeEach(async () => {
     tmpDir = await fs.mkdtemp(path.join(import.meta.dirname, '.tmp-'));
     sharedDir = path.join(tmpDir, 'shared');
-    sliceDir = path.join(tmpDir, 'src', 'slices', 'some-slice');
-    await fs.mkdir(sliceDir, { recursive: true });
+    momentDir = path.join(tmpDir, 'src', 'moments', 'some-moment');
+    await fs.mkdir(momentDir, { recursive: true });
   });
 
   afterEach(async () => {
@@ -20,14 +20,14 @@ describe('loadSharedContext', () => {
   });
 
   it('returns empty record when shared directory does not exist', async () => {
-    expect(await loadSharedContext(sliceDir)).toEqual({});
+    expect(await loadSharedContext(momentDir)).toEqual({});
   });
 
   it('returns empty record when shared directory has no .ts files', async () => {
     await fs.mkdir(sharedDir, { recursive: true });
     await fs.writeFile(path.join(sharedDir, 'readme.md'), '# Readme');
 
-    expect(await loadSharedContext(sliceDir)).toEqual({});
+    expect(await loadSharedContext(momentDir)).toEqual({});
   });
 
   it('returns all .ts files from shared directory keyed by real path sorted by name', async () => {
@@ -35,7 +35,7 @@ describe('loadSharedContext', () => {
     await fs.writeFile(path.join(sharedDir, 'types.ts'), 'export type Foo = string;');
     await fs.writeFile(path.join(sharedDir, 'enums.ts'), 'export enum Bar { A = "a" }');
 
-    const result = await loadSharedContext(sliceDir);
+    const result = await loadSharedContext(momentDir);
 
     expect(result).toEqual({
       'shared/enums.ts': 'export enum Bar { A = "a" }',
@@ -47,7 +47,7 @@ describe('loadSharedContext', () => {
     await fs.mkdir(sharedDir, { recursive: true });
     await fs.writeFile(path.join(sharedDir, 'types.ts'), 'export type X = number;');
 
-    const result = await loadSharedContext(sliceDir);
+    const result = await loadSharedContext(momentDir);
 
     expect(result).toEqual({
       'shared/types.ts': 'export type X = number;',

package/src/utils/loadSharedContext.ts

@@ -3,8 +3,8 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import fg from 'fast-glob';
 
-export async function loadSharedContext(sliceDir: string): Promise<Record<string, string>> {
-  const sharedDir = path.resolve(sliceDir, '../../../shared');
+export async function loadSharedContext(momentDir: string): Promise<Record<string, string>> {
+  const sharedDir = path.resolve(momentDir, '../../../shared');
   if (!existsSync(sharedDir)) return {};
 
   const sharedFiles = await fg(['*.ts'], { cwd: sharedDir });