@niroai/niro 0.12.0 → 0.15.0

package/src/commands/upgrade.js

@@ -0,0 +1,400 @@
+/**
+ * `niro upgrade` — replace this install with the latest published package, then put back the
+ * things replacing the package cannot put back for itself.
+ *
+ * Why this runs as two processes.
+ *
+ * Every command in this CLI is loaded lazily, inside its own action handler (src/index.js), and
+ * `npm install -g` replaces the folder those files are loaded from. A single process that ran npm
+ * and then carried on would be running the modules it loaded before the swap alongside modules
+ * loaded after it. Nothing tests that mixture. start.js has always avoided the same trap the same
+ * way: bootstrapIfNpx installs globally only when it is running from the npx cache, so it never
+ * overwrites the tree it is executing, and then it hands over.
+ *
+ *   phase one, this copy       run npm, then exec the NEW global binary with --finish and stop.
+ *   phase two, the new copy    a fresh process reading the new tree: restart the watcher, refresh
+ *                              each configured client's hooks and skills, ask for an assistant
+ *                              restart.
+ *
+ * Phase one requires nothing between the npm call and the hand-over, and it also catches its own
+ * errors rather than letting them reach src/index.js `run()`, whose catch does
+ * `require("./lib/printError")` — a lazy load out of the folder npm has just replaced. That is the
+ * one path where the swap could still bite, so it is closed here rather than described.
+ *
+ * What it deliberately does not do is write a settings file itself. Refreshing hooks means
+ * spawning the existing installer, once per client. A second write path into
+ * ~/.claude/settings.json was built once, reviewed three times and reverted on 2026-07-30
+ * (d3ff3d8) after it was found deleting users' own hooks, changing that file from mode 0600 to
+ * 0644 while it can hold API keys, and, with HOME unset, writing into a project's git-tracked
+ * .claude/settings.json. The installer already gets those cases right, and here it runs because
+ * the user asked for it.
+ */
+const childProcess = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const color = require("../lib/color");
+const service = require("../lib/service");
+const mcpClients = require("../lib/mcpClients");
+const mcpCmd = require("./mcp");
+const startCmd = require("./start");
+
+const PACKAGE_NAME = "@niroai/niro";
+const VERSION = require("../../package.json").version;
+
+/**
+ * Set on the process phase one hands over to. If phase one ever sees it already set, it is itself
+ * a hand-over child that failed to reach phase two, which means the newly installed version does
+ * not understand `--finish`. Without this, that version would run npm and hand over again, without
+ * bound. start.js guards its own hand-over with BOOTSTRAP_ENV for the same reason.
+ */
+const HANDOVER_ENV = "NIRO_UPGRADE_HANDOVER";
+
+/** Exit codes, so a script can tell the failures apart. */
+const EXIT_NPM_FAILED = 1;
+const EXIT_NO_BINARY = 2;
+const EXIT_HANDOVER_FAILED = 3;
+const EXIT_REFRESH_INCOMPLETE = 4;
+const EXIT_WRONG_COPY = 5;
+
+/** `niro upgrade` (phase one) and `niro upgrade --finish` (phase two). */
+async function upgrade(opts = {}) {
+  if (opts.finish) return finish(opts.from);
+  return replaceAndHandOver(Boolean(opts.force));
+}
+
+/**
+ * Phase one. Replace the package, then hand over to the copy that replaced it.
+ *
+ * Everything this function touches is already loaded by the requires at the top of this file, and
+ * every failure is reported here rather than thrown, because a throw would reach a catch that
+ * lazily loads a module out of the folder npm has just swapped.
+ */
+function replaceAndHandOver(force) {
+  if (process.env[HANDOVER_ENV]) {
+    console.error(color.red("\n  The version just installed does not support `niro upgrade --finish`."));
+    console.error("    The package itself is upgraded. Your hooks, skills and watcher are not.");
+    console.error(`    Finish by hand: ${color.cyan("niro mcp install")} for each assistant you use,`);
+    console.error(`    then ${color.cyan("niro service install")} if you run the background watcher.\n`);
+    process.exitCode = EXIT_HANDOVER_FAILED;
+    return;
+  }
+
+  const running = describeRunningCopy();
+  if (running.kind === "linked" && !force) {
+    console.error(color.yellow("\n  Not upgrading: niro is npm-linked to a working copy."));
+    console.error(`    ${color.cyan("npm prefix -g")} says the global package folder is a link:`);
+    console.error(`      ${running.pkgDir}`);
+    console.error(`      -> ${running.linkTarget}`);
+    console.error("    `npm install -g` would replace that link with the published package, and");
+    console.error("    `niro` would stop running your checkout. Your files would be untouched, but");
+    console.error(`    you would have to run ${color.cyan("npm link")} in the checkout to get it back.`);
+    console.error(`    Upgrade anyway with ${color.cyan("niro upgrade --force")}.\n`);
+    process.exitCode = EXIT_WRONG_COPY;
+    return;
+  }
+  if (running.kind === "elsewhere" && !force) {
+    console.error(color.yellow("\n  Not upgrading: you are not running the globally installed niro."));
+    console.error(`    running:  ${running.self || "unknown"}`);
+    console.error(`    would upgrade: ${running.pkgDir || "the npm global folder"}`);
+    console.error("    Those are different copies, so this would replace one you are not using and");
+    console.error("    leave the one you are.");
+    console.error(`    Upgrade the global copy anyway with ${color.cyan("niro upgrade --force")}.\n`);
+    process.exitCode = EXIT_WRONG_COPY;
+    return;
+  }
+
+  console.log(`\n  Upgrading niro. Installed now: ${VERSION}\n`);
+
+  const installed = childProcess.spawnSync("npm", ["install", "-g", `${PACKAGE_NAME}@latest`], {
+    shell: true,
+    stdio: "inherit",
+  });
+
+  if (installed.signal) {
+    // Ctrl+C reaches the whole process group, so npm dies with this process. Whether it left the
+    // global folder half-written is npm's business and not something this can know, so it is not
+    // claimed either way.
+    console.error(color.yellow(`\n  Interrupted (${installed.signal}) while npm was running.`));
+    console.error("    Whether the package was replaced is unknown. Check with `niro --version`,");
+    console.error(`    then run ${color.cyan("niro upgrade")} again.\n`);
+    process.exitCode = EXIT_NPM_FAILED;
+    return;
+  }
+
+  if (installed.status !== 0) {
+    console.error(color.red("\n  npm could not replace the package."));
+    console.error("    The usual cause is that your npm global folder needs root. Find it with");
+    console.error(`    ${color.cyan("npm prefix -g")}, then either fix its ownership or re-run the install`);
+    console.error("    with the privileges it needs:");
+    console.error(`      ${color.cyan(`npm install -g ${PACKAGE_NAME}@latest`)}`);
+    console.error(`    Then run ${color.cyan("niro upgrade --finish")} to refresh your assistant files.\n`);
+    process.exitCode = EXIT_NPM_FAILED;
+    return;
+  }
+
+  const bin = startCmd.globalNiroPath();
+  if (!bin) {
+    console.error(color.red("\n  npm reported success, but there is no niro in your npm global folder."));
+    console.error(`    Check ${color.cyan("npm prefix -g")} and that its bin folder is on your PATH.`);
+    console.error("    The package is upgraded; only the refresh step was skipped. Run it with");
+    console.error(`    ${color.cyan("niro upgrade --finish")} once niro is back on PATH.\n`);
+    process.exitCode = EXIT_NO_BINARY;
+    return;
+  }
+
+  if (!supportsFinish(bin)) {
+    // The version just installed has no `upgrade` command, which is what happens when the newest
+    // published version predates this one. Saying "re-run niro upgrade --finish" here would send
+    // the user to a command that cannot exist.
+    console.error(color.yellow("\n  The package is upgraded, but the version now installed has no"));
+    console.error("  `niro upgrade` command, so it cannot refresh your assistant files itself.");
+    console.error("    Finish by hand:");
+    console.error(`      ${color.cyan("niro mcp install")}       once per assistant you use`);
+    console.error(`      ${color.cyan("niro service install")}   if you run the background watcher`);
+    console.error("    Then restart your assistant.\n");
+    process.exitCode = EXIT_HANDOVER_FAILED;
+    return;
+  }
+
+  // The hand-over. A fresh process reads the new tree cleanly; this one cannot. VERSION comes from
+  // package.json, so it is a semver string and safe on a Windows command line. The Windows branch
+  // is untested: spawning a .cmd shim needs a shell on current Node, and a global prefix
+  // containing spaces is why the path is quoted.
+  const env = { ...process.env, [HANDOVER_ENV]: "1" };
+  const handover = process.platform === "win32"
+    ? childProcess.spawnSync(`"${bin}" upgrade --finish --from ${VERSION}`, { stdio: "inherit", shell: true, env })
+    : childProcess.spawnSync(bin, ["upgrade", "--finish", "--from", VERSION], { stdio: "inherit", env });
+
+  if (handover.error) {
+    // spawnSync could not start the child at all: a non-executable bin link, a directory where the
+    // binary should be, a broken shim. Without this the command exits silently.
+    console.error(color.red(`\n  Could not run the upgraded niro at ${bin}:`));
+    console.error(`    ${handover.error.message}`);
+    console.error("    The package is upgraded; your hooks, skills and watcher are not.");
+    console.error(`    Try ${color.cyan("niro upgrade --finish")}, or reinstall with`);
+    console.error(`    ${color.cyan(`npm install -g ${PACKAGE_NAME}@latest`)}.\n`);
+    process.exitCode = EXIT_HANDOVER_FAILED;
+    return;
+  }
+
+  if (handover.signal) {
+    console.error(color.yellow(`\n  Interrupted (${handover.signal}) while refreshing.`));
+    console.error(`    The package is upgraded. Finish with ${color.cyan("niro upgrade --finish")}.\n`);
+    process.exitCode = EXIT_HANDOVER_FAILED;
+    return;
+  }
+
+  if (handover.status !== 0) {
+    console.error(`\n  The upgraded niro exited with ${handover.status} while refreshing.`);
+    console.error(`    The package is upgraded. Re-run ${color.cyan("niro upgrade --finish")} to try again.\n`);
+  }
+  process.exitCode = handover.status === null ? EXIT_HANDOVER_FAILED : handover.status;
+}
+
+/** Where npm would install this package globally. */
+function globalPackageDir() {
+  const r = childProcess.spawnSync("npm", ["prefix", "-g"], { shell: true, encoding: "utf8" });
+  if (r.status !== 0) return null;
+  const prefix = String(r.stdout || "").trim();
+  if (!prefix) return null;
+  return process.platform === "win32"
+    ? path.join(prefix, "node_modules", PACKAGE_NAME.replace("/", path.sep))
+    : path.join(prefix, "lib", "node_modules", PACKAGE_NAME.replace("/", path.sep));
+}
+
+/**
+ * Which copy of niro is running this, checked BEFORE npm is allowed to touch anything.
+ *
+ *   "global"     this process is the globally installed package, so replacing it is the job
+ *   "linked"     the global package folder is a symlink, which is what `npm link` leaves behind.
+ *                `npm install -g` deletes that link and puts the published package in its place,
+ *                so a developer working on niro loses the wiring between `niro` and their checkout.
+ *   "elsewhere"  running from somewhere else entirely: a checkout invoked directly, or the npx
+ *                cache. Upgrading then replaces a copy the user is not running.
+ *
+ * This exists because the first real run of `niro upgrade` was from a linked checkout and silently
+ * replaced it with the published package.
+ */
+function describeRunningCopy(pkgDirOverride) {
+  // The directory is a parameter so a unit test can exercise every branch without shelling out to
+  // npm at all. An end-to-end rehearsal takes the other route and sets npm_config_prefix, which
+  // npm does honour (scripts/rehearse-upgrade.sh).
+  const pkgDir = pkgDirOverride === undefined ? globalPackageDir() : pkgDirOverride;
+
+  let self = null;
+  try {
+    self = fs.realpathSync(process.argv[1]);
+  } catch (err) {
+    self = null;
+  }
+
+  if (pkgDir) {
+    try {
+      if (fs.lstatSync(pkgDir).isSymbolicLink()) {
+        return { kind: "linked", pkgDir, linkTarget: fs.realpathSync(pkgDir), self };
+      }
+    } catch (err) {
+      // Not installed globally at all. Falls through to "elsewhere".
+    }
+  }
+
+  let pkgReal = null;
+  try {
+    pkgReal = pkgDir ? fs.realpathSync(pkgDir) : null;
+  } catch (err) {
+    pkgReal = null;
+  }
+  if (pkgReal && self && (self === pkgReal || self.startsWith(pkgReal + path.sep))) {
+    return { kind: "global", pkgDir, linkTarget: null, self };
+  }
+  return { kind: "elsewhere", pkgDir, linkTarget: null, self };
+}
+
+/**
+ * Does the version now installed actually have `niro upgrade --finish`?
+ *
+ * Asked rather than assumed, because the newest published version can predate this one: a machine
+ * running an unreleased build upgrades "up" to a package with no `upgrade` command at all. Without
+ * this, the hand-over fails with commander's bare `error: unknown command 'upgrade'` and the user
+ * is told to re-run a command that cannot exist.
+ */
+function supportsFinish(bin) {
+  const probe = process.platform === "win32"
+    ? childProcess.spawnSync(`"${bin}" upgrade --help`, { shell: true, encoding: "utf8", stdio: "pipe" })
+    : childProcess.spawnSync(bin, ["upgrade", "--help"], { encoding: "utf8", stdio: "pipe" });
+  if (probe.error || probe.status !== 0) return false;
+  return String(probe.stdout || "").includes("--finish");
+}
+
+/** Phase two, running from the new package: put back what npm could not. */
+async function finish(fromVersion) {
+  console.log(fromVersion && fromVersion !== VERSION
+    ? `\n  niro ${fromVersion} to ${VERSION}\n`
+    : `\n  niro ${VERSION}\n`);
+
+  // The watcher first. It is one command and cannot block, whereas a client refresh can sit on a
+  // prompt for as long as the user is away, and until the restart happens the watcher is running
+  // code from a package that no longer exists on disk.
+  restartWatcher();
+
+  const complete = await refreshAssistantFiles();
+  if (!complete) process.exitCode = EXIT_REFRESH_INCOMPLETE;
+
+  console.log(`  ${color.yellow("One thing left:")} restart your AI assistant.`);
+  console.log("  Hooks and skills are read when it starts, so an assistant that is already open");
+  console.log("  is still using the old ones.\n");
+}
+
+/**
+ * Re-run the installer once per configured client, so their hooks, skills and instruction files
+ * match the package that is now installed. Returns false when anything was skipped or failed, so
+ * the caller can set a non-zero exit code: a script driving this needs to know that half of it
+ * did nothing.
+ *
+ * One client failing does not stop the others. They are separate files owned by separate tools,
+ * and a missing editor CLI is an ordinary reason for one to fail.
+ */
+async function refreshAssistantFiles() {
+  const { home, configured } = mcpClients.configuredClients();
+
+  if (!home) {
+    console.log(`  ${color.yellow("Skipped the assistant files:")} there is no usable home folder.`);
+    console.log("  HOME is unset or empty, so every path would have been read relative to the");
+    console.log("  folder you are standing in, which is not yours to read or write.");
+    console.log(`  Set HOME, then run ${color.cyan("niro upgrade --finish")}.\n`);
+    return false;
+  }
+
+  if (configured.length === 0) {
+    console.log("  No configured assistant found, so there were no hooks or skills to refresh.");
+    console.log(`  Connect one with ${color.cyan("niro mcp install")}.\n`);
+    return true;
+  }
+
+  if (!startCmd.hasCredentials()) {
+    console.log(`  ${color.yellow("Heads up:")} you are not signed in, so each client's installer will ask`);
+    console.log(`  for an API key. ${color.cyan("niro login")} first if you would rather it did not.\n`);
+  }
+
+  // Cursor's installer writes a project-scoped rule to <cwd>/.cursor/rules/niro.mdc, so refreshing
+  // it leaves a file in whatever folder the upgrade was run from. That is the installer's design,
+  // not something to change here, but it is a surprise when you only asked to upgrade.
+  if (configured.some((c) => c.id === "cursor")) {
+    console.log(`  ${color.yellow("Note:")} refreshing Cursor also writes a project rule to`);
+    console.log(`  ${path.join(process.cwd(), ".cursor", "rules", "niro.mdc")}`);
+    console.log("  because Cursor rules are per-folder. Delete it if you did not want it here.\n");
+  }
+
+  const total = configured.length;
+  console.log(`  Refreshing hooks and skills for ${total} client${total === 1 ? "" : "s"}:`);
+  for (const client of configured) {
+    console.log(`    ${client.name}  (${client.where})`);
+  }
+  console.log("");
+
+  let done = 0;
+  let failed = 0;
+  for (const client of configured) {
+    console.log(color.dim(`  [${done + failed + 1} of ${total}] ${client.name}`));
+    try {
+      await mcpCmd.install(["--client", client.id]);
+      done += 1;
+    } catch (err) {
+      failed += 1;
+      console.error(`  ${color.yellow("!")} ${client.name} was not refreshed: ${err.message}`);
+      console.error(`    Run ${color.cyan(`niro mcp install --client ${client.id}`)} to see why.\n`);
+    }
+  }
+
+  if (failed > 0) {
+    console.log(`  ${done} of ${total} refreshed, ${failed} failed.`);
+    console.log(`  Re-run ${color.cyan("niro upgrade --finish")} once the failures above are sorted.\n`);
+    return false;
+  }
+  console.log(`  ${color.green("Done.")} ${done} of ${total} refreshed.\n`);
+  return true;
+}
+
+/**
+ * Restart the background watcher, which is a long-running process still holding the code it loaded
+ * when it started. Replacing files on disk cannot change a process that is already running.
+ */
+function restartWatcher() {
+  if (!service.pm2Available()) {
+    console.log("  Background watcher: PM2 is not installed, so there is nothing to restart.\n");
+    return;
+  }
+
+  const state = service.processState();
+  if (state !== "online") {
+    const what = state === "stopped" ? "registered but not running" : "not installed";
+    console.log(`  Background watcher: ${what}, so it was left alone.\n`);
+    return;
+  }
+
+  console.log("  Restarting the background watcher, which is still running the old code...");
+  if (service.restart()) {
+    // Deliberately not "now on <version>": pm2 re-execs the script path recorded when the daemon
+    // was installed (service.js records process.argv[1]), which is not necessarily the copy that
+    // was just upgraded. All that is known here is that pm2 restarted it.
+    console.log(`  ${color.green("Done.")} niro-watch restarted. Check it with ${color.cyan("niro service status")}.\n`);
+  } else {
+    console.log(`  ${color.yellow("!")} Could not restart it. Run ${color.cyan("niro service install")}.\n`);
+  }
+}
+
+module.exports = {
+  upgrade,
+  // exported for tests
+  refreshAssistantFiles,
+  restartWatcher,
+  describeRunningCopy,
+  supportsFinish,
+  HANDOVER_ENV,
+  EXIT_NPM_FAILED,
+  EXIT_NO_BINARY,
+  EXIT_HANDOVER_FAILED,
+  EXIT_REFRESH_INCOMPLETE,
+  EXIT_WRONG_COPY,
+};

