ucn 3.1.0 → 3.1.1

package/core/imports.js

@@ -431,6 +431,12 @@ function resolveImport(importPath, fromFile, config = {}) {
             }
         }
 
+        // Check Go module imports
+        if (config.language === 'go') {
+            const resolved = resolveGoImport(importPath, fromFile, config.root);
+            if (resolved) return resolved;
+        }
+
         return null;  // External package
     }
 
@@ -439,6 +445,83 @@ function resolveImport(importPath, fromFile, config = {}) {
     return resolveFilePath(resolved, config.extensions || getExtensions(config.language));
 }
 
+// Cache for Go module paths
+const goModuleCache = new Map();
+
+/**
+ * Find and parse go.mod to get the module path
+ * @param {string} startDir - Directory to start searching from
+ * @returns {{modulePath: string, root: string}|null}
+ */
+function findGoModule(startDir) {
+    // Check cache first
+    if (goModuleCache.has(startDir)) {
+        return goModuleCache.get(startDir);
+    }
+
+    let dir = startDir;
+    while (dir !== path.dirname(dir)) {
+        const goModPath = path.join(dir, 'go.mod');
+        if (fs.existsSync(goModPath)) {
+            try {
+                const content = fs.readFileSync(goModPath, 'utf-8');
+                // Parse module line: module github.com/user/project
+                const match = content.match(/^module\s+(\S+)/m);
+                if (match) {
+                    const result = { modulePath: match[1], root: dir };
+                    goModuleCache.set(startDir, result);
+                    return result;
+                }
+            } catch (e) {
+                // Ignore read errors
+            }
+        }
+        dir = path.dirname(dir);
+    }
+
+    goModuleCache.set(startDir, null);
+    return null;
+}
+
+/**
+ * Resolve Go package import to local files
+ * @param {string} importPath - Go import path (e.g., "github.com/user/proj/pkg/util")
+ * @param {string} fromFile - File containing the import
+ * @param {string} projectRoot - Project root directory
+ * @returns {string|null} - Directory path containing the package, or null if external
+ */
+function resolveGoImport(importPath, fromFile, projectRoot) {
+    const goMod = findGoModule(path.dirname(fromFile));
+    if (!goMod) return null;
+
+    const { modulePath, root } = goMod;
+
+    // Check if the import is within this module
+    if (importPath.startsWith(modulePath)) {
+        // Convert module path to relative path
+        // e.g., "github.com/user/proj/pkg/util" -> "pkg/util"
+        const relativePath = importPath.slice(modulePath.length).replace(/^\//, '');
+        const pkgDir = path.join(root, relativePath);
+
+        // Go imports are directories, find a .go file in the directory
+        if (fs.existsSync(pkgDir) && fs.statSync(pkgDir).isDirectory()) {
+            // Return the first .go file in the directory (not _test.go)
+            try {
+                const files = fs.readdirSync(pkgDir);
+                for (const file of files) {
+                    if (file.endsWith('.go') && !file.endsWith('_test.go')) {
+                        return path.join(pkgDir, file);
+                    }
+                }
+            } catch (e) {
+                // Ignore read errors
+            }
+        }
+    }
+
+    return null;
+}
+
 /**
  * Try to resolve a path with various extensions
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ucn",
-  "version": "3.1.0",
-  "description": "Code navigation built by AI, for AI. Reduces context usage by 90%+ when working with large codebases.",
+  "version": "3.1.1",
+  "description": "Code navigation built by AI, for AI. Reduces context usage when working with large codebases.",
   "main": "index.js",
   "bin": {
     "ucn": "./cli/index.js"

package/test/parser.test.js

@@ -4297,6 +4297,53 @@ class Product {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         }
     });
+
+    it('should resolve Go module imports for exporters', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ucn-go-import-'));
+        try {
+            // Create go.mod file
+            fs.writeFileSync(path.join(tmpDir, 'go.mod'), `module example.com/myproject
+
+go 1.21
+`);
+
+            // Create package structure
+            fs.mkdirSync(path.join(tmpDir, 'pkg', 'config'), { recursive: true });
+            fs.writeFileSync(path.join(tmpDir, 'pkg', 'config', 'config.go'), `package config
+
+type Config struct {
+    Name string
+}
+
+func NewConfig() *Config {
+    return &Config{}
+}
+`);
+
+            fs.writeFileSync(path.join(tmpDir, 'main.go'), `package main
+
+import "example.com/myproject/pkg/config"
+
+func main() {
+    cfg := config.NewConfig()
+    _ = cfg
+}
+`);
+
+            const index = new ProjectIndex(tmpDir);
+            index.build('**/*.go', { quiet: true });
+
+            // Get exporters for the config package
+            const exportersResult = index.exporters(path.join(tmpDir, 'pkg', 'config', 'config.go'));
+            assert.ok(exportersResult.length > 0, 'Should find files that import the config package');
+
+            // main.go should be in the list
+            const mainFile = exportersResult.find(e => e.file.includes('main.go'));
+            assert.ok(mainFile, 'main.go should import the config package');
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
 });
 
 console.log('UCN v3 Test Suite');