Skip to content

vercel-labs/agent-skills / skills/vercel-optimize

vercel-optimize

Verified

Use for Vercel cost and performance optimization on deployed projects, especially Next.js, SvelteKit, Nuxt, and limited Astro apps. Collect Vercel metrics, usage, project config, and code scan results first; investigate only metric-backed candidates; produce ranked recommendations grounded in verified files and version-aware Vercel/framework docs. Trigger for Vercel bill reduction, slow or expensive routes, caching opportunities, Function Invocations, Build Minutes, Fast Data Transfer, Core Web Vitals, Bot Management, Fluid compute, or cost breakdown requests.

FileKindSize
AGENTS.mdmarkdown1.9 KB
CONTRIBUTING.mdmarkdown2.2 KB
README.mdmarkdown4.4 KB
SKILL.mdskill md16.9 KB
lib/auth-route.mjsscript807 B
lib/budget-summary.mjsscript7.0 KB
lib/citations.mjsscript3.9 KB
lib/cost-coverage.mjsscript8.4 KB
lib/dedup-recs.mjsscript9.9 KB
lib/deep-dive.mjsscript10.2 KB
lib/display-labels.mjsscript7.4 KB
lib/extract-claims.mjsscript18.7 KB
lib/framework-support.mjsscript2.1 KB
lib/gates/build-minutes-fanout.mjsscript2.9 KB
lib/gates/cold-start.mjsscript2.7 KB
lib/gates/contract.mjsscript3.1 KB
lib/gates/cwv-poor.mjsscript3.3 KB
lib/gates/external-api-slow.mjsscript2.1 KB
lib/gates/hard-gates.mjsscript2.5 KB
lib/gates/index.mjsscript2.0 KB
lib/gates/isr-overrevalidation.mjsscript2.4 KB
lib/gates/middleware-heavy.mjsscript2.0 KB
lib/gates/observability-events-attribution.mjsscript2.2 KB
lib/gates/platform-bot-protection.mjsscript5.0 KB
lib/gates/platform-fluid-compute.mjsscript3.5 KB
lib/gates/region-misconfig.mjsscript3.0 KB
lib/gates/route-errors.mjsscript3.0 KB
lib/gates/scanner-driven.mjsscript5.1 KB
lib/gates/select-candidates.mjsscript4.6 KB
lib/gates/slow-route.mjsscript4.3 KB
lib/gates/types.d.tsscript893 B
lib/gates/uncached-route.mjsscript3.9 KB
lib/gates/usage-spike-triage.mjsscript5.0 KB
lib/grade-recommendation.mjsscript6.7 KB
lib/impact-label.mjsscript5.2 KB
lib/impact-magnitude.mjsscript2.1 KB
lib/investigation-brief.mjsscript34.3 KB
lib/observation-safety.mjsscript9.3 KB
lib/project-facts.mjsscript4.3 KB
lib/queries.mjsscript10.1 KB
lib/reconcile-candidates.mjsscript15.6 KB
lib/render-report.mjsscript38.2 KB
lib/repo-root.mjsscript3.1 KB
lib/route-normalize.mjsscript8.4 KB
lib/sanitizers/bot-protection-certainty.mjsscript1.9 KB
lib/sanitizers/cache-tag-invalidation-certainty.mjsscript1.5 KB
lib/sanitizers/count-correct.mjsscript1.9 KB
lib/sanitizers/function-duration-invocations.mjsscript1.4 KB
lib/sanitizers/index.mjsscript3.0 KB
lib/sanitizers/middleware-conflict.mjsscript1.5 KB
lib/sanitizers/missing-citation.mjsscript497 B
lib/sanitizers/pre-release.mjsscript2.2 KB
lib/sanitizers/rate-limit.mjsscript2.6 KB
lib/sanitizers/rendering-mode-mislabel.mjsscript1.6 KB
lib/sanitizers/undeclared-dep.mjsscript2.8 KB
lib/sanitizers/vercel-directive-strip.mjsscript1.4 KB
lib/sanitizers/window-units.mjsscript869 B
lib/scanners/cache-components-suspense-dedupe.mjsscript4.3 KB
lib/scanners/edge-heavy-import.mjsscript3.7 KB
lib/scanners/force-dynamic.mjsscript1.5 KB
lib/scanners/headers-in-page.mjsscript1.5 KB
lib/scanners/index.mjsscript1.4 KB
lib/scanners/large-static-asset.mjsscript3.2 KB
lib/scanners/max-age-without-s-maxage.mjsscript1.6 KB
lib/scanners/middleware-broad-matcher.mjsscript1.9 KB
lib/scanners/missing-cache-headers.mjsscript3.8 KB
lib/scanners/prisma-include-tree.mjsscript1.5 KB
lib/scanners/region-pin-in-config.mjsscript3.4 KB
lib/scanners/source-maps-production.mjsscript1.3 KB
lib/scanners/sveltekit-prerender-missing.mjsscript2.1 KB
lib/scanners/turbo-force-bypass.mjsscript4.9 KB
lib/scanners/unoptimized-image.mjsscript4.4 KB
lib/scanners/use-cache-date-stamp.mjsscript3.9 KB
lib/support-topics.mjsscript12.5 KB
lib/throttle.mjsscript8.8 KB
lib/util.mjsscript544 B
lib/vercel.mjsscript30.4 KB
lib/verify-claim.mjsscript59.6 KB
lib/workspace-resolver.mjsscript17.1 KB
metadata.jsonconfig903 B
references/candidates.mdmarkdown8.3 KB
references/data-collection.mdmarkdown20.4 KB
references/docs-library.jsonconfig30.8 KB
references/doctrine.mdmarkdown9.3 KB
references/observability-plus.mdmarkdown5.2 KB
references/playbooks/README.mdmarkdown2.7 KB
references/playbooks/ai-application.mdmarkdown3.8 KB
references/playbooks/api-service.mdmarkdown2.4 KB
references/playbooks/content-site.mdmarkdown2.4 KB
references/playbooks/ecommerce.mdmarkdown2.7 KB
references/playbooks/marketing.mdmarkdown2.6 KB
references/playbooks/saas.mdmarkdown2.8 KB
references/playbooks/sveltekit.mdmarkdown3.9 KB
references/recommendations.mdmarkdown10.5 KB
references/scanner-patterns.mdmarkdown13.4 KB
references/scoring.mdmarkdown12.2 KB
references/support-topics/README.mdmarkdown1.7 KB
references/support-topics/astro-edge-middleware-scope.mdmarkdown1012 B
references/support-topics/astro-output-mode-and-isr.mdmarkdown1.1 KB
references/support-topics/auth-preserving-parallelization.mdmarkdown1.2 KB
references/support-topics/bot-protection-product-guardrails.mdmarkdown1.1 KB
references/support-topics/build-minutes-monorepo-fanout.mdmarkdown1.2 KB
references/support-topics/cache-components-static-shell-boundaries.mdmarkdown1.1 KB
references/support-topics/cache-components-suspense-dedupe-pitfall.mdmarkdown1.3 KB
references/support-topics/cdn-cache-auth-safety.mdmarkdown1.0 KB
references/support-topics/cold-start-initialization-bundle.mdmarkdown1.1 KB
references/support-topics/core-web-vitals-client-bottlenecks.mdmarkdown1.0 KB
references/support-topics/database-egress-pooling-region.mdmarkdown1015 B
references/support-topics/dynamic-rendering-traps.mdmarkdown1.1 KB
references/support-topics/external-api-critical-path-platform.mdmarkdown1.1 KB
references/support-topics/external-api-critical-path.mdmarkdown978 B
references/support-topics/fast-data-transfer-payloads.mdmarkdown1.0 KB
references/support-topics/fluid-compute-caveats.mdmarkdown1.1 KB
references/support-topics/function-duration-io-and-after.mdmarkdown1.0 KB
references/support-topics/function-invocation-reduction.mdmarkdown1.2 KB
references/support-topics/function-region-misconfiguration-ttfb.mdmarkdown1.2 KB
references/support-topics/image-optimization-cost-control.mdmarkdown1.0 KB
references/support-topics/isr-revalidation-static-generation.mdmarkdown1.4 KB
references/support-topics/middleware-proxy-edge-cost.mdmarkdown991 B
references/support-topics/next-fetch-revalidate-floor.mdmarkdown1.0 KB
references/support-topics/next-font-cls-self-hosting.mdmarkdown906 B
references/support-topics/next-heavy-ui-lazy-load-boundaries.mdmarkdown1.0 KB
references/support-topics/next-image-lcp-preload-sizes.mdmarkdown1.0 KB
references/support-topics/next-route-handler-get-cache-defaults.mdmarkdown1.0 KB
references/support-topics/next-script-third-party-strategy.mdmarkdown1.0 KB
references/support-topics/nextjs-version-cache-semantics.mdmarkdown996 B
references/support-topics/not-found-catchall-request-waste.mdmarkdown1.2 KB
references/support-topics/nuxt-route-rules-cache-isr.mdmarkdown1.2 KB
references/support-topics/observability-events-cost-attribution.mdmarkdown1.1 KB
references/support-topics/post-response-work-waituntil.mdmarkdown1009 B
references/support-topics/route-error-durable-offload.mdmarkdown1.3 KB
references/support-topics/route-error-runtime-limits.mdmarkdown988 B
references/support-topics/runtime-cache-reusable-data.mdmarkdown1.2 KB
references/support-topics/sveltekit-isr-prerender-safety.mdmarkdown1.1 KB
references/support-topics/sveltekit-split-cold-start-tradeoff.mdmarkdown1.0 KB
references/support-topics/usage-spike-triage.mdmarkdown1018 B
references/support-topics/use-cache-date-stamp-isr-write-amplifier.mdmarkdown1.2 KB
references/support-topics/use-cache-remote-shared-origin-data.mdmarkdown1.1 KB
references/support-topics/workflow-resumable-stream-routes.mdmarkdown1.2 KB
references/verification.mdmarkdown8.8 KB
references/voice.mdmarkdown3.6 KB
scripts/budget-summary.mjsscript2.0 KB
scripts/build-docs.mjsexecutablescript3.3 KB
scripts/check-citations.mjsscript3.4 KB
scripts/check-docs-fresh.mjsexecutablescript3.8 KB
scripts/collect-signals.mjsexecutablescript21.1 KB
scripts/collect-sub-agent-outputs.mjsscript9.9 KB
scripts/deep-dive.mjsexecutablescript12.0 KB
scripts/gate-investigations.mjsexecutablescript6.2 KB
scripts/merge-signals.mjsscript6.2 KB
scripts/prepare-investigation-brief.mjsscript7.9 KB
scripts/reconcile-candidates.mjsscript2.4 KB
scripts/render-report.mjsscript17.0 KB
scripts/scan-codebase.mjsexecutablescript11.3 KB
scripts/verify-and-regen.mjsscript14.9 KB
scripts/verify-finding.mjsexecutablescript698 B

