eva4j 1.0.11 → 1.0.13

package/src/commands/generate-kafka-event.js

@@ -8,6 +8,7 @@ const ConfigManager = require('../utils/config-manager');
 const { isEva4jProject, moduleExists } = require('../utils/validator');
 const { toPackagePath, toPascalCase, toCamelCase, toSnakeCase, toKebabCase } = require('../utils/naming');
 const { renderAndWrite, renderTemplate } = require('../utils/template-engine');
+const { parseDomainYaml } = require('../utils/yaml-to-entity');
 
 async function generateKafkaEventCommand(moduleName, eventName) {
   const projectDir = process.cwd();
@@ -51,127 +52,190 @@ async function generateKafkaEventCommand(moduleName, eventName) {
     process.exit(1);
   }
 
-  // Prompt for event name if not provided
-  if (!eventName) {
+  // Try to read domain events declared in domain.yaml for the module
+  let domainEventChoices = [];
+  let domainEventMap = {};
+  const domainYamlPath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName, 'domain.yaml');
+  if (await fs.pathExists(domainYamlPath)) {
+    try {
+      const parsed = await parseDomainYaml(domainYamlPath, packageName, moduleName);
+      parsed.aggregates.forEach(agg => {
+        (agg.domainEvents || []).forEach(event => {
+          domainEventChoices.push({ name: `${event.name} (from ${agg.name} aggregate)`, value: event.name });
+          domainEventMap[event.name] = event;
+        });
+      });
+    } catch (_) {
+      // domain.yaml may not be parseable yet — silently fall back to free text
+    }
+  }
+
+  // ── Resolve list of event names to process ─────────────────────────────
+  let eventNames = [];
+
+  if (eventName) {
+    // Provided via CLI arg → single event
+    eventNames = [eventName];
+  } else if (domainEventChoices.length > 0) {
+    // Interactive multi-select from domain.yaml events
+    const choicesWithAll = [
+      { name: chalk.bold('★  All events'), value: '__all__' },
+      new inquirer.Separator(),
+      ...domainEventChoices,
+      new inquirer.Separator(),
+      { name: 'Custom name (free text)...', value: '__custom__' }
+    ];
+
+    const { selectedEvents } = await inquirer.prompt([
+      {
+        type: 'checkbox',
+        name: 'selectedEvents',
+        message: 'Select domain events to publish via Kafka (space to select, enter to confirm):',
+        choices: choicesWithAll,
+        validate: (input) => input.length > 0 ? true : 'Select at least one event'
+      }
+    ]);
+
+    if (selectedEvents.includes('__all__')) {
+      // Expand to every declared domain event
+      eventNames = domainEventChoices.map(c => c.value);
+    } else if (selectedEvents.includes('__custom__')) {
+      const { customName } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'customName',
+          message: 'Enter event name:',
+          validate: (input) => input && input.trim() !== '' ? true : 'Event name cannot be empty'
+        }
+      ]);
+      eventNames = [customName];
+    } else {
+      eventNames = selectedEvents;
+    }
+  } else {
+    // No domain events in yaml → free-text fallback
     const nameAnswer = await inquirer.prompt([
       {
         type: 'input',
         name: 'eventName',
         message: 'Enter event name:',
-        validate: (input) => {
-          if (!input || input.trim() === '') {
-            return 'Event name cannot be empty';
-          }
-          return true;
-        }
+        validate: (input) => input && input.trim() !== '' ? true : 'Event name cannot be empty'
       }
     ]);
-    eventName = nameAnswer.eventName;
+    eventNames = [nameAnswer.eventName];
   }
 
