@readme/cli 0.0.27 → 0.0.29

package/src/utils/url-segs.test.js

@@ -0,0 +1,239 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { stripSegmentExtensions, urlTrieSegs, extractUrlPathSegments, normalizePath, compareCanonicalUrlPreference, llmsPageDedupeKey } from './url-segs.js'
+
+// ---------------------------------------------------------------------------
+// stripSegmentExtensions
+// ---------------------------------------------------------------------------
+
+test('stripSegmentExtensions: strips single .md', () => {
+  assert.equal(stripSegmentExtensions('index.md'), 'index')
+})
+
+test('stripSegmentExtensions: strips single .html', () => {
+  assert.equal(stripSegmentExtensions('index.html'), 'index')
+})
+
+test('stripSegmentExtensions: strips single .htm', () => {
+  assert.equal(stripSegmentExtensions('index.htm'), 'index')
+})
+
+test('stripSegmentExtensions: strips double .html.md (plaid pattern)', () => {
+  assert.equal(stripSegmentExtensions('index.html.md'), 'index')
+})
+
+test('stripSegmentExtensions: strips .mdx', () => {
+  assert.equal(stripSegmentExtensions('page.mdx'), 'page')
+})
+
+test('stripSegmentExtensions: strips .txt', () => {
+  assert.equal(stripSegmentExtensions('terminal.txt'), 'terminal')
+})
+
+test('stripSegmentExtensions: leaves bare txt segment untouched (no dot prefix)', () => {
+  assert.equal(stripSegmentExtensions('txt'), 'txt')
+})
+
+test('stripSegmentExtensions: leaves plain segments untouched', () => {
+  assert.equal(stripSegmentExtensions('quickstart'), 'quickstart')
+})
+
+test('stripSegmentExtensions: leaves kebab segments untouched', () => {
+  assert.equal(stripSegmentExtensions('getting-started'), 'getting-started')
+})
+
+// ---------------------------------------------------------------------------
+// urlTrieSegs — the double-extension plaid.com pattern
+// ---------------------------------------------------------------------------
+
+test('urlTrieSegs: .html.md index collapses to parent path (plaid pattern)', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://plaid.com/docs/account/index.html.md'),
+    ['docs', 'account'],
+  )
+})
+
+test('urlTrieSegs: .html index collapses to parent path', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://plaid.com/docs/account/index.html'),
+    ['docs', 'account'],
+  )
+})
+
+test('urlTrieSegs: trailing slash collapses correctly', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://plaid.com/docs/account/'),
+    ['docs', 'account'],
+  )
+})
+
+test('urlTrieSegs: non-index .html.md page keeps its segment', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://plaid.com/docs/account/billing/index.html.md'),
+    ['docs', 'account', 'billing'],
+  )
+})
+
+test('urlTrieSegs: orval.dev docs/index.html.md collapses correctly', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://orval.dev/docs/index.html.md'),
+    ['docs'],
+  )
+})
+
+test('urlTrieSegs: plain URL without extension passes through', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://example.com/docs/quickstart'),
+    ['docs', 'quickstart'],
+  )
+})
+
+test('urlTrieSegs: returns null on unparseable input', () => {
+  assert.equal(urlTrieSegs('not-a-url'), null)
+})
+
+test('urlTrieSegs: .txt segment strips extension (warp.dev pattern)', () => {
+  assert.deepEqual(
+    urlTrieSegs('https://docs.warp.dev/_llms-txt/terminal.txt'),
+    ['_llms-txt', 'terminal'],
+  )
+})
+
+// ---------------------------------------------------------------------------
+// extractUrlPathSegments — slug source
+// ---------------------------------------------------------------------------
+
+test('extractUrlPathSegments: .html.md index → parent segments only (plaid pattern)', () => {
+  assert.deepEqual(
+    extractUrlPathSegments('https://plaid.com/docs/account/index.html.md'),
+    ['docs', 'account'],
+  )
+})
+
+test('extractUrlPathSegments: slug from deepened path', () => {
+  assert.deepEqual(
+    extractUrlPathSegments('https://plaid.com/docs/account/billing/index.html.md'),
+    ['docs', 'account', 'billing'],
+  )
+})
+
+test('extractUrlPathSegments: strips leading numeric prefix', () => {
+  assert.deepEqual(
+    extractUrlPathSegments('https://example.com/docs/01-intro.md'),
+    ['docs', 'intro'],
+  )
+})
+
+test('extractUrlPathSegments: plain .md page', () => {
+  assert.deepEqual(
+    extractUrlPathSegments('https://example.com/docs/quickstart.md'),
+    ['docs', 'quickstart'],
+  )
+})
+
+test('extractUrlPathSegments: returns [] for empty/null input', () => {
+  assert.deepEqual(extractUrlPathSegments(''), [])
+  assert.deepEqual(extractUrlPathSegments(null), [])
+})
+
+// ---------------------------------------------------------------------------
+// normalizePath — deduplication keys
+// ---------------------------------------------------------------------------
+
+test('normalizePath: .html.md and .html and bare path all produce same key', () => {
+  const a = normalizePath('https://plaid.com/docs/account/index.html.md')
+  const b = normalizePath('https://plaid.com/docs/account/index.html')
+  const c = normalizePath('https://plaid.com/docs/account/index')
+  assert.equal(a, b)
+  assert.equal(b, c)
+})
+
+test('normalizePath: trailing slash and bare path produce same key', () => {
+  const a = normalizePath('https://example.com/docs/foo/')
+  const b = normalizePath('https://example.com/docs/foo')
+  assert.equal(a, b)
+})
+
+test('normalizePath: index variants and bare path produce same key', () => {
+  const bare = normalizePath('https://example.com/docs/get-started')
+  assert.equal(normalizePath('https://example.com/docs/get-started/'), bare)
+  assert.equal(normalizePath('https://example.com/docs/get-started/index.html'), bare)
+  assert.equal(normalizePath('https://example.com/docs/get-started/index.htm'), bare)
+})
+
+test('normalizePath: lowercases result', () => {
+  assert.equal(normalizePath('https://example.com/Docs/QuickStart'), '/docs/quickstart')
+})
+
+test('normalizePath: falls back for unparseable input', () => {
+  assert.equal(normalizePath('not-a-url'), 'not-a-url')
+})
+
+test('normalizePath: strips .txt extension (warp.dev pattern)', () => {
+  assert.equal(
+    normalizePath('https://docs.warp.dev/_llms-txt/terminal.txt'),
+    '/_llms-txt/terminal',
+  )
+})
+
+// ---------------------------------------------------------------------------
+// llmsPageDedupeKey — llms.txt page-row deduplication
+// ---------------------------------------------------------------------------
+
+test('llmsPageDedupeKey: includes origin so same paths on different hosts stay distinct', () => {
+  assert.notEqual(
+    llmsPageDedupeKey('https://docs.example.com/docs/get-started.md'),
+    llmsPageDedupeKey('https://example.com/docs/get-started.md'),
+  )
+})
+
+test('llmsPageDedupeKey: preserves query params by default', () => {
+  assert.notEqual(
+    llmsPageDedupeKey('https://example.com/docs/search?product=api'),
+    llmsPageDedupeKey('https://example.com/docs/search?product=sdk'),
+  )
+})
+
+test('llmsPageDedupeKey: normalizes query param order', () => {
+  assert.equal(
+    llmsPageDedupeKey('https://example.com/docs/search?b=2&a=1'),
+    llmsPageDedupeKey('https://example.com/docs/search?a=1&b=2'),
+  )
+})
+
+test('llmsPageDedupeKey: ignores fragments but preserves router query state', () => {
+  assert.equal(
+    llmsPageDedupeKey('https://example.com/docs/get-started.md?tab=js#install'),
+    llmsPageDedupeKey('https://example.com/docs/get-started?tab=js#auth'),
+  )
+})
+
+test('llmsPageDedupeKey: collapses doc URL spellings for the same page', () => {
+  const bare = llmsPageDedupeKey('https://example.com/docs/get-started')
+  assert.equal(llmsPageDedupeKey('https://example.com/docs/get-started.md'), bare)
+  assert.equal(llmsPageDedupeKey('https://example.com/docs/get-started.txt'), bare)
+  assert.equal(llmsPageDedupeKey('https://example.com/docs/get-started/index.html'), bare)
+  assert.equal(llmsPageDedupeKey('https://example.com/docs/get-started/'), bare)
+})
+
+// ---------------------------------------------------------------------------
+// compareCanonicalUrlPreference — retained URL selection
+// ---------------------------------------------------------------------------
+
+test('compareCanonicalUrlPreference: prefers md over txt, bare, trailing slash, and index', () => {
+  const urls = [
+    'https://example.com/docs/get-started/index.html',
+    'https://example.com/docs/get-started/',
+    'https://example.com/docs/get-started',
+    'https://example.com/docs/get-started.txt',
+    'https://example.com/docs/get-started.md',
+  ]
+
+  assert.deepEqual([...urls].sort(compareCanonicalUrlPreference), [
+    'https://example.com/docs/get-started.md',
+    'https://example.com/docs/get-started.txt',
+    'https://example.com/docs/get-started',
+    'https://example.com/docs/get-started/',
+    'https://example.com/docs/get-started/index.html',
+  ])
+})

