a11y-devkit-deploy 0.4.0

package/README.md

@@ -0,0 +1,101 @@
+# A11y Devkit Deploy
+
+A cross-platform CLI for deploying accessibility skills and MCP servers across Claude Code, Cursor, Codex, and VSCode. Automatically clones the a11y-skills repo and all required MCP server repositories.
+
+## Install
+
+```bash
+npm install -g a11y-devkit-deploy
+# or
+npx a11y-devkit-deploy
+```
+
+## Usage
+
+```bash
+a11y-devkit-deploy
+```
+
+### Flags
+
+- `--local` / `--global`: Skip the scope prompt.
+- `--yes`: Use defaults (local scope, all IDEs, install skills).
+
+## What It Does
+
+This CLI automates the setup of accessibility tooling by:
+
+1. **Cloning the a11y-skills repository** - Contains IDE skills for accessibility workflows
+2. **Cloning and building MCP server repositories** - Installs 5 accessibility-focused MCP servers:
+   - **wcag-mcp** - WCAG 2.2 guidelines, success criteria, and techniques
+   - **aria-mcp** - WAI-ARIA roles, states, properties, and patterns
+   - **magentaa11y** - Component accessibility acceptance criteria
+   - **a11y-personas-mcp** - Accessibility personas for diverse user needs
+   - **a11y-issues-template-mcp** - Format AxeCore violations into standardized issue templates
+3. **Installing skills** - Copies skills to IDE-specific directories based on scope (local/global)
+4. **Installing MCP servers** - Copies built MCP servers to home directory:
+   - Single IDE: `~/.{ide}/mcp/servers/` (e.g., `~/.claude/mcp/servers/`)
+   - Multiple IDEs: `~/.mcp/servers/` (shared location)
+5. **Configuring MCP servers** - Updates each IDE's MCP config to enable the accessibility tools
+6. **Cleanup** - Removes temporary build directory after installation
+
+## Configuration
+
+Edit `config/a11y.json` to customize the deployment:
+
+- `repo.url` - Main skills repository to clone
+- `mcpRepos` - Array of MCP repositories to clone and build
+- `skillsSearchPaths` - Directories to search for skills in the cloned repo
+- `ideSkillsPaths` - IDE-specific skills directories (configurable per IDE)
+- `mcpServers` - MCP server definitions with placeholders:
+  - `{mcpRepoDir}` - Path to the MCP servers directory (e.g., `~/.mcp/servers/` or `~/.claude/mcp/servers/`)
+
+## Directory Structure
+
+### Local Install (Project-Specific)
+```
+your-project/
+├── .claude/skills/          # Skills copied to Claude Code (if selected)
+├── .cursor/skills/          # Skills copied to Cursor (if selected)
+├── .codex/skills/           # Skills copied to Codex (if selected)
+└── .github/skills/          # Skills copied here for version control
+```
+
+### Global Install (User-Wide)
+```
+~/.claude/skills/            # Claude Code skills
+~/.cursor/skills/            # Cursor skills
+~/.codex/skills/             # Codex skills
+~/.vscode/skills/            # VSCode skills
+```
+
+### MCP Server Locations
+MCP servers are always installed to the home directory:
+
+**Single IDE Selection:**
+```
+~/.claude/mcp/servers/       # If only Claude Code is selected
+│   ├── wcag-mcp/
+│   ├── aria-mcp/
+│   ├── magentaa11y-mcp/
+│   ├── a11y-personas-mcp/
+│   └── a11y-issues-template-mcp/
+```
+
+**Multiple IDE Selection:**
+```
+~/.mcp/servers/              # Shared location for all selected IDEs
+│   ├── wcag-mcp/
+│   ├── aria-mcp/
+│   ├── magentaa11y-mcp/
+│   ├── a11y-personas-mcp/
+│   └── a11y-issues-template-mcp/
+```
+
+MCP configurations are written to each IDE's OS-specific config path:
+- **macOS**: `~/Library/Application Support/{IDE}/mcp.json`
+- **Windows**: `%APPDATA%\{IDE}\mcp.json`
+- **Linux**: `~/.config/{IDE}/mcp.json`
+
+### Temporary Build Directory
+During installation, repos are cloned and built in a temporary directory (OS temp folder) which is automatically cleaned up after completion.