lib/workspace-resolver.mjs

View on GitHub
// Resolve workspace-package imports to actual source files. Sub-agents need this when the route file is a thin shell that re-exports from a workspace package.
//
// Bounded expansion keeps the brief allowlist small: package export resolution, pure-barrel
// traversal, and suffix fan-out for likely data-loading modules. This stays string-based
// and falls through ("couldn't resolve") on shapes that need a full TS resolver.

import { readFile, readdir, stat } from 'node:fs/promises';
import { dirname, join, resolve as pathResolve } from 'node:path';

const DEFAULT_RESOLVE_OPTIONS = {
  pureBarrelDepth: 3,
  suffixFanoutDepth: 2,
  perSpecifierCap: 3,
};
const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
const EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
const INDEX_FILES = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.mjs'];
const SUFFIX_FANOUT_RE = /(^|\/)(content|data|loader|fetch|service|metadata|actions)\.tsx?$/;
const EXPORT_FORWARD_RE = /export\s+(?:type\s+)?(?:\*|\*\s+as\s+[A-Za-z_$][\w$]*|\{[^}]*\})\s+from\s+['"][^'"\n]+['"]\s*;?/gs;

export async function detectMonorepoRoot(startDir) {
  let dir = pathResolve(startDir);
  for (let depth = 0; depth < 15; depth++) {
    if (await fileExists(join(dir, 'pnpm-workspace.yaml'))) return dir;
    const pkg = await tryReadJson(join(dir, 'package.json'));
    if (pkg && (Array.isArray(pkg.workspaces) || Array.isArray(pkg.workspaces?.packages))) {
      return dir;
    }
    const parent = dirname(dir);
    if (parent === dir) return null;
    dir = parent;
  }
  return null;
}

