db4ai 0.3.0 → 0.3.1

package/dist/cli/scanner/index.js

@@ -1,640 +1,9 @@
-/**
- * Module 13: Project Scanner
- *
- * Scans project files to find schemas, seeds, and workflows.
- */
-import { readdir, readFile, stat, access } from 'fs/promises';
-import { join, relative } from 'path';
-import { parse } from '@babel/parser';
-import traverse from '@babel/traverse';
-import matter from 'gray-matter';
-import { minimatch } from 'minimatch';
-// ============================================================================
-// Default patterns
-// ============================================================================
-const DEFAULT_EXCLUDE = ['node_modules/**', 'dist/**', '**/*.test.ts', '**/*.spec.ts', 'tests/**', '__tests__/**'];
-// ============================================================================
-// Glob matching utilities
-// ============================================================================
-function matchesPatterns(filePath, patterns) {
-    // Separate positive and negative patterns
-    const positivePatterns = patterns.filter((p) => !p.startsWith('!'));
-    const negativePatterns = patterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1));
-    // Must match at least one positive pattern (or have no positive patterns)
-    const matchesPositive = positivePatterns.length === 0 || positivePatterns.some((p) => minimatch(filePath, p, { dot: true }));
-    // Must not match any negative pattern
-    const matchesNegative = negativePatterns.some((p) => minimatch(filePath, p, { dot: true }));
-    return matchesPositive && !matchesNegative;
-}
-function shouldIncludeFile(relativePath, include, exclude) {
-    // Check include patterns if provided
-    if (include && include.length > 0) {
-        if (!matchesPatterns(relativePath, include)) {
-            return false;
-        }
-    }
-    // Check exclude patterns
-    const excludePatterns = exclude || DEFAULT_EXCLUDE;
-    if (excludePatterns.some((p) => minimatch(relativePath, p, { dot: true }))) {
-        return false;
-    }
-    return true;
-}
-// ============================================================================
-// File scanning
-// ============================================================================
-async function* walkDirectory(dir, root) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        const relativePath = relative(root, fullPath);
-        if (entry.isDirectory()) {
-            // Skip node_modules and hidden directories by default
-            if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
-                continue;
-            }
-            yield* walkDirectory(fullPath, root);
-        }
-        else if (entry.isFile()) {
-            yield { path: fullPath, relativePath };
-        }
-    }
-}
-function parseTypeScript(content) {
-    try {
-        return {
-            ast: parse(content, {
-                sourceType: 'module',
-                plugins: ['typescript', 'jsx'],
-            }),
-        };
-    }
-    catch (err) {
-        return {
-            ast: null,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-/**
- * Extract a simple value from an AST node (strings, numbers, booleans, arrays, objects)
- */
-function extractValue(node) {
-    if (!node)
-        return undefined;
-    switch (node.type) {
-        case 'StringLiteral':
-            return node.value;
-        case 'NumericLiteral':
-            return node.value;
-        case 'BooleanLiteral':
-            return node.value;
-        case 'NullLiteral':
-            return null;
-        case 'ArrayExpression':
-            return node.elements.map((el) => extractValue(el));
-        case 'ObjectExpression':
-            return extractObjectValue(node);
-        case 'TemplateLiteral':
-            // Simple case: no expressions
-            if (node.expressions.length === 0 && node.quasis.length === 1) {
-                return node.quasis[0].value.cooked;
-            }
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-function extractObjectValue(node) {
-    const result = {};
-    for (const prop of node.properties) {
-        if (prop.type === 'ObjectProperty') {
-            const key = prop.key.type === 'Identifier' ? prop.key.name : prop.key.type === 'StringLiteral' ? prop.key.value : null;
-            if (key) {
-                result[key] = extractValue(prop.value);
-            }
-        }
-        else if (prop.type === 'SpreadElement') {
-            // Can't statically analyze spreads
-            continue;
-        }
-    }
-    return result;
-}
-function getImportsFromMdxai(ast) {
-    const imports = new Map();
-    traverse(ast, {
-        ImportDeclaration(path) {
-            const source = path.node.source.value;
-            if (source !== 'mdxai')
-                return;
-            for (const specifier of path.node.specifiers) {
-                if (specifier.type === 'ImportSpecifier') {
-                    const importedName = specifier.imported.type === 'Identifier' ? specifier.imported.name : specifier.imported.value;
-                    imports.set(specifier.local.name, {
-                        localName: specifier.local.name,
-                        importedName,
-                        source,
-                    });
-                }
-                else if (specifier.type === 'ImportNamespaceSpecifier') {
-                    // import * as mdxai from 'mdxai'
-                    imports.set(specifier.local.name, {
-                        localName: specifier.local.name,
-                        importedName: '*',
-                        source,
-                    });
-                }
-            }
-        },
-    });
-    return imports;
-}
-function isDBCall(callee, dbLocalName, namespaceImport) {
-    // Direct DB() call
-    if (callee.type === 'Identifier' && callee.name === 'DB') {
-        return dbLocalName === 'DB' || dbLocalName === null; // Allow bare DB() if no import check needed
-    }
-    // Aliased import: Database() where DB was imported as Database
-    if (callee.type === 'Identifier' && callee.name === dbLocalName) {
-        return true;
-    }
-    // Namespace import: mdxai.DB()
-    if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === namespaceImport && callee.property.type === 'Identifier' && callee.property.name === 'DB') {
-        return true;
-    }
-    return false;
-}
-function findDBExports(content, ast, imports, rejectNonMdxaiImports) {
-    const results = [];
-    // Track which variable declarations contain DB() calls
-    const dbVariables = new Map();
-    // Find the local name for DB (could be aliased)
-    let dbLocalName = null;
-    let namespaceImport = null;
-    let hasNonMdxaiDBImport = false;
-    for (const [localName, info] of imports) {
-        if (info.importedName === 'DB') {
-            dbLocalName = localName;
-        }
-        else if (info.importedName === '*') {
-            namespaceImport = localName;
-        }
-    }
-    // Check if there's a DB import from a non-mdxai package
-    traverse(ast, {
-        ImportDeclaration(path) {
-            const source = path.node.source.value;
-            if (source !== 'mdxai') {
-                for (const specifier of path.node.specifiers) {
-                    if (specifier.type === 'ImportSpecifier') {
-                        const importedName = specifier.imported.type === 'Identifier' ? specifier.imported.name : specifier.imported.value;
-                        if (importedName === 'DB') {
-                            hasNonMdxaiDBImport = true;
-                        }
-                    }
-                }
-            }
-        },
-    });
-    // If there's a DB import from a non-mdxai package, reject this file
-    if (rejectNonMdxaiImports && hasNonMdxaiDBImport) {
-        return [];
-    }
-    // If no explicit import, allow bare DB() calls
-    const effectiveDbName = dbLocalName || 'DB';
-    traverse(ast, {
-        // Handle: export default DB({...})
-        ExportDefaultDeclaration(path) {
-            const declaration = path.node.declaration;
-            if (declaration && declaration.type === 'CallExpression') {
-                const callee = declaration.callee;
-                if (isDBCall(callee, dbLocalName, namespaceImport) && declaration.arguments.length > 0) {
-                    const arg = declaration.arguments[0];
-                    if (arg.type === 'ObjectExpression') {
-                        const config = extractObjectValue(arg);
-                        const types = extractTypesFromConfig(config);
-                        results.push({
-                            exportName: 'default',
-                            config,
-                            types,
-                        });
-                    }
-                }
-            }
-        },
-        // Handle: export const schema = DB({...})
-        ExportNamedDeclaration(path) {
-            const declaration = path.node.declaration;
-            if (declaration && declaration.type === 'VariableDeclaration') {
-                for (const decl of declaration.declarations) {
-                    if (decl.id.type === 'Identifier' && decl.init && decl.init.type === 'CallExpression') {
-                        const callee = decl.init.callee;
-                        if (isDBCall(callee, dbLocalName, namespaceImport) && decl.init.arguments.length > 0) {
-                            const arg = decl.init.arguments[0];
-                            if (arg.type === 'ObjectExpression') {
-                                const config = extractObjectValue(arg);
-                                const types = extractTypesFromConfig(config);
-                                results.push({
-                                    exportName: decl.id.name,
-                                    config,
-                                    types,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            // Handle: export { schema }
-            if (path.node.specifiers) {
-                for (const specifier of path.node.specifiers) {
-                    if (specifier.type === 'ExportSpecifier') {
-                        const localName = specifier.local.name;
-                        if (dbVariables.has(localName)) {
-                            const info = dbVariables.get(localName);
-                            const exportedName = specifier.exported.type === 'Identifier' ? specifier.exported.name : specifier.exported.value;
-                            results.push({
-                                ...info,
-                                exportName: exportedName,
-                            });
-                        }
-                    }
-                }
-            }
-        },
-        // Track variable declarations that might be exported later
-        VariableDeclarator(path) {
-            if (path.node.id.type === 'Identifier' && path.node.init && path.node.init.type === 'CallExpression') {
-                const callee = path.node.init.callee;
-                if (isDBCall(callee, dbLocalName, namespaceImport) && path.node.init.arguments.length > 0) {
-                    const arg = path.node.init.arguments[0];
-                    if (arg.type === 'ObjectExpression') {
-                        const config = extractObjectValue(arg);
-                        const types = extractTypesFromConfig(config);
-                        dbVariables.set(path.node.id.name, {
-                            exportName: path.node.id.name,
-                            config,
-                            types,
-                        });
-                    }
-                }
-            }
-        },
-    });
-    return results;
-}
-function extractTypesFromConfig(config) {
-    const types = [];
-    for (const key of Object.keys(config)) {
-        // Skip special keys that start with $
-        if (!key.startsWith('$')) {
-            types.push(key);
-        }
-    }
-    return types;
-}
-function extractNamespace(config) {
-    // Try $id first
-    const id = config['$id'];
-    if (typeof id === 'string') {
-        // Handle URLs like 'https://db.sb/my-namespace'
-        if (id.includes('/')) {
-            const parts = id.split('/');
-            return parts[parts.length - 1];
-        }
-        return id;
-    }
-    // Try $context
-    const context = config['$context'];
-    if (typeof context === 'string') {
-        return context;
-    }
-    return undefined;
-}
-async function parseSchemaFile(filePath, relativePath, content, rejectNonMdxaiImports) {
-    const parseResult = parseTypeScript(content);
-    if (!parseResult.ast) {
-        return { schemas: null, error: parseResult.error };
-    }
-    const imports = getImportsFromMdxai(parseResult.ast);
-    const dbExports = findDBExports(content, parseResult.ast, imports, rejectNonMdxaiImports);
-    if (dbExports.length === 0)
-        return { schemas: null };
-    return {
-        schemas: dbExports.map((dbExport) => ({
-            path: filePath,
-            relativePath,
-            namespace: extractNamespace(dbExport.config),
-            types: dbExport.types,
-            exportName: dbExport.exportName,
-        })),
-    };
-}
-// ============================================================================
-// Seed file parsing
-// ============================================================================
-function findSeedOrGenerateExports(ast) {
-    let config = null;
-    traverse(ast, {
-        ExportDefaultDeclaration(path) {
-            const declaration = path.node.declaration;
-            if (declaration && declaration.type === 'CallExpression') {
-                const callee = declaration.callee;
-                // Check for Seed(...) or Generate(...)
-                if (callee.type === 'Identifier' && (callee.name === 'Seed' || callee.name === 'Generate')) {
-                    if (declaration.arguments.length > 0) {
-                        const arg = declaration.arguments[0];
-                        if (arg.type === 'ObjectExpression') {
-                            config = extractObjectValue(arg);
-                            // For Generate(), also capture the function name as a hint
-                            if (callee.name === 'Generate' && config && !config.prompt) {
-                                // Generate typically has a prompt, keep type from config
-                            }
-                        }
-                    }
-                }
-            }
-        },
-    });
-    return config;
-}
-async function parseSeedTsFile(filePath, relativePath, content) {
-    const parseResult = parseTypeScript(content);
-    if (!parseResult.ast) {
-        return { seed: null, error: parseResult.error };
-    }
-    const config = findSeedOrGenerateExports(parseResult.ast);
-    if (!config)
-        return { seed: null };
-    return {
-        seed: {
-            path: filePath,
-            relativePath,
-            format: 'ts',
-            targetType: config.type,
-            config,
-        },
-    };
-}
-async function parseSeedMdxFile(filePath, relativePath, content) {
-    try {
-        const { data: frontmatter, content: mdxContent } = matter(content);
-        // Extract prompt from MDX content (strip frontmatter)
-        const prompt = mdxContent.trim() || undefined;
-        const config = {
-            ...frontmatter,
-            prompt: (prompt || frontmatter.prompt),
-        };
-        return {
-            path: filePath,
-            relativePath,
-            format: 'mdx',
-            targetType: frontmatter.type,
-            config,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ============================================================================
-// Workflow file parsing
-// ============================================================================
-function findWorkflowExport(ast) {
-    let config = null;
-    traverse(ast, {
-        ExportDefaultDeclaration(path) {
-            const declaration = path.node.declaration;
-            if (declaration && declaration.type === 'CallExpression') {
-                const callee = declaration.callee;
-                // Check for Workflow(...)
-                if (callee.type === 'Identifier' && callee.name === 'Workflow') {
-                    if (declaration.arguments.length > 0) {
-                        const arg = declaration.arguments[0];
-                        if (arg.type === 'ObjectExpression') {
-                            config = extractObjectValue(arg);
-                        }
-                    }
-                }
-            }
-        },
-    });
-    return config;
-}
-async function parseWorkflowFile(filePath, relativePath, content) {
-    const parseResult = parseTypeScript(content);
-    if (!parseResult.ast) {
-        return { workflow: null, error: parseResult.error };
-    }
-    const config = findWorkflowExport(parseResult.ast);
-    if (!config)
-        return { workflow: null };
-    return {
-        workflow: {
-            path: filePath,
-            relativePath,
-            name: config.name,
-            trigger: config.trigger,
-            config,
-        },
-    };
-}
-// ============================================================================
-// Config file loading
-// ============================================================================
-async function loadProjectConfig(root) {
-    // Try .ts first, then .js
-    const configFiles = ['db4.config.ts', 'db4.config.js'];
-    for (const configFile of configFiles) {
-        const configPath = join(root, configFile);
-        try {
-            await access(configPath);
-            const content = await readFile(configPath, 'utf-8');
-            // Parse the config file
-            if (configFile.endsWith('.ts')) {
-                return parseTsConfig(content);
-            }
-            else {
-                return parseJsConfig(content);
-            }
-        }
-        catch {
-            // File doesn't exist or can't be read
-            continue;
-        }
-    }
-    return undefined;
-}
-function parseTsConfig(content) {
-    const parseResult = parseTypeScript(content);
-    if (!parseResult.ast)
-        return undefined;
-    let config;
-    traverse(parseResult.ast, {
-        ExportDefaultDeclaration(path) {
-            const declaration = path.node.declaration;
-            if (declaration && declaration.type === 'ObjectExpression') {
-                config = extractObjectValue(declaration);
-            }
-        },
-    });
-    return config;
-}
-function parseJsConfig(content) {
-    // Handle CommonJS: module.exports = { ... }
-    const parseResult = parseTypeScript(content);
-    if (!parseResult.ast)
-        return undefined;
-    let config;
-    traverse(parseResult.ast, {
-        AssignmentExpression(path) {
-            const left = path.node.left;
-            const right = path.node.right;
-            // Check for module.exports = { ... }
-            if (left.type === 'MemberExpression' && left.object.type === 'Identifier' && left.object.name === 'module' && left.property.type === 'Identifier' && left.property.name === 'exports' && right.type === 'ObjectExpression') {
-                config = extractObjectValue(right);
-            }
-        },
-    });
-    return config;
-}
-// ============================================================================
-// Main Scanner
-// ============================================================================
-export function createScanner(scannerConfig) {
-    const { root } = scannerConfig;
-    // Cache for incremental scanning
-    const cache = new Map();
-    async function scan(options = {}) {
-        const startTime = performance.now();
-        // Verify root directory exists
-        try {
-            const rootStat = await stat(root);
-            if (!rootStat.isDirectory()) {
-                throw new Error(`Not a directory: ${root}`);
-            }
-        }
-        catch (err) {
-            throw new Error(`Cannot access directory: ${root}`);
-        }
-        const schemas = [];
-        const seeds = [];
-        const workflows = [];
-        const errors = [];
-        // Load project config first (it may override include/exclude patterns)
-        const projectConfig = await loadProjectConfig(root);
-        // Determine effective include/exclude patterns
-        const includePatterns = scannerConfig.include || projectConfig?.scan?.include;
-        const excludePatterns = scannerConfig.exclude || projectConfig?.scan?.exclude;
-        // Walk the directory
-        for await (const { path: filePath, relativePath } of walkDirectory(root, root)) {
-            // Check file extension
-            const ext = filePath.slice(filePath.lastIndexOf('.'));
-            if (ext !== '.ts' && ext !== '.mdx') {
-                continue;
-            }
-            // Apply include/exclude filters
-            if (!shouldIncludeFile(relativePath, includePatterns, excludePatterns)) {
-                continue;
-            }
-            try {
-                const content = await readFile(filePath, 'utf-8');
-                // Skip empty files
-                if (!content.trim()) {
-                    continue;
-                }
-                // Determine file type and parse accordingly
-                if (relativePath.endsWith('.seed.ts')) {
-                    const result = await parseSeedTsFile(filePath, relativePath, content);
-                    if (result.error) {
-                        errors.push({ path: filePath, error: result.error });
-                    }
-                    else if (result.seed) {
-                        seeds.push(result.seed);
-                    }
-                }
-                else if (relativePath.endsWith('.seed.mdx')) {
-                    const seedFile = await parseSeedMdxFile(filePath, relativePath, content);
-                    if (seedFile) {
-                        seeds.push(seedFile);
-                    }
-                }
-                else if (relativePath.endsWith('.workflow.ts')) {
-                    const result = await parseWorkflowFile(filePath, relativePath, content);
-                    if (result.error) {
-                        errors.push({ path: filePath, error: result.error });
-                    }
-                    else if (result.workflow) {
-                        workflows.push(result.workflow);
-                    }
-                }
-                else if (relativePath.endsWith('.schema.ts') || relativePath.endsWith('.db.ts')) {
-                    // Schema files - allow bare DB() calls, reject non-mdxai imports
-                    const result = await parseSchemaFile(filePath, relativePath, content, true);
-                    if (result.error) {
-                        errors.push({ path: filePath, error: result.error });
-                    }
-                    else if (result.schemas) {
-                        schemas.push(...result.schemas);
-                    }
-                }
-                else if (ext === '.ts') {
-                    // Regular .ts files - allow bare DB() calls, reject non-mdxai imports
-                    const result = await parseSchemaFile(filePath, relativePath, content, true);
-                    if (result.error) {
-                        errors.push({ path: filePath, error: result.error });
-                    }
-                    else if (result.schemas) {
-                        schemas.push(...result.schemas);
-                    }
-                }
-            }
-            catch (err) {
-                errors.push({
-                    path: filePath,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        const duration = performance.now() - startTime;
-        const result = {
-            root,
-            schemas,
-            seeds,
-            workflows,
-            duration,
-        };
-        if (projectConfig) {
-            result.config = projectConfig;
-        }
-        if (errors.length > 0) {
-            result.errors = errors;
-        }
-        return result;
-    }
-    function watch(callback) {
-        // For now, just return a no-op unsubscribe function
-        // A full implementation would use fs.watch or chokidar
-        let isWatching = true;
-        // Do an initial scan (catch errors to avoid unhandled rejections)
-        scan()
-            .then((result) => {
-            if (isWatching) {
-                callback(result);
-            }
-        })
-            .catch(() => {
-            // Ignore errors if we've already unsubscribed
-        });
-        return () => {
-            isWatching = false;
-        };
-    }
-    return {
-        scan,
-        watch,
-    };
-}
-// Re-export minimatch for tests that might need it
-export { minimatch };
+import {
+  createScanner,
+  minimatch
+} from "../../chunk-Y5IXAS7F.js";
+export {
+  createScanner,
+  minimatch
+};
 //# sourceMappingURL=index.js.map