vibe-coding-master 0.8.12 → 0.9.0

package/scripts/harness-tools/generate-module-index

@@ -1,521 +1,1056 @@
-#!/usr/bin/env python3
-import argparse
-import fnmatch
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-try:
-    import tomllib
-except ModuleNotFoundError:
-    tomllib = None
-
-
-NODE_SOURCE_EXTENSIONS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
-NODE_EXCLUDED_DIRS = {"node_modules", "dist", "build", "coverage", ".next", ".turbo", ".vite"}
-NODE_DEPENDENCY_TABLES = ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies")
-NODE_TEST_MARKERS = (".test.", ".spec.")
-RUST_EXCLUDED_DIRS = {"target", ".git"}
-
-
-def relative_path(path: Path, root: Path) -> str:
-    try:
-        rel = path.absolute().relative_to(root.absolute())
-    except ValueError:
-        rel = path.resolve().relative_to(root.resolve())
-    return "." if str(rel) == "." else rel.as_posix()
-
-
-def maybe_find_cargo_root(project_root: Path) -> Path | None:
-    if (project_root / "Cargo.toml").is_file():
-        return project_root
-
-    for child in sorted(project_root.iterdir(), key=lambda path: path.name):
-        if child.is_dir() and (child / "Cargo.toml").is_file():
-            return child
-
-    return None
-
-
-def find_cargo_root(project_root: Path) -> Path:
-    cargo_root = maybe_find_cargo_root(project_root)
-    if cargo_root is None:
-        raise SystemExit(f"Could not find Cargo.toml in {project_root} or its direct child directories.")
-    return cargo_root
-
-
-def load_json(path: Path) -> dict:
-    return json.loads(path.read_text())
-
-
-def load_toml(path: Path) -> dict:
-    if tomllib is None:
-        raise SystemExit("Python 3.11+ is required to parse Cargo.toml files.")
-    return tomllib.loads(path.read_text())
-
-
-def load_cargo_metadata(cargo_root: Path) -> dict | None:
-    try:
-        result = subprocess.run(
-            ["cargo", "metadata", "--format-version", "1", "--no-deps"],
-            cwd=cargo_root,
-            check=False,
-            text=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-    except FileNotFoundError:
-        return None
-    if result.returncode != 0:
-        return None
-    return json.loads(result.stdout)
-
-
-def path_is_excluded(relative: str, excludes: list[str]) -> bool:
-    normalized = relative.rstrip("/")
-    for pattern in excludes:
-        normalized_pattern = pattern.rstrip("/")
-        if (
-            normalized == normalized_pattern
-            or normalized.startswith(f"{normalized_pattern}/")
-            or fnmatch.fnmatch(normalized, normalized_pattern)
-        ):
-            return True
-    return False
-
-
-def valid_workspace_member_manifests(cargo_root: Path) -> list[Path]:
-    data = load_toml(cargo_root / "Cargo.toml")
-    workspace = data.get("workspace", {})
-    members = workspace.get("members", [])
-    excludes = workspace.get("exclude", [])
-
-    manifests: list[Path] = []
-    seen: set[Path] = set()
-
-    if data.get("package", {}).get("name"):
-        manifests.append(cargo_root / "Cargo.toml")
-        seen.add(cargo_root / "Cargo.toml")
-
-    for member in members:
-        candidates = sorted(cargo_root.glob(member)) if "*" in member else [cargo_root / member]
-        for candidate in candidates:
-            if not candidate.is_dir():
-                continue
-            member_rel = relative_path(candidate, cargo_root)
-            if path_is_excluded(member_rel, excludes):
-                continue
-            manifest = candidate / "Cargo.toml"
-            if not manifest.is_file() or manifest in seen:
-                continue
-            manifests.append(manifest)
-            seen.add(manifest)
-
-    return manifests
-
-
-def package_name(manifest: Path) -> str | None:
-    package = load_toml(manifest).get("package", {})
-    name = package.get("name")
-    return name if isinstance(name, str) else None
-
-
-def dependency_names_from_table(table: dict) -> set[str]:
-    names: set[str] = set()
-    for name, value in table.items():
-        if isinstance(value, dict):
-            package = value.get("package")
-            names.add(package if isinstance(package, str) else name)
-        else:
-            names.add(name)
-    return names
-
-
-def manifest_dependency_names(manifest: Path) -> set[str]:
-    data = load_toml(manifest)
-    names: set[str] = set()
-    for key in ("dependencies", "dev-dependencies", "build-dependencies"):
-        table = data.get(key, {})
-        if isinstance(table, dict):
-            names.update(dependency_names_from_table(table))
-
-    target = data.get("target", {})
-    if isinstance(target, dict):
-        for target_table in target.values():
-            if not isinstance(target_table, dict):
-                continue
-            for key in ("dependencies", "dev-dependencies", "build-dependencies"):
-                table = target_table.get(key, {})
-                if isinstance(table, dict):
-                    names.update(dependency_names_from_table(table))
-    return names
-
-
-def infer_layer(module_cargo_path: str, cargo_root: Path, project_root: Path) -> tuple[str, str]:
-    if module_cargo_path == ".":
-        return ("root", relative_path(cargo_root, project_root))
-    first = module_cargo_path.split("/", 1)[0]
-    return (first, relative_path(cargo_root / first, project_root))
-
-
-def rust_files_under(module_dir: Path, project_root: Path, child: str) -> list[str]:
-    root = module_dir / child
-    if not root.is_dir():
-        return []
-    return sorted(
-        relative_path(path, project_root)
-        for path in root.rglob("*.rs")
-        if path.is_file()
-        and not any(part in RUST_EXCLUDED_DIRS for part in path.relative_to(module_dir).parts)
-    )
-
-
-def maybe_find_node_root(project_root: Path) -> Path | None:
-    if (project_root / "package.json").is_file():
-        return project_root
-
-    for child in sorted(project_root.iterdir(), key=lambda path: path.name):
-        if child.is_dir() and (child / "package.json").is_file():
-            return child
-
-    return None
-
-
-def workspace_patterns(package_data: dict) -> list[str]:
-    workspaces = package_data.get("workspaces")
-    if isinstance(workspaces, list):
-        return [pattern for pattern in workspaces if isinstance(pattern, str)]
-    if isinstance(workspaces, dict):
-        packages = workspaces.get("packages", [])
-        if isinstance(packages, list):
-            return [pattern for pattern in packages if isinstance(pattern, str)]
-    return []
-
-
-def node_workspace_manifests(node_root: Path) -> list[Path]:
-    root_manifest = node_root / "package.json"
-    root_data = load_json(root_manifest)
-    patterns = workspace_patterns(root_data)
-
-    if not patterns:
-        return [root_manifest]
-
-    manifests: list[Path] = []
-    seen: set[Path] = set()
-
-    for pattern in patterns:
-        if pattern.startswith("!") or pattern.startswith("/") or ".." in Path(pattern).parts:
-            continue
-        for candidate in sorted(node_root.glob(pattern), key=lambda path: path.as_posix()):
-            manifest = candidate / "package.json"
-            if not candidate.is_dir() or not manifest.is_file() or manifest in seen:
-                continue
-            if any(part in NODE_EXCLUDED_DIRS for part in relative_path(candidate, node_root).split("/")):
-                continue
-            manifests.append(manifest)
-            seen.add(manifest)
-
-    if root_data.get("name") and (root_data.get("main") or root_data.get("exports") or (node_root / "src").is_dir()):
-        manifests.insert(0, root_manifest)
-
-    return manifests
-
-
-def node_dependency_names(manifest: Path) -> set[str]:
-    data = load_json(manifest)
-    names: set[str] = set()
-    for table_name in NODE_DEPENDENCY_TABLES:
-        table = data.get(table_name, {})
-        if isinstance(table, dict):
-            names.update(name for name in table.keys() if isinstance(name, str))
-    return names
-
-
-def node_source_files_under(module_dir: Path, project_root: Path) -> tuple[list[str], list[str]]:
-    source_root = module_dir / "src"
-    if not source_root.is_dir():
-        return ([], [])
-
-    source_files: list[str] = []
-    test_files: list[str] = []
-
-    for path in sorted(source_root.rglob("*"), key=lambda item: item.as_posix()):
-        if not path.is_file():
-            continue
-        if path.suffix not in NODE_SOURCE_EXTENSIONS or path.name.endswith(".d.ts"):
-            continue
-        if any(part in NODE_EXCLUDED_DIRS for part in path.relative_to(module_dir).parts):
-            continue
-
-        rel = relative_path(path, project_root)
-        if any(marker in path.name for marker in NODE_TEST_MARKERS):
-            test_files.append(rel)
-        else:
-            source_files.append(rel)
-
-    tests_root = module_dir / "tests"
-    if tests_root.is_dir():
-        for path in sorted(tests_root.rglob("*"), key=lambda item: item.as_posix()):
-            if (
-                path.is_file()
-                and path.suffix in NODE_SOURCE_EXTENSIONS
-                and not path.name.endswith(".d.ts")
-                and not any(part in NODE_EXCLUDED_DIRS for part in path.relative_to(module_dir).parts)
-            ):
-                test_files.append(relative_path(path, project_root))
-
-    return (source_files, sorted(set(test_files)))
-
-
-def infer_node_layer(module_path: str, node_root: Path, project_root: Path) -> tuple[str, str]:
-    node_root_rel = relative_path(node_root, project_root)
-    if module_path == node_root_rel:
-        return ("root", node_root_rel)
-
-    relative_to_node_root = relative_path(project_root / module_path, node_root)
-    first = relative_to_node_root.split("/", 1)[0]
-    return (first, relative_path(node_root / first, project_root))
-
-
-def node_package_records(node_root: Path) -> list[dict]:
-    manifests = node_workspace_manifests(node_root)
-    records: list[dict] = []
-    names_by_manifest: dict[Path, str] = {}
-
-    for manifest in manifests:
-        data = load_json(manifest)
-        name = data.get("name")
-        if isinstance(name, str) and name:
-            names_by_manifest[manifest] = name
-
-    workspace_names = set(names_by_manifest.values())
-
-    for manifest, name in names_by_manifest.items():
-        dependency_names = node_dependency_names(manifest) & workspace_names
-        records.append(
-            {
-                "name": name,
-                "manifest": manifest,
-                "workspaceDependencies": sorted(dependency_names),
-            }
-        )
-
-    return records
-
-
-def build_node_index(project_root: Path, node_root: Path) -> dict:
-    records = node_package_records(node_root)
-    has_workspaces = bool(workspace_patterns(load_json(node_root / "package.json")))
-    layers: list[dict] = []
-    layer_by_name: dict[str, dict] = {}
-
-    for record in records:
-        manifest_path = record["manifest"]
-        module_dir = manifest_path.parent
-        module_path = relative_path(module_dir, project_root)
-        manifest_rel = relative_path(manifest_path, project_root)
-        layer_name, layer_path = infer_node_layer(module_path, node_root, project_root)
-        source_files, test_files = node_source_files_under(module_dir, project_root)
-
-        if layer_name not in layer_by_name:
-            layer = {
-                "name": layer_name,
-                "path": layer_path,
-                "modules": [],
+#!/usr/bin/env node
+"use strict";
+// Generate .ai/generated/module-index.json from Cargo or npm workspace metadata.
+
+const childProcess = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const NODE_SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+const NODE_EXCLUDED_DIRS = new Set(["node_modules", "dist", "build", "coverage", ".next", ".turbo", ".vite"]);
+const NODE_DEPENDENCY_TABLES = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+const NODE_TEST_MARKERS = [".test.", ".spec."];
+const RUST_EXCLUDED_DIRS = new Set(["target", ".git"]);
+const USAGE = "usage: generate-module-index [-h] [--check] [--print] [--output OUTPUT]";
+
+class ToolExit extends Error {}
+
+function fail(message) {
+  throw new ToolExit(message);
+}
+
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// Python truthiness, so empty lists and objects count as false.
+function truthy(value) {
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (isObject(value)) {
+    return Object.keys(value).length > 0;
+  }
+  return Boolean(value);
+}
+
+function compareStrings(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function sortedStrings(values) {
+  return [...values].sort(compareStrings);
+}
+
+function isFile(target) {
+  try {
+    return fs.statSync(target).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDir(target) {
+  try {
+    return fs.statSync(target).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function resolvePath(target) {
+  try {
+    return fs.realpathSync(target);
+  } catch {
+    const parent = path.dirname(target);
+    return parent === target ? target : path.join(resolvePath(parent), path.basename(target));
+  }
+}
+
+function toPosix(relative) {
+  return relative.split(path.sep).join("/");
+}
+
+function isInside(relative) {
+  return relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative);
+}
+
+function relativePath(target, root) {
+  let relative = path.relative(path.resolve(root), path.resolve(target));
+  if (!isInside(relative)) {
+    relative = path.relative(resolvePath(root), resolvePath(target));
+    if (!isInside(relative)) {
+      fail("'" + target + "' is not in the subpath of '" + root + "'");
+    }
+  }
+  return relative === "" ? "." : toPosix(relative);
+}
+
+function pathSuffix(target) {
+  const name = path.basename(target);
+  const index = name.lastIndexOf(".");
+  return index > 0 && index < name.length - 1 ? name.slice(index) : "";
+}
+
+function listDir(directory) {
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function fnmatchSource(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index];
+    if (character === "*") {
+      source += "[\\s\\S]*";
+    } else if (character === "?") {
+      source += "[\\s\\S]";
+    } else if (character === "[") {
+      let end = index + 1;
+      if (pattern[end] === "!") {
+        end += 1;
+      }
+      if (pattern[end] === "]") {
+        end += 1;
+      }
+      while (end < pattern.length && pattern[end] !== "]") {
+        end += 1;
+      }
+      if (end >= pattern.length) {
+        source += "\\[";
+      } else {
+        let body = pattern.slice(index + 1, end).replace(/\\/g, "\\\\");
+        if (body.startsWith("!")) {
+          body = "^" + body.slice(1);
+        } else if (body.startsWith("^")) {
+          body = "\\" + body;
+        }
+        source += "[" + body + "]";
+        index = end;
+      }
+    } else {
+      source += character.replace(/[.*+?^${}()|[\]\\/-]/g, "\\$&");
+    }
+  }
+  return source;
+}
+
+function fnmatch(name, pattern) {
+  return new RegExp("^(?:" + fnmatchSource(pattern) + ")$").test(name);
+}
+
+function hasWildcard(part) {
+  return /[*?[]/.test(part);
+}
+
+// Mirrors pathlib.Path.glob: "**" matches this directory and every
+// non-symlink subdirectory; other parts match one path component.
+function globPaths(base, pattern) {
+  const parts = pattern.split("/").filter((part) => part !== "" && part !== ".");
+  let current = [base];
+  parts.forEach((part, partIndex) => {
+    const last = partIndex === parts.length - 1;
+    const next = [];
+    const seen = new Set();
+    const add = (candidate) => {
+      if (!seen.has(candidate)) {
+        seen.add(candidate);
+        next.push(candidate);
+      }
+    };
+    for (const directory of current) {
+      if (part === "**") {
+        const walk = (dir) => {
+          add(dir);
+          for (const entry of listDir(dir)) {
+            if (entry.isDirectory()) {
+              walk(path.join(dir, entry.name));
             }
-            layer_by_name[layer_name] = layer
-            layers.append(layer)
-
-        module_entry = {
-            "name": record["name"],
-            "path": module_path,
-            "manifest": manifest_rel,
-            "workspaceDependencies": record["workspaceDependencies"],
-            "language": "typescript",
-            "files": {
-                "source": source_files,
-                "tests": test_files,
-            },
+          }
+        };
+        if (isDir(directory)) {
+          walk(directory);
         }
-        if module_path != ".":
-            module_entry["architectureDoc"] = f"{module_path}/ARCHITECTURE.md"
-
-        layer_by_name[layer_name]["modules"].append(module_entry)
+      } else if (hasWildcard(part)) {
+        for (const entry of listDir(directory)) {
+          const candidate = path.join(directory, entry.name);
+          if (fnmatch(entry.name, part) && (last || isDir(candidate))) {
+            add(candidate);
+          }
+        }
+      } else {
+        const candidate = path.join(directory, part);
+        if (last ? fs.existsSync(candidate) : isDir(candidate)) {
+          add(candidate);
+        }
+      }
+    }
+    current = next;
+  });
+  return current;
+}
+
+// Recursive listing that, like Path.rglob, does not descend into symlinked directories.
+function walkFiles(directory) {
+  const results = [];
+  const walk = (dir) => {
+    for (const entry of listDir(dir)) {
+      const candidate = path.join(dir, entry.name);
+      results.push(candidate);
+      if (entry.isDirectory()) {
+        walk(candidate);
+      }
+    }
+  };
+  walk(directory);
+  return results;
+}
+
+function comparePathParts(left, right) {
+  const leftParts = left.split(path.sep);
+  const rightParts = right.split(path.sep);
+  for (let index = 0; index < Math.min(leftParts.length, rightParts.length); index += 1) {
+    const order = compareStrings(leftParts[index], rightParts[index]);
+    if (order !== 0) {
+      return order;
+    }
+  }
+  return leftParts.length - rightParts.length;
+}
+
+// Minimal TOML reader covering the syntax Cargo manifests use.
+function parseToml(text) {
+  const root = {};
+  let current = root;
+  let index = 0;
+
+  const error = (message) => fail("Invalid TOML: " + message + " (offset " + index + ")");
+  const peek = (offset = 0) => text[index + offset];
+  const startsWith = (value) => text.startsWith(value, index);
+
+  function skipInlineSpace() {
+    while (peek() === " " || peek() === "\t") {
+      index += 1;
+    }
+  }
 
-    return {
-        "schemaVersion": 1,
-        "kind": "module-index",
-        "generatedBy": ".ai/tools/generate-module-index",
-        "workspace": {
-            "type": "npm-workspaces" if has_workspaces else "npm-package",
-            "root": relative_path(node_root, project_root),
-            "manifest": relative_path(node_root / "package.json", project_root),
-        },
-        "layerInference": {
-            "method": "path-first-segment-from-workspace-root",
-            "rootPackageLayer": "root",
-        },
-        "layers": layers,
-    }
-
-
-def package_records_from_metadata(project_root: Path, cargo_root: Path, metadata: dict) -> list[dict]:
-    workspace_root = Path(metadata["workspace_root"])
-    workspace_member_ids = set(metadata["workspace_members"])
-    member_order = {member_id: index for index, member_id in enumerate(metadata["workspace_members"])}
-
-    packages = [
-        package
-        for package in metadata["packages"]
-        if package["id"] in workspace_member_ids
-    ]
-    packages.sort(key=lambda package: member_order[package["id"]])
-
-    workspace_names = {package["name"] for package in packages}
-    records = []
-    for package in packages:
-        dependency_names = {
-            dependency["name"]
-            for dependency in package.get("dependencies", [])
-            if dependency.get("name") in workspace_names
+  function skipComment() {
+    if (peek() === "#") {
+      while (index < text.length && peek() !== "\n") {
+        index += 1;
+      }
+    }
+  }
+
+  function skipBlank() {
+    while (index < text.length) {
+      skipInlineSpace();
+      skipComment();
+      if (peek() === "\n" || peek() === "\r") {
+        index += 1;
+      } else {
+        return;
+      }
+    }
+  }
+
+  function parseEscape() {
+    const character = peek();
+    index += 1;
+    const simple = { b: "\b", t: "\t", n: "\n", f: "\f", r: "\r", "\"": "\"", "\\": "\\", e: "\x1b" };
+    if (character in simple) {
+      return simple[character];
+    }
+    if (character === "u" || character === "U") {
+      const length = character === "u" ? 4 : 8;
+      const hex = text.slice(index, index + length);
+      if (!/^[0-9A-Fa-f]+$/.test(hex) || hex.length !== length) {
+        error("invalid unicode escape");
+      }
+      index += length;
+      return String.fromCodePoint(parseInt(hex, 16));
+    }
+    if (character === "x") {
+      const hex = text.slice(index, index + 2);
+      index += 2;
+      return String.fromCharCode(parseInt(hex, 16));
+    }
+    return error("invalid escape");
+  }
+
+  function parseBasicString() {
+    if (startsWith("\"\"\"")) {
+      index += 3;
+      if (peek() === "\r" && peek(1) === "\n") {
+        index += 2;
+      } else if (peek() === "\n") {
+        index += 1;
+      }
+      let value = "";
+      while (index < text.length) {
+        if (startsWith("\"\"\"")) {
+          let quotes = 3;
+          while (quotes < 5 && text[index + quotes] === "\"") {
+            quotes += 1;
+          }
+          value += "\"".repeat(quotes - 3);
+          index += quotes;
+          return value;
         }
-        records.append(
-            {
-                "name": package["name"],
-                "manifest": Path(package["manifest_path"]),
-                "workspaceDependencies": sorted(dependency_names),
-            }
-        )
-    return records
-
-
-def package_records_from_manifests(cargo_root: Path) -> list[dict]:
-    manifests = valid_workspace_member_manifests(cargo_root)
-    names_by_manifest = {
-        manifest: name
-        for manifest in manifests
-        if (name := package_name(manifest)) is not None
-    }
-    workspace_names = set(names_by_manifest.values())
-    records = []
-
-    for manifest, name in names_by_manifest.items():
-        dependency_names = manifest_dependency_names(manifest) & workspace_names
-        records.append(
-            {
-                "name": name,
-                "manifest": manifest,
-                "workspaceDependencies": sorted(dependency_names),
-            }
-        )
-    return records
-
-
-def build_cargo_index(project_root: Path, cargo_root: Path) -> dict:
-    metadata = load_cargo_metadata(cargo_root)
-    records = (
-        package_records_from_metadata(project_root, cargo_root, metadata)
-        if metadata is not None
-        else package_records_from_manifests(cargo_root)
-    )
-
-    layers: list[dict] = []
-    layer_by_name: dict[str, dict] = {}
-
-    for record in records:
-        manifest_path = record["manifest"]
-        module_dir = manifest_path.parent
-        module_path = relative_path(module_dir, project_root)
-        manifest_rel = relative_path(manifest_path, project_root)
-        module_cargo_path = relative_path(module_dir, cargo_root)
-        layer_name, layer_path = infer_layer(module_cargo_path, cargo_root, project_root)
-
-        if layer_name not in layer_by_name:
-            layer = {
-                "name": layer_name,
-                "path": layer_path,
-                "modules": [],
+        if (peek() === "\\") {
+          index += 1;
+          if (/^[ \t]*\r?\n/.test(text.slice(index))) {
+            while (/[ \t\r\n]/.test(peek() || "")) {
+              index += 1;
             }
-            layer_by_name[layer_name] = layer
-            layers.append(layer)
-
-        module_entry = {
-            "name": record["name"],
-            "path": module_path,
-            "manifest": manifest_rel,
-            "workspaceDependencies": record["workspaceDependencies"],
-            "files": {
-                "source": rust_files_under(module_dir, project_root, "src"),
-                "tests": rust_files_under(module_dir, project_root, "tests"),
-            },
+            continue;
+          }
+          value += parseEscape();
+          continue;
+        }
+        value += peek();
+        index += 1;
+      }
+      return error("unterminated string");
+    }
+    index += 1;
+    let value = "";
+    while (index < text.length && peek() !== "\"") {
+      if (peek() === "\n") {
+        error("newline in string");
+      }
+      if (peek() === "\\") {
+        index += 1;
+        value += parseEscape();
+        continue;
+      }
+      value += peek();
+      index += 1;
+    }
+    if (peek() !== "\"") {
+      error("unterminated string");
+    }
+    index += 1;
+    return value;
+  }
+
+  function parseLiteralString() {
+    if (startsWith("'''")) {
+      index += 3;
+      if (peek() === "\r" && peek(1) === "\n") {
+        index += 2;
+      } else if (peek() === "\n") {
+        index += 1;
+      }
+      let end = text.indexOf("'''", index);
+      if (end < 0) {
+        error("unterminated string");
+      }
+      while (text[end + 3] === "'") {
+        end += 1;
+      }
+      const value = text.slice(index, end);
+      index = end + 3;
+      return value;
+    }
+    index += 1;
+    const end = text.indexOf("'", index);
+    if (end < 0 || text.slice(index, end).includes("\n")) {
+      error("unterminated string");
+    }
+    const value = text.slice(index, end);
+    index = end + 1;
+    return value;
+  }
+
+  function parseKeyPart() {
+    if (peek() === "\"") {
+      return parseBasicString();
+    }
+    if (peek() === "'") {
+      return parseLiteralString();
+    }
+    const match = /^[A-Za-z0-9_-]+/.exec(text.slice(index));
+    if (!match) {
+      error("invalid key");
+    }
+    index += match[0].length;
+    return match[0];
+  }
+
+  function parseKey() {
+    const parts = [];
+    while (true) {
+      skipInlineSpace();
+      parts.push(parseKeyPart());
+      skipInlineSpace();
+      if (peek() !== ".") {
+        return parts;
+      }
+      index += 1;
+    }
+  }
+
+  function parseArray() {
+    index += 1;
+    const values = [];
+    while (true) {
+      skipBlank();
+      if (peek() === "]") {
+        index += 1;
+        return values;
+      }
+      values.push(parseValue());
+      skipBlank();
+      if (peek() === ",") {
+        index += 1;
+      } else if (peek() !== "]") {
+        error("expected , or ]");
+      }
+    }
+  }
+
+  function parseInlineTable() {
+    index += 1;
+    const table = {};
+    skipInlineSpace();
+    if (peek() === "}") {
+      index += 1;
+      return table;
+    }
+    while (true) {
+      const key = parseKey();
+      if (peek() !== "=") {
+        error("expected =");
+      }
+      index += 1;
+      skipInlineSpace();
+      assign(table, key, parseValue());
+      skipInlineSpace();
+      if (peek() === ",") {
+        index += 1;
+        continue;
+      }
+      if (peek() === "}") {
+        index += 1;
+        return table;
+      }
+      error("expected , or }");
+    }
+  }
+
+  function parseValue() {
+    const character = peek();
+    if (character === "\"") {
+      return parseBasicString();
+    }
+    if (character === "'") {
+      return parseLiteralString();
+    }
+    if (character === "[") {
+      return parseArray();
+    }
+    if (character === "{") {
+      return parseInlineTable();
+    }
+    const match = /^[^\s,\]}#]+(?: [0-9][^\s,\]}#]*)?/.exec(text.slice(index));
+    if (!match) {
+      error("invalid value");
+    }
+    index += match[0].length;
+    const raw = match[0];
+    if (raw === "true") {
+      return true;
+    }
+    if (raw === "false") {
+      return false;
+    }
+    if (/^[+-]?(?:inf|nan)$/.test(raw)) {
+      return raw.includes("nan") ? NaN : raw.startsWith("-") ? -Infinity : Infinity;
+    }
+    const cleaned = raw.replace(/_/g, "");
+    if (/^[+-]?(?:0x[0-9a-fA-F]+|0o[0-7]+|0b[01]+)$/.test(cleaned)) {
+      const sign = cleaned.startsWith("-") ? -1 : 1;
+      return sign * Number(cleaned.replace(/^[+-]/, ""));
+    }
+    if (/^[+-]?(?:\d+)(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(cleaned)) {
+      return Number(cleaned);
+    }
+    // Dates and times are kept as their source text.
+    return raw;
+  }
+
+  function descend(table, key, forArrayTable) {
+    let target = table;
+    key.forEach((part, partIndex) => {
+      const last = partIndex === key.length - 1;
+      if (last && forArrayTable) {
+        if (!(part in target)) {
+          target[part] = [];
+        }
+        if (!Array.isArray(target[part])) {
+          error("key redefined as array of tables");
         }
-        if module_path != ".":
-            module_entry["architectureDoc"] = f"{module_path}/ARCHITECTURE.md"
+        const entry = {};
+        target[part].push(entry);
+        target = entry;
+        return;
+      }
+      if (!(part in target)) {
+        target[part] = {};
+      }
+      let next = target[part];
+      if (Array.isArray(next)) {
+        next = next[next.length - 1];
+      }
+      if (!isObject(next)) {
+        error("key redefined as table");
+      }
+      target = next;
+    });
+    return target;
+  }
+
+  function assign(table, key, value) {
+    const parent = descend(table, key.slice(0, -1), false);
+    const last = key[key.length - 1];
+    if (last in parent) {
+      error("duplicate key " + key.join("."));
+    }
+    parent[last] = value;
+  }
+
+  while (true) {
+    skipBlank();
+    if (index >= text.length) {
+      return root;
+    }
+    if (startsWith("[[")) {
+      index += 2;
+      const key = parseKey();
+      if (!startsWith("]]")) {
+        error("expected ]]");
+      }
+      index += 2;
+      current = descend(root, key, true);
+    } else if (peek() === "[") {
+      index += 1;
+      const key = parseKey();
+      if (peek() !== "]") {
+        error("expected ]");
+      }
+      index += 1;
+      current = descend(root, key, false);
+    } else {
+      const key = parseKey();
+      if (peek() !== "=") {
+        error("expected =");
+      }
+      index += 1;
+      skipInlineSpace();
+      assign(current, key, parseValue());
+    }
+    skipInlineSpace();
+    skipComment();
+    if (index < text.length && peek() !== "\n" && peek() !== "\r") {
+      error("expected end of line");
+    }
+  }
+}
+
+function maybeFindRoot(projectRoot, manifestName) {
+  if (isFile(path.join(projectRoot, manifestName))) {
+    return projectRoot;
+  }
+  for (const name of sortedStrings(fs.readdirSync(projectRoot))) {
+    const child = path.join(projectRoot, name);
+    if (isDir(child) && isFile(path.join(child, manifestName))) {
+      return child;
+    }
+  }
+  return null;
+}
+
+function loadJson(target) {
+  return JSON.parse(fs.readFileSync(target, "utf8").replace(/\r\n?/g, "\n"));
+}
+
+function loadToml(target) {
+  return parseToml(fs.readFileSync(target, "utf8").replace(/\r\n?/g, "\n"));
+}
+
+function getTable(data, key) {
+  return isObject(data) && key in data ? data[key] : {};
+}
+
+function loadCargoMetadata(cargoRoot) {
+  const result = childProcess.spawnSync("cargo", ["metadata", "--format-version", "1", "--no-deps"], {
+    cwd: cargoRoot,
+    encoding: "utf8",
+    stdio: ["inherit", "pipe", "pipe"],
+    maxBuffer: 1024 * 1024 * 1024
+  });
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+  return JSON.parse(result.stdout);
+}
+
+function pathIsExcluded(relative, excludes) {
+  const normalized = relative.replace(/\/+$/, "");
+  return excludes.some((pattern) => {
+    const normalizedPattern = pattern.replace(/\/+$/, "");
+    return normalized === normalizedPattern
+      || normalized.startsWith(normalizedPattern + "/")
+      || fnmatch(normalized, normalizedPattern);
+  });
+}
+
+function validWorkspaceMemberManifests(cargoRoot) {
+  const data = loadToml(path.join(cargoRoot, "Cargo.toml"));
+  const workspace = getTable(data, "workspace");
+  const members = getTable(workspace, "members");
+  const excludes = isObject(workspace) && "exclude" in workspace ? workspace.exclude : [];
+
+  const manifests = [];
+  const seen = new Set();
+
+  if (truthy(getTable(data, "package").name)) {
+    manifests.push(path.join(cargoRoot, "Cargo.toml"));
+    seen.add(path.join(cargoRoot, "Cargo.toml"));
+  }
+
+  for (const member of Array.isArray(members) ? members : Object.keys(members)) {
+    const candidates = member.includes("*")
+      ? globPaths(cargoRoot, member).sort(comparePathParts)
+      : [path.join(cargoRoot, member)];
+    for (const candidate of candidates) {
+      if (!isDir(candidate)) {
+        continue;
+      }
+      if (pathIsExcluded(relativePath(candidate, cargoRoot), excludes)) {
+        continue;
+      }
+      const manifest = path.join(candidate, "Cargo.toml");
+      if (!isFile(manifest) || seen.has(manifest)) {
+        continue;
+      }
+      manifests.push(manifest);
+      seen.add(manifest);
+    }
+  }
+
+  return manifests;
+}
+
+function packageName(manifest) {
+  const name = getTable(loadToml(manifest), "package").name;
+  return typeof name === "string" ? name : null;
+}
+
+function dependencyNamesFromTable(table) {
+  const names = new Set();
+  for (const [name, value] of Object.entries(table)) {
+    if (isObject(value)) {
+      names.add(typeof value.package === "string" ? value.package : name);
+    } else {
+      names.add(name);
+    }
+  }
+  return names;
+}
+
+function manifestDependencyNames(manifest) {
+  const data = loadToml(manifest);
+  const names = new Set();
+  const addTables = (container) => {
+    for (const key of ["dependencies", "dev-dependencies", "build-dependencies"]) {
+      const table = getTable(container, key);
+      if (isObject(table)) {
+        for (const name of dependencyNamesFromTable(table)) {
+          names.add(name);
+        }
+      }
+    }
+  };
+  addTables(data);
+  const target = getTable(data, "target");
+  if (isObject(target)) {
+    for (const targetTable of Object.values(target)) {
+      if (isObject(targetTable)) {
+        addTables(targetTable);
+      }
+    }
+  }
+  return names;
+}
+
+function inferLayer(moduleCargoPath, cargoRoot, projectRoot) {
+  if (moduleCargoPath === ".") {
+    return ["root", relativePath(cargoRoot, projectRoot)];
+  }
+  const first = moduleCargoPath.split("/")[0];
+  return [first, relativePath(path.join(cargoRoot, first), projectRoot)];
+}
+
+function rustFilesUnder(moduleDir, projectRoot, child) {
+  const root = path.join(moduleDir, child);
+  if (!isDir(root)) {
+    return [];
+  }
+  return sortedStrings(walkFiles(root)
+    .filter((candidate) => candidate.endsWith(".rs") && isFile(candidate))
+    .filter((candidate) => !path.relative(moduleDir, candidate).split(path.sep).some((part) => RUST_EXCLUDED_DIRS.has(part)))
+    .map((candidate) => relativePath(candidate, projectRoot)));
+}
+
+function workspacePatterns(packageData) {
+  const workspaces = packageData.workspaces;
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((pattern) => typeof pattern === "string");
+  }
+  if (isObject(workspaces)) {
+    const packages = "packages" in workspaces ? workspaces.packages : [];
+    if (Array.isArray(packages)) {
+      return packages.filter((pattern) => typeof pattern === "string");
+    }
+  }
+  return [];
+}
 
-        layer_by_name[layer_name]["modules"].append(module_entry)
+function nodeWorkspaceManifests(nodeRoot) {
+  const rootManifest = path.join(nodeRoot, "package.json");
+  const rootData = loadJson(rootManifest);
+  const patterns = workspacePatterns(rootData);
 
+  if (patterns.length === 0) {
+    return [rootManifest];
+  }
+
+  const manifests = [];
+  const seen = new Set();
+
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!") || pattern.startsWith("/") || pattern.split("/").includes("..")) {
+      continue;
+    }
+    const candidates = globPaths(nodeRoot, pattern)
+      .sort((left, right) => compareStrings(toPosix(left), toPosix(right)));
+    for (const candidate of candidates) {
+      const manifest = path.join(candidate, "package.json");
+      if (!isDir(candidate) || !isFile(manifest) || seen.has(manifest)) {
+        continue;
+      }
+      if (relativePath(candidate, nodeRoot).split("/").some((part) => NODE_EXCLUDED_DIRS.has(part))) {
+        continue;
+      }
+      manifests.push(manifest);
+      seen.add(manifest);
+    }
+  }
+
+  if (truthy(rootData.name) && (truthy(rootData.main) || truthy(rootData.exports) || isDir(path.join(nodeRoot, "src")))) {
+    manifests.unshift(rootManifest);
+  }
+
+  return manifests;
+}
+
+function nodeDependencyNames(manifest) {
+  const data = loadJson(manifest);
+  const names = new Set();
+  for (const tableName of NODE_DEPENDENCY_TABLES) {
+    const table = getTable(data, tableName);
+    if (isObject(table)) {
+      for (const name of Object.keys(table)) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
+
+function isNodeSource(candidate) {
+  return NODE_SOURCE_EXTENSIONS.includes(pathSuffix(candidate)) && !path.basename(candidate).endsWith(".d.ts");
+}
+
+function hasExcludedNodePart(moduleDir, candidate) {
+  return path.relative(moduleDir, candidate).split(path.sep).some((part) => NODE_EXCLUDED_DIRS.has(part));
+}
+
+function nodeSourceFilesUnder(moduleDir, projectRoot) {
+  const sourceRoot = path.join(moduleDir, "src");
+  if (!isDir(sourceRoot)) {
+    return [[], []];
+  }
+
+  const sourceFiles = [];
+  const testFiles = [];
+  const byPosix = (left, right) => compareStrings(toPosix(left), toPosix(right));
+
+  for (const candidate of walkFiles(sourceRoot).sort(byPosix)) {
+    if (!isFile(candidate) || !isNodeSource(candidate) || hasExcludedNodePart(moduleDir, candidate)) {
+      continue;
+    }
+    const relative = relativePath(candidate, projectRoot);
+    if (NODE_TEST_MARKERS.some((marker) => path.basename(candidate).includes(marker))) {
+      testFiles.push(relative);
+    } else {
+      sourceFiles.push(relative);
+    }
+  }
+
+  const testsRoot = path.join(moduleDir, "tests");
+  if (isDir(testsRoot)) {
+    for (const candidate of walkFiles(testsRoot).sort(byPosix)) {
+      if (isFile(candidate) && isNodeSource(candidate) && !hasExcludedNodePart(moduleDir, candidate)) {
+        testFiles.push(relativePath(candidate, projectRoot));
+      }
+    }
+  }
+
+  return [sourceFiles, sortedStrings(new Set(testFiles))];
+}
+
+function inferNodeLayer(modulePath, nodeRoot, projectRoot) {
+  const nodeRootRelative = relativePath(nodeRoot, projectRoot);
+  if (modulePath === nodeRootRelative) {
+    return ["root", nodeRootRelative];
+  }
+  const first = relativePath(path.join(projectRoot, modulePath), nodeRoot).split("/")[0];
+  return [first, relativePath(path.join(nodeRoot, first), projectRoot)];
+}
+
+function recordsFromNames(namesByManifest, dependencyNames) {
+  const workspaceNames = new Set(namesByManifest.values());
+  return [...namesByManifest].map(([manifest, name]) => ({
+    name,
+    manifest,
+    workspaceDependencies: sortedStrings([...dependencyNames(manifest)].filter((dependency) => workspaceNames.has(dependency)))
+  }));
+}
+
+function nodePackageRecords(nodeRoot) {
+  const namesByManifest = new Map();
+  for (const manifest of nodeWorkspaceManifests(nodeRoot)) {
+    const name = loadJson(manifest).name;
+    if (typeof name === "string" && name) {
+      namesByManifest.set(manifest, name);
+    }
+  }
+  return recordsFromNames(namesByManifest, nodeDependencyNames);
+}
+
+function buildLayers(records, describe) {
+  const layers = [];
+  const layerByName = new Map();
+  for (const record of records) {
+    const moduleDir = path.dirname(record.manifest);
+    const { layerName, layerPath, moduleEntry } = describe(record, moduleDir);
+    if (!layerByName.has(layerName)) {
+      const layer = { name: layerName, path: layerPath, modules: [] };
+      layerByName.set(layerName, layer);
+      layers.push(layer);
+    }
+    if (moduleEntry.path !== ".") {
+      moduleEntry.architectureDoc = moduleEntry.path + "/ARCHITECTURE.md";
+    }
+    layerByName.get(layerName).modules.push(moduleEntry);
+  }
+  return layers;
+}
+
+function buildNodeIndex(projectRoot, nodeRoot) {
+  const records = nodePackageRecords(nodeRoot);
+  const hasWorkspaces = workspacePatterns(loadJson(path.join(nodeRoot, "package.json"))).length > 0;
+  const layers = buildLayers(records, (record, moduleDir) => {
+    const modulePath = relativePath(moduleDir, projectRoot);
+    const [layerName, layerPath] = inferNodeLayer(modulePath, nodeRoot, projectRoot);
+    const [sourceFiles, testFiles] = nodeSourceFilesUnder(moduleDir, projectRoot);
     return {
-        "schemaVersion": 1,
-        "kind": "module-index",
-        "generatedBy": ".ai/tools/generate-module-index",
-        "workspace": {
-            "root": relative_path(cargo_root, project_root),
-            "manifest": relative_path(cargo_root / "Cargo.toml", project_root),
-        },
-        "layerInference": {
-            "method": "path-first-segment-from-cargo-root",
-            "rootPackageLayer": "root",
-        },
-        "layers": layers,
-    }
-
-
-def build_index(project_root: Path) -> dict:
-    cargo_root = maybe_find_cargo_root(project_root)
-    if cargo_root is not None:
-        return build_cargo_index(project_root, cargo_root)
-
-    node_root = maybe_find_node_root(project_root)
-    if node_root is not None:
-        return build_node_index(project_root, node_root)
-
-    raise SystemExit(
-        f"Could not find Cargo.toml or package.json in {project_root} or its direct child directories."
-    )
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Generate .ai/generated/module-index.json from Cargo or npm workspace metadata.")
-    parser.add_argument("--check", action="store_true", help="Fail if the generated module index differs from the current file.")
-    parser.add_argument("--print", action="store_true", help="Print generated JSON instead of writing it.")
-    parser.add_argument("--output", default=".ai/generated/module-index.json", help="Output path relative to the project root.")
-    args = parser.parse_args()
-
-    root = Path(__file__).resolve().parents[2]
-    generated = json.dumps(build_index(root), indent=2, sort_keys=False) + "\n"
-    output_path = root / args.output
-
-    if args.check:
-        if not output_path.is_file():
-            sys.stderr.write(f"Missing generated module index: {output_path.relative_to(root)}\n")
-            return 1
-        current = output_path.read_text()
-        if current != generated:
-            sys.stderr.write(f"Stale generated module index: {output_path.relative_to(root)}\n")
-            return 1
-        print("generate-module-index check passed")
-        return 0
-
-    if args.print:
-        sys.stdout.write(generated)
-        return 0
-
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    output_path.write_text(generated)
-    print(f"wrote {output_path.relative_to(root)}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
+      layerName,
+      layerPath,
+      moduleEntry: {
+        name: record.name,
+        path: modulePath,
+        manifest: relativePath(record.manifest, projectRoot),
+        workspaceDependencies: record.workspaceDependencies,
+        language: "typescript",
+        files: { source: sourceFiles, tests: testFiles }
+      }
+    };
+  });
+
+  return {
+    schemaVersion: 1,
+    kind: "module-index",
+    generatedBy: ".ai/tools/generate-module-index",
+    workspace: {
+      type: hasWorkspaces ? "npm-workspaces" : "npm-package",
+      root: relativePath(nodeRoot, projectRoot),
+      manifest: relativePath(path.join(nodeRoot, "package.json"), projectRoot)
+    },
+    layerInference: {
+      method: "path-first-segment-from-workspace-root",
+      rootPackageLayer: "root"
+    },
+    layers
+  };
+}
+
+function packageRecordsFromMetadata(metadata) {
+  const memberOrder = new Map(metadata.workspace_members.map((memberId, index) => [memberId, index]));
+  const packages = metadata.packages
+    .filter((pkg) => memberOrder.has(pkg.id))
+    .sort((left, right) => memberOrder.get(left.id) - memberOrder.get(right.id));
+  const workspaceNames = new Set(packages.map((pkg) => pkg.name));
+  return packages.map((pkg) => ({
+    name: pkg.name,
+    manifest: pkg.manifest_path,
+    workspaceDependencies: sortedStrings(new Set((pkg.dependencies || [])
+      .filter((dependency) => workspaceNames.has(dependency.name))
+      .map((dependency) => dependency.name)))
+  }));
+}
+
+function packageRecordsFromManifests(cargoRoot) {
+  const namesByManifest = new Map();
+  for (const manifest of validWorkspaceMemberManifests(cargoRoot)) {
+    const name = packageName(manifest);
+    if (name !== null) {
+      namesByManifest.set(manifest, name);
+    }
+  }
+  return recordsFromNames(namesByManifest, manifestDependencyNames);
+}
+
+function buildCargoIndex(projectRoot, cargoRoot) {
+  const metadata = loadCargoMetadata(cargoRoot);
+  const records = metadata !== null ? packageRecordsFromMetadata(metadata) : packageRecordsFromManifests(cargoRoot);
+  const layers = buildLayers(records, (record, moduleDir) => {
+    const [layerName, layerPath] = inferLayer(relativePath(moduleDir, cargoRoot), cargoRoot, projectRoot);
+    return {
+      layerName,
+      layerPath,
+      moduleEntry: {
+        name: record.name,
+        path: relativePath(moduleDir, projectRoot),
+        manifest: relativePath(record.manifest, projectRoot),
+        workspaceDependencies: record.workspaceDependencies,
+        files: {
+          source: rustFilesUnder(moduleDir, projectRoot, "src"),
+          tests: rustFilesUnder(moduleDir, projectRoot, "tests")
+        }
+      }
+    };
+  });
+
+  return {
+    schemaVersion: 1,
+    kind: "module-index",
+    generatedBy: ".ai/tools/generate-module-index",
+    workspace: {
+      root: relativePath(cargoRoot, projectRoot),
+      manifest: relativePath(path.join(cargoRoot, "Cargo.toml"), projectRoot)
+    },
+    layerInference: {
+      method: "path-first-segment-from-cargo-root",
+      rootPackageLayer: "root"
+    },
+    layers
+  };
+}
+
+function buildIndex(projectRoot) {
+  const cargoRoot = maybeFindRoot(projectRoot, "Cargo.toml");
+  if (cargoRoot !== null) {
+    return buildCargoIndex(projectRoot, cargoRoot);
+  }
+  const nodeRoot = maybeFindRoot(projectRoot, "package.json");
+  if (nodeRoot !== null) {
+    return buildNodeIndex(projectRoot, nodeRoot);
+  }
+  return fail("Could not find Cargo.toml or package.json in " + projectRoot + " or its direct child directories.");
+}
+
+// Matches Python json.dumps(indent=2) with ensure_ascii.
+function toJson(data) {
+  return JSON.stringify(data, null, 2)
+    .replace(/[\u007f-￿]/g, (character) => "\\u" + character.charCodeAt(0).toString(16).padStart(4, "0")) + "\n";
+}
+
+function parseArgs(argv) {
+  const args = { check: false, print: false, output: ".ai/generated/module-index.json" };
+  const usageError = (message) => {
+    process.stderr.write(USAGE + "\ngenerate-module-index: error: " + message + "\n");
+    process.exit(2);
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") {
+      process.stdout.write(USAGE + "\n\nGenerate .ai/generated/module-index.json from Cargo or npm workspace metadata.\n");
+      process.exit(0);
+    } else if (argument === "--check") {
+      args.check = true;
+    } else if (argument === "--print") {
+      args.print = true;
+    } else if (argument === "--output" || argument.startsWith("--output=")) {
+      if (argument === "--output") {
+        if (index + 1 >= argv.length) {
+          usageError("argument --output: expected one argument");
+        }
+        index += 1;
+        args.output = argv[index];
+      } else {
+        args.output = argument.slice("--output=".length);
+      }
+    } else {
+      usageError("unrecognized arguments: " + argv.slice(index).join(" "));
+    }
+  }
+  return args;
+}
+
+function main(argv) {
+  const args = parseArgs(argv);
+  const root = path.resolve(path.dirname(fs.realpathSync(__filename)), "..", "..");
+  const generated = toJson(buildIndex(root));
+  const outputPath = path.join(root, args.output);
+  const displayPath = toPosix(path.relative(root, outputPath));
+
+  if (args.check) {
+    if (!isFile(outputPath)) {
+      process.stderr.write("Missing generated module index: " + displayPath + "\n");
+      return 1;
+    }
+    if (fs.readFileSync(outputPath, "utf8").replace(/\r\n?/g, "\n") !== generated) {
+      process.stderr.write("Stale generated module index: " + displayPath + "\n");
+      return 1;
+    }
+    process.stdout.write("generate-module-index check passed\n");
+    return 0;
+  }
+
+  if (args.print) {
+    process.stdout.write(generated);
+    return 0;
+  }
+
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, generated);
+  process.stdout.write("wrote " + displayPath + "\n");
+  return 0;
+}
+
+try {
+  process.exitCode = main(process.argv.slice(2));
+} catch (error) {
+  if (!(error instanceof ToolExit)) {
+    throw error;
+  }
+  process.stderr.write(error.message + "\n");
+  process.exitCode = 1;
+}