codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/system-discovery.js

@@ -0,0 +1,481 @@
+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 system_discovery_exports = {};
+__export(system_discovery_exports, {
+  buildAliasMap: () => buildAliasMap,
+  discoverSystems: () => discoverSystems,
+  readTsconfigPaths: () => readTsconfigPaths,
+  stripJsonc: () => stripJsonc
+});
+module.exports = __toCommonJS(system_discovery_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+const ALWAYS_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  // Keep in sync with project-scanner.ts ALWAYS_IGNORED. Anything starting
+  // with '.' is also skipped.
+  "node_modules",
+  "dist",
+  "out",
+  "build",
+  "__pycache__",
+  "venv",
+  "env",
+  "target",
+  "vendor",
+  "coverage",
+  "test-results",
+  "playwright-report",
+  "cypress"
+]);
+const MANIFEST_PRIORITY = [
+  { filename: "package.json", kind: "package.json" },
+  { filename: "pyproject.toml", kind: "pyproject.toml" },
+  { filename: "Cargo.toml", kind: "Cargo.toml" },
+  { filename: "composer.json", kind: "composer.json" },
+  { filename: "go.mod", kind: "go.mod" },
+  { filename: "pom.xml", kind: "pom.xml" },
+  { filename: "build.gradle.kts", kind: "build.gradle.kts" },
+  { filename: "build.gradle", kind: "build.gradle" },
+  { filename: "Gemfile", kind: "Gemfile" },
+  { filename: "Package.swift", kind: "Package.swift" },
+  // Lower-priority manifests that signal a project but with weaker info
+  { filename: "setup.py", kind: "setup.py" },
+  { filename: "requirements.txt", kind: "requirements.txt" }
+  // tsconfig.json by itself only counts when there's no package.json
+  // sibling — handled specially below.
+];
+function discoverSystems(projectRoot) {
+  const absoluteRoot = import_node_path.default.resolve(projectRoot);
+  const systems = [];
+  walk(
+    absoluteRoot,
+    absoluteRoot,
+    systems,
+    0,
+    /* maxDepth */
+    8
+  );
+  systems.sort((a, b) => a.rootPath.length - b.rootPath.length);
+  if (systems.length === 0 || systems[0].rootPath !== absoluteRoot) {
+    systems.unshift(makeInformalSystem(absoluteRoot, absoluteRoot));
+  }
+  return systems;
+}
+function walk(dir, projectRoot, out, depth, maxDepth) {
+  if (depth > maxDepth) return;
+  let entries;
+  try {
+    entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const filenames = new Set(entries.filter((e) => e.isFile()).map((e) => e.name));
+  const sys = detectSystemAtDir(dir, projectRoot, filenames);
+  if (sys) out.push(sys);
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    if (ALWAYS_IGNORED_DIRS.has(entry.name)) continue;
+    walk(import_node_path.default.join(dir, entry.name), projectRoot, out, depth + 1, maxDepth);
+  }
+}
+function detectSystemAtDir(dir, projectRoot, filenames) {
+  for (const { filename, kind } of MANIFEST_PRIORITY) {
+    if (!filenames.has(filename)) continue;
+    return readManifest(dir, projectRoot, filename, kind);
+  }
+  const csproj = [...filenames].filter((name) => name.toLowerCase().endsWith(".csproj")).sort()[0];
+  if (csproj) {
+    return readCsproj(dir, projectRoot, import_node_path.default.join(dir, csproj));
+  }
+  if (filenames.has("tsconfig.json") && !filenames.has("package.json")) {
+    return readTsconfigSystem(dir, projectRoot);
+  }
+  return null;
+}
+function readCsproj(dir, projectRoot, manifestPath) {
+  const projectName = import_node_path.default.basename(manifestPath, import_node_path.default.extname(manifestPath));
+  return {
+    id: stableId(dir),
+    name: projectName,
+    rootPath: dir,
+    relativeRoot: import_node_path.default.relative(projectRoot, dir),
+    language: "csharp",
+    manifestKind: "csproj",
+    manifestPath,
+    isWorkspaceRoot: false,
+    packageName: projectName
+  };
+}
+function readManifest(dir, projectRoot, filename, kind) {
+  const manifestPath = import_node_path.default.join(dir, filename);
+  const id = stableId(dir);
+  const relativeRoot = import_node_path.default.relative(projectRoot, dir);
+  const baseName = import_node_path.default.basename(dir) || "project";
+  switch (kind) {
+    case "package.json":
+      return readPackageJson(dir, projectRoot, manifestPath, id, relativeRoot, baseName);
+    case "pyproject.toml":
+    case "setup.py":
+    case "requirements.txt":
+      return {
+        id,
+        name: baseName,
+        rootPath: dir,
+        relativeRoot,
+        language: "python",
+        manifestKind: kind,
+        manifestPath,
+        isWorkspaceRoot: false
+      };
+    case "Cargo.toml":
+      return readCargoToml(dir, projectRoot, manifestPath, id, relativeRoot, baseName);
+    case "go.mod":
+      return readGoMod(dir, projectRoot, manifestPath, id, relativeRoot, baseName);
+    case "composer.json":
+      return readComposerJson(dir, projectRoot, manifestPath, id, relativeRoot, baseName);
+    case "pom.xml":
+      return {
+        id,
+        name: baseName,
+        rootPath: dir,
+        relativeRoot,
+        language: "java",
+        manifestKind: kind,
+        manifestPath,
+        isWorkspaceRoot: false
+      };
+    case "build.gradle":
+    case "build.gradle.kts":
+      return {
+        id,
+        name: baseName,
+        rootPath: dir,
+        relativeRoot,
+        language: "java",
+        manifestKind: kind,
+        manifestPath,
+        isWorkspaceRoot: false
+      };
+    case "Gemfile":
+      return {
+        id,
+        name: baseName,
+        rootPath: dir,
+        relativeRoot,
+        language: "ruby",
+        manifestKind: kind,
+        manifestPath,
+        isWorkspaceRoot: false
+      };
+    case "Package.swift":
+      return readSwiftPackage(dir, projectRoot, manifestPath, id, relativeRoot, baseName);
+    default:
+      return {
+        id,
+        name: baseName,
+        rootPath: dir,
+        relativeRoot,
+        language: "unknown",
+        manifestKind: kind,
+        manifestPath,
+        isWorkspaceRoot: false
+      };
+  }
+}
+function readPackageJson(dir, projectRoot, manifestPath, id, relativeRoot, baseName) {
+  let pkg = {};
+  try {
+    pkg = JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf-8"));
+  } catch {
+  }
+  const packageName = typeof pkg.name === "string" ? pkg.name : void 0;
+  const workspacesRaw = pkg.workspaces;
+  const workspaceGlobs = Array.isArray(workspacesRaw) ? workspacesRaw : Array.isArray(workspacesRaw?.packages) ? workspacesRaw.packages : [];
+  const isWorkspaceRoot = workspaceGlobs.length > 0;
+  const hasTypeScript = pkg.devDependencies?.typescript || pkg.dependencies?.typescript || pkg.types || pkg.typings || import_node_fs.default.existsSync(import_node_path.default.join(dir, "tsconfig.json"));
+  const language = hasTypeScript ? "typescript" : "javascript";
+  const entryHints = computePackageEntryHints(dir, pkg);
+  const packageMeta = {
+    main: typeof pkg.main === "string" ? pkg.main : void 0,
+    source: typeof pkg.source === "string" ? pkg.source : void 0,
+    types: typeof pkg.types === "string" ? pkg.types : void 0,
+    module: typeof pkg.module === "string" ? pkg.module : void 0,
+    exports: pkg.exports
+  };
+  return {
+    id,
+    name: packageName || baseName,
+    rootPath: dir,
+    relativeRoot,
+    language,
+    manifestKind: "package.json",
+    manifestPath,
+    isWorkspaceRoot,
+    workspaceGlobs: isWorkspaceRoot ? workspaceGlobs : void 0,
+    packageName,
+    entryHints,
+    packageMeta
+  };
+}
+function computePackageEntryHints(dir, pkg) {
+  const hints = /* @__PURE__ */ new Set();
+  for (const candidate of [pkg.source, pkg.types, pkg.module, pkg.main]) {
+    if (typeof candidate === "string") hints.add(candidate);
+  }
+  for (const candidate of [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/index.js",
+    "src/index.jsx",
+    "src/main.ts",
+    "src/main.tsx",
+    "index.ts",
+    "index.tsx",
+    "index.js",
+    "index.jsx"
+  ]) {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, candidate))) hints.add(candidate);
+  }
+  return [...hints];
+}
+function readCargoToml(dir, _projectRoot, manifestPath, id, relativeRoot, baseName) {
+  let raw = "";
+  try {
+    raw = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+  } catch {
+  }
+  const isWorkspaceRoot = /\[workspace\]/.test(raw);
+  const nameMatch = raw.match(/^\s*name\s*=\s*"([^"]+)"/m);
+  const name = nameMatch ? nameMatch[1] : baseName;
+  const workspaceGlobs = [];
+  if (isWorkspaceRoot) {
+    const membersBlock = raw.match(/members\s*=\s*\[([\s\S]*?)\]/);
+    if (membersBlock) {
+      const members = membersBlock[1].match(/"([^"]+)"/g) || [];
+      for (const m of members) workspaceGlobs.push(m.replace(/"/g, ""));
+    }
+  }
+  return {
+    id,
+    name,
+    rootPath: dir,
+    relativeRoot,
+    language: "rust",
+    manifestKind: "Cargo.toml",
+    manifestPath,
+    isWorkspaceRoot,
+    workspaceGlobs: isWorkspaceRoot ? workspaceGlobs : void 0
+  };
+}
+function readGoMod(dir, _projectRoot, manifestPath, id, relativeRoot, baseName) {
+  let raw = "";
+  try {
+    raw = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+  } catch {
+  }
+  const moduleMatch = raw.match(/^module\s+(\S+)/m);
+  const moduleName = moduleMatch ? moduleMatch[1] : baseName;
+  return {
+    id,
+    name: moduleName,
+    rootPath: dir,
+    relativeRoot,
+    language: "go",
+    manifestKind: "go.mod",
+    manifestPath,
+    isWorkspaceRoot: false,
+    packageName: moduleName
+  };
+}
+function readSwiftPackage(dir, _projectRoot, manifestPath, id, relativeRoot, baseName) {
+  let raw = "";
+  try {
+    raw = import_node_fs.default.readFileSync(manifestPath, "utf-8");
+  } catch {
+  }
+  const nameMatch = raw.match(/name\s*:\s*"([^"]+)"/);
+  const packageName = nameMatch ? nameMatch[1] : baseName;
+  return {
+    id,
+    name: packageName,
+    rootPath: dir,
+    relativeRoot,
+    language: "swift",
+    manifestKind: "Package.swift",
+    manifestPath,
+    isWorkspaceRoot: false,
+    packageName
+  };
+}
+function readComposerJson(dir, _projectRoot, manifestPath, id, relativeRoot, baseName) {
+  let pkg = {};
+  try {
+    pkg = JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf-8"));
+  } catch {
+  }
+  const packageName = typeof pkg.name === "string" ? pkg.name : void 0;
+  return {
+    id,
+    name: packageName || baseName,
+    rootPath: dir,
+    relativeRoot,
+    language: "php",
+    manifestKind: "composer.json",
+    manifestPath,
+    isWorkspaceRoot: false,
+    packageName
+  };
+}
+function readTsconfigSystem(dir, projectRoot) {
+  const id = stableId(dir);
+  const relativeRoot = import_node_path.default.relative(projectRoot, dir);
+  const baseName = import_node_path.default.basename(dir) || "project";
+  return {
+    id,
+    name: baseName,
+    rootPath: dir,
+    relativeRoot,
+    language: "typescript",
+    manifestKind: "tsconfig.json",
+    manifestPath: import_node_path.default.join(dir, "tsconfig.json"),
+    isWorkspaceRoot: false
+  };
+}
+function makeInformalSystem(rootPath, projectRoot) {
+  return {
+    id: stableId(rootPath),
+    name: import_node_path.default.basename(rootPath) || "project",
+    rootPath,
+    relativeRoot: import_node_path.default.relative(projectRoot, rootPath),
+    language: "mixed",
+    manifestKind: "informal",
+    manifestPath: null,
+    isWorkspaceRoot: false
+  };
+}
+function stableId(absPath) {
+  return (0, import_node_crypto.createHash)("sha1").update(absPath).digest("hex").slice(0, 12);
+}
+function buildAliasMap(systems) {
+  const map = [];
+  for (const sys of systems) {
+    if (!sys.packageName) continue;
+    if (sys.manifestKind !== "package.json") continue;
+    map.push({
+      alias: sys.packageName,
+      rootPath: sys.rootPath,
+      entries: sys.entryHints,
+      source: "package"
+    });
+  }
+  for (const sys of systems) {
+    const tsconfigPath = import_node_path.default.join(sys.rootPath, "tsconfig.json");
+    if (!import_node_fs.default.existsSync(tsconfigPath)) continue;
+    const tsPaths = readTsconfigPaths(tsconfigPath, sys.rootPath);
+    for (const m of tsPaths) map.push(m);
+  }
+  map.sort((a, b) => b.alias.length - a.alias.length);
+  return map;
+}
+function stripJsonc(raw) {
+  let out = "";
+  let inString = false;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (inString) {
+      out += c;
+      if (c === "\\") {
+        out += raw[++i] ?? "";
+        continue;
+      }
+      if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      continue;
+    }
+    if (c === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (c === "/" && raw[i + 1] === "*") {
+      i += 2;
+      while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+    out += c;
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+function readTsconfigPaths(tsconfigPath, configDir) {
+  const out = [];
+  let raw = "";
+  try {
+    raw = import_node_fs.default.readFileSync(tsconfigPath, "utf-8");
+  } catch {
+    return out;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(stripJsonc(raw));
+  } catch {
+    return out;
+  }
+  const compilerOptions = pkg?.compilerOptions || {};
+  const baseUrl = typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : ".";
+  const baseDir = import_node_path.default.resolve(configDir, baseUrl);
+  const paths = compilerOptions.paths;
+  if (!paths || typeof paths !== "object") return out;
+  for (const [pattern, candidates] of Object.entries(paths)) {
+    if (!Array.isArray(candidates)) continue;
+    const cleanAlias = pattern.replace(/\/\*$/, "");
+    for (const candidate of candidates) {
+      const cleanCandidate = candidate.replace(/\/\*$/, "");
+      const resolvedRoot = import_node_path.default.resolve(baseDir, cleanCandidate);
+      out.push({
+        alias: cleanAlias,
+        rootPath: resolvedRoot,
+        source: "tsconfig-paths"
+      });
+    }
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAliasMap,
+  discoverSystems,
+  readTsconfigPaths,
+  stripJsonc
+});