@aefree/pi-unity 0.9.0

package/src/unity-core.ts

@@ -0,0 +1,218 @@
+import { realpathSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export type SupportedPlatform = NodeJS.Platform | "win32" | "darwin" | "linux";
+
+export function normalizeUserPath(rawPath: string): string {
+  const trimmed = rawPath.trim();
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+
+export function resolveAbsolutePath(cwd: string, rawPath: string): string {
+  const normalized = normalizeUserPath(rawPath);
+  return path.isAbsolute(normalized) ? path.normalize(normalized) : path.resolve(cwd, normalized);
+}
+
+export function formatPathForUser(cwd: string, absolutePath: string): string {
+  const relative = path.relative(cwd, absolutePath);
+  if (!relative || relative.startsWith("..")) {
+    return absolutePath;
+  }
+  return relative.split(path.sep).join("/");
+}
+
+export function parseUnityVersionText(contents: string): string | null {
+  const match = contents.match(/^m_EditorVersion:\s*(\S+)\s*$/m);
+  return match ? match[1] : null;
+}
+
+export function normalizeUnityEditorOverride(editorPath: string, platform: SupportedPlatform): string {
+  const normalized = path.normalize(editorPath.trim());
+  if (platform === "darwin" && normalized.toLowerCase().endsWith(".app")) {
+    return path.join(normalized, "Contents", "MacOS", "Unity");
+  }
+  return normalized;
+}
+
+export function buildUnityEditorCandidates(
+  version: string,
+  platform: SupportedPlatform = process.platform,
+  homeDir: string = os.homedir(),
+): string[] {
+  if (platform === "win32") {
+    return [
+      path.join("C:/Program Files/Unity/Hub/Editor", version, "Editor", "Unity.exe"),
+      path.join("C:/Program Files/Unity", version, "Editor", "Unity.exe"),
+      path.join("C:/UnityInstalls", version, "Editor", "Unity.exe"),
+    ];
+  }
+
+  if (platform === "darwin") {
+    return [
+      path.join("/Applications/Unity/Hub/Editor", version, "Unity.app", "Contents", "MacOS", "Unity"),
+      path.join("/Applications/Unity", version, "Unity.app", "Contents", "MacOS", "Unity"),
+    ];
+  }
+
+  return [
+    path.join(homeDir, "Unity", "Hub", "Editor", version, "Editor", "Unity"),
+    path.join(homeDir, "Applications", "Unity", "Hub", "Editor", version, "Editor", "Unity"),
+    path.join("/opt/Unity/Hub/Editor", version, "Editor", "Unity"),
+    path.join("/opt/Unity", version, "Editor", "Unity"),
+    path.join("/opt/unity", version, "Editor", "Unity"),
+  ];
+}
+
+export function buildUnityOpenEditorArgs(projectRoot: string): string[] {
+  return ["-projectPath", projectRoot];
+}
+
+export type UnityBatchmodeArgsOptions = {
+  useGraphics?: boolean;
+};
+
+export function hasUnityCommandLineFlag(args: string[], flag: string): boolean {
+  const normalizedFlag = flag.toLowerCase();
+  return args.some((arg) => {
+    const lower = arg.toLowerCase();
+    return lower === normalizedFlag || lower.startsWith(`${normalizedFlag}=`);
+  });
+}
+
+export function applyDefaultUnityBatchmodeArgs(
+  extraArgs: string[] = [],
+  options: UnityBatchmodeArgsOptions = {},
+): string[] {
+  if (options.useGraphics || hasUnityCommandLineFlag(extraArgs, "-nographics")) {
+    return [...extraArgs];
+  }
+  return ["-nographics", ...extraArgs];
+}
+
+export function buildUnityBatchmodeArgs(
+  projectRoot: string,
+  extraArgs: string[] = [],
+  options: UnityBatchmodeArgsOptions = {},
+): string[] {
+  return ["-batchmode", "-projectPath", projectRoot, ...applyDefaultUnityBatchmodeArgs(extraArgs, options)];
+}
+
+function pathApiForPlatform(platform: SupportedPlatform): typeof path.win32 | typeof path.posix {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+
+export function normalizeForCommandSearch(value: string, platform: SupportedPlatform = process.platform): string {
+  const normalized = pathApiForPlatform(platform).normalize(value.trim());
+  return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function realpathMatchesOnDarwin(candidatePath: string, projectRoot: string, platform: SupportedPlatform): boolean | null {
+  if (platform !== "darwin" || process.platform !== "darwin") {
+    return null;
+  }
+
+  try {
+    return realpathSync.native(candidatePath) === realpathSync.native(projectRoot);
+  } catch {
+    // Only use filesystem identity when both paths can be resolved. Falling back
+    // to the case-sensitive textual comparison preserves case-sensitive APFS.
+    return null;
+  }
+}
+
+export function projectPathsMatch(candidatePath: string, projectRoot: string, platform: SupportedPlatform = process.platform): boolean {
+  const trimmedCandidatePath = candidatePath.trim();
+  const trimmedProjectRoot = projectRoot.trim();
+  const isWindowsStyleAbsolutePath = (value: string): boolean => /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+  const comparisonPlatform = isWindowsStyleAbsolutePath(trimmedCandidatePath) && isWindowsStyleAbsolutePath(trimmedProjectRoot)
+    ? "win32"
+    : platform;
+  const pathApi = pathApiForPlatform(comparisonPlatform);
+  if (!pathApi.isAbsolute(trimmedCandidatePath) || !pathApi.isAbsolute(trimmedProjectRoot)) {
+    return false;
+  }
+
+  const realpathMatch = realpathMatchesOnDarwin(trimmedCandidatePath, trimmedProjectRoot, comparisonPlatform);
+  if (realpathMatch !== null) {
+    return realpathMatch;
+  }
+
+  return normalizeForCommandSearch(trimmedCandidatePath, comparisonPlatform) === normalizeForCommandSearch(trimmedProjectRoot, comparisonPlatform);
+}
+
+export function parseCommandLineArguments(commandLine: string): string[] {
+  const args: string[] = [];
+  let current = "";
+  let quote: "\"" | "'" | null = null;
+  let tokenStarted = false;
+
+  const pushCurrent = (): void => {
+    if (tokenStarted) {
+      args.push(current);
+      current = "";
+      tokenStarted = false;
+    }
+  };
+
+  for (const character of commandLine) {
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+      } else {
+        current += character;
+      }
+      continue;
+    }
+
+    if (character === "\"" || character === "'") {
+      quote = character;
+      tokenStarted = true;
+    } else if (/\s/.test(character)) {
+      pushCurrent();
+    } else {
+      current += character;
+      tokenStarted = true;
+    }
+  }
+
+  pushCurrent();
+  return args;
+}
+
+export function extractUnityProjectPathArguments(commandLine: string): string[] {
+  const values: string[] = [];
+  const flagPattern = /(?:^|\s)-projectpath(?=\s|=)/gi;
+  let match: RegExpExecArray | null;
+
+  while ((match = flagPattern.exec(commandLine)) !== null) {
+    let index = flagPattern.lastIndex;
+    while (/\s/.test(commandLine[index] ?? "")) index += 1;
+    if (commandLine[index] === "=") {
+      index += 1;
+      while (/\s/.test(commandLine[index] ?? "")) index += 1;
+    }
+
+    const quote = commandLine[index] === "\"" || commandLine[index] === "'" ? commandLine[index] : null;
+    if (quote) {
+      const end = commandLine.indexOf(quote, index + 1);
+      if (end >= 0) {
+        values.push(commandLine.slice(index + 1, end));
+        flagPattern.lastIndex = end + 1;
+      }
+      continue;
+    }
+
+    const remainder = commandLine.slice(index);
+    const nextFlag = remainder.search(/\s+-[A-Za-z][A-Za-z0-9-]*(?=\s|=|$)/);
+    const value = (nextFlag >= 0 ? remainder.slice(0, nextFlag) : remainder).trim();
+    if (value) values.push(value);
+  }
+
+  return values;
+}
+
+export function commandTargetsProject(commandLine: string, projectRoot: string, platform: SupportedPlatform = process.platform): boolean {
+  return extractUnityProjectPathArguments(commandLine)
+    .some((candidatePath) => projectPathsMatch(candidatePath, projectRoot, platform));
+}

package/src/unity-file-discovery-filter.ts

@@ -0,0 +1,89 @@
+import { access, readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import * as path from "node:path";
+import type {
+  FileDiscoveryExecutionContextV1,
+  FileDiscoveryFilterRequestV1,
+  FileDiscoveryFilterResultV1,
+  FileDiscoveryFilterV1,
+} from "@aefree/pi-file-discovery/contracts/v1";
+
+export const UNITY_FILE_DISCOVERY_FILTER_ID_V1 = "unity.generated-directories-filter.v1" as const;
+export const UNITY_BROAD_GENERATED_DIRECTORIES_APPLIED_CODE = "unity_broad_generated_directories_applied" as const;
+export const UNITY_EXACT_GENERATED_ROOT_BYPASSED_CODE = "unity_exact_generated_root_bypassed" as const;
+export const UNITY_GENERATED_DIRECTORIES = Object.freeze(["Library", "Temp", "Logs", "obj", "Build", "Builds", "UserSettings", ".vs"] as const);
+
+export function createUnityFileDiscoveryFilterV1(): FileDiscoveryFilterV1 {
+  return Object.freeze({
+    contractVersion: 1,
+    id: UNITY_FILE_DISCOVERY_FILTER_ID_V1,
+    kind: "file-discovery-filter",
+    owner: Object.freeze({ packageName: "@aefree/pi-unity", packageVersion: "0.8.3", packageRoot: path.resolve(fileURLToPath(new URL("..", import.meta.url))), registeredBy: "index.ts" }),
+    async evaluate(context, request) { return await evaluateUnityFileDiscoveryFilterV1(context, request); },
+  });
+}
+
+export async function evaluateUnityFileDiscoveryFilterV1(
+  context: FileDiscoveryExecutionContextV1,
+  request: FileDiscoveryFilterRequestV1,
+): Promise<FileDiscoveryFilterResultV1> {
+  if (context.signal !== request.signal) return { outcome: "error", code: "unity_signal_mismatch", retryable: false };
+  if (request.signal.aborted) return { outcome: "unavailable", code: "aborted", retryable: true };
+  const unityRoots = await discoverUnityRoots(request.workspaceRoot, request.roots, request.signal);
+  if (unityRoots.length === 0) return { outcome: "not_applicable" };
+  const roots = request.roots.map((searchRoot) => {
+    const absoluteSearchRoot = path.resolve(request.workspaceRoot, searchRoot);
+    const globs = new Set<string>();
+    let generatedRoot = false;
+    for (const unityRoot of unityRoots) {
+      if (isInside(unityRoot, absoluteSearchRoot)) {
+        const first = path.relative(unityRoot, absoluteSearchRoot).split(path.sep).filter(Boolean)[0];
+        if (first && UNITY_GENERATED_DIRECTORIES.some((entry) => entry.toLowerCase() === first.toLowerCase())) generatedRoot = true;
+      }
+      if (!isInside(absoluteSearchRoot, unityRoot)) continue;
+      const prefix = normalize(path.relative(absoluteSearchRoot, unityRoot));
+      for (const directory of UNITY_GENERATED_DIRECTORIES) globs.add(`!${prefix ? `${prefix}/` : ""}${directory}/**`);
+    }
+    // An exact root inside a generated directory is deliberate research intent.
+    return Object.freeze({
+      root: searchRoot,
+      filterDecision: generatedRoot ? "bypassed" : "applied",
+      decisionCode: generatedRoot ? UNITY_EXACT_GENERATED_ROOT_BYPASSED_CODE : UNITY_BROAD_GENERATED_DIRECTORIES_APPLIED_CODE,
+      ...(generatedRoot ? {} : { excludeGlobs: Object.freeze([...globs].sort()) }),
+      disclosures: Object.freeze([generatedRoot
+        ? "Unity generated/cache/output root filter bypassed for the explicit root; it is searched."
+        : "Unity broad-root generated-directory filter applied; excludes Library, Temp, Logs, obj, Build, Builds, UserSettings, .vs."]),
+    });
+  });
+  return Object.freeze({ outcome: "applied", roots: Object.freeze(roots) });
+}
+
+async function discoverUnityRoots(workspaceRoot: string, searchRoots: readonly string[], signal: AbortSignal): Promise<string[]> {
+  const workspace = path.resolve(workspaceRoot);
+  const found = new Set<string>();
+  for (const rawRoot of searchRoots) {
+    if (signal.aborted) return [];
+    const root = path.resolve(workspace, rawRoot);
+    for (let current = root; isInside(workspace, current); current = path.dirname(current)) {
+      if (await isUnityProject(current)) { found.add(current); break; }
+      if (current === workspace) break;
+    }
+    if (!isInside(workspace, root)) continue;
+    await discoverBelow(root, found, signal, 0);
+  }
+  return [...found].sort((left, right) => normalize(left).localeCompare(normalize(right)));
+}
+async function discoverBelow(root: string, found: Set<string>, signal: AbortSignal, depth: number): Promise<void> {
+  if (depth > 8 || signal.aborted || found.size >= 64) return;
+  if (await isUnityProject(root)) { found.add(root); return; }
+  let entries;
+  try { entries = await readdir(root, { withFileTypes: true }); } catch { return; }
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (signal.aborted || found.size >= 64) return;
+    if (!entry.isDirectory() || entry.isSymbolicLink() || UNITY_GENERATED_DIRECTORIES.some((name) => name.toLowerCase() === entry.name.toLowerCase()) || entry.name === ".git" || entry.name === "node_modules") continue;
+    await discoverBelow(path.join(root, entry.name), found, signal, depth + 1);
+  }
+}
+async function isUnityProject(root: string): Promise<boolean> { try { await access(path.join(root, "ProjectSettings", "ProjectVersion.txt")); await access(path.join(root, "Assets")); return true; } catch { return false; } }
+function normalize(value: string): string { return value.replaceAll("\\", "/"); }
+function isInside(parent: string, child: string): boolean { const relative = path.relative(path.resolve(parent), path.resolve(child)); return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)); }