motia 0.5.11-beta.120-492039 → 0.5.11-beta.120-356715

package/dist/cjs/cloud/build/builder.js

@@ -51,11 +51,15 @@ class Builder {
         const pythonBuilder = this.builders.get('python');
         this.routersConfig = {};
         if (nodeSteps.length > 0 && nodeBuilder) {
-            const { path } = await nodeBuilder.buildApiSteps(nodeSteps);
+            this.listener.onApiRouterBuilding('node');
+            const { size, path } = await nodeBuilder.buildApiSteps(nodeSteps);
+            this.listener.onApiRouterBuilt('node', size);
             this.routersConfig.node = path;
         }
         if (pythonSteps.length > 0 && pythonBuilder) {
-            const { path } = await pythonBuilder.buildApiSteps(pythonSteps);
+            this.listener.onApiRouterBuilding('python');
+            const { size, path } = await pythonBuilder.buildApiSteps(pythonSteps);
+            this.listener.onApiRouterBuilt('python', size);
             this.routersConfig.python = path;
         }
     }

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

@@ -74,14 +74,8 @@ class NodeBuilder {
             .readFileSync(path_1.default.join(__dirname, 'router-template.ts'), 'utf-8')
             .replace('// {{imports}}', steps.map((step, index) => `import * as route${index} from '${getStepPath(step)}'`).join('\n'))
             .replace('// {{router paths}}', steps
-            .map((step, index) => {
-            this.listener.onBuildStart(step);
-            const route = `'${step.config.method} ${step.config.path}': { stepName: '${step.config.name}', handler: route${index}.handler, config: route${index}.config }`;
-            this.listener.onBuildEnd(step);
-            return route;
-        })
+            .map((step, index) => `'${step.config.method} ${step.config.path}': { stepName: '${step.config.name}', handler: route${index}.handler, config: route${index}.config }`)
             .join(',\n'));
-        this.listener.onApiRouterBuilding('node');
         const tsRouter = path_1.default.join(constants_1.distDir, 'router.ts');
         fs_1.default.writeFileSync(tsRouter, file);
         const userConfig = await this.loadEsbuildConfig();
@@ -104,7 +98,6 @@ class NodeBuilder {
         fs_1.default.unlinkSync(tsRouter);
         fs_1.default.unlinkSync(routerJs);
         fs_1.default.unlinkSync(routerMap);
-        this.listener.onApiRouterBuilt('node', size);
         return { size, path: zipName };
     }
     async build(step) {

package/dist/cjs/cloud/build/builders/python/add-package-to-archive.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addPackageToArchive = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const colors_1 = __importDefault(require("colors"));
 const shouldIgnore = (filePath) => {
     const ignorePatterns = [/\.pyc$/, /\.egg$/, /__pycache__/, /\.dist-info$/];
     return ignorePatterns.some((pattern) => pattern.test(filePath));
@@ -30,24 +31,26 @@ const addDirectoryToArchive = async (archive, baseDir, dirPath) => {
         .filter(Boolean));
 };
 const addPackageToArchive = async (archive, sitePackagesDir, packageName) => {
-    const packageNameVariations = [packageName, `${packageName}.py`];
-    // Iterate over all possible package name variations
-    for (const pkg of packageNameVariations) {
-        let fullPath = path_1.default.join(sitePackagesDir, pkg);
-        if (!fs_1.default.existsSync(fullPath)) {
-            // If not found, try next package name variation
-            continue;
+    // First try the package name as is
+    let fullPath = path_1.default.join(sitePackagesDir, packageName);
+    // If not found, try with .py extension
+    if (!fs_1.default.existsSync(fullPath)) {
+        const pyPath = path_1.default.join(sitePackagesDir, `${packageName}.py`);
+        if (fs_1.default.existsSync(pyPath)) {
+            fullPath = pyPath;
         }
-        const stat = fs_1.default.statSync(fullPath);
-        if (stat.isDirectory()) {
-            await addDirectoryToArchive(archive, sitePackagesDir, fullPath);
-        }
-        else {
-            const relativePath = path_1.default.relative(sitePackagesDir, fullPath);
-            archive.append(fs_1.default.createReadStream(fullPath), relativePath);
-        }
-        // package added successfully
+    }
+    if (!fs_1.default.existsSync(fullPath)) {
+        console.log(colors_1.default.yellow(`Warning: Package not found in site-packages: ${packageName}`));
         return;
     }
+    const stat = fs_1.default.statSync(fullPath);
+    if (stat.isDirectory()) {
+        await addDirectoryToArchive(archive, sitePackagesDir, fullPath);
+    }
+    else {
+        const relativePath = path_1.default.relative(sitePackagesDir, fullPath);
+        archive.append(fs_1.default.createReadStream(fullPath), relativePath);
+    }
 };
 exports.addPackageToArchive = addPackageToArchive;

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

@@ -23,33 +23,41 @@ class PythonBuilder {
         const normalizedEntrypointPath = entrypointPath.replace(/[.]step.py$/, '_step.py');
         const sitePackagesDir = `${process.env.PYTHON_SITE_PACKAGES}-lambda`;
         // Get Python builder response
-        const { packages, files } = await this.getPythonBuilderData(step);
+        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}`);
         }
         archive.append(fs_1.default.createReadStream(step.filePath), path_1.default.relative(this.builder.projectDir, normalizedEntrypointPath));
-        files.forEach((file) => archive.append(fs_1.default.createReadStream(file), path_1.default.relative(this.builder.projectDir, file)));
-        if (packages.length > 0) {
-            await Promise.all(packages.map((pkg) => (0, add_package_to_archive_1.addPackageToArchive)(archive, sitePackagesDir, pkg.name)));
-            this.listener.onBuildProgress(step, `Added ${packages.length} packages to archive`);
-        }
+        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);
         try {
             // Create output directory
             fs_1.default.mkdirSync(path_1.default.dirname(outfile), { recursive: true });
             this.listener.onBuildStart(step);
-            // Create the step zip archive
+            // Get Python builder response
+            const { packages } = await this.getPythonBuilderData(step);
             const stepArchiver = new archiver_1.Archiver(outfile);
-            // Build the step
             const stepPath = await this.buildStep(step, stepArchiver);
-            // Add static files to the archive
+            // Add main file to archive
+            if (!fs_1.default.existsSync(step.filePath)) {
+                throw new Error(`Source file not found: ${step.filePath}`);
+            }
+            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`);
+            }
             // Finalize the archive and wait for completion
             const size = await stepArchiver.finalize();
             this.builder.registerStep({ entrypointPath: stepPath, bundlePath, step, type: 'python' });
@@ -73,12 +81,9 @@ class PythonBuilder {
         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)));