package/bin/a11y-skills.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { run } from "../src/cli.js";
+
+run().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`\n[Error] ${message}`);
+  process.exitCode = 1;
+});

package/config/a11y.json

@@ -0,0 +1,73 @@
+{
+  "repo": {
+    "url": "https://github.com/joe-watkins/a11y-skills",
+    "dirName": "a11y-skills"
+  },
+  "mcpRepos": [
+    {
+      "url": "https://github.com/joe-watkins/wcag-mcp",
+      "dirName": "wcag-mcp",
+      "buildCommands": ["npm install", "npm run build"]
+    },
+    {
+      "url": "https://github.com/joe-watkins/aria-mcp",
+      "dirName": "aria-mcp",
+      "buildCommands": ["npm install"]
+    },
+    {
+      "url": "https://github.com/joe-watkins/magentaa11y-mcp",
+      "dirName": "magentaa11y-mcp",
+      "buildCommands": ["npm install", "npm run update-content"]
+    },
+    {
+      "url": "https://github.com/joe-watkins/a11y-personas-mcp",
+      "dirName": "a11y-personas-mcp",
+      "buildCommands": ["npm install", "npm run build"]
+    },
+    {
+      "url": "https://github.com/joe-watkins/accessibility-issues-template-mcp",
+      "dirName": "a11y-issues-template-mcp",
+      "buildCommands": ["npm install", "npm run build"]
+    }
+  ],
+  "skillsSearchPaths": [
+    ".",
+    "skills",
+    ".github/skills",
+    ".codex/skills"
+  ],
+  "ideSkillsPaths": {
+    "claude": ".claude/skills",
+    "cursor": ".cursor/skills",
+    "codex": ".codex/skills",
+    "vscode": ".github/skills",
+    "local": ".github/skills"
+  },
+  "mcpServers": [
+    {
+      "name": "wcag-mcp",
+      "command": "node",
+      "args": ["{mcpRepoDir}/wcag-mcp/src/index.js"]
+    },
+    {
+      "name": "aria-mcp",
+      "command": "node",
+      "args": ["{mcpRepoDir}/aria-mcp/src/index.js"]
+    },
+    {
+      "name": "magentaa11y",
+      "command": "node",
+      "args": ["{mcpRepoDir}/magentaa11y-mcp/src/index.js"]
+    },
+    {
+      "name": "a11y-personas-mcp",
+      "command": "node",
+      "args": ["{mcpRepoDir}/a11y-personas-mcp/src/index.js"]
+    },
+    {
+      "name": "a11y-issues-template-mcp",
+      "command": "node",
+      "args": ["{mcpRepoDir}/accessibility-issues-template-mcp/build/index.js"]
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "a11y-devkit-deploy",
+  "version": "0.4.0",
+  "description": "CLI to deploy a11y skills and MCP servers across IDEs",
+  "license": "MIT",
+  "type": "module",
+  "main": "src/cli.js",
+  "bin": {
+    "a11y-devkit-deploy": "bin/a11y-skills.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "config",
+    "README.md"
+  ],
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "mcp",
+    "model-context-protocol",
+    "copilot",
+    "skills",
+    "wcag",
+    "aria",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joe-watkins/a11y-skills-npm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/joe-watkins/a11y-skills-npm/issues"
+  },
+  "homepage": "https://github.com/joe-watkins/a11y-skills-npm#readme",
+  "author": "Joe Watkins",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node bin/a11y-skills.js"
+  },
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "ora": "^6.3.1",
+    "picocolors": "^1.1.0",
+    "prompts": "^2.4.2"
+  }
+}

