motia 0.6.3-beta.130-601955 → 0.6.3-beta.130-538881

package/dist/cjs/cli.js

@@ -149,44 +149,5 @@ docker
     await build(arg.projectName);
     process.exit(0);
 });
-const rules = commander_1.program
-    .command('rules')
-    .description('Manage Motia AI development guides (AGENTS.md, CLAUDE.md) and IDE-specific rules');
-rules
-    .command('pull')
-    .description('Install essential AI development guides (AGENTS.md, CLAUDE.md) and optional Cursor IDE rules')
-    .option('-f, --force', 'Overwrite existing files')
-    .action(async (options) => {
-    const { handleAIGuides } = require('./cursor-rules');
-    await handleAIGuides({ force: options.force });
-});
-rules
-    .command('list')
-    .description('List available AI development guides and IDE rules')
-    .action(async () => {
-    const { handleAIGuides } = require('./cursor-rules');
-    await handleAIGuides({ list: true });
-});
-rules
-    .command('show <rule-name>')
-    .description('Show content of a specific AI guide or IDE rule')
-    .action(async (ruleName) => {
-    const { handleAIGuides } = require('./cursor-rules');
-    await handleAIGuides({ show: ruleName });
-});
-rules
-    .command('remove')
-    .description('Remove AI development guides and IDE rules from your project')
-    .action(async () => {
-    const { handleAIGuides } = require('./cursor-rules');
-    await handleAIGuides({ remove: true });
-});
-rules
-    .command('version')
-    .description('Show AI development guides version')
-    .action(async () => {
-    const { handleAIGuides } = require('./cursor-rules');
-    await handleAIGuides({ version: true });
-});
 commander_1.program.version(version_1.version, '-V, --version', 'Output the current version');
 commander_1.program.parse(process.argv);

package/dist/cjs/create/index.d.ts

@@ -1,8 +1,8 @@
 import { CliContext } from '../cloud/config-utils';
 type Args = {
     projectName: string;
-    template?: string;
-    cursorEnabled?: boolean;
+    template: string;
+    cursorEnabled: boolean;
     context: CliContext;
     skipTutorialTemplates?: boolean;
 };

package/dist/cjs/create/index.js

@@ -170,11 +170,21 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.join(rootDir, '.gitignore'), gitignoreContent);
         context.log('gitignore-created', (message) => message.tag('success').append('File').append('.gitignore', 'cyan').append('has been created.'));
     }
-    const cursorTemplateDir = path_1.default.join(__dirname, '../../dot-files/.cursor');
-    const cursorTargetDir = path_1.default.join(rootDir, '.cursor');
-    if (cursorEnabled && !(0, utils_1.checkIfDirectoryExists)(cursorTargetDir)) {
-        fs_1.default.cpSync(cursorTemplateDir, cursorTargetDir, { recursive: true });
-        context.log('cursor-folder-created', (message) => message.tag('success').append('Folder').append('.cursor', 'cyan').append('has been created.'));
+    if (cursorEnabled) {
+    }
+    const cursorTemplateDir = path_1.default.join(__dirname, '..', 'cursor-rules', 'dot-files');
+    const files = fs_1.default.readdirSync(cursorTemplateDir);
+    for (const file of files) {
+        const targetFile = path_1.default.join(rootDir, file);
+        if (!(0, utils_1.checkIfDirectoryExists)(targetFile)) {
+            const isFolder = fs_1.default.statSync(path_1.default.join(cursorTemplateDir, file)).isDirectory();
+            fs_1.default.cpSync(path_1.default.join(cursorTemplateDir, file), targetFile, { recursive: isFolder });
+            context.log(`${file}-created`, (message) => message
+                .tag('success')
+                .append(isFolder ? 'Folder' : 'File')
+                .append(file, 'cyan')
+                .append('has been created.'));
+        }
     }
     if (template) {
         await (0, setup_template_1.setupTemplate)(template, rootDir, context);

package/dist/cjs/cursor-rules/dot-files/.claude/CLAUDE.md

@@ -0,0 +1,224 @@
+# Build ANY Backend with Motia
+
+Welcome! This guide helps you build production-ready backends using Motia's unified framework. Whether you're building an e-commerce platform, social network, AI application, or IoT system - Motia handles it all.
+
+## The One Concept You Need: Steps
+
+In Motia, everything is a "Step":
+- **API endpoints** → API steps
+- **Background jobs** → Event steps  
+- **Scheduled tasks** → Cron steps
+- **External webhooks** → Noop steps
+
+That's it. Master this one concept and you can build anything.
+
+## Choose Your Language Based on the Task
+
+```
+JavaScript → Quick APIs, prototypes, real-time features
+TypeScript → Enterprise APIs, complex business logic  
+Python    → AI/ML, data science, image processing
+Ruby      → Reports, data exports, file manipulation
+```
+
+## Quick Start Commands
+
+```bash
+# Start any backend in 30 seconds
+motia create my-backend
+cd my-backend
+motia dev
+
+# Your backend is now running at http://localhost:5173
+```
+
+## Build Your Backend - Step by Step
+
+### 1. Need a REST API?
+See `commands/build-api.md`
+
+### 2. Need Authentication? 
+See `commands/add-authentication.md`
+
+### 3. Need Background Jobs?
+See `commands/process-background-jobs.md`
+
+### 4. Need Real-time Features?
+See `commands/add-realtime.md`
+
+### 5. Need AI/ML Processing?
+See `commands/integrate-ai.md`
+
+### 6. Need Data Processing?
+See `commands/process-data.md`
+
+## Complete Application Templates
+
+### E-commerce Backend
+```bash
+motia generate ecommerce
+# Includes: cart, payments, inventory, recommendations
+```
+
+### SaaS Platform
+```bash
+motia generate saas  
+# Includes: multi-tenant, billing, admin, analytics
+```
+
+### Real-time Chat
+```bash
+motia generate chat
+# Includes: rooms, messages, presence, history
+```
+
+### AI Application
+```bash
+motia generate ai-app
+# Includes: LLM integration, embeddings, RAG
+```
+
+## Core Pattern: API → Process → Respond
+
+Here's how different languages work together in Motia:
+
+```javascript
+// Step 1: API endpoint (JavaScript - quick & simple)
+// steps/api/submit-form.step.js
+exports.config = {
+  type: 'api',
+  method: 'POST', 
+  path: '/submit',
+  emits: ['form.submitted']
+}
+
+exports.handler = async (req, { emit }) => {
+  await emit({
+    topic: 'form.submitted',
+    data: req.body
+  })
+  return { status: 200, body: { message: 'Processing...' } }
+}
+```
+
+```python
+# Step 2: Process with AI (Python - best for ML)
+# steps/process_form_step.py
+config = {
+    "type": "event",
+    "subscribes": ["form.submitted"],
+    "emits": ["email.send"]
+}
+
+async def handler(input_data, ctx):
+    # AI processing here
+    result = analyze_sentiment(input_data["message"])
+    
+    await ctx.emit({
+        "topic": "email.send",
+        "data": {
+            "to": input_data["email"],
+            "sentiment": result
+        }
+    })
+```
+
+```ruby
+# Step 3: Generate and send email (Ruby - great for templates)
+# steps/send_email.step.rb
+def config
+  {
+    type: 'event',
+    subscribes: ['email.send'],
+    emits: ['email.sent']
+  }
+end
+
+def handler(input, context)
+  html = generate_email_template(input)
+  send_email(input['to'], html)
+  
+  context.emit(
+    topic: 'email.sent',
+    data: { recipient: input['to'] }
+  )
+end
+```
+
+## Production Checklist
+
+- [ ] Add authentication (`commands/add-authentication.md`)
+- [ ] Set up error handling (`commands/handle-errors.md`)
+- [ ] Configure rate limiting (`commands/add-rate-limiting.md`)
+- [ ] Add monitoring (`commands/add-monitoring.md`)
+- [ ] Deploy to production (`commands/deploy.md`)
+
+## Project Structure
+
+```
+your-app/
+├── steps/              # All your code goes here
+│   ├── api/           # API endpoints
+│   ├── events/        # Background jobs
+│   ├── cron/          # Scheduled tasks
+│   └── integrations/  # External webhooks
+├── package.json       # JavaScript dependencies
+├── requirements.txt   # Python dependencies
+└── Gemfile           # Ruby dependencies
+```
+
+## Common Questions
+
+**Q: Which language should I use?**
+A: Use the language that best fits the task:
+- APIs & web logic → JavaScript/TypeScript
+- AI & data science → Python
+- Reports & file processing → Ruby
+
+**Q: How do I handle errors?**
+A: Every example includes error handling. Copy the patterns.
+
+**Q: Can I use my favorite npm/pip/gem packages?**
+A: Yes! Just add them to package.json, requirements.txt, or Gemfile.
+
+**Q: How do I scale?**
+A: Motia scales horizontally. Just run more instances.
+
+## Quick Reference
+
+### Building Features
+- **Build API**: `commands/build-api.md`
+- **Add Auth**: `commands/add-authentication.md`
+- **Background Jobs**: `commands/process-background-jobs.md`
+- **Real-time**: `commands/add-realtime.md`
+- **AI/ML**: `commands/integrate-ai.md`
+- **Data Processing**: `commands/process-data.md`
+
+### Complete Examples
+- **Full Backend**: `commands/complete-backend.md`
+- **Backend Types**: `commands/backend-types.md`
+- **Multi-language**: `commands/multi-language-workflow.md`
+
+### Help & Tools
+- **Debug Issues**: `agents/debugger.md`
+- **Review Code**: `agents/code-reviewer.md`
+- **Write Tests**: `agents/test-runner.md`
+
+## Get Started Now
+
+Don't overthink it. Pick a template, copy the code, and start building. Motia handles the complex stuff so you can focus on your business logic.
+
+```bash
+# Your backend in 3 commands
+motia create awesome-app
+cd awesome-app
+motia dev
+
+# You're ready to build!
+```
+
+## Resources
+
+- Documentation: https://motia.dev/docs
+- Examples: https://github.com/MotiaDev/motia-examples
+- Discord: https://discord.gg/motia

package/dist/cjs/cursor-rules/dot-files/.claude/README.md

@@ -0,0 +1,45 @@
+# Claude Assistant Configuration for Motia
+
+This directory contains AI assistant configuration following the Claude Code directory structure.
+
+## Directory Structure
+
+```
+.claude/
+├── CLAUDE.md         # Main instructions and overview
+├── commands/         # Slash commands for common tasks
+│   ├── create-api.md
+│   ├── process-events.md
+│   ├── multi-language.md
+│   └── deploy.md
+├── agents/           # Specialized AI agents
+│   ├── code-reviewer.md
+│   ├── test-runner.md
+│   └── debugger.md
+├── hooks/            # Lifecycle automation scripts
+│   ├── pre-commit.sh
+│   └── post-deploy.sh
+└── settings.json     # Configuration and preferences
+```
+
+## Usage
+
+When working with Claude on Motia projects:
+
+1. Claude will automatically reference `CLAUDE.md` for context
+2. Use slash commands like `/create-api` to trigger specific patterns
+3. Agents activate automatically based on keywords (e.g., "review", "test", "debug")
+4. Hooks can be integrated with your git and deployment workflows
+
+## Customization
+
+Feel free to:
+- Add new command patterns in `commands/`
+- Create specialized agents in `agents/`
+- Modify `settings.json` for your preferences
+- Update `CLAUDE.md` with project-specific context
+
+## Learn More
+
+- [Motia Documentation](https://motia.dev/docs)
+- [Claude Code Documentation](https://docs.anthropic.com/en/docs/claude-code)

package/dist/cjs/cursor-rules/dot-files/.claude/agents/code-reviewer.md

@@ -0,0 +1,153 @@
+# Code Reviewer Agent
+
+Specialized agent for reviewing Motia code for best practices, security, and performance.
+
+## Review Checklist
+
+### Step Configuration
+- [ ] Correct step type (api/event/cron/noop)
+- [ ] Descriptive step name
+- [ ] Input/output schemas defined with Zod
+- [ ] Appropriate events emitted
+- [ ] Middleware applied correctly
+
+### Code Quality
+- [ ] Error handling with try-catch
+- [ ] Structured logging with context
+- [ ] No hardcoded values
+- [ ] DRY principle followed
+- [ ] Functions are focused and small
+
+### Security
+- [ ] Input validation on all endpoints
+- [ ] Authentication required where needed
+- [ ] No sensitive data in logs
+- [ ] SQL injection prevention
+- [ ] XSS protection
+
+### Performance
+- [ ] No blocking operations
+- [ ] Efficient state queries
+- [ ] Proper use of caching
+- [ ] Batch operations where appropriate
+- [ ] Connection pooling
+
+### TypeScript Specific
+```typescript
+// Good ✓
+export const handler: Handlers['StepName'] = async (req, { emit, logger, state }) => {
+  try {
+    // Validate
+    if (!req.body.userId) {
+      return { status: 400, body: { error: 'userId required' } }
+    }
+    
+    // Process
+    const result = await processData(req.body)
+    
+    // Emit event
+    await emit({ topic: 'data.processed', data: result })
+    
+    // Log success
+    logger.info('Processing complete', { userId: req.body.userId })
+    
+    return { status: 200, body: result }
+  } catch (error) {
+    logger.error('Processing failed', { error: error.message })
+    return { status: 500, body: { error: 'Internal error' } }
+  }
+}
+
+// Bad ✗
+export const handler = async (req, ctx) => {
+  const data = await processData(req.body) // No error handling
+  console.log(data) // Using console.log
+  return data // Wrong return format
+}
+```
+
+### Python Specific
+```python
+# Good ✓
+async def handler(input_data, ctx):
+    try:
+        # Validate input
+        if not input_data.get("userId"):
+            raise ValueError("userId required")
+        
+        # Process
+        result = process_data(input_data)
+        
+        # Emit event
+        await ctx.emit({
+            "topic": "data.processed",
+            "data": result
+        })
+        
+        ctx.logger.info("Processing complete", extra={"userId": input_data["userId"]})
+        
+    except Exception as e:
+        ctx.logger.error(f"Processing failed: {str(e)}")
+        raise
+
+# Bad ✗
+def handler(input, ctx):  # Not async
+    data = process(input)
+    print(data)  # Using print
+    return data  # Returning instead of emitting
+```
+
+### Common Issues
+
+1. **Missing Error Handling**
+   - Always wrap in try-catch
+   - Log errors with context
+   - Return appropriate status codes
+
+2. **Poor State Management**
+   - Use consistent key patterns
+   - Set TTL for temporary data
+   - Clean up after processing
+
+3. **Event Anti-patterns**
+   - Avoid circular dependencies
+   - Don't emit too many events
+   - Keep event data minimal
+
+4. **Security Vulnerabilities**
+   - Never trust user input
+   - Sanitize all outputs
+   - Use parameterized queries
+
+## Review Comments Template
+
+```
+### Code Review: [Step Name]
+
+**Overall**: [Good/Needs Work/Critical Issues]
+
+**Strengths**:
+- ✓ [Positive aspect]
+- ✓ [Another good point]
+
+**Issues Found**:
+- ⚠️ **[Category]**: [Description]
+  ```typescript
+  // Current code
+  ```
+  **Suggestion**:
+  ```typescript
+  // Improved code
+  ```
+
+**Security Concerns**:
+- 🔒 [Any security issues]
+
+**Performance Considerations**:
+- ⚡ [Performance improvements]
+
+**Recommended Actions**:
+1. [High priority fix]
+2. [Medium priority improvement]
+3. [Nice to have enhancement]
+```