motia 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,51 @@
+# Motia Snap
+
+Motia Snap is a command-line interface tool to get your Motia project setup.
+
+## Installation
+
+To install the CLI globally, run:
+
+```sh
+npm install -g @motiadev/snap
+```
+
+## Usage
+
+Below are the available commands for the Motia Snap:
+
+### `motia init`
+
+Initializes a new Motia project in the current directory.
+
+```sh
+motia init
+```
+
+### `motia build`
+
+Builds a lock file based on your current project setup which is then used by the Motia ecosystem.
+
+```sh
+motia build
+```
+
+### `motia dev`
+
+Initiates a dev environment for your project allowing you to use Motia Workbench (visualization tool for your flows).
+
+```sh
+motia dev
+```
+
+## Help
+
+For more information on a specific command, you can use the `--help` flag:
+
+```sh
+motia <command> --help
+```
+
+## License
+
+This project is licensed under the MIT License.

package/dist/src/cli.js

@@ -0,0 +1,44 @@
+#!/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 });
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const defaultPort = 3000;
+require('dotenv/config');
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+commander_1.program
+    .command('dev')
+    .description('Start the development server')
+    .option('-p, --port <port>', 'The port to run the server on', `${defaultPort}`)
+    .option('-d, --debug', 'Enable debug logging')
+    .action(async (arg) => {
+    if (arg.debug) {
+        console.log('🔍 Debug logging enabled');
+        process.env.LOG_LEVEL = 'debug';
+    }
+    const port = arg.port ? parseInt(arg.port) : defaultPort;
+    const { dev } = require('./dev');
+    await dev(port);
+});
+commander_1.program
+    .command('get-config')
+    .description('Get the generated config for your project')
+    .option('-o, --output <port>', 'Path to write the generated config')
+    .action(async (arg) => {
+    const { generateLockedData } = require('./src/generate/locked-data');
+    const lockedData = await generateLockedData(path_1.default.join(process.cwd()));
+    if (arg.output) {
+        const fs = require('fs');
+        fs.writeFileSync(path_1.default.join(arg.output, '.motia.generated.json'), JSON.stringify(lockedData, null, 2));
+        console.log(`📄 Wrote locked data to ${arg.output}`);
+        return;
+    }
+    console.log(JSON.stringify(lockedData, null, 2));
+});
+commander_1.program.parse(process.argv);

package/dist/src/dev.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = void 0;
+const core_1 = require("@motiadev/core");
+const generate_locked_data_1 = require("./generate-locked-data");
+const path_1 = __importDefault(require("path"));
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+const dev = async (port) => {
+    const lockedData = await (0, generate_locked_data_1.generateLockedData)(process.cwd());
+    const steps = [...lockedData.steps.active, ...lockedData.steps.dev];
+    const eventManager = (0, core_1.createEventManager)();
+    const state = (0, core_1.createStateAdapter)({
+        adapter: 'default',
+        filePath: path_1.default.join(process.cwd(), '.motia'),
+    });
+    await state.init();
+    const { app, server } = await (0, core_1.createServer)({ steps, state, flows: lockedData.flows, eventManager });
+    (0, core_1.createStepHandlers)(steps, eventManager, state);
+    server.listen(port);
+    console.log('🚀 Server ready and listening on port', port);
+    console.log(`🔗 Open http://localhost:${port}/ to open workbench 🛠️`);
+    const { applyMiddleware } = require('@motiadev/workbench/dist/middleware');
+    await applyMiddleware(app);
+    // 6) Gracefully shut down on SIGTERM
+    process.on('SIGTERM', async () => {
+        core_1.globalLogger.info('🛑 Shutting down...');
+        server.close();
+        process.exit(0);
+    });
+};
+exports.dev = dev;

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

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateLockedData = void 0;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const core_1 = require("@motiadev/core");
+const version = `${(0, crypto_1.randomUUID)()}:${Math.floor(Date.now() / 1000)}`;
+const baseFlowRegex = new RegExp(/flows\"?\s?.*\s*\[([^\]]+)\]/);
+// Helper function to read config.yml
+const readConfig = (configPath) => {
+    if (!fs_1.default.existsSync(configPath)) {
+        console.warn(`Config file not found at ${configPath}`);
+        return {};
+    }
+    const configContent = fs_1.default.readFileSync(configPath, 'utf-8');
+    return yaml_1.default.parse(configContent);
+};
+const extractStepConfig = (filePath) => {
+    const isRb = filePath.endsWith('.rb');
+    const isPython = filePath.endsWith('.py');
+    const isNode = filePath.endsWith('.js') || filePath.endsWith('.ts');
+    if (isRb) {
+        return (0, core_1.getRubyConfig)(filePath);
+    }
+    if (isPython) {
+        return (0, core_1.getPythonConfig)(filePath);
+    }
+    if (isNode) {
+        return (0, core_1.getNodeFileConfig)(filePath);
+    }
+};
+// Helper function to recursively collect flow data
+const collectFlows = async (baseDir) => {
+    const folderItems = fs_1.default.readdirSync(baseDir, { withFileTypes: true });
+    let steps = [];
+    for (const item of folderItems) {
+        const itemPath = path_1.default.join(baseDir, item.name);
+        if (item.isDirectory()) {
+            steps = steps.concat(await collectFlows(itemPath));
+        }
+        else if (!!item.name.match(/\.step\.(ts|js|py|rb)$/)) {
+            const fileContent = fs_1.default.readFileSync(itemPath, 'utf-8');
+            const flowMatch = fileContent.match(baseFlowRegex);
+            const config = await extractStepConfig(itemPath);
+            if (!config) {
+                console.warn(`No config found in step ${itemPath}, step skipped`);
+                continue;
+            }
+            if (flowMatch) {
+                steps.push({
+                    // TODO: when the lock file comes back, this needs to be updated to use a relative path
+                    filePath: itemPath,
+                    version,
+                    config,
+                });
+            }
+        }
+    }
+    return steps;
+};
+const generateLockedData = async (projectDir) => {
+    const configPath = path_1.default.join(projectDir, 'config.yml');
+    // NOTE: right now for performance and simplicity let's enforce a folder, but we might want to remove this and scan the entire current directory
+    const stepsPath = path_1.default.join(projectDir, 'steps');
+    try {
+        const config = readConfig(configPath);
+        // Collect steps data from steps folder
+        const sourceSteps = await collectFlows(stepsPath);
+        const { flows, steps } = sourceSteps.reduce((acc, step) => {
+            const nextSteps = { ...acc.steps };
+            // NOTE: identifies a noop step
+            if (step.config.virtualEmits) {
+                nextSteps.dev.push(step);
+            }
+            else {
+                nextSteps.active.push(step);
+            }
+            const nextFlows = { ...acc.flows };
+            step.config.flows.forEach((flowName) => {
+                if (!nextFlows[flowName]) {
+                    nextFlows[flowName] = {
+                        name: flowName,
+                        // TODO: how are we going to extract descriptions?
+                        description: '',
+                        steps: [],
+                    };
+                }
+                nextFlows[flowName].steps.push(step);
+            });
+            return {
+                ...acc,
+                steps: nextSteps,
+                flows: nextFlows,
+            };
+        }, {
+            flows: {},
+            steps: {
+                active: [],
+                dev: [],
+            },
+        });
+        // Prepare the lock file data
+        const lockedData = {
+            baseDir: projectDir,
+            state: config?.state || {},
+            steps,
+            flows,
+        };
+        console.log('Project config loaded');
+        // TODO: for now this will return the locked data as an object, in the future we will write it to a lock file
+        return lockedData;
+    }
+    catch (error) {
+        console.error('Error generating locked data:', error);
+        throw Error('Failed to parse the project, generating locked data step failed');
+    }
+};
+exports.generateLockedData = generateLockedData;

package/package.json

@@ -1,11 +1,24 @@
 {
   "name": "motia",
-  "version": "0.0.1",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.0.2",
+  "bin": {
+    "motia": "dist/src/cli.js"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.7",
+    "commander": "^13.0.0",
+    "ts-node": "^10.9.2",
+    "yaml": "^2.7.0",
+    "@motiadev/core": "0.0.10",
+    "@motiadev/workbench": "0.0.9"
   },
-  "author": "",
-  "license": "ISC",
-  "description": ""
-}
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc"
+  }
+}