@harness-engineering/core 0.24.0 → 0.26.0

package/dist/index.mjs

@@ -46,6 +46,7 @@ import {
   fileExists,
   findFiles,
   formatOutline,
+  getDefaultRegistry,
   getOutline,
   getParser,
   parseFile,
@@ -56,11 +57,108 @@ import {
   runAll,
   validateDependencies,
   violationId
-} from "./chunk-NC4RPKD4.mjs";
+} from "./chunk-4UI65RLE.mjs";
 
 // src/index.ts
 export * from "@harness-engineering/types";
 
+// src/shared/port.ts
+var WHATWG_BAD_PORTS = Object.freeze([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  4190,
+  5060,
+  5061,
+  6e3,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6679,
+  6697,
+  10080
+]);
+var BAD_PORT_SET = new Set(WHATWG_BAD_PORTS);
+function isBadPort(port) {
+  return BAD_PORT_SET.has(port);
+}
+function assertPortUsable(port, label = "server") {
+  if (isBadPort(port)) {
+    throw new Error(
+      `Refusing to bind ${label} to port ${port}: this port is on the WHATWG fetch bad-ports list, so browsers and Node's fetch() will reject every connection with "bad port". Choose a different port. See https://fetch.spec.whatwg.org/#port-blocking for the full list.`
+    );
+  }
+}
+
 // src/validation/file-structure.ts
 async function validateFileStructure(projectPath, conventions) {
   const missing = [];
@@ -436,7 +534,7 @@ function isAgnixDisabled() {
   return v === "1" || v === "true";
 }
 function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, spawnFn = spawn) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const args = ["--format", "json"];
     if (strict) args.push("--strict");
     args.push(cwd);
