ui-pro-forge-cli 2.5.0

package/dist/utils/template.js

@@ -0,0 +1,249 @@
+import { existsSync } from 'node:fs';
+import { readFile, mkdir, writeFile, cp, access, readdir, lstat, rm } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ASSETS_CANDIDATES = [
+    // Bun bundle: dist/index.js
+    join(__dirname, '..', 'assets'),
+    // TypeScript fallback: dist/utils/template.js
+    join(__dirname, '..', '..', 'assets'),
+];
+const ASSETS_DIR = ASSETS_CANDIDATES.find(path => existsSync(path)) ?? ASSETS_CANDIDATES[0];
+// Map AIType to platform config file name
+const AI_TO_PLATFORM = {
+    claude: 'claude',
+    cursor: 'cursor',
+    windsurf: 'windsurf',
+    antigravity: 'agent',
+    copilot: 'copilot',
+    kiro: 'kiro',
+    opencode: 'opencode',
+    roocode: 'roocode',
+    codex: 'codex',
+    qoder: 'qoder',
+    gemini: 'gemini',
+    trae: 'trae',
+    continue: 'continue',
+    codebuddy: 'codebuddy',
+    droid: 'droid',
+    kilocode: 'kilocode',
+    warp: 'warp',
+    augment: 'augment',
+    codewhale: 'codewhale',
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load platform configuration from JSON file
+ */
+export async function loadPlatformConfig(aiType) {
+    const platformName = AI_TO_PLATFORM[aiType];
+    if (!platformName) {
+        throw new Error(`Unknown AI type: ${aiType}`);
+    }
+    const configPath = join(ASSETS_DIR, 'templates', 'platforms', `${platformName}.json`);
+    const content = await readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Load all available platform configs
+ */
+export async function loadAllPlatformConfigs() {
+    const configs = new Map();
+    for (const [aiType, platformName] of Object.entries(AI_TO_PLATFORM)) {
+        try {
+            const config = await loadPlatformConfig(aiType);
+            configs.set(aiType, config);
+        }
+        catch {
+            // Skip if config doesn't exist
+        }
+    }
+    return configs;
+}
+/**
+ * Load a template file
+ */
+async function loadTemplate(templateName) {
+    const templatePath = join(ASSETS_DIR, 'templates', templateName);
+    return readFile(templatePath, 'utf-8');
+}
+/**
+ * Render frontmatter section
+ */
+function renderFrontmatter(frontmatter) {
+    if (!frontmatter)
+        return '';
+    const lines = ['---'];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        // Quote values that contain special characters
+        if (value.includes(':') || value.includes('"') || value.includes('\n')) {
+            lines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    lines.push('---', '');
+    return lines.join('\n');
+}
+/**
+ * Render skill file content from template
+ * When isGlobal=true, rewrites script paths to use ~/{root}/ prefix
+ */
+export async function renderSkillFile(config, isGlobal = false) {
+    // Load base template
+    let content = await loadTemplate('base/skill-content.md');
+    // Load quick reference if needed
+    let quickReferenceContent = '';
+    if (config.sections.quickReference) {
+        quickReferenceContent = await loadTemplate('base/quick-reference.md');
+    }
+    // Build the final content
+    const frontmatter = renderFrontmatter(config.frontmatter);
+    // Replace placeholders
+    // Add newline before quick reference content if it exists
+    const quickRefWithNewline = quickReferenceContent ? '\n' + quickReferenceContent : '';
+    content = content
+        .replace(/\{\{TITLE\}\}/g, config.title)
+        .replace(/\{\{DESCRIPTION\}\}/g, config.description)
+        .replace(/\{\{SCRIPT_PATH\}\}/g, config.scriptPath)
+        .replace(/\{\{SKILL_OR_WORKFLOW\}\}/g, config.skillOrWorkflow)
+        .replace(/\{\{QUICK_REFERENCE\}\}/g, quickRefWithNewline);
+    // For global install, rewrite relative script paths to absolute ~/root/ paths
+    if (isGlobal) {
+        const globalPrefix = `~/${config.folderStructure.root}/`;
+        content = content.replace(/python3 skills\//g, `python3 ${globalPrefix}skills/`);
+    }
+    return frontmatter + content;
+}
+/**
+ * Replace a pre-existing non-directory at `path` so a real directory can be
+ * created there. Older CLI installs (and Windows checkouts of the repo's
+ * symlinked data/scripts) can leave plain "pointer" files at these paths;
+ * mkdir then throws EEXIST and the install silently leaves stale files.
+ */
+async function ensureCleanDir(path) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isDirectory()) {
+            await rm(path, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Nothing exists at the path yet — mkdir will create it.
+    }
+}
+/**
+ * Copy data and scripts to target directory
+ */
+async function copyDataAndScripts(targetSkillDir) {
+    const dataSource = join(ASSETS_DIR, 'data');
+    const scriptsSource = join(ASSETS_DIR, 'scripts');
+    const dataTarget = join(targetSkillDir, 'data');
+    const scriptsTarget = join(targetSkillDir, 'scripts');
+    // Copy data
+    if (await exists(dataSource)) {
+        await ensureCleanDir(dataTarget);
+        await mkdir(dataTarget, { recursive: true });
+        await cp(dataSource, dataTarget, { recursive: true });
+    }
+    // Copy scripts
+    if (await exists(scriptsSource)) {
+        await ensureCleanDir(scriptsTarget);
+        await mkdir(scriptsTarget, { recursive: true });
+        await cp(scriptsSource, scriptsTarget, { recursive: true });
+    }
+}
+/**
+ * List the static sub-skills bundled under assets/skills/ (everything except
+ * the template-rendered orchestrator). Empty if the package predates bundling.
+ */
+export async function listBundledSubSkills() {
+    const skillsSource = join(ASSETS_DIR, 'skills');
+    if (!(await exists(skillsSource)))
+        return [];
+    const entries = await readdir(skillsSource, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory()).map(e => e.name).sort();
+}
+/**
+ * Install the bundled sub-skills as siblings of the orchestrator skill, so a
+ * single `uipro init` delivers all 7 skills instead of only ui-pro-forge.
+ */
+async function copySubSkills(skillsParentDir, force) {
+    const skillsSource = join(ASSETS_DIR, 'skills');
+    if (!(await exists(skillsSource)))
+        return;
+    for (const name of await listBundledSubSkills()) {
+        const target = join(skillsParentDir, name);
+        if (await exists(target) && !force)
+            continue;
+        await mkdir(target, { recursive: true });
+        await cp(join(skillsSource, name), target, { recursive: true });
+    }
+}
+/**
+ * Generate platform files for a specific AI type
+ * All platforms use self-contained installation with data and scripts
+ * When isGlobal=true, installs to ~/home directory with absolute script paths
+ */
+export async function generatePlatformFiles(targetDir, aiType, isGlobal = false, force = false) {
+    const config = await loadPlatformConfig(aiType);
+    const createdFolders = [];
+    // For global install, target the user's home directory
+    const effectiveDir = isGlobal ? homedir() : targetDir;
+    // Determine full skill directory path
+    const skillDir = join(effectiveDir, config.folderStructure.root, config.folderStructure.skillPath);
+    // Create directory structure
+    await mkdir(skillDir, { recursive: true });
+    // Render and write skill file (pass isGlobal to adjust paths)
+    const skillContent = await renderSkillFile(config, isGlobal);
+    const skillFilePath = join(skillDir, config.folderStructure.filename);
+    const fileAlreadyExists = await exists(skillFilePath);
+    if (fileAlreadyExists && !force) {
+        console.log(`  Skipped (already exists): ${skillFilePath} — use --force to overwrite`);
+        return [];
+    }
+    await writeFile(skillFilePath, skillContent, 'utf-8');
+    createdFolders.push(config.folderStructure.root);
+    // Copy data and scripts into the skill directory (self-contained)
+    await copyDataAndScripts(skillDir);
+    // Install the sibling sub-skills (banner-design, brand, design, ...) next to
+    // the orchestrator so all 7 skills are delivered. The skills parent is the
+    // orchestrator's parent dir (skills/ for most platforms, prompts/ for
+    // copilot, steering/ for kiro) — derived, not hardcoded.
+    const skillsParentDir = join(effectiveDir, config.folderStructure.root, dirname(config.folderStructure.skillPath));
+    await copySubSkills(skillsParentDir, force);
+    return createdFolders;
+}
+/**
+ * Generate files for all AI types
+ */
+export async function generateAllPlatformFiles(targetDir, isGlobal = false, force = false) {
+    const allFolders = new Set();
+    for (const aiType of Object.keys(AI_TO_PLATFORM)) {
+        try {
+            const folders = await generatePlatformFiles(targetDir, aiType, isGlobal, force);
+            folders.forEach(f => allFolders.add(f));
+        }
+        catch {
+            // Skip if generation fails for a platform
+        }
+    }
+    return Array.from(allFolders);
+}
+/**
+ * Get list of supported AI types
+ */
+export function getSupportedAITypes() {
+    return Object.keys(AI_TO_PLATFORM);
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "ui-pro-forge-cli",
+  "version": "2.5.0",
+  "description": "CLI to install UI Pro Forge skill for AI coding assistants",
+  "type": "module",
+  "bin": {
+    "uiforge": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "dev": "bun run src/index.ts",
+    "sync:assets": "node scripts/sync-assets.mjs",
+    "check:assets": "node scripts/sync-assets.mjs --check",
+    "validate:csv": "cd .. && python3 scripts/validate-csv.py",
+    "smoke:domains": "cd .. && bash scripts/smoke-domains.sh",
+    "smoke:stacks": "cd .. && bash scripts/smoke-stacks.sh",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run sync:assets && npm run validate:csv && npm run smoke:domains && npm run smoke:stacks && npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "claude-code",
+    "claude-skill",
+    "cursor",
+    "cursor-ai",
+    "ai-agent",
+    "ai-coding-assistant",
+    "ui",
+    "ux",
+    "ui-ux",
+    "design",
+    "design-system",
+    "design-intelligence",
+    "color-palette",
+    "typography",
+    "tailwind",
+    "shadcn",
+    "accessibility",
+    "wcag",
+    "windsurf",
+    "copilot",
+    "codex",
+    "ai",
+    "skill",
+    "agent-skill"
+  ],
+  "author": "kterfan",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.61.1",
+    "@types/bun": "^1.1.14",
+    "@types/node": "^22.10.1",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.7.2"
+  }
+}