motia 0.0.21 → 0.0.23

package/dist/src/cli.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const defaultPort = 3000;
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('dotenv/config');
@@ -94,4 +95,34 @@ commander_1.program
         process.exit(1);
     }
 });
+const generate = commander_1.program.command('generate').description('Generate motia resources');
+generate
+    .command('step')
+    .description('Create a new step with interactive prompts')
+    .option('-d, --dir <step file path>', 'The path relative to the steps directory, used to create the step file')
+    .action(async (arg) => {
+    const { createStep } = require('./create-step'); // eslint-disable-line @typescript-eslint/no-require-imports
+    await createStep({
+        stepFilePath: arg.dir,
+    });
+});
+const state = commander_1.program.command('state').description('Manage application state');
+state
+    .command('list')
+    .description('List the current file state')
+    .action(async () => {
+    try {
+        const statePath = path_1.default.join(process.cwd(), '.motia', 'motia.state.json');
+        if (!fs_1.default.existsSync(statePath)) {
+            console.error('Error: State file not found at', statePath);
+            process.exit(1);
+        }
+        const state = require(statePath); // eslint-disable-line @typescript-eslint/no-require-imports
+        console.log(JSON.stringify(state, null, 2));
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+});
 commander_1.program.parse(process.argv);

package/dist/src/create/index.js

@@ -62,8 +62,8 @@ const installRequiredDependencies = async (packageManager, rootDir) => {
         yarn: 'yarn add',
         pnpm: 'pnpm add',
     }[packageManager];
-    const dependencies = ['@motiadev/core', 'motia', '@motiadev/workbench', 'zod'].join(' ');
-    const devDependencies = ['ts-node@^10.9.2', 'typescript@^5.7.3'].join(' ');
+    const dependencies = ['@motiadev/core', 'motia', '@motiadev/workbench', 'zod', 'react@^19.0.0'].join(' ');
+    const devDependencies = ['ts-node@^10.9.2', 'typescript@^5.7.3', '@types/react@^18.3.18'].join(' ');
     try {
         await executeCommand(`${installCommand} ${dependencies}`, rootDir);
         await executeCommand(`${installCommand} -D ${devDependencies}`, rootDir);

package/dist/src/create-step/getAnswers.js

@@ -0,0 +1,171 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStepAnswers = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const colors_1 = __importDefault(require("colors"));
+const types_1 = require("./types");
+const getStepAnswers = async () => {
+    console.log('\n📝 ', colors_1.default.bold('Create a new Motia step\n'));
+    // Basic information prompts
+    const basicInfo = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Step name:',
+            validate: (input) => {
+                if (input.length === 0)
+                    return 'Name is required';
+                if (!/^[a-zA-Z][a-zA-Z0-9-_]*$/.test(input)) {
+                    return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'list',
+            name: 'type',
+            message: 'Select step type:',
+            choices: types_1.STEP_TYPES.map((type) => ({
+                name: type.toUpperCase(),
+                value: type,
+            })),
+        },
+    ]);
+    let answers = { ...basicInfo };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const languageAnswer = {
+        type: 'list',
+        name: 'language',
+        message: 'Select language:',
+        choices: types_1.LANGUAGES.map((lang) => ({
+            name: lang.charAt(0).toUpperCase() + lang.slice(1),
+            value: lang,
+        })),
+    };
+    // Type-specific configuration prompts
+    if (answers.type === 'api') {
+        const apiConfig = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'method',
+                message: 'HTTP method:',
+                choices: types_1.HTTP_METHODS,
+            },
+            {
+                type: 'input',
+                name: 'path',
+                message: 'API path (e.g. /users):',
+                validate: (input) => {
+                    if (!input.startsWith('/'))
+                        return 'Path must start with /';
+                    return true;
+                },
+            },
+        ]);
+        answers = { ...answers, ...apiConfig };
+    }
+    else if (answers.type === 'event') {
+        const eventConfig = await inquirer_1.default.prompt([
+            languageAnswer,
+            {
+                type: 'input',
+                name: 'subscriptions',
+                message: 'Event subscriptions (comma-separated):',
+                filter: (input) => input
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+            },
+        ]);
+        answers = { ...answers, ...eventConfig };
+    }
+    else if (answers.type === 'cron') {
+        const cronConfig = await inquirer_1.default.prompt([
+            languageAnswer,
+            {
+                type: 'input',
+                name: 'cronExpression',
+                message: 'Cron expression:',
+                validate: (input) => {
+                    if (!input)
+                        return 'Cron expression is required';
+                    const parts = input.split(' ');
+                    if (parts.length !== 5)
+                        return 'Invalid cron expression format';
+                    return true;
+                },
+            },
+        ]);
+        answers = { ...answers, ...cronConfig };
+    }
+    else if (answers.type === 'noop') {
+        const noopConfig = await inquirer_1.default.prompt([
+            languageAnswer,
+            {
+                type: 'input',
+                name: 'virtualEmits',
+                message: 'Virtual emits (comma-separated):',
+                filter: (input) => input
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+            },
+            {
+                type: 'input',
+                name: 'virtualSubscribes',
+                message: 'Virtual subscribes (comma-separated):',
+                filter: (input) => input
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean),
+            },
+        ]);
+        answers = { ...answers, ...noopConfig };
+    }
+    // Common configuration prompts
+    const commonConfig = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'flows',
+            message: 'Flow names (comma-separated):',
+            filter: (input) => input
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+            validate: (input) => {
+                if (input.length === 0)
+                    return 'At least one flow is required';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'emits',
+            message: 'Events to emit (comma-separated):',
+            filter: (input) => input
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean),
+        },
+        {
+            type: 'input',
+            name: 'description',
+            message: 'Step description:',
+        },
+        {
+            type: 'confirm',
+            name: 'createOverride',
+            message: 'Create UI component override?',
+            default: false,
+        },
+    ]);
+    const nextAnswers = { ...answers, ...commonConfig };
+    return {
+        ...nextAnswers,
+        language: nextAnswers.type === 'api' ? 'typescript' : nextAnswers.language,
+    };
+};
+exports.getStepAnswers = getStepAnswers;

