motia 0.5.11-beta.120-391598 → 0.5.11-beta.120-207545

package/dist/cjs/cloud/build/builders/python/index.d.ts

@@ -4,9 +4,17 @@ import { BuildListener } from '../../../new-deployment/listeners/listener.types'
 export declare class PythonBuilder implements StepBuilder {
     private readonly builder;
     private readonly listener;
+    private uvPackager;
     constructor(builder: Builder, listener: BuildListener);
-    private buildStep;
-    build(step: Step): Promise<void>;
     buildApiSteps(steps: Step<ApiRouteConfig>[]): Promise<RouterBuildResult>;
-    private getPythonBuilderData;
+    build(step: Step): Promise<void>;
+    private addStepToArchive;
+    private addPackagesToArchive;
+    private shouldIgnoreFile;
+    private normalizeStepPath;
+    private createRouterTemplate;
+    private findInternalFiles;
+    private resolveModulePaths;
+    private getModuleName;
+    private waitForDirectoryReady;
 }

package/dist/cjs/cloud/build/builders/python/index.js

@@ -4,116 +4,252 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PythonBuilder = void 0;
-const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const activate_python_env_1 = require("../../../../utils/activate-python-env");
 const archiver_1 = require("../archiver");
 const include_static_files_1 = require("../include-static-files");
-const add_package_to_archive_1 = require("./add-package-to-archive");
 const constants_1 = require("../../../new-deployment/constants");
+const uv_packager_1 = require("./uv-packager");
+const activate_python_env_1 = require("../../../../utils/activate-python-env");
 class PythonBuilder {
     constructor(builder, listener) {
         this.builder = builder;
         this.listener = listener;
         (0, activate_python_env_1.activatePythonVenv)({ baseDir: this.builder.projectDir });
+        this.uvPackager = new uv_packager_1.UvPackager(this.builder.projectDir);
     }
-    async buildStep(step, archive) {
-        const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
-        const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        // Get Python builder response
-        const { packages } = await this.getPythonBuilderData(step);
-        // Add main file to archive
-        if (!fs_1.default.existsSync(step.filePath)) {
-            throw new Error(`Source file not found: ${step.filePath}`);
+    async buildApiSteps(steps) {
+        const zipName = 'router-python.zip';
+        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
+        const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
+        try {
+            await this.uvPackager.packageDependencies(tempSitePackages);
+            // Wait for directory to be ready with proper access checks
+            await this.waitForDirectoryReady(tempSitePackages);
+            await this.addPackagesToArchive(archive, tempSitePackages);
+            for (const step of steps) {
+                await this.addStepToArchive(step, archive);
+            }
+            const routerTemplate = this.createRouterTemplate(steps);
+            archive.append(routerTemplate, 'router.py');
+            (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
+            const size = await archive.finalize();
+            return { size, path: zipName };
+        }
+        catch (error) {
+            throw new Error(`Failed to build Python API router: ${error}`);
+        }
+        finally {
+            if (fs_1.default.existsSync(tempSitePackages)) {
+                fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
+            }
         }
-        archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, packageName)));
-        return normalizedEntrypointPath;
     }
     async build(step) {
         const entrypointPath = step.filePath.replace(this.builder.projectDir, '');
         const bundlePath = path_1.default.join('python', entrypointPath.replace(/(.*)\.py$/, '$1.zip'));
-        const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const outfile = path_1.default.join(constants_1.distDir, bundlePath);
+        this.builder.registerStep({ entrypointPath, bundlePath, step, type: 'python' });
+        this.listener.onBuildStart(step);
         try {
-            // Create output directory
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
-            this.listener.onBuildStart(step);
-            // Get Python builder response
-            const { packages } = await this.getPythonBuilderData(step);
-            const stepArchiver = new archiver_1.Archiver(outfile);
-            const stepPath = await this.buildStep(step, stepArchiver);
-            // Add main file to archive
-            if (!fs_1.default.existsSync(step.filePath)) {
-                throw new Error(`Source file not found: ${step.filePath}`);
+            const archive = new archiver_1.Archiver(outfile);
+            const tempSitePackages = path_1.default.join(constants_1.distDir, `temp-python-packages-${Date.now()}`);
+            try {
+                await this.uvPackager.packageDependencies(tempSitePackages);
+                await this.waitForDirectoryReady(tempSitePackages);
+                await this.addStepToArchive(step, archive);
+                await this.addPackagesToArchive(archive, tempSitePackages);
+                (0, include_static_files_1.includeStaticFiles)([step], this.builder, archive);
+                const size = await archive.finalize();
+                this.listener.onBuildEnd(step, size);
             }
-            stepArchiver.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-            // Add all imported files to archive
-            this.listener.onBuildProgress(step, 'Adding imported files to archive...');
-            const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-            (0, include_static_files_1.includeStaticFiles)([step], this.builder, stepArchiver);
-            if (packages.length > 0) {
-                await Promise.all(packages.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(stepArchiver, sitePackagesDir, packageName)));
-                this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
+            finally {
+                if (fs_1.default.existsSync(tempSitePackages)) {
+                    fs_1.default.rmSync(tempSitePackages, { recursive: true, force: true });
+                }
             }
-            // Finalize the archive and wait for completion
-            const size = await stepArchiver.finalize();
-            this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
-            this.listener.onBuildEnd(step, size);
         }
         catch (err) {
             this.listener.onBuildError(step, err);
             throw err;
         }
     }
-    async buildApiSteps(steps) {
-        const getStepPath = (step) => {
-            const normalizedEntrypointPath = step.filePath.replace(/[.]step.py$/, '_step.py');
-            return normalizedEntrypointPath
-                .replace(`${this.builder.projectDir}/`, '')
-                .replace(/(.*)\.py$/, '$1')
-                .replace(/\\/g, '.')
-                .replace(/\//g, '.');
-        };
-        const zipName = 'router-python.zip';
-        const archive = new archiver_1.Archiver(path_1.default.join(constants_1.distDir, zipName));
-        const dependencies = ['uvicorn', 'pydantic', 'pydantic_core', 'uvloop', 'starlette', 'typing_inspection'];
-        const lambdaSitePackages = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
-        await Promise.all(dependencies.map(async (packageName) => (0, add_package_to_archive_1.addPackageToArchive)(archive, lambdaSitePackages, packageName)));
-        for (const step of steps) {
-            await this.buildStep(step, archive);
+    async addStepToArchive(step, archive) {
+        const normalizedPath = this.normalizeStepPath(step, false);
+        archive.append(fs_1.default.createReadStream(step.filePath), normalizedPath);
+        const internalFiles = await this.findInternalFiles(step.filePath);
+        for (const file of internalFiles) {
+            const fullPath = path_1.default.join(this.builder.projectDir, file);
+            if (fs_1.default.existsSync(fullPath) && fullPath !== step.filePath) {
+                const archivePath = file.replace(/\.step\.py$/, '_step.py');
+                archive.append(fs_1.default.createReadStream(fullPath), archivePath);
+            }
+        }
+    }
+    async addPackagesToArchive(archive, sitePackagesDir) {
+        if (!fs_1.default.existsSync(sitePackagesDir)) {
+            console.warn(`Warning: Site packages directory not found: ${sitePackagesDir}`);
+            return;
+        }
+        try {
+            fs_1.default.accessSync(sitePackagesDir, fs_1.default.constants.R_OK);
         }
-        const file = fs_1.default
+        catch (error) {
+            console.warn(`Warning: Cannot access site packages directory: ${sitePackagesDir}`);
+            return;
+        }
+        const addDirectory = (dirPath, basePath = sitePackagesDir) => {
+            try {
+                const items = fs_1.default.readdirSync(dirPath);
+                for (const item of items) {
+                    const fullPath = path_1.default.join(dirPath, item);
+                    const relativePath = path_1.default.relative(basePath, fullPath);
+                    if (this.shouldIgnoreFile(relativePath)) {
+                        continue;
+                    }
+                    try {
+                        const stat = fs_1.default.statSync(fullPath);
+                        if (stat.isDirectory()) {
+                            addDirectory(fullPath, basePath);
+                        }
+                        else {
+                            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Warning: Could not process file ${fullPath}: ${error}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Warning: Could not read directory ${dirPath}: ${error}`);
+            }
+        };
+        addDirectory(sitePackagesDir);
+    }
+    shouldIgnoreFile(filePath) {
+        const ignorePatterns = [
+            /\.pyc$/,
+            /\.pyo$/,
+            /\.egg$/,
+            /\.egg-info$/,
+            /__pycache__/,
+            /\.dist-info$/,
+            /^tests?\//,
+            /^docs?\//,
+            /^examples?\//,
+            /\.pytest_cache/,
+        ];
+        return ignorePatterns.some((pattern) => pattern.test(filePath));
+    }
+    normalizeStepPath(step, normalizePythonModulePath) {
+        let normalizedStepPath = step.filePath
+            .replace(/[.]step.py$/, '_step.py') // Replace .step.py with _step.py
+            .replace(`${this.builder.projectDir}/`, ''); // Remove the project directory from the path
+        const pathParts = normalizedStepPath.split(path_1.default.sep).map((part) => part
+            .replace(/^[0-9]+/g, '') // Remove numeric prefixes
+            .replace(/[^a-zA-Z0-9._]/g, '_') // Replace any non-alphanumeric characters (except dots) with underscores
+            .replace(/^_/, '')); // Remove leading underscore
+        normalizedStepPath = normalizePythonModulePath
+            ? pathParts.join('.') // Convert path delimiter to dot (python module separator)
+            : '/' + pathParts.join(path_1.default.sep);
+        return normalizedStepPath;
+    }
+    createRouterTemplate(steps) {
+        const imports = steps
+            .map((step, index) => {
+            const moduleName = this.getModuleName(step);
+            return `from ${moduleName} import handler as route${index}_handler, config as route${index}_config`;
+        })
+            .join('\n');
+        const routerPaths = steps
+            .map((step, index) => {
+            const method = step.config.method.toUpperCase();
+            const path = step.config.path;
+            return `    '${method} ${path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`;
+        })
+            .join(',\n');
+        return fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
-            .replace('# {{imports}}', steps
-            .map((step, index) => `from ${getStepPath(step)} import handler as route${index}_handler, config as route${index}_config`)
-            .join('\n'))
-            .replace('# {{router paths}}', steps
-            .map((step, index) => `'${step.config.method} ${step.config.path}': RouterPath('${step.config.name}', '${step.config.method.toLowerCase()}', route${index}_handler, route${index}_config)`)
-            .join(',\n    '));
-        archive.append(file, 'router.py');
-        (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
-        // Finalize the archive and wait for completion
-        const size = await archive.finalize();
-        return { size, path: zipName };
+            .replace('# {{imports}}', imports)
+            .replace('# {{router paths}}', routerPaths);
     }
-    async getPythonBuilderData(step) {
-        return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), step.filePath], {
-                cwd: this.builder.projectDir,
-                stdio: [undefined, undefined, 'pipe', 'ipc'],
-            });
-            const err = [];
-            child.on('stderr', (data) => err.push(data.toString()));
-            child.on('message', resolve);
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(err.join('')));
+    async findInternalFiles(entryFile) {
+        const files = [];
+        const visited = new Set();
+        const analyzeFile = (filePath) => {
+            if (visited.has(filePath) || !fs_1.default.existsSync(filePath)) {
+                return;
+            }
+            visited.add(filePath);
+            files.push(path_1.default.relative(this.builder.projectDir, filePath));
+            try {
+                const content = fs_1.default.readFileSync(filePath, 'utf-8');
+                const importRegex = /^(?:from\s+([a-zA-Z_][a-zA-Z0-9_.]*)\s+import|import\s+([a-zA-Z_][a-zA-Z0-9_.]*))/gm;
+                let match;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const moduleName = match[1] || match[2]; // from X import Y ou import X
+                    this.resolveModulePaths(moduleName, path_1.default.dirname(filePath)).forEach((possiblePath) => {
+                        if (fs_1.default.existsSync(possiblePath)) {
+                            analyzeFile(possiblePath);
+                        }
+                    });
                 }
-            });
-        });
+            }
+            catch (error) {
+                console.warn(`Could not analyze file: ${filePath}`);
+            }
+        };
+        analyzeFile(entryFile);
+        return files;
+    }
+    resolveModulePaths(moduleName, currentDir) {
+        const parts = moduleName.split('.');
+        const baseName = parts[0];
+        const subPath = parts.length > 1 ? path_1.default.join(...parts) : baseName;
+        return [
+            path_1.default.join(currentDir, `${baseName}.py`),
+            path_1.default.join(currentDir, baseName, '__init__.py'),
+            path_1.default.join(currentDir, `${subPath}.py`),
+            path_1.default.join(this.builder.projectDir, `${baseName}.py`),
+            path_1.default.join(this.builder.projectDir, baseName, '__init__.py'),
+            path_1.default.join(this.builder.projectDir, `${subPath}.py`),
+            path_1.default.join(this.builder.projectDir, subPath + '.py'),
+            path_1.default.join(this.builder.projectDir, subPath, '__init__.py'),
+        ];
+    }
+    getModuleName(step) {
+        return this.normalizeStepPath(step, true).replace(/\.py$/, '').replace(/\//g, '.');
+    }
+    async waitForDirectoryReady(dirPath, maxRetries = 10, initialDelayMs = 10) {
+        let lastError = null;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                const exists = await fs_1.default.promises
+                    .access(dirPath, fs_1.default.constants.F_OK)
+                    .then(() => true)
+                    .catch(() => false);
+                if (!exists) {
+                    // Directory doesn't exist yet, wait
+                    lastError = new Error(`Directory ${dirPath} does not exist yet`);
+                }
+                else {
+                    await fs_1.default.promises.access(dirPath, fs_1.default.constants.R_OK);
+                    return;
+                }
+            }
+            catch (error) {
+                lastError = error;
+            }
+            if (i === maxRetries - 1) {
+                throw new Error(`Directory ${dirPath} is not accessible after ${maxRetries} attempts. ` +
+                    `Last error: ${lastError?.message || 'Unknown error'}`);
+            }
+            // Exponential backoff: 10ms, 20ms, 40ms, 80ms, etc.
+            const delay = initialDelayMs * Math.pow(2, i);
+            await new Promise((resolve) => setTimeout(resolve, Math.min(delay, 1000))); // Cap at 1 second
+        }
     }
 }
 exports.PythonBuilder = PythonBuilder;

package/dist/cjs/cloud/build/builders/python/uv-packager.d.ts

@@ -0,0 +1,13 @@
+export interface UvPackageConfig {
+    pythonVersion?: string;
+    platform?: string;
+    onlyBinary?: boolean;
+}
+export declare const defaultUvConfig: UvPackageConfig;
+export declare class UvPackager {
+    private readonly projectDir;
+    private readonly config;
+    constructor(projectDir: string, config?: UvPackageConfig);
+    private runCommand;
+    packageDependencies(targetDir: string): Promise<void>;
+}

package/dist/cjs/cloud/build/builders/python/uv-packager.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UvPackager = exports.defaultUvConfig = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.defaultUvConfig = {
+    pythonVersion: process.env.MOTIA_PYTHON_VERSION || '3.13',
+    platform: process.env.MOTIA_PLATFORM || 'x86_64-manylinux2014',
+    onlyBinary: process.env.MOTIA_ONLY_BINARY !== 'false',
+};
+class UvPackager {
+    constructor(projectDir, config = exports.defaultUvConfig) {
+        this.projectDir = projectDir;
+        this.config = config;
+    }
+    async runCommand(command, args, options) {
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(command, args, {
+                cwd: options?.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+                if (options?.showOutput) {
+                    process.stdout.write(data);
+                }
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    const errorPrefix = `Command '${command}'`;
+                    reject(new Error(`${errorPrefix} failed: ${stderr || stdout}`));
+                }
+            });
+            child.on('error', (error) => {
+                reject(new Error(`Failed to spawn ${command}: ${error.message}`));
+            });
+        });
+    }
+    async packageDependencies(targetDir) {
+        if (!fs_1.default.existsSync(targetDir)) {
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+        }
+        const requirementsFile = path_1.default.join(this.projectDir, 'requirements.txt');
+        if (!fs_1.default.existsSync(requirementsFile)) {
+            return;
+        }
+        const args = [
+            'pip',
+            'install',
+            '--target',
+            targetDir,
+            '--requirement',
+            requirementsFile,
+            '--python-version',
+            this.config.pythonVersion || '3.13',
+            '--python-platform',
+            this.config.platform || 'x86_64-manylinux2014',
+        ];
+        if (this.config.onlyBinary) {
+            args.push('--only-binary=:all:');
+        }
+        await this.runCommand('uv', args, { cwd: this.projectDir });
+    }
+}
+exports.UvPackager = UvPackager;

package/dist/cjs/cloud/cli/deploy.js

@@ -13,11 +13,13 @@ cli_1.cloudCli
     .command('deploy')
     .description('Deploy a new version to Motia Cloud')
     .requiredOption('-k, --api-key <key>', 'The API key for authentication', process.env.MOTIA_API_KEY)
-    .requiredOption('-v, --version-name <version>', 'The version to deploy')
     .option('-p, --project-id <id>', 'Project ID (Deprecated)')
+    .option('-n, --project-name <name>', 'Project name (used when creating a new project)')
     .option('-s, --environment-id <id>', 'Environment ID', process.env.MOTIA_ENVIRONMENT_ID)
+    .option('--environment-name <name>', 'Environment name')
     .option('-e, --env-file <path>', 'Path to environment file')
-    .option('-n, --project-name <name>', 'Project name (used when creating a new project)', '')
+    .requiredOption('-v, --version-name <version>', 'The version to deploy')
+    .option('-d, --version-description <description>', 'The description of the version')
     .action((0, config_utils_1.handler)(async (arg, context) => {
     const listener = new cli_listener_1.CliListener(context);
     const builder = await (0, build_1.build)(listener);
@@ -30,9 +32,11 @@ cli_1.cloudCli
     const deployment = await cloud_api_1.cloudApi
         .createDeployment({
         apiKey: arg.apiKey,
-        versionName: arg.versionName,
-        environmentId: arg.environmentId,
         projectName: arg.projectName,
+        environmentId: arg.environmentId,
+        environmentName: arg.environmentName,
+        versionName: arg.versionName,
+        versionDescription: arg.versionDescription,
     })
         .catch((error) => {
         context.log('creating-deployment', (message) => message.tag('failed').append('Failed to create deployment'));

package/dist/cjs/cloud/new-deployment/cloud-api/create-deployment.d.ts

@@ -1,8 +1,10 @@
 type CreateDeploymentRequest = {
     apiKey: string;
+    projectName?: string;
     environmentId?: string;
+    environmentName?: string;
     versionName: string;
-    projectName?: string;
+    versionDescription?: string;
 };
 type CreateDeploymentResult = {
     deploymentId: string;

package/dist/cjs/cloud/new-deployment/cloud-api/index.d.ts

@@ -11,9 +11,11 @@ export declare const cloudApi: {
     }>;
     createDeployment: (request: {
         apiKey: string;
+        projectName?: string;
         environmentId?: string;
+        environmentName?: string;
         versionName: string;
-        projectName?: string;
+        versionDescription?: string;
     }) => Promise<{
         deploymentId: string;
         deploymentToken: string;

package/dist/cjs/create/templates/python/steps/state_audit_cron_step.py.txt

@@ -2,7 +2,7 @@ from datetime import datetime, timezone
 
 config = {
     "type": "cron",
-    "cron": "*/5 * * * *",  # run every 5 minutes
+    "cron": "0 0 * * 1", # run once every Monday at midnight
     "name": "StateAuditJob",
     "description": "Checks the state for orders that are not complete and have a ship date in the past",
     "emits": ["notification"],

package/dist/cjs/create/templates/typescript/steps/state-audit-cron.step.ts.txt

@@ -2,7 +2,7 @@ import { CronConfig, Handlers } from 'motia'
 
 export const config: CronConfig = {
   type: 'cron',
-  cron: '*/5 * * * *', // run every 5 minutes
+  cron: '0 0 * * 1', // run once every Monday at midnight
   name: 'StateAuditJob',
   description: 'Checks the state for orders that are not complete and have a ship date in the past',
   emits: ['notification'],

package/dist/cjs/cursor-rules/index.js

@@ -9,7 +9,9 @@ const path_1 = __importDefault(require("path"));
 const colors_1 = __importDefault(require("colors"));
 const AI_GUIDES_VERSION = '1.0.0';
 const CURSOR_RULES_SOURCE = path_1.default.join(__dirname, '../../dot-files/.cursor/rules');
+const CLAUDE_SOURCE = path_1.default.join(__dirname, '../../dot-files/.claude');
 const TARGET_DIR = '.cursor/rules';
+const CLAUDE_TARGET_DIR = '.claude';
 async function handleAIGuides(options) {
     if (options.version) {
         console.log(colors_1.default.blue(`Motia AI Development Guides v${AI_GUIDES_VERSION}`));
@@ -50,11 +52,11 @@ async function pullAIGuides(force) {
         }
         // First, copy the essential AI development guides
         console.log(colors_1.default.blue('🤖 Installing AI Development Guides...'));
-        let claudePath = path_1.default.join(__dirname, '../../dot-files/CLAUDE.md');
+        let claudePath = path_1.default.join(__dirname, '../../dot-files/.claude/CLAUDE.md');
         let agentsPath = path_1.default.join(__dirname, '../../dot-files/AGENTS.md');
         // Try node_modules paths if local paths don't exist
         if (!fs_1.default.existsSync(claudePath)) {
-            claudePath = path_1.default.join('node_modules', '@motiadev/snap', 'dist', 'dot-files', 'CLAUDE.md');
+            claudePath = path_1.default.join('node_modules', '@motiadev/snap', 'dist', 'dot-files', '.claude', 'CLAUDE.md');
         }
         if (!fs_1.default.existsSync(agentsPath)) {
             agentsPath = path_1.default.join('node_modules', '@motiadev/snap', 'dist', 'dot-files', 'AGENTS.md');
@@ -89,18 +91,38 @@ async function pullAIGuides(force) {
             }
         }
         await copyDirectory(sourcePath, TARGET_DIR);
+        // Copy Claude IDE configurations
         console.log('');
-        console.log(colors_1.default.green('🎉 AI Development Guides & Cursor Rules installed successfully!'));
+        console.log(colors_1.default.blue('🧠 Installing Claude IDE Configurations...'));
+        if (!fs_1.default.existsSync(CLAUDE_TARGET_DIR) || force) {
+            if (fs_1.default.existsSync(CLAUDE_TARGET_DIR) && force) {
+                fs_1.default.rmSync(CLAUDE_TARGET_DIR, { recursive: true, force: true });
+            }
+            if (fs_1.default.existsSync(CLAUDE_SOURCE)) {
+                await copyDirectory(CLAUDE_SOURCE, CLAUDE_TARGET_DIR);
+                console.log(colors_1.default.green('✅ Claude IDE configurations installed'));
+            }
+            else {
+                console.log(colors_1.default.yellow('⚠️  Claude configurations not found - this is optional'));
+            }
+        }
+        else {
+            console.log(colors_1.default.yellow('⚠️  Claude configurations already exist. Use --force to overwrite.'));
+        }
+        console.log('');
+        console.log(colors_1.default.green('🎉 AI Development Guides, Cursor Rules & Claude Configs installed successfully!'));
         console.log('');
         console.log(colors_1.default.blue('📋 What you got:'));
         console.log(colors_1.default.gray('   • AGENTS.md - Universal guide for ANY AI tool (project root)'));
         console.log(colors_1.default.gray('   • CLAUDE.md - Specific guide for Claude AI assistant (project root)'));
         console.log(colors_1.default.gray(`   • Cursor Rules - IDE-specific patterns (${TARGET_DIR})`));
+        console.log(colors_1.default.gray(`   • Claude Configs - Claude IDE configurations (${CLAUDE_TARGET_DIR})`));
         console.log('');
         console.log(colors_1.default.blue('📁 File locations:'));
         console.log(colors_1.default.gray(`   ./AGENTS.md`));
         console.log(colors_1.default.gray(`   ./CLAUDE.md`));
         console.log(colors_1.default.gray(`   ${path_1.default.resolve(TARGET_DIR)}/`));
+        console.log(colors_1.default.gray(`   ${path_1.default.resolve(CLAUDE_TARGET_DIR)}/`));
         console.log('');
         console.log(colors_1.default.blue('🚀 Next steps:'));
         console.log(colors_1.default.gray('   1. Open AGENTS.md to understand Motia development patterns'));
@@ -214,6 +236,13 @@ async function removeAIGuides() {
         console.log(colors_1.default.yellow('🗑️  Removed .cursor/rules/'));
         removed = true;
     }
+    // Remove Claude configurations directory
+    if (fs_1.default.existsSync(CLAUDE_TARGET_DIR)) {
+        console.log(colors_1.default.yellow('🗑️  Removing Claude configurations...'));
+        fs_1.default.rmSync(CLAUDE_TARGET_DIR, { recursive: true, force: true });
+        console.log(colors_1.default.yellow('🗑️  Removed .claude/'));
+        removed = true;
+    }
     if (removed) {
         console.log(colors_1.default.green('✅ AI development guides and cursor rules removed successfully!'));
     }

package/dist/cjs/install.js

@@ -11,6 +11,7 @@ const activate_python_env_1 = require("./utils/activate-python-env");
 const install_lambda_python_packages_1 = require("./utils/install-lambda-python-packages");
 const generate_locked_data_1 = require("./generate-locked-data");
 const python_version_utils_1 = require("./utils/python-version-utils");
+const ensure_uv_1 = require("./utils/ensure-uv");
 const pythonInstall = async ({ baseDir, isVerbose = false, pythonVersion = '3.13', }) => {
     const venvPath = path_1.default.join(baseDir, 'python_modules');
     console.log('📦 Installing Python dependencies...', venvPath);
@@ -30,6 +31,10 @@ const pythonInstall = async ({ baseDir, isVerbose = false, pythonVersion = '3.13
             await (0, execute_command_1.executeCommand)(`${pythonCmd} -m venv python_modules`, baseDir);
         }
         (0, activate_python_env_1.activatePythonVenv)({ baseDir, isVerbose, pythonVersion });
+        // Ensure UV is installed
+        console.log('🔧 Checking UV installation...');
+        await (0, ensure_uv_1.ensureUvInstalled)();
+        console.log('✅ UV is available');
         (0, install_lambda_python_packages_1.installLambdaPythonPackages)({ isVerbose, requirementsList });
         // Install requirements
         console.log('📥 Installing Python dependencies...');

package/dist/cjs/utils/ensure-uv.d.ts

@@ -0,0 +1 @@
+export declare const ensureUvInstalled: () => Promise<void>;