@cassiomc1/forgeloop 1.12.0 → 1.14.0

package/src/core/java-project.js

@@ -0,0 +1,403 @@
+import { createLanguageProject, JAVA_SOURCE_EXTENSIONS, pathBelongsToRoot, portablePath } from "./multi-language-project.js";
+import { maskBuildScript } from "./build-script.js";
+import { parseXmlStructure } from "./xml-structure.js";
+
+function invalidJava() {
+  return {
+    valid: false,
+    javaPlugin: false,
+    javaPlatform: false,
+    javaCompiler: false,
+    packaging: null,
+    modules: [],
+    includes: [],
+    gradleBuild: false,
+    gradleSettings: false,
+    gradleProperties: false,
+  };
+}
+
+function childNodes(node, name) {
+  return node.children.filter((child) => child.name.toLowerCase() === name.toLowerCase());
+}
+
+function nodesAtPath(root, names) {
+  return names.reduce((nodes, name) => nodes.flatMap((node) => childNodes(node, name)), [root]);
+}
+
+function nodeValues(nodes) {
+  return nodes
+    .filter((node) => node.children.length === 0 && node.text.length <= 256)
+    .map((node) => node.text.trim())
+    .filter(Boolean);
+}
+
+export function parseMavenPom(text) {
+  const document = parseXmlStructure(text);
+  if (!document || document.root.name.toLowerCase() !== "project") return invalidJava();
+  const root = document.root;
+  const packaging = nodeValues(childNodes(root, "packaging"))[0] ?? null;
+  const modules = nodeValues(nodesAtPath(root, ["modules", "module"]));
+  const compilerProperties = ["release", "source", "target"]
+    .some((name) => nodeValues(nodesAtPath(root, ["properties", `maven.compiler.${name}`])).length > 0);
+  const compilerPlugin = [
+    ["build", "plugins", "plugin", "artifactId"],
+    ["build", "pluginManagement", "plugins", "plugin", "artifactId"],
+  ].some((path) => nodeValues(nodesAtPath(root, path)).some((value) => value === "maven-compiler-plugin"));
+  const javaCompiler = compilerProperties || compilerPlugin;
+  const valid = nodeValues(childNodes(root, "artifactId")).length > 0
+    || packaging === "pom"
+    || modules.length > 0
+    || javaCompiler;
+  return { valid, javaPlugin: false, javaPlatform: false, javaCompiler, packaging, modules };
+}
+
+function maskGradleStringsAndComments(text) {
+  let result = "";
+  let state = "code";
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "string") {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote) {
+        state = "code";
+        quote = null;
+      }
+      result += character === "\n" || character === "\r" ? character : " ";
+    } else if (state === "line-comment") {
+      if (character === "\n" || character === "\r") {
+        result += character;
+        state = "code";
+      } else result += " ";
+    } else if (state === "block-comment") {
+      if (character === "*" && next === "/") {
+        result += "  ";
+        index += 1;
+        state = "code";
+      } else result += character === "\n" || character === "\r" ? character : " ";
+    } else if (character === "\"" || character === "'") {
+      result += " ";
+      quote = character;
+      state = "string";
+    } else if (character === "/" && next === "/") {
+      result += "  ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      result += "  ";
+      index += 1;
+      state = "block-comment";
+    } else {
+      result += character;
+    }
+  }
+  return state === "code" ? result : null;
+}
+
+function stripGradleComments(text) {
+  let result = "";
+  let state = "code";
+  let quote = null;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "string") {
+      result += character;
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote) {
+        state = "code";
+        quote = null;
+      }
+    } else if (state === "line-comment") {
+      if (character === "\n" || character === "\r") {
+        result += character;
+        state = "code";
+      } else result += " ";
+    } else if (state === "block-comment") {
+      if (character === "*" && next === "/") {
+        result += "  ";
+        index += 1;
+        state = "code";
+      } else result += character === "\n" || character === "\r" ? character : " ";
+    } else if (character === "\"" || character === "'") {
+      result += character;
+      quote = character;
+      state = "string";
+    } else if (character === "/" && next === "/") {
+      result += "  ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      result += "  ";
+      index += 1;
+      state = "block-comment";
+    } else result += character;
+  }
+  return state === "code" ? result : null;
+}
+
+const JAVA_PLUGIN_IDS = new Set(["java", "java-library", "java-platform", "java-gradle-plugin", "application", "war"]);
+
+function quotedPluginId(rawBlock, start) {
+  const plugin = rawBlock.slice(start).match(/^\s*(?:\(\s*)?["']([^"']+)["']/u)?.[1];
+  return JAVA_PLUGIN_IDS.has(plugin);
+}
+
+function pluginBlockHasJava(rawBlock) {
+  const masked = maskGradleStringsAndComments(rawBlock);
+  if (masked === null) return false;
+  for (const match of masked.matchAll(/\bid\b/gu)) {
+    if (quotedPluginId(rawBlock, match.index + match[0].length)) return true;
+  }
+  return /(?:^|[;{}\n])\s*(?:`(?:java|javaLibrary|javaPlatform|java-gradle-plugin|application|war)`|java|javaLibrary|javaPlatform|java-gradle-plugin|application|war)\s*(?:[;\n}]|$)/mu.test(masked);
+}
+
+function hasJavaPlugin(text) {
+  const masked = maskGradleStringsAndComments(text);
+  if (masked === null) return false;
+  for (const match of masked.matchAll(/\bplugins\s*\{([\s\S]*?)\}/gu)) {
+    const open = match[0].indexOf("{");
+    if (pluginBlockHasJava(text.slice(match.index + open + 1, match.index + match[0].length - 1))) return true;
+  }
+  for (const match of masked.matchAll(/\bapply\s+plugin\s*:\s*/gu)) {
+    const suffix = text.slice(match.index + match[0].length);
+    if (/^['"](?:java|java-library|java-platform|java-gradle-plugin|application|war)['"]/u.test(suffix)) return true;
+  }
+  return false;
+}
+
+function splitGradleArguments(text) {
+  if (text.trim() === "") return [];
+  const parts = [];
+  let start = 0;
+  let quote = null;
+  let escaped = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === quote) quote = null;
+      continue;
+    }
+    if (character === "\"" || character === "'") {
+      quote = character;
+    } else if (character === "(" || character === "[" || character === "{") {
+      depth += 1;
+    } else if (character === ")" || character === "]" || character === "}") {
+      depth -= 1;
+      if (depth < 0) return null;
+    } else if (character === "," && depth === 0) {
+      parts.push(text.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  if (quote || depth !== 0) return null;
+  parts.push(text.slice(start).trim());
+  return parts.filter(Boolean);
+}
+
+function gradleQuotedValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2 || !["\"", "'"].includes(trimmed[0]) || trimmed.at(-1) !== trimmed[0]) return null;
+  const quote = trimmed[0];
+  if (trimmed.includes("$")) return null;
+  let result = "";
+  let escaped = false;
+  for (let index = 1; index < trimmed.length; index += 1) {
+    const character = trimmed[index];
+    if (escaped) {
+      result += character;
+      escaped = false;
+    } else if (character === "\\") {
+      escaped = true;
+    } else if (character === quote) {
+      return index === trimmed.length - 1 ? result : null;
+    } else {
+      result += character;
+    }
+  }
+  return null;
+}
+
+function gradleParenthesisEnd(source, open) {
+  let depth = 1;
+  for (let index = open + 1; index < source.length; index += 1) {
+    if (source[index] === "(") depth += 1;
+    else if (source[index] === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function topLevelGradleIncludeOffsets(source) {
+  const offsets = [];
+  const depths = { braces: 0, parentheses: 0, brackets: 0 };
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    if (character === "{") depths.braces += 1;
+    else if (character === "}") depths.braces = Math.max(0, depths.braces - 1);
+    else if (character === "(") depths.parentheses += 1;
+    else if (character === ")") depths.parentheses = Math.max(0, depths.parentheses - 1);
+    else if (character === "[") depths.brackets += 1;
+    else if (character === "]") depths.brackets = Math.max(0, depths.brackets - 1);
+    if (Object.values(depths).some((depth) => depth !== 0)
+      || !source.startsWith("include", index)
+      || /[A-Za-z0-9_]/u.test(source[index - 1] ?? "")
+      || /[A-Za-z0-9_]/u.test(source[index + 7] ?? "")) continue;
+    offsets.push(index);
+  }
+  return offsets;
+}
+
+function parseGradleIncludeAt(text, source, index) {
+  let cursor = index + 7;
+  while (/\s/u.test(text[cursor] ?? "")) cursor += 1;
+  let body;
+  if (text[cursor] === "(") {
+    const close = gradleParenthesisEnd(source, cursor);
+    if (close < 0) return null;
+    body = text.slice(cursor + 1, close);
+  } else {
+    const end = text.indexOf("\n", cursor);
+    body = text.slice(cursor, end < 0 ? text.length : end);
+  }
+  const commentFreeBody = stripGradleComments(body);
+  const values = commentFreeBody === null ? null : splitGradleArguments(commentFreeBody);
+  if (values === null) return null;
+  const literals = values.map((value) => gradleQuotedValue(value));
+  return literals.some((literal) => literal === null || literal.trim() === "") ? null : literals;
+}
+
+function isStandaloneGradleInclude(source, index) {
+  const statementStart = Math.max(
+    source.lastIndexOf("\n", index - 1),
+    source.lastIndexOf("\r", index - 1),
+    source.lastIndexOf(";", index - 1),
+  ) + 1;
+  return source.slice(statementStart, index).trim() === "";
+}
+
+function isUnbracedGradleControlBody(source, index) {
+  const lineStart = Math.max(source.lastIndexOf("\n", index - 1), source.lastIndexOf("\r", index - 1)) + 1;
+  let previousEnd = lineStart - 1;
+  while (previousEnd >= 0) {
+    const previousStart = Math.max(
+      source.lastIndexOf("\n", previousEnd - 1),
+      source.lastIndexOf("\r", previousEnd - 1),
+    ) + 1;
+    const previousLine = source.slice(previousStart, previousEnd).trim();
+    if (previousLine) {
+      if (previousLine.includes("{")) return false;
+      return /^(?:if|else|for|while|when|switch)\b/u.test(previousLine);
+    }
+    previousEnd = previousStart - 1;
+  }
+  return false;
+}
+
+export function parseGradleSettings(text) {
+  const invalid = {
+    valid: false,
+    javaPlugin: false,
+    javaPlatform: false,
+    javaCompiler: false,
+    packaging: null,
+    modules: [],
+    includes: [],
+    gradleBuild: false,
+    gradleSettings: true,
+    gradleProperties: false,
+  };
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalid;
+  const source = maskGradleStringsAndComments(text);
+  if (source === null) return invalid;
+  const includes = [];
+  for (const offset of topLevelGradleIncludeOffsets(source)) {
+    if (!isStandaloneGradleInclude(source, offset) || isUnbracedGradleControlBody(source, offset)) continue;
+    const literals = parseGradleIncludeAt(text, source, offset);
+    if (literals === null) return invalid;
+    includes.push(...literals);
+  }
+  return { ...invalid, valid: true, includes: [...new Set(includes)] };
+}
+
+export function parseGradleProperties(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidJava();
+  return { ...invalidJava(), valid: true, gradleProperties: true };
+}
+
+export function parseGradleBuild(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidJava();
+  const source = maskGradleStringsAndComments(text);
+  if (source === null) return invalidJava();
+  const javaPlugin = hasJavaPlugin(text);
+  const javaPlatform = javaPlugin && /(?:java-platform|javaPlatform)/u.test(text);
+  return {
+    valid: javaPlugin || javaPlatform,
+    javaPlugin,
+    javaPlatform,
+    javaCompiler: false,
+    packaging: null,
+    modules: [],
+    includes: [],
+    gradleBuild: true,
+    gradleSettings: false,
+    gradleProperties: false,
+  };
+}
+
+export function parseBazelJava(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidJava();
+  const source = maskBuildScript(text);
+  const javaPlugin = source !== null && /\bjava_(?:binary|library|test|import|plugin)\s*\(/u.test(source);
+  return { valid: javaPlugin, javaPlugin, javaPlatform: false, javaCompiler: false, packaging: null, modules: [] };
+}
+
+function hasOwnedJavaSource(sourceFiles, targetRoot, projectRoot, projectRoots) {
+  return sourceFiles.some((file) => JAVA_SOURCE_EXTENSIONS.has(file.extension)
+    && pathBelongsToRoot(portablePath(targetRoot, file.path), projectRoot, projectRoots));
+}
+
+export function inspectJavaProject({ projectRoot, manifestRelative, manifestText, manifestName, targetRoot, sourceFiles, projectRoots }) {
+  const parsed = manifestName === "pom.xml"
+    ? parseMavenPom(manifestText)
+    : manifestName === "build" || manifestName === "build.bazel"
+      ? parseBazelJava(manifestText)
+      : manifestName === "settings.gradle" || manifestName === "settings.gradle.kts"
+        ? parseGradleSettings(manifestText)
+        : manifestName === "gradle.properties"
+          ? parseGradleProperties(manifestText)
+          : parseGradleBuild(manifestText);
+  const javaSource = hasOwnedJavaSource(sourceFiles, targetRoot, projectRoot, projectRoots);
+  const canProvideJavaEvidence = !parsed.gradleSettings && !parsed.gradleProperties;
+  const structurallyValid = parsed.valid || parsed.gradleBuild;
+  const primary = canProvideJavaEvidence && structurallyValid
+    && (javaSource || parsed.javaPlugin || parsed.javaPlatform || parsed.javaCompiler);
+  const primarySignals = primary
+    ? [`${manifestRelative}:${parsed.javaPlatform ? "java-platform" : manifestName === "pom.xml" ? "maven" : "build"}`]
+    : [];
+  const supportingSignals = [];
+  if (javaSource) supportingSignals.push(`${projectRoot === "." ? "source" : `${projectRoot}/source`}:java`);
+  for (const module of parsed.modules) supportingSignals.push(`${manifestRelative}:module=${module}`);
+  for (const include of parsed.includes ?? []) supportingSignals.push(`${manifestRelative}:include=${include}`);
+  return createLanguageProject({
+    kind: "java",
+    root: projectRoot,
+    manifest: manifestRelative,
+    frameworks: primary ? ["java"] : [],
+    primary,
+    primarySignals,
+    supportingSignals,
+    internal: { ...parsed, valid: parsed.valid },
+  });
+}

package/src/core/model-router/constants.js

@@ -0,0 +1,10 @@
+import { DECISION_AUTHORITY, DECISION_EVIDENCE_AUTHORITY, PINNED_JEV_MODEL } from "../decision/constants.js";
+
+export const MODEL_ROUTE_TIERS = Object.freeze(["NONE", "FAST", "STANDARD", "PRIMARY"]);
+export const MODEL_ROUTE_POLICY_VERSION = 1;
+export const MODEL_ROUTE_PROJECTION_AUTHORITY = DECISION_AUTHORITY;
+export const MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY = DECISION_EVIDENCE_AUTHORITY;
+export const MODEL_ROUTE_JEV_MODEL = PINNED_JEV_MODEL;
+
+export const MODEL_ROUTE_RANK = Object.freeze({ NONE: 0, FAST: 1, STANDARD: 2, PRIMARY: 3 });
+

package/src/core/model-router/policy.js

@@ -0,0 +1,103 @@
+import { MODEL_ROUTE_RANK, MODEL_ROUTE_TIERS } from "./constants.js";
+
+const GENERATION_WORK_TYPES = new Set([
+  "code", "bug", "refactor", "backend", "api", "infrastructure", "security-review", "release",
+]);
+const PRIMARY_WORK_TYPES = new Set(["infrastructure", "security-review", "release"]);
+const PRIMARY_RISKS = new Set(["secrets", "personal-data", "publication", "critical-path", "destructive", "irreversible", "migration", "credentials", "payment"]);
+const PRIMARY_SURFACES = new Set(["auth", "critical-path", "database"]);
+
+function text(value) {
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+
+function array(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+
+function contractText(contract) {
+  if (!contract || typeof contract !== "object" || Array.isArray(contract)) return "";
+  const values = [contract.objective, contract.summary, ...(contract.deliverables ?? []), ...(contract.successCriteria ?? []), ...(contract.risks ?? []), ...(contract.constraints ?? [])];
+  return values.map((value) => value && typeof value === "object" ? value.text : value).filter((value) => typeof value === "string").join(" ").toLowerCase();
+}
+
+function normalizedInput(input = {}) {
+  return {
+    workType: text(input.workType),
+    surfaces: array(input.surfaces).map(text),
+    risks: array(input.risks).map(text),
+    platforms: array(input.platforms).map(text),
+    behaviorChange: input.behaviorChange === true,
+    executableChange: input.executableChange === true,
+    generationRequired: input.generationRequired === true,
+    architectureChange: input.architectureChange === true,
+    ambiguity: input.ambiguity === true,
+    contract: input.contract,
+  };
+}
+
+function deterministicFloor(input) {
+  const normalized = normalizedInput(input);
+  const reasons = [];
+  const combined = `${contractText(normalized.contract)} ${normalized.workType} ${normalized.surfaces.join(" ")} ${normalized.risks.join(" ")}`;
+  const generationRequired = normalized.generationRequired
+    || normalized.behaviorChange
+    || normalized.executableChange
+    || GENERATION_WORK_TYPES.has(normalized.workType)
+    || /\b(implement|fix|refactor|change|build|generate|write|modify|code)\b/.test(combined);
+  const primary = normalized.architectureChange
+    || normalized.ambiguity
+    || PRIMARY_WORK_TYPES.has(normalized.workType)
+    || normalized.risks.some((risk) => PRIMARY_RISKS.has(risk))
+    || normalized.surfaces.some((surface) => PRIMARY_SURFACES.has(surface))
+    || /\b(architecture|architectural|security boundary|migration|ambiguous|unknown requirements)\b/.test(combined);
+
+  if (!generationRequired) {
+    reasons.push("NO_GENERATION_REQUIRED");
+    return { floor: "NONE", reasons };
+  }
+  reasons.push("GENERATION_REQUIRED");
+  if (primary) {
+    reasons.push("PRIMARY_COMPLEXITY_OR_RISK");
+    return { floor: "PRIMARY", reasons };
+  }
+  reasons.push("STANDARD_GENERATION_FLOOR");
+  return { floor: "STANDARD", reasons };
+}
+
+function normalizeRecommendation(recommendation) {
+  if (recommendation === null || recommendation === undefined) return null;
+  if (typeof recommendation === "string") {
+    return MODEL_ROUTE_TIERS.includes(recommendation) ? { tier: recommendation, confidence: null, requiresEscalation: false } : null;
+  }
+  if (!recommendation || typeof recommendation !== "object" || Array.isArray(recommendation)) return null;
+  const tier = typeof recommendation.tier === "string" && MODEL_ROUTE_TIERS.includes(recommendation.tier) ? recommendation.tier : null;
+  if (!tier) return null;
+  return {
+    tier,
+    confidence: typeof recommendation.confidence === "number" && Number.isFinite(recommendation.confidence) ? recommendation.confidence : null,
+    requiresEscalation: recommendation.requiresEscalation === true,
+  };
+}
+
+export function resolveModelRoute({ input = {}, semanticRecommendation = null } = {}) {
+  const deterministic = deterministicFloor(input);
+  const recommendation = normalizeRecommendation(semanticRecommendation);
+  let resolved = deterministic.floor;
+  const reasons = [...deterministic.reasons];
+  if (recommendation?.requiresEscalation) {
+    if (MODEL_ROUTE_RANK[resolved] < MODEL_ROUTE_RANK.PRIMARY) resolved = "PRIMARY";
+    reasons.push("JEV_LOW_CONFIDENCE_ESCALATION");
+  } else if (recommendation && MODEL_ROUTE_RANK[recommendation.tier] > MODEL_ROUTE_RANK[resolved]) {
+    resolved = recommendation.tier;
+    reasons.push("JEV_ESCALATION_ONLY");
+  }
+  return {
+    floor: deterministic.floor,
+    resolved,
+    reasons: [...new Set(reasons)],
+    semanticRecommendation: recommendation,
+    generationRequired: deterministic.floor !== "NONE",
+  };
+}
+

package/src/core/model-router/router.js

@@ -0,0 +1,37 @@
+import {
+  MODEL_ROUTE_JEV_MODEL,
+  MODEL_ROUTE_POLICY_VERSION,
+  MODEL_ROUTE_PROJECTION_AUTHORITY,
+  MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY,
+  MODEL_ROUTE_RANK,
+  MODEL_ROUTE_TIERS,
+} from "./constants.js";
+import { resolveModelRoute } from "./policy.js";
+
+export function projectModelRoute({ input = {}, semanticRecommendation = null } = {}) {
+  const route = resolveModelRoute({ input, semanticRecommendation });
+  if (!MODEL_ROUTE_TIERS.includes(route.floor) || !MODEL_ROUTE_TIERS.includes(route.resolved)
+    || MODEL_ROUTE_RANK[route.resolved] < MODEL_ROUTE_RANK[route.floor]) {
+    const error = new Error("Model route violates its deterministic safety floor.");
+    error.code = "E_MODEL_ROUTE_SAFETY_FLOOR_INVALID";
+    throw error;
+  }
+  return {
+    schemaVersion: 1,
+    policyVersion: MODEL_ROUTE_POLICY_VERSION,
+    engine: "typesafe-jev",
+    model: MODEL_ROUTE_JEV_MODEL,
+    floor: route.floor,
+    resolved: route.resolved,
+    reasons: route.reasons,
+    generationRequired: route.generationRequired,
+    semanticRecommendation: route.semanticRecommendation,
+    authority: MODEL_ROUTE_PROJECTION_AUTHORITY,
+    evidenceAuthority: MODEL_ROUTE_PROJECTION_EVIDENCE_AUTHORITY,
+    lifecycleAuthority: false,
+    completionAuthority: false,
+    ownershipAuthority: false,
+    installationAuthority: false,
+  };
+}
+

package/src/core/multi-language-project.js

@@ -0,0 +1,117 @@
+import path from "node:path";
+
+export const LANGUAGE_PROJECT_FILE_KINDS = Object.freeze({
+  "go.mod": ["go"],
+  "go.work": ["go-work"],
+  "tsconfig.json": ["typescript"],
+  "jsconfig.json": ["javascript-config"],
+  "composer.json": ["php"],
+  "pom.xml": ["java-maven"],
+  "build.gradle": ["java-gradle"],
+  "build.gradle.kts": ["java-gradle"],
+  "settings.gradle": ["java-gradle-settings"],
+  "settings.gradle.kts": ["java-gradle-settings"],
+  "gradle.properties": ["java-gradle-properties"],
+  "build": ["java-bazel", "native-bazel"],
+  "build.bazel": ["java-bazel", "native-bazel"],
+  "cmakelists.txt": ["c-cpp-cmake", "swift-cmake"],
+  "meson.build": ["c-cpp-meson", "swift-meson"],
+  "meson_options.txt": ["c-cpp-meson-options"],
+  "makefile": ["c-cpp-make"],
+  "gnumakefile": ["c-cpp-make"],
+  "package.swift": ["swift-package"],
+  "project.pbxproj": ["swift-xcode"],
+});
+
+export const LANGUAGE_SOURCE_EXTENSIONS = Object.freeze(new Set([
+  ".c", ".cc", ".cpp", ".cxx", ".c++",
+  ".go", ".java", ".php", ".sql", ".psql", ".pgsql", ".swift",
+  ".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs",
+]));
+
+export const SQL_SOURCE_EXTENSIONS = Object.freeze(new Set([".sql", ".psql", ".pgsql"]));
+export const C_SOURCE_EXTENSIONS = Object.freeze(new Set([".c"]));
+export const CPP_SOURCE_EXTENSIONS = Object.freeze(new Set([".cc", ".cpp", ".cxx", ".c++", ".C"]));
+export const JAVA_SOURCE_EXTENSIONS = Object.freeze(new Set([".java"]));
+export const PHP_SOURCE_EXTENSIONS = Object.freeze(new Set([".php", ".phtml", ".php3", ".php4", ".php5", ".php7", ".phps"]));
+export const SWIFT_SOURCE_EXTENSIONS = Object.freeze(new Set([".swift"]));
+
+export function languageProjectKinds(fileName) {
+  if (typeof fileName !== "string") return [];
+  const lowerName = fileName.toLowerCase();
+  if (/^tsconfig\.[^/]+\.json$/u.test(lowerName)) return ["typescript"];
+  if (/\.sqlproj$/u.test(lowerName)) return ["sql-project"];
+  return LANGUAGE_PROJECT_FILE_KINDS[lowerName] ?? [];
+}
+
+export function languageSourceExtension(fileName) {
+  if (typeof fileName !== "string") return null;
+  const extension = path.extname(fileName);
+  const normalized = extension === ".C" ? ".C" : extension.toLowerCase();
+  return LANGUAGE_SOURCE_EXTENSIONS.has(normalized.toLowerCase()) ? normalized : null;
+}
+
+export function portablePath(root, absolutePath) {
+  const relative = path.relative(root, absolutePath).split(path.sep).join("/");
+  return relative === "" ? "." : relative;
+}
+
+export function relativeProjectRoots(targetRoot, projectFiles = []) {
+  return [...new Set(projectFiles
+    .map((entry) => portablePath(targetRoot, path.dirname(entry.path)))
+    .filter((root) => root !== ".." && !root.startsWith("../")))].sort((left, right) => left.localeCompare(right));
+}
+
+export function pathBelongsToRoot(relativePath, root, projectRoots = []) {
+  const normalizedPath = relativePath.replaceAll("\\", "/").toLowerCase();
+  const normalizedRoot = root.replaceAll("\\", "/").toLowerCase();
+  if (normalizedRoot !== "."
+    && normalizedPath !== normalizedRoot
+    && !normalizedPath.startsWith(`${normalizedRoot}/`)) return false;
+  return !projectRoots.some((candidate) => {
+    const normalizedCandidate = candidate.replaceAll("\\", "/").toLowerCase();
+    const nested = normalizedRoot === "."
+      ? normalizedCandidate !== "."
+      : normalizedCandidate.startsWith(`${normalizedRoot}/`);
+    return nested
+      && (normalizedPath === normalizedCandidate || normalizedPath.startsWith(`${normalizedCandidate}/`));
+  });
+}
+
+export function sourceFilesUnderRoot(sourceFiles, targetRoot, root, extensions, projectRoots = []) {
+  return sourceFiles.filter((file) => {
+    if (!extensions.has(languageSourceExtension(file.name))) return false;
+    return pathBelongsToRoot(portablePath(targetRoot, file.path), root, projectRoots);
+  });
+}
+
+export function createLanguageProject({
+  kind,
+  root,
+  manifest,
+  frameworks = [],
+  primary = false,
+  primarySignals = [],
+  supportingSignals = [],
+  internal = null,
+}) {
+  return {
+    kind,
+    root,
+    manifest,
+    validManifest: Boolean(internal?.valid ?? primary),
+    primary,
+    frameworks: [...new Set(frameworks)].sort((left, right) => left.localeCompare(right)),
+    primarySignals: [...primarySignals],
+    supportingSignals: [...supportingSignals],
+    internal,
+  };
+}
+
+export function isDirectSourceClaim(claim, extensions) {
+  return extensions.has(path.extname(claim).toLowerCase());
+}
+
+export function isConfigOnlyProject(project) {
+  return !project?.frameworks?.length && !project?.primary;
+}