@astryxdesign/cli 0.0.0-bootstrap.0 → 0.0.15

package/src/utils/package-manager.mjs

@@ -0,0 +1,74 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Detect the project's package manager from lockfiles.
+ *
+ * Returns the correct command prefix for running package binaries
+ * (e.g. 'npx xds', 'yarn xds', 'pnpm exec xds').
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/**
+ * Detect the package manager used in a project directory.
+ * Walks up from targetDir looking for lockfiles.
+ *
+ * @param {string} [targetDir=process.cwd()]
+ * @returns {'yarn'|'pnpm'|'bun'|'npm'}
+ */
+export function detectPackageManager(targetDir = process.cwd()) {
+  const KNOWN_PMS = new Set(['yarn', 'pnpm', 'bun', 'npm']);
+  let dir = path.resolve(targetDir);
+  const root = path.parse(dir).root;
+
+  while (dir !== root) {
+    // 1. Lockfiles (highest priority)
+    if (fs.existsSync(path.join(dir, 'yarn.lock'))) return 'yarn';
+    if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock'))) return 'bun';
+    if (fs.existsSync(path.join(dir, 'package-lock.json'))) return 'npm';
+
+    // 2. packageManager field in package.json
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg.packageManager) {
+          const name = pkg.packageManager.split('@')[0];
+          if (KNOWN_PMS.has(name)) return name;
+        }
+      } catch {
+        // Best-effort: unreadable/invalid package.json — keep walking up.
+      }
+    }
+
+    dir = path.dirname(dir);
+  }
+
+  // 3. npm_config_user_agent env var (set by all PMs when running scripts)
+  const ua = process.env.npm_config_user_agent;
+  if (ua) {
+    const name = ua.split('/')[0];
+    if (KNOWN_PMS.has(name)) return name;
+  }
+
+  return 'npx';
+}
+
+/**
+ * Get the command prefix for running a package binary.
+ *
+ * @param {string} [targetDir]
+ * @returns {string} e.g. 'npx', 'yarn', 'pnpm exec', 'bunx'
+ */
+export function getRunPrefix(targetDir) {
+  const pm = detectPackageManager(targetDir);
+  switch (pm) {
+    case 'yarn': return 'yarn';
+    case 'pnpm': return 'pnpm exec';
+    case 'bun': return 'bunx';
+    case 'npm':
+    default: return 'npx';
+  }
+}

package/src/utils/package-manager.test.mjs

@@ -0,0 +1,113 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect, afterEach, vi} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {detectPackageManager} from './package-manager.mjs';
+
+let tmpDir;
+
+afterEach(() => {
+  if (tmpDir) {
+    fs.rmSync(tmpDir, {recursive: true, force: true});
+    tmpDir = null;
+  }
+  vi.restoreAllMocks();
+  delete process.env.npm_config_user_agent;
+});
+
+function makeTmpDir() {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xds-pm-test-'));
+  return tmpDir;
+}
+
+describe('detectPackageManager', () => {
+  it('detects yarn from yarn.lock', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(path.join(dir, 'yarn.lock'), '');
+    expect(detectPackageManager(dir)).toBe('yarn');
+  });
+
+  it('detects pnpm from pnpm-lock.yaml', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(path.join(dir, 'pnpm-lock.yaml'), '');
+    expect(detectPackageManager(dir)).toBe('pnpm');
+  });
+
+  it('detects npm from package-lock.json', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(path.join(dir, 'package-lock.json'), '{}');
+    expect(detectPackageManager(dir)).toBe('npm');
+  });
+
+  it('detects bun from bun.lockb', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(path.join(dir, 'bun.lockb'), '');
+    expect(detectPackageManager(dir)).toBe('bun');
+  });
+
+  it('detects from packageManager field in package.json (no lockfile)', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({packageManager: 'yarn@4.1.0'}),
+    );
+    expect(detectPackageManager(dir)).toBe('yarn');
+  });
+
+  it('detects pnpm from packageManager field', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({packageManager: 'pnpm@8.0.0'}),
+    );
+    expect(detectPackageManager(dir)).toBe('pnpm');
+  });
+
+  it('ignores unknown packageManager values', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({packageManager: 'unknown@1.0.0'}),
+    );
+    expect(detectPackageManager(dir)).toBe('npx');
+  });
+
+  it('lockfile takes priority over packageManager field', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(path.join(dir, 'yarn.lock'), '');
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({packageManager: 'pnpm@8.0.0'}),
+    );
+    expect(detectPackageManager(dir)).toBe('yarn');
+  });
+
+  it('detects from npm_config_user_agent env var', () => {
+    const dir = makeTmpDir();
+    process.env.npm_config_user_agent = 'yarn/1.22.22 node/v20.0.0';
+    expect(detectPackageManager(dir)).toBe('yarn');
+  });
+
+  it('detects pnpm from npm_config_user_agent env var', () => {
+    const dir = makeTmpDir();
+    process.env.npm_config_user_agent = 'pnpm/8.15.0 node/v20.0.0';
+    expect(detectPackageManager(dir)).toBe('pnpm');
+  });
+
+  it('falls back to npx when no signals present', () => {
+    const dir = makeTmpDir();
+    expect(detectPackageManager(dir)).toBe('npx');
+  });
+
+  it('packageManager field takes priority over npm_config_user_agent', () => {
+    const dir = makeTmpDir();
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({packageManager: 'bun@1.0.0'}),
+    );
+    process.env.npm_config_user_agent = 'npm/10.0.0 node/v20.0.0';
+    expect(detectPackageManager(dir)).toBe('bun');
+  });
+});

package/src/utils/path-safety.mjs

@@ -0,0 +1,185 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Path safety helpers.
+ *
+ * Centralizes path-traversal defenses, name sanitization, and
+ * file-vs-directory detection used by CLI commands that write to
+ * user-controlled output paths.
+ *
+ * Commands should use these helpers instead of constructing paths
+ * directly with `path.resolve` / `path.join`, which silently re-root
+ * absolute paths or allow traversal via `..`.
+ */
+
+import * as path from 'node:path';
+
+/**
+ * Error thrown by path-safety guards. Carries a stable `code`
+ * so callers (CLI handlers) can render a friendly message and
+ * exit cleanly without leaking stack traces.
+ */
+export class PathSafetyError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} code
+   */
+  constructor(message, code = 'PATH_UNSAFE') {
+    super(message);
+    this.name = 'PathSafetyError';
+    this.code = code;
+  }
+}
+
+/**
+ * Resolve `targetPath` (relative to `rootDir`) and assert that the
+ * result stays inside `rootDir`. Rejects:
+ *
+ *   - Absolute paths (e.g. `/tmp/x`) — re-rooted by `path.join` is silent;
+ *     better to fail loudly. Pass `{allowAbsolute: true}` to opt in.
+ *   - Paths that escape via `..` segments.
+ *
+ * Returns the resolved absolute path on success.
+ *
+ * @param {string} targetPath - User-provided path (relative or absolute).
+ * @param {string} rootDir - Absolute path of the directory to constrain into.
+ * @param {object} [options]
+ * @param {boolean} [options.allowAbsolute=false] - If true, absolute paths
+ *   are accepted *as long as* they resolve inside `rootDir`.
+ * @param {string} [options.label='path'] - Human-readable name of the arg
+ *   being checked (used in error messages, e.g. 'output directory').
+ * @returns {string} Absolute resolved path inside `rootDir`.
+ * @throws {PathSafetyError}
+ */
+export function assertWithin(targetPath, rootDir, options = {}) {
+  const {allowAbsolute = false, label = 'path'} = options;
+
+  if (typeof targetPath !== 'string' || targetPath.length === 0) {
+    throw new PathSafetyError(`Invalid ${label}: must be a non-empty string`, 'PATH_INVALID');
+  }
+
+  if (path.isAbsolute(targetPath) && !allowAbsolute) {
+    throw new PathSafetyError(
+      `Invalid ${label} "${targetPath}": absolute paths are not allowed. ` +
+        `Use a path relative to the project root.`,
+      'PATH_ABSOLUTE',
+    );
+  }
+
+  const absRoot = path.resolve(rootDir);
+  const resolved = path.resolve(absRoot, targetPath);
+
+  // Canonicalize for the "is inside" comparison. Use normalized paths
+  // with a trailing separator so /root/foo doesn't match /rootbar.
+  const rootWithSep = absRoot.endsWith(path.sep) ? absRoot : absRoot + path.sep;
+  if (resolved !== absRoot && !resolved.startsWith(rootWithSep)) {
+    throw new PathSafetyError(
+      `Invalid ${label} "${targetPath}": resolves outside the project root ` +
+        `(${absRoot}). Path traversal is not allowed.`,
+      'PATH_TRAVERSAL',
+    );
+  }
+
+  return resolved;
+}
+
+/**
+ * Validate a "name" argument (e.g. theme name, component name) that will
+ * be embedded in a generated filename. Rejects names containing path
+ * separators, parent-segment markers, NUL bytes, leading dots, or any
+ * character outside a conservative allow-list.
+ *
+ * Use this at the entry point of any command whose name arg flows into
+ * `path.join(outDir, name + '.css')` etc.
+ *
+ * @param {string} name
+ * @param {object} [options]
+ * @param {string} [options.label='name']
+ * @returns {string} The name (unchanged on success).
+ * @throws {PathSafetyError}
+ */
+export function sanitizeName(name, options = {}) {
+  const {label = 'name'} = options;
+
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new PathSafetyError(`Invalid ${label}: must be a non-empty string`, 'NAME_INVALID');
+  }
+
+  if (name.includes('\0')) {
+    throw new PathSafetyError(`Invalid ${label}: contains a NUL byte`, 'NAME_INVALID');
+  }
+
+  // Reject any path-segment characters. We don't try to rewrite — silent
+  // sanitization hides intent. Fail loudly with a clear hint instead.
+  if (/[\\/]/.test(name)) {
+    throw new PathSafetyError(
+      `Invalid ${label} "${name}": must not contain path separators ('/' or '\\\\').`,
+      'NAME_HAS_SEPARATOR',
+    );
+  }
+
+  if (name === '.' || name === '..' || name.startsWith('..')) {
+    throw new PathSafetyError(
+      `Invalid ${label} "${name}": must not be '.' or start with '..'.`,
+      'NAME_TRAVERSAL',
+    );
+  }
+
+  // Conservative allow-list: alphanumerics, dot, underscore, hyphen.
+  // Theme/component names in this codebase already conform to this.
+  if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+    throw new PathSafetyError(
+      `Invalid ${label} "${name}": only letters, digits, '.', '_', and '-' are allowed.`,
+      'NAME_BAD_CHARS',
+    );
+  }
+
+  return name;
+}
+
+const FILE_EXTENSIONS = new Set([
+  '.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs',
+  '.css', '.scss', '.json', '.md', '.html',
+]);
+
+/**
+ * Heuristic: does this CLI argument look like a file path (vs a directory)?
+ *
+ * Used by `astryx template <name> <path>` so that
+ *   `astryx template blank ./foo.tsx`
+ * writes to `./foo.tsx` as a file, not `./foo.tsx/page.tsx` (the old bug).
+ *
+ * Returns true when the basename has a known source/asset extension.
+ * Conservative on purpose — unknown extensions still fall through to the
+ * directory branch, matching pre-existing behavior for things like
+ * `./out` or `./src/pages`.
+ *
+ * @param {string} pathArg
+ * @returns {boolean}
+ */
+export function isFilePathArg(pathArg) {
+  if (typeof pathArg !== 'string' || pathArg.length === 0) return false;
+  // Trailing slash → explicit directory.
+  if (/[\\/]$/.test(pathArg)) return false;
+  const base = path.basename(pathArg);
+  const ext = path.extname(base).toLowerCase();
+  return ext.length > 0 && FILE_EXTENSIONS.has(ext);
+}
+
+/**
+ * True when the process is running non-interactively (no TTY) or when the
+ * caller has signaled JSON / scripted use. Commands consult this before
+ * prompting for confirmation; in scripted mode they require an explicit
+ * `--overwrite` flag instead.
+ *
+ * @param {object} [options]
+ * @param {boolean} [options.json] - Caller's --json flag.
+ * @returns {boolean}
+ */
+export function isNonInteractive({json = false} = {}) {
+  if (json) return true;
+  // stdin not a TTY means piped input or scripted execution.
+  if (process.stdin && process.stdin.isTTY === false) return true;
+  if (process.stdout && process.stdout.isTTY === false) return true;
+  return false;
+}

package/src/utils/path-safety.test.mjs

@@ -0,0 +1,137 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  assertWithin,
+  sanitizeName,
+  isFilePathArg,
+  PathSafetyError,
+} from './path-safety.mjs';
+
+let tmpDir;
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xds-path-safety-'));
+});
+afterEach(() => {
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+describe('assertWithin', () => {
+  it('accepts a relative path that stays inside root', () => {
+    const result = assertWithin('subdir/file.txt', tmpDir);
+    expect(result).toBe(path.join(tmpDir, 'subdir', 'file.txt'));
+  });
+
+  it('accepts the root itself', () => {
+    expect(assertWithin('.', tmpDir)).toBe(path.resolve(tmpDir));
+  });
+
+  it('rejects ../ traversal', () => {
+    expect(() => assertWithin('../escaped', tmpDir)).toThrow(PathSafetyError);
+    expect(() => assertWithin('../escaped', tmpDir)).toThrow(/traversal|outside/i);
+  });
+
+  it('rejects deep ../../ traversal', () => {
+    expect(() => assertWithin('a/b/../../../c', tmpDir)).toThrow(PathSafetyError);
+  });
+
+  it('rejects absolute paths by default', () => {
+    expect(() => assertWithin('/tmp/elsewhere', tmpDir)).toThrow(/absolute paths are not allowed/i);
+  });
+
+  it('accepts absolute paths inside root when allowAbsolute', () => {
+    const inside = path.join(tmpDir, 'x.txt');
+    expect(assertWithin(inside, tmpDir, {allowAbsolute: true})).toBe(inside);
+  });
+
+  it('rejects absolute paths outside root even when allowAbsolute', () => {
+    expect(() =>
+      assertWithin('/etc/passwd', tmpDir, {allowAbsolute: true}),
+    ).toThrow(PathSafetyError);
+  });
+
+  it('does not match sibling-prefix paths', () => {
+    // /tmp/foo should not be accepted as inside /tmp/foobar
+    const root = path.join(tmpDir, 'foo');
+    fs.mkdirSync(root);
+    expect(() => assertWithin('../foobar/x', root)).toThrow(PathSafetyError);
+  });
+
+  it('rejects empty / non-string input', () => {
+    expect(() => assertWithin('', tmpDir)).toThrow(/non-empty/i);
+    expect(() => assertWithin(null, tmpDir)).toThrow();
+  });
+});
+
+describe('sanitizeName', () => {
+  it('accepts simple names', () => {
+    expect(sanitizeName('button')).toBe('button');
+    expect(sanitizeName('Default-Theme_2')).toBe('Default-Theme_2');
+    expect(sanitizeName('theme.v1')).toBe('theme.v1');
+  });
+
+  it('rejects names with /', () => {
+    expect(() => sanitizeName('foo/bar')).toThrow(PathSafetyError);
+    expect(() => sanitizeName('foo/bar')).toThrow(/path separator/i);
+  });
+
+  it('rejects names with \\', () => {
+    expect(() => sanitizeName('foo\\bar')).toThrow(PathSafetyError);
+  });
+
+  it('rejects ..', () => {
+    expect(() => sanitizeName('..')).toThrow(PathSafetyError);
+    expect(() => sanitizeName('../escaped')).toThrow(PathSafetyError);
+  });
+
+  it('rejects . and leading dots that look traversal-y', () => {
+    expect(() => sanitizeName('.')).toThrow(PathSafetyError);
+  });
+
+  it('rejects NUL bytes', () => {
+    expect(() => sanitizeName('foo\0bar')).toThrow(PathSafetyError);
+  });
+
+  it('rejects empty/non-string', () => {
+    expect(() => sanitizeName('')).toThrow(PathSafetyError);
+    expect(() => sanitizeName(null)).toThrow(PathSafetyError);
+  });
+
+  it('rejects characters outside the allow-list', () => {
+    expect(() => sanitizeName('foo bar')).toThrow(PathSafetyError);
+    expect(() => sanitizeName('foo$bar')).toThrow(PathSafetyError);
+  });
+});
+
+describe('isFilePathArg', () => {
+  it('returns true for known source extensions', () => {
+    expect(isFilePathArg('foo.tsx')).toBe(true);
+    expect(isFilePathArg('./foo.tsx')).toBe(true);
+    expect(isFilePathArg('./src/page.jsx')).toBe(true);
+    expect(isFilePathArg('out.js')).toBe(true);
+    expect(isFilePathArg('out.mjs')).toBe(true);
+    expect(isFilePathArg('out.css')).toBe(true);
+  });
+
+  it('returns false for plain directory names', () => {
+    expect(isFilePathArg('out')).toBe(false);
+    expect(isFilePathArg('./components/astryx')).toBe(false);
+    expect(isFilePathArg('src/pages')).toBe(false);
+  });
+
+  it('returns false for trailing slash even with extension-like name', () => {
+    expect(isFilePathArg('foo.tsx/')).toBe(false);
+  });
+
+  it('returns false for unknown extensions', () => {
+    expect(isFilePathArg('archive.zip')).toBe(false);
+  });
+
+  it('returns false for empty/invalid', () => {
+    expect(isFilePathArg('')).toBe(false);
+    expect(isFilePathArg(null)).toBe(false);
+  });
+});

package/src/utils/paths.mjs

@@ -0,0 +1,159 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Path resolution utilities for Astryx CLI
+ *
+ * Finds packages/core, project root, and CLI package root.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Root of the @astryxdesign/cli package */
+export const CLI_ROOT = path.resolve(__dirname, '..', '..');
+
+/**
+ * Find packages/core directory by walking up from startDir.
+ * Also checks node_modules/@astryxdesign/core for installed usage.
+ */
+export function findCoreDir(startDir = process.cwd()) {
+  let dir = startDir;
+
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'packages', 'core');
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+
+    const nodeModules = path.join(dir, 'node_modules', '@astryxdesign', 'core');
+    if (fs.existsSync(nodeModules)) {
+      return nodeModules;
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Find the monorepo root by looking for the root package.json
+ * that has workspaces defined.
+ */
+export function findProjectRoot(startDir = process.cwd()) {
+  let dir = startDir;
+
+  for (let i = 0; i < 5; i++) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg.workspaces) {
+          return dir;
+        }
+      } catch {
+        // skip invalid JSON
+      }
+    }
+
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return null;
+}
+
+/**
+ * Discover external Astryx-compatible packages from node_modules.
+ * Scans for packages with an "astryx" field in their package.json:
+ *
+ *   { "astryx": { "docs": "./src", "category": "Common", "blocks": "./blocks/components" } }
+ *
+ * Returns array of { name, category, docsDir, blocksDir }.
+ */
+export function discoverExternalPackages(startDir = process.cwd()) {
+  const externals = [];
+  let dir = startDir;
+
+  // Walk up to find node_modules
+  let nodeModulesDir = null;
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'node_modules');
+    if (fs.existsSync(candidate)) {
+      nodeModulesDir = candidate;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  if (!nodeModulesDir) return externals;
+
+  const scanDir = (searchDir) => {
+    if (!fs.existsSync(searchDir)) return;
+    const entries = fs.readdirSync(searchDir, {withFileTypes: true});
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') || entry.name === '.bin') continue;
+
+      const fullPath = path.join(searchDir, entry.name);
+
+      // Recurse into scoped packages (@org/*)
+      if (entry.name.startsWith('@')) {
+        scanDir(fullPath);
+        continue;
+      }
+
+      const pkgJsonPath = path.join(fullPath, 'package.json');
+      if (!fs.existsSync(pkgJsonPath)) continue;
+
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        if (pkg.name === '@astryxdesign/core') continue;
+        if (pkg.astryx && pkg.astryx.docs) {
+          externals.push({
+            name: pkg.name,
+            category: pkg.astryx.category || pkg.name,
+            docsDir: path.resolve(fullPath, pkg.astryx.docs),
+            blocksDir: pkg.astryx.blocks
+              ? path.resolve(fullPath, pkg.astryx.blocks)
+              : null,
+          });
+        }
+      } catch {
+        // skip invalid JSON
+      }
+    }
+  };
+
+  scanDir(nodeModulesDir);
+  return externals;
+}
+
+/**
+ * List available component directories in packages/core/src.
+ * Returns directory names that contain Astryx*.tsx files.
+ */
+export function listComponents(coreDir) {
+  const srcDir = path.join(coreDir, 'src');
+  if (!fs.existsSync(srcDir)) return [];
+
+  const entries = fs.readdirSync(srcDir, {withFileTypes: true});
+  return entries
+    .filter(e => {
+      if (!e.isDirectory()) return false;
+      // Skip non-component dirs
+      if (['hooks', 'theme', 'utils'].includes(e.name)) return false;
+      return true;
+    })
+    .map(e => e.name)
+    .sort();
+}