@piecemaker-legal/piecemaker 1.0.0

package/scripts/piecemaker/cli/lib/pwa.mjs

@@ -0,0 +1,323 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+
+import { APP, APP_URL, PIECEMAKER_HOME } from './config.mjs';
+import { runCapture } from './exec.mjs';
+
+const APPLICATION_NAME = 'PieceMaker';
+
+function fetchStatus(url) {
+  return new Promise((resolve) => {
+    const request = http.get(url, { timeout: 4000 }, (response) => {
+      const chunks = [];
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => resolve({ status: response.statusCode, body: Buffer.concat(chunks).toString('utf8') }));
+    });
+    request.on('timeout', () => {
+      request.destroy();
+      resolve({ status: 0, body: '' });
+    });
+    request.on('error', () => resolve({ status: 0, body: '' }));
+  });
+}
+
+export async function verifyPwaAssets() {
+  const manifest = await fetchStatus(`${APP_URL}/manifest.json`);
+  const serviceWorker = await fetchStatus(`${APP_URL}/sw.js`);
+
+  let manifestName = null;
+  try {
+    manifestName = JSON.parse(manifest.body).name || null;
+  } catch {
+    manifestName = null;
+  }
+
+  return {
+    manifestServed: manifest.status === 200 && Boolean(manifestName),
+    serviceWorkerServed: serviceWorker.status === 200 && serviceWorker.body.includes('addEventListener'),
+    manifestName,
+  };
+}
+
+function macChromiumBrowser() {
+  const candidates = [
+    '/Applications/Google Chrome.app',
+    '/Applications/Microsoft Edge.app',
+    '/Applications/Brave Browser.app',
+    '/Applications/Chromium.app',
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function writeMacIcon(bundleResourcesDir) {
+  const sourceIcon = path.join(APP.directory, 'public', 'logo-512.png');
+  if (!fs.existsSync(sourceIcon)) return null;
+  if (runCapture('which', ['iconutil']).code !== 0) return null;
+
+  const iconsetDir = path.join(PIECEMAKER_HOME, 'cache', `${APPLICATION_NAME}.iconset`);
+  fs.rmSync(iconsetDir, { recursive: true, force: true });
+  fs.mkdirSync(iconsetDir, { recursive: true });
+
+  const sizes = [16, 32, 64, 128, 256, 512];
+  for (const size of sizes) {
+    runCapture('sips', ['-z', String(size), String(size), sourceIcon, '--out', path.join(iconsetDir, `icon_${size}x${size}.png`)]);
+  }
+
+  const icnsPath = path.join(bundleResourcesDir, `${APPLICATION_NAME}.icns`);
+  const converted = runCapture('iconutil', ['-c', 'icns', iconsetDir, '-o', icnsPath]);
+  fs.rmSync(iconsetDir, { recursive: true, force: true });
+  return converted.code === 0 ? `${APPLICATION_NAME}.icns` : null;
+}
+
+function registerMacBundle(bundleDir) {
+  const lsregister = '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister';
+  if (!fs.existsSync(lsregister)) return;
+  runCapture(lsregister, ['-f', bundleDir]);
+}
+
+function writeMacDesktopAlias(bundleDir) {
+  const desktopAlias = path.join(os.homedir(), 'Desktop', `${APPLICATION_NAME}.app`);
+  try {
+    fs.rmSync(desktopAlias, { recursive: true, force: true });
+    fs.symlinkSync(bundleDir, desktopAlias);
+    return desktopAlias;
+  } catch {
+    return null;
+  }
+}
+
+function installMacApplication() {
+  const applicationsDir = path.join(os.homedir(), 'Applications');
+  const bundleDir = path.join(applicationsDir, `${APPLICATION_NAME}.app`);
+  const macosDir = path.join(bundleDir, 'Contents', 'MacOS');
+  const resourcesDir = path.join(bundleDir, 'Contents', 'Resources');
+
+  fs.mkdirSync(macosDir, { recursive: true });
+  fs.mkdirSync(resourcesDir, { recursive: true });
+
+  const browser = macChromiumBrowser();
+  const launchCommand = browser
+    ? `open -na "${browser}" --args --app="${APP_URL}" --user-data-dir="$HOME/.piecemaker/pwa-profile"`
+    : `open "${APP_URL}"`;
+
+  const launcherPath = path.join(macosDir, APPLICATION_NAME);
+  fs.writeFileSync(launcherPath, `#!/bin/sh\n/usr/bin/env piecemaker --launch-only >/dev/null 2>&1 &\nsleep 2\n${launchCommand}\n`, 'utf8');
+  fs.chmodSync(launcherPath, 0o755);
+
+  const iconFile = writeMacIcon(resourcesDir);
+  const iconEntry = iconFile ? `  <key>CFBundleIconFile</key>\n  <string>${iconFile}</string>\n` : '';
+
+  fs.writeFileSync(
+    path.join(bundleDir, 'Contents', 'Info.plist'),
+    `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n  <key>CFBundleName</key>\n  <string>${APPLICATION_NAME}</string>\n  <key>CFBundleDisplayName</key>\n  <string>${APPLICATION_NAME}</string>\n  <key>CFBundleIdentifier</key>\n  <string>legal.piecemaker.pwa</string>\n  <key>CFBundleExecutable</key>\n  <string>${APPLICATION_NAME}</string>\n  <key>CFBundlePackageType</key>\n  <string>APPL</string>\n  <key>CFBundleShortVersionString</key>\n  <string>1.0</string>\n${iconEntry}  <key>LSUIElement</key>\n  <false/>\n</dict>\n</plist>\n`,
+    'utf8'
+  );
+
+  runCapture('touch', [bundleDir]);
+  registerMacBundle(bundleDir);
+
+  const desktopAlias = writeMacDesktopAlias(bundleDir);
+
+  const locations = [bundleDir];
+  if (desktopAlias) locations.push(desktopAlias);
+
+  const bundleReady = fs.existsSync(launcherPath) && fs.existsSync(path.join(bundleDir, 'Contents', 'Info.plist'));
+  const desktopReady = Boolean(desktopAlias) && fs.existsSync(desktopAlias);
+
+  return {
+    installed: true,
+    location: bundleDir,
+    locations,
+    standalone: Boolean(browser),
+    verified: bundleReady && desktopReady,
+  };
+}
+
+function linuxDesktopEntryContent() {
+  return `[Desktop Entry]\nType=Application\nName=${APPLICATION_NAME}\nComment=Plateforme IA pour juristes français\nExec=sh -c "piecemaker --launch-only >/dev/null 2>&1 & sleep 1; xdg-open ${APP_URL}"\nIcon=${path.join(APP.directory, 'public', 'logo-512.png')}\nCategories=Office;Legal;\nTerminal=false\n`;
+}
+
+function installLinuxApplication() {
+  const applicationsDir = path.join(os.homedir(), '.local', 'share', 'applications');
+  fs.mkdirSync(applicationsDir, { recursive: true });
+  const desktopFile = path.join(applicationsDir, 'piecemaker.desktop');
+  const content = linuxDesktopEntryContent();
+
+  fs.writeFileSync(desktopFile, content, 'utf8');
+  const locations = [desktopFile];
+
+  const desktopDir = path.join(os.homedir(), 'Desktop');
+  let desktopShortcut = null;
+  if (fs.existsSync(desktopDir)) {
+    desktopShortcut = path.join(desktopDir, 'piecemaker.desktop');
+    fs.writeFileSync(desktopShortcut, content, 'utf8');
+    fs.chmodSync(desktopShortcut, 0o755);
+    locations.push(desktopShortcut);
+  }
+
+  return {
+    installed: true,
+    location: desktopFile,
+    locations,
+    standalone: false,
+    verified: locations.every((entry) => fs.existsSync(entry)),
+  };
+}
+
+function encodePngAsIco(pngBuffer) {
+  const header = Buffer.alloc(6);
+  header.writeUInt16LE(0, 0);
+  header.writeUInt16LE(1, 2);
+  header.writeUInt16LE(1, 4);
+
+  const entry = Buffer.alloc(16);
+  entry.writeUInt8(0, 0);
+  entry.writeUInt8(0, 1);
+  entry.writeUInt8(0, 2);
+  entry.writeUInt8(0, 3);
+  entry.writeUInt16LE(1, 4);
+  entry.writeUInt16LE(32, 6);
+  entry.writeUInt32LE(pngBuffer.length, 8);
+  entry.writeUInt32LE(header.length + entry.length, 12);
+
+  return Buffer.concat([header, entry, pngBuffer]);
+}
+
+function writeWindowsIcon() {
+  const sourceIcon = path.join(APP.directory, 'public', 'logo-512.png');
+  if (!fs.existsSync(sourceIcon)) return null;
+
+  const cacheDir = path.join(PIECEMAKER_HOME, 'cache');
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const icoPath = path.join(cacheDir, `${APPLICATION_NAME}.ico`);
+
+  try {
+    const pngBuffer = fs.readFileSync(sourceIcon);
+    fs.writeFileSync(icoPath, encodePngAsIco(pngBuffer));
+    return icoPath;
+  } catch {
+    return null;
+  }
+}
+
+function windowsChromiumBrowser() {
+  const programFiles = process.env['ProgramFiles'] || 'C:\\Program Files';
+  const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
+  const localAppData = process.env.LOCALAPPDATA || '';
+
+  const candidates = [
+    path.join(programFiles, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(programFilesX86, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    localAppData && path.join(localAppData, 'Google', 'Chrome', 'Application', 'chrome.exe'),
+    path.join(programFilesX86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+    path.join(programFiles, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
+    path.join(programFiles, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+    path.join(programFilesX86, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+    localAppData && path.join(localAppData, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'),
+  ].filter(Boolean);
+
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function windowsDesktopDir() {
+  const standard = path.join(os.homedir(), 'Desktop');
+  if (fs.existsSync(standard)) return standard;
+
+  const oneDrive = process.env.OneDrive;
+  if (oneDrive) {
+    const oneDriveDesktop = path.join(oneDrive, 'Desktop');
+    if (fs.existsSync(oneDriveDesktop)) return oneDriveDesktop;
+  }
+
+  return standard;
+}
+
+function windowsStartMenuDir() {
+  const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  return path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs');
+}
+
+function createWindowsShortcut(shortcutPath, targetPath, shortcutArgs, iconPath) {
+  const escape = (value) => String(value).replace(/'/g, "''");
+  const lines = [
+    '$shell = New-Object -ComObject WScript.Shell',
+    `$shortcut = $shell.CreateShortcut('${escape(shortcutPath)}')`,
+    `$shortcut.TargetPath = '${escape(targetPath)}'`,
+    shortcutArgs ? `$shortcut.Arguments = '${escape(shortcutArgs)}'` : null,
+    `$shortcut.WorkingDirectory = '${escape(path.dirname(targetPath))}'`,
+    iconPath ? `$shortcut.IconLocation = '${escape(iconPath)}'` : null,
+    '$shortcut.Save()',
+  ].filter(Boolean);
+
+  const scriptPath = path.join(os.tmpdir(), `piecemaker-shortcut-${Date.now()}-${Math.random().toString(36).slice(2)}.ps1`);
+  fs.writeFileSync(scriptPath, lines.join('\r\n'), 'utf8');
+
+  const result = runCapture('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', `& '${escape(scriptPath)}'`]);
+  fs.rmSync(scriptPath, { force: true });
+
+  return result.code === 0;
+}
+
+function installWindowsApplication() {
+  const browser = windowsChromiumBrowser();
+  const iconPath = writeWindowsIcon();
+  const userDataDir = path.join(os.homedir(), '.piecemaker', 'pwa-profile');
+
+  const targetPath = browser || path.join(process.env.WINDIR || 'C:\\Windows', 'explorer.exe');
+  const shortcutArgs = browser ? `--app=${APP_URL} --user-data-dir=${userDataDir}` : APP_URL;
+
+  const desktopDir = windowsDesktopDir();
+  const startMenuDir = windowsStartMenuDir();
+  fs.mkdirSync(desktopDir, { recursive: true });
+  fs.mkdirSync(startMenuDir, { recursive: true });
+
+  const desktopShortcut = path.join(desktopDir, `${APPLICATION_NAME}.lnk`);
+  const startMenuShortcut = path.join(startMenuDir, `${APPLICATION_NAME}.lnk`);
+
+  createWindowsShortcut(desktopShortcut, targetPath, shortcutArgs, iconPath);
+  createWindowsShortcut(startMenuShortcut, targetPath, shortcutArgs, iconPath);
+
+  const locations = [desktopShortcut, startMenuShortcut].filter((candidate) => fs.existsSync(candidate));
+
+  if (locations.length === 0) {
+    return { installed: false, reason: "création du raccourci Windows impossible (PowerShell absent ou refusé)" };
+  }
+
+  return {
+    installed: true,
+    location: locations[0],
+    locations,
+    standalone: Boolean(browser),
+    verified: locations.length === 2,
+  };
+}
+
+export function installApplicationEntry() {
+  try {
+    if (process.platform === 'darwin') return installMacApplication();
+    if (process.platform === 'linux') return installLinuxApplication();
+    if (process.platform === 'win32') return installWindowsApplication();
+    return { installed: false, reason: 'plateforme non prise en charge' };
+  } catch (error) {
+    return { installed: false, reason: error.message };
+  }
+}
+
+export function openApplication() {
+  if (process.platform === 'darwin') {
+    const browser = macChromiumBrowser();
+    if (browser) {
+      runCapture('open', ['-na', browser, '--args', `--app=${APP_URL}`, `--user-data-dir=${path.join(os.homedir(), '.piecemaker', 'pwa-profile')}`]);
+      return;
+    }
+    runCapture('open', [APP_URL]);
+    return;
+  }
+  if (process.platform === 'linux') {
+    runCapture('xdg-open', [APP_URL]);
+    return;
+  }
+  runCapture('cmd', ['/c', 'start', '', APP_URL]);
+}

package/scripts/piecemaker/cli/lib/repos.mjs

@@ -0,0 +1,140 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { PIECEMAKER_HOME } from './config.mjs';
+import { runCapture, runStreaming } from './exec.mjs';
+import { npmPath, runtimeEnv } from './node-runtime.mjs';
+
+const STAMP_DIR = path.join(PIECEMAKER_HOME, 'install-stamps');
+
+function isGitRepository(directory) {
+  return fs.existsSync(path.join(directory, '.git'));
+}
+
+function git(directory, args) {
+  return runCapture('git', ['-C', directory, ...args]);
+}
+
+function currentBranch(directory) {
+  const result = git(directory, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  return result.code === 0 ? result.stdout.trim() : null;
+}
+
+function hasLocalChanges(directory) {
+  const result = git(directory, ['status', '--porcelain']);
+  return result.code === 0 && result.stdout.trim().length > 0;
+}
+
+function dependencyFingerprint(directory) {
+  const lockFile = path.join(directory, 'package-lock.json');
+  const manifest = path.join(directory, 'package.json');
+  const source = fs.existsSync(lockFile) ? lockFile : manifest;
+  if (!fs.existsSync(source)) return null;
+  return crypto.createHash('sha256').update(fs.readFileSync(source)).digest('hex');
+}
+
+function stampPath(repo) {
+  return path.join(STAMP_DIR, `${repo.key}.json`);
+}
+
+function readStamp(repo) {
+  try {
+    return JSON.parse(fs.readFileSync(stampPath(repo), 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeStamp(repo, data) {
+  fs.mkdirSync(STAMP_DIR, { recursive: true });
+  fs.writeFileSync(stampPath(repo), `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+export async function ensureRepository(repo, runtime, report) {
+  if (!isGitRepository(repo.directory)) {
+    report.step(`${repo.label} — clonage`);
+    fs.mkdirSync(path.dirname(repo.directory), { recursive: true });
+    await runStreaming('git', ['clone', '--branch', repo.branch, repo.remote, repo.directory], {
+      env: runtimeEnv(runtime),
+    });
+    return { cloned: true, updated: true };
+  }
+
+  const fetched = git(repo.directory, ['fetch', '--quiet', 'origin', repo.branch]);
+  if (fetched.code !== 0) {
+    report.warn(`${repo.label} — dépôt distant injoignable, version locale conservée`);
+    return { cloned: false, updated: false, offline: true };
+  }
+
+  const branch = currentBranch(repo.directory);
+  const behind = git(repo.directory, ['rev-list', '--count', `HEAD..origin/${repo.branch}`]);
+  const behindCount = Number.parseInt(behind.stdout.trim(), 10) || 0;
+
+  if (behindCount === 0) {
+    return { cloned: false, updated: false };
+  }
+
+  if (branch !== repo.branch) {
+    report.warn(`${repo.label} — branche ${branch} active, ${behindCount} commit(s) non appliqués sur ${repo.branch}`);
+    return { cloned: false, updated: false, diverged: true };
+  }
+
+  if (hasLocalChanges(repo.directory)) {
+    report.warn(`${repo.label} — modifications locales, ${behindCount} commit(s) non appliqués`);
+    return { cloned: false, updated: false, dirty: true };
+  }
+
+  report.step(`${repo.label} — mise à jour (${behindCount} commit(s))`);
+  const merged = git(repo.directory, ['merge', '--ff-only', `origin/${repo.branch}`]);
+  if (merged.code !== 0) {
+    report.warn(`${repo.label} — mise à jour impossible en avance rapide`);
+    return { cloned: false, updated: false, diverged: true };
+  }
+  return { cloned: false, updated: true };
+}
+
+export async function ensureDependencies(repo, runtime, report, { force = false } = {}) {
+  if (!fs.existsSync(path.join(repo.directory, 'package.json'))) {
+    return { installed: false };
+  }
+
+  const fingerprint = dependencyFingerprint(repo.directory);
+  const stamp = readStamp(repo);
+  const modulesPresent = fs.existsSync(path.join(repo.directory, 'node_modules'));
+  const upToDate = modulesPresent && stamp.dependencies === fingerprint && stamp.node === runtime.version;
+
+  if (upToDate && !force) {
+    return { installed: false };
+  }
+
+  report.step(`${repo.label} — installation des dépendances`);
+  const useCleanInstall = fs.existsSync(path.join(repo.directory, 'package-lock.json')) && !modulesPresent;
+  await runStreaming(npmPath(runtime), [useCleanInstall ? 'ci' : 'install', '--no-audit', '--no-fund'], {
+    cwd: repo.directory,
+    env: runtimeEnv(runtime),
+  });
+
+  writeStamp(repo, {
+    ...readStamp(repo),
+    dependencies: dependencyFingerprint(repo.directory),
+    node: runtime.version,
+    updatedAt: new Date().toISOString(),
+  });
+  return { installed: true };
+}
+
+export function rebuildNativeModules(repo, runtime, report, moduleNames) {
+  const present = moduleNames.filter((name) => fs.existsSync(path.join(repo.directory, 'node_modules', name)));
+  if (present.length === 0) return;
+
+  const stamp = readStamp(repo);
+  if (stamp.nativeNode === runtime.version) return;
+
+  report.step(`${repo.label} — recompilation des modules natifs`);
+  runCapture(npmPath(runtime), ['rebuild', ...present], {
+    cwd: repo.directory,
+    env: runtimeEnv(runtime),
+  });
+  writeStamp(repo, { ...stamp, nativeNode: runtime.version });
+}

package/scripts/piecemaker/cli/lib/services.mjs

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+import { APP, LOG_DIR, PIECEMAKER_HOME, PORTS } from './config.mjs';
+import { waitUntil } from './exec.mjs';
+import { npmPath, runtimeEnv } from './node-runtime.mjs';
+
+export const APP_LOG = path.join(LOG_DIR, 'application.log');
+export const APP_PID_FILE = path.join(PIECEMAKER_HOME, 'application.pid');
+
+function httpReachable(url, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    const request = http.get(url, { timeout: timeoutMs }, (response) => {
+      response.resume();
+      resolve(true);
+    });
+    request.on('timeout', () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.on('error', () => resolve(false));
+  });
+}
+
+export function appServerReachable() {
+  return httpReachable(`http://127.0.0.1:${PORTS.appServer}/api/auth/status`);
+}
+
+export function appClientReachable() {
+  return httpReachable(`http://127.0.0.1:${PORTS.appClient}/`);
+}
+
+export async function startApplication(runtime, report) {
+  const alreadyRunning = await appClientReachable() && await appServerReachable();
+  if (alreadyRunning) {
+    return { started: false, alreadyRunning: true };
+  }
+
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+  fs.appendFileSync(APP_LOG, `\n[${new Date().toISOString()}] Démarrage de l application\n`, 'utf8');
+  const logHandle = fs.openSync(APP_LOG, 'a');
+
+  report.step('Application — démarrage du serveur et du client');
+  let child;
+  try {
+    child = spawn(npmPath(runtime), ['run', 'dev'], {
+      cwd: APP.directory,
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', logHandle, logHandle],
+      env: runtimeEnv(runtime, {
+        SERVER_PORT: String(PORTS.appServer),
+        PORT: String(PORTS.appServer),
+        VITE_PORT: String(PORTS.appClient),
+        BROWSER: 'none',
+      }),
+    });
+  } finally {
+    fs.closeSync(logHandle);
+  }
+
+  child.unref();
+  fs.writeFileSync(APP_PID_FILE, String(child.pid), 'utf8');
+
+  const serverUp = await waitUntil(appServerReachable, { timeoutMs: 120_000 });
+  const clientUp = await waitUntil(appClientReachable, { timeoutMs: 120_000 });
+
+  return { started: true, pid: child.pid, serverUp, clientUp };
+}

package/scripts/piecemaker/cli/lib/ui.mjs

@@ -0,0 +1,41 @@
+const supportsColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined;
+
+const paint = (code) => (text) => (supportsColor ? `\u001b[${code}m${text}\u001b[0m` : String(text));
+
+export const c = {
+  bold: paint('1'),
+  dim: paint('2'),
+  red: paint('31'),
+  green: paint('32'),
+  yellow: paint('33'),
+  blue: paint('34'),
+  cyan: paint('36'),
+};
+
+export function banner(text) {
+  process.stdout.write(`\n${c.bold(c.cyan(text))}\n\n`);
+}
+
+export function step(text) {
+  process.stdout.write(`${c.blue('•')} ${text}\n`);
+}
+
+export function ok(text) {
+  process.stdout.write(`${c.green('✓')} ${text}\n`);
+}
+
+export function warn(text) {
+  process.stdout.write(`${c.yellow('!')} ${text}\n`);
+}
+
+export function fail(text) {
+  process.stderr.write(`${c.red('✗')} ${text}\n`);
+}
+
+export function detail(text) {
+  process.stdout.write(`  ${c.dim(text)}\n`);
+}
+
+export function blank() {
+  process.stdout.write('\n');
+}