// Zero-dependency — pnpm-workspace.yaml shape is predictable; not pulling in js-yaml.
export async function readWorkspaceGlobs(monorepoRoot) {
  const pnpmPath = join(monorepoRoot, 'pnpm-workspace.yaml');
  if (await fileExists(pnpmPath)) {
    const text = await readFile(pnpmPath, 'utf-8');
    return parsePnpmWorkspaceYaml(text);
  }
  const pkg = await tryReadJson(join(monorepoRoot, 'package.json'));
  if (Array.isArray(pkg?.workspaces)) return pkg.workspaces;
  if (Array.isArray(pkg?.workspaces?.packages)) return pkg.workspaces.packages;
  return [];
}

// Handles `packages:` block with `- glob` entries. Not full YAML grammar.
export function parsePnpmWorkspaceYaml(text) {
  const out = [];
  let inPackages = false;
  for (const rawLine of text.split('\n')) {
    const line = rawLine.replace(/#.*$/, '').trimEnd();
    if (!line.trim()) continue;
    if (/^packages\s*:/.test(line)) { inPackages = true; continue; }
    if (!inPackages) continue;
    if (!/^\s/.test(line)) { inPackages = false; continue; }
    const m = line.match(/^\s*-\s+['"]?([^'"\s]+)['"]?\s*$/);
    if (m) out.push(m[1]);
  }
  return out;
}

export async function listWorkspacePackages(monorepoRoot) {
  const globs = await readWorkspaceGlobs(monorepoRoot);
  const dirs = new Set();
  for (const g of globs) {
    const expanded = await expandWorkspaceGlob(monorepoRoot, g);
    for (const d of expanded) dirs.add(d);
  }
  const out = [];
  for (const dir of dirs) {
    const pkg = await tryReadJson(join(dir, 'package.json'));
    if (pkg?.name) out.push({ name: pkg.name, dir, pkg });
  }
  return out.sort((a, b) => a.name.localeCompare(b.name));
}

// Handles workspace-shape globs only. `**` collapses to one level — npm/pnpm don't document deep `**`.
async function expandWorkspaceGlob(root, glob) {
  const parts = glob.replace(/\\/g, '/').split('/');
  return await expandParts(root, parts);
}

async function expandParts(currentDir, parts) {
  if (parts.length === 0) return [currentDir];
  const [head, ...rest] = parts;
  if (head === '' || head === '.') return await expandParts(currentDir, rest);
  if (head === '*' || head === '**') {
    let entries = [];
    try {
      entries = await readdir(currentDir, { withFileTypes: true });
    } catch { return []; }
    const childDirs = entries.filter((e) => e.isDirectory()).map((e) => join(currentDir, e.name));
    const out = [];
    for (const d of childDirs) {
      const more = await expandParts(d, rest);
      out.push(...more);
    }
    return out;
  }
  const next = join(currentDir, head);
  try {
    const s = await stat(next);
    if (!s.isDirectory()) return [];
  } catch {
    return [];
  }
  return await expandParts(next, rest);
}

export function buildResolver(packages) {
  const byName = new Map();
  for (const p of packages) {
    byName.set(p.name, buildPackageLookup(p));
  }
  return function resolveSpecifier(specifier) {
    if (typeof specifier !== 'string' || !specifier.length) return null;
    // Longest-name match first so `@vercel/foo-bar` wins over `@vercel/foo`.
    const candidates = [...byName.keys()]
      .filter((name) => specifier === name || specifier.startsWith(name + '/'))
      .sort((a, b) => b.length - a.length);
    if (candidates.length === 0) return null;
    const pkgName = candidates[0];
    const subpath = specifier === pkgName ? '.' : './' + specifier.slice(pkgName.length + 1);
    const lookup = byName.get(pkgName);
    return lookup.resolveSubpath(subpath);
  };
}

// Node spec: pattern key has exactly one `*`; target may have one or zero.
function buildPackageLookup(p) {
  const exact = new Map();
  const wildcards = [];
  const exports = p.pkg.exports;
  if (exports && typeof exports === 'object' && !Array.isArray(exports)) {
    for (const [key, value] of Object.entries(exports)) {
      const target = pickConditionalTarget(value);
      if (typeof target !== 'string') continue;
      if (key.includes('*')) {
        const keyStarIdx = key.indexOf('*');
        if (keyStarIdx !== key.lastIndexOf('*')) continue;
        wildcards.push({
          keyPrefix: key.slice(0, keyStarIdx),
          keySuffix: key.slice(keyStarIdx + 1),
          valueTemplate: target,
        });
      } else {
        exact.set(key, target);
      }
    }
  }
  return {
    resolveSubpath(subpath) {
      const exactHit = exact.get(subpath);
      if (exactHit) return joinPackagePath(p.dir, exactHit);
      for (const w of wildcards) {
        if (subpath.startsWith(w.keyPrefix) && subpath.endsWith(w.keySuffix)) {
          const star = subpath.slice(w.keyPrefix.length, subpath.length - w.keySuffix.length);
          if (!star) continue;
          const target = w.valueTemplate.replace('*', star);
          return joinPackagePath(p.dir, target);
        }
      }
      // Unsafe to guess when no exports declared.
      if (exact.size === 0 && wildcards.length === 0 && subpath !== '.') {
        return null;
      }
      return null;
    },
  };
}

// Condition order matches what Next.js / Vite / esbuild would resolve.
function pickConditionalTarget(value) {
  if (typeof value === 'string') return value;
  if (Array.isArray(value)) {
    for (const item of value) {
      const target = pickConditionalTarget(item);
      if (typeof target === 'string') return target;
    }
    return null;
  }
  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
  for (const cond of ['default', 'import', 'node', 'browser', 'require', 'types']) {
    const v = value[cond];
    if (typeof v === 'string') return v;
  }
  return null;
}

export async function resolveWorkspaceImports(sourceFilePath, resolver, options = {}) {
  let text;
  try {
    text = await readFile(sourceFilePath, 'utf-8');
  } catch {
    return [];
  }
  const opts = { ...DEFAULT_RESOLVE_OPTIONS, ...options };
  const refs = extractModuleReferences(text);
  const out = [];
  const seen = new Set();
  for (const ref of refs) {
    const resolved = await resolveModuleSpecifier(sourceFilePath, ref.specifier, resolver);
    if (!resolved) continue;
    const expanded = await expandResolvedSpecifier(resolved, ref.importedNames, resolver, opts);
    for (const file of expanded) {
      if (seen.has(file)) continue;
      seen.add(file);
      out.push(file);
    }
  }
  return out;
}

// Skips CommonJS `require('foo')` and template-literal dynamic imports (statically unresolvable).
export function extractImportSpecifiers(text) {
  return [...new Set(extractModuleReferences(text).map((ref) => ref.specifier))];
}

function joinPackagePath(packageDir, relativeTarget) {
  return join(packageDir, relativeTarget.replace(/^\.\//, ''));
}

async function expandResolvedSpecifier(startFile, importedNames, resolver, opts) {
  const out = [];
  const seen = new Set();
  const barrelVisited = new Set();
  const fanoutVisited = new Set();

  const add = (file) => {
    if (seen.has(file)) return false;
    if (out.length > 0 && out.length - 1 >= opts.perSpecifierCap) return false;
    seen.add(file);
    out.push(file);
    return true;
  };

  add(startFile);
  await expandPureBarrel(startFile, importedNames, 0);
  const fanoutSeeds = out.slice();
  for (const file of fanoutSeeds) {
    await expandSuffixFanout(file, 0);
  }
  return out;

  async function expandPureBarrel(file, requestedNames, depth) {
    if (depth >= opts.pureBarrelDepth) return;
    if (barrelVisited.has(file)) return;
    barrelVisited.add(file);
    const text = await tryReadText(file);
    if (text == null || !isPureBarrel(text)) return;
    const refs = await selectRelevantForwards(file, extractExportForwardRefs(text), requestedNames, resolver);
    for (const { ref, next } of refs) {
      if (!add(next)) return;
      await expandPureBarrel(next, requestedNamesForForward(ref, requestedNames), depth + 1);
    }
  }

  async function expandSuffixFanout(file, depth) {
    if (depth >= opts.suffixFanoutDepth) return;
    if (!isSuffixFanoutFile(file)) return;
    const visitKey = `${file}:${depth}`;
    if (fanoutVisited.has(visitKey)) return;
    fanoutVisited.add(visitKey);
    const text = await tryReadText(file);
    if (text == null) return;
    for (const ref of extractModuleReferences(text)) {
      const next = await resolveModuleSpecifier(file, ref.specifier, resolver);
      if (!next) continue;
      if (!add(next)) return;
      if (isSuffixFanoutFile(next)) await expandSuffixFanout(next, depth + 1);
    }
  }
}

async function selectRelevantForwards(fromFile, refs, requestedNames, resolver) {
  const resolved = [];
  for (const [index, ref] of refs.entries()) {
    const next = await resolveModuleSpecifier(fromFile, ref.specifier, resolver);
    if (!next) continue;
    let score = requestedNames && requestedNames.size > 0
      ? forwardRelevanceScore(ref, requestedNames, refs.length)
      : 1;
    if (requestedNames && requestedNames.size > 0 && await fileExportsAnyName(next, requestedNames)) {
      score = Math.max(score, 75);
    }
    resolved.push({ ref, next, index, score });
  }
  if (!requestedNames || requestedNames.size === 0) return resolved;
  const ranked = resolved
    .filter((x) => x.score > 0)
    .sort((a, b) => b.score - a.score || a.index - b.index);
  return ranked.length > 0 ? ranked : resolved;
}

function forwardRelevanceScore(ref, requestedNames, siblingCount) {
  if (!requestedNames || requestedNames.size === 0) return 1;
  if (ref.exportedNames) {
    for (const name of requestedNames) {
      if (ref.exportedNames.has(name)) return 100;
    }
  }
  if (specifierMatchesNames(ref.specifier, requestedNames)) return 50;
  return siblingCount === 1 ? 1 : 0;
}

function requestedNamesForForward(ref, requestedNames) {
  if (!requestedNames || requestedNames.size === 0) return null;
  if (ref.star) return requestedNames;
  const out = new Set();
  for (const name of requestedNames) {
    const source = ref.sourceNamesByExported?.get(name);
    if (source) out.add(source);
  }
  return out.size > 0 ? out : requestedNames;
}

async function resolveModuleSpecifier(fromFile, specifier, resolver) {
  const raw = specifier.startsWith('.')
    ? join(dirname(fromFile), specifier)
    : resolver(specifier);
  if (!raw) return null;
  return await resolveExistingPath(raw);
}

async function resolveExistingPath(basePath) {
  for (const ext of EXTENSIONS) {
    const candidate = ext === '' ? basePath : basePath + ext;
    if (!isSourcePath(candidate)) continue;
    if (await isFile(candidate)) return candidate;
  }
  for (const indexFile of INDEX_FILES) {
    const candidate = join(basePath, indexFile);
    if (await isFile(candidate)) return candidate;
  }
  return null;
}

function extractModuleReferences(text) {
  return [
    ...extractImportReferences(text),
    ...extractExportForwardRefs(text).map((ref) => ({
      specifier: ref.specifier,
      importedNames: ref.star ? null : ref.exportedNames,
    })),
    ...extractDynamicImportReferences(text),
  ];
}

function extractImportReferences(text) {
  const out = [];
  const fromRe = /import\s+(?:type\s+)?([\s\S]*?)\s+from\s+['"]([^'"\n]+)['"]/g;
  let m;
  while ((m = fromRe.exec(text)) !== null) {
    out.push({ specifier: m[2], importedNames: parseImportNames(m[1]) });
  }
  const sideEffectRe = /import\s+['"]([^'"\n]+)['"]/g;
  while ((m = sideEffectRe.exec(text)) !== null) {
    out.push({ specifier: m[1], importedNames: null });
  }
  return out;
}

function extractDynamicImportReferences(text) {
  const out = [];
  const re = /import\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g;
  let m;
  while ((m = re.exec(text)) !== null) {
    out.push({ specifier: m[1], importedNames: null });
  }
  return out;
}

function extractExportForwardRefs(text) {
  const out = [];
  const re = /export\s+(?:type\s+)?(\*|\*\s+as\s+[A-Za-z_$][\w$]*|\{[^}]*\})\s+from\s+['"]([^'"\n]+)['"]\s*;?/g;
  let m;
  while ((m = re.exec(text)) !== null) {
    const clause = m[1].trim();
    const star = clause.startsWith('*');
    const names = star ? null : parseExportNames(clause);
    out.push({
      specifier: m[2],
      star,
      exportedNames: names?.exportedNames ?? null,
      sourceNamesByExported: names?.sourceNamesByExported ?? null,
    });
  }
  return out;
}

function parseImportNames(clause) {
  const names = new Set();
  const trimmed = clause.trim();
  if (!trimmed) return null;
  const named = /\{([^}]+)\}/s.exec(trimmed);
  if (named) {
    for (const part of splitImportList(named[1])) {
      const cleaned = part.replace(/^type\s+/, '').trim();
      if (!cleaned) continue;
      const [source] = cleaned.split(/\s+as\s+/i);
      if (source?.trim()) names.add(source.trim());
    }
  }
  const withoutNamed = trimmed.replace(/\{[^}]*\}/s, '').replace(/,\s*$/, '').trim();
  if (withoutNamed && !withoutNamed.startsWith('*')) names.add('default');
  return names.size > 0 ? names : null;
}

function parseExportNames(clause) {
  const body = clause.replace(/^\{|\}$/g, '');
  const exportedNames = new Set();
  const sourceNamesByExported = new Map();
  for (const part of splitImportList(body)) {
    const cleaned = part.replace(/^type\s+/, '').trim();
    if (!cleaned) continue;
    const [sourceRaw, exportedRaw] = cleaned.split(/\s+as\s+/i);
    const source = sourceRaw.trim();
    const exported = (exportedRaw ?? sourceRaw).trim();
    if (!source || !exported) continue;
    exportedNames.add(exported);
    sourceNamesByExported.set(exported, source);
  }
  return { exportedNames, sourceNamesByExported };
}

function splitImportList(value) {
  return value.split(',').map((part) => part.trim()).filter(Boolean);
}

function isPureBarrel(text) {
  const refs = extractExportForwardRefs(text);
  if (refs.length === 0) return false;
  const withoutComments = text
    .replace(/\/\*[\s\S]*?\*\//g, '')
    .replace(/^\s*\/\/.*$/gm, '');
  return withoutComments.replace(EXPORT_FORWARD_RE, '').trim() === '';
}

function specifierMatchesNames(specifier, names) {
  const normalizedSpecifier = normalizeName(specifier.split('/').at(-1) ?? specifier);
  for (const name of names) {
    const normalizedName = normalizeName(name);
    if (normalizedSpecifier === normalizedName || normalizedSpecifier.endsWith(normalizedName)) {
      return true;
    }
  }
  return false;
}

function normalizeName(value) {
  return String(value ?? '').toLowerCase().replace(/[^a-z0-9]/g, '');
}

function isSuffixFanoutFile(file) {
  return SUFFIX_FANOUT_RE.test(file.replace(/\\/g, '/'));
}

async function fileExportsAnyName(file, names) {
  const text = await tryReadText(file);
  if (text == null) return false;
  for (const name of names) {
    if (textExportsName(text, name)) return true;
  }
  return false;
}

function textExportsName(text, name) {
  const escaped = escapeRegExp(name);
  const declaration = new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var|class|interface|type)\\s+${escaped}\\b`);
  if (declaration.test(text)) return true;
  const listRe = /export\s+\{([^}]+)\}(?!\s+from\b)/gs;
  let m;
  while ((m = listRe.exec(text)) !== null) {
    const names = parseExportNames(`{${m[1]}}`).exportedNames;
    if (names.has(name)) return true;
  }
  return false;
}

function isSourcePath(path) {
  const match = /\.([A-Za-z0-9]+)$/.exec(path);
  if (!match) return true;
  return SOURCE_EXTENSIONS.has('.' + match[1]);
}

function escapeRegExp(value) {
  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

async function tryReadText(path) {
  try {
    return await readFile(path, 'utf-8');
  } catch {
    return null;
  }
}

async function fileExists(p) {
  try { await stat(p); return true; } catch { return false; }
}

async function isFile(p) {
  try {
    const s = await stat(p);
    return s.isFile();
  } catch {
    return false;
  }
}

async function tryReadJson(path) {
  try {
    const text = await readFile(path, 'utf-8');
    return JSON.parse(text);
  } catch {
    return null;
  }
}
writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall