@svgicons-com/cli 0.1.0-alpha.1

package/src/project.js

@@ -0,0 +1,270 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { sanitizeFileSegment } from './downloads.js';
+
+export const DEFAULT_MANIFEST = 'svgicons.json';
+export const DEFAULT_LOCKFILE = 'svgicons.lock';
+export const DEFAULT_OUTPUT_DIR = 'svgicons-icons';
+
+export function manifestPath(options = {}, cwd = process.cwd()) {
+  return resolve(cwd, String(options.manifest || DEFAULT_MANIFEST));
+}
+
+export function lockfilePath(options = {}, cwd = process.cwd()) {
+  return resolve(cwd, String(options.lockfile || DEFAULT_LOCKFILE));
+}
+
+export function createManifest(options = {}) {
+  const collection = options.collection && options.collection !== true
+    ? String(options.collection)
+    : '';
+
+  return {
+    version: 1,
+    framework: String(options.framework || 'svg'),
+    format: String(options.format || 'svg'),
+    output: String(options.output || DEFAULT_OUTPUT_DIR),
+    icons: [],
+    collections: collection ? [{ ref: collection }] : [],
+    licensePolicy: {
+      allow: [],
+      deny: [],
+    },
+  };
+}
+
+export async function readJsonFile(path) {
+  const raw = await readFile(path, 'utf8');
+  return JSON.parse(raw);
+}
+
+export async function writeJsonFile(path, value, { force = true } = {}) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${stableStringify(value)}\n`, {
+    flag: force ? 'w' : 'wx',
+  });
+}
+
+export async function writeTextFile(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, value.endsWith('\n') ? value : `${value}\n`, 'utf8');
+}
+
+export function normalizeManifest(manifest) {
+  return {
+    version: 1,
+    framework: manifest.framework || 'svg',
+    format: manifest.format || 'svg',
+    output: manifest.output || DEFAULT_OUTPUT_DIR,
+    icons: Array.isArray(manifest.icons) ? manifest.icons : [],
+    collections: Array.isArray(manifest.collections) ? manifest.collections : [],
+    licensePolicy: {
+      allow: Array.isArray(manifest.licensePolicy?.allow) ? manifest.licensePolicy.allow : [],
+      deny: Array.isArray(manifest.licensePolicy?.deny) ? manifest.licensePolicy.deny : [],
+    },
+  };
+}
+
+export function normalizeIconManifestEntry(entry) {
+  if (typeof entry === 'string' || typeof entry === 'number') {
+    return { ref: String(entry) };
+  }
+
+  return {
+    ref: String(entry?.ref || entry?.id || '').trim(),
+  };
+}
+
+export function normalizeCollectionManifestEntry(entry) {
+  if (typeof entry === 'string' || typeof entry === 'number') {
+    return { ref: String(entry) };
+  }
+
+  return {
+    ref: String(entry?.ref || entry?.id || entry?.slug || entry?.name || '').trim(),
+  };
+}
+
+export function lockIconFromIcon(icon) {
+  const svg = icon.svg || icon.body || '';
+  const iconSet = icon.iconSet || {};
+  const ref = `${Number(icon.id)}-${sanitizeFileSegment(icon.name || 'icon')}`;
+
+  return {
+    id: Number(icon.id),
+    name: String(icon.name || ''),
+    ref,
+    width: Number(icon.width || 0) || null,
+    height: Number(icon.height || 0) || null,
+    pageUrl: icon.pageUrl || null,
+    svgHash: svg ? `sha256-${sha256(svg)}` : null,
+    license: iconSet.license || 'Unknown license',
+    licenseUrl: iconSet.licenseUrl || iconSet.license_url || null,
+    iconSet: {
+      id: iconSet.id || icon.icon_set_id || null,
+      name: iconSet.name || null,
+      prefix: iconSet.prefix || null,
+    },
+    svg,
+  };
+}
+
+export function createLockfile(icons, manifest = {}) {
+  const deduped = new Map();
+
+  for (const icon of icons) {
+    const locked = lockIconFromIcon(icon);
+    if (locked.id) {
+      deduped.set(locked.id, locked);
+    }
+  }
+
+  return {
+    version: 1,
+    source: {
+      manifestVersion: manifest.version || 1,
+      framework: manifest.framework || 'svg',
+      format: manifest.format || 'svg',
+      output: manifest.output || DEFAULT_OUTPUT_DIR,
+    },
+    icons: [...deduped.values()].sort((a, b) => a.id - b.id),
+  };
+}
+
+export function svgFilenameForIcon(icon) {
+  return `${icon.ref || `${icon.id}-${sanitizeFileSegment(icon.name || 'icon')}`}.svg`;
+}
+
+export function buildLicenseReport(lockfile, policy = {}) {
+  const allow = normalizeLicenseList(policy.allow);
+  const deny = normalizeLicenseList(policy.deny);
+  const licenses = new Map();
+  const violations = [];
+
+  for (const icon of lockfile.icons || []) {
+    const license = icon.license || 'Unknown license';
+    const normalized = normalizeLicense(license);
+    const current = licenses.get(normalized) || {
+      license,
+      count: 0,
+      icons: [],
+    };
+
+    current.count += 1;
+    current.icons.push({
+      id: icon.id,
+      name: icon.name,
+      ref: icon.ref,
+      iconSet: icon.iconSet?.name || icon.iconSet?.prefix || '',
+    });
+    licenses.set(normalized, current);
+
+    if (deny.has(normalized)) {
+      violations.push({ reason: 'denied', license, icon });
+      continue;
+    }
+
+    if (allow.size > 0 && !allow.has(normalized)) {
+      violations.push({ reason: 'not_allowed', license, icon });
+    }
+  }
+
+  return {
+    ok: violations.length === 0,
+    checkedIcons: (lockfile.icons || []).length,
+    licenses: [...licenses.values()].sort((a, b) => a.license.localeCompare(b.license)),
+    violations: violations.map(({ reason, license, icon }) => ({
+      reason,
+      license,
+      icon: {
+        id: icon.id,
+        name: icon.name,
+        ref: icon.ref,
+        iconSet: icon.iconSet,
+      },
+    })),
+  };
+}
+
+export function licenseReportToMarkdown(report) {
+  const lines = [
+    '# Third-party SVG icons',
+    '',
+    `Checked icons: ${report.checkedIcons}`,
+    '',
+    '## Licenses',
+    '',
+    '| License | Icons |',
+    '| --- | ---: |',
+  ];
+
+  for (const item of report.licenses) {
+    lines.push(`| ${escapeMarkdownCell(item.license)} | ${item.count} |`);
+  }
+
+  if (report.violations.length > 0) {
+    lines.push('', '## Policy violations', '');
+    for (const violation of report.violations) {
+      lines.push(`- ${violation.icon.ref}: ${violation.license} (${violation.reason})`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+export function licenseReportToCsv(report) {
+  const rows = [['license', 'icons']];
+  for (const item of report.licenses) {
+    rows.push([item.license, String(item.count)]);
+  }
+
+  return `${rows.map((row) => row.map(csvCell).join(',')).join('\n')}\n`;
+}
+
+export function stableStringify(value) {
+  return JSON.stringify(sortForJson(value), null, 2);
+}
+
+export function sha256(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
+function sortForJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortForJson);
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  return Object.keys(value)
+    .sort()
+    .reduce((result, key) => {
+      result[key] = sortForJson(value[key]);
+      return result;
+    }, {});
+}
+
+function normalizeLicenseList(values = []) {
+  return new Set(
+    values
+      .flatMap((value) => String(value || '').split(','))
+      .map((value) => normalizeLicense(value))
+      .filter(Boolean),
+  );
+}
+
+function normalizeLicense(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function escapeMarkdownCell(value) {
+  return String(value || '').replace(/\|/g, '\\|');
+}
+
+function csvCell(value) {
+  const text = String(value ?? '');
+  return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}

package/src/redact.js

@@ -0,0 +1,43 @@
+const SECRET_KEY_PATTERN = /(token|secret|password|authorization|api[_-]?key|bearer)/i;
+const BEARER_PATTERN = /Bearer\s+[A-Za-z0-9._~+/=-]+/gi;
+const TOKEN_LIKE_PATTERN = /\b(?:sk|pk|whsec|svgicons)_[A-Za-z0-9._~+/=-]{12,}\b/g;
+
+export const REDACTED = '[redacted]';
+
+export function redact(value) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    return redactString(value);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => redact(item));
+  }
+
+  if (typeof value === 'object') {
+    return redactObject(value);
+  }
+
+  return value;
+}
+
+export function redactObject(value) {
+  const output = {};
+
+  for (const [key, item] of Object.entries(value || {})) {
+    output[key] = SECRET_KEY_PATTERN.test(key) && item
+      ? REDACTED
+      : redact(item);
+  }
+
+  return output;
+}
+
+export function redactString(value) {
+  return String(value)
+    .replace(BEARER_PATTERN, `Bearer ${REDACTED}`)
+    .replace(TOKEN_LIKE_PATTERN, REDACTED);
+}

package/src/scanner.js

@@ -0,0 +1,247 @@
+import { opendir, readFile, stat } from 'node:fs/promises';
+import { basename, extname, join, resolve, sep } from 'node:path';
+
+const DEFAULT_EXTENSIONS = new Set([
+  '.astro',
+  '.blade.php',
+  '.css',
+  '.html',
+  '.js',
+  '.jsx',
+  '.md',
+  '.scss',
+  '.svelte',
+  '.ts',
+  '.tsx',
+  '.vue',
+]);
+
+const EXCLUDED_DIRS = new Set([
+  '.git',
+  '.next',
+  '.nuxt',
+  '.output',
+  '.turbo',
+  'build',
+  'coverage',
+  'dist',
+  'node_modules',
+  'public/build',
+  'storage',
+  'vendor',
+]);
+
+const CONCEPT_PATTERNS = {
+  account: ['account', 'profile', 'avatar'],
+  analytics: ['analytics', 'chart', 'graph', 'metric', 'report'],
+  auth: ['auth', 'login', 'logout', 'password', 'sign in', 'signin'],
+  billing: ['billing', 'invoice', 'payment', 'pricing', 'subscription'],
+  calendar: ['calendar', 'date', 'schedule'],
+  check: ['check', 'success', 'complete', 'done'],
+  close: ['close', 'cancel', 'dismiss', 'remove'],
+  dashboard: ['dashboard', 'admin', 'overview'],
+  download: ['download', 'export'],
+  edit: ['edit', 'pencil', 'compose'],
+  file: ['file', 'document', 'attachment'],
+  home: ['home', 'landing'],
+  lock: ['lock', 'security', 'permission', 'private'],
+  mail: ['mail', 'email', 'inbox'],
+  menu: ['menu', 'navigation', 'navbar', 'sidebar'],
+  notification: ['notification', 'alert', 'bell', 'warning'],
+  search: ['search', 'filter', 'find'],
+  settings: ['settings', 'preferences', 'config', 'gear'],
+  trash: ['trash', 'delete', 'remove'],
+  upload: ['upload', 'import'],
+  user: ['user', 'users', 'member', 'team'],
+};
+
+export async function scanProject(inputPath = '.', options = {}) {
+  const root = resolve(inputPath);
+  const maxFiles = Number(options.maxFiles || 500);
+  const files = [];
+
+  await collectFiles(root, files, {
+    maxFiles,
+    extensions: options.extensions || DEFAULT_EXTENSIONS,
+  });
+
+  const concepts = new Map();
+  const iconIds = new Set();
+  const iconRefs = new Set();
+  const iconSetPrefixes = new Set();
+  const generatedIconRefs = new Set();
+  let bytesRead = 0;
+  let generatedImportCount = 0;
+  let inlineSvgCount = 0;
+
+  for (const file of files) {
+    const text = await readFile(file, 'utf8').catch(() => '');
+    bytesRead += Buffer.byteLength(text, 'utf8');
+    detectConcepts(`${file}\n${text}`, concepts);
+    detectSvgiconsUrls(text, iconIds, iconRefs, iconSetPrefixes);
+
+    const generated = detectGeneratedSvgImports(text);
+    generatedImportCount += generated.count;
+    for (const ref of generated.refs) {
+      generatedIconRefs.add(ref);
+      iconIds.add(ref.split('-')[0]);
+    }
+
+    inlineSvgCount += detectInlineSvgCount(text);
+  }
+
+  const sortedConcepts = [...concepts.entries()]
+    .map(([name, count]) => ({ name, count }))
+    .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+
+  const projectName = titleFromRoot(root);
+
+  return {
+    root,
+    collection: {
+      name: options.collectionName || `${projectName} icons`,
+      description: `Icon candidates detected from ${projectName} codebase scan.`,
+    },
+    concepts: sortedConcepts,
+    existingIconIds: [...iconIds].sort((a, b) => Number(a) - Number(b)),
+    existingIconRefs: [...iconRefs].sort(sortRefsById),
+    generatedIconRefs: [...generatedIconRefs].sort(sortRefsById),
+    iconSetPrefixes: [...iconSetPrefixes].sort(),
+    stats: {
+      filesScanned: files.length,
+      maxFiles,
+      bytesRead,
+      generatedImportCount,
+      inlineSvgCount,
+    },
+  };
+}
+
+async function collectFiles(directory, files, options) {
+  if (files.length >= options.maxFiles) {
+    return;
+  }
+
+  let entries;
+  try {
+    entries = await opendir(directory);
+  } catch {
+    return;
+  }
+
+  for await (const entry of entries) {
+    if (files.length >= options.maxFiles) {
+      break;
+    }
+
+    const path = join(directory, entry.name);
+
+    if (entry.isDirectory()) {
+      if (isExcludedDirectory(path)) {
+        continue;
+      }
+
+      await collectFiles(path, files, options);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    if (!isSupportedFile(path, options.extensions)) {
+      continue;
+    }
+
+    const info = await stat(path).catch(() => null);
+    if (!info || info.size > 256 * 1024) {
+      continue;
+    }
+
+    files.push(path);
+  }
+}
+
+function isSupportedFile(path, extensions) {
+  if (path.endsWith('.blade.php')) {
+    return extensions.has('.blade.php');
+  }
+
+  return extensions.has(extname(path).toLowerCase());
+}
+
+function isExcludedDirectory(path) {
+  const normalized = path.split(sep).join('/');
+
+  return [...EXCLUDED_DIRS].some((dir) => normalized.endsWith(`/${dir}`) || normalized.includes(`/${dir}/`));
+}
+
+function detectConcepts(text, concepts) {
+  const normalized = text.toLowerCase().replace(/[-_]/g, ' ');
+
+  for (const [concept, needles] of Object.entries(CONCEPT_PATTERNS)) {
+    let count = 0;
+
+    for (const needle of needles) {
+      const pattern = new RegExp(`\\b${escapeRegExp(needle)}\\b`, 'gi');
+      count += normalized.match(pattern)?.length || 0;
+    }
+
+    if (count > 0) {
+      concepts.set(concept, (concepts.get(concept) || 0) + count);
+    }
+  }
+}
+
+function detectSvgiconsUrls(text, iconIds, iconRefs, iconSetPrefixes) {
+  for (const match of text.matchAll(/(?:svgicons\.com)?\/icon\/(\d+)\/([a-z0-9._-]+)/gi)) {
+    const id = match[1];
+    const slug = normalizeSlug(match[2]);
+    iconIds.add(id);
+    iconRefs.add(`${id}-${slug}`);
+  }
+
+  for (const match of text.matchAll(/svgicons\.com\/icon-set\/([a-z0-9-]+)|\/icon-set\/([a-z0-9-]+)/gi)) {
+    iconSetPrefixes.add(match[1] || match[2]);
+  }
+}
+
+function detectGeneratedSvgImports(text) {
+  const refs = new Set();
+  let count = 0;
+
+  for (const match of text.matchAll(/(?:import\s+[^'"]+\s+from\s+|require\()\s*['"][^'"]*?(\d+)-([a-z0-9._-]+)\.svg['"]/gi)) {
+    count++;
+    refs.add(`${match[1]}-${normalizeSlug(match[2])}`);
+  }
+
+  return { count, refs };
+}
+
+function detectInlineSvgCount(text) {
+  return [...text.matchAll(/<svg(?:\s|>)/gi)].length;
+}
+
+function titleFromRoot(root) {
+  return basename(root).replace(/[-_]+/g, ' ').replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function normalizeSlug(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[._-]+|[._-]+$/g, '');
+}
+
+function sortRefsById(a, b) {
+  const aId = Number(String(a).split('-')[0]);
+  const bId = Number(String(b).split('-')[0]);
+
+  return aId - bId || String(a).localeCompare(String(b));
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}