-  // Normalize event name to PascalCase
-  const normalizedEventName = toPascalCase(eventName);
-  const eventClassName = normalizedEventName.endsWith('Event') 
-    ? normalizedEventName 
-    : `${normalizedEventName}Event`;
-
-  // Check if event already exists
-  const eventPath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName, 'application', 'events', `${eventClassName}.java`);
-  if (await fs.pathExists(eventPath)) {
-    console.error(chalk.red(`❌ Event '${eventClassName}' already exists in module '${moduleName}'`));
-    process.exit(1);
-  }
-
-  // Prompt for event configuration
+  // ── Shared configuration (applies to all selected events) ────────────────
   const answers = await inquirer.prompt([
     {
       type: 'number',
       name: 'partitions',
       message: 'Number of partitions:',
       default: 3,
-      validate: (value) => {
-        if (value < 1) return 'Partitions must be at least 1';
-        return true;
-      }
+      validate: (value) => value >= 1 ? true : 'Partitions must be at least 1'
     },
     {
       type: 'number',
       name: 'replicas',
       message: 'Number of replicas:',
       default: 1,
-      validate: (value) => {
-        if (value < 1) return 'Replicas must be at least 1';
-        return true;
-      }
+      validate: (value) => value >= 1 ? true : 'Replicas must be at least 1'
     }
   ]);
 
   const { partitions, replicas } = answers;
-
-  const spinner = ora('Generating Kafka event...').start();
+  const isBatch = eventNames.length > 1;
+  const spinner = ora(`Generating ${isBatch ? `${eventNames.length} Kafka events` : 'Kafka event'}...`).start();
+  const results = [];
 
   try {
-    // Generate property names
-    const topicNameKebab = toKebabCase(eventName);
-    const topicNameCamel = toCamelCase(eventName);
-    const topicNameSnake = toSnakeCase(eventName).toUpperCase();
-    const topicPropertyKey = topicNameKebab;
-    const topicPropertyValue = topicNameSnake;
-    const topicSpringProperty = `\${topics.${topicNameKebab}}`;
-
-    const context = {
-      packageName,
-      moduleName,
-      modulePascalCase: toPascalCase(moduleName),
-      moduleCamelCase: toCamelCase(moduleName),
-      kafkaMessageBrokerClassName: `${toPascalCase(moduleName)}KafkaMessageBroker`,
-      eventClassName,
-      topicNameSnake,
-      topicNameKebab,
-      topicNameCamel,
-      topicPropertyKey,
-      topicPropertyValue,
-      topicSpringProperty,
-      partitions,
-      replicas
-    };
-
-    // 1. Generate Event Record
-    spinner.text = 'Generating event record...';
-    await generateEventRecord(projectDir, packagePath, context);
-
-    // 2. Update kafka.yaml files
-    spinner.text = 'Updating kafka.yaml configuration...';
-    await updateKafkaYml(projectDir, topicPropertyKey, topicPropertyValue);
-
-    // 3. Create/Update MessageBroker interface
-    spinner.text = 'Updating MessageBroker interface...';
-    await createOrUpdateMessageBroker(projectDir, packagePath, context);
-
-    // 4. Create/Update KafkaMessageBroker implementation
-    spinner.text = 'Updating KafkaMessageBroker implementation...';
-    await createOrUpdateKafkaMessageBroker(projectDir, packagePath, context);
-
-    // 5. Update KafkaConfig with NewTopic bean
-    spinner.text = 'Updating KafkaConfig...';
-    await updateKafkaConfig(projectDir, packagePath, context);
-
-    spinner.succeed(chalk.green('Kafka event generated successfully! ✨'));
+    for (const name of eventNames) {
+      const normalizedName = toPascalCase(name);
+      const evtClassName = normalizedName.endsWith('Event') ? normalizedName : `${normalizedName}Event`;
+
+      // In batch mode skip already-existing events; in single mode abort
+      const evtPath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName, 'application', 'events', `${evtClassName}.java`);
+      if (await fs.pathExists(evtPath)) {
+        if (isBatch) {
+          results.push({ name: evtClassName, skipped: true });
+          continue;
+        } else {
+          spinner.fail();
+          console.error(chalk.red(`❌ Event '${evtClassName}' already exists in module '${moduleName}'`));
+          process.exit(1);
+        }
+      }
 
+      const topicNameKebab = toKebabCase(name);
+      const topicNameCamel = toCamelCase(name);
+      const topicNameSnake = toSnakeCase(name).toUpperCase();
+      const topicSpringProperty = `\${topics.${topicNameKebab}}`;
+      const selectedDomainEvent = domainEventMap[normalizedName] || null;
+
+      const context = {
+        packageName,
+        moduleName,
+        modulePascalCase: toPascalCase(moduleName),
+        moduleCamelCase: toCamelCase(moduleName),
+        kafkaMessageBrokerClassName: `${toPascalCase(moduleName)}KafkaMessageBroker`,
+        eventClassName: evtClassName,
+        topicNameSnake,
+        topicNameKebab,
+        topicNameCamel,
+        topicPropertyKey: topicNameKebab,
+        topicPropertyValue: topicNameSnake,
+        topicSpringProperty,
+        partitions,
+        replicas,
+        eventFields: selectedDomainEvent ? selectedDomainEvent.fields : null
+      };
+
+      if (isBatch) spinner.text = `[${results.length + 1}/${eventNames.length}] Generating ${evtClassName}...`;
+
+      await generateSingleKafkaEvent(projectDir, packagePath, context);
+      results.push({ name: evtClassName, skipped: false, handlerUpdated: context._handlerUpdated });
+    }
+
+    const generated = results.filter(r => !r.skipped);
+    spinner.succeed(chalk.green(`${isBatch ? `${generated.length} Kafka events` : 'Kafka event'} generated successfully! ✨`));
+
+    const kafkaMessageBrokerClass = `${toPascalCase(moduleName)}KafkaMessageBroker`;
     console.log(chalk.blue('\n📦 Generated/Updated components:'));
-    console.log(chalk.gray(`  ├── ${moduleName}/application/events/${eventClassName}.java`));
+    results.forEach((r) => {
+      if (r.skipped) {
+        console.log(chalk.yellow(`  ├── ${moduleName}/application/events/${r.name}.java (skipped — already exists)`));
+      } else {
+        console.log(chalk.gray(`  ├── ${moduleName}/application/events/${r.name}.java`));
+      }
+    });
     console.log(chalk.gray(`  ├── ${moduleName}/application/ports/MessageBroker.java`));
-    console.log(chalk.gray(`  ├── ${moduleName}/infrastructure/adapters/kafkaMessageBroker/${context.kafkaMessageBrokerClassName}.java`));
+    console.log(chalk.gray(`  ├── ${moduleName}/infrastructure/adapters/kafkaMessageBroker/${kafkaMessageBrokerClass}.java`));
     console.log(chalk.gray(`  ├── shared/configurations/kafkaConfig/KafkaConfig.java`));
+    if (results.some(r => r.handlerUpdated)) {
+      console.log(chalk.gray(`  ├── ${moduleName}/application/usecases/*DomainEventHandler.java`));
+    }
     console.log(chalk.gray('  └── parameters/*/kafka.yaml (all environments)'));
-    
-    console.log(chalk.blue('\n✅ Kafka event configured successfully!'));
-    console.log(chalk.white(`\n   Event: ${eventClassName}`));
-    console.log(chalk.white(`   Topic: ${topicPropertyValue} (${topicNameKebab})`));
-    console.log(chalk.white(`   Partitions: ${partitions}`));
-    console.log(chalk.white(`   Replicas: ${replicas}`));
-    console.log(chalk.gray('\n   You can now inject MessageBroker in your services and call:'));
-    console.log(chalk.gray(`   messageBroker.publish${eventClassName}(event);\n`));
+
+    if (!isBatch && generated.length === 1) {
+      const r = generated[0];
+      const topicSnake = toSnakeCase(eventNames[0]).toUpperCase();
+      const topicKebab = toKebabCase(eventNames[0]);
+      console.log(chalk.blue('\n✅ Kafka event configured successfully!'));
+      console.log(chalk.white(`\n   Event: ${r.name}`));
+      console.log(chalk.white(`   Topic: ${topicSnake} (${topicKebab})`));
+      console.log(chalk.white(`   Partitions: ${partitions}`));
+      console.log(chalk.white(`   Replicas: ${replicas}`));
+      console.log(chalk.gray('\n   You can now inject MessageBroker in your services and call:'));
+      console.log(chalk.gray(`   messageBroker.publish${r.name}(event);\n`));
+    } else {
+      console.log(chalk.blue('\n✅ All Kafka events configured successfully!'));
+      console.log(chalk.white(`\n   Partitions: ${partitions}  |  Replicas: ${replicas}`));
+      if (generated.length > 0) {
+        console.log(chalk.gray('\n   Available MessageBroker methods:'));
+        generated.forEach(r => console.log(chalk.gray(`   messageBroker.publish${r.name}(event);`)));
+      }
+      console.log('');
+    }
 
   } catch (error) {
     spinner.fail(chalk.red('Failed to generate Kafka event'));
@@ -183,6 +247,19 @@ async function generateKafkaEventCommand(moduleName, eventName) {
   }
 }
 
+/**
+ * Run the full generation pipeline for a single event.
+ * Mutates context._handlerUpdated to signal whether the DomainEventHandler was wired.
+ */
+async function generateSingleKafkaEvent(projectDir, packagePath, context) {
+  await generateEventRecord(projectDir, packagePath, context);
+  await updateKafkaYml(projectDir, context.topicPropertyKey, context.topicPropertyValue);
+  await createOrUpdateMessageBroker(projectDir, packagePath, context);
+  await createOrUpdateKafkaMessageBroker(projectDir, packagePath, context);
+  await updateKafkaConfig(projectDir, packagePath, context);
+  context._handlerUpdated = await updateDomainEventHandler(projectDir, packagePath, context);
+}
+
 /**
  * Generate Event Record
  */
@@ -455,4 +532,111 @@ async function updateKafkaConfig(projectDir, packagePath, context) {
   await fs.writeFile(configPath, content, 'utf-8');
 }
 
+/**
+ * Update DomainEventHandler: inject MessageBroker dependency and replace TODO with real mapping call.
+ * Returns true if the handler was found and updated, false if skipped.
+ */
+async function updateDomainEventHandler(projectDir, packagePath, context) {
+  const handlerDir = path.join(
+    projectDir, 'src', 'main', 'java', packagePath,
+    context.moduleName, 'application', 'usecases'
+  );
+
+  if (!(await fs.pathExists(handlerDir))) {
+    console.log(chalk.yellow(`\n   ⚠️  No usecases directory found — skipping handler update`));
+    console.log(chalk.gray(`      Run 'eva4j g entities ${context.moduleName}' first to generate the DomainEventHandler`));
+    return false;
+  }
+
+  const files = await fs.readdir(handlerDir);
+  const handlerFile = files.find(f => f.endsWith('DomainEventHandler.java'));
+
+  if (!handlerFile) {
+    console.log(chalk.yellow(`\n   ⚠️  DomainEventHandler not found in ${context.moduleName}/application/usecases/ — skipping`));
+    console.log(chalk.gray(`      Run 'eva4j g entities ${context.moduleName}' first`));
+    return false;
+  }
+
+  const handlerPath = path.join(handlerDir, handlerFile);
+  const handlerClassName = handlerFile.replace('.java', '');
+  let content = await fs.readFile(handlerPath, 'utf-8');
+
+  // Idempotency: bail if the publish call is already there
+  if (content.includes(`publish${context.eventClassName}`)) {
+    return false;
+  }
+
+  // Compute domain event name by stripping 'Event' suffix from eventClassName
+  // e.g. OrderPlacedEvent → OrderPlaced
+  const domainEventName = context.eventClassName.endsWith('Event')
+    ? context.eventClassName.slice(0, -'Event'.length)
+    : context.eventClassName;
+
+  // Guard: the TODO comment must exist (generated by g entities)
+  if (!content.includes(`// TODO: handle ${domainEventName}`)) {
+    console.log(chalk.yellow(`\n   ⚠️  No TODO handler found for '${domainEventName}' in ${handlerFile} — skipping`));
+    return false;
+  }
+
+  // 1. Inject import for the application-layer event record
+  const eventImport = `import ${context.packageName}.${context.moduleName}.application.events.${context.eventClassName};`;
+  if (!content.includes(eventImport)) {
+    content = injectImportIntoFile(content, eventImport);
+  }
+
+  // 2. Inject import for the MessageBroker port
+  const brokerImport = `import ${context.packageName}.${context.moduleName}.application.ports.MessageBroker;`;
+  if (!content.includes(brokerImport)) {
+    content = injectImportIntoFile(content, brokerImport);
+  }
+
+  // 3. Inject field + constructor if MessageBroker is not yet present
+  if (!content.includes('private final MessageBroker messageBroker;')) {
+    const classPattern = /(public\s+class\s+\w+DomainEventHandler\s*\{\s*\n)/;
+    const classMatch = content.match(classPattern);
+    if (classMatch) {
+      const insertPos = classMatch.index + classMatch[0].length;
+      const fieldAndCtor =
+        `\n    private final MessageBroker messageBroker;\n` +
+        `\n    public ${handlerClassName}(MessageBroker messageBroker) {\n` +
+        `        this.messageBroker = messageBroker;\n` +
+        `    }\n`;
+      content = content.slice(0, insertPos) + fieldAndCtor + content.slice(insertPos);
+    }
+  }
+
+  // 4. Render the mapping call and replace the TODO block
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'kafka-event', 'DomainEventHandlerMethod.ejs');
+  const mappingLine = await renderTemplate(templatePath, { ...context, domainEventFields: context.eventFields });
+
+  const todoRegex = new RegExp(
+    `([ \\t]*\/\/ TODO: handle ${domainEventName}[^\\n]*\\n)(?:[ \\t]*\/\/[^\\n]*\\n)*`
+  );
+  content = content.replace(todoRegex, `        ${mappingLine.trim()}\n`);
+
+  await fs.writeFile(handlerPath, content, 'utf-8');
+  return true;
+}
+
+/**
+ * Injects an import statement after the last existing import, or after the package declaration.
+ */
+function injectImportIntoFile(content, importStatement) {
+  const packageMatch = content.match(/(package\s+[\w.]+;\s*\n)/);
+  if (!packageMatch) return content;
+
+  const hasImports = /import\s+[\w.]+;/.test(content);
+  if (hasImports) {
+    const imports = content.matchAll(/import\s+[\w.]+;\s*\n/g);
+    let lastImportEnd = packageMatch.index + packageMatch[0].length;
+    for (const match of imports) {
+      lastImportEnd = match.index + match[0].length;
+    }
+    return content.slice(0, lastImportEnd) + importStatement + '\n' + content.slice(lastImportEnd);
+  } else {
+    const insertPos = packageMatch.index + packageMatch[0].length;
+    return content.slice(0, insertPos) + '\n' + importStatement + '\n' + content.slice(insertPos);
+  }
+}
+
 module.exports = generateKafkaEventCommand;

