@aiforui/install 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @aiforui/install
+
+Installs [aiforui.dev](https://aiforui.dev) agent skills into every supported
+coding agent on your machine: Claude Code, Cursor, Codex, Amp, Gemini CLI,
+OpenCode, Windsurf, and Antigravity.
+
+## Usage
+
+Grab your personal install command from [aiforui.dev](https://aiforui.dev)
+(it includes your token), then run it:
+
+```bash
+npx @aiforui/install --token=<token>
+```
+
+Preselect skills by passing their ids:
+
+```bash
+npx @aiforui/install --token=<token> typography color
+```
+
+Non-interactive (installs everything you own, keeps default names):
+
+```bash
+npx @aiforui/install --token=<token> -y
+```
+
+## How it works
+
+- The CLI detects which coding agents are installed by looking for their
+  config directories under your home directory.
+- It fetches the skill files from aiforui.dev, authenticated by your
+  per-user token. Entitlement is checked live against your purchase, so the
+  same command keeps working as new skills are added.
+- Skills are written into each agent's skills directory (for Windsurf, the
+  skill is appended to `global_rules.md`).
+
+## Development
+
+Point the CLI at a local or preview deployment:
+
+```bash
+node bin/cli.js --token=<token> --api=http://localhost:3000
+```

package/bin/cli.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+
+/**
+ * @aiforui/install
+ *
+ * Installs aiforui.dev agent skills into every supported coding agent found
+ * on the machine. Skill content is fetched from aiforui.dev at runtime and
+ * gated by a per-user token, so this CLI rarely needs to be republished.
+ *
+ *   npx @aiforui/install --token=<token>              # interactive
+ *   npx @aiforui/install --token=<token> typography   # preselect a skill
+ *   npx @aiforui/install --token=<token> -y           # non-interactive
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import * as p from "@clack/prompts";
+import color from "picocolors";
+
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+
+const DEFAULT_API = "https://aiforui.dev";
+
+const HOME = os.homedir();
+const underHome = (...seg) => path.join(HOME, ...seg);
+const existsUnderHome = (...seg) => fs.existsSync(underHome(...seg));
+
+function writeSkillFiles(dir, files) {
+  fs.mkdirSync(dir, { recursive: true });
+  for (const file of files) {
+    fs.writeFileSync(path.join(dir, file.name), file.content);
+  }
+}
+
+/**
+ * Every supported agent: how to detect it, where its skills live, and the
+ * prefix used to invoke a skill inside that tool (purely cosmetic, for the
+ * summary line).
+ */
+const AGENTS = [
+  {
+    id: "claude",
+    label: "Claude Code",
+    prefix: "/",
+    detect: () => existsUnderHome(".claude"),
+    install: (skill, name) =>
+      writeSkillFiles(underHome(".claude", "skills", name), skill.files),
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    prefix: "/",
+    detect: () => existsUnderHome(".cursor"),
+    install: (skill, name) =>
+      writeSkillFiles(underHome(".cursor", "skills", name), skill.files),
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    prefix: "$",
+    detect: () => existsUnderHome(".codex"),
+    install: (skill, name) => {
+      const dir = underHome(".codex", "skills", name);
+      writeSkillFiles(dir, skill.files);
+      fs.mkdirSync(path.join(dir, "agents"), { recursive: true });
+      fs.writeFileSync(
+        path.join(dir, "agents", "openai.yaml"),
+        `interface:\n  display_name: "${skill.displayName}"\n  short_description: "${skill.shortDescription}"\n`,
+      );
+    },
+  },
+  {
+    id: "opencode",
+    label: "OpenCode",
+    prefix: "@",
+    detect: () => existsUnderHome(".config", "opencode"),
+    install: (skill, name) =>
+      writeSkillFiles(
+        underHome(".config", "opencode", "skills", name),
+        skill.files,
+      ),
+  },
+  {
+    id: "amp",
+    label: "Amp",
+    prefix: "",
+    detect: () => existsUnderHome(".amp"),
+    install: (skill, name) =>
+      writeSkillFiles(underHome(".config", "amp", "skills", name), skill.files),
+  },
+  {
+    id: "gemini",
+    label: "Gemini CLI",
+    prefix: "/",
+    detect: () => existsUnderHome(".gemini"),
+    install: (skill, name) =>
+      writeSkillFiles(underHome(".gemini", "skills", name), skill.files),
+  },
+  {
+    id: "antigravity",
+    label: "Antigravity",
+    prefix: "/",
+    detect: () => existsUnderHome(".gemini", "antigravity"),
+    install: (skill, name) =>
+      writeSkillFiles(
+        underHome(".gemini", "antigravity", "skills", name),
+        skill.files,
+      ),
+  },
+  {
+    id: "windsurf",
+    label: "Windsurf",
+    prefix: "",
+    detect: () =>
+      existsUnderHome(".codeium") ||
+      existsUnderHome("Library", "Application Support", "Windsurf"),
+    install: (skill) => {
+      const skillFile = skill.files.find((f) => f.name === "SKILL.md");
+      if (!skillFile) return;
+      const dir = underHome(".codeium", "windsurf", "memories");
+      fs.mkdirSync(dir, { recursive: true });
+      const rulesFile = path.join(dir, "global_rules.md");
+      const existing = fs.existsSync(rulesFile)
+        ? fs.readFileSync(rulesFile, "utf-8")
+        : "";
+      if (existing.includes(skill.windsurfMarker)) return;
+      fs.appendFileSync(
+        rulesFile,
+        `${existing.length ? "\n" : ""}${skill.windsurfMarker}\n\n${skillFile.content}`,
+      );
+    },
+  },
+];
+
+function parseArgs(argv) {
+  const args = { token: null, skills: [], yes: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") args.help = true;
+    else if (arg === "--yes" || arg === "-y") args.yes = true;
+    else if (arg === "--token") args.token = argv[++i];
+    else if (arg.startsWith("--token=")) args.token = arg.slice(8);
+    else if (arg.startsWith("--api=")) process.env.AIFORUI_API = arg.slice(6);
+    else if (!arg.startsWith("-")) args.skills.push(arg.toLowerCase());
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+${color.bold("@aiforui/install")}
+
+Install aiforui.dev skills into your coding agents.
+
+${color.bold("Usage")}
+  npx @aiforui/install --token=<token> [skills...]
+
+${color.bold("Options")}
+  --token=<token>   Your install token (from aiforui.dev)
+  -y, --yes         Non-interactive: install everything you own, keep names
+  -h, --help        Show this help
+
+${color.bold("Examples")}
+  npx @aiforui/install --token=abc.def
+  npx @aiforui/install --token=abc.def typography
+  npx @aiforui/install --token=abc.def color ui-polish -y
+
+Get your command at ${color.bold("https://aiforui.dev")}
+`);
+}
+
+function sanitizeName(name) {
+  return String(name || "")
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function joinWithAnd(items) {
+  if (items.length <= 1) return items.join("");
+  if (items.length === 2) return `${items[0]} and ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+
+async function fetchManifest(token, skills) {
+  const base = process.env.AIFORUI_API || DEFAULT_API;
+  const url = new URL("/api/install", base);
+  url.searchParams.set("token", token);
+  if (skills.length > 0) url.searchParams.set("skills", skills.join(","));
+
+  let res;
+  try {
+    res = await fetch(url.toString());
+  } catch {
+    throw new Error(
+      `Could not reach ${base}. Check your connection and try again.`,
+    );
+  }
+
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+    /* keep {} */
+  }
+
+  if (!res.ok) throw new Error(body.error || `Request failed (${res.status}).`);
+  return body;
+}
+
+function bail(message) {
+  p.cancel(message);
+  process.exit(0);
+}
+
+async function prompt(value) {
+  if (p.isCancel(value)) bail("Installation cancelled.");
+  return value;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  if (!args.token) {
+    console.error(color.red("\nA token is required."));
+    console.error("Get your install command at https://aiforui.dev\n");
+    process.exit(1);
+  }
+
+  const interactive =
+    Boolean(process.stdin.isTTY && process.stdout.isTTY) && !args.yes;
+
+  p.intro(`${color.cyan("aiforui.dev")} installer ${color.dim(`v${version}`)}`);
+
+  // 1. Detect agents.
+  const detected = AGENTS.filter((a) => a.detect());
+  if (detected.length === 0) {
+    p.cancel(
+      "No supported agents detected. Install Claude Code, Cursor, Codex, Amp, Gemini CLI, OpenCode, Windsurf, or Antigravity first.",
+    );
+    process.exit(1);
+  }
+
+  // 2. Which agents?
+  let chosenAgents = detected;
+  if (interactive && detected.length > 1) {
+    const selected = await prompt(
+      await p.multiselect({
+        message: "Which tools do you want to set up?",
+        options: detected.map((a) => ({ value: a.id, label: a.label })),
+        initialValues: detected.map((a) => a.id),
+        required: true,
+      }),
+    );
+    chosenAgents = detected.filter((a) => selected.includes(a.id));
+  } else if (!interactive) {
+    p.log.step(`Detected ${detected.map((a) => a.label).join(", ")}`);
+  }
+
+  // 3. Fetch entitled skills.
+  const loader = p.spinner();
+  loader.start("Checking your access");
+  let manifest;
+  try {
+    manifest = await fetchManifest(args.token, args.skills);
+  } catch (err) {
+    loader.stop("Couldn't reach aiforui.dev");
+    p.cancel(err.message);
+    process.exit(1);
+  }
+
+  const available = manifest.skills || [];
+  const unavailable = manifest.unavailable || [];
+
+  if (available.length === 0) {
+    loader.stop("No skills available");
+    p.cancel("None of the requested skills are available for your account.");
+    process.exit(1);
+  }
+  loader.stop(
+    `Found ${available.length} skill${available.length === 1 ? "" : "s"}`,
+  );
+
+  // 4. Which skills?
+  let chosenSkills = available;
+  if (interactive && args.skills.length === 0 && available.length > 1) {
+    const selected = await prompt(
+      await p.multiselect({
+        message: "Which skills do you want to install?",
+        options: available.map((sk) => ({
+          value: sk.id,
+          label: sk.name,
+          hint: sk.shortDescription,
+        })),
+        initialValues: available.map((sk) => sk.id),
+        required: true,
+      }),
+    );
+    chosenSkills = available.filter((sk) => selected.includes(sk.id));
+  }
+
+  // 5. Rename?
+  const names = new Map(chosenSkills.map((sk) => [sk.id, sk.name]));
+  if (interactive) {
+    const wantRename = await prompt(
+      await p.confirm({
+        message: "Do you want to rename any of these skills?",
+        initialValue: false,
+      }),
+    );
+    if (wantRename) {
+      for (const sk of chosenSkills) {
+        const answer = await prompt(
+          await p.text({
+            message: `Install ${color.bold(sk.displayName)} as`,
+            placeholder: sk.name,
+            defaultValue: sk.name,
+          }),
+        );
+        names.set(sk.id, sanitizeName(answer) || sk.name);
+      }
+    }
+  }
+
+  // 6. Install.
+  const installer = p.spinner();
+  installer.start(
+    `Installing ${chosenSkills.length} skill${chosenSkills.length === 1 ? "" : "s"}`,
+  );
+  for (const agent of chosenAgents) {
+    for (const sk of chosenSkills) {
+      try {
+        agent.install(sk, names.get(sk.id));
+      } catch {
+        /* keep going; summary reflects best effort */
+      }
+    }
+  }
+  installer.stop(
+    `Downloaded ${chosenSkills.length} skill${chosenSkills.length === 1 ? "" : "s"}`,
+  );
+
+  // 7. Per-agent summary.
+  for (const agent of chosenAgents) {
+    const list = chosenSkills.map((sk) =>
+      color.cyan(agent.prefix + names.get(sk.id)),
+    );
+    p.log.success(
+      `${color.bold(agent.label)} ${joinWithAnd(list)} ${color.dim("installed")}`,
+    );
+  }
+
+  for (const u of unavailable) {
+    p.log.warn(`Skipped ${color.bold(u.id)} ${color.dim(`— ${u.reason}`)}`);
+  }
+
+  p.outro("You're all set!");
+}
+
+main().catch((err) => {
+  console.error(color.red(err && err.message ? err.message : String(err)));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@aiforui/install",
+  "version": "0.1.0",
+  "description": "Install aiforui.dev agent skills into Claude Code, Cursor, Codex, Amp, Windsurf, Gemini CLI, OpenCode, and Antigravity.",
+  "bin": {
+    "aiforui-installer": "bin/cli.js"
+  },
+  "type": "module",
+  "files": [
+    "bin/cli.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "picocolors": "^1.1.1"
+  },
+  "keywords": [
+    "ui",
+    "design",
+    "agent-skills",
+    "claude-code",
+    "cursor",
+    "skills"
+  ],
+  "homepage": "https://aiforui.dev",
+  "license": "UNLICENSED",
+  "author": "Emil Kowalski"
+}