@mrdemonwolf/iconwolf 0.1.1

package/src/utils/image.ts

@@ -0,0 +1,207 @@
+import sharp from 'sharp';
+import type { GenerationResult } from '../types.js';
+
+const ADAPTIVE_ICON_SIZE = 1024;
+const SAFE_ZONE_RATIO = 66 / 108;
+const SAFE_ZONE_PX = Math.round(ADAPTIVE_ICON_SIZE * SAFE_ZONE_RATIO);
+
+export interface SourceImageMeta {
+  width: number;
+  height: number;
+  format: string;
+}
+
+export async function validateSourceImage(
+  inputPath: string,
+): Promise<SourceImageMeta> {
+  const metadata = await sharp(inputPath).metadata();
+
+  if (!metadata.format || metadata.format !== 'png') {
+    throw new Error(
+      `Source image must be a PNG file (got ${metadata.format || 'unknown'})`,
+    );
+  }
+
+  if (!metadata.width || !metadata.height) {
+    throw new Error('Could not read image dimensions');
+  }
+
+  if (metadata.width !== metadata.height) {
+    throw new Error(
+      `Source image must be square (got ${metadata.width}x${metadata.height})`,
+    );
+  }
+
+  return {
+    width: metadata.width,
+    height: metadata.height,
+    format: metadata.format,
+  };
+}
+
+export async function resizeImage(
+  inputPath: string,
+  width: number,
+  height: number,
+  outputPath: string,
+): Promise<GenerationResult> {
+  const info = await sharp(inputPath)
+    .resize(width, height, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toFile(outputPath);
+
+  return {
+    filePath: outputPath,
+    width: info.width,
+    height: info.height,
+    size: info.size,
+  };
+}
+
+export async function createAdaptiveForeground(
+  inputPath: string,
+  targetSize: number,
+  outputPath: string,
+): Promise<GenerationResult> {
+  const artwork = await sharp(inputPath)
+    .resize(SAFE_ZONE_PX, SAFE_ZONE_PX, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+
+  const margin = Math.round((targetSize - SAFE_ZONE_PX) / 2);
+
+  const info = await sharp({
+    create: {
+      width: targetSize,
+      height: targetSize,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    },
+  })
+    .composite([{ input: artwork, left: margin, top: margin }])
+    .png()
+    .toFile(outputPath);
+
+  return {
+    filePath: outputPath,
+    width: info.width,
+    height: info.height,
+    size: info.size,
+  };
+}
+
+export async function createSolidBackground(
+  hexColor: string,
+  size: number,
+  outputPath: string,
+): Promise<GenerationResult> {
+  const { r, g, b } = parseHexColor(hexColor);
+
+  const info = await sharp({
+    create: {
+      width: size,
+      height: size,
+      channels: 4,
+      background: { r, g, b, alpha: 255 },
+    },
+  })
+    .png()
+    .toFile(outputPath);
+
+  return {
+    filePath: outputPath,
+    width: info.width,
+    height: info.height,
+    size: info.size,
+  };
+}
+
+export async function createMonochromeIcon(
+  inputPath: string,
+  targetSize: number,
+  outputPath: string,
+): Promise<GenerationResult> {
+  const artwork = await sharp(inputPath)
+    .resize(SAFE_ZONE_PX, SAFE_ZONE_PX, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .grayscale()
+    .png()
+    .toBuffer();
+
+  const margin = Math.round((targetSize - SAFE_ZONE_PX) / 2);
+
+  const info = await sharp({
+    create: {
+      width: targetSize,
+      height: targetSize,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    },
+  })
+    .composite([{ input: artwork, left: margin, top: margin }])
+    .png()
+    .toFile(outputPath);
+
+  return {
+    filePath: outputPath,
+    width: info.width,
+    height: info.height,
+    size: info.size,
+  };
+}
+
+/**
+ * Apply rounded corners to an image using an SVG mask.
+ * Uses Apple's icon corner radius ratio (~22.37%).
+ */
+export async function applyRoundedCorners(
+  inputBuffer: Buffer,
+  size: number,
+): Promise<Buffer> {
+  const radius = Math.round(size * 0.2237);
+  const mask = Buffer.from(
+    `<svg width="${size}" height="${size}"><rect x="0" y="0" width="${size}" height="${size}" rx="${radius}" ry="${radius}" fill="white"/></svg>`,
+  );
+
+  return sharp(inputBuffer)
+    .resize(size, size)
+    .composite([{ input: mask, blend: 'dest-in' }])
+    .png()
+    .toBuffer();
+}
+
+export function parseHexColor(hex: string): {
+  r: number;
+  g: number;
+  b: number;
+} {
+  const cleaned = hex.replace(/^#/, '');
+
+  let r: number, g: number, b: number;
+
+  if (cleaned.length === 3) {
+    r = parseInt(cleaned[0] + cleaned[0], 16);
+    g = parseInt(cleaned[1] + cleaned[1], 16);
+    b = parseInt(cleaned[2] + cleaned[2], 16);
+  } else if (cleaned.length === 6) {
+    r = parseInt(cleaned.slice(0, 2), 16);
+    g = parseInt(cleaned.slice(2, 4), 16);
+    b = parseInt(cleaned.slice(4, 6), 16);
+  } else {
+    throw new Error(`Invalid hex color: ${hex}. Use #RGB or #RRGGBB format.`);
+  }
+
+  if (isNaN(r) || isNaN(g) || isNaN(b)) {
+    throw new Error(`Invalid hex color: ${hex}. Contains non-hex characters.`);
+  }
+
+  return { r, g, b };
+}

package/src/utils/logger.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import type { GenerationResult } from '../types.js';
+
+export function banner(): void {
+  console.log(
+    chalk.bold.hex('#FF6B35')('\n  iconwolf') +
+      chalk.dim(' - app icon generator\n'),
+  );
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('  info') + chalk.dim(' · ') + message);
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('  done') + chalk.dim(' · ') + message);
+}
+
+export function generated(result: GenerationResult): void {
+  const sizeKB = (result.size / 1024).toFixed(1);
+  console.log(
+    chalk.green('  generated') +
+      chalk.dim(' · ') +
+      chalk.white(result.filePath) +
+      chalk.dim(` (${result.width}x${result.height}, ${sizeKB} KB)`),
+  );
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow('  warn') + chalk.dim(' · ') + message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('  error') + chalk.dim(' · ') + message);
+}
+
+export function summary(results: GenerationResult[]): void {
+  const totalSize = results.reduce((sum, r) => sum + r.size, 0);
+  const totalKB = (totalSize / 1024).toFixed(1);
+  console.log(
+    chalk.bold(
+      `\n  ${results.length} file${results.length === 1 ? '' : 's'} generated`,
+    ) + chalk.dim(` (${totalKB} KB total)\n`),
+  );
+}
+
+export function updateNotice(
+  currentVersion: string,
+  latestVersion: string,
+): void {
+  console.log(
+    chalk.yellow('  update') +
+      chalk.dim(' · ') +
+      `New version available: ${chalk.dim(currentVersion)} → ${chalk.green(latestVersion)}`,
+  );
+  console.log(
+    '         ' +
+      chalk.dim(' · ') +
+      `Run ${chalk.cyan('brew upgrade iconwolf')} to update\n`,
+  );
+}

package/src/utils/paths.ts

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_OUTPUT_DIR = './assets/images';
+
+/**
+ * Detect the default output directory based on project structure.
+ * If a `src/` directory exists (common in React Native/Expo projects),
+ * defaults to `./src/assets/images/`. Otherwise uses `./assets/images/`.
+ */
+export function resolveDefaultOutputDir(): string {
+  const srcDir = path.resolve('src');
+  if (fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) {
+    return './src/assets/images';
+  }
+  return DEFAULT_OUTPUT_DIR;
+}
+
+export const OUTPUT_FILES = {
+  icon: 'icon.png',
+  androidForeground: 'adaptive-icon.png',
+  androidBackground: 'android-icon-background.png',
+  androidMonochrome: 'monochrome-icon.png',
+  favicon: 'favicon.png',
+  splashIcon: 'splash-icon.png',
+} as const;
+
+export function resolveOutputPath(outputDir: string, fileName: string): string {
+  return path.resolve(outputDir, fileName);
+}

package/src/utils/update-notifier.ts

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CACHE_DIR = path.join(os.homedir(), '.iconwolf');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-check.json');
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 5000;
+const RELEASES_URL =
+  'https://api.github.com/repos/MrDemonWolf/iconwolf/releases/latest';
+
+export interface UpdateInfo {
+  updateAvailable: boolean;
+  currentVersion: string;
+  latestVersion: string;
+}
+
+interface CacheData {
+  latestVersion: string;
+  checkedAt: number;
+}
+
+export function isNewerVersion(current: string, latest: string): boolean {
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+  const len = Math.max(currentParts.length, latestParts.length);
+
+  for (let i = 0; i < len; i++) {
+    const c = currentParts[i] ?? 0;
+    const l = latestParts[i] ?? 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+
+  return false;
+}
+
+export function readCachedUpdateInfo(
+  currentVersion: string,
+): UpdateInfo | null {
+  try {
+    const raw = fs.readFileSync(CACHE_FILE, 'utf-8');
+    const data: CacheData = JSON.parse(raw);
+    if (!data.latestVersion) return null;
+
+    return {
+      updateAvailable: isNewerVersion(currentVersion, data.latestVersion),
+      currentVersion,
+      latestVersion: data.latestVersion,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function refreshCacheInBackground(
+  currentCacheFile?: string,
+): Promise<void> {
+  const cacheFile = currentCacheFile ?? CACHE_FILE;
+  const cacheDir = path.dirname(cacheFile);
+
+  try {
+    // Check if cache is still fresh
+    try {
+      const stat = fs.statSync(cacheFile);
+      if (Date.now() - stat.mtimeMs < CACHE_TTL_MS) return;
+    } catch {
+      // Cache missing, proceed with fetch
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+    try {
+      const res = await fetch(RELEASES_URL, {
+        signal: controller.signal,
+        headers: { Accept: 'application/vnd.github.v3+json' },
+      });
+
+      if (!res.ok) return;
+
+      const body = (await res.json()) as { tag_name?: string };
+      if (!body.tag_name) return;
+
+      const latestVersion = body.tag_name.replace(/^v/, '');
+      const cacheData: CacheData = {
+        latestVersion,
+        checkedAt: Date.now(),
+      };
+
+      fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(cacheFile, JSON.stringify(cacheData));
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch {
+    // Silently swallow all errors
+  }
+}

package/src/variants/android.ts

@@ -0,0 +1,45 @@
+import {
+  createAdaptiveForeground,
+  createSolidBackground,
+  createMonochromeIcon,
+} from '../utils/image.js';
+import { resolveOutputPath, OUTPUT_FILES } from '../utils/paths.js';
+import type { GenerationResult } from '../types.js';
+
+const ANDROID_ICON_SIZE = 1024;
+
+export async function generateAndroidIcons(
+  inputPath: string,
+  outputDir: string,
+  bgColor: string,
+  options?: { includeBackground?: boolean },
+): Promise<GenerationResult[]> {
+  const includeBackground = options?.includeBackground ?? false;
+
+  const foregroundPromise = createAdaptiveForeground(
+    inputPath,
+    ANDROID_ICON_SIZE,
+    resolveOutputPath(outputDir, OUTPUT_FILES.androidForeground),
+  );
+
+  if (!includeBackground) {
+    const foreground = await foregroundPromise;
+    return [foreground];
+  }
+
+  const [foreground, background, monochrome] = await Promise.all([
+    foregroundPromise,
+    createSolidBackground(
+      bgColor,
+      ANDROID_ICON_SIZE,
+      resolveOutputPath(outputDir, OUTPUT_FILES.androidBackground),
+    ),
+    createMonochromeIcon(
+      inputPath,
+      ANDROID_ICON_SIZE,
+      resolveOutputPath(outputDir, OUTPUT_FILES.androidMonochrome),
+    ),
+  ]);
+
+  return [foreground, background, monochrome];
+}

package/src/variants/favicon.ts

@@ -0,0 +1,32 @@
+import sharp from 'sharp';
+import { applyRoundedCorners } from '../utils/image.js';
+import { resolveOutputPath, OUTPUT_FILES } from '../utils/paths.js';
+import type { GenerationResult } from '../types.js';
+
+const FAVICON_SIZE = 48;
+
+export async function generateFavicon(
+  inputPath: string,
+  outputDir: string,
+): Promise<GenerationResult> {
+  const outputPath = resolveOutputPath(outputDir, OUTPUT_FILES.favicon);
+
+  const resized = await sharp(inputPath)
+    .resize(FAVICON_SIZE, FAVICON_SIZE, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+
+  const rounded = await applyRoundedCorners(resized, FAVICON_SIZE);
+
+  const info = await sharp(rounded).png().toFile(outputPath);
+
+  return {
+    filePath: outputPath,
+    width: info.width,
+    height: info.height,
+    size: info.size,
+  };
+}

package/src/variants/splash.ts

@@ -0,0 +1,11 @@
+import { resizeImage } from '../utils/image.js';
+import { resolveOutputPath, OUTPUT_FILES } from '../utils/paths.js';
+import type { GenerationResult } from '../types.js';
+
+export async function generateSplashIcon(
+  inputPath: string,
+  outputDir: string,
+): Promise<GenerationResult> {
+  const outputPath = resolveOutputPath(outputDir, OUTPUT_FILES.splashIcon);
+  return resizeImage(inputPath, 1024, 1024, outputPath);
+}

package/src/variants/standard.ts

@@ -0,0 +1,11 @@
+import { resizeImage } from '../utils/image.js';
+import { resolveOutputPath, OUTPUT_FILES } from '../utils/paths.js';
+import type { GenerationResult } from '../types.js';
+
+export async function generateStandardIcon(
+  inputPath: string,
+  outputDir: string,
+): Promise<GenerationResult> {
+  const outputPath = resolveOutputPath(outputDir, OUTPUT_FILES.icon);
+  return resizeImage(inputPath, 1024, 1024, outputPath);
+}

package/tests/cli.test.ts

@@ -0,0 +1,84 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestPng, createTmpDir, cleanDir } from './helpers.js';
+
+let tmpDir: string;
+let testPng: string;
+const CLI_PATH = path.resolve('dist/index.js');
+
+beforeAll(async () => {
+  tmpDir = createTmpDir();
+  testPng = await createTestPng(1024, 1024, tmpDir);
+});
+
+afterAll(() => {
+  cleanDir(tmpDir);
+});
+
+function runCli(args: string): string {
+  return execSync(`node ${CLI_PATH} ${args}`, {
+    encoding: 'utf-8',
+    timeout: 30000,
+  });
+}
+
+describe('CLI end-to-end', () => {
+  it('prints version with --version', () => {
+    const output = runCli('--version');
+    expect(output.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+
+  it('prints help with --help', () => {
+    const output = runCli('--help');
+    expect(output).toContain('iconwolf');
+    expect(output).toContain('--output');
+    expect(output).toContain('--android');
+    expect(output).toContain('--favicon');
+    expect(output).toContain('--splash');
+    expect(output).toContain('--icon');
+    expect(output).toContain('--splash-input');
+    expect(output).toContain('--bg-color');
+  });
+
+  it('generates icon.png via CLI with --icon flag', () => {
+    const outDir = path.join(tmpDir, 'cli-icon');
+
+    runCli(`${testPng} --icon -o ${outDir}`);
+
+    expect(fs.existsSync(path.join(outDir, 'icon.png'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'favicon.png'))).toBe(false);
+  });
+
+  it('generates all 4 default files via CLI', () => {
+    const outDir = path.join(tmpDir, 'cli-all');
+
+    runCli(`${testPng} -o ${outDir}`);
+
+    expect(fs.existsSync(path.join(outDir, 'icon.png'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'adaptive-icon.png'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'splash-icon.png'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'favicon.png'))).toBe(true);
+    // Background and monochrome NOT generated by default
+    expect(
+      fs.existsSync(path.join(outDir, 'android-icon-background.png')),
+    ).toBe(false);
+    expect(fs.existsSync(path.join(outDir, 'monochrome-icon.png'))).toBe(false);
+  });
+
+  it('exits with error on missing input file', () => {
+    expect(() => {
+      runCli('/tmp/nonexistent-icon.png -o /tmp/out');
+    }).toThrow();
+  });
+
+  it('generates favicon when --favicon flag is used', () => {
+    const outDir = path.join(tmpDir, 'cli-favicon');
+
+    runCli(`${testPng} --favicon -o ${outDir}`);
+
+    expect(fs.existsSync(path.join(outDir, 'favicon.png'))).toBe(true);
+    expect(fs.existsSync(path.join(outDir, 'icon.png'))).toBe(false);
+  });
+});