package/src/validators/components.js

@@ -220,6 +220,7 @@ export function validateAll(files, gitRoot) {
         results.push({
           file: relPath,
           rule: name,
+          severity: 'warning',
           message: `Unknown component: <${comp}> is not a built-in or custom block`,
         });
       }

package/src/validators/duplicates.js

@@ -8,7 +8,7 @@ const CHECKED_DIRS = ['docs', 'reference'];
 export function validateAll(files) {
   const results = [];
 
-  // Group files by slug.
+  // Group files by "<topDir>:<slug>" so slugs only collide within the same section.
   const slugMap = new Map();
   for (const relPath of files) {
     const topDir = relPath.split('/')[0];
@@ -18,17 +18,19 @@ export function validateAll(files) {
     if (filename === 'index.md' || filename === 'index.mdx') continue;
 
     const slug = filename.replace(/\.(md|mdx)$/, '');
-    if (!slugMap.has(slug)) slugMap.set(slug, []);
-    slugMap.get(slug).push(relPath);
+    const key = `${topDir}:${slug}`;
+    if (!slugMap.has(key)) slugMap.set(key, []);
+    slugMap.get(key).push(relPath);
   }
 
-  for (const [slug, paths] of slugMap) {
+  for (const [key, paths] of slugMap) {
     if (paths.length < 2) continue;
 
     // TODO: figure out why ReadMeConfig causes duplicate slugs and handle properly.
     // For now, skip any duplicate set that involves a ReadMeConfig path.
     if (paths.some((p) => p.includes('ReadMeConfig/'))) continue;
 
+    const slug = key.slice(key.indexOf(':') + 1);
     const others = paths.slice(1);
     for (const relPath of others) {
       const otherLocations = paths.filter((p) => p !== relPath).map((p) => path.dirname(p)).join(', ');

package/src/validators/frontmatter.js

@@ -113,6 +113,17 @@ export function validate({ content, filePath, relativePath, fix }) {
     const valid = validateFn(data);
     if (!valid) {
       for (const err of validateFn.errors) {
+        // Reference pages are OAS-backed: title/excerpt come from the spec, so a
+        // missing title is not an error for pages that declare an api.file.
+        if (
+          dir === 'reference' &&
+          data?.api?.file &&
+          err.keyword === 'required' &&
+          err.params?.missingProperty === 'title'
+        ) {
+          continue;
+        }
+
         if (err.keyword === 'not' && err.schema?.properties) {
           const target = err.instancePath ? getNestedValue(data, err.instancePath) : data;
           if (!target || !Object.keys(err.schema.properties).some((k) => k in target)) continue;

package/src/validators/oas-reference.js

@@ -60,37 +60,7 @@ export function validateAll(files, gitRoot, { fix } = {}) {
       continue;
     }
 
-    // Skip title/excerpt sync checks for ReadMeConfig (internal ReadMe pages).
-    // Check both the spec title and the page's directory path.
-    const isReadMeConfig = oas.spec.info?.title === 'ReadMeConfig'
-      || relPath.startsWith('reference/ReadMeConfig/');
-    if (isReadMeConfig) continue;
-
-    // Check: title or excerpt out of sync.
-    const op = oas.ops.get(operationId);
-    const expectedTitle = op.summary || operationId;
-    const expectedExcerpt = op.description || null;
-
-    if (data.title !== expectedTitle) {
-      results.push({
-        file: relPath,
-        rule: name,
-        severity: 'warning',
-        message: `Out of sync: title is "${data.title}" but spec summary is "${expectedTitle}"`,
-        fixable: true,
-      });
-    }
-
-    const currentExcerpt = data.excerpt || null;
-    if (currentExcerpt !== expectedExcerpt) {
-      results.push({
-        file: relPath,
-        rule: name,
-        severity: 'warning',
-        message: `Out of sync: excerpt does not match spec description for "${operationId}"`,
-        fixable: true,
-      });
-    }
+    // Title/excerpt are owned by the OAS spec at render time — no sync check here.
   }
 
   // Check for missing pages: operations in the spec with no corresponding page.

package/src/validators/ordering.js

@@ -3,8 +3,13 @@ import path from 'node:path';
 
 export const name = 'ordering';
 
-// Content directories where _order.yaml is expected.
-const ORDERED_DIRS = ['docs', 'recipes', 'custom_pages'];
+// Top-level content directories that use _order.yaml.
+const CONTENT_DIRS = ['docs', 'reference', 'recipes', 'custom_pages'];
+
+// Of those, the dirs that must list every page/folder. reference ordering is
+// OAS-managed, so we never flag pages "missing from" a reference _order.yaml —
+// but stale entries are flagged everywhere.
+const REQUIRE_ORDER = new Set(['docs', 'recipes', 'custom_pages']);
 
 // Values that YAML interprets as non-strings and need quoting in _order.yaml.
 const YAML_UNSAFE = /^(?:\d+\.?\d*|true|false|yes|no|on|off|null|~)$/i;
@@ -12,110 +17,191 @@ function yamlSafeSlug(slug) {
   return YAML_UNSAFE.test(slug) ? `"${slug}"` : slug;
 }
 
-function slugFromFile(filename) {
-  return filename.replace(/\.(md|mdx)$/, '');
+// Returns the slug a "- entry" line refers to, or null for any other line.
+// Handles quoted slugs and trailing inline comments (`- overview # comment`).
+function parseOrderEntry(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('- ')) return null;
+  const value = trimmed.slice(2).trim();
+  const quoted = value.match(/^(['"])(.*)\1\s*(?:#.*)?$/);
+  if (quoted) return quoted[2];
+  const slug = value.replace(/(?:^|\s)#.*$/, '').trim();
+  return slug === '' ? null : slug;
 }
 
 function parseOrderYaml(content) {
   return content
     .split('\n')
-    .map((line) => line.trim())
-    .filter((line) => line.startsWith('- '))
-    .map((line) => line.slice(2).trim().replace(/^(['"])(.*)\1$/, '$2'));
+    .map(parseOrderEntry)
+    .filter((entry) => entry !== null);
+}
+
+function isIndex(name) {
+  return name === 'index' || name === 'index.md' || name === 'index.mdx';
+}
+
+/**
+ * Walk a content directory tree once. For every directory, capture the on-disk
+ * slug set (child pages + child folders) and its _order.yaml entries (or null
+ * when absent), so the caller can diff the two in a single pass.
+ */
+function collectDirs(gitRoot, topDir) {
+  const base = path.join(gitRoot, topDir);
+  if (!fs.existsSync(base)) return [];
+
+  const dirs = [];
+  const stack = [base];
+  while (stack.length) {
+    const cur = stack.pop();
+    const onDisk = new Set();
+    let orderEntries = null;
+
+    for (const entry of fs.readdirSync(cur, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        onDisk.add(entry.name);
+        stack.push(path.join(cur, entry.name));
+      } else if (entry.name === '_order.yaml') {
+        orderEntries = parseOrderYaml(fs.readFileSync(path.join(cur, entry.name), 'utf-8'));
+      } else if (/\.(md|mdx)$/.test(entry.name) && !isIndex(entry.name)) {
+        onDisk.add(entry.name.replace(/\.(md|mdx)$/, ''));
+      }
+    }
+
+    dirs.push({ dir: cur, onDisk, orderEntries });
+  }
+  return dirs;
 }
 
 /**
- * Find all directories that contain content and check their _order.yaml.
+ * Validate every _order.yaml against the files and folders next to it:
+ *   - on disk but missing from _order.yaml  → "Missing from _order.yaml" (required dirs only)
+ *   - in _order.yaml but missing on disk     → "Stale entry"
+ *   - an index entry that shouldn't be listed → "Invalid entry"
  */
 export function validateAll(files, gitRoot, { fix } = {}) {
   const results = [];
 
-  // Group files by their immediate parent directory.
-  const dirContents = new Map();
-  for (const relPath of files) {
-    const topDir = relPath.split('/')[0];
-    if (!ORDERED_DIRS.includes(topDir)) continue;
-
-    const dir = path.dirname(relPath);
-    if (!dirContents.has(dir)) dirContents.set(dir, { files: [], subdirs: new Set() });
-
-    const filename = path.basename(relPath);
-    dirContents.get(dir).files.push(filename);
-
-    // Track subdirectories in the parent so we know about categories/nested dirs.
-    const parts = relPath.split('/');
-    if (parts.length > 2) {
-      const parentDir = parts.slice(0, -2).join('/');
-      const subdir = parts[parts.length - 2];
-      if (!dirContents.has(parentDir)) dirContents.set(parentDir, { files: [], subdirs: new Set() });
-      dirContents.get(parentDir).subdirs.add(subdir);
-    }
-  }
+  for (const topDir of CONTENT_DIRS) {
+    const requireOrder = REQUIRE_ORDER.has(topDir);
+
+    for (const { dir, onDisk, orderEntries } of collectDirs(gitRoot, topDir)) {
+      const orderPath = path.join(dir, '_order.yaml');
+      const relOrder = path.relative(gitRoot, orderPath);
+
+      // No _order.yaml at all: only required dirs need one.
+      if (orderEntries === null) {
+        if (requireOrder && onDisk.size > 0) {
+          const missing = [...onDisk].sort();
+          results.push({
+            file: relOrder,
+            rule: name,
+            severity: 'warning',
+            fixable: true,
+            message: `Missing order: _order.yaml not found (${missing.length} ${missing.length === 1 ? 'entry needs' : 'entries need'} ordering)`,
+            _fixAdd: { orderPath, missing },
+          });
+        }
+        continue;
+      }
 
-  for (const [dir, { files: dirFiles, subdirs }] of dirContents) {
-    const orderPath = path.join(gitRoot, dir, '_order.yaml');
+      const ordered = new Set(orderEntries);
+
+      // On disk but not ordered.
+      if (requireOrder) {
+        const missing = [...onDisk].filter((slug) => !ordered.has(slug)).sort();
+        if (missing.length > 0) {
+          results.push({
+            file: relOrder,
+            rule: name,
+            severity: 'warning',
+            fixable: true,
+            message: `Missing from _order.yaml: ${missing.join(', ')}`,
+            _fixAdd: { orderPath, missing },
+          });
+        }
+      }
 
-    // Collect expected slugs: files (excluding index.md) + subdirectories.
-    const expectedSlugs = [];
-    for (const f of dirFiles) {
-      if (f === 'index.md' || f === 'index.mdx') continue;
-      expectedSlugs.push(slugFromFile(f));
-    }
-    for (const sub of subdirs) {
-      expectedSlugs.push(sub);
+      // Ordered but not on disk (or an index entry that shouldn't be listed).
+      for (const entry of orderEntries) {
+        if (isIndex(entry)) {
+          results.push({
+            file: relOrder,
+            rule: name,
+            severity: 'warning',
+            fixable: true,
+            message: `Invalid entry: "${entry}" should not be listed in _order.yaml`,
+            _fixRemove: { orderPath, entry },
+          });
+        } else if (!onDisk.has(entry)) {
+          results.push({
+            file: relOrder,
+            rule: name,
+            severity: 'warning',
+            fixable: true,
+            message: `Stale entry: "${entry}" in _order.yaml has no matching file or folder`,
+            _fixRemove: { orderPath, entry },
+          });
+        }
+      }
     }
+  }
 
-    if (!fs.existsSync(orderPath)) {
-      if (expectedSlugs.length === 0) continue;
-
-      results.push({
-        file: path.join(dir, '_order.yaml'),
-        rule: name,
-        severity: 'warning',
-        fixable: true,
-        message: `Missing order: _order.yaml not found (${expectedSlugs.length} ${expectedSlugs.length === 1 ? 'entry needs' : 'entries need'} ordering)`,
-        _fix: { orderPath, missing: expectedSlugs },
-      });
-      continue;
+  if (!fix) return strip(results);
+
+  // Additions: append missing slugs to the _order.yaml.
+  for (const r of results) {
+    if (!r._fixAdd) continue;
+    const { orderPath, missing } = r._fixAdd;
+    const newEntries = missing.map((slug) => `- ${yamlSafeSlug(slug)}`).join('\n');
+
+    if (fs.existsSync(orderPath)) {
+      const existing = fs.readFileSync(orderPath, 'utf-8');
+      const sep = existing.endsWith('\n') ? '' : '\n';
+      fs.writeFileSync(orderPath, `${existing}${sep}${newEntries}\n`);
+    } else {
+      fs.mkdirSync(path.dirname(orderPath), { recursive: true });
+      fs.writeFileSync(orderPath, `${newEntries}\n`);
     }
+    r.message += ' (fixed)';
+  }
 
-    const content = fs.readFileSync(orderPath, 'utf-8');
-    const ordered = new Set(parseOrderYaml(content));
-    const missing = expectedSlugs.filter((slug) => !ordered.has(slug));
-
-    if (missing.length > 0) {
-      results.push({
-        file: path.join(dir, '_order.yaml'),
-        rule: name,
-        severity: 'warning',
-        fixable: true,
-        message: `Missing from _order.yaml: ${missing.join(', ')}`,
-        _fix: { orderPath, missing },
+  // Removals: group stale/index entries by order file, then rewrite each once.
+  const removalsByPath = new Map();
+  for (const r of results) {
+    if (!r._fixRemove) continue;
+    const { orderPath, entry } = r._fixRemove;
+    if (!removalsByPath.has(orderPath)) removalsByPath.set(orderPath, new Set());
+    removalsByPath.get(orderPath).add(entry);
+  }
+  for (const [orderPath, toRemove] of removalsByPath) {
+    if (!fs.existsSync(orderPath)) continue;
+    // Drop only the targeted entry lines, keeping comments, blank lines, and
+    // untouched entries exactly as written.
+    const kept = fs
+      .readFileSync(orderPath, 'utf-8')
+      .split('\n')
+      .filter((line) => {
+        const entry = parseOrderEntry(line);
+        return entry === null || !toRemove.has(entry);
       });
+    if (kept.some((line) => parseOrderEntry(line) !== null)) {
+      fs.writeFileSync(orderPath, kept.join('\n'));
+    } else {
+      fs.unlinkSync(orderPath);
     }
   }
+  for (const r of results) {
+    if (r._fixRemove) r.message += ' (fixed)';
+  }
 
-  // Apply fixes if requested.
-  if (fix) {
-    for (const r of results) {
-      if (!r._fix) continue;
-      const { orderPath, missing } = r._fix;
-      const newEntries = missing.map((slug) => `- ${yamlSafeSlug(slug)}`).join('\n');
-
-      if (fs.existsSync(orderPath)) {
-        const existing = fs.readFileSync(orderPath, 'utf-8');
-        const sep = existing.endsWith('\n') ? '' : '\n';
-        fs.writeFileSync(orderPath, `${existing}${sep}${newEntries}\n`);
-      } else {
-        fs.mkdirSync(path.dirname(orderPath), { recursive: true });
-        fs.writeFileSync(orderPath, `${newEntries}\n`);
-      }
+  return strip(results);
+}
 
-      r.message += ' (fixed)';
-    }
+// Remove internal fix descriptors before returning results to the reporter.
+function strip(results) {
+  for (const r of results) {
+    delete r._fixAdd;
+    delete r._fixRemove;
   }
-
-  // Strip internal _fix data before returning.
-  for (const r of results) delete r._fix;
   return results;
 }

package/vendor/TOOLS.md

@@ -4,7 +4,7 @@ The ReadMe CLI (`npx @readme/cli`) has several commands that can help fix issues
 
 ## `npx @readme/cli lint --fix`
 
-Automatically fixes common linting issues: ordering problems, frontmatter cleanup, numbering suffixes, etc. Always try this first.
+Automatically fixes common linting issues: ordering problems, frontmatter cleanup, etc. Always try this first.
 
 ## `npx @readme/cli oas:sync`
 

package/src/dev/.next/app-build-manifest.json

@@ -1,20 +0,0 @@
-{
-  "pages": {
-    "/layout": [
-      "static/chunks/webpack.js",
-      "static/chunks/main-app.js",
-      "static/css/app/layout.css",
-      "static/chunks/app/layout.js"
-    ],
-    "/[...slug]/loading": [
-      "static/chunks/webpack.js",
-      "static/chunks/main-app.js",
-      "static/chunks/app/[...slug]/loading.js"
-    ],
-    "/[...slug]/page": [
-      "static/chunks/webpack.js",
-      "static/chunks/main-app.js",
-      "static/chunks/app/[...slug]/page.js"
-    ]
-  }
-}