package/src/commands/watch.js

@@ -878,13 +878,42 @@ function matchesPatterns(relativePath, includePatterns, excludePatterns) {
   return !excludePatterns.some(p => minimatch(relativePath, p));
 }
 
-/** Simple glob matching without a dependency: handles ** and * patterns. */
+// Every character that is special inside a regular expression EXCEPT `*`, which is the
+// only wildcard this glob syntax has. Escaping `.` alone was the defect, because a pattern
+// is not ours to choose: the server names a ROOT-LEVEL file by its own filename
+// (ai-orchestrator SourceFileFilterService.derivePatterns, the `else` branch) and the new
+// directory prompt above names a directory by its own path, so a real name reaches this
+// function verbatim. `main.c++` at a repo root became /^main\.c++$/, "Nothing to repeat",
+// and that throw killed EVERY sync pass for the folder: the file event gate, the delta and
+// backstop walk, and the rescue check that runs before a delete. The quieter half of the
+// same defect never threw at all: `app (copy).js` built a valid regex with a capture group,
+// so the file silently stopped matching its own pattern and was never synced again.
+// No /g flag: `test` on a global regex advances lastIndex between calls.
+const REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/;
+
+/**
+ * Simple glob matching without a dependency: handles ** and * patterns.
+ *
+ * One pass over the pattern, so every character that is not a wildcard is escaped as a
+ * literal and the result is always a valid regular expression. The previous version
+ * escaped `.` and then routed `**` through a `§§` placeholder, which also corrupted any
+ * pattern that genuinely contained `§§`.
+ */
 function minimatch(filePath, pattern) {
-  const regexStr = pattern
-    .replace(/\./g, "\\.")
-    .replace(/\*\*/g, "§§")    // temp placeholder
-    .replace(/\*/g, "[^/]*")
-    .replace(/§§/g, ".*");
+  let regexStr = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        regexStr += ".*"; // ** crosses directory separators
+        i++;
+      } else {
+        regexStr += "[^/]*"; // * stays inside one path segment
+      }
+      continue;
+    }
+    regexStr += REGEX_SPECIAL_CHARS.test(ch) ? "\\" + ch : ch;
+  }
   return new RegExp("^" + regexStr + "$").test(filePath);
 }
 