package/src/cli.js

@@ -0,0 +1,194 @@
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import prompts from "prompts";
+
+import { header, info, warn, success, startSpinner, formatPath } from "./ui.js";
+import { getPlatform, getIdePaths, getMcpServerDir, getTempDir } from "./paths.js";
+import { ensureRepo, buildMcp, copyMcpServers, cleanupTemp } from "./installers/repo.js";
+import { findSkillsDir, copySkills } from "./installers/skills.js";
+import { resolveServers, installMcpConfig } from "./installers/mcp.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function loadConfig() {
+  const configPath = path.join(__dirname, "..", "config", "a11y.json");
+  const raw = await fs.readFile(configPath, "utf8");
+  return JSON.parse(raw);
+}
+
+function parseArgs(argv) {
+  const args = new Set(argv.slice(2));
+  return {
+    autoYes: args.has("--yes") || args.has("-y"),
+    scope: args.has("--global") ? "global" : args.has("--local") ? "local" : null
+  };
+}
+
+function formatOs(platformInfo) {
+  if (platformInfo.isWindows) return "Windows";
+  if (platformInfo.isMac) return "macOS";
+  if (platformInfo.isLinux) return "Linux";
+  return platformInfo.platform;
+}
+
+async function run() {
+  const projectRoot = process.cwd();
+  const platformInfo = getPlatform();
+  const config = await loadConfig();
+  const idePaths = getIdePaths(projectRoot, platformInfo, config.ideSkillsPaths);
+  const args = parseArgs(process.argv);
+  const homeDir = os.homedir();
+
+  header("A11y Devkit Deploy", "Install skills + MCP servers across IDEs");
+  info(`Detected OS: ${formatOs(platformInfo)}`);
+
+  const ideChoices = [
+    { title: "Claude Code", value: "claude" },
+    { title: "Cursor", value: "cursor" },
+    { title: "Codex", value: "codex" },
+    { title: "VSCode", value: "vscode" }
+  ];
+
+  let scope = args.scope;
+  let ideSelection = ["claude", "cursor", "codex", "vscode"];
+  let installSkills = true;
+
+  if (!args.autoYes) {
+    const response = await prompts(
+      [
+        {
+          type: scope ? null : "select",
+          name: "scope",
+          message: "Install skills + repo locally or globally?",
+          choices: [
+            { title: "Local to this project", value: "local" },
+            { title: "Global for this user", value: "global" }
+          ],
+          initial: 0
+        },
+        {
+          type: "multiselect",
+          name: "ides",
+          message: "Configure MCP for which IDEs?",
+          choices: ideChoices,
+          initial: ideChoices.map((_, index) => index)
+        },
+        {
+          type: "toggle",
+          name: "installSkills",
+          message: "Install skills into IDE skills folders?",
+          active: "yes",
+          inactive: "no",
+          initial: true
+        }
+      ],
+      {
+        onCancel: () => {
+          warn("Setup cancelled.");
+          process.exit(0);
+        }
+      }
+    );
+
+    scope = scope || response.scope;
+    ideSelection = response.ides || ideSelection;
+    installSkills = response.installSkills;
+  }
+
+  if (!scope) {
+    scope = "local";
+  }
+
+  if (!ideSelection.length) {
+    warn("No IDEs selected. MCP installation requires at least one IDE.");
+    process.exit(1);
+  }
+
+  info(`Install scope: ${scope === "local" ? "Local" : "Global"}`);
+
+  // Create temp directory for cloning and building
+  const tempDir = path.join(getTempDir(), `.a11y-devkit-${Date.now()}`);
+  const tempSkillsDir = path.join(tempDir, "skills");
+  const tempMcpDir = path.join(tempDir, "mcp");
+
+  // Determine MCP server destination based on IDE selection
+  const mcpServerDir = getMcpServerDir(homeDir, ideSelection);
+  info(`MCP servers: ${formatPath(mcpServerDir)}`);
+
+  // Clone skills repo into temp
+  const repoSpinner = startSpinner("Syncing a11y-skills repo...");
+  const repoResult = await ensureRepo({
+    url: config.repo.url,
+    dir: tempSkillsDir
+  });
+  repoSpinner.succeed(`Repo ${repoResult.action}: ${formatPath(repoResult.dir)}`);
+
+  // Clone and build MCP repos in temp
+  if (config.mcpRepos && config.mcpRepos.length > 0) {
+    const mcpSpinner = startSpinner(`Syncing ${config.mcpRepos.length} MCP repos...`);
+    for (const mcpRepo of config.mcpRepos) {
+      const mcpDir = path.join(tempMcpDir, mcpRepo.dirName);
+      await ensureRepo({
+        url: mcpRepo.url,
+        dir: mcpDir
+      });
+
+      // Build MCP if build commands are specified
+      if (mcpRepo.buildCommands) {
+        mcpSpinner.text = `Building ${mcpRepo.dirName}...`;
+        await buildMcp({
+          dir: mcpDir,
+          buildCommands: mcpRepo.buildCommands
+        });
+      }
+    }
+    mcpSpinner.succeed(`MCP repos synced and built in temp directory`);
+  }
+
+  // Copy MCP servers from temp to final location
+  const copySpinner = startSpinner("Installing MCP servers...");
+  await copyMcpServers(tempMcpDir, mcpServerDir);
+  copySpinner.succeed(`MCP servers installed to ${formatPath(mcpServerDir)}`);
+
+  if (installSkills) {
+    const skillsSpinner = startSpinner("Installing skills to IDE folders...");
+    const sourceDir = await findSkillsDir(tempSkillsDir, config.skillsSearchPaths);
+    if (!sourceDir) {
+      skillsSpinner.fail("No skills directory found in repo.");
+    } else {
+      const skillTargets = scope === "local"
+        ? ideSelection.map((ide) => idePaths[ide].localSkillsDir)
+        : ideSelection.map((ide) => idePaths[ide].skillsDir);
+
+      for (const target of skillTargets) {
+        await copySkills(sourceDir, target);
+      }
+
+      skillsSpinner.succeed(`Skills installed to ${skillTargets.length} IDE location(s).`);
+    }
+  } else {
+    warn("Skipping skills install to IDE folders.");
+  }
+
+  const serverDefs = resolveServers(config.mcpServers, mcpServerDir, mcpServerDir);
+  const mcpSpinner = startSpinner("Updating MCP configurations...");
+  for (const ide of ideSelection) {
+    await installMcpConfig(idePaths[ide].mcpConfig, serverDefs, idePaths[ide].mcpServerKey);
+  }
+  mcpSpinner.succeed(`MCP configs updated for ${ideSelection.length} IDE(s).`);
+
+  // Clean up temporary directory
+  const cleanupSpinner = startSpinner("Cleaning up temporary files...");
+  await cleanupTemp(tempDir);
+  cleanupSpinner.succeed("Temporary files removed");
+
+  success("All done. Your skills and MCP servers are ready.");
+  info("You can re-run this CLI any time to update the repo and configs.");
+}
+
+export {
+  run
+};

