@koi-language/koi 1.0.0

package/src/compiler/import-resolver.js

@@ -0,0 +1,369 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { TypeScriptTranspiler } from './typescript-transpiler.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Resolves imports recursively and merges imported Skills and Agents into the main AST
+ */
+export class ImportResolver {
+  constructor(parse) {
+    this.parse = parse;
+    this.importedFiles = new Set(); // Track imported files to avoid circular imports
+    this.importedSkills = []; // Collect all imported Skills
+    this.importedAgents = []; // Collect all imported Agents
+    this.importedRoles = []; // Collect all imported Roles
+    this.importedTeams = []; // Collect all imported Teams
+    this.externalImports = []; // Track TypeScript/JavaScript imports
+    this.tsTranspiler = new TypeScriptTranspiler(); // TypeScript transpiler
+  }
+
+  /**
+   * Resolve all imports in an AST recursively
+   * @param {object} ast - The AST to process
+   * @param {string} sourceFile - The source file path (for resolving relative paths)
+   * @returns {object} - AST with imports resolved and all declarations merged
+   */
+  async resolveImports(ast, sourceFile) {
+    const sourceDir = path.dirname(sourceFile);
+    const imports = [];
+    const nonImportDecls = [];
+
+    // Separate imports from other declarations
+    for (const decl of ast.declarations) {
+      if (decl.type === 'ImportDecl') {
+        imports.push(decl);
+      } else {
+        nonImportDecls.push(decl);
+      }
+    }
+
+    // Process each import
+    for (const importDecl of imports) {
+      const importPath = importDecl.name.value;
+      const resolvedPath = this.resolveImportPath(importPath, sourceDir, sourceFile);
+
+      // Check if this is an external (TypeScript/JavaScript) import
+      const ext = path.extname(resolvedPath);
+      const isExternalImport = ['.ts', '.tsx', '.js', '.jsx', '.mjs'].includes(ext);
+
+      if (isExternalImport) {
+        // Handle TypeScript/JavaScript imports
+        let finalPath = resolvedPath;
+
+        // Transpile TypeScript files to JavaScript
+        if (ext === '.ts' || ext === '.tsx') {
+          try {
+            finalPath = this.tsTranspiler.transpile(resolvedPath);
+          } catch (error) {
+            throw new Error(`Failed to transpile TypeScript file "${importPath}": ${error.message}`);
+          }
+        }
+
+        if (!this.externalImports.find(e => e.resolvedPath === finalPath)) {
+          this.externalImports.push({
+            originalPath: importPath,
+            resolvedPath: finalPath,
+            sourceFile: sourceFile,
+            isTypeScript: ext === '.ts' || ext === '.tsx'
+          });
+        }
+        continue;
+      }
+
+      // Check for circular imports
+      if (this.importedFiles.has(resolvedPath)) {
+        console.warn(`⚠️  Skipping circular import: ${importPath}`);
+        continue;
+      }
+
+      // Mark as imported
+      this.importedFiles.add(resolvedPath);
+
+      try {
+        // Load and parse the imported file
+        const importedSource = fs.readFileSync(resolvedPath, 'utf-8');
+        const importedAst = this.parse(importedSource);
+
+        // Recursively resolve imports in the imported file
+        const resolvedImportedAst = await this.resolveImports(importedAst, resolvedPath);
+
+        // Extract all exportable declarations from imported file
+        for (const decl of resolvedImportedAst.declarations) {
+          if (decl.type === 'SkillDecl') {
+            const existingSkill = this.importedSkills.find(s => s.name.name === decl.name.name);
+            if (!existingSkill) {
+              this.importedSkills.push(decl);
+            } else {
+              console.warn(`⚠️  Duplicate Skill "${decl.name.name}" found in ${importPath}, skipping`);
+            }
+          } else if (decl.type === 'AgentDecl') {
+            const existingAgent = this.importedAgents.find(a => a.name.name === decl.name.name);
+            if (!existingAgent) {
+              this.importedAgents.push(decl);
+            } else {
+              console.warn(`⚠️  Duplicate Agent "${decl.name.name}" found in ${importPath}, skipping`);
+            }
+          } else if (decl.type === 'RoleDecl') {
+            const existingRole = this.importedRoles.find(r => r.name.name === decl.name.name);
+            if (!existingRole) {
+              this.importedRoles.push(decl);
+            } else {
+              console.warn(`⚠️  Duplicate Role "${decl.name.name}" found in ${importPath}, skipping`);
+            }
+          } else if (decl.type === 'TeamDecl') {
+            const existingTeam = this.importedTeams.find(t => t.name.name === decl.name.name);
+            if (!existingTeam) {
+              this.importedTeams.push(decl);
+            } else {
+              console.warn(`⚠️  Duplicate Team "${decl.name.name}" found in ${importPath}, skipping`);
+            }
+          }
+        }
+      } catch (error) {
+        throw new Error(`Failed to import from "${importPath}": ${error.message}`);
+      }
+    }
+
+    // Merge imported declarations with current declarations
+    // Order: Roles -> Skills -> Agents -> Teams -> Other
+    const mergedDeclarations = [
+      ...this.importedRoles,
+      ...this.importedSkills,
+      ...this.importedAgents,
+      ...this.importedTeams,
+      ...nonImportDecls
+    ];
+
+    return {
+      ...ast,
+      declarations: mergedDeclarations
+    };
+  }
+
+  /**
+   * Resolve import path - supports relative paths, absolute paths, and node_modules
+   * @param {string} importPath - The import path from the import statement
+   * @param {string} sourceDir - The directory of the source file
+   * @param {string} sourceFile - The full source file path
+   * @returns {string} - Absolute path to the imported file
+   */
+  resolveImportPath(importPath, sourceDir, sourceFile) {
+    // 1. Relative paths (./ or ../)
+    if (importPath.startsWith('./') || importPath.startsWith('../')) {
+      const resolved = this.resolveRelativePath(importPath, sourceDir);
+      if (fs.existsSync(resolved)) {
+        return resolved;
+      }
+      throw new Error(`Import file not found: ${resolved}`);
+    }
+
+    // 2. Absolute paths
+    if (path.isAbsolute(importPath)) {
+      if (fs.existsSync(importPath)) {
+        return importPath;
+      }
+      throw new Error(`Import file not found: ${importPath}`);
+    }
+
+    // 3. Package imports (from node_modules)
+    const packageResolved = this.resolveFromNodeModules(importPath, sourceDir);
+    if (packageResolved) {
+      return packageResolved;
+    }
+
+    throw new Error(`Cannot resolve import: ${importPath}`);
+  }
+
+  /**
+   * Resolve a relative path, trying different extensions and directory index
+   */
+  resolveRelativePath(importPath, sourceDir) {
+    const basePath = path.resolve(sourceDir, importPath);
+
+    // 1. Try exact path first
+    if (fs.existsSync(basePath)) {
+      // If it's a file, return it
+      if (fs.statSync(basePath).isFile()) {
+        return basePath;
+      }
+      // If it's a directory, try index files
+      if (fs.statSync(basePath).isDirectory()) {
+        // Try index.koi first
+        const indexKoi = path.join(basePath, 'index.koi');
+        if (fs.existsSync(indexKoi)) {
+          return indexKoi;
+        }
+        // Try index.ts
+        const indexTs = path.join(basePath, 'index.ts');
+        if (fs.existsSync(indexTs)) {
+          return indexTs;
+        }
+        // Try index.js
+        const indexJs = path.join(basePath, 'index.js');
+        if (fs.existsSync(indexJs)) {
+          return indexJs;
+        }
+      }
+    }
+
+    // 2. Try with different extensions if no extension provided
+    if (!path.extname(basePath)) {
+      const extensions = ['.koi', '.ts', '.tsx', '.js', '.jsx', '.mjs'];
+      for (const ext of extensions) {
+        const withExt = basePath + ext;
+        if (fs.existsSync(withExt)) {
+          return withExt;
+        }
+      }
+    }
+
+    // 3. Try as directory with index files
+    const indexKoi = path.join(basePath, 'index.koi');
+    if (fs.existsSync(indexKoi)) {
+      return indexKoi;
+    }
+    const indexTs = path.join(basePath, 'index.ts');
+    if (fs.existsSync(indexTs)) {
+      return indexTs;
+    }
+    const indexJs = path.join(basePath, 'index.js');
+    if (fs.existsSync(indexJs)) {
+      return indexJs;
+    }
+
+    return basePath;
+  }
+
+  /**
+   * Resolve from node_modules, checking each parent directory
+   */
+  resolveFromNodeModules(packageName, sourceDir) {
+    let currentDir = sourceDir;
+
+    // Walk up the directory tree looking for node_modules
+    while (true) {
+      const nodeModulesPath = path.join(currentDir, 'node_modules', packageName);
+
+      // Try to resolve the package
+      const resolved = this.resolvePackage(nodeModulesPath, packageName);
+      if (resolved) {
+        return resolved;
+      }
+
+      // Move to parent directory
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        // Reached root, stop
+        break;
+      }
+      currentDir = parentDir;
+    }
+
+    return null;
+  }
+
+  /**
+   * Resolve a package, checking package.json for main/exports
+   */
+  resolvePackage(packagePath, packageName) {
+    // Check if package directory exists
+    if (!fs.existsSync(packagePath)) {
+      return null;
+    }
+
+    // Try package.json
+    const packageJsonPath = path.join(packagePath, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+
+        // Check "koi" field (custom field for Koi packages)
+        if (packageJson.koi) {
+          const koiEntry = path.join(packagePath, packageJson.koi);
+          if (fs.existsSync(koiEntry)) {
+            return koiEntry;
+          }
+        }
+
+        // Check "main" field
+        if (packageJson.main) {
+          const mainPath = path.join(packagePath, packageJson.main);
+          if (fs.existsSync(mainPath)) {
+            return mainPath;
+          }
+        }
+
+        // Check "exports" field (modern Node.js)
+        if (packageJson.exports) {
+          const exports = packageJson.exports;
+          if (typeof exports === 'string') {
+            const exportPath = path.join(packagePath, exports);
+            if (fs.existsSync(exportPath)) {
+              return exportPath;
+            }
+          } else if (exports['.']) {
+            const defaultExport = typeof exports['.'] === 'string' ? exports['.'] : exports['.'].default;
+            if (defaultExport) {
+              const exportPath = path.join(packagePath, defaultExport);
+              if (fs.existsSync(exportPath)) {
+                return exportPath;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️  Failed to parse package.json for ${packageName}: ${error.message}`);
+      }
+    }
+
+    // Try index files in order: .koi, .ts, .js
+    const indexKoi = path.join(packagePath, 'index.koi');
+    if (fs.existsSync(indexKoi)) {
+      return indexKoi;
+    }
+
+    const indexTs = path.join(packagePath, 'index.ts');
+    if (fs.existsSync(indexTs)) {
+      return indexTs;
+    }
+
+    const indexJs = path.join(packagePath, 'index.js');
+    if (fs.existsSync(indexJs)) {
+      return indexJs;
+    }
+
+    // Try packageName with extensions
+    const namedKoi = path.join(packagePath, `${packageName}.koi`);
+    if (fs.existsSync(namedKoi)) {
+      return namedKoi;
+    }
+
+    const namedTs = path.join(packagePath, `${packageName}.ts`);
+    if (fs.existsSync(namedTs)) {
+      return namedTs;
+    }
+
+    const namedJs = path.join(packagePath, `${packageName}.js`);
+    if (fs.existsSync(namedJs)) {
+      return namedJs;
+    }
+
+    return null;
+  }
+
+  /**
+   * Reset the resolver state
+   */
+  reset() {
+    this.importedFiles.clear();
+    this.importedSkills = [];
+    this.importedAgents = [];
+    this.importedRoles = [];
+    this.importedTeams = [];
+    this.externalImports = [];
+  }
+}