package/dist/src/create-step/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStep = createStep;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const colors_1 = __importDefault(require("colors"));
+const teamplateUtils_1 = require("./teamplateUtils");
+const overrides_1 = require("./templates/ui/overrides");
+const getAnswers_1 = require("./getAnswers");
+const utils_1 = require("./utils");
+async function createStep(options) {
+    try {
+        const answers = await (0, getAnswers_1.getStepAnswers)();
+        // Create steps directory if it doesn't exist
+        const stepDir = path_1.default.join(process.cwd(), 'steps', options?.stepFilePath || '');
+        if (!fs_1.default.existsSync(stepDir)) {
+            fs_1.default.mkdirSync(stepDir, { recursive: true });
+        }
+        // Create step file
+        const extension = (0, utils_1.getFileExtension)(answers.language);
+        const stepPath = path_1.default.join(stepDir, `${answers.name}${answers.type === 'api' ? '.api' : ''}.step${extension}`);
+        // Check if file already exists
+        if (fs_1.default.existsSync(stepPath)) {
+            console.error(colors_1.default.red(`\n❌ Error: Step file already exists at ${stepPath}`));
+            process.exit(1);
+        }
+        // Generate and write step file
+        const stepContent = await (0, teamplateUtils_1.generateTemplate)(answers);
+        fs_1.default.writeFileSync(stepPath, stepContent);
+        console.log(colors_1.default.green(`\n✨ Created step file at ${stepPath}`));
+        // Create UI override if requested
+        if (answers.createOverride) {
+            const overridePath = path_1.default.join(stepDir, `${answers.name}.step.tsx`);
+            const overrideContent = await (0, overrides_1.generateOverride)(answers);
+            fs_1.default.writeFileSync(overridePath, overrideContent);
+            console.log(colors_1.default.green(`✨ Created UI override at ${overridePath}`));
+        }
+        console.log(colors_1.default.bold('\n🎉 Step creation complete!'));
+    }
+    catch (error) {
+        console.error(colors_1.default.red('\n❌ Error creating step:'), error);
+        process.exit(1);
+    }
+}

