codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/resolvers/csharp.js

@@ -0,0 +1,109 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csharp_exports = {};
+__export(csharp_exports, {
+  csharpResolver: () => csharpResolver
+});
+module.exports = __toCommonJS(csharp_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_base = require("./base");
+const EXTERNAL_PREFIXES = [
+  "System",
+  "Microsoft",
+  "Windows",
+  "Internal",
+  "Newtonsoft",
+  "Xunit",
+  "NUnit",
+  "Moq",
+  "FluentAssertions",
+  "AutoMapper",
+  "Serilog"
+];
+function isExternal(namespace) {
+  const first = namespace.split(".")[0];
+  return EXTERNAL_PREFIXES.includes(first);
+}
+const rootNamespaceCache = /* @__PURE__ */ new Map();
+function readRootNamespace(manifestPath) {
+  let stat;
+  try {
+    stat = import_node_fs.default.statSync(manifestPath);
+  } catch {
+    return null;
+  }
+  const cached = rootNamespaceCache.get(manifestPath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) return cached.value;
+  let value = null;
+  try {
+    const raw = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+    value = raw.match(/<RootNamespace>\s*([^<\s]+)\s*<\/RootNamespace>/)?.[1] ?? null;
+  } catch {
+    value = null;
+  }
+  rootNamespaceCache.set(manifestPath, { mtimeMs: stat.mtimeMs, value });
+  return value;
+}
+function buildNamespaceIndex(systems) {
+  const roots = [];
+  for (const sys of systems) {
+    if (sys.manifestKind !== "csproj") continue;
+    const declared = sys.manifestPath ? readRootNamespace(sys.manifestPath) : null;
+    const ns = declared || sys.packageName || sys.name;
+    if (ns) roots.push({ namespace: ns, rootPath: sys.rootPath });
+  }
+  roots.sort((a, b) => b.namespace.length - a.namespace.length);
+  return roots;
+}
+function resolve(ctx) {
+  const { importSource, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  if (isExternal(importSource)) return null;
+  for (const root of buildNamespaceIndex(systems)) {
+    if (importSource !== root.namespace && !importSource.startsWith(root.namespace + ".")) {
+      continue;
+    }
+    const remainder = importSource.slice(root.namespace.length).replace(/^\./, "");
+    const dir = remainder ? import_node_path.default.join(root.rootPath, ...remainder.split(".")) : root.rootPath;
+    const hit = (0, import_base.pickRepresentativeFile)(dir, knownFiles, {
+      extensions: [".cs"],
+      prefer: remainder ? remainder.split(".").pop() : import_node_path.default.basename(dir)
+    });
+    if (hit) return hit;
+  }
+  return null;
+}
+const csharpResolver = {
+  languages: ["csharp"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  csharpResolver
+});

package/src/backend/services/resolvers/go.js

@@ -0,0 +1,105 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var go_exports = {};
+__export(go_exports, {
+  goResolver: () => goResolver
+});
+module.exports = __toCommonJS(go_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const replaceCache = /* @__PURE__ */ new Map();
+function readReplaceDirectives(manifestPath) {
+  let stat;
+  try {
+    stat = import_node_fs.default.statSync(manifestPath);
+  } catch {
+    return [];
+  }
+  const cached = replaceCache.get(manifestPath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) return cached.entries;
+  let raw = "";
+  try {
+    raw = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const dir = import_node_path.default.dirname(manifestPath);
+  const entries = [];
+  const LINE_RE = /^\s*(?:replace\s+)?(\S+?)(?:\s+v\S+)?\s*=>\s*(\S+)(?:\s+v\S+)?\s*$/gm;
+  let m;
+  while (m = LINE_RE.exec(raw)) {
+    const [, from, to] = m;
+    if (from === "replace" || from.startsWith("//")) continue;
+    if (!to.startsWith(".") && !import_node_path.default.isAbsolute(to)) continue;
+    entries.push({ modulePath: from, rootPath: import_node_path.default.resolve(dir, to) });
+  }
+  replaceCache.set(manifestPath, { mtimeMs: stat.mtimeMs, entries });
+  return entries;
+}
+function buildModuleIndex(systems) {
+  const entries = [];
+  for (const sys of systems) {
+    if (sys.manifestKind !== "go.mod") continue;
+    const modulePath = sys.packageName || sys.name;
+    if (modulePath) entries.push({ modulePath, rootPath: sys.rootPath });
+    if (sys.manifestPath) entries.push(...readReplaceDirectives(sys.manifestPath));
+  }
+  entries.sort((a, b) => b.modulePath.length - a.modulePath.length);
+  return entries;
+}
+function pickPackageFile(dir, knownFiles) {
+  return (0, import_base.pickRepresentativeFile)(dir, knownFiles, {
+    extensions: [".go"],
+    prefer: import_node_path.default.basename(dir),
+    deprioritize: (file) => file.endsWith("_test.go")
+  });
+}
+function resolve(ctx) {
+  const { importSource, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  const index = buildModuleIndex(systems);
+  for (const entry of index) {
+    if (importSource !== entry.modulePath && !importSource.startsWith(entry.modulePath + "/")) {
+      continue;
+    }
+    const remainder = importSource.slice(entry.modulePath.length).replace(/^\//, "");
+    const dir = remainder ? import_node_path.default.join(entry.rootPath, remainder) : entry.rootPath;
+    const hit = pickPackageFile(dir, knownFiles);
+    if (hit) return hit;
+  }
+  return null;
+}
+const goResolver = {
+  languages: ["go"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  goResolver
+});

package/src/backend/services/resolvers/index.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolvers_exports = {};
+__export(resolvers_exports, {
+  RESOLVER_PLUGINS: () => RESOLVER_PLUGINS,
+  getResolverForLanguage: () => getResolverForLanguage
+});
+module.exports = __toCommonJS(resolvers_exports);
+var import_typescript = require("./typescript");
+var import_python = require("./python");
+var import_rust = require("./rust");
+var import_php = require("./php");
+var import_java = require("./java");
+var import_go = require("./go");
+var import_ruby = require("./ruby");
+var import_csharp = require("./csharp");
+var import_kotlin = require("./kotlin");
+var import_swift = require("./swift");
+const RESOLVER_PLUGINS = [
+  import_typescript.typescriptResolver,
+  import_python.pythonResolver,
+  import_rust.rustResolver,
+  import_php.phpResolver,
+  import_java.javaResolver,
+  import_go.goResolver,
+  import_ruby.rubyResolver,
+  import_csharp.csharpResolver,
+  import_kotlin.kotlinResolver,
+  import_swift.swiftResolver
+];
+const RESOLVER_BY_LANGUAGE = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const plugin of RESOLVER_PLUGINS) {
+    for (const lang of plugin.languages) map.set(lang, plugin);
+  }
+  return map;
+})();
+function getResolverForLanguage(lang) {
+  return RESOLVER_BY_LANGUAGE.get(lang) ?? null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RESOLVER_PLUGINS,
+  getResolverForLanguage
+});

package/src/backend/services/resolvers/java.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var java_exports = {};
+__export(java_exports, {
+  javaResolver: () => javaResolver
+});
+module.exports = __toCommonJS(java_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const SOURCE_ROOTS = [
+  "src/main/java",
+  "src/test/java",
+  "src",
+  ""
+];
+const STD_PREFIXES = ["java.", "javax.", "sun.", "com.sun."];
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  if (importSource.endsWith(".*")) return null;
+  if (STD_PREFIXES.some((p) => importSource.startsWith(p))) return null;
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  if (!containing) return null;
+  const subpath = importSource.replace(/\./g, "/") + ".java";
+  for (const root of SOURCE_ROOTS) {
+    const candidate = import_node_path.default.join(containing.rootPath, root, subpath);
+    if (knownFiles.has(candidate)) return candidate;
+  }
+  return null;
+}
+const javaResolver = {
+  languages: ["java"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  javaResolver
+});

package/src/backend/services/resolvers/kotlin.js

@@ -0,0 +1,109 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var kotlin_exports = {};
+__export(kotlin_exports, {
+  kotlinResolver: () => kotlinResolver
+});
+module.exports = __toCommonJS(kotlin_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const SOURCE_ROOTS = [
+  "src/main/kotlin",
+  "src/main/java",
+  "src/test/kotlin",
+  "src/test/java",
+  // Kotlin Multiplatform
+  "src/commonMain/kotlin",
+  "src/jvmMain/kotlin",
+  "src/androidMain/kotlin",
+  "src/iosMain/kotlin",
+  "src/commonTest/kotlin",
+  // Plain / script layouts
+  "src",
+  ""
+];
+const EXTERNAL_PREFIXES = [
+  "kotlin",
+  "kotlinx",
+  "java",
+  "javax",
+  "jakarta",
+  "android",
+  "androidx",
+  "org.jetbrains",
+  "org.junit",
+  "org.gradle",
+  "com.google",
+  "io.ktor",
+  "org.springframework",
+  "dagger",
+  "retrofit2",
+  "okhttp3"
+];
+function isExternal(importSource) {
+  return EXTERNAL_PREFIXES.some(
+    (prefix) => importSource === prefix || importSource.startsWith(prefix + ".")
+  );
+}
+const EXTENSIONS = [".kt", ".kts"];
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  if (isExternal(importSource)) return null;
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  const segments = importSource.split(".").filter(Boolean);
+  if (segments.length === 0) return null;
+  const last = segments[segments.length - 1];
+  const looksLikeDeclaration = last !== last.toLowerCase();
+  const packageSegments = looksLikeDeclaration ? segments.slice(0, -1) : segments;
+  if (packageSegments.length === 0) return null;
+  const searchRoots = [
+    ...containing ? [containing.rootPath] : [],
+    ...systems.map((sys) => sys.rootPath).filter((r) => r !== containing?.rootPath),
+    ctx.projectRoot
+  ];
+  for (const base of searchRoots) {
+    for (const root of SOURCE_ROOTS) {
+      const dir = import_node_path.default.join(base, root, ...packageSegments);
+      const hit = (0, import_base.pickRepresentativeFile)(dir, knownFiles, {
+        extensions: EXTENSIONS,
+        prefer: looksLikeDeclaration ? last : null
+      });
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+const kotlinResolver = {
+  languages: ["kotlin"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  kotlinResolver
+});

package/src/backend/services/resolvers/php.js

@@ -0,0 +1,89 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var php_exports = {};
+__export(php_exports, {
+  phpResolver: () => phpResolver
+});
+module.exports = __toCommonJS(php_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const psr4Cache = /* @__PURE__ */ new Map();
+function readPsr4(composerPath) {
+  if (psr4Cache.has(composerPath)) return psr4Cache.get(composerPath);
+  const mappings = [];
+  try {
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(composerPath, "utf-8"));
+    const dir = import_node_path.default.dirname(composerPath);
+    for (const section of ["autoload", "autoload-dev"]) {
+      const psr4 = pkg?.[section]?.["psr-4"];
+      if (!psr4 || typeof psr4 !== "object") continue;
+      for (const [prefix, target] of Object.entries(psr4)) {
+        const targets = Array.isArray(target) ? target : [target];
+        for (const t of targets) {
+          if (typeof t !== "string") continue;
+          mappings.push({
+            prefix: prefix.replace(/\\$/, ""),
+            basePath: import_node_path.default.resolve(dir, t)
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  mappings.sort((a, b) => b.prefix.length - a.prefix.length);
+  psr4Cache.set(composerPath, mappings);
+  return mappings;
+}
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  const fqcn = importSource.replace(/^\\/, "");
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  if (!containing || containing.manifestKind !== "composer.json" || !containing.manifestPath) {
+    return null;
+  }
+  const mappings = readPsr4(containing.manifestPath);
+  const cleanFqcn = fqcn.replace(/\\/g, "\\").replace(/\\$/, "");
+  for (const m of mappings) {
+    if (cleanFqcn === m.prefix || cleanFqcn.startsWith(m.prefix + "\\")) {
+      const sub = cleanFqcn.slice(m.prefix.length).replace(/^\\/, "").replace(/\\/g, "/");
+      const candidate = import_node_path.default.join(m.basePath, sub) + ".php";
+      if (knownFiles.has(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+const phpResolver = {
+  languages: ["php"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  phpResolver
+});

package/src/backend/services/resolvers/python.js

@@ -0,0 +1,154 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var python_exports = {};
+__export(python_exports, {
+  pythonResolver: () => pythonResolver
+});
+module.exports = __toCommonJS(python_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const PY_EXTS = [".py"];
+const PY_INDEX_SUFFIXES = ["/__init__.py"];
+function resolve(ctx) {
+  const { importSource, importerPath, projectRoot, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  if (isLikelyExternal(importSource)) return null;
+  if (importSource.startsWith(".")) {
+    const dots = importSource.match(/^\.+/)[0].length;
+    const tail = importSource.slice(dots).replace(/^\./, "").replace(/\./g, "/");
+    let baseDir = import_node_path.default.dirname(importerPath);
+    for (let i = 1; i < dots; i += 1) baseDir = import_node_path.default.dirname(baseDir);
+    const base = tail ? import_node_path.default.join(baseDir, tail) : baseDir;
+    return tryPython(base, knownFiles);
+  }
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  const roots = [];
+  if (containing) roots.push(containing.rootPath);
+  if (containing?.rootPath !== projectRoot) roots.push(projectRoot);
+  const moduleSubpath = importSource.replace(/\./g, "/");
+  for (const root of roots) {
+    const candidatesBases = [
+      import_node_path.default.join(root, moduleSubpath),
+      import_node_path.default.join(root, "src", moduleSubpath),
+      import_node_path.default.join(root, "app", moduleSubpath)
+    ];
+    for (const base of candidatesBases) {
+      const hit = tryPython(base, knownFiles);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+function tryPython(basePath, knownFiles) {
+  return (0, import_base.tryExtensions)(basePath, knownFiles, [...PY_EXTS, ...PY_INDEX_SUFFIXES]);
+}
+const STDLIB_AND_COMMON_THIRD_PARTY = /* @__PURE__ */ new Set([
+  // stdlib
+  "os",
+  "sys",
+  "io",
+  "re",
+  "json",
+  "time",
+  "typing",
+  "pathlib",
+  "collections",
+  "functools",
+  "itertools",
+  "datetime",
+  "subprocess",
+  "asyncio",
+  "threading",
+  "logging",
+  "math",
+  "random",
+  "enum",
+  "dataclasses",
+  "abc",
+  "inspect",
+  "copy",
+  "string",
+  "unittest",
+  "shutil",
+  "tempfile",
+  "glob",
+  "argparse",
+  "contextlib",
+  "warnings",
+  "urllib",
+  "http",
+  "socket",
+  "hashlib",
+  "base64",
+  "pickle",
+  "csv",
+  "xml",
+  "html",
+  "sqlite3",
+  "concurrent",
+  "multiprocessing",
+  "queue",
+  // common third-party we won't try to ingest from node_modules-equivalents
+  "fastapi",
+  "pydantic",
+  "sqlalchemy",
+  "alembic",
+  "starlette",
+  "uvicorn",
+  "celery",
+  "redis",
+  "requests",
+  "httpx",
+  "numpy",
+  "pandas",
+  "scipy",
+  "sklearn",
+  "torch",
+  "tensorflow",
+  "matplotlib",
+  "pytest",
+  "click",
+  "flask",
+  "django",
+  "jinja2",
+  "boto3",
+  "stripe",
+  "sentry_sdk"
+]);
+function isLikelyExternal(importSource) {
+  const top = importSource.replace(/^\.+/, "").split(".")[0];
+  return STDLIB_AND_COMMON_THIRD_PARTY.has(top);
+}
+const pythonResolver = {
+  languages: ["python"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pythonResolver
+});