@tinacms/cli 2.2.5 → 2.3.0

package/README.md

@@ -32,11 +32,31 @@ Commands:
   schema:types [options]    Generate a GraphQL query for your site's schema, (and optionally Typescript types)
   init [options]            Add TinaCloud to an existing project
   audit [options]           Audit your schema and the files to check for errors
+  doctor [options]          Check direct TinaCMS dependencies against npm latest
   help [command]            display help for command
 ```
 
 [See our docs](https://tina.io/docs/cli-overview/) for more information about the commands.
 
+### `doctor`
+
+Use `tinacms doctor` to check whether the Tina packages installed in your
+project are current against the npm `latest` dist-tag.
+
+The command reads your `package.json`, resolves installed versions from
+`node_modules` or the project lockfile, filters to Tina package names
+(`tinacms`, `@tinacms/*`, `tinacms-*`, `next-tinacms-*`, and
+`create-tina-app`), then prints the installed version next to the latest
+published version.
+
+```bash
+pnpm tinacms doctor
+```
+
+Use `--json` for machine-readable output. The command exits with code `1` if a
+Tina package is outdated or if a package version cannot be checked, which makes
+it suitable for CI.
+
 ## Getting started
 
 The simplest way to get started is to add a `.tina/schema.ts` file

package/dist/index.js

@@ -2,11 +2,12 @@
 import { Cli, Builtins } from "clipanion";
 
 // package.json
-var version = "2.2.5";
+var version = "2.3.0";
 
 // src/next/commands/dev-command/index.ts
 import path9 from "path";
 import { FilesystemBridge as FilesystemBridge2, buildSchema } from "@tinacms/graphql";
+import { Telemetry } from "@tinacms/metrics";
 import { LocalSearchIndexClient, SearchIndexer } from "@tinacms/search";
 import AsyncLock from "async-lock";
 import chokidar from "chokidar";
@@ -511,14 +512,6 @@ var Codegen = class {
     );
     await fs.ensureFile(filePath);
     await fs.outputFile(filePath, data);
-    if (this.configManager.hasSeparateContentRoot()) {
-      const filePath2 = path.join(
-        this.configManager.generatedFolderPathContentRepo,
-        fileName
-      );
-      await fs.ensureFile(filePath2);
-      await fs.outputFile(filePath2, data);
-    }
   }
   async removeGeneratedFilesIfExists() {
     await unlinkIfExists(this.configManager.generatedClientJSFilePath);
@@ -691,7 +684,7 @@ var Codegen = class {
 import { resolve } from "@tinacms/datalayer";
 import type { TinaClient } from "tinacms/dist/client";
 
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types" : "./types.js"}";
 import database from "../database";
 
 export async function databaseRequest({ query, variables, user }) {
@@ -757,7 +750,7 @@ export default databaseClient;
     const errorPolicy = this.configManager.config?.client?.errorPolicy;
     const apiURL = this.getApiURL();
     const clientString = `import { createClient } from "tinacms/dist/client";
-import { queries } from "./types";
+import { queries } from "${this.configManager.isUsingTs() ? "./types" : "./types.js"}";
 export const client = createClient({ ${this.noClientBuildCache === false ? `cacheDir: '${normalizePath(
       this.configManager.generatedCachePath
     )}', ` : ""}url: ${this.localContentBuild ? `process.env.TINA_LOCAL_URL || '${apiURL}'` : `'${apiURL}'`}, token: '${token}', queries, ${errorPolicy ? `errorPolicy: '${errorPolicy}'` : ""} });
@@ -826,7 +819,6 @@ import { pathToFileURL } from "url";
 import * as esbuild from "esbuild";
 import * as dotenv from "dotenv";
 import normalizePath2 from "normalize-path";
-import chalk4 from "chalk";
 import { createRequire } from "module";
 
 // src/next/resolve-content-root.ts
@@ -894,13 +886,13 @@ var ConfigManager = class {
   rootPath;
   tinaFolderPath;
   isUsingLegacyFolder;
+  hasWarnedLegacyFolder = false;
   tinaConfigFilePath;
   tinaSpaPackagePath;
   contentRootPath;
   envFilePath;
   generatedCachePath;
   generatedFolderPath;
-  generatedFolderPathContentRepo;
   generatedGraphQLGQLPath;
   generatedGraphQLJSONPath;
   generatedSchemaJSONPath;
@@ -957,6 +949,14 @@ var ConfigManager = class {
   async processConfig() {
     const require2 = createRequire(import.meta.url);
     this.tinaFolderPath = await this.getTinaFolderPath(this.rootPath);
+    if (this.isUsingLegacyFolder && !this.hasWarnedLegacyFolder) {
+      this.hasWarnedLegacyFolder = true;
+      logger.warn(
+        warnText(
+          "WARN: Detected legacy `.tina/` config folder. `tina-lock.json` is only generated for the new `tina/` layout, and TinaCloud requires it to index your schema. Migrate by renaming `.tina/` to `tina/` (the contents stay the same). See https://tina.io/docs/tina-folder/overview/."
+        )
+      );
+    }
     this.envFilePath = path4.resolve(
       path4.join(this.tinaFolderPath, "..", ".env")
     );
@@ -1078,16 +1078,10 @@ var ConfigManager = class {
       tinaConfigFilePath: this.tinaConfigFilePath,
       localContentPath: this.config.localContentPath
     });
-    this.generatedFolderPathContentRepo = path4.join(
-      await this.getTinaFolderPath(this.contentRootPath, {
-        isContentRoot: this.hasSeparateContentRoot()
-      }),
-      GENERATED_FOLDER
-    );
     this.spaMainPath = require2.resolve("@tinacms/app");
     this.spaRootPath = path4.join(this.spaMainPath, "..", "..");
   }
-  async getTinaFolderPath(rootPath, { isContentRoot } = {}) {
+  async getTinaFolderPath(rootPath) {
     const tinaFolderPath = path4.join(rootPath, TINA_FOLDER);
     const tinaFolderExists = await fs3.pathExists(tinaFolderPath);
     if (tinaFolderExists) {
@@ -1100,11 +1094,6 @@ var ConfigManager = class {
       this.isUsingLegacyFolder = true;
       return legacyFolderPath;
     }
-    if (isContentRoot) {
-      throw new Error(
-        `Unable to find a ${chalk4.cyan("tina/")} folder in your content root at ${chalk4.cyan(rootPath)}. When using localContentPath, the content directory must contain a ${chalk4.cyan("tina/")} folder for generated files. Create one with: mkdir ${path4.join(rootPath, TINA_FOLDER)}`
-      );
-    }
     throw new Error(
       `Unable to find Tina folder, if you're working in folder outside of the Tina config be sure to specify --rootPath`
     );
@@ -1129,28 +1118,41 @@ var ConfigManager = class {
   }
   printGeneratedClientFilePath() {
     if (this.isUsingTs()) {
-      return this.generatedClientTSFilePath.replace(`${this.rootPath}/`, "");
+      return normalizePath2(
+        path4.relative(this.rootPath, this.generatedClientTSFilePath)
+      );
     }
-    return this.generatedClientJSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedClientJSFilePath)
+    );
   }
   printGeneratedTypesFilePath() {
-    return this.generatedTypesTSFilePath.replace(`${this.rootPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.rootPath, this.generatedTypesTSFilePath)
+    );
   }
   printoutputHTMLFilePath() {
-    return this.outputHTMLFilePath.replace(`${this.publicFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(this.publicFolderPath, this.outputHTMLFilePath)
+    );
   }
   printRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.rootPath}/`, "");
+      return normalizePath2(path4.relative(this.rootPath, filename));
     }
     throw `No path provided to print`;
   }
   printPrebuildFilePath() {
-    return this.prebuildFilePath.replace(/\\/g, "/").replace(`${this.rootPath}/${this.tinaFolderPath}/`, "");
+    return normalizePath2(
+      path4.relative(
+        path4.join(this.rootPath, this.tinaFolderPath),
+        this.prebuildFilePath
+      )
+    );
   }
   printContentRelativePath(filename) {
     if (filename) {
-      return filename.replace(/\\/g, "/").replace(`${this.contentRootPath}/`, "");
+      return normalizePath2(path4.relative(this.contentRootPath, filename));
     }
     throw `No path provided to print`;
   }
@@ -1351,7 +1353,7 @@ async function createAndInitializeDatabase(configManager, datalayerPort, bridgeO
 
 // src/next/commands/baseCommands.ts
 import { Command, Option } from "clipanion";
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 
 // src/utils/start-subprocess.ts
 import childProcess from "child_process";
@@ -1419,7 +1421,7 @@ var BaseCommand = class extends Command {
     if (this.subCommand) {
       subProc = await startSubprocess2({ command: this.subCommand });
       logger.info(
-        `Running web application with command: ${chalk5.cyan(this.subCommand)}`
+        `Running web application with command: ${chalk4.cyan(this.subCommand)}`
       );
     }
     function exitHandler(options, exitCode) {
@@ -1499,7 +1501,7 @@ var BaseCommand = class extends Command {
             pathFilter
           });
           const tinaPathUpdates = modified.filter(
-            (path16) => path16.startsWith(".tina/__generated__/_schema.json") || path16.startsWith("tina/tina-lock.json")
+            (path17) => path17.startsWith(".tina/__generated__/_schema.json") || path17.startsWith("tina/tina-lock.json")
           );
           if (tinaPathUpdates.length > 0) {
             res = await database.indexContent({
@@ -2730,6 +2732,15 @@ var DevCommand = class extends BaseCommand {
       try {
         await configManager.processConfig();
         if (firstTime) {
+          const telemetry = new Telemetry({ disabled: this.noTelemetry });
+          await telemetry.submitRecord({
+            event: {
+              name: "tinacms:cli:dev:invoke",
+              hasLocalContentPath: Boolean(
+                configManager.config.localContentPath
+              )
+            }
+          });
           database = await createAndInitializeDatabase(
             configManager,
             Number(this.datalayerPort)
@@ -2770,15 +2781,6 @@ var DevCommand = class extends BaseCommand {
             path9.join(configManager.tinaFolderPath, tinaLockFilename),
             tinaLockContent
           );
-          if (configManager.hasSeparateContentRoot()) {
-            const rootPath = await configManager.getTinaFolderPath(
-              configManager.contentRootPath,
-              { isContentRoot: true }
-            );
-            const filePath = path9.join(rootPath, tinaLockFilename);
-            await fs8.ensureFile(filePath);
-            await fs8.outputFile(filePath, tinaLockContent);
-          }
         }
         await this.indexContentWithSpinner({
           database,
@@ -3019,6 +3021,7 @@ import crypto from "crypto";
 import path10 from "path";
 import { diff } from "@graphql-inspector/core";
 import { FilesystemBridge as FilesystemBridge3, buildSchema as buildSchema2 } from "@tinacms/graphql";
+import { Telemetry as Telemetry2 } from "@tinacms/metrics";
 import { parseURL as parseURL2 } from "@tinacms/schema-tools";
 import {
   SearchIndexer as SearchIndexer2,
@@ -3252,6 +3255,13 @@ ${dangerText(e.message)}`);
       );
       process.exit(1);
     }
+    const telemetry = new Telemetry2({ disabled: this.noTelemetry });
+    await telemetry.submitRecord({
+      event: {
+        name: "tinacms:cli:build:invoke",
+        hasLocalContentPath: Boolean(configManager.config.localContentPath)
+      }
+    });
     if (localContentOnly && !this.localOption) {
       const config2 = configManager.config;
       const missing = [];
@@ -3882,9 +3892,9 @@ import { buildSchema as buildSchema3 } from "@tinacms/graphql";
 
 // src/next/commands/audit-command/audit.ts
 import prompts from "prompts";
-import { Telemetry } from "@tinacms/metrics";
+import { Telemetry as Telemetry3 } from "@tinacms/metrics";
 import { resolve } from "@tinacms/graphql";
-import chalk6 from "chalk";
+import chalk5 from "chalk";
 var audit = async ({
   database,
   clean,
@@ -3892,7 +3902,7 @@ var audit = async ({
   noTelemetry,
   verbose
 }) => {
-  const telemetry = new Telemetry({ disabled: noTelemetry });
+  const telemetry = new Telemetry3({ disabled: noTelemetry });
   await telemetry.submitRecord({
     event: {
       name: "tinacms:cli:audit:invoke",
@@ -3902,7 +3912,7 @@ var audit = async ({
   });
   if (clean) {
     logger.info(
-      `You are using the \`--clean\` option. This will modify your content as if a user is submitting a form. Before running this you should have a ${chalk6.bold(
+      `You are using the \`--clean\` option. This will modify your content as if a user is submitting a form. Before running this you should have a ${chalk5.bold(
         "clean git tree"
       )} so unwanted changes can be undone.
 
@@ -3914,13 +3924,13 @@ var audit = async ({
       message: `Do you want to continue?`
     });
     if (!res.useClean) {
-      logger.warn(chalk6.yellowBright("\u26A0\uFE0F Audit not complete"));
+      logger.warn(chalk5.yellowBright("\u26A0\uFE0F Audit not complete"));
       process.exit(0);
     }
   }
   if (useDefaultValues && !clean) {
     logger.warn(
-      chalk6.yellowBright(
+      chalk5.yellowBright(
         "WARNING: using the `--useDefaultValues` without the `--clean` flag has no effect. Please re-run audit and add the `--clean` flag"
       )
     );
@@ -3948,10 +3958,10 @@ var audit = async ({
   }
   if (error) {
     logger.error(
-      chalk6.redBright(`\u203C\uFE0F Audit ${chalk6.bold("failed")} with errors`)
+      chalk5.redBright(`\u203C\uFE0F Audit ${chalk5.bold("failed")} with errors`)
     );
   } else {
-    logger.info(chalk6.greenBright("\u2705 Audit passed"));
+    logger.info(chalk5.greenBright("\u2705 Audit passed"));
   }
 };
 var auditDocuments = async (args) => {
@@ -3979,11 +3989,11 @@ var auditDocuments = async (args) => {
     if (docResult.errors) {
       error = true;
       docResult.errors.forEach((err) => {
-        logger.error(chalk6.red(err.message));
+        logger.error(chalk5.red(err.message));
         if (err.originalError.originalError) {
           logger.error(
             // @ts-ignore FIXME: this doesn't seem right
-            chalk6.red(`    ${err.originalError.originalError.message}`)
+            chalk5.red(`    ${err.originalError.originalError.message}`)
           );
         }
       });
@@ -4025,7 +4035,7 @@ var auditDocuments = async (args) => {
       if (mutationRes.errors) {
         mutationRes.errors.forEach((err) => {
           error = true;
-          logger.error(chalk6.red(err.message));
+          logger.error(chalk5.red(err.message));
         });
       }
     }
@@ -5650,7 +5660,7 @@ var rewriteTemplateKeysInDocs = (args) => {
 };
 
 // src/cmds/init/apply.ts
-import { Telemetry as Telemetry2 } from "@tinacms/metrics";
+import { Telemetry as Telemetry4 } from "@tinacms/metrics";
 import fs15 from "fs-extra";
 
 // src/next/commands/codemod-command/index.ts
@@ -6613,7 +6623,7 @@ var reportTelemetry = async ({
   if (noTelemetry) {
     logger.info(logText("Telemetry disabled"));
   }
-  const telemetry = new Telemetry2({ disabled: noTelemetry });
+  const telemetry = new Telemetry4({ disabled: noTelemetry });
   const schemaFileType = usingTypescript ? "ts" : "js";
   await telemetry.submitRecord({
     event: {
@@ -6711,22 +6721,22 @@ var writeGeneratedFile = async ({
   content,
   typescript
 }) => {
-  const { exists, path: path16, parentPath } = generatedFile.resolve(typescript);
+  const { exists, path: path17, parentPath } = generatedFile.resolve(typescript);
   if (exists) {
     if (overwrite) {
-      logger.info(`Overwriting file at ${path16}... \u2705`);
-      fs15.outputFileSync(path16, content);
+      logger.info(`Overwriting file at ${path17}... \u2705`);
+      fs15.outputFileSync(path17, content);
     } else {
-      logger.info(`Not overwriting file at ${path16}.`);
+      logger.info(`Not overwriting file at ${path17}.`);
       logger.info(
-        logText(`Please add the following to ${path16}:
+        logText(`Please add the following to ${path17}:
 ${indentText(content)}}`)
       );
     }
   } else {
-    logger.info(`Adding file at ${path16}... \u2705`);
+    logger.info(`Adding file at ${path17}... \u2705`);
     await fs15.ensureDir(parentPath);
-    fs15.outputFileSync(path16, content);
+    fs15.outputFileSync(path17, content);
   }
 };
 var addConfigFile = async ({
@@ -7121,6 +7131,356 @@ var SearchIndexCommand = class extends Command7 {
   }
 };
 
+// src/next/commands/doctor-command/index.ts
+import { Command as Command8, Option as Option8 } from "clipanion";
+
+// src/next/commands/doctor-command/doctor.ts
+import path16 from "path";
+import fs16 from "fs-extra";
+import yaml3 from "js-yaml";
+var DEPENDENCY_TYPES = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var LOCAL_REFERENCE_PREFIXES = [
+  "file:",
+  "link:",
+  "patch:",
+  "portal:",
+  "workspace:"
+];
+function isTinaPackage(name2) {
+  return name2 === "tinacms" || name2 === "create-tina-app" || name2.startsWith("@tinacms/") || name2.startsWith("tinacms-") || name2.startsWith("next-tinacms-");
+}
+function getTinaDependencies(packageJson) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, declared] of Object.entries(
+      packageJson[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2) || dependencies.has(name2)) continue;
+      dependencies.set(name2, { name: name2, declared, dependencyType });
+    }
+  }
+  return [...dependencies.values()].sort(
+    (a, b) => a.name.localeCompare(b.name)
+  );
+}
+async function readProjectPackageJson(rootPath) {
+  const packageJsonPath = path16.join(rootPath, "package.json");
+  if (!await fs16.pathExists(packageJsonPath)) {
+    throw new Error(`No package.json found at ${packageJsonPath}`);
+  }
+  return fs16.readJSON(packageJsonPath);
+}
+async function resolveInstalledVersions({
+  rootPath,
+  dependencies
+}) {
+  const lockfileVersions = await readLockfileVersions(rootPath);
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      const installed = await readNodeModulesVersion(rootPath, dependency.name) || lockfileVersions.get(dependency.name);
+      return { ...dependency, installed };
+    })
+  );
+}
+async function fetchLatestVersion(packageName, timeoutMs) {
+  const controller = new AbortController();
+  const timeout2 = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      { signal: controller.signal }
+    );
+    if (!response.ok) {
+      throw new Error(`npm registry returned ${response.status}`);
+    }
+    const body = await response.json();
+    const latest = body?.["dist-tags"]?.latest;
+    if (typeof latest !== "string" || latest.length === 0) {
+      throw new Error("npm registry response did not include dist-tags.latest");
+    }
+    return latest;
+  } finally {
+    clearTimeout(timeout2);
+  }
+}
+function classifyDependency(dependency, latest, error) {
+  if (!dependency.installed) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error: "Installed version could not be resolved from node_modules or lockfile"
+    };
+  }
+  if (isLocalReference(dependency.installed)) {
+    return {
+      ...dependency,
+      latest,
+      status: "local",
+      error
+    };
+  }
+  if (!latest || error) {
+    return {
+      ...dependency,
+      latest,
+      status: "unknown",
+      error
+    };
+  }
+  return {
+    ...dependency,
+    latest,
+    status: normalizeVersion(dependency.installed) === normalizeVersion(latest) ? "current" : "outdated"
+  };
+}
+async function checkTinaDependencies({
+  dependencies,
+  fetchLatest
+}) {
+  return Promise.all(
+    dependencies.map(async (dependency) => {
+      try {
+        const latest = await fetchLatest(dependency.name);
+        return classifyDependency(dependency, latest);
+      } catch (error) {
+        return classifyDependency(
+          dependency,
+          void 0,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    })
+  );
+}
+function formatDoctorTable(results) {
+  const rows = [
+    ["Package", "Type", "Declared", "Installed", "Latest", "Status"],
+    ...results.map((result) => [
+      result.name,
+      result.dependencyType,
+      result.declared,
+      result.installed || "-",
+      result.latest || "-",
+      formatStatus(result)
+    ])
+  ];
+  const widths = rows[0].map(
+    (_, column) => Math.max(...rows.map((row) => row[column].length))
+  );
+  return rows.map((row, rowIndex) => {
+    const line = row.map((cell, column) => cell.padEnd(widths[column])).join("  ");
+    return rowIndex === 0 ? `${line}
+${widths.map((w) => "-".repeat(w)).join("  ")}` : line;
+  }).join("\n");
+}
+function formatStatus(result) {
+  if (result.status === "outdated") return "OUTDATED";
+  if (result.status === "local") return "LOCAL";
+  if (result.status === "unknown")
+    return `UNKNOWN${result.error ? ` (${result.error})` : ""}`;
+  return "CURRENT";
+}
+function normalizeVersion(version2) {
+  return version2.trim().replace(/^v/, "").split("(")[0].trim();
+}
+function isLocalReference(version2) {
+  const normalized = version2.trim();
+  return LOCAL_REFERENCE_PREFIXES.some(
+    (prefix) => normalized.startsWith(prefix)
+  );
+}
+async function readNodeModulesVersion(rootPath, packageName) {
+  const packageJsonPath = path16.join(
+    rootPath,
+    "node_modules",
+    ...packageName.split("/"),
+    "package.json"
+  );
+  if (!await fs16.pathExists(packageJsonPath)) return void 0;
+  const packageJson = await fs16.readJSON(packageJsonPath);
+  return typeof packageJson.version === "string" ? packageJson.version : void 0;
+}
+async function readLockfileVersions(rootPath) {
+  const readers = [
+    readPackageLockVersions,
+    readPnpmLockVersions,
+    readYarnLockVersions
+  ];
+  for (const reader of readers) {
+    const versions = await reader(rootPath);
+    if (versions.size > 0) return versions;
+  }
+  return /* @__PURE__ */ new Map();
+}
+async function readPackageLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "package-lock.json");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const lockfile = await fs16.readJSON(lockfilePath);
+  for (const [key, value] of Object.entries(lockfile.packages || {})) {
+    if (!key.startsWith("node_modules/")) continue;
+    const name2 = key.replace(/^node_modules\//, "");
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  for (const [name2, value] of Object.entries(lockfile.dependencies || {})) {
+    const version2 = value.version;
+    if (isTinaPackage(name2) && typeof version2 === "string") {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+async function readPnpmLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "pnpm-lock.yaml");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const lockfile = yaml3.load(await fs16.readFile(lockfilePath, "utf8"));
+  const rootImporter = lockfile?.importers?.["."];
+  for (const dependencyType of DEPENDENCY_TYPES) {
+    for (const [name2, value] of Object.entries(
+      rootImporter?.[dependencyType] || {}
+    )) {
+      if (!isTinaPackage(name2)) continue;
+      const version2 = typeof value === "string" ? value : typeof value.version === "string" ? value.version : void 0;
+      if (version2) versions.set(name2, normalizeInstalledVersion(version2));
+    }
+  }
+  for (const key of Object.keys(lockfile?.packages || {})) {
+    const parsed = parsePnpmPackageKey(key);
+    if (parsed && isTinaPackage(parsed.name) && !versions.has(parsed.name)) {
+      versions.set(parsed.name, parsed.version);
+    }
+  }
+  return versions;
+}
+async function readYarnLockVersions(rootPath) {
+  const lockfilePath = path16.join(rootPath, "yarn.lock");
+  const versions = /* @__PURE__ */ new Map();
+  if (!await fs16.pathExists(lockfilePath)) return versions;
+  const contents = await fs16.readFile(lockfilePath, "utf8");
+  if (contents.includes("__metadata:")) {
+    return readYarnBerryLockVersions(contents);
+  }
+  const lines = contents.split("\n");
+  let activeNames = [];
+  for (const line of lines) {
+    if (line.length > 0 && !line.startsWith(" ") && line.includes("@")) {
+      activeNames = extractYarnPackageNames(line);
+      continue;
+    }
+    const version2 = line.match(/^\s+version\s+"([^"]+)"/)?.[1];
+    if (!version2) continue;
+    for (const name2 of activeNames) {
+      if (isTinaPackage(name2) && !versions.has(name2)) {
+        versions.set(name2, version2);
+      }
+    }
+  }
+  return versions;
+}
+function readYarnBerryLockVersions(contents) {
+  const versions = /* @__PURE__ */ new Map();
+  const lockfile = yaml3.load(contents);
+  for (const [descriptor, value] of Object.entries(lockfile || {})) {
+    if (descriptor === "__metadata") continue;
+    const name2 = extractYarnBerryPackageName(descriptor);
+    const version2 = getYarnBerryInstalledVersion(descriptor, value?.version);
+    if (name2 && isTinaPackage(name2) && version2) {
+      versions.set(name2, version2);
+    }
+  }
+  return versions;
+}
+function parsePnpmPackageKey(key) {
+  const normalized = key.replace(/^\//, "");
+  const match = normalized.match(/^(@[^/]+\/[^@]+|[^@/]+)@([^(/]+)/);
+  if (!match) return void 0;
+  return { name: match[1], version: normalizeVersion(match[2]) };
+}
+function normalizeInstalledVersion(version2) {
+  return isLocalReference(version2) ? version2 : normalizeVersion(version2);
+}
+function extractYarnPackageNames(line) {
+  return line.replace(/:$/, "").split(/,\s*/).map((descriptor) => descriptor.trim().replace(/^"|"$/g, "")).map((descriptor) => {
+    if (descriptor.startsWith("@")) {
+      const [, scope, name2] = descriptor.match(/^(@[^/]+)\/([^@]+)/) || [];
+      return scope && name2 ? `${scope}/${name2}` : descriptor;
+    }
+    return descriptor.split("@")[0];
+  }).filter(Boolean);
+}
+function extractYarnBerryPackageName(descriptor) {
+  if (descriptor.startsWith("@")) {
+    return descriptor.match(/^(@[^/]+\/[^@]+)/)?.[1];
+  }
+  return descriptor.split("@")[0] || void 0;
+}
+function getYarnBerryInstalledVersion(descriptor, version2) {
+  const name2 = extractYarnBerryPackageName(descriptor);
+  const reference = name2 ? descriptor.slice(name2.length + 1) : void 0;
+  if (reference && isLocalReference(reference)) return reference;
+  return typeof version2 === "string" ? normalizeInstalledVersion(version2) : void 0;
+}
+
+// src/next/commands/doctor-command/index.ts
+var DoctorCommand = class extends Command8 {
+  static paths = [["doctor"]];
+  rootPath = Option8.String("--rootPath", {
+    description: "Specify the root directory to inspect (defaults to current working directory)"
+  });
+  json = Option8.Boolean("--json", false, {
+    description: "Print machine-readable JSON output"
+  });
+  timeout = Option8.String("--timeout", "5000", {
+    description: "npm registry request timeout in milliseconds"
+  });
+  static usage = Command8.Usage({
+    category: "Commands",
+    description: "Check direct TinaCMS dependencies against npm latest"
+  });
+  async catch(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error occurred during tinacms doctor: ${message}`);
+    process.exit(1);
+  }
+  async execute() {
+    const rootPath = this.rootPath || process.cwd();
+    const timeoutMs = Number(this.timeout);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      logger.error("--timeout must be a positive number");
+      return 1;
+    }
+    const packageJson = await readProjectPackageJson(rootPath);
+    const dependencies = await resolveInstalledVersions({
+      rootPath,
+      dependencies: getTinaDependencies(packageJson)
+    });
+    const results = await checkTinaDependencies({
+      dependencies,
+      fetchLatest: (name2) => fetchLatestVersion(name2, timeoutMs)
+    });
+    if (this.json) {
+      logger.info(JSON.stringify({ rootPath, results }, null, 2));
+    } else if (results.length === 0) {
+      logger.info("No direct TinaCMS dependencies found.");
+    } else {
+      logger.info(formatDoctorTable(results));
+    }
+    const hasOutdated = results.some((result) => result.status === "outdated");
+    const hasUnknown = results.some((result) => result.status === "unknown");
+    return hasOutdated || hasUnknown ? 1 : 0;
+  }
+};
+
 // src/index.ts
 var cli = new Cli({
   binaryName: `tinacms`,
@@ -7133,6 +7493,7 @@ cli.register(AuditCommand);
 cli.register(InitCommand);
 cli.register(CodemodCommand);
 cli.register(SearchIndexCommand);
+cli.register(DoctorCommand);
 cli.register(Builtins.DefinitionsCommand);
 cli.register(Builtins.HelpCommand);
 cli.register(Builtins.VersionCommand);

package/dist/next/commands/doctor-command/doctor.d.ts

@@ -0,0 +1,34 @@
+export type DoctorStatus = 'current' | 'local' | 'outdated' | 'unknown';
+export type TinaDependency = {
+    name: string;
+    declared: string;
+    dependencyType: DependencyType;
+    installed?: string;
+};
+export type DoctorResult = TinaDependency & {
+    latest?: string;
+    status: DoctorStatus;
+    error?: string;
+};
+type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+};
+type DependencyType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
+export declare function isTinaPackage(name: string): boolean;
+export declare function getTinaDependencies(packageJson: PackageJson): TinaDependency[];
+export declare function readProjectPackageJson(rootPath: string): Promise<any>;
+export declare function resolveInstalledVersions({ rootPath, dependencies, }: {
+    rootPath: string;
+    dependencies: TinaDependency[];
+}): Promise<TinaDependency[]>;
+export declare function fetchLatestVersion(packageName: string, timeoutMs: number): Promise<string>;
+export declare function classifyDependency(dependency: TinaDependency, latest?: string, error?: string): DoctorResult;
+export declare function checkTinaDependencies({ dependencies, fetchLatest, }: {
+    dependencies: TinaDependency[];
+    fetchLatest: (name: string) => Promise<string>;
+}): Promise<DoctorResult[]>;
+export declare function formatDoctorTable(results: DoctorResult[]): string;
+export {};

package/dist/next/commands/doctor-command/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'clipanion';
+export declare class DoctorCommand extends Command {
+    static paths: string[][];
+    rootPath: string;
+    json: boolean;
+    timeout: string;
+    static usage: import("clipanion").Usage;
+    catch(error: unknown): Promise<void>;
+    execute(): Promise<number | void>;
+}

package/dist/next/config-manager.d.ts

@@ -8,13 +8,13 @@ export declare class ConfigManager {
     rootPath: string;
     tinaFolderPath: string;
     isUsingLegacyFolder: boolean;
+    private hasWarnedLegacyFolder;
     tinaConfigFilePath: string;
     tinaSpaPackagePath: string;
     contentRootPath?: string;
     envFilePath: string;
     generatedCachePath: string;
     generatedFolderPath: string;
-    generatedFolderPathContentRepo: string;
     generatedGraphQLGQLPath: string;
     generatedGraphQLJSONPath: string;
     generatedSchemaJSONPath: string;
@@ -54,21 +54,19 @@ export declare class ConfigManager {
     hasSeparateContentRoot(): boolean;
     shouldSkipSDK(): boolean;
     processConfig(): Promise<void>;
-    getTinaFolderPath(rootPath: string, { isContentRoot }?: {
-        isContentRoot?: boolean;
-    }): Promise<string>;
+    getTinaFolderPath(rootPath: string): Promise<string>;
     getTinaGraphQLVersion(): {
         fullVersion: string;
         major: string;
         minor: string;
         patch: string;
     };
-    printGeneratedClientFilePath(): string;
-    printGeneratedTypesFilePath(): string;
-    printoutputHTMLFilePath(): string;
-    printRelativePath(filename: string): string;
-    printPrebuildFilePath(): string;
-    printContentRelativePath(filename: string): string;
+    printGeneratedClientFilePath(): any;
+    printGeneratedTypesFilePath(): any;
+    printoutputHTMLFilePath(): any;
+    printRelativePath(filename: string): any;
+    printPrebuildFilePath(): any;
+    printContentRelativePath(filename: string): any;
     /**
      * Given a filepath without an extension, find the first match (eg. tsx, ts, jsx, js)
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tinacms/cli",
   "type": "module",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "files": [
@@ -41,7 +41,7 @@
     "@types/progress": "^2.0.7",
     "@types/prompts": "^2.4.9",
     "jest": "^29.7.0",
-    "@tinacms/scripts": "1.6.0"
+    "@tinacms/scripts": "1.6.1"
   },
   "dependencies": {
     "@graphql-codegen/core": "^2.6.8",
@@ -88,12 +88,12 @@
     "vite": "^4.5.9",
     "yup": "^1.6.1",
     "zod": "^3.24.2",
-    "@tinacms/app": "2.4.5",
-    "@tinacms/graphql": "2.3.0",
-    "@tinacms/schema-tools": "2.7.3",
-    "@tinacms/metrics": "2.0.1",
-    "@tinacms/search": "1.2.12",
-    "tinacms": "3.7.5"
+    "@tinacms/graphql": "2.4.0",
+    "@tinacms/schema-tools": "2.7.4",
+    "@tinacms/metrics": "2.1.0",
+    "@tinacms/search": "1.2.14",
+    "@tinacms/app": "2.4.7",
+    "tinacms": "3.8.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"