package/dist/src/create-step/teamplateUtils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplate = generateTemplate;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Reads a template file and replaces variables
+ */
+async function readTemplate(templatePath, answers) {
+    const content = await fs_1.promises.readFile(templatePath, 'utf8');
+    return replaceTemplateVariables(content, answers);
+}
+/**
+ * Replaces template variables with actual values
+ */
+function replaceTemplateVariables(content, answers) {
+    const replacements = {
+        STEP_NAME: answers.name,
+        DESCRIPTION: answers.description || '',
+        FLOWS: JSON.stringify(answers.flows),
+        EMITS: JSON.stringify(answers.emits),
+        METHOD: answers.method || '',
+        PATH: answers.path || '',
+        SUBSCRIPTIONS: JSON.stringify(answers.subscriptions || []),
+        CRON_EXPRESSION: answers.cronExpression || '',
+        VIRTUAL_EMITS: JSON.stringify(answers.virtualEmits || []),
+        VIRTUAL_SUBSCRIBES: JSON.stringify(answers.virtualSubscribes || []),
+    };
+    return Object.entries(replacements).reduce((content, [key, value]) => {
+        const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        return content.replace(regex, String(value));
+    }, content);
+}
+/**
+ * Generates the appropriate template based on language and type
+ */
+async function generateTemplate(answers) {
+    const templateDir = path_1.default.join(__dirname, 'templates', answers.type);
+    const templateFile = `template.${answers.language}.txt`;
+    const templatePath = path_1.default.join(templateDir, templateFile);
+    try {
+        return await readTemplate(templatePath, answers);
+    }
+    catch (error) {
+        throw new Error(`Failed to generate template: ${error}`);
+    }
+}

package/dist/src/create-step/templates/api/template.javascript.txt

@@ -0,0 +1,25 @@
+const { z } = require('zod')
+
+export const config = {
+  type: 'api',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  path: '{{PATH}}',
+  method: '{{METHOD}}',
+  emits: {{EMITS}},
+  flows: {{FLOWS}},
+  bodySchema: z.object({
+    // Add your schema here
+  })
+}
+
+export const handler = async (req, { logger, emit }) => {
+  logger.info('Processing {{STEP_NAME}}', req)
+
+  // Add your handler logic here
+  
+  return {
+    status: 200,
+    body: { message: 'Success' }
+  }
+}

package/dist/src/create-step/templates/api/template.python.txt

@@ -0,0 +1,19 @@
+config = {
+    "type": "api",
+    "name": "{{STEP_NAME}}",
+    "description": "{{DESCRIPTION}}",
+    "path": "{{PATH}}",
+    "method": "{{METHOD}}",
+    "emits": {{EMITS}},
+    "flows": {{FLOWS}}
+}
+
+async def handler(req, context):
+    context.logger.info("Processing {{STEP_NAME}}", req)
+
+    # Add your handler logic here
+    
+    return {
+        "status": 200,
+        "body": {"message": "Success"}
+    }

package/dist/src/create-step/templates/api/template.ruby.txt

@@ -0,0 +1,22 @@
+def config
+  {
+    type: 'api',
+    name: '{{STEP_NAME}}',
+    description: '{{DESCRIPTION}}',
+    path: '{{PATH}}',
+    method: '{{METHOD}}',
+    emits: {{EMITS}},
+    flows: {{FLOWS}}
+  }
+end
+
+def handler(req, context)
+  context.logger.info('Processing {{STEP_NAME}}', req)
+
+  # Add your handler logic here
+  
+  {
+    status: 200,
+    body: { message: 'Success' }
+  }
+end

package/dist/src/create-step/templates/api/template.typescript.txt

@@ -0,0 +1,26 @@
+import { ApiRouteConfig, StepHandler } from '@motiadev/core'
+import { z } from 'zod'
+
+export const config: ApiRouteConfig = {
+  type: 'api',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  path: '{{PATH}}',
+  method: '{{METHOD}}',
+  emits: {{EMITS}},
+  flows: {{FLOWS}},
+  bodySchema: z.object({
+    // Add your schema here
+  })
+}
+
+export const handler: StepHandler<typeof config> = async (req, { logger, emit }) => {
+  logger.info('Processing {{STEP_NAME}}', req)
+
+  // Add your handler logic here
+  
+  return {
+    status: 200,
+    body: { message: 'Success' }
+  }
+}

package/dist/src/create-step/templates/cron/template.javascript.txt

@@ -0,0 +1,20 @@
+export const config = {
+  type: 'cron',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  cron: '{{CRON_EXPRESSION}}',
+  emits: {{EMITS}},
+  flows: {{FLOWS}}
+}
+
+export const handler = async ({ logger, emit }) => {
+  logger.info('Running {{STEP_NAME}} cron job')
+
+  // Add your cron logic here
+  
+  // Example emit
+  // await emit({
+  //   type: 'event-type',
+  //   data: {}
+  // })
+}

package/dist/src/create-step/templates/cron/template.python.txt

@@ -0,0 +1,19 @@
+config = {
+    "type": "cron",
+    "name": "{{STEP_NAME}}",
+    "description": "{{DESCRIPTION}}",
+    "cron": "{{CRON_EXPRESSION}}",
+    "emits": {{EMITS}},
+    "flows": {{FLOWS}}
+}
+
+async def handler(context):
+    context.logger.info("Running {{STEP_NAME}} cron job")
+
+    # Add your cron logic here
+    
+    # Example emit
+    # await context.emit({
+    #     "type": "event-type",
+    #     "data": {}
+    # })

package/dist/src/create-step/templates/cron/template.ruby.txt

@@ -0,0 +1,22 @@
+def config
+  {
+    type: 'cron',
+    name: '{{STEP_NAME}}',
+    description: '{{DESCRIPTION}}',
+    cron: '{{CRON_EXPRESSION}}',
+    emits: {{EMITS}},
+    flows: {{FLOWS}}
+  }
+end
+
+def handler(context)
+  context.logger.info('Running {{STEP_NAME}} cron job')
+
+  # Add your cron logic here
+  
+  # Example emit
+  # context.emit({
+  #   type: 'event-type',
+  #   data: {}
+  # })
+end

package/dist/src/create-step/templates/cron/template.type.txt

@@ -0,0 +1,22 @@
+import { CronConfig, StepHandler } from '@motiadev/core'
+
+export const config: CronConfig = {
+  type: 'cron',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  cron: '{{CRON_EXPRESSION}}',
+  emits: {{EMITS}},
+  flows: {{FLOWS}}
+}
+
+export const handler: StepHandler<typeof config> = async ({ logger, emit }) => {
+  logger.info('Running {{STEP_NAME}} cron job')
+
+  // Add your cron logic here
+  
+  // Example emit
+  // await emit({
+  //   type: 'event-type',
+  //   data: {}
+  // })
+}

package/dist/src/create-step/templates/cron/template.typescript.txt

@@ -0,0 +1,22 @@
+import { CronConfig, FlowContext } from '@motiadev/core'
+
+export const config = {
+  type: 'cron',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  cron: '{{CRON_EXPRESSION}}',
+  emits: {{EMITS}},
+  flows: {{FLOWS}}
+}
+
+export const handler = async ({ logger, emit }: FlowContext) => {
+  logger.info('Running {{STEP_NAME}} cron job')
+
+  // Add your cron logic here
+  
+  // Example emit
+  // await emit({
+  //   type: 'event-type',
+  //   data: {}
+  // })
+}

package/dist/src/create-step/templates/event/template.javascript.txt

@@ -0,0 +1,27 @@
+const { z } = require('zod')
+
+const inputSchema = z.object({
+  // Add your schema here
+})
+
+export const config = {
+  type: 'event',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  subscribes: {{SUBSCRIPTIONS}},
+  emits: {{EMITS}},
+  input: inputSchema,
+  flows: {{FLOWS}}
+}
+
+export const handler = async (input, { logger, emit }) => {
+  logger.info('Processing {{STEP_NAME}}', input)
+
+  // Add your handler logic here
+  
+  // Example emit
+  // await emit({
+  //   type: 'event-type',
+  //   data: {}
+  // })
+}

package/dist/src/create-step/templates/event/template.python.txt

@@ -0,0 +1,20 @@
+config = {
+    "type": "event",
+    "name": "{{STEP_NAME}}",
+    "description": "{{DESCRIPTION}}",
+    "subscribes": {{SUBSCRIPTIONS}}, 
+    "emits": {{EMITS}},
+    "flows": {{FLOWS}},
+    "input": None,  # No schema validation in Python
+}
+
+async def handler(args, ctx):
+    ctx.logger.info('Processing {{STEP_NAME}}', args)
+
+    # Add your handler logic here
+
+    # Add your handler logic here
+    # await ctx.emit({
+    #   type: 'event-type',
+    #   data: {}
+    # })

package/dist/src/create-step/templates/event/template.ruby.txt

@@ -0,0 +1,22 @@
+def config
+  {
+    type: 'event',
+    name: '{{STEP_NAME}}',
+    description: '{{DESCRIPTION}}',
+    subscribes: {{SUBSCRIPTIONS}},
+    emits: {{EMITS}},
+    flows: {{FLOWS}}
+  }
+end
+
+def handler(input, context)
+  context.logger.info('Processing {{STEP_NAME}}', input)
+
+  # Add your handler logic here
+  
+  # Example emit
+  # context.emit({
+  #   type: 'event-type',
+  #   data: {}
+  # })
+end

package/dist/src/create-step/templates/event/template.typescript.txt

@@ -0,0 +1,30 @@
+import { EventConfig, StepHandler } from '@motiadev/core'
+import { z } from 'zod'
+
+type Input = typeof inputSchema
+
+const inputSchema = z.object({
+  // Add your schema here
+})
+
+export const config: EventConfig = {
+  type: 'event',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  subscribes: {{SUBSCRIPTIONS}},
+  emits: {{EMITS}},
+  input: inputSchema,
+  flows: {{FLOWS}}
+}
+
+export const handler: StepHandler<typeof config> = async (input, { logger, emit }) => {
+  logger.info('Processing {{STEP_NAME}}', input)
+
+  // Add your handler logic here
+  
+  // Example emit
+  // await emit({
+  //   type: 'event-type',
+  //   data: {}
+  // })
+}

package/dist/src/create-step/templates/noop/template.javascript.txt

@@ -0,0 +1,8 @@
+export const config = {
+  type: 'noop',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  virtualEmits: {{VIRTUAL_EMITS}},
+  virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
+  flows: {{FLOWS}}
+}

package/dist/src/create-step/templates/noop/template.python.txt

@@ -0,0 +1,8 @@
+config = {
+    "type": "noop",
+    "name": "{{STEP_NAME}}",
+    "description": "{{DESCRIPTION}}",
+    "virtualEmits": {{VIRTUAL_EMITS}},
+    "virtualSubscribes": {{VIRTUAL_SUBSCRIBES}},
+    "flows": {{FLOWS}}
+}

package/dist/src/create-step/templates/noop/template.ruby.txt

@@ -0,0 +1,10 @@
+def config
+  {
+    type: 'noop',
+    name: '{{STEP_NAME}}',
+    description: '{{DESCRIPTION}}',
+    virtualEmits: {{VIRTUAL_EMITS}},
+    virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
+    flows: {{FLOWS}}
+  }
+end

package/dist/src/create-step/templates/noop/template.typescript.txt

@@ -0,0 +1,10 @@
+import { NoopConfig } from '@motiadev/core'
+
+export const config: NoopConfig = {
+  type: 'noop',
+  name: '{{STEP_NAME}}',
+  description: '{{DESCRIPTION}}',
+  virtualEmits: {{VIRTUAL_EMITS}},
+  virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
+  flows: {{FLOWS}}
+}

package/dist/src/create-step/templates/ui/api.step.txt

@@ -0,0 +1,20 @@
+import React from 'react'
+import { ApiNode, Button, ApiNodeProps } from '@motiadev/workbench'
+
+export const Node: React.FC<ApiNodeProps> = ({ data }) => {
+  const doSomething = () => {
+    window.alert('Replace this with your custom logic')
+  }
+
+
+  return (
+    <ApiNode data={{ ...data, description: undefined }}>
+      <div className="flex flex-row gap-4">
+        <div className="flex flex-col items-center text-sm">{data.description}</div>
+        <div className="flex flex-col items-end text-sm">
+          <Button onClick={doSomething}>Play</Button>
+        </div>
+      </div>
+    </ApiNode>
+  )
+}

package/dist/src/create-step/templates/ui/cron.step.txt

@@ -0,0 +1,15 @@
+import React from 'react'
+import { BaseNode, Button, CronNodeProps } from '@motiadev/workbench'
+
+export const Node: React.FC<CronNodeProps> = ({ data }) => {
+  const doSomething = () => {
+    window.alert('Replace this with your custom logic')
+  }
+
+
+  return (
+    <BaseNode title="{{STEP_NAME}}" variant="noop" {...data} disableTargetHandle>
+      <Button onClick={doSomething}>Click me</Button>
+    </BaseNode>
+  )
+}

package/dist/src/create-step/templates/ui/event.step.txt

@@ -0,0 +1,15 @@
+import React from 'react'
+import { BaseNode, Button, EventNodeProps } from '@motiadev/workbench'
+
+export const Node: React.FC<EventNodeProps> = ({ data }) => {
+  const doSomething = () => {
+    window.alert('Replace this with your custom logic')
+  }
+
+
+  return (
+    <BaseNode title="{{STEP_NAME}}" variant="noop" {...data} disableTargetHandle>
+      <Button onClick={doSomething}>Click me</Button>
+    </BaseNode>
+  )
+}

package/dist/src/create-step/templates/ui/noop.step.txt

@@ -0,0 +1,15 @@
+import React from 'react'
+import { BaseNode, Button, NoopNodeProps } from '@motiadev/workbench'
+
+export const Node: React.FC<NoopNodeProps> = ({ data }) => {
+  const doSomething = () => {
+    window.alert('Replace this with your custom logic')
+  }
+
+
+  return (
+    <BaseNode title="{{STEP_NAME}}" variant="noop" {...data} disableTargetHandle>
+      <Button onClick={doSomething}>Click me</Button>
+    </BaseNode>
+  )
+}

package/dist/src/create-step/templates/ui/overrides.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOverride = generateOverride;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Generates a React component override for the step
+ */
+async function generateOverride(answers) {
+    const templatePath = path_1.default.join(__dirname, `${answers.type}.step.txt`);
+    const content = await fs_1.promises.readFile(templatePath, 'utf8');
+    const replacements = {
+        STEP_NAME: answers.name,
+        DESCRIPTION: answers.description || '',
+        TYPE: answers.type,
+        FLOWS: JSON.stringify(answers.flows),
+        EMITS: JSON.stringify(answers.emits),
+    };
+    return Object.entries(replacements).reduce((content, [key, value]) => {
+        const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        return content.replace(regex, String(value));
+    }, content);
+}

package/dist/src/create-step/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_METHODS = exports.LANGUAGES = exports.STEP_TYPES = void 0;
+exports.STEP_TYPES = ['api', 'event', 'cron', 'noop'];
+exports.LANGUAGES = ['typescript', 'javascript', 'python', 'ruby'];
+exports.HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE'];

package/dist/src/create-step/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileExtension = void 0;
+const getFileExtension = (language) => {
+    const extensions = {
+        typescript: '.ts',
+        javascript: '.js',
+        python: '.py',
+        ruby: '.rb',
+    };
+    return extensions[language];
+};
+exports.getFileExtension = getFileExtension;

package/dist/src/generate-locked-data.js

@@ -3,45 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateLockedData = exports.readConfig = void 0;
+exports.generateLockedData = void 0;
 const core_1 = require("@motiadev/core");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
 const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
-const baseFlowRegex = new RegExp(/flows"?\s?.*\s*\[([^\]]+)\]/);
-// Helper function to read config.yml
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const readConfig = (configPath) => {
-    if (!fs_1.default.existsSync(configPath)) {
-        console.warn(`Config file not found at ${configPath}`);
-        return {};
-    }
-    const configContent = fs_1.default.readFileSync(configPath, 'utf-8');
-    return yaml_1.default.parse(configContent);
-};
-exports.readConfig = readConfig;
 // Helper function to recursively collect flow data
-const collectFlows = async (baseDir) => {
+const collectFlows = async (baseDir, lockedData) => {
     const folderItems = fs_1.default.readdirSync(baseDir, { withFileTypes: true });
     let steps = [];
     for (const item of folderItems) {
         const filePath = path_1.default.join(baseDir, item.name);
         if (item.isDirectory()) {
-            steps = steps.concat(await collectFlows(filePath));
+            steps = steps.concat(await collectFlows(filePath, lockedData));
         }
         else if (item.name.match(/\.step\.(ts|js|py|rb)$/)) {
-            const fileContent = fs_1.default.readFileSync(filePath, 'utf-8');
-            const flowMatch = fileContent.match(baseFlowRegex);
             const config = await (0, core_1.getStepConfig)(filePath);
             if (!config) {
                 console.warn(`No config found in step ${filePath}, step skipped`);
                 continue;
             }
-            if (flowMatch) {
-                steps.push({ filePath, version, config });
-            }
+            lockedData.createStep({ filePath, version, config });
         }
     }
     return steps;
@@ -52,9 +35,8 @@ const generateLockedData = async (projectDir) => {
          * NOTE: right now for performance and simplicity let's enforce a folder,
          * but we might want to remove this and scan the entire current directory
          */
-        const sourceSteps = await collectFlows(path_1.default.join(projectDir, 'steps'));
         const lockedData = new core_1.LockedData(projectDir);
-        sourceSteps.forEach((step) => lockedData.createStep(step));
+        await collectFlows(path_1.default.join(projectDir, 'steps'), lockedData);
         return lockedData;
     }
     catch (error) {

package/dist/src/watcher.js

@@ -30,9 +30,10 @@ class Watcher {
             console.warn(`No step create handler, step skipped`);
             return;
         }
-        const config = await (0, core_1.getStepConfig)(path);
+        const config = await (0, core_1.getStepConfig)(path).catch((err) => {
+            console.error(err);
+        });
         if (!config) {
-            console.warn(`No config found in step ${path}, step skipped`);
             return;
         }
         const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
@@ -40,14 +41,11 @@ class Watcher {
         this.stepCreateHandler?.(step);
     }
     async onFileChange(path) {
-        if (!this.stepChangeHandler) {
-            console.warn(`No step change handler, step skipped`);
-            return;
-        }
-        const config = await (0, core_1.getStepConfig)(path);
+        const config = await (0, core_1.getStepConfig)(path).catch((err) => {
+            console.error(err);
+        });
         const step = this.findStep(path);
         if (!step && !config) {
-            console.warn(`Step ${path} not found, step skipped`);
             return;
         }
         // didn't have a step, but now we have a config
@@ -67,10 +65,6 @@ class Watcher {
         }
     }
     async onFileDelete(path) {
-        if (!this.stepDeleteHandler) {
-            console.warn(`No step delete handler, step skipped`);
-            return;
-        }
         const step = this.findStep(path);
         if (!step) {
             console.warn(`Step ${path} not found, step skipped`);
@@ -81,9 +75,12 @@ class Watcher {
     init() {
         this.watcher = chokidar_1.default
             .watch(this.dir, { persistent: true, ignoreInitial: true })
-            .on('add', (path) => this.onFileAdd(path))
-            .on('change', (path) => this.onFileChange(path))
-            .on('unlink', (path) => this.onFileDelete(path));
+            .on('add', (path) => this.isStepFile(path) && this.onFileAdd(path))
+            .on('change', (path) => this.isStepFile(path) && this.onFileChange(path))
+            .on('unlink', (path) => this.isStepFile(path) && this.onFileDelete(path));
+    }
+    isStepFile(path) {
+        return /\.step\.[^.]+$/.test(path) && !/\.tsx$/.test(path);
     }
     async stop() {
         if (this.watcher) {

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "motia",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "license": "MIT",
   "bin": {
     "motia": "dist/src/cli.js"
   },
   "dependencies": {
     "chokidar": "^4.0.3",
+    "colors": "^1.4.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.7",
     "figlet": "^1.8.0",
+    "inquirer": "^12.4.1",
     "ts-node": "^10.9.2",
     "yaml": "^2.7.0",
-    "@motiadev/core": "0.0.21",
-    "@motiadev/workbench": "0.0.21"
+    "@motiadev/core": "0.0.23",
+    "@motiadev/workbench": "0.0.23"
   },
   "devDependencies": {
     "@types/figlet": "^1.7.0",

package/scripts/move-templates.sh

@@ -1,20 +1,34 @@
 #!/bin/bash
 
+copy_templates() {
+    local src_dir="$1"
+    local dest_dir="$2"
+
+    # Create the destination directory if it doesn't exist
+    mkdir -p "$dest_dir"
+
+    # Copy all .txt files while preserving the directory structure
+    find "$src_dir" -type f -name "*.txt" | while read -r file; do
+        # Get the relative path of the file
+        rel_path="${file#$src_dir/}"
+        # Create the destination directory for the file
+        mkdir -p "$dest_dir/$(dirname "$rel_path")"
+        # Copy the file to the destination directory
+        cp "$file" "$dest_dir/$rel_path"
+    done
+
+    echo "All .txt files from $src_dir have been copied successfully to $dest_dir."
+}
+
 # Define source and destination directories
-SRC_DIR="$(dirname "$0")/../src/create/templates"
-DEST_DIR="$(dirname "$0")/../dist/src/create/templates"
-
-# Create the destination directory if it doesn't exist
-mkdir -p "$DEST_DIR"
-
-# Copy all .txt files while preserving the directory structure
-find "$SRC_DIR" -type f -name "*.txt" | while read -r file; do
-  # Get the relative path of the file
-  rel_path="${file#$SRC_DIR/}"
-  # Create the destination directory for the file
-  mkdir -p "$DEST_DIR/$(dirname "$rel_path")"
-  # Copy the file to the destination directory
-  cp "$file" "$DEST_DIR/$rel_path"
-done
-
-echo "All .txt files have been copied successfully."
+CREATE_TEMPLATES_SRC_DIR="$(dirname "$0")/../src/create/templates"
+CREATE_TEMPLATES_DEST_DIR="$(dirname "$0")/../dist/src/create/templates"
+
+# Call the function with the directories
+copy_templates "$CREATE_TEMPLATES_SRC_DIR" "$CREATE_TEMPLATES_DEST_DIR"
+
+CREATE_STEP_TEMPLATES_SRC_DIR="$(dirname "$0")/../src/create-step/templates"
+CREATE_STEP_TEMPLATES_DEST_DIR="$(dirname "$0")/../dist/src/create-step/templates"
+
+# Call the function with the directories
+copy_templates "$CREATE_STEP_TEMPLATES_SRC_DIR" "$CREATE_STEP_TEMPLATES_DEST_DIR"