-        await Promise.all(steps.map(async (step) => {
-            this.listener.onBuildStart(step);
+        for (const step of steps) {
             await this.buildStep(step, archive);
-            this.listener.onBuildEnd(step); // TODO: add size?
-        }));
-        this.listener.onApiRouterBuilding('python');
+        }
         const file = fs_1.default
             .readFileSync(path_1.default.join(__dirname, 'router_template.py'), 'utf-8')
             .replace('# {{imports}}', steps
@@ -91,12 +96,11 @@ class PythonBuilder {
         (0, include_static_files_1.includeStaticFiles)(steps, this.builder, archive);
         // Finalize the archive and wait for completion
         const size = await archive.finalize();
-        this.listener.onApiRouterBuilt('python', size);
         return { size, path: zipName };
     }
     async getPythonBuilderData(step) {
         return new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)('python', [path_1.default.join(__dirname, 'python-builder.py'), this.builder.projectDir, step.filePath], {
+            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'],
             });

package/dist/cjs/cloud/build/builders/python/python-builder.py

@@ -1,39 +1,221 @@
 import os
 import sys
 import json
+import importlib.util
 import traceback
+import site
+import builtins
+import ast
+import importlib.metadata
+import subprocess
+import re
+from typing import Set, List, Tuple, Optional, Dict, Any
+from pathlib import Path
+from functools import lru_cache
 
-from trace_packages import trace_packages
-from trace_project_files import trace_project_files
+NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
 
-NODEIPCFD = int(os.environ.get("NODE_CHANNEL_FD", 0))
+# Cache for built-in modules to avoid repeated checks
+_builtin_modules_cache: Set[str] = set()
 
-def main() -> None:
-    """Main entry point for the script."""
-    if len(sys.argv) != 3:
-        print("Usage: python python-builder.py <project_dir> <entry_file>")
-        sys.exit(2)
+@lru_cache(maxsize=1024)
+def is_valid_package_name(name: str) -> bool:
+    """Check if a name is a valid package name."""
+    if not name or name.startswith('_'):
+        return False
+    
+    # Skip common special cases
+    invalid_names = {'__main__', 'module', 'cython_runtime', 'builtins'}
+    return name not in invalid_names
+
+@lru_cache(maxsize=1024)
+def get_package_name(module_name: str) -> str:
+    """Get the top-level package name from a module name."""
+    return module_name.split('.')[0]
+
+@lru_cache(maxsize=1024)
+def clean_package_name(package_name: str) -> str:
+    """Clean package name by removing version specifiers and other metadata."""
+    # Remove version specifiers and conditions using regex
+    package_name = re.sub(r'[<>=~!;].*$', '', package_name)
+    # Remove any remaining whitespace and convert underscores to hyphens
+    return package_name.strip().replace('_', '-')
 
-    project_dir = os.path.abspath(sys.argv[1])
-    entry_file = os.path.abspath(sys.argv[2])
+@lru_cache(maxsize=1024)
+def extract_base_package_name(dependency_spec: str) -> str:
+    """
+    Extract the base package name from a complex dependency specification.
+    Handles cases like:
+    - 'package (>=1.2.1,<2.0.0)'
+    - 'package[extra] (>=1.2.1)'
+    - 'package ; extra == "vlm"'
+    - 'package (>=1.2.1) ; sys_platform == "darwin"'
+    """
+    # First, remove any conditions after semicolon
+    base_spec = dependency_spec.split(';')[0].strip()
+    
+    # Extract the package name before any version specifiers or extras
+    match = re.match(r'^([a-zA-Z0-9_.-]+)(?:\[[^\]]+\])?(?:\s*\([^)]*\))?$', base_spec)
+    
+    return clean_package_name(match.group(1) if match else base_spec)
 
+@lru_cache(maxsize=1024)
+def is_package_installed(package_name: str) -> bool:
+    """Check if a package is installed in the current environment."""
+    try:
+        # Try both hyphenated and non-hyphenated versions
+        try:
+            importlib.metadata.distribution(package_name)
+            return True
+        except importlib.metadata.PackageNotFoundError:
+            # Try with hyphens replaced by underscores
+            alt_name = package_name.replace('-', '_')
+            if alt_name != package_name:
+                importlib.metadata.distribution(alt_name)
+                return True
+            return False
+    except importlib.metadata.PackageNotFoundError:
+        return False
+
+@lru_cache(maxsize=1024)
+def is_builtin_module(module_name: str) -> bool:
+    """Check if a module is a Python built-in module."""
+    if module_name in _builtin_modules_cache:
+        return True
+        
     try:
-        # Find project dependencies
-        packages = trace_packages(project_dir, entry_file)
-        files = trace_project_files(project_dir, entry_file)
+        module = importlib.import_module(module_name)
         
-        # Prepare output
+        # Built-in modules either have no __file__ attribute or their file is in the standard library
+        if not hasattr(module, '__file__'):
+            _builtin_modules_cache.add(module_name)
+            return True
+            
+        # Get the standard library path
+        stdlib_path = os.path.dirname(os.__file__)
+        
+        # Check if the module's file is in the standard library
+        is_builtin = module.__file__ and module.__file__.startswith(stdlib_path)
+        if is_builtin:
+            _builtin_modules_cache.add(module_name)
+        return is_builtin
+    except ImportError:
+        return False
+
+def get_direct_imports(file_path: str) -> Set[str]:
+    """Extract direct imports from a Python file using AST parsing."""
+    direct_imports = set()
+    
+    try:
+        with open(file_path, 'r') as f:
+            content = f.read()
+        
+        tree = ast.parse(content)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for name in node.names:
+                    base_pkg = name.name.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    base_pkg = node.module.split('.')[0]
+                    if is_valid_package_name(base_pkg) and not is_builtin_module(base_pkg):
+                        direct_imports.add(base_pkg)
+    except Exception as e:
+        print(f"Warning: Could not parse imports from {file_path}: {str(e)}")
+    
+    return direct_imports
+
+@lru_cache(maxsize=1024)
+def is_optional_dependency(req: str) -> bool:
+    """Check if a dependency is an optional dependency."""
+    return '[' in req or 'extra ==' in req
+
+def get_package_dependencies(package_name: str, processed: Set[str] = None) -> Set[str]:
+    """Get all dependencies (including sub-dependencies) for a given package."""
+    if processed is None:
+        processed = set()
+    
+    if package_name in processed or is_builtin_module(package_name):
+        return set()
+    
+    processed.add(package_name)
+    all_dependencies = set()
+    
+    try:
+        # Try to get the distribution
+        try:
+            dist = importlib.metadata.distribution(package_name)
+        except importlib.metadata.PackageNotFoundError:
+            print(f'Warning: Package {package_name} not found')
+            return all_dependencies
+
+        # Filter out optional dependencies
+        sub_dependencies = list(filter(lambda dep: not is_optional_dependency(dep), dist.requires or []))
+        
+        # Get direct dependencies
+        for req in sub_dependencies:                
+            base_pkg = extract_base_package_name(req)
+            
+            if base_pkg and base_pkg not in processed:
+                # Try both hyphenated and non-hyphenated versions
+                for dep_name in [base_pkg, base_pkg.replace('-', '_'), base_pkg.replace('_', '-')]:
+                    try:
+                        importlib.import_module(dep_name)
+                        all_dependencies.add(dep_name)
+                        # Recursively get sub-dependencies
+                        all_dependencies.update(get_package_dependencies(dep_name, processed))
+                        break
+                    except ImportError:
+                        continue
+            
+    except Exception as e:
+        print(f"Warning: Error processing {package_name}: {str(e)}")
+    
+    return all_dependencies
+
+def trace_imports(entry_file: str) -> List[str]:
+    """Find all imported Python packages and files starting from an entry file."""
+    entry_file = os.path.abspath(entry_file)
+    module_dir = os.path.dirname(entry_file)
+    
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    
+    # Get direct imports from the entry file
+    direct_imports = get_direct_imports(entry_file)
+    
+    # Initialize sets to track packages
+    all_packages = set()
+    processed_packages = set()
+    
+    # Process each direct import and its dependencies
+    for package_name in direct_imports:
+        if is_valid_package_name(package_name):
+            all_packages.add(package_name)
+            # Get all dependencies including sub-dependencies
+            all_packages.update(get_package_dependencies(package_name, processed_packages))
+    
+    # Filter out built-in packages
+    non_builtin_packages = {pkg for pkg in all_packages if not is_builtin_module(pkg)}
+    
+    return sorted(list(non_builtin_packages))
+
+def main() -> None:
+    """Main entry point for the script."""
+    if len(sys.argv) != 2:
+        print("Usage: python python-builder.py <entry_file>", file=sys.stderr)
+        sys.exit(1)
+
+    entry_file = sys.argv[1]
+    try:
+        packages = trace_imports(entry_file)
         output = {
-            'packages': packages,
-            'files': files,
+            'packages': packages
         }
-        
-        # Output as JSON
         bytes_message = (json.dumps(output) + '\n').encode('utf-8')
-        if NODEIPCFD > 0:
-            os.write(NODEIPCFD, bytes_message)
-        else:
-            print(bytes_message)
+        os.write(NODEIPCFD, bytes_message)
         sys.exit(0)
     except Exception as e:
         print(f"Error: {str(e)}", file=sys.stderr)

package/dist/cjs/cloud/new-deployment/build.js

@@ -30,9 +30,8 @@ const build = async (listener) => {
     if (invalidSteps.length > 0) {
         throw new Error('Project contains invalid steps, please fix them before building');
     }
-    const stepPromises = lockedData.activeSteps.filter((step) => !(0, core_1.isApiStep)(step)).map((step) => builder.buildStep(step));
-    const apiStepPromise = builder.buildApiSteps(lockedData.activeSteps.filter(core_1.isApiStep));
-    await Promise.all([...stepPromises, apiStepPromise]);
+    await Promise.all(lockedData.activeSteps.map((step) => builder.buildStep(step)));
+    await builder.buildApiSteps(lockedData.activeSteps.filter(core_1.isApiStep));
     const streams = lockedData.listStreams();
     for (const stream of streams) {
         if (stream.config.baseConfig.storageType === 'default') {

package/dist/cjs/cloud/new-deployment/listeners/build-printer.d.ts

@@ -6,7 +6,7 @@ export declare class BuildPrinter {
     getLanguage(language: string): string;
     getStepLanguage(step: Step): string;
     printStepBuilding(step: Step, progressMessage?: string): void;
-    printStepBuilt(step: Step, size?: number): void;
+    printStepBuilt(step: Step, size: number): void;
     printApiRouterBuilding(language: string): void;
     printApiRouterBuilt(language: string, size: number): void;
     printStepFailed(step: Step, error: Error): void;

package/dist/cjs/cloud/new-deployment/listeners/build-printer.js

@@ -62,7 +62,7 @@ class BuildPrinter {
         const stepPath = this.printer.getStepPath(step);
         this.output.log(step.filePath, (message) => message
             .append(`${built} ${stepTag} ${stepLanguage} ${stepType} ${stepPath}`)
-            .append(`${size ? (0, pretty_bytes_1.prettyBytes)(size) : ''}`, 'gray'));
+            .append(`${(0, pretty_bytes_1.prettyBytes)(size)}`, 'gray'));
     }
     printApiRouterBuilding(language) {
         const fileName = `router-${language}.zip`;

package/dist/cjs/cloud/new-deployment/listeners/cli-listener.d.ts

@@ -11,7 +11,7 @@ export declare class CliListener implements DeploymentListener {
     constructor(context: CliContext);
     onBuildStart(step: Step): void;
     onBuildProgress(step: Step, message: string): void;
-    onBuildEnd(step: Step, size?: number): void;
+    onBuildEnd(step: Step, size: number): void;
     onBuildError(step: Step, error: Error): void;
     onBuildSkip(step: Step, reason: string): void;
     onStreamCreated(stream: Stream): void;

package/dist/cjs/cloud/new-deployment/listeners/listener.types.d.ts

@@ -5,7 +5,7 @@ import { ValidationError } from '../utils/validation';
 export type BuildListener = {
     onBuildStart: (step: Step) => void;
     onBuildProgress: (step: Step, message: string) => void;
-    onBuildEnd: (step: Step, size?: number) => void;
+    onBuildEnd: (step: Step, size: number) => void;
     onBuildError: (step: Step, error: Error) => void;
     onBuildSkip: (step: Step, reason: string) => void;
     onApiRouterBuilding: (language: string) => void;

package/dist/cjs/dev-watchers.js

@@ -8,9 +8,8 @@ const core_1 = require("@motiadev/core");
 const path_1 = __importDefault(require("path"));
 const watcher_1 = require("./watcher");
 const createDevWatchers = (lockedData, server, eventHandler, cronManager) => {
-    const projectDir = process.cwd();
-    const stepDir = path_1.default.join(projectDir, 'steps');
-    const watcher = new watcher_1.Watcher(projectDir, stepDir, lockedData);
+    const stepDir = path_1.default.join(process.cwd(), 'steps');
+    const watcher = new watcher_1.Watcher(stepDir, lockedData);
     watcher.onStreamChange((oldStream, stream) => {
         (0, core_1.trackEvent)('stream_updated', {
             streamName: stream.config.name,

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

@@ -27,7 +27,7 @@ const collectFlows = async (projectDir, lockedData) => {
         ...(0, glob_1.globSync)(path_1.default.join(projectDir, '{steps,streams}/**/*_stream.{ts,js,py}')),
     ];
     for (const filePath of stepFiles) {
-        const config = await (0, core_1.getStepConfig)(projectDir, filePath);
+        const config = await (0, core_1.getStepConfig)(filePath);
         if (!config) {
             console.warn(`No config found in step ${filePath}, step skipped`);
             continue;
@@ -38,7 +38,7 @@ const collectFlows = async (projectDir, lockedData) => {
         }
     }
     for (const filePath of streamFiles) {
-        const config = await (0, core_1.getStreamConfig)(projectDir, filePath);
+        const config = await (0, core_1.getStreamConfig)(filePath);
         if (!config) {
             console.warn(`No config found in stream ${filePath}, stream skipped`);
             continue;

package/dist/cjs/generate-types.js

@@ -15,13 +15,13 @@ const generateTypes = async (projectDir) => {
     const streamsFiles = (0, glob_1.globSync)('**/*.stream.{ts,js,py,rb}', { absolute: true, cwd: stepsDir });
     const lockedData = new core_1.LockedData(projectDir, 'memory', new core_1.Printer(projectDir));
     for (const filePath of files) {
-        const config = await (0, core_1.getStepConfig)(projectDir, filePath);
+        const config = await (0, core_1.getStepConfig)(filePath);
         if (config) {
             lockedData.createStep({ filePath, version, config }, { disableTypeCreation: true });
         }
     }
     for (const filePath of streamsFiles) {
-        const config = await (0, core_1.getStreamConfig)(projectDir, filePath);
+        const config = await (0, core_1.getStreamConfig)(filePath);
         if (config) {
             lockedData.createStream({ filePath, config }, { disableTypeCreation: true });
         }

package/dist/cjs/utils/install-lambda-python-packages.js

@@ -14,7 +14,7 @@ const installLambdaPythonPackages = ({ isVerbose = false, requirementsList }) =>
             if (isVerbose) {
                 internal_logger_1.internalLogger.warn(`requirements.txt not found at ${requirement}`);
             }
-            continue;
+            return;
         }
         try {
             // Install packages to lambda site-packages with platform specification

package/dist/cjs/watcher.d.ts

@@ -7,7 +7,6 @@ type StreamChangeHandler = (oldStream: Stream, newStream: Stream) => void;
 type StreamCreateHandler = (stream: Stream) => void;
 type StreamDeleteHandler = (stream: Stream) => void;
 export declare class Watcher {
-    private readonly baseDir;
     private readonly dir;
     private lockedData;
     private watcher?;
@@ -17,7 +16,7 @@ export declare class Watcher {
     private streamChangeHandler?;
     private streamCreateHandler?;
     private streamDeleteHandler?;
-    constructor(baseDir: string, dir: string, lockedData: LockedData);
+    constructor(dir: string, lockedData: LockedData);
     onStepChange(handler: StepChangeHandler): void;
     onStepCreate(handler: StepCreateHandler): void;
     onStepDelete(handler: StepDeleteHandler): void;

package/dist/cjs/watcher.js

@@ -8,8 +8,7 @@ const chokidar_1 = __importDefault(require("chokidar"));
 const crypto_1 = require("crypto");
 const core_1 = require("@motiadev/core");
 class Watcher {
-    constructor(baseDir, dir, lockedData) {
-        this.baseDir = baseDir;
+    constructor(dir, lockedData) {
         this.dir = dir;
         this.lockedData = lockedData;
     }
@@ -40,7 +39,7 @@ class Watcher {
             console.warn(`No step create handler, step skipped`);
             return;
         }
-        const config = await (0, core_1.getStepConfig)(this.baseDir, path).catch((err) => console.error(err));
+        const config = await (0, core_1.getStepConfig)(path).catch((err) => console.error(err));
         if (!config) {
             return;
         }
@@ -49,7 +48,7 @@ class Watcher {
         this.stepCreateHandler?.(step);
     }
     async onStepFileChange(path) {
-        const config = await (0, core_1.getStepConfig)(this.baseDir, path).catch((err) => {
+        const config = await (0, core_1.getStepConfig)(path).catch((err) => {
             console.error(err);
         });
         const step = this.findStep(path);
@@ -81,7 +80,7 @@ class Watcher {
         this.stepDeleteHandler?.(step);
     }
     async onStreamFileAdd(path) {
-        const config = await (0, core_1.getStreamConfig)(this.baseDir, path).catch((err) => console.error(err));
+        const config = await (0, core_1.getStreamConfig)(path).catch((err) => console.error(err));
         if (!config) {
             return;
         }
@@ -89,7 +88,7 @@ class Watcher {
     }
     async onStreamFileChange(path) {
         const stream = this.lockedData.findStream(path);
-        const config = await (0, core_1.getStreamConfig)(this.baseDir, path).catch((err) => console.error(err));
+        const config = await (0, core_1.getStreamConfig)(path).catch((err) => console.error(err));
         if (!stream && config) {
             this.streamCreateHandler?.({ filePath: path, config, factory: null });
         }