@@ -944,8 +973,11 @@ function buildMinimalManifest(rootDir, includePatterns, excludePatterns) {
 }
 
 // handleFileEvent + deltaSyncOnResume are exported for unit testing the
-// gitignore/fail-closed guards without a live server or fs.watch loop.
+// gitignore/fail-closed guards without a live server or fs.watch loop. matchesPatterns is
+// exported for the same reason: it is the gate all three sync paths share, and a pattern that
+// cannot be compiled stops every one of them, so it is worth testing on its own.
 module.exports = { watch, startWatch, startPeriodicSweep, handleFileEvent, deltaSyncOnResume, handleEntryFailure,
+  matchesPatterns,
   queueDelete, flushPendingDeletes, pendingDeletes, DELETE_SETTLE_MS, backstopTick, notHolding,
   unreadableRoots,
   nextBackoffMs, shouldAttemptBackstop, recordBackstopFailure, recordBackstopSuccess };

package/src/index.js

@@ -309,6 +309,17 @@ function main() {
       await deleteCmd.deleteProject(projectId, { ...opts });
     }));
 
+  program
+    .command("upgrade")
+    .description("Upgrade niro to the latest published version, then refresh the hooks, skills and background watcher that replacing the package leaves untouched.")
+    .option("--finish", "Only refresh hooks, skills and the watcher; do not run npm. `niro upgrade` runs this for you in the new version once the package is replaced.")
+    .option("--from <version>", "The version upgraded from, for the summary line. Set automatically by `niro upgrade`.")
+    .option("--force", "Upgrade the global copy even when you are running a linked or local checkout, which `npm install -g` would replace.")
+    .action((opts) => run(async () => {
+      const upgradeCmd = require("./commands/upgrade");
+      await upgradeCmd.upgrade(opts);
+    }));
+
   const svc = program
     .command("service")
     .description("Manage the niro-watch background daemon (auto-sync on login).");

package/src/lib/folderSync.js

@@ -34,11 +34,25 @@ const prompt = require("./prompt");
 const color = require("./color");
 
 const BATCH_SIZE = 50;
+// MUST stay identical to ai-orchestrator SourceFileFilterService.SOURCE_EXTENSIONS.
+// Both are hand-maintained and nothing enforced that until test/sourceExtensionDrift.test.js
+// here, which reads the Java file, and ai-orchestrator SourceExtensionDriftTest, which reads
+// THIS file. The two repositories build separately, so the guard is on both sides. The
+// server's /filter is the authoritative gate, so an extension missing here is never
+// offered and never uploaded, whatever the server would have accepted.
 const SOURCE_EXTENSIONS = new Set([
   ".java", ".py", ".go", ".js", ".ts", ".tsx", ".jsx",
   ".cjs", ".mjs", ".cts", ".mts",
   ".kt", ".scala", ".rs", ".rb", ".php", ".cs", ".swift",
   ".c", ".cpp", ".h", ".hpp", ".dart",
+  // The remaining C++ extensions ast-parser routes to its C++ grammar and CppMapper.
+  ".cc", ".cxx", ".hxx", ".hh", ".h++", ".c++", ".tcc", ".ipp", ".inl", ".tpp",
+  // Ten more the parser routes to a real mapper and that this list did not offer, so the
+  // user's Kotlin build scripts, C# scripts, Rakefiles, gemspecs, legacy PHP files and
+  // Python stubs were never uploaded. Added 2026-09-14 alongside .jsx.
+  ".kts", ".csx", ".rake", ".gemspec",
+  ".phtml", ".php3", ".php4", ".php5",
+  ".pyi", ".pyw",
 ]);
 
 // Build/config files the server's project-structure resolver needs to detect