package/src/commands/generate-temporal-activity.js

@@ -0,0 +1,228 @@
+const inquirer = require('inquirer');
+const ora = require('ora');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const ConfigManager = require('../utils/config-manager');
+const { isEva4jProject, moduleExists } = require('../utils/validator');
+const { toPackagePath, toPascalCase } = require('../utils/naming');
+const { renderAndWrite } = require('../utils/template-engine');
+const ChecksumManager = require('../utils/checksum-manager');
+
+async function generateTemporalActivityCommand(moduleName, activityName, options = {}) {
+  const projectDir = process.cwd();
+
+  if (!(await isEva4jProject(projectDir))) {
+    console.error(chalk.red('❌ Not in an eva4j project directory'));
+    console.error(chalk.gray('Run this command inside a project created with eva4j'));
+    process.exit(1);
+  }
+
+  const configManager = new ConfigManager(projectDir);
+
+  if (!(await configManager.featureExists('temporal'))) {
+    console.error(chalk.red('❌ Temporal client is not installed in this project'));
+    console.error(chalk.gray('Install Temporal first using: eva add temporal-client'));
+    process.exit(1);
+  }
+
+  if (!moduleName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'moduleName',
+      message: 'Module name:',
+      validate: (v) => (v.trim() ? true : 'Module name is required'),
+    }]);
+    moduleName = answer.moduleName.trim();
+  }
+
+  const projectConfig = await configManager.loadProjectConfig();
+  if (!projectConfig) {
+    console.error(chalk.red('❌ Could not load project configuration'));
+    console.error(chalk.gray('Make sure .eva4j.json exists in the project root'));
+    process.exit(1);
+  }
+
+  const { packageName } = projectConfig;
+  const packagePath = toPackagePath(packageName);
+
+  if (!(await configManager.moduleExists(moduleName))) {
+    console.error(chalk.red(`❌ Module '${moduleName}' does not exist`));
+    console.error(chalk.gray(`Create it first using: eva add module ${moduleName}`));
+    process.exit(1);
+  }
+
+  if (!(await moduleExists(projectDir, packagePath, moduleName))) {
+    console.error(chalk.red(`❌ Module directory for '${moduleName}' not found`));
+    process.exit(1);
+  }
+
+  // 1. Prompt activity name
+  if (!activityName) {
+    const answer = await inquirer.prompt([{
+      type: 'input',
+      name: 'activityName',
+      message: 'Activity name (e.g. register-order, ValidatePayment):',
+      validate: (v) => (v.trim() ? true : 'Activity name is required'),
+    }]);
+    activityName = answer.activityName.trim();
+  }
+
+  const activityPascalCase = toPascalCase(activityName);
+
+  // 2. Prompt activity category
+  const { activityCategory } = await inquirer.prompt([{
+    type: 'list',
+    name: 'activityCategory',
+    message: 'Activity category:',
+    choices: [
+      { name: 'LightActivity  (fast, low-resource tasks)', value: 'LightActivity' },
+      { name: 'HeavyActivity  (long-running, resource-intensive tasks)', value: 'HeavyActivity' },
+    ],
+  }]);
+
+  // 3. Discover existing workflows across all modules
+  const javaRoot = path.join(projectDir, 'src', 'main', 'java', packagePath);
+  const workflows = await findExistingWorkflows(javaRoot);
+
+  if (workflows.length === 0) {
+    console.error(chalk.red('❌ No workflows found in this project'));
+    console.error(chalk.gray('Create a workflow first using: eva generate temporal-flow <module>'));
+    process.exit(1);
+  }
+
+  const { selectedWorkflow } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selectedWorkflow',
+    message: 'Register activity in workflow:',
+    choices: workflows.map((w) => ({ name: `${w.moduleName} / ${w.implClass}`, value: w })),
+  }]);
+
+  const moduleBasePath = path.join(projectDir, 'src', 'main', 'java', packagePath, moduleName);
+  const checksumManager = new ChecksumManager(moduleBasePath);
+  await checksumManager.load();
+
+  const spinner = ora(`Generating ${activityPascalCase}Activity...`).start();
+
+  try {
+    const context = { packageName, moduleName, activityPascalCase, activityCategory };
+    const templatesDir = path.join(__dirname, '..', '..', 'templates', 'temporal-activity');
+    const writeOptions = { force: options.force, checksumManager };
+
+    // 4. Generate ActivityInterface in application/ports/
+    spinner.text = `Generating ${activityPascalCase}Activity interface...`;
+    await renderAndWrite(
+      path.join(templatesDir, 'ActivityInterface.java.ejs'),
+      path.join(moduleBasePath, 'application', 'ports', `${activityPascalCase}Activity.java`),
+      context,
+      writeOptions
+    );
+
+    // 5. Generate ActivityImpl in infrastructure/adapters/activities/
+    spinner.text = `Generating ${activityPascalCase}ActivityImpl...`;
+    await renderAndWrite(
+      path.join(templatesDir, 'ActivityImpl.java.ejs'),
+      path.join(moduleBasePath, 'infrastructure', 'adapters', 'activities', `${activityPascalCase}ActivityImpl.java`),
+      context,
+      writeOptions
+    );
+
+    // 6. Register activity stub in selected WorkFlowImpl
+    spinner.text = `Registering activity in ${selectedWorkflow.implClass}...`;
+    await registerActivityInWorkflow(
+      selectedWorkflow.filePath,
+      packageName,
+      moduleName,
+      activityPascalCase,
+      activityCategory
+    );
+
+    spinner.succeed(chalk.green(`✅ ${activityPascalCase}Activity generated successfully`));
+
+    console.log(chalk.blue('\n📁 Generated files:'));
+    console.log(chalk.gray(`  ${moduleName}/application/ports/${activityPascalCase}Activity.java`));
+    console.log(chalk.gray(`  ${moduleName}/infrastructure/adapters/activities/${activityPascalCase}ActivityImpl.java`));
+    console.log(chalk.blue('\n📝 Updated files:'));
+    console.log(chalk.gray(`  ${selectedWorkflow.moduleName}/application/usecases/${selectedWorkflow.implClass}.java`));
+
+    await checksumManager.save();
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to generate temporal activity'));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function findExistingWorkflows(javaRoot) {
+  const results = [];
+  if (!(await fs.pathExists(javaRoot))) return results;
+
+  const modules = await fs.readdir(javaRoot);
+  for (const mod of modules) {
+    const usecasesDir = path.join(javaRoot, mod, 'application', 'usecases');
+    if (!(await fs.pathExists(usecasesDir))) continue;
+    const files = await fs.readdir(usecasesDir);
+    for (const file of files) {
+      if (file.endsWith('WorkFlowImpl.java')) {
+        results.push({
+          moduleName: mod,
+          implClass: file.replace('.java', ''),
+          filePath: path.join(usecasesDir, file),
+        });
+      }
+    }
+  }
+  return results;
+}
+
+async function registerActivityInWorkflow(workflowImplPath, packageName, moduleName, activityPascalCase, activityCategory) {
+  if (!(await fs.pathExists(workflowImplPath))) return;
+
+  let content = await fs.readFile(workflowImplPath, 'utf-8');
+
+  const activityInterface = `${activityPascalCase}Activity`;
+  const activityField = `${activityPascalCase.charAt(0).toLowerCase()}${activityPascalCase.slice(1)}Activity`;
+  const importLine = `import ${packageName}.${moduleName}.application.ports.${activityInterface};`;
+  const optionsVar = activityCategory === 'HeavyActivity' ? 'heavyActivityOptions' : 'lightActivityOptions';
+  const fieldLine = `    private final ${activityInterface} ${activityField} = Workflow.newActivityStub(${activityInterface}.class, ${optionsVar});`;
+
+  // Skip if already registered
+  if (content.includes(fieldLine)) return;
+
+  // Add import after last import line
+  if (!content.includes(importLine)) {
+    const allImports = [...content.matchAll(/^import .+;/gm)];
+    if (allImports.length > 0) {
+      const lastImport = allImports[allImports.length - 1];
+      const insertPos = lastImport.index + lastImport[0].length;
+      content = content.slice(0, insertPos) + '\n' + importLine + content.slice(insertPos);
+    }
+  }
+
+  // Insert field after last activityOptions block (or append after last existing stub)
+  const activityOptionsRegex = /(private final ActivityOptions heavyActivityOptions = ActivityOptions\.newBuilder\(\)[\s\S]*?\.build\(\)\s*\)\.build\(\);)/;
+  if (content.includes('//register activities')) {
+    // Append after the last existing activity stub
+    const lastStubRegex = /(private final \w+Activity \w+Activity = Workflow\.newActivityStub\([^;]+;)/g;
+    const allStubs = [...content.matchAll(lastStubRegex)];
+    if (allStubs.length > 0) {
+      const lastStub = allStubs[allStubs.length - 1];
+      const insertPos = lastStub.index + lastStub[0].length;
+      content = content.slice(0, insertPos) + '\n' + fieldLine + content.slice(insertPos);
+    }
+  } else if (activityOptionsRegex.test(content)) {
+    content = content.replace(activityOptionsRegex, (match) => {
+      return match + '\n\n    //register activities\n' + fieldLine;
+    });
+  } else {
+    // Fallback: insert before the first @Override
+    content = content.replace(
+      /( {4}@Override)/,
+      `    //register activities\n${fieldLine}\n\n$1`
+    );
+  }
+
+  await fs.writeFile(workflowImplPath, content, 'utf-8');
+}
+
+module.exports = generateTemporalActivityCommand;