@@ -450,7 +548,7 @@ function runAgnix(cwd, strict, binPath, timeoutMs = DEFAULT_AGNIX_TIMEOUT_MS, sp
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve9(outcome);
+      resolve10(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -1615,8 +1713,82 @@ function validateRoadmapMode(config, projectRoot) {
   return Ok(void 0);
 }
 
-// src/context/doc-coverage.ts
+// src/validation/branch.ts
 import { minimatch } from "minimatch";
+var KEBAB_CASE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var TICKET_ID = /^([A-Z0-9]+-[0-9]+)-(.*)$/;
+function validateBranchName(branchName, config) {
+  for (const pattern of config.ignore) {
+    if (minimatch(branchName, pattern)) {
+      return { valid: true, branchName };
+    }
+  }
+  if (config.customRegex) {
+    const regex = new RegExp(config.customRegex);
+    if (!regex.test(branchName)) {
+      return {
+        valid: false,
+        branchName,
+        message: `Branch name "${branchName}" does not match the custom regex: ${config.customRegex}`
+      };
+    }
+    return { valid: true, branchName };
+  }
+  const parts = branchName.split("/");
+  if (parts.length < 2) {
+    return {
+      valid: false,
+      branchName,
+      message: `Branch name "${branchName}" must have a prefix followed by a slash (e.g., "feat/my-feature").`,
+      suggestion: `Try renaming to "feat/${branchName}" or "fix/${branchName}".`
+    };
+  }
+  const prefix = parts[0];
+  const slug = parts.slice(1).join("/");
+  if (!config.prefixes.includes(prefix)) {
+    return {
+      valid: false,
+      branchName,
+      message: `Prefix "${prefix}" is not allowed.`,
+      suggestion: `Allowed prefixes: ${config.prefixes.join(", ")}.`
+    };
+  }
+  if (config.enforceKebabCase) {
+    for (const part of slug.split("/")) {
+      const ticketMatch = part.match(TICKET_ID);
+      if (ticketMatch) {
+        const rest = ticketMatch[2];
+        if (rest && !KEBAB_CASE.test(rest)) {
+          return {
+            valid: false,
+            branchName,
+            message: `Branch slug part "${part}" does not follow kebab-case after the ticket ID.`,
+            suggestion: `Ensure the description after "${ticketMatch[1]}" uses kebab-case (lowercase, single hyphens, no leading/trailing hyphen).`
+          };
+        }
+      } else if (!KEBAB_CASE.test(part)) {
+        return {
+          valid: false,
+          branchName,
+          message: `Branch slug part "${part}" must be in kebab-case (lowercase, single hyphens, no leading/trailing hyphen).`,
+          suggestion: `Change "${part}" to match the convention.`
+        };
+      }
+    }
+  }
+  if (typeof config.maxLength === "number" && config.maxLength > 0 && slug.length > config.maxLength) {
+    return {
+      valid: false,
+      branchName,
+      message: `Branch slug is ${slug.length} characters; max allowed is ${config.maxLength}.`,
+      suggestion: `Shorten the description after "${prefix}/" to ${config.maxLength} characters or fewer.`
+    };
+  }
+  return { valid: true, branchName };
+}
+
+// src/context/doc-coverage.ts
+import { minimatch as minimatch2 } from "minimatch";
 import { basename as basename2 } from "path";
 function determineImportance(filePath) {
   const name = basename2(filePath).toLowerCase();
@@ -1659,7 +1831,7 @@ async function checkDocCoverage(domain, options = {}) {
     const filteredSourceFiles = sourceFiles.filter((file) => {
       const relativePath = relativePosix(sourceDir, file);
       return !excludePatterns.some((pattern) => {
-        return minimatch(relativePath, pattern, { dot: true }) || minimatch(file, pattern, { dot: true });
+        return minimatch2(relativePath, pattern, { dot: true }) || minimatch2(file, pattern, { dot: true });
       });
     });
     const docFiles = await findFiles("**/*.md", docsDir);
@@ -2912,8 +3084,12 @@ function parseProtectedRegions(files) {
 }
 
 // src/entropy/snapshot.ts
+import { skipDirGlobs } from "@harness-engineering/graph";
+import { resolve as resolve5 } from "path";
+import { minimatch as minimatch3 } from "minimatch";
+
+// src/entropy/entry-points.ts
 import { join as join15, resolve as resolve4 } from "path";
-import { minimatch as minimatch2 } from "minimatch";
 function collectFieldEntries(rootDir, field) {
   if (typeof field === "string") return [resolve4(rootDir, field)];
   if (typeof field === "object" && field !== null) {
@@ -2927,47 +3103,263 @@ function extractPackageEntries(rootDir, pkg) {
   if (entries.length === 0 && typeof pkg["main"] === "string") {
     entries.push(resolve4(rootDir, pkg["main"]));
   }
-  if (pkg["bin"]) {
-    entries.push(...collectFieldEntries(rootDir, pkg["bin"]));
-  }
+  if (pkg["bin"]) entries.push(...collectFieldEntries(rootDir, pkg["bin"]));
   return entries;
 }
-async function resolveEntryPoints(rootDir, explicitEntries) {
-  if (explicitEntries && explicitEntries.length > 0) {
-    return Ok(explicitEntries.map((e) => resolve4(rootDir, e)));
+var TS_HINTS = ['Add "exports" or "main" to package.json', "Create src/index.ts"];
+var TS_CONVENTIONS = ["src/index.ts", "src/main.ts", "src/index.tsx", "index.ts", "main.ts"];
+async function readPackageJsonEntries(rootDir, pkgPath) {
+  const content = await readFileContent(pkgPath);
+  if (!content.ok) return [];
+  try {
+    const pkg = JSON.parse(content.value);
+    return extractPackageEntries(rootDir, pkg);
+  } catch {
+    return [];
   }
+}
+async function resolveTypeScript(rootDir) {
   const pkgPath = join15(rootDir, "package.json");
-  if (await fileExists(pkgPath)) {
-    const pkgContent = await readFileContent(pkgPath);
-    if (pkgContent.ok) {
-      try {
-        const pkg = JSON.parse(pkgContent.value);
-        const entries = extractPackageEntries(rootDir, pkg);
-        if (entries.length > 0) return Ok(entries);
-      } catch {
-      }
+  const detected = await fileExists(pkgPath);
+  if (detected) {
+    const entries = await readPackageJsonEntries(rootDir, pkgPath);
+    if (entries.length > 0) {
+      return { language: "typescript", detected: true, entries, hints: TS_HINTS };
     }
   }
-  const conventions = ["src/index.ts", "src/main.ts", "index.ts", "main.ts"];
-  for (const conv of conventions) {
-    const convPath = join15(rootDir, conv);
-    if (await fileExists(convPath)) {
-      return Ok([convPath]);
+  for (const conv of TS_CONVENTIONS) {
+    const p = join15(rootDir, conv);
+    if (await fileExists(p)) {
+      return { language: "typescript", detected: true, entries: [p], hints: TS_HINTS };
     }
   }
+  return { language: "typescript", detected, entries: [], hints: TS_HINTS };
+}
+var PYTHON_HINTS = [
+  "Add an entry to [project.scripts] in pyproject.toml",
+  "Create main.py or <package>/__main__.py"
+];
+var PYTHON_CONVENTIONS = [
+  "__main__.py",
+  "main.py",
+  "app.py",
+  "src/__main__.py",
+  "src/main.py",
+  "src/app.py"
+];
+async function detectPython(rootDir) {
+  return await fileExists(join15(rootDir, "pyproject.toml")) || await fileExists(join15(rootDir, "setup.py")) || await fileExists(join15(rootDir, "requirements.txt"));
+}
+async function readPyProject(rootDir) {
+  const pyproject = join15(rootDir, "pyproject.toml");
+  if (!await fileExists(pyproject)) return { scriptTargets: [] };
+  const content = await readFileContent(pyproject);
+  if (!content.ok) return { scriptTargets: [] };
+  return parsePyProject(content.value);
+}
+async function resolveScriptTargetEntry(rootDir, target) {
+  const mod = target.split(":")[0];
+  if (!mod) return void 0;
+  const relPath2 = mod.replaceAll(".", "/") + ".py";
+  for (const candidate of [join15(rootDir, relPath2), join15(rootDir, "src", relPath2)]) {
+    if (await fileExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function resolvePythonFromScripts(rootDir, targets) {
+  const entries = [];
+  for (const target of targets) {
+    const entry = await resolveScriptTargetEntry(rootDir, target);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+async function resolvePythonFromProjectName(rootDir, projectName) {
+  if (!projectName) return [];
+  const normalized = projectName.replaceAll("-", "_");
+  const candidates = [
+    join15(rootDir, normalized, "__init__.py"),
+    join15(rootDir, normalized, "__main__.py"),
+    join15(rootDir, "src", normalized, "__init__.py"),
+    join15(rootDir, "src", normalized, "__main__.py")
+  ];
+  const entries = [];
+  for (const c of candidates) {
+    if (await fileExists(c)) entries.push(c);
+  }
+  return entries;
+}
+async function resolvePythonConventions(rootDir) {
+  const entries = [];
+  for (const conv of PYTHON_CONVENTIONS) {
+    const p = join15(rootDir, conv);
+    if (await fileExists(p)) entries.push(p);
+  }
+  return entries;
+}
+async function findPythonTopLevelPackages(rootDir) {
+  const found = await findFiles("*/__init__.py", rootDir);
+  if (found.length > 0) return found;
+  return findFiles("src/*/__init__.py", rootDir);
+}
+async function resolvePython(rootDir) {
+  if (!await detectPython(rootDir)) {
+    return { language: "python", detected: false, entries: [], hints: PYTHON_HINTS };
+  }
+  const info = await readPyProject(rootDir);
+  const strategies = [
+    () => resolvePythonFromScripts(rootDir, info.scriptTargets),
+    () => resolvePythonFromProjectName(rootDir, info.projectName),
+    () => resolvePythonConventions(rootDir),
+    () => findPythonTopLevelPackages(rootDir)
+  ];
+  for (const strategy of strategies) {
+    const entries = await strategy();
+    if (entries.length > 0) {
+      return { language: "python", detected: true, entries, hints: PYTHON_HINTS };
+    }
+  }
+  return { language: "python", detected: true, entries: [], hints: PYTHON_HINTS };
+}
+async function resolveGo(rootDir) {
+  const hints = ["Create main.go at the project root, or use the cmd/<name>/main.go layout"];
+  const detected = await fileExists(join15(rootDir, "go.mod"));
+  if (!detected) return { language: "go", detected: false, entries: [], hints };
+  const entries = [];
+  const mainGo = join15(rootDir, "main.go");
+  if (await fileExists(mainGo)) entries.push(mainGo);
+  entries.push(...await findFiles("cmd/*/main.go", rootDir));
+  return { language: "go", detected: true, entries, hints };
+}
+async function resolveRust(rootDir) {
+  const hints = [
+    "Create src/main.rs or src/lib.rs",
+    "Declare [[bin]] entries with a `path` in Cargo.toml"
+  ];
+  const cargoPath = join15(rootDir, "Cargo.toml");
+  const detected = await fileExists(cargoPath);
+  if (!detected) return { language: "rust", detected: false, entries: [], hints };
+  const entries = [];
+  const content = await readFileContent(cargoPath);
+  if (content.ok) {
+    for (const bp of parseCargoBinPaths(content.value)) {
+      const abs = resolve4(rootDir, bp);
+      if (await fileExists(abs)) entries.push(abs);
+    }
+  }
+  if (entries.length === 0) {
+    for (const conv of ["src/main.rs", "src/lib.rs"]) {
+      const p = join15(rootDir, conv);
+      if (await fileExists(p)) entries.push(p);
+    }
+    entries.push(...await findFiles("src/bin/*.rs", rootDir));
+  }
+  return { language: "rust", detected: true, entries, hints };
+}
+async function resolveJava(rootDir) {
+  const hints = [
+    "Place an entry class at src/main/java/**/Main.java (or *Application.java for Spring Boot)"
+  ];
+  const detected = await fileExists(join15(rootDir, "pom.xml")) || await fileExists(join15(rootDir, "build.gradle")) || await fileExists(join15(rootDir, "build.gradle.kts"));
+  if (!detected) return { language: "java", detected: false, entries: [], hints };
+  const entries = [];
+  entries.push(...await findFiles("src/main/java/**/Main.java", rootDir));
+  entries.push(...await findFiles("src/main/java/**/*Application.java", rootDir));
+  return { language: "java", detected: true, entries, hints };
+}
+function parseTomlLine(raw) {
+  const line = raw.replace(/(^|\s)#.*$/, "").trim();
+  if (!line) return {};
+  const sectionMatch = /^\[([^\]]+)\]$/.exec(line);
+  if (sectionMatch) return { section: sectionMatch[1] ?? "" };
+  const eq = line.indexOf("=");
+  if (eq <= 0) return {};
+  return {
+    key: line.slice(0, eq).trim(),
+    value: stripTomlString2(line.slice(eq + 1).trim())
+  };
+}
+function parsePyProject(content) {
+  const result = { scriptTargets: [] };
+  let section = null;
+  for (const raw of content.split(/\r?\n/)) {
+    const parsed = parseTomlLine(raw);
+    if (parsed.section !== void 0) {
+      section = parsed.section;
+      continue;
+    }
+    if (parsed.key === void 0 || parsed.value === void 0) continue;
+    if (section === "project" && parsed.key === "name") result.projectName = parsed.value;
+    else if (section === "project.scripts") result.scriptTargets.push(parsed.value);
+  }
+  return result;
+}
+function parseCargoBinPaths(content) {
+  const paths = [];
+  let inBin = false;
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.replace(/(^|\s)#.*$/, "").trim();
+    if (!line) continue;
+    if (line === "[[bin]]") {
+      inBin = true;
+      continue;
+    }
+    if (line.startsWith("[")) {
+      inBin = false;
+      continue;
+    }
+    if (!inBin) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (key === "path") paths.push(stripTomlString2(line.slice(eq + 1).trim()));
+  }
+  return paths;
+}
+function stripTomlString2(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function resolveEntryPoints(rootDir, explicitEntries) {
+  if (explicitEntries && explicitEntries.length > 0) {
+    return Ok(explicitEntries.map((e) => resolve4(rootDir, e)));
+  }
+  const resolvers = [resolveTypeScript, resolvePython, resolveGo, resolveRust, resolveJava];
+  const resolutions = [];
+  for (const resolver of resolvers) {
+    const res = await resolver(rootDir);
+    resolutions.push(res);
+    if (res.entries.length > 0) return Ok(res.entries);
+  }
+  const detectedLangs = resolutions.filter((r) => r.detected);
+  const suggestions = detectedLangs.length > 0 ? detectedLangs.flatMap((r) => r.hints) : resolutions.flatMap((r) => r.hints);
+  suggestions.push("Specify entryPoints in config");
+  const reason = detectedLangs.length > 0 ? `Detected ${detectedLangs.map((r) => r.language).join(", ")} project but found no entry points` : "No language manifest (package.json, pyproject.toml, go.mod, Cargo.toml, pom.xml) and no conventional entry files found";
   return Err(
     createEntropyError(
       "ENTRY_POINT_NOT_FOUND",
       "Could not resolve entry points",
-      { reason: "No package.json exports/main and no conventional entry files found" },
-      [
-        'Add "exports" or "main" to package.json',
-        "Create src/index.ts",
-        "Specify entryPoints in config"
-      ]
+      { reason },
+      suggestions
     )
   );
 }
+
+// src/entropy/snapshot.ts
+var DEFAULT_INCLUDE_PATTERNS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.mjs",
+  "**/*.cjs",
+  "**/*.py",
+  "**/*.go",
+  "**/*.rs",
+  "**/*.java"
+];
 function extractCodeBlocks(content) {
   const blocks = [];
   const lines = content.split("\n");
@@ -3061,6 +3453,7 @@ function extractSymbolsFromNode(node) {
   return [];
 }
 function extractInternalSymbols(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
   const body = ast.body;
   if (!body?.body) return [];
   const nodes = body.body;
@@ -3071,6 +3464,7 @@ function toJSDocComment(comment) {
   return { content: comment.value, line: comment.loc?.start?.line || 0 };
 }
 function extractJSDocComments(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
   const body = ast.body;
   if (!body?.comments) return [];
   return body.comments.flatMap((c) => {
@@ -3129,19 +3523,16 @@ function extractAllCodeReferences(docs) {
 }
 async function buildSnapshot(config) {
   const startTime = Date.now();
-  const parser = config.parser || new TypeScriptParser();
-  const rootDir = resolve4(config.rootDir);
+  const rootDir = resolve5(config.rootDir);
   const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
   if (!entryPointsResult.ok) {
     return Err(entryPointsResult.error);
   }
-  const includePatterns = config.include || ["**/*.ts", "**/*.tsx"];
-  const excludePatterns = config.exclude || [
-    "node_modules/**",
-    "dist/**",
-    "**/*.test.ts",
-    "**/*.spec.ts"
-  ];
+  const registry = getDefaultRegistry();
+  const singleParser = config.parser;
+  const parserForFile = (filePath) => singleParser ?? registry.getForFile(filePath);
+  const includePatterns = config.include || DEFAULT_INCLUDE_PATTERNS;
+  const excludePatterns = config.exclude || [...skipDirGlobs(), "**/*.test.ts", "**/*.spec.ts"];
   let sourceFilePaths = [];
   for (const pattern of includePatterns) {
     const files2 = await findFiles(pattern, rootDir);
@@ -3149,14 +3540,16 @@ async function buildSnapshot(config) {
   }
   sourceFilePaths = sourceFilePaths.filter((f) => {
     const rel = relativePosix(rootDir, f);
-    return !excludePatterns.some((p) => minimatch2(rel, p));
+    return !excludePatterns.some((p) => minimatch3(rel, p));
   });
   const files = [];
   for (const filePath of sourceFilePaths) {
-    const parseResult = await parser.parseFile(filePath);
+    const fileParser = parserForFile(filePath);
+    if (!fileParser) continue;
+    const parseResult = await fileParser.parseFile(filePath);
     if (!parseResult.ok) continue;
-    const importsResult = parser.extractImports(parseResult.value);
-    const exportsResult = parser.extractExports(parseResult.value);
+    const importsResult = fileParser.extractImports(parseResult.value);
+    const exportsResult = fileParser.extractExports(parseResult.value);
     const internalSymbols = extractInternalSymbols(parseResult.value);
     const jsDocComments = extractJSDocComments(parseResult.value);
     files.push({
@@ -3168,7 +3561,7 @@ async function buildSnapshot(config) {
       jsDocComments
     });
   }
-  const graphResult = await buildDependencyGraph(sourceFilePaths, parser);
+  const graphResult = await buildDependencyGraph(sourceFilePaths, singleParser ?? registry);
   const dependencyGraph = graphResult.ok ? graphResult.value : { nodes: [], edges: [] };
   const docPatterns = config.docPaths || ["docs/**/*.md", "README.md", "**/README.md"];
   let docFilePaths = [];
@@ -3201,7 +3594,7 @@ async function buildSnapshot(config) {
 }
 
 // src/entropy/detectors/drift.ts
-import { dirname as dirname5, resolve as resolve5 } from "path";
+import { dirname as dirname5, resolve as resolve6 } from "path";
 function initLevenshteinMatrix(aLen, bLen) {
   const matrix = [];
   for (let i = 0; i <= bLen; i++) {
@@ -3313,7 +3706,7 @@ async function checkStructureDrift(snapshot, _config) {
   for (const doc of snapshot.docs) {
     const fileLinks = extractFileLinks(doc.content);
     for (const { link, line } of fileLinks) {
-      const resolvedPath = resolve5(dirname5(doc.path), link);
+      const resolvedPath = resolve6(dirname5(doc.path), link);
       const exists = await fileExists(resolvedPath);
       if (!exists) {
         drifts.push({
@@ -3404,7 +3797,7 @@ async function detectDocDrift(snapshot, config, graphDriftData) {
 }
 
 // src/entropy/detectors/dead-code.ts
-import { dirname as dirname6, extname, resolve as resolve6 } from "path";
+import { dirname as dirname6, extname, resolve as resolve7 } from "path";
 var JS_EXT_FALLBACKS = {
   ".js": [".ts", ".tsx", ".jsx"],
   ".jsx": [".tsx"],
@@ -3424,7 +3817,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
   }
   const hasFile = fileIndex ? (p) => fileIndex.has(p) : (p) => snapshot.files.some((f) => f.path === p);
   const fromDir = dirname6(fromFile);
-  const resolved = resolve6(fromDir, importSource);
+  const resolved = resolve7(fromDir, importSource);
   const sourceExt = extname(resolved);
   const fallbacks = JS_EXT_FALLBACKS[sourceExt];
   if (fallbacks) {
@@ -3434,7 +3827,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
       if (hasFile(candidate)) return candidate;
     }
     for (const indexExt of [".ts", ".tsx", ".jsx"]) {
-      const indexPath2 = resolve6(base, "index" + indexExt);
+      const indexPath2 = resolve7(base, "index" + indexExt);
       if (hasFile(indexPath2)) return indexPath2;
     }
   }
@@ -3445,7 +3838,7 @@ function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
       if (hasFile(candidate)) return candidate;
     }
     for (const indexExt of [".ts", ".tsx"]) {
-      const indexPath2 = resolve6(resolved, "index" + indexExt);
+      const indexPath2 = resolve7(resolved, "index" + indexExt);
       if (hasFile(indexPath2)) return indexPath2;
     }
   }
@@ -3759,10 +4152,10 @@ async function detectDeadCode(snapshot, graphDeadCodeData, protectedRegions) {
 }
 
 // src/entropy/detectors/patterns.ts
-import { minimatch as minimatch3 } from "minimatch";
+import { minimatch as minimatch4 } from "minimatch";
 function fileMatchesPattern(filePath, pattern, rootDir) {
   const relativePath = relativePosix(rootDir, filePath);
-  return minimatch3(relativePath, pattern);
+  return minimatch4(relativePath, pattern);
 }
 var CONVENTION_DESCRIPTIONS = {
   camelCase: "camelCase (e.g., myFunction)",
@@ -3962,6 +4355,7 @@ async function detectPatternViolations(snapshot, config) {
 // src/entropy/detectors/size-budget.ts
 import { readdirSync, statSync as statSync2 } from "fs";
 import { join as join16 } from "path";
+import { DEFAULT_SKIP_DIRS } from "@harness-engineering/graph";
 function parseSize(size) {
   const match = size.trim().match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
   if (!match) return 0;
@@ -3987,7 +4381,7 @@ function dirSize(dirPath) {
     return 0;
   }
   for (const entry of entries) {
-    if (entry === "node_modules" || entry === ".git") continue;
+    if (DEFAULT_SKIP_DIRS.has(entry)) continue;
     const fullPath = join16(dirPath, entry);
     try {
       const stat2 = statSync2(fullPath);
@@ -4164,10 +4558,7 @@ var EntropyAnalyzer = class {
   snapshot;
   report;
   constructor(config) {
-    this.config = {
-      ...config,
-      parser: config.parser || new TypeScriptParser()
-    };
+    this.config = { ...config };
   }
   /**
    * Run full entropy analysis.
@@ -5176,7 +5567,7 @@ var RegressionDetector = class {
 // src/performance/critical-path.ts
 import * as fs7 from "fs";
 import * as path4 from "path";
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
+import { DEFAULT_SKIP_DIRS as DEFAULT_SKIP_DIRS2 } from "@harness-engineering/graph";
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
 var FUNCTION_DECL_RE = /(?:export\s+)?(?:async\s+)?function\s+(\w+)/;
 var CONST_DECL_RE = /(?:export\s+)?(?:const|let)\s+(\w+)\s*=/;
@@ -5243,7 +5634,7 @@ var CriticalPathResolver = class {
     }
     for (const item of items) {
       if (item.isDirectory()) {
-        if (SKIP_DIRS.has(item.name)) continue;
+        if (DEFAULT_SKIP_DIRS2.has(item.name)) continue;
         this.walkDir(path4.join(dir, item.name), entries);
       } else if (item.isFile() && SOURCE_EXTENSIONS.has(path4.extname(item.name))) {
         this.scanFile(path4.join(dir, item.name), entries);
@@ -8262,7 +8653,7 @@ function checkOverlap(newEntry, existingEntries, options) {
 var LOCK_RETRIES = 3;
 var LOCK_BACKOFFS = [50, 100, 200];
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function acquireFileLock(lockPath) {
   for (let attempt = 0; attempt < LOCK_RETRIES; attempt++) {
@@ -9475,7 +9866,7 @@ async function runMultiTurnPipeline(initialContext, turnExecutor, options) {
 
 // src/security/scanner.ts
 import * as fs28 from "fs/promises";
-import { minimatch as minimatch4 } from "minimatch";
+import { minimatch as minimatch5 } from "minimatch";
 
 // src/security/rules/registry.ts
 var RuleRegistry = class {
@@ -9507,13 +9898,15 @@ var RuleRegistry = class {
 
 // src/security/config.ts
 import { z as z10 } from "zod";
+import { skipDirGlobs as skipDirGlobs3 } from "@harness-engineering/graph";
 
 // src/security/types.ts
+import { skipDirGlobs as skipDirGlobs2 } from "@harness-engineering/graph";
 var DEFAULT_SECURITY_CONFIG = {
   enabled: true,
   strict: false,
   rules: {},
-  exclude: ["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]
+  exclude: [...skipDirGlobs2(), "**/*.test.ts", "**/fixtures/**"]
 };
 
 // src/security/config.ts
@@ -9522,7 +9915,7 @@ var SecurityConfigSchema = z10.object({
   enabled: z10.boolean().default(true),
   strict: z10.boolean().default(false),
   rules: z10.record(z10.string(), RuleOverrideSchema).optional().default({}),
-  exclude: z10.array(z10.string()).optional().default(["**/node_modules/**", "**/dist/**", "**/*.test.ts", "**/fixtures/**"]),
+  exclude: z10.array(z10.string()).optional().default([...skipDirGlobs3(), "**/*.test.ts", "**/fixtures/**"]),
   external: z10.object({
     semgrep: z10.object({
       enabled: z10.union([z10.literal("auto"), z10.boolean()]).default("auto"),
@@ -10433,7 +10826,7 @@ var SecurityScanner = class {
     const applicableRules = this.activeRules.filter((rule) => {
       if (!rule.fileGlob) return true;
       const globs = rule.fileGlob.split(",").map((g) => g.trim());
-      return globs.some((glob5) => minimatch4(filePath, glob5, { dot: true }));
+      return globs.some((glob5) => minimatch5(filePath, glob5, { dot: true }));
     });
     return this.scanLinesWithRules(lines, applicableRules, filePath, startLine);
   }
@@ -11441,6 +11834,7 @@ var SecurityTimelineManager = class _SecurityTimelineManager {
 
 // src/ci/check-orchestrator.ts
 import * as path25 from "path";
+import { skipDirGlobs as skipDirGlobs4 } from "@harness-engineering/graph";
 import { GraphStore, queryTraceability } from "@harness-engineering/graph";
 var ALL_CHECKS = [
   "validate",
@@ -11518,8 +11912,7 @@ async function runDocsCheck(projectRoot, config) {
     docsDir,
     sourceDir: projectRoot,
     excludePatterns: entropyConfig.excludePatterns || [
-      "**/node_modules/**",
-      "**/dist/**",
+      ...skipDirGlobs4(),
       "**/*.test.ts",
       "**/fixtures/**"
     ]
@@ -11584,12 +11977,7 @@ async function runSecurityCheck(projectRoot, config) {
   const { glob: globFn } = await import("glob");
   const sourceFiles = await globFn("**/*.{ts,tsx,js,jsx,go,py}", {
     cwd: projectRoot,
-    ignore: securityConfig.exclude ?? [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/*.test.ts",
-      "**/fixtures/**"
-    ],
+    ignore: securityConfig.exclude ?? [...skipDirGlobs4(), "**/*.test.ts", "**/fixtures/**"],
     absolute: true
   });
   const scanResult = await scanner.scanFiles(sourceFiles);
@@ -14463,7 +14851,7 @@ function parseRepoParts(repo) {
   return { owner: parts[0], repo: parts[1] };
 }
 function sleep2(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function fetchWithRetry(fetchFn, input, init, opts = RETRY_DEFAULTS) {
   let lastResponse;
@@ -14997,8 +15385,8 @@ var syncMutex = Promise.resolve();
 async function fullSync(roadmapPath, adapter2, config, options) {
   const previousSync = syncMutex;
   let releaseMutex;
-  syncMutex = new Promise((resolve9) => {
-    releaseMutex = resolve9;
+  syncMutex = new Promise((resolve10) => {
+    releaseMutex = resolve10;
   });
   await previousSync;
   try {
@@ -17766,7 +18154,7 @@ var POSTHOG_BATCH_URL = "https://app.posthog.com/batch";
 var MAX_ATTEMPTS = 3;
 var TIMEOUT_MS = 5e3;
 function sleep3(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function send(events, apiKey) {
   if (events.length === 0) return;
@@ -18676,6 +19064,7 @@ export {
   ViolationHistorySchema,
   ViolationSchema,
   ViolationSnapshotSchema,
+  WHATWG_BAD_PORTS,
   acquireCompoundLock,
   addProvenance,
   agentConfigRules,
@@ -18701,6 +19090,7 @@ export {
   archiveStream,
   assembleCandidateReport,
   assembleReport,
+  assertPortUsable,
   assertSanitized,
   assignFeature,
   buildDependencyGraph,
@@ -18815,6 +19205,7 @@ export {
   goRules,
   injectionRules,
   insecureDefaultsRules,
+  isBadPort,
   isDuplicateFinding,
   isRegression,
   isSanitizedResult,
@@ -18948,6 +19339,7 @@ export {
   validateAgentConfigs,
   validateAgentsMap,
   validateBoundaries,
+  validateBranchName,
   validateCommitMessage,
   validateConfig,
   validateDependencies,