fix(module-interface-import): block export-from, dynamic import, .js fallback, and directory index

.devin-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "module-gates",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Enforce module boundary contracts for Devin CLI.",
   "author": {
     "name": "Cause Chung",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuzfrog/module-gates",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Controls the entropy of the codebase by enforcing code module boundaries. Ships bridges for pi, Claude Code, and Devin CLI.",
   "keywords": [
     "pi-package",

src/core/gates/module-interface-import-gate.test.ts

@@ -543,4 +543,163 @@ describe("checkModuleInterfaceImports", () => {
 
     expect(result.blocked).toBe(true);
   });
+
+  it("blocks export from non-interface file in another module", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "file1.ts");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'export { foo } from "../module1/file1";\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(true);
+    if (result.blocked) {
+      expect(result.reason).toContain("file1.ts");
+    }
+  });
+
+  it("blocks dynamic import of non-interface file in another module", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "file1.ts");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'const { foo } = await import("../module1/file1");\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(true);
+    if (result.blocked) {
+      expect(result.reason).toContain("file1.ts");
+    }
+  });
+
+  it("blocks import with .js extension resolving to .ts non-interface file", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "file1.ts");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'import { foo } from "../module1/file1.js";\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(true);
+    if (result.blocked) {
+      expect(result.reason).toContain("file1.ts");
+    }
+  });
+
+  it("allows import from module directory resolving to index.ts", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "index.ts");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'import { foo } from "../module1";\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(false);
+  });
+
+  it("blocks export * from non-interface file", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "file1.ts");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'export * from "../module1/file1";\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(true);
+  });
+
+  it("blocks import with .js extension when .js file exists and is non-interface", () => {
+    setup();
+    createFile("", "src", "module1", "module.md");
+    createFile("export function foo() {}", "src", "module1", "file1.js");
+    createFile("", "src", "module2", "module.md");
+    createDir("src", "module2");
+
+    const dirToModule = new Map<string, string>();
+    dirToModule.set(join(tmpDir, "src", "module1"), join(tmpDir, "src", "module1"));
+    dirToModule.set(join(tmpDir, "src", "module2"), join(tmpDir, "src", "module2"));
+    const index = makeIndex(dirToModule);
+
+    const content = 'import { foo } from "../module1/file1.js";\n';
+    const result = checkModuleInterfaceImports(
+      "src/module2/app.ts",
+      content,
+      index,
+      tmpDir,
+      false,
+      ["src/"],
+    );
+
+    expect(result.blocked).toBe(true);
+  });
 });

src/core/gates/module-interface-import-gate.ts

@@ -77,6 +77,14 @@ function extractJsImportPaths(content: string): string[] {
     results.push(m[1]);
   }
 
+  for (const m of content.matchAll(/^\s*export\s+[\s\S]*?\s+from\s+["']([^"']+)["']/gm)) {
+    results.push(m[1]);
+  }
+
+  for (const m of content.matchAll(/import\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+    results.push(m[1]);
+  }
+
   for (const m of content.matchAll(/^\s*(?:const|let|var)\s+[\s\S]*?=\s*require\s*\(\s*["']([^"']+)["']\s*\)/gm)) {
     results.push(m[1]);
   }
@@ -97,24 +105,62 @@ function extractRustUsePaths(content: string): string[] {
   return results;
 }
 
+const JS_TS_EXTS = [".ts", ".tsx", ".js", ".jsx"];
+const FILE_EXTS = [...JS_TS_EXTS, ".rs"];
+const DIRECTORY_INDEX_NAMES = ["index.ts", "index.tsx", "index.js", "index.jsx", "mod.rs"];
+
 function resolveRelativeImport(importPath: string, fileDir: string): string | undefined {
   if (!importPath.startsWith(".")) return undefined;
 
   const resolved = path.resolve(fileDir, importPath);
   const ext = path.extname(resolved);
 
   if (ext) {
-    return fs.existsSync(resolved) ? resolved : undefined;
+    return resolveWithExtension(resolved, ext);
+  }
+
+  const asFile = resolveAsFile(resolved);
+  if (asFile) return asFile;
+
+  return resolveAsDirectory(resolved);
+}
+
+function resolveWithExtension(filePath: string, ext: string): string | undefined {
+  if (!JS_TS_EXTS.includes(ext)) {
+    return fs.existsSync(filePath) ? filePath : undefined;
   }
 
-  for (const tryExt of [".ts", ".tsx", ".js", ".jsx", ".rs"]) {
-    const candidate = resolved + tryExt;
+  const base = filePath.slice(0, -ext.length);
+  for (const tryExt of [ext, ...JS_TS_EXTS.filter((e) => e !== ext)]) {
+    const candidate = base + tryExt;
     if (fs.existsSync(candidate)) return candidate;
   }
 
   return undefined;
 }
 
+function resolveAsFile(basePath: string): string | undefined {
+  for (const tryExt of FILE_EXTS) {
+    const candidate = basePath + tryExt;
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return undefined;
+}
+
+function resolveAsDirectory(dirPath: string): string | undefined {
+  try {
+    if (!fs.lstatSync(dirPath).isDirectory()) return undefined;
+  } catch {
+    return undefined;
+  }
+
+  for (const name of DIRECTORY_INDEX_NAMES) {
+    const candidate = path.join(dirPath, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return undefined;
+}
+
 function resolveRustCratePath(modulePath: string, srcRoots: string[]): string | undefined {
   const segments = modulePath.split("/");