@nucleoicons/skills 0.1.9 → 0.1.10

package/README.md

@@ -43,6 +43,8 @@ npx @nucleoicons/skills setup --free --target vue --tools cursor
 
 Setup installs the package under your user home (`~/.nucleo/skills`) and configures the editors you choose (skills + MCP, no manual config step).
 
+You can install more than one target. A later `setup --target vue` keeps an existing React install, and the other way around. `update` refreshes every target already on the machine.
+
 Reload MCP in your editor, then ask something like:
 
 ```text
@@ -51,7 +53,7 @@ What Nucleo icon families do I have?
 
 ## Update
 
-Same command for free and Pro — the CLI remembers which package you installed (`--free` is not needed again):
+Same command for free and Pro. The CLI updates every target you have installed (`--free` is not needed again):
 
 ```bash
 npx @nucleoicons/skills update

package/dist/commands/setup.js

@@ -2,7 +2,7 @@ import { confirm, select, checkbox } from "@inquirer/prompts";
 import { mkdir } from "node:fs/promises";
 import { ApiError, fetchSkillsFreeRelease, fetchSkillsRelease } from "../api.js";
 import { installRoot, isPackageTarget, nucleoHomeDir, } from "../config.js";
-import { buildMcp, ensureManifestTarget, hasProFamilies, installFromLocalDir, installFromRelease, readInstallManifest, } from "../install.js";
+import { buildMcp, ensureManifestTarget, hasProFamilies, installFromLocalDir, installFromRelease, readInstallManifest, rootHasIconFamilies, } from "../install.js";
 import { configureTool } from "../adapters/agents.js";
 import { ensureSkillsSession, isInvalidTokenError } from "../session.js";
 async function fetchProReleaseWithSession(target, emailHint) {
@@ -49,6 +49,12 @@ export async function runSetup(options = {}) {
         throw new Error("Select at least one tool to configure.");
     }
     await mkdir(nucleoHomeDir(), { recursive: true });
+    const existing = await readInstallManifest();
+    const primary = existing?.target && isPackageTarget(existing.target) ? existing.target : null;
+    const placement = rootHasIconFamilies() && primary && primary !== target ? "nested" : "root";
+    if (placement === "nested") {
+        console.log(`Keeping the installed ${primary} package. Adding ${target} alongside it.\n`);
+    }
     if (options.from) {
         console.log(`\nInstalling from local folder:\n  ${options.from}\n`);
         if (!options.yes) {
@@ -68,7 +74,7 @@ export async function runSetup(options = {}) {
         });
     }
     else if (free) {
-        const mergingIntoPro = hasProFamilies();
+        const mergingIntoPro = placement === "root" && hasProFamilies();
         if (mergingIntoPro) {
             console.log("Existing Pro install detected — free icons will be added alongside Pro.\n");
         }
@@ -87,7 +93,7 @@ export async function runSetup(options = {}) {
         console.log(`  Families: ${release.families.join(", ")}`);
         console.log(`  Files:    ${release.files.map((f) => f.id).join(", ")}`);
         console.log("\nDownloading…");
-        await installFromRelease(release, target);
+        await installFromRelease(release, target, undefined, { placement });
     }
     else {
         console.log(`Fetching ${target} release (Pro + free)…`);
@@ -105,7 +111,7 @@ export async function runSetup(options = {}) {
         console.log(`  Families: ${release.families.join(", ")}`);
         console.log(`  Files:    ${release.files.map((f) => f.id).join(", ")}`);
         console.log("\nDownloading…");
-        await installFromRelease(release, target);
+        await installFromRelease(release, target, undefined, { placement });
     }
     console.log("Building MCP…");
     await buildMcp();
@@ -116,7 +122,8 @@ export async function runSetup(options = {}) {
     const manifest = await readInstallManifest();
     console.log("\n✓ Done");
     console.log(`  Install path: ${installRoot()}`);
-    console.log(`  Target:       ${manifest?.target ?? target}`);
+    const installedTargets = manifest?.targets?.filter((entry) => typeof entry === "string") ?? [];
+    console.log(`  Targets:      ${installedTargets.join(", ") || manifest?.target || target}`);
     console.log(`  Tier:         ${manifest?.tier ?? (free ? "free" : "pro")}`);
     console.log(`  Version:      ${manifest?.version ?? "(none)"}`);
     console.log(`  Families:     ${(manifest?.families ?? []).join(", ") || "(none)"}`);

package/dist/commands/status.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { installRoot, credentialsPath } from "../config.js";
 import { loadCredentials } from "../credentials.js";
-import { mcpEntryPath, readInstallManifest } from "../install.js";
+import { listInstalledTargets, mcpEntryPath, readInstallManifest } from "../install.js";
 export async function runStatus() {
     console.log("\nNucleo Skills status");
     console.log("────────────────────\n");
@@ -22,7 +22,8 @@ export async function runStatus() {
     }
     const manifest = await readInstallManifest();
     console.log(`Version:     ${manifest?.version ?? "(missing)"}`);
-    console.log(`Target:      ${manifest?.target ?? "(missing)"}`);
+    const targets = listInstalledTargets(manifest);
+    console.log(`Targets:     ${targets.join(", ") || manifest?.target || "(missing)"}`);
     console.log(`Tier:        ${manifest?.tier ?? "(missing)"}`);
     console.log(`Product:     ${manifest?.product ?? "(missing)"}`);
     console.log(`Families:    ${(manifest?.families ?? []).join(", ") || "(none)"}`);

package/dist/commands/update.js

@@ -1,7 +1,7 @@
 import { confirm } from "@inquirer/prompts";
 import { ApiError, fetchSkillsFreeRelease, fetchSkillsRelease } from "../api.js";
 import { installRoot } from "../config.js";
-import { buildMcp, ensureManifestTarget, installFromLocalDir, installFromRelease, isFreeOnlyInstall, readInstallManifest, } from "../install.js";
+import { buildMcp, ensureManifestTarget, installFromLocalDir, installFromRelease, isFreeOnlyInstall, listInstalledTargets, readInstallManifest, } from "../install.js";
 import { configureTool } from "../adapters/agents.js";
 import { ensureSkillsSession, isInvalidTokenError } from "../session.js";
 async function fetchProReleaseWithSession(target) {
@@ -25,7 +25,8 @@ export async function runUpdate(options = {}) {
     if (!manifest && !options.from) {
         throw new Error(`No install found at ${installRoot()}.\nRun: nucleo-skills setup`);
     }
-    const target = manifest?.target ?? "react";
+    const targets = listInstalledTargets(manifest ?? null);
+    const target = targets[0] ?? (manifest?.target ?? "react");
     const localVersion = manifest?.version ?? "0.0.0";
     const freeOnly = isFreeOnlyInstall(installRoot(), manifest);
     if (options.from) {
@@ -60,6 +61,7 @@ export async function runUpdate(options = {}) {
     const remoteVersion = release.version;
     console.log(`  Installed: ${localVersion}`);
     console.log(`  Latest:    ${remoteVersion}`);
+    console.log(`  Targets:   ${targets.join(", ") || target}`);
     console.log(`  Families:  ${release.families.join(", ")}`);
     if (options.check) {
         if (remoteVersion === localVersion) {
@@ -85,7 +87,23 @@ export async function runUpdate(options = {}) {
         }
     }
     console.log("\nDownloading…");
-    await installFromRelease(release, target);
+    const extras = targets.filter((installed) => installed !== target);
+    for (const extra of extras) {
+        console.log(`\n${extra}`);
+        const extraRelease = freeOnly
+            ? await fetchSkillsFreeRelease(extra)
+            : await fetchProReleaseWithSession(extra);
+        await installFromRelease(extraRelease, extra, undefined, { placement: "nested" });
+    }
+    const rootRelease = extras.length === 0
+        ? release
+        : freeOnly
+            ? await fetchSkillsFreeRelease(target)
+            : await fetchProReleaseWithSession(target);
+    if (extras.length > 0) {
+        console.log(`\n${target}`);
+    }
+    await installFromRelease(rootRelease, target, undefined, { placement: "root" });
     console.log("Building MCP…");
     await buildMcp();
     await reconfigure(options.tools ?? ["cursor"]);

package/dist/config.d.ts

@@ -19,7 +19,10 @@ export interface InstallManifest {
     product?: string;
     /** free | pro | pro+free — drives update channel without requiring --free again */
     tier?: "free" | "pro" | "pro+free" | string;
+    /** Original install. Stays at the root of ~/.nucleo/skills so older packages keep working. */
     target?: PackageTarget | string;
+    /** Every installed format, including `target`. Extra formats live in `targets/<id>/`. */
+    targets?: PackageTarget[] | string[];
     version?: string;
     families?: string[];
     [key: string]: unknown;

package/dist/install.d.ts

@@ -11,14 +11,23 @@ export declare const FREE_FAMILIES: readonly ["flags", "cursors", "credit-cards"
  */
 export declare function resolveNpmBin(): string;
 export declare function readInstallManifest(root?: string): Promise<InstallManifest | null>;
+/**
+ * Replace the original install at the root. Extra targets live in `targets/`
+ * and are moved aside so they survive the wipe.
+ */
 export declare function cleanInstallRoot(root?: string): Promise<void>;
-/** True if any Pro family catalog is present under the install root. */
+/** Icon families sitting directly in the original install (not under `targets/`). */
+export declare function rootHasIconFamilies(root?: string): boolean;
+export declare function targetInstallDir(target: PackageTarget, root?: string): string;
+/** True if any Pro family catalog is present at the root or under `targets/`. */
 export declare function hasProFamilies(root?: string): boolean;
-/** True if any free family catalog is present under the install root. */
+/** True if any free family catalog is present at the root or under `targets/`. */
 export declare function hasFreeFamilies(root?: string): boolean;
 /**
- * Detect installed icon families by looking for `{family}/icons.json`.
+ * Original target at the install root, then every other format.
+ * A single-target install from an older CLI is just `[manifest.target]`.
  */
+export declare function listInstalledTargets(manifest: InstallManifest | null, root?: string): PackageTarget[];
 export declare function detectInstalledFamilies(root?: string): string[];
 export declare function resolveInstallTier(root?: string): {
     hasPro: boolean;
@@ -37,6 +46,11 @@ export interface InstallFromReleaseOptions {
      * Default: auto — merge free releases onto an existing Pro install.
      */
     merge?: boolean;
+    /**
+     * `root` replaces the original install and keeps `targets/`.
+     * `nested` adds this format under `targets/<target>/` and leaves the original install in place.
+     */
+    placement?: "root" | "nested";
 }
 /**
  * Download all release files (signed URLs) and install into the root.

package/dist/install.js

@@ -1,11 +1,11 @@
-import { existsSync } from "node:fs";
-import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
+import { cp, mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import extract from "extract-zip";
 import { downloadUrlToFile, formatBytes } from "./api.js";
-import { installRoot, nucleoHomeDir } from "./config.js";
+import { installRoot, isPackageTarget, nucleoHomeDir, } from "./config.js";
 const execFileAsync = promisify(execFile);
 /** Licensed Pro families — never installed via the free (no-auth) channel. */
 export const PRO_FAMILIES = ["core", "ui", "sharp", "micro", "pixel"];
@@ -66,24 +66,121 @@ export async function readInstallManifest(root = installRoot()) {
         return null;
     }
 }
+function targetsStashPath() {
+    return join(nucleoHomeDir(), "targets-stash");
+}
+/**
+ * Replace the original install at the root. Extra targets live in `targets/`
+ * and are moved aside so they survive the wipe.
+ */
 export async function cleanInstallRoot(root = installRoot()) {
+    const targetsDir = join(root, "targets");
+    const stash = targetsStashPath();
+    if (!existsSync(targetsDir) && existsSync(stash)) {
+        await mkdir(root, { recursive: true });
+        await rename(stash, targetsDir);
+    }
+    let stashed = false;
+    if (existsSync(targetsDir)) {
+        await rm(stash, { recursive: true, force: true });
+        await rename(targetsDir, stash);
+        stashed = true;
+    }
     await rm(root, { recursive: true, force: true });
     await mkdir(root, { recursive: true });
+    if (stashed) {
+        await rename(stash, join(root, "targets"));
+    }
+}
+function directoryHasProFamilies(dir) {
+    return PRO_FAMILIES.some((family) => existsSync(join(dir, family, "icons.json")));
 }
-/** True if any Pro family catalog is present under the install root. */
+function directoryHasFreeFamilies(dir) {
+    return FREE_FAMILIES.some((family) => existsSync(join(dir, family, "icons.json")));
+}
+/** Icon families sitting directly in the original install (not under `targets/`). */
+export function rootHasIconFamilies(root = installRoot()) {
+    return directoryHasProFamilies(root) || directoryHasFreeFamilies(root);
+}
+export function targetInstallDir(target, root = installRoot()) {
+    return join(root, "targets", target);
+}
+/** True if any Pro family catalog is present at the root or under `targets/`. */
 export function hasProFamilies(root = installRoot()) {
-    return PRO_FAMILIES.some((family) => existsSync(join(root, family, "icons.json")));
+    if (directoryHasProFamilies(root)) {
+        return true;
+    }
+    const targetsDir = join(root, "targets");
+    if (!existsSync(targetsDir)) {
+        return false;
+    }
+    return readdirSync(targetsDir).some((name) => directoryHasProFamilies(join(targetsDir, name)));
 }
-/** True if any free family catalog is present under the install root. */
+/** True if any free family catalog is present at the root or under `targets/`. */
 export function hasFreeFamilies(root = installRoot()) {
-    return FREE_FAMILIES.some((family) => existsSync(join(root, family, "icons.json")));
+    if (directoryHasFreeFamilies(root)) {
+        return true;
+    }
+    const targetsDir = join(root, "targets");
+    if (!existsSync(targetsDir)) {
+        return false;
+    }
+    return readdirSync(targetsDir).some((name) => directoryHasFreeFamilies(join(targetsDir, name)));
+}
+/**
+ * Original target at the install root, then every other format.
+ * A single-target install from an older CLI is just `[manifest.target]`.
+ */
+export function listInstalledTargets(manifest, root = installRoot()) {
+    const found = new Set();
+    if (manifest?.target && isPackageTarget(manifest.target)) {
+        found.add(manifest.target);
+    }
+    if (Array.isArray(manifest?.targets)) {
+        for (const entry of manifest.targets) {
+            if (typeof entry === "string" && isPackageTarget(entry)) {
+                found.add(entry);
+            }
+        }
+    }
+    const targetsDir = join(root, "targets");
+    if (existsSync(targetsDir)) {
+        for (const name of readdirSync(targetsDir)) {
+            if (!isPackageTarget(name)) {
+                continue;
+            }
+            const dir = join(targetsDir, name);
+            if (directoryHasProFamilies(dir) || directoryHasFreeFamilies(dir)) {
+                found.add(name);
+            }
+        }
+    }
+    const primary = manifest?.target && isPackageTarget(manifest.target)
+        ? manifest.target
+        : rootHasIconFamilies(root)
+            ? ([...found][0] ?? null)
+            : null;
+    const rest = [...found].filter((target) => target !== primary);
+    return primary ? [primary, ...rest] : rest;
 }
 /**
  * Detect installed icon families by looking for `{family}/icons.json`.
  */
-export function detectInstalledFamilies(root = installRoot()) {
+function familiesInDir(dir) {
     const known = [...PRO_FAMILIES, ...FREE_FAMILIES];
-    return known.filter((family) => existsSync(join(root, family, "icons.json")));
+    return known.filter((family) => existsSync(join(dir, family, "icons.json")));
+}
+export function detectInstalledFamilies(root = installRoot()) {
+    const found = new Set(familiesInDir(root));
+    const targetsDir = join(root, "targets");
+    if (existsSync(targetsDir)) {
+        for (const name of readdirSync(targetsDir)) {
+            for (const family of familiesInDir(join(targetsDir, name))) {
+                found.add(family);
+            }
+        }
+    }
+    return [...found];
 }
 export function resolveInstallTier(root = installRoot()) {
     const hasPro = hasProFamilies(root);
@@ -180,7 +277,12 @@ export async function installFromRelease(release, target, root = installRoot(),
         throw new Error(`Release files missing download urls: ${missingUrl.map((f) => f.id).join(", ")}`);
     }
     const isFreeRelease = release.tier === "free";
-    const merge = options.merge ?? (isFreeRelease && existsSync(root) && hasProFamilies(root));
+    const placement = options.placement ?? "root";
+    const destination = placement === "nested" ? targetInstallDir(target, root) : root;
+    const previous = await readInstallManifest(root);
+    const previousTargets = listInstalledTargets(previous, root);
+    const merge = options.merge ??
+        (isFreeRelease && existsSync(destination) && directoryHasProFamilies(destination));
     // Safety: free channel must never claim Pro family modules.
     if (isFreeRelease) {
         const forbidden = release.files.filter((f) => PRO_FAMILIES.includes(f.id));
@@ -221,26 +323,43 @@ export async function installFromRelease(release, target, root = installRoot(),
             }
             downloaded.push({ id: file.id, zipPath });
         }
-        // 2) Extract — wipe unless merging free into Pro
-        console.log(merge ? "  Merging into existing install (Pro families kept)…" : "  Extracting…");
-        if (!merge) {
-            await cleanInstallRoot(root);
+        // 2) Extract — a failed download above does not wipe a previous install
+        console.log(placement === "nested"
+            ? `  Extracting ${target} alongside the existing install…`
+            : merge
+                ? "  Merging into existing install (Pro families kept)…"
+                : "  Extracting…");
+        if (placement === "nested") {
+            const staging = join(nucleoHomeDir(), "staging");
+            await rm(staging, { recursive: true, force: true });
+            await mkdir(staging, { recursive: true });
+            try {
+                for (const file of downloaded) {
+                    await extractReleaseZip(file.zipPath, file.id, staging);
+                }
+                if (!merge) {
+                    await rm(destination, { recursive: true, force: true });
+                }
+                await mkdir(destination, { recursive: true });
+                await mkdir(root, { recursive: true });
+                await placeStagedRelease(staging, destination, root);
+            }
+            finally {
+                await rm(staging, { recursive: true, force: true }).catch(() => undefined);
+            }
+            if (familiesInDir(destination).length === 0) {
+                throw new Error(`No icon families were extracted for ${target}.`);
+            }
         }
         else {
-            await mkdir(root, { recursive: true });
-        }
-        for (const file of downloaded) {
-            const zipInfo = await stat(file.zipPath);
-            process.stdout.write(`  ▸ ${file.id} (${formatBytes(zipInfo.size)}) `);
-            try {
-                await extractZipMerge(file.zipPath, root);
-                console.log(`  ✓ ${file.id}`);
+            if (!merge) {
+                await cleanInstallRoot(root);
             }
-            catch (error) {
-                const detail = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed extracting ${file.id} (${formatBytes(zipInfo.size)}). ${detail}\n` +
-                    `If this keeps happening, free disk space or try again with:\n` +
-                    `  NODE_OPTIONS=--max-old-space-size=8192 npx @nucleoicons/skills setup …`);
+            else {
+                await mkdir(root, { recursive: true });
+            }
+            for (const file of downloaded) {
+                await extractReleaseZip(file.zipPath, file.id, root);
             }
         }
         await assertInstallLooksComplete(root);
@@ -250,14 +369,55 @@ export async function installFromRelease(release, target, root = installRoot(),
     }
     const families = detectInstalledFamilies(root);
     const { tier } = resolveInstallTier(root);
+    const primary = placement === "nested" && previous?.target && isPackageTarget(previous.target)
+        ? previous.target
+        : target;
+    const targets = [...new Set([primary, ...previousTargets, target])];
     await writeInstallManifest({
         product: tier === "free" ? "nucleo-skills-free" : "nucleo-skills",
         tier,
-        target,
+        target: primary,
+        targets,
         version: release.version,
         families,
     }, root);
 }
+async function extractReleaseZip(zipPath, id, dest) {
+    const zipInfo = await stat(zipPath);
+    process.stdout.write(`  ▸ ${id} (${formatBytes(zipInfo.size)}) `);
+    try {
+        await extractZipMerge(zipPath, dest);
+        console.log(`  ✓ ${id}`);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed extracting ${id} (${formatBytes(zipInfo.size)}). ${detail}\n` +
+            `If this keeps happening, free disk space or try again with:\n` +
+            `  NODE_OPTIONS=--max-old-space-size=8192 npx @nucleoicons/skills setup …`);
+    }
+}
+/** Copy mcp/skills to the install root and family folders to `familyDest`. Skips manifest.json. */
+async function placeStagedRelease(staging, familyDest, sharedDest) {
+    const entries = await readdir(staging, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.name === "manifest.json") {
+            continue;
+        }
+        const from = join(staging, entry.name);
+        if (entry.name === "mcp" || entry.name === "skills") {
+            const to = join(sharedDest, entry.name);
+            await rm(to, { recursive: true, force: true });
+            await cp(from, to, { recursive: true });
+            continue;
+        }
+        if (!entry.isDirectory() || !existsSync(join(from, "icons.json"))) {
+            continue;
+        }
+        const to = join(familyDest, entry.name);
+        await rm(to, { recursive: true, force: true });
+        await cp(from, to, { recursive: true });
+    }
+}
 /**
  * Copy a local prepared package (e.g. packages/react) into the install root.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nucleoicons/skills",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "CLI to install and update Nucleo MCP + icon skills (Pro and free)",
   "type": "module",
   "bin": {