package/src/installers/mcp.js

@@ -0,0 +1,69 @@
+import fs from "fs/promises";
+import path from "path";
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function loadJson(filePath) {
+  if (!(await pathExists(filePath))) {
+    return {};
+  }
+
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch (error) {
+    const backupPath = `${filePath}.bak`;
+    await fs.copyFile(filePath, backupPath);
+    return {};
+  }
+}
+
+function resolveServers(servers, repoDir, mcpRepoDir) {
+  return servers.map((server) => {
+    const args = Array.isArray(server.args) ? server.args : [];
+    return {
+      ...server,
+      args: args.map((value) => 
+        value.replace("{repoDir}", repoDir).replace("{mcpRepoDir}", mcpRepoDir)
+      )
+    };
+  });
+}
+
+function mergeServers(existing, incoming, serverKey = "servers") {
+  const existingServers = existing[serverKey] && typeof existing[serverKey] === "object"
+    ? existing[serverKey]
+    : {};
+
+  const merged = { ...existing, [serverKey]: { ...existingServers } };
+
+  for (const server of incoming) {
+    merged[serverKey][server.name] = {
+      command: server.command,
+      args: server.args || [],
+      env: server.env || {},
+      cwd: server.cwd
+    };
+  }
+
+  return merged;
+}
+
+async function installMcpConfig(configPath, servers, serverKey = "servers") {
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  const existing = await loadJson(configPath);
+  const updated = mergeServers(existing, servers, serverKey);
+  await fs.writeFile(configPath, `${JSON.stringify(updated, null, 2)}\n`, "utf8");
+}
+
+export {
+  resolveServers,
+  installMcpConfig
+};

