motia 0.5.12-beta.120 → 0.6.0-beta.120

package/dist/cjs/cli.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-require-imports */
 const commander_1 = require("commander");
 require("./cloud");
 const version_1 = require("./version");
 const config_utils_1 = require("./cloud/config-utils");
+const inquirer_1 = __importDefault(require("inquirer"));
 const defaultPort = 3000;
 const defaultHost = '0.0.0.0';
 require('dotenv/config');
@@ -28,14 +32,23 @@ commander_1.program
     .option('-c, --cursor', 'Copy .cursor folder from template')
     .option('-i, --interactive', 'Use interactive prompts to create project')
     .option('-y, --skip-confirmation', 'Skip confirmation prompt')
+    .option('-d, --skip-tutorial', 'Skip the motia tutorial', false)
     .action((0, config_utils_1.handler)(async (arg, context) => {
     if (arg.name || arg.template || arg.cursor) {
         const { create } = require('./create');
+        const disableTutorial = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'disableTutorial',
+            message: 'Do you wish to disable the motia tutorial?',
+            default: arg.skipTutorial,
+            when: () => arg.skipTutorial === false,
+        });
         await create({
             projectName: arg.name ?? '.',
             template: arg.template ?? 'default',
             cursorEnabled: arg.cursor,
             context,
+            skipTutorialTemplates: disableTutorial.disableTutorial,
         });
     }
     else {
@@ -143,6 +156,14 @@ generate
         stepFilePath: arg.dir,
     });
 });
+generate
+    .command('tutorial-flow')
+    .description('Download the tutorial flow into an existing motia project')
+    .action((0, config_utils_1.handler)(async (_, context) => {
+    const { createTutorialFlow } = require('./create/setup-tutorial-flow');
+    await createTutorialFlow({ context });
+    process.exit(0);
+}));
 const docker = commander_1.program.command('docker').description('Motia docker commands');
 docker
     .command('setup')

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

@@ -4,6 +4,7 @@ type Args = {
     template?: string;
     cursorEnabled?: boolean;
     context: CliContext;
+    skipTutorialTemplates?: boolean;
 };
 export declare const create: ({ projectName, template, cursorEnabled, context }: Args) => Promise<void>;
 export {};

package/dist/cjs/create/index.js

@@ -6,35 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const templates_1 = require("./templates");
 const execute_command_1 = require("../utils/execute-command");
 const install_1 = require("../install");
 const generate_types_1 = require("../generate-types");
 const version_1 = require("../version");
+const setup_template_1 = require("./setup-template");
+const utils_1 = require("./utils");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
     transpileOnly: true,
     compilerOptions: { module: 'commonjs' },
 });
-const checkIfFileExists = (dir, fileName) => {
-    return fs_1.default.existsSync(path_1.default.join(dir, fileName));
-};
-const checkIfDirectoryExists = (dir) => {
-    try {
-        return fs_1.default.statSync(dir).isDirectory();
-    }
-    catch {
-        return false;
-    }
-};
 const getPackageManager = (dir) => {
-    if (checkIfFileExists(dir, 'yarn.lock')) {
+    if ((0, utils_1.checkIfFileExists)(dir, 'yarn.lock')) {
         return 'yarn';
     }
-    else if (checkIfFileExists(dir, 'pnpm-lock.yaml')) {
+    else if ((0, utils_1.checkIfFileExists)(dir, 'pnpm-lock.yaml')) {
         return 'pnpm';
     }
-    else if (checkIfFileExists(dir, 'package-lock.json')) {
+    else if ((0, utils_1.checkIfFileExists)(dir, 'package-lock.json')) {
         return 'npm';
     }
     else {
@@ -97,14 +87,14 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         '\n\n');
     const isCurrentDir = projectName === '.' || projectName === './' || projectName === '.\\';
     const rootDir = isCurrentDir ? process.cwd() : path_1.default.join(process.cwd(), projectName);
-    if (!isCurrentDir && !checkIfDirectoryExists(rootDir)) {
+    if (!isCurrentDir && !(0, utils_1.checkIfDirectoryExists)(rootDir)) {
         fs_1.default.mkdirSync(path_1.default.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'));
     }
-    if (!checkIfFileExists(rootDir, 'package.json')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, 'package.json')) {
         const packageJsonContent = {
             name: projectName,
             description: '',
@@ -144,7 +134,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
             .append('command to')
             .append('package.json', 'gray'));
     }
-    if (!checkIfFileExists(rootDir, 'tsconfig.json')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, 'tsconfig.json')) {
         const tsconfigContent = {
             compilerOptions: {
                 target: 'ES2020',
@@ -167,7 +157,7 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
         fs_1.default.writeFileSync(path_1.default.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.'));
     }
-    if (!checkIfFileExists(rootDir, '.gitignore')) {
+    if (!(0, utils_1.checkIfFileExists)(rootDir, '.gitignore')) {
         const gitignoreContent = [
             'node_modules',
             'python_modules',
@@ -183,24 +173,28 @@ const create = async ({ projectName, template, cursorEnabled, context }) => {
     }
     const cursorTemplateDir = path_1.default.join(__dirname, '../../dot-files/.cursor');
     const cursorTargetDir = path_1.default.join(rootDir, '.cursor');
-    if (cursorEnabled && !checkIfDirectoryExists(cursorTargetDir)) {
+    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.'));
     }
     const stepsDir = path_1.default.join(rootDir, 'steps');
-    if (!checkIfDirectoryExists(stepsDir)) {
+    if (!(0, utils_1.checkIfDirectoryExists)(stepsDir)) {
         fs_1.default.mkdirSync(stepsDir);
         context.log('steps-directory-created', (message) => message.tag('success').append('Folder').append('steps', 'cyan').append('has been created.'));
     }
-    if (!template || !(template in templates_1.templates)) {
-        context.log('template-not-found', (message) => message.tag('failed').append(`Template ${template} not found, please use one of the following:`));
-        context.log('available-templates', (message) => message.tag('info').append(`Available templates: \n\n ${Object.keys(templates_1.templates).join('\n')}`));
-        return;
+    if (!(0, utils_1.checkIfDirectoryExists)(path_1.default.join(stepsDir, 'basic-tutorial'))) {
+        fs_1.default.mkdirSync(path_1.default.join(stepsDir, 'basic-tutorial'));
+    }
+    await (0, setup_template_1.setupTemplate)('basic-tutorial', stepsDir, context);
+    if (template) {
+        if (!(0, utils_1.checkIfDirectoryExists)(path_1.default.join(stepsDir, template))) {
+            fs_1.default.mkdirSync(path_1.default.join(stepsDir, template));
+        }
+        await (0, setup_template_1.setupTemplate)(template, stepsDir, context);
     }
-    await templates_1.templates[template](rootDir, context);
     const packageManager = await installNodeDependencies(rootDir, context);
     if (template === 'python') {
-        if (!checkIfFileExists(rootDir, 'requirements.txt')) {
+        if (!(0, utils_1.checkIfFileExists)(rootDir, 'requirements.txt')) {
             const requirementsContent = [
             // TODO: motia PyPi package
             // Add other Python dependencies as needed

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

@@ -0,0 +1,2 @@
+import { CliContext } from '@/cloud/config-utils';
+export declare const setupTemplate: (template: string, rootDir: string, context: CliContext) => Promise<void>;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTemplate = void 0;
+const templates_1 = require("./templates");
+const setupTemplate = async (template, rootDir, context) => {
+    if (!template || !(template in templates_1.templates)) {
+        context.log('template-not-found', (message) => message.tag('failed').append(`Template ${template} not found, please use one of the following:`));
+        context.log('available-templates', (message) => message.tag('info').append(`Available templates: \n\n ${Object.keys(templates_1.templates).join('\n')}`));
+        return;
+    }
+    await templates_1.templates[template](rootDir, context);
+};
+exports.setupTemplate = setupTemplate;

package/dist/cjs/create/setup-tutorial-flow.d.ts

@@ -0,0 +1,6 @@
+import { CliContext } from '@/cloud/config-utils';
+type Args = {
+    context: CliContext;
+};
+export declare const createTutorialFlow: ({ context }: Args) => Promise<void>;
+export {};

package/dist/cjs/create/setup-tutorial-flow.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTutorialFlow = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+const setup_template_1 = require("./setup-template");
+const createTutorialFlow = async ({ context }) => {
+    const rootDir = process.cwd();
+    if (!(0, utils_1.checkIfFileExists)(rootDir, 'motia-workbench.json')) {
+        context.log('invalid-project', (message) => message
+            .tag('failed')
+            .append('In order to setup the Motia tutorial you need to be in a valid Motia project, motia-workbench.json not found, if this is not a Motia project you can create one using the motia create cli command.'));
+        return;
+    }
+    const stepsDir = path_1.default.join(rootDir, 'steps');
+    if (!(0, utils_1.checkIfDirectoryExists)(stepsDir)) {
+        fs_1.default.mkdirSync(stepsDir);
+        context.log('steps-directory-created', (message) => message.tag('success').append('Folder').append('steps', 'cyan').append('has been created.'));
+    }
+    if (!(0, utils_1.checkIfDirectoryExists)(path_1.default.join(stepsDir, 'basic-tutorial'))) {
+        fs_1.default.mkdirSync(path_1.default.join(stepsDir, 'basic-tutorial'));
+    }
+    await (0, setup_template_1.setupTemplate)('basic-tutorial', stepsDir, context);
+    context.log('tutorial-flow-setup-completed', (message) => message.tag('success').append('Tutorial flow setup completed, you can now start the tutorial from Workbench.'));
+};
+exports.createTutorialFlow = createTutorialFlow;

package/dist/cjs/create/templates/basic-tutorial/01-api.step.ts.txt

@@ -0,0 +1,58 @@
+import { ApiRouteConfig, Handlers } from 'motia'
+import { z } from 'zod'
+import { petStoreService } from './services/pet-store'
+
+export const config: ApiRouteConfig = {
+  type: 'api',
+  name: 'ApiTrigger',
+  description: 'basic-tutorial api trigger',
+  flows: ['basic-tutorial'],
+
+  method: 'POST',
+  path: '/basic-tutorial',
+  bodySchema: z.object({
+    pet: z.object({
+      name: z.string(),
+      photoUrl: z.string(),
+    }),
+    foodOrder: z
+      .object({
+        id: z.string(),
+        quantity: z.number(),
+      })
+      .optional(),
+  }),
+  responseSchema: {
+    200: z.object({
+      message: z.string(),
+      traceId: z.string(),
+    }),
+  },
+  emits: ['process-food-order'],
+}
+
+export const handler: Handlers['ApiTrigger'] = async (req, { logger, emit, traceId }) => {
+  logger.info('Step 01 – Processing API Step', { body: req.body })
+
+  const { pet, foodOrder } = req.body
+
+  const newPetRecord = await petStoreService.createPet(pet)
+
+  if (foodOrder) {
+    await emit({
+      topic: 'process-food-order',
+      data: {
+        ...foodOrder,
+        petId: newPetRecord.id,
+      },
+    })
+  }
+
+  return {
+    status: 200,
+    body: {
+      traceId,
+      message: 'Your pet has been registered and your order is being processed',
+    },
+  }
+}

package/dist/cjs/create/templates/basic-tutorial/02-process-food-order.step.ts.txt

@@ -0,0 +1,30 @@
+import { EventConfig, Handlers } from 'motia'
+import { z } from 'zod'
+import { petStoreService } from './services/pet-store'
+
+export const config: EventConfig = {
+  type: 'event',
+  name: 'ProcessFoodOrder',
+  description: 'basic-tutorial event step, demonstrates how to consume an event from a topic and persist data in state',
+  flows: ['basic-tutorial'],
+  subscribes: ['process-food-order'],
+  emits: ['new-order-notification'],
+  input: z.object({
+    id: z.string(),
+    quantity: z.number(),
+    petId: z.number(),
+  }),
+}
+
+export const handler: Handlers['ProcessFoodOrder'] = async (input, { traceId, logger, state, emit }) => {
+  logger.info('Step 02 – Process food order', { input, traceId })
+
+  const order = await petStoreService.createOrder(input)
+
+  await state.set<string>('orders', order.id, order)
+
+  await emit({
+    topic: 'new-order-notification',
+    data: { order_id: order.id },
+  })
+}

package/dist/cjs/create/templates/basic-tutorial/03-state-audit-cron.step.ts.txt

@@ -0,0 +1,42 @@
+import { CronConfig, Handlers } from 'motia'
+
+export const config: CronConfig = {
+  type: 'cron' as const,
+  name: 'StateAuditJob',
+  description: 'Runs every minute and emits a timestamp',
+  cron: '*/5 * * * *', // run every hour at minute 0
+  emits: ['order-audit-error', 'order-audit-warning'],
+  flows: ['basic-tutorial'],
+}
+
+export const handler: Handlers['StateAuditJob'] = async ({ state, emit }) => {
+  const stateValue = await state.getGroup<{
+    id: number
+    petId: number
+    quantity: number
+    shipDate: string
+    status: string
+    complete: boolean
+  }>('orders')
+
+  if (!Array.isArray(stateValue)) {
+    await emit({
+      topic: 'state-audit-error',
+      data: { message: 'State value is not an array' },
+    })
+
+    return
+  }
+
+  for (const item of stateValue) {
+    // check if current date is after item.shipDate
+    const currentDate = new Date()
+    const shipDate = new Date(item.shipDate)
+    if (!item.complete && currentDate > shipDate) {
+      await emit({
+        topic: 'order-audit-warning',
+        data: { message: 'Order is not complete and ship date is past' },
+      })
+    }
+  }
+}

package/dist/cjs/create/templates/basic-tutorial/04_new_order_notifications.step.py.txt

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, Field
+
+class NewOrderNotificationInput(BaseModel):
+    order_id: str = Field(description="pet store order id")
+
+config = {
+    "type": "event",
+    "name": "NewOrderNotifications",
+    "description": "Checks a state change using python",
+    "subscribes": ["new-order-notification"],
+    "emits": [],
+    "flows": ["basic-tutorial"],
+    "input": NewOrderNotificationInput.model_json_schema(),
+}
+
+async def handler(input, ctx):
+    ctx.logger.info('Processing NewOrderNotifications', input)
+    ctx.logger.info('[NewOrderNotifications] order id', input.get('order_id'))
+
+    order = await ctx.state.get('orders', input.get('order_id'))
+    
+    # This represents a call to some sort of notification service ot indicate that a new order has been placed
+    ctx.logger.info('New order notification sent using Python: ', {
+        'order_id': input.get('order_id'),
+        'order': order,
+        'trace_id': ctx.trace_id
+    })

package/dist/cjs/create/templates/basic-tutorial/motia-workbench.json

@@ -0,0 +1,28 @@
+[
+  {
+    "id": "basic-tutorial",
+    "config": {
+      "steps/basic-tutorial/04_new_order_notifications.step.py": {
+        "x": 668,
+        "y": 266,
+        "targetHandlePosition": "left"
+      },
+      "steps/basic-tutorial/03-state-audit-cron.step.ts": {
+        "x": 224,
+        "y": 520
+      },
+      "steps/basic-tutorial/02-process-food-order.step.ts": {
+        "x": 220,
+        "y": 242,
+        "sourceHandlePosition": "right",
+        "targetHandlePosition": "left"
+      },
+      "steps/basic-tutorial/01-api.step.ts": {
+        "x": -243,
+        "y": 199,
+        "sourceHandlePosition": "right",
+        "targetHandlePosition": "left"
+      }
+    }
+  }
+]

package/dist/cjs/create/templates/basic-tutorial/services/pet-store.ts.txt

@@ -0,0 +1,32 @@
+export const petStoreService = {
+  createPet: async (pet: { name: string; photoUrl: string }) => {
+    const response = await fetch('https://petstore.swagger.io/v2/pet', {
+      method: 'POST',
+      body: JSON.stringify({
+        name: pet.name,
+        photoUrls: [pet.photoUrl],
+        status: 'available',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    return response.json()
+  },
+  createOrder: async (order: { id: string; quantity: number; petId: number }) => {
+    const response = await fetch('https://petstore.swagger.io/v2/store/order', {
+      method: 'POST',
+      body: JSON.stringify({
+        id: order.id,
+        quantity: order.quantity,
+        petId: order.petId,
+        shipDate: new Date().toISOString(),
+        status: 'placed',
+      }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+    return response.json()
+  },
+}

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

@@ -1,3 +1,3 @@
 import { CliContext } from '../../cloud/config-utils';
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>;
-export declare const generateTemplateSteps: (templateDir: string) => Generator;
+export declare const generateTemplateSteps: (templateFolder: string) => Generator;

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

@@ -37,20 +37,40 @@ exports.generateTemplateSteps = void 0;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const glob_1 = require("glob");
-const generateTemplateSteps = (templateDir) => {
+const generateTemplateSteps = (templateFolder) => {
     return async (rootDir, context) => {
-        const templatePath = path.join(__dirname, templateDir);
+        const templatePath = path.join(__dirname, templateFolder);
         const files = (0, glob_1.globSync)('**/*', { absolute: false, cwd: templatePath });
         try {
             for (const fileName of files) {
                 const filePath = path.join(templatePath, fileName);
-                if ((0, fs_1.statSync)(filePath).isDirectory()) {
+                if ((0, fs_1.statSync)(filePath).isDirectory() && !filePath.match(/services|utils|lib/)) {
                     // ignore folders
                     continue;
                 }
+                if ((0, fs_1.statSync)(filePath).isDirectory()) {
+                    const folderPath = path.basename(filePath);
+                    (0, fs_1.mkdirSync)(path.join(rootDir, templateFolder, folderPath));
+                    continue;
+                }
                 const sanitizedFileName = fileName.replace('.txt', '');
-                const generateFilePath = path.join(rootDir, sanitizedFileName);
-                const content = await fs_1.promises.readFile(filePath, 'utf8');
+                const isWorkbenchConfig = fileName.match('motia-workbench.json');
+                const generateFilePath = path.join(...(isWorkbenchConfig
+                    ? [rootDir.match(/steps/) ? path.join(rootDir, '..') : rootDir, sanitizedFileName]
+                    : [rootDir, templateFolder, sanitizedFileName]));
+                let content = await fs_1.promises.readFile(filePath, 'utf8');
+                // Make sure statSync doesn't break the execution if the file doesn't exist
+                try {
+                    if (isWorkbenchConfig && (0, fs_1.statSync)(generateFilePath).isFile()) {
+                        const existingWorkbenchConfig = await fs_1.promises.readFile(generateFilePath, '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.'));
+                    }
+                }
+                catch {
+                    void 0;
+                }
                 await fs_1.promises.writeFile(generateFilePath, content, 'utf8');
                 context.log(sanitizedFileName, (message) => {
                     message.tag('success').append('File').append(sanitizedFileName, 'cyan').append('has been created.');

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

@@ -1,27 +1,54 @@
-import { promises as fs, statSync } from 'fs'
+import { promises as fs, statSync, mkdirSync } from 'fs'
 import * as path from 'path'
 import { globSync } from 'glob'
 import { CliContext } from '../../cloud/config-utils'
 
 export type Generator = (rootDir: string, context: CliContext) => Promise<void>
 
-export const generateTemplateSteps = (templateDir: string): Generator => {
+export const generateTemplateSteps = (templateFolder: string): Generator => {
   return async (rootDir: string, context: CliContext): Promise<void> => {
-    const templatePath = path.join(__dirname, templateDir)
+    const templatePath = path.join(__dirname, templateFolder)
     const files = globSync('**/*', { absolute: false, cwd: templatePath })
 
     try {
       for (const fileName of files) {
         const filePath = path.join(templatePath, fileName)
 
-        if (statSync(filePath).isDirectory()) {
+        if (statSync(filePath).isDirectory() && !filePath.match(/services|utils|lib/)) {
           // ignore folders
           continue
         }
 
+        if (statSync(filePath).isDirectory()) {
+          const folderPath = path.basename(filePath)
+          mkdirSync(path.join(rootDir, templateFolder, folderPath))
+          continue
+        }
+
         const sanitizedFileName = fileName.replace('.txt', '')
-        const generateFilePath = path.join(rootDir, sanitizedFileName)
-        const content = await fs.readFile(filePath, 'utf8')
+        const isWorkbenchConfig = fileName.match('motia-workbench.json')
+        const generateFilePath = path.join(
+          ...(isWorkbenchConfig
+            ? [rootDir.match(/steps/) ? path.join(rootDir, '..') : rootDir, sanitizedFileName]
+            : [rootDir, templateFolder, sanitizedFileName]),
+        )
+        let content = await fs.readFile(filePath, 'utf8')
+
+        // Make sure statSync doesn't break the execution if the file doesn't exist
+        try {
+          if (isWorkbenchConfig && statSync(generateFilePath).isFile()) {
+            const existingWorkbenchConfig = await fs.readFile(generateFilePath, '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.'),
+            )
+          }
+        } catch {
+          void 0
+        }
 
         await fs.writeFile(generateFilePath, content, 'utf8')
         context.log(sanitizedFileName, (message) => {

package/dist/cjs/create/templates/index.js

@@ -5,4 +5,5 @@ const generate_1 = require("./generate");
 exports.templates = {
     default: (0, generate_1.generateTemplateSteps)('default'),
     python: (0, generate_1.generateTemplateSteps)('python'),
+    'basic-tutorial': (0, generate_1.generateTemplateSteps)('basic-tutorial'),
 };

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

@@ -3,4 +3,5 @@ import { generateTemplateSteps, Generator } from './generate'
 export const templates: Record<string, Generator> = {
   default: generateTemplateSteps('default'),
   python: generateTemplateSteps('python'),
+  'basic-tutorial': generateTemplateSteps('basic-tutorial'),
 }

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

@@ -0,0 +1,2 @@
+export declare const checkIfFileExists: (dir: string, fileName: string) => boolean;
+export declare const checkIfDirectoryExists: (dir: string) => boolean;

package/dist/cjs/create/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfDirectoryExists = exports.checkIfFileExists = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const checkIfFileExists = (dir, fileName) => {
+    return fs_1.default.existsSync(path_1.default.join(dir, fileName));
+};
+exports.checkIfFileExists = checkIfFileExists;
+const checkIfDirectoryExists = (dir) => {
+    try {
+        return fs_1.default.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+exports.checkIfDirectoryExists = checkIfDirectoryExists;

package/dist/cjs/docker/utils/print-intro.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable no-useless-escape */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printMotiaDockerIntro = void 0;
 const printMotiaDockerIntro = () => {