motia 0.14.0-beta.165-285707 → 0.15.0-beta.165

package/dist/esm/create/index.js

@@ -1,208 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import pc from 'picocolors';
-import { generateTypes } from '../generate-types';
-import { pythonInstall } from '../install';
-import { pluginDependencies } from '../plugins/plugin-dependencies';
-import { handleBuildToolsError } from '../utils/build-tools-error';
-import { executeCommand } from '../utils/execute-command';
-import { getPackageManager } from '../utils/get-package-manager';
-import { version } from '../version';
-import { pullRules } from './pull-rules';
-import { setupTemplate } from './setup-template';
-import { checkIfDirectoryExists, checkIfFileExists } from './utils';
-require('ts-node').register({
-    transpileOnly: true,
-    compilerOptions: { module: 'commonjs' },
-});
-const installRequiredDependencies = async (packageManager, rootDir, context) => {
-    context.log('installing-dependencies', (message) => message.tag('info').append('Installing dependencies...'));
-    const installCommand = {
-        npm: 'npm install --save',
-        yarn: 'yarn add',
-        pnpm: 'pnpm add',
-    }[packageManager];
-    const dependencies = [
-        `motia@${version}`,
-        'zod@4.1.12',
-        `@motiadev/adapter-bullmq-events@${version}`,
-        ...pluginDependencies.map((dep) => `${dep}@${version}`),
-    ].join(' ');
-    const devDependencies = ['ts-node@10.9.2', 'typescript@5.7.3', '@types/react@19.1.1'].join(' ');
-    try {
-        await executeCommand(`${installCommand} ${dependencies}`, rootDir);
-        await executeCommand(`${installCommand} -D ${devDependencies}`, rootDir);
-        context.log('dependencies-installed', (message) => message.tag('success').append('Dependencies installed'));
-    }
-    catch (error) {
-        const wasBuildToolsError = handleBuildToolsError(error, 'install');
-        if (!wasBuildToolsError) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            context.log('install-error', (message) => message.tag('failed').append('Failed to install dependencies:').append(errorMessage));
-        }
-        console.error('❌ Failed to install dependencies:', error);
-        throw error;
-    }
-};
-const preparePackageManager = async (rootDir, context) => {
-    let packageManager = 'npm';
-    const detectedPackageManager = getPackageManager(rootDir);
-    if (detectedPackageManager !== 'unknown') {
-        context.log('package-manager-detected', (message) => message.tag('info').append('Detected package manager').append(detectedPackageManager, 'gray'));
-        packageManager = detectedPackageManager;
-    }
-    else {
-        context.log('package-manager-using-default', (message) => message.tag('info').append('Using default package manager').append(packageManager, 'gray'));
-    }
-    return packageManager;
-};
-const installNodeDependencies = async (rootDir, context) => {
-    const packageManager = await preparePackageManager(rootDir, context);
-    await installRequiredDependencies(packageManager, rootDir, context).catch((error) => {
-        context.log('failed-to-install-dependencies', (message) => message.tag('failed').append('Failed to install dependencies'));
-        console.error(error);
-    });
-    return packageManager;
-};
-export const create = async ({ projectName, template, cursorEnabled, context }) => {
-    console.log('\n\n' +
-        `
-           _____   ______  ______   ______
-   /'\\_/\`\\/\\  __\`\\/\\__  _\\/\\__  _\\ /\\  _  \\
-  /\\      \\ \\ \\/\\ \\/_/\\ \\/\\/_/\\ \\/ \\ \\ \\L\\ \\
-  \\ \\ \\__\\ \\ \\ \\ \\ \\ \\ \\ \\   \\ \\ \\  \\ \\  __ \\
-   \\ \\ \\_/\\ \\ \\ \\_\\ \\ \\ \\ \\   \\_\\ \\__\\ \\ \\/\\ \\
-    \\ \\_\\\\ \\_\\ \\_____\\ \\ \\_\\  /\\_____\\\\ \\_\\ \\_\\
-     \\/_/ \\/_/\\/_____/  \\/_/  \\/_____/ \\/_/\\/_/
-        ` +
-        '\n\n');
-    const isCurrentDir = projectName === '.' || projectName === './' || projectName === '.\\';
-    const rootDir = isCurrentDir ? process.cwd() : path.join(process.cwd(), projectName);
-    const isPluginTemplate = template === 'plugin';
-    if (!isCurrentDir && !checkIfDirectoryExists(rootDir)) {
-        fs.mkdirSync(path.join(rootDir));
-        context.log('directory-created', (message) => message.tag('success').append('Directory created ').append(projectName, 'gray'));
-    }
-    else {
-        context.log('directory-using', (message) => message.tag('info').append('Using current directory'));
-    }
-    // Plugin template handles package.json differently (via template)
-    if (!isPluginTemplate && !checkIfFileExists(rootDir, 'package.json')) {
-        const finalProjectName = !projectName || projectName === '.' || projectName === './' || projectName === '.\\'
-            ? path.basename(process.cwd())
-            : projectName.trim();
-        const packageJsonContent = {
-            name: finalProjectName,
-            description: '',
-            scripts: {
-                postinstall: 'motia install',
-                dev: 'motia dev',
-                start: 'motia start',
-                'generate-types': 'motia generate-types',
-                build: 'motia build',
-                clean: 'rm -rf dist node_modules python_modules .motia .mermaid',
-                //'generate:config': 'motia get-config --output ./', TODO: doesnt work at the moment
-            },
-            keywords: ['motia'],
-        };
-        fs.writeFileSync(path.join(rootDir, 'package.json'), JSON.stringify(packageJsonContent, null, 2));
-        context.log('package-json-created', (message) => message.tag('success').append('File').append('package.json', 'cyan').append('has been created.'));
-    }
-    else if (!isPluginTemplate) {
-        const packageJsonPath = path.join(rootDir, 'package.json');
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        if (!packageJson.scripts) {
-            packageJson.scripts = {};
-        }
-        if (!packageJson.scripts.dev) {
-            packageJson.scripts.dev = 'motia dev';
-        }
-        else {
-            packageJson.scripts.olddev = packageJson.scripts.dev;
-            packageJson.scripts.dev = 'motia dev';
-            context.log('dev-command-already-exists', (message) => message.tag('warning').append('dev command already exists in package.json'));
-        }
-        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-        context.log('dev-command-updated', (message) => message
-            .tag('success')
-            .append('Updated')
-            .append('dev', 'gray')
-            .append('command to')
-            .append('package.json', 'gray'));
-    }
-    // Plugin template handles tsconfig.json via template
-    if (!isPluginTemplate && !checkIfFileExists(rootDir, 'tsconfig.json')) {
-        const tsconfigContent = {
-            compilerOptions: {
-                target: 'ES2020',
-                module: 'ESNext',
-                moduleResolution: 'Node',
-                esModuleInterop: true,
-                strict: true,
-                skipLibCheck: true,
-                forceConsistentCasingInFileNames: true,
-                resolveJsonModule: true,
-                allowJs: true,
-                outDir: 'dist',
-                rootDir: '.',
-                baseUrl: '.',
-                jsx: 'react-jsx',
-            },
-            include: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', 'types.d.ts'],
-            exclude: ['node_modules', 'dist', 'tests'],
-        };
-        fs.writeFileSync(path.join(rootDir, 'tsconfig.json'), JSON.stringify(tsconfigContent, null, 2));
-        context.log('tsconfig-json-created', (message) => message.tag('success').append('File').append('tsconfig.json', 'cyan').append('has been created.'));
-    }
-    // Plugin template handles .gitignore via template
-    if (!isPluginTemplate && !checkIfFileExists(rootDir, '.gitignore')) {
-        const gitignoreContent = [
-            'node_modules',
-            'python_modules',
-            '.venv',
-            'venv',
-            '.motia',
-            '.mermaid',
-            'dist',
-            '*.pyc',
-        ].join('\n');
-        fs.writeFileSync(path.join(rootDir, '.gitignore'), gitignoreContent);
-        context.log('gitignore-created', (message) => message.tag('success').append('File').append('.gitignore', 'cyan').append('has been created.'));
-    }
-    // Skip cursor rules for plugin template
-    if (!isPluginTemplate && cursorEnabled) {
-        await pullRules({ force: true, rootDir }, context);
-    }
-    if (template) {
-        await setupTemplate(template, rootDir, context);
-    }
-    let packageManager;
-    if (!isPluginTemplate) {
-        packageManager = await installNodeDependencies(rootDir, context);
-        if (template.includes('python')) {
-            await pythonInstall({ baseDir: rootDir });
-        }
-        await generateTypes(rootDir);
-    }
-    else {
-        // For plugin template, just detect the package manager
-        packageManager = await preparePackageManager(rootDir, context);
-    }
-    const projectDirName = path.basename(rootDir);
-    const devCommand = `${packageManager} run dev`;
-    const port = 3000;
-    const cdCommand = isCurrentDir ? '' : `${pc.cyan(`cd ${projectDirName}`)}\n  `;
-    context.log('success-blank', (message) => message.text(''));
-    context.log('success-header', (message) => message.text(`${pc.green('✨')} ${pc.bold('All set! Your project is ready to go.')}`));
-    context.log('success-blank-2', (message) => message.text(''));
-    context.log('success-get-started', (message) => message.text('Get started:'));
-    context.log('success-blank-3', (message) => message.text(''));
-    context.log('success-commands', (message) => message.text(`  ${cdCommand}${pc.cyan(devCommand)}`));
-    context.log('success-blank-4', (message) => message.text(''));
-    context.log('success-open', (message) => message.text(`Then open ${pc.cyan(`http://localhost:${port}`)}`));
-    context.log('success-blank-5', (message) => message.text(''));
-    context.log('success-docs', (message) => message.text(`Docs: ${pc.cyan('https://www.motia.dev/docs')}`));
-    context.log('success-blank-6', (message) => message.text(''));
-    context.log('success-signoff', (message) => message.text('Happy coding! 🚀'));
-    context.log('success-blank-7', (message) => message.text(''));
-};

package/dist/esm/create/interactive.d.ts

@@ -1,9 +0,0 @@
-import type { CliContext } from '../cloud/config-utils';
-interface CreateInteractiveArgs {
-    name?: string;
-    template?: string;
-    plugin?: boolean;
-}
-export declare const createInteractive: (args: CreateInteractiveArgs, context: CliContext) => Promise<void>;
-export {};
-//# sourceMappingURL=interactive.d.ts.map

package/dist/esm/create/interactive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"interactive.d.ts","sourceRoot":"","sources":["../../../src/create/interactive.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAgBvD,UAAU,qBAAqB;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,eAAO,MAAM,iBAAiB,GAAU,MAAM,qBAAqB,EAAE,SAAS,UAAU,KAAG,OAAO,CAAC,IAAI,CAuEtG,CAAA"}

package/dist/esm/create/interactive.js

@@ -1,68 +0,0 @@
-import inquirer from 'inquirer';
-import pc from 'picocolors';
-import { create } from './index';
-const choices = {
-    'motia-tutorial-typescript': 'Tutorial (TypeScript)',
-    'motia-tutorial-python': 'Tutorial (Python)',
-    'starter-typescript': 'Starter (TypeScript)',
-    'starter-javascript': 'Starter (JavaScript)',
-    'starter-python': 'Starter (Python)',
-};
-export const createInteractive = async (args, context) => {
-    context.log('welcome', (message) => message.append(`\n🚀 ${pc.bold(args.plugin ? 'Welcome to Motia Plugin Creator!' : 'Welcome to Motia Project Creator!')}`));
-    const questions = [];
-    let name = args.name;
-    let template = args.template;
-    if (args.plugin) {
-        if (!args.name) {
-            context.log('failed', (message) => message.tag('failed').append(`Project name is required: ${pc.bold('motia create --plugin [project-name]')}\n`));
-            return;
-        }
-        return create({
-            projectName: args.name,
-            template: 'plugin',
-            cursorEnabled: false,
-            context,
-        });
-    }
-    else if (!args.template) {
-        questions.push({
-            type: 'list',
-            name: 'template',
-            message: 'What template do you want to use? (Use arrow keys)',
-            choices: Object.keys(choices).map((key) => ({
-                name: choices[key],
-                value: key,
-            })),
-        });
-    }
-    if (!args.name) {
-        questions.push({
-            type: 'input',
-            name: 'projectName',
-            message: 'Project name (leave blank to use current folder):',
-            validate: (input) => {
-                if (input && input.trim().length > 0) {
-                    if (!/^[a-zA-Z0-9][a-zA-Z0-9-_]*$/.test(input.trim())) {
-                        return 'Project name must start with a letter or number and contain only letters, numbers, hyphens, and underscores';
-                    }
-                }
-                return true;
-            },
-            filter: (input) => input.trim(),
-        });
-    }
-    if (questions.length > 0) {
-        const answers = await inquirer.prompt(questions);
-        name = args.name || answers.projectName;
-        template = args.template || answers.template;
-    }
-    context.log('creating', (message) => message.append('\n🔨 Creating your Motia project...\n'));
-    await create({
-        projectName: name || '.',
-        template: template || 'motia-tutorial-typescript',
-        cursorEnabled: true, // Default to true for cursor rules
-        context,
-    });
-    process.exit(0);
-};

package/dist/esm/create/pull-rules.d.ts

@@ -1,8 +0,0 @@
-import type { CliContext } from '../cloud/config-utils';
-type PullRulesArgs = {
-    rootDir: string;
-    force?: boolean;
-};
-export declare const pullRules: (args: PullRulesArgs, context: CliContext) => Promise<void>;
-export {};
-//# sourceMappingURL=pull-rules.d.ts.map

package/dist/esm/create/pull-rules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pull-rules.d.ts","sourceRoot":"","sources":["../../../src/create/pull-rules.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAEvD,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,SAAS,GAAU,MAAM,aAAa,EAAE,SAAS,UAAU,kBAwBvE,CAAA"}

package/dist/esm/create/pull-rules.js

@@ -1,21 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-export const pullRules = async (args, context) => {
-    const cursorTemplateDir = path.join(__dirname, '..', 'cursor-rules', 'dot-files');
-    const files = fs.readdirSync(cursorTemplateDir);
-    for (const file of files) {
-        const targetFile = path.join(args.rootDir, file);
-        const isFolder = fs.statSync(path.join(cursorTemplateDir, file)).isDirectory();
-        const type = isFolder ? 'Folder' : 'File';
-        if (args.force || !fs.existsSync(targetFile)) {
-            fs.cpSync(path.join(cursorTemplateDir, file), targetFile, {
-                recursive: isFolder,
-                force: true,
-            });
-            context.log(`${file}-created`, (message) => message.tag('success').append(type).append(file, 'cyan').append('has been created.'));
-        }
-        else {
-            context.log(`${file}-skipped`, (message) => message.tag('warning').append(type).append(file, 'cyan').append('already exists, skipping...'));
-        }
-    }
-};

package/dist/esm/create/setup-template.d.ts

@@ -1,3 +0,0 @@
-import type { CliContext } from '@/cloud/config-utils';
-export declare const setupTemplate: (template: string, rootDir: string, context: CliContext) => Promise<void>;
-//# sourceMappingURL=setup-template.d.ts.map

package/dist/esm/create/setup-template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup-template.d.ts","sourceRoot":"","sources":["../../../src/create/setup-template.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAGtD,eAAO,MAAM,aAAa,GAAU,UAAU,MAAM,EAAE,SAAS,MAAM,EAAE,SAAS,UAAU,kBAazF,CAAA"}

package/dist/esm/create/setup-template.js

@@ -1,11 +0,0 @@
-import { templates } from './templates';
-export const setupTemplate = async (template, rootDir, context) => {
-    if (!template || !(template in templates)) {
-        context.log('template-not-found', (message) => message
-            .tag('failed')
-            .append(`Template ${template} not found, please use one of the following:`)
-            .append(Object.keys(templates).join(', '), 'gray'));
-        process.exit(1);
-    }
-    await templates[template](rootDir, context);
-};

package/dist/esm/create/templates/generate.d.ts

@@ -1,5 +0,0 @@
-import type { CliContext } from '../../cloud/config-utils';
-export type Generator = (rootDir: string, context: CliContext) => Promise<void>;
-export declare const generateTemplateSteps: (templateFolder: string) => Generator;
-export declare const generatePluginTemplate: (templateFolder: string) => Generator;
-//# sourceMappingURL=generate.d.ts.map

package/dist/esm/create/templates/generate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/create/templates/generate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAuB/E,eAAO,MAAM,qBAAqB,GAAI,gBAAgB,MAAM,KAAG,SAkE9D,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,gBAAgB,MAAM,KAAG,SA0C/D,CAAA"}

package/dist/esm/create/templates/generate.js

@@ -1,125 +0,0 @@
-import { constants, promises as fs, mkdirSync, statSync } from 'fs';
-import { globSync } from 'glob';
-import * as path from 'path';
-const replaceTemplateVariables = (content, projectName) => {
-    const replacements = {
-        '{{PROJECT_NAME}}': projectName,
-        '{{PLUGIN_NAME}}': toPascalCase(projectName),
-        '{{CSS_FILE_NAME}}': projectName.replace(/^@[^/]+\//, ''),
-    };
-    return Object.entries(replacements).reduce((result, [key, value]) => {
-        return result.replace(new RegExp(key, 'g'), value);
-    }, content);
-};
-const toPascalCase = (str) => {
-    // Remove @ and scope if present
-    const name = str.replace(/^@[^/]+\//, '');
-    return name
-        .split(/[-_]/)
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join('');
-};
-export const generateTemplateSteps = (templateFolder) => {
-    return async (rootDir, context) => {
-        const templatePath = path.join(__dirname, templateFolder);
-        const files = globSync('**/*', { absolute: false, cwd: templatePath, dot: true });
-        const projectName = path.basename(rootDir);
-        try {
-            for (const fileName of files) {
-                const filePath = path.join(templatePath, fileName);
-                const targetFilePath = path.join(rootDir, fileName);
-                const targetDir = path.dirname(targetFilePath);
-                mkdirSync(targetDir, { recursive: true });
-                if (statSync(filePath).isDirectory()) {
-                    const folderPath = filePath.replace(templatePath, '');
-                    mkdirSync(path.join(rootDir, folderPath), { recursive: true });
-                    continue;
-                }
-                const sanitizedFileName = fileName === 'requirements.txt' ? fileName : fileName.replace('.txt', '');
-                const isWorkbenchConfig = fileName.match('motia-workbench.json');
-                const generateFilePath = path.join(rootDir, sanitizedFileName);
-                let content = await fs.readFile(filePath, 'utf8');
-                if (isWorkbenchConfig) {
-                    try {
-                        // Use file descriptor to avoid TOCTOU vulnerability
-                        let fd = null;
-                        try {
-                            // Try to open existing file for reading
-                            fd = await fs.open(generateFilePath, constants.O_RDONLY);
-                            const existingWorkbenchConfig = await fd.readFile('utf8');
-                            const workbenchContent = JSON.parse(content);
-                            content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2);
-                            context.log('workbench-config-updated', (message) => message.tag('success').append('Workbench config').append('has been updated.'));
-                        }
-                        finally {
-                            if (fd)
-                                await fd.close();
-                        }
-                    }
-                    catch {
-                        void 0;
-                    }
-                }
-                else {
-                    content = replaceTemplateVariables(content, projectName);
-                }
-                // Use file descriptor for atomic write operation
-                let fd = null;
-                try {
-                    fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644);
-                    await fd.writeFile(content, 'utf8');
-                }
-                finally {
-                    if (fd)
-                        await fd.close();
-                }
-                context.log(sanitizedFileName, (message) => {
-                    message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error generating template files:', error);
-        }
-    };
-};
-export const generatePluginTemplate = (templateFolder) => {
-    return async (rootDir, context) => {
-        const templatePath = path.join(__dirname, templateFolder);
-        const files = globSync('**/*', { absolute: false, cwd: templatePath, dot: true });
-        const projectName = path.basename(rootDir);
-        try {
-            for (const fileName of files) {
-                const filePath = path.join(templatePath, fileName);
-                const targetFilePath = path.join(rootDir, fileName);
-                const targetDir = path.dirname(targetFilePath);
-                mkdirSync(targetDir, { recursive: true });
-                if (statSync(filePath).isDirectory()) {
-                    const folderPath = filePath.replace(templatePath, '');
-                    mkdirSync(path.join(rootDir, folderPath), { recursive: true });
-                    continue;
-                }
-                const sanitizedFileName = fileName.replace('.txt', '');
-                const generateFilePath = path.join(rootDir, sanitizedFileName);
-                let content = await fs.readFile(filePath, 'utf8');
-                content = replaceTemplateVariables(content, projectName);
-                // Use file descriptor for atomic write operation
-                let fd = null;
-                try {
-                    fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644);
-                    await fd.writeFile(content, 'utf8');
-                }
-                finally {
-                    if (fd)
-                        await fd.close();
-                }
-                context.log(sanitizedFileName, (message) => {
-                    message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');
-                });
-            }
-        }
-        catch (error) {
-            console.error('Error generating template files:', error);
-        }
-    };
-};

package/dist/esm/create/templates/generate.ts

@@ -1,139 +0,0 @@
-import { constants, promises as fs, mkdirSync, statSync } from 'fs'
-import { globSync } from 'glob'
-import * as path from 'path'
-import type { CliContext } from '../../cloud/config-utils'
-
-export type Generator = (rootDir: string, context: CliContext) => Promise<void>
-
-const replaceTemplateVariables = (content: string, projectName: string): string => {
-  const replacements: Record<string, string> = {
-    '{{PROJECT_NAME}}': projectName,
-    '{{PLUGIN_NAME}}': toPascalCase(projectName),
-    '{{CSS_FILE_NAME}}': projectName.replace(/^@[^/]+\//, ''),
-  }
-
-  return Object.entries(replacements).reduce((result, [key, value]) => {
-    return result.replace(new RegExp(key, 'g'), value)
-  }, content)
-}
-
-const toPascalCase = (str: string): string => {
-  // Remove @ and scope if present
-  const name = str.replace(/^@[^/]+\//, '')
-  return name
-    .split(/[-_]/)
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join('')
-}
-
-export const generateTemplateSteps = (templateFolder: string): Generator => {
-  return async (rootDir: string, context: CliContext): Promise<void> => {
-    const templatePath = path.join(__dirname, templateFolder)
-    const files = globSync('**/*', { absolute: false, cwd: templatePath, dot: true })
-    const projectName = path.basename(rootDir)
-
-    try {
-      for (const fileName of files) {
-        const filePath = path.join(templatePath, fileName)
-        const targetFilePath = path.join(rootDir, fileName)
-        const targetDir = path.dirname(targetFilePath)
-
-        mkdirSync(targetDir, { recursive: true })
-
-        if (statSync(filePath).isDirectory()) {
-          const folderPath = filePath.replace(templatePath, '')
-          mkdirSync(path.join(rootDir, folderPath), { recursive: true })
-          continue
-        }
-
-        const sanitizedFileName = fileName === 'requirements.txt' ? fileName : fileName.replace('.txt', '')
-        const isWorkbenchConfig = fileName.match('motia-workbench.json')
-        const generateFilePath = path.join(rootDir, sanitizedFileName)
-        let content = await fs.readFile(filePath, 'utf8')
-
-        if (isWorkbenchConfig) {
-          try {
-            // Use file descriptor to avoid TOCTOU vulnerability
-            let fd: fs.FileHandle | null = null
-            try {
-              // Try to open existing file for reading
-              fd = await fs.open(generateFilePath, constants.O_RDONLY)
-              const existingWorkbenchConfig = await fd.readFile('utf8')
-              const workbenchContent = JSON.parse(content)
-
-              content = JSON.stringify([...JSON.parse(existingWorkbenchConfig), ...workbenchContent], null, 2)
-
-              context.log('workbench-config-updated', (message) =>
-                message.tag('success').append('Workbench config').append('has been updated.'),
-              )
-            } finally {
-              if (fd) await fd.close()
-            }
-          } catch {
-            void 0
-          }
-        } else {
-          content = replaceTemplateVariables(content, projectName)
-        }
-
-        // Use file descriptor for atomic write operation
-        let fd: fs.FileHandle | null = null
-        try {
-          fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644)
-          await fd.writeFile(content, 'utf8')
-        } finally {
-          if (fd) await fd.close()
-        }
-        context.log(sanitizedFileName, (message) => {
-          message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.')
-        })
-      }
-    } catch (error) {
-      console.error('Error generating template files:', error)
-    }
-  }
-}
-
-export const generatePluginTemplate = (templateFolder: string): Generator => {
-  return async (rootDir: string, context: CliContext): Promise<void> => {
-    const templatePath = path.join(__dirname, templateFolder)
-    const files = globSync('**/*', { absolute: false, cwd: templatePath, dot: true })
-    const projectName = path.basename(rootDir)
-
-    try {
-      for (const fileName of files) {
-        const filePath = path.join(templatePath, fileName)
-        const targetFilePath = path.join(rootDir, fileName)
-        const targetDir = path.dirname(targetFilePath)
-
-        mkdirSync(targetDir, { recursive: true })
-
-        if (statSync(filePath).isDirectory()) {
-          const folderPath = filePath.replace(templatePath, '')
-          mkdirSync(path.join(rootDir, folderPath), { recursive: true })
-          continue
-        }
-
-        const sanitizedFileName = fileName.replace('.txt', '')
-        const generateFilePath = path.join(rootDir, sanitizedFileName)
-        let content = await fs.readFile(filePath, 'utf8')
-
-        content = replaceTemplateVariables(content, projectName)
-
-        // Use file descriptor for atomic write operation
-        let fd: fs.FileHandle | null = null
-        try {
-          fd = await fs.open(generateFilePath, constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC, 0o644)
-          await fd.writeFile(content, 'utf8')
-        } finally {
-          if (fd) await fd.close()
-        }
-        context.log(sanitizedFileName, (message) => {
-          message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.')
-        })
-      }
-    } catch (error) {
-      console.error('Error generating template files:', error)
-    }
-  }
-}