package/src/installers/repo.js

@@ -0,0 +1,103 @@
+import fs from "fs/promises";
+import path from "path";
+import { spawn } from "child_process";
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "inherit", ...options });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(" ")} failed with code ${code}`));
+    });
+  });
+}
+
+async function ensureRepo({ url, dir }) {
+  const hasDir = await pathExists(dir);
+  const gitDir = path.join(dir, ".git");
+
+  if (hasDir) {
+    const isGitRepo = await pathExists(gitDir);
+    if (!isGitRepo) {
+      throw new Error(`Target exists but is not a git repo: ${dir}`);
+    }
+
+    await run("git", ["-C", dir, "pull", "--ff-only"]);
+    return { action: "updated", dir };
+  }
+
+  await run("git", ["clone", "--depth", "1", url, dir]);
+  return { action: "cloned", dir };
+}
+
+async function buildMcp({ dir, buildCommands }) {
+  if (!buildCommands || buildCommands.length === 0) {
+    return;
+  }
+
+  for (const command of buildCommands) {
+    const parts = command.split(" ");
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    await run(cmd, args, { cwd: dir, shell: true });
+  }
+}
+
+async function copyDirectory(source, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(source, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(source, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+async function copyMcpServers(tempMcpDir, finalMcpDir) {
+  if (!(await pathExists(tempMcpDir))) {
+    return;
+  }
+
+  await fs.mkdir(finalMcpDir, { recursive: true });
+  const entries = await fs.readdir(tempMcpDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const srcPath = path.join(tempMcpDir, entry.name);
+      const destPath = path.join(finalMcpDir, entry.name);
+      await copyDirectory(srcPath, destPath);
+    }
+  }
+}
+
+async function cleanupTemp(tempDir) {
+  if (await pathExists(tempDir)) {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+export {
+  ensureRepo,
+  buildMcp,
+  copyMcpServers,
+  cleanupTemp
+};

package/src/installers/skills.js

@@ -0,0 +1,31 @@
+import fs from "fs/promises";
+import path from "path";
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findSkillsDir(repoDir, candidates) {
+  for (const candidate of candidates) {
+    const fullPath = path.join(repoDir, candidate);
+    if (await pathExists(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+
+async function copySkills(sourceDir, targetDir) {
+  await fs.mkdir(targetDir, { recursive: true });
+  await fs.cp(sourceDir, targetDir, { recursive: true, force: true });
+}
+
+export {
+  findSkillsDir,
+  copySkills
+};

package/src/paths.js

@@ -0,0 +1,93 @@
+import os from "os";
+import path from "path";
+
+function getPlatform() {
+  const platform = os.platform();
+  return {
+    platform,
+    isWindows: platform === "win32",
+    isMac: platform === "darwin",
+    isLinux: platform === "linux"
+  };
+}
+
+function getTempDir() {
+  return os.tmpdir();
+}
+
+function getAppSupportDir(platformInfo = getPlatform()) {
+  if (platformInfo.isWindows) {
+    return (
+      process.env.APPDATA ||
+      path.join(os.homedir(), "AppData", "Roaming")
+    );
+  }
+
+  if (platformInfo.isMac) {
+    return path.join(os.homedir(), "Library", "Application Support");
+  }
+
+  return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+}
+
+function getMcpServerDir(home, ideSelection) {
+  // Single IDE: use IDE-specific path (~/.claude/mcp/servers/)
+  // Multiple IDEs: use shared path (~/.mcp/servers/)
+  if (ideSelection.length === 1) {
+    return path.join(home, `.${ideSelection[0]}`, "mcp", "servers");
+  }
+  return path.join(home, ".mcp", "servers");
+}
+
+function getIdePaths(projectRoot, platformInfo = getPlatform(), ideSkillsPaths = null) {
+  const appSupport = getAppSupportDir(platformInfo);
+  const home = os.homedir();
+
+  // Default paths if not provided via config
+  const skillsPaths = ideSkillsPaths || {
+    claude: ".claude/skills",
+    cursor: ".cursor/skills",
+    codex: ".codex/skills",
+    vscode: ".vscode/skills",
+    local: ".github/skills"
+  };
+
+  return {
+    claude: {
+      name: "Claude Code",
+      mcpConfig: path.join(appSupport, "Claude", "mcp.json"),
+      mcpServerKey: "servers",
+      skillsDir: path.join(home, skillsPaths.claude),
+      localSkillsDir: path.join(projectRoot, skillsPaths.claude)
+    },
+    cursor: {
+      name: "Cursor",
+      mcpConfig: path.join(appSupport, "Cursor", "mcp.json"),
+      mcpServerKey: "mcpServers",
+      skillsDir: path.join(home, skillsPaths.cursor),
+      localSkillsDir: path.join(projectRoot, skillsPaths.cursor)
+    },
+    codex: {
+      name: "Codex",
+      mcpConfig: path.join(home, ".codex", "mcp.json"),
+      mcpServerKey: "servers",
+      skillsDir: path.join(home, skillsPaths.codex),
+      localSkillsDir: path.join(projectRoot, skillsPaths.codex)
+    },
+    vscode: {
+      name: "VSCode",
+      mcpConfig: path.join(appSupport, "Code", "User", "mcp.json"),
+      mcpServerKey: "servers",
+      skillsDir: path.join(home, skillsPaths.vscode),
+      localSkillsDir: path.join(projectRoot, skillsPaths.vscode)
+    }
+  };
+}
+
+export {
+  getPlatform,
+  getAppSupportDir,
+  getIdePaths,
+  getMcpServerDir,
+  getTempDir
+};

package/src/ui.js

@@ -0,0 +1,57 @@
+import boxen from "boxen";
+import pc from "picocolors";
+import ora from "ora";
+
+const bullets = {
+  info: pc.cyan("i"),
+  warn: pc.yellow("!"),
+  error: pc.red("x"),
+  success: pc.green("ok")
+};
+
+function header(title, subtitle) {
+  const line = subtitle ? `${pc.dim(subtitle)}` : "";
+  const content = [pc.bold(title), line].filter(Boolean).join("\n");
+  console.log(
+    boxen(content, {
+      padding: 1,
+      margin: { top: 1, bottom: 1 },
+      borderStyle: "round",
+      borderColor: "cyan"
+    })
+  );
+}
+
+function info(message) {
+  console.log(`${bullets.info} ${message}`);
+}
+
+function warn(message) {
+  console.log(`${bullets.warn} ${message}`);
+}
+
+function success(message) {
+  console.log(`${bullets.success} ${message}`);
+}
+
+function error(message) {
+  console.log(`${bullets.error} ${message}`);
+}
+
+function startSpinner(text) {
+  return ora({ text, spinner: "dots" }).start();
+}
+
+function formatPath(value) {
+  return pc.dim(value);
+}
+
+export {
+  header,
+  info,
+  warn,
+  success,
+  error,
+  startSpinner,
+  formatPath
+};