@yh-ui/yh-ui-skill 1.0.30

package/dist/args.mjs

@@ -0,0 +1,76 @@
+import { INSTALL_TARGETS } from "./types.mjs";
+import { isInstallTarget } from "./targets.mjs";
+export function parseArgs(argv) {
+  const parsed = {
+    command: "install",
+    force: false,
+    dryRun: false,
+    json: false,
+    help: false,
+    version: false
+  };
+  const args = [...argv];
+  const first = args[0];
+  if (first && !first.startsWith("-")) {
+    if (first === "install" || first === "doctor" || first === "help") {
+      parsed.command = first;
+      args.shift();
+    } else {
+      throw new Error(`Unknown command "${first}".`);
+    }
+  }
+  for (let index = 0; index < args.length; index += 1) {
+    const current = args[index];
+    switch (current) {
+      case "--target":
+      case "-t": {
+        const value = args[index + 1];
+        if (!value) {
+          throw new Error(`Missing value for ${current}.`);
+        }
+        if (!isInstallTarget(value)) {
+          throw new Error(
+            `Invalid target "${value}". Expected one of: ${INSTALL_TARGETS.join(", ")}.`
+          );
+        }
+        parsed.target = value;
+        index += 1;
+        break;
+      }
+      case "--out-dir":
+      case "-o": {
+        const value = args[index + 1];
+        if (!value) {
+          throw new Error(`Missing value for ${current}.`);
+        }
+        parsed.outDir = value;
+        index += 1;
+        break;
+      }
+      case "--force":
+      case "-f":
+        parsed.force = true;
+        break;
+      case "--dry-run":
+        parsed.dryRun = true;
+        break;
+      case "--json":
+        parsed.json = true;
+        break;
+      case "--help":
+      case "-h":
+        parsed.help = true;
+        break;
+      case "--version":
+      case "-v":
+        parsed.version = true;
+        break;
+      default:
+        throw new Error(`Unknown option "${current}".`);
+    }
+  }
+  if (parsed.help) {
+    parsed.command = "help";
+  }
+  return parsed;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.mjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { INSTALL_TARGETS } from "./types.mjs";
+import { parseArgs } from "./args.mjs";
+import {
+  autoSelectTarget,
+  defaultBaseDirForTarget,
+  detectInstallTargetCandidates,
+  resolveInstallPlan
+} from "./targets.mjs";
+import { getPackageVersion, inspectInstallation, installSkill } from "./install.mjs";
+function printHelp() {
+  console.log(`YH-UI skill installer
+
+Usage:
+  yh-ui-skill install [options]
+  yh-ui-skill doctor [options]
+  yh-ui-skill --version
+
+Options:
+  -t, --target <target>   project | cursor | claude | codex | markdown
+  -o, --out-dir <path>    Override the default target directory
+  -f, --force             Overwrite an existing installation
+      --dry-run           Print the install plan without copying files
+      --json              Print machine-readable output
+  -h, --help              Show help
+  -v, --version           Show package version
+`);
+}
+function resolveTargetSelection(value, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const numericIndex = Number(value);
+  if (!Number.isNaN(numericIndex) && numericIndex >= 1 && numericIndex <= INSTALL_TARGETS.length) {
+    return INSTALL_TARGETS[numericIndex - 1];
+  }
+  if (INSTALL_TARGETS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Invalid target "${value}".`);
+}
+async function promptForInstallOptions(cwd) {
+  const candidates = await detectInstallTargetCandidates(cwd);
+  const defaultTarget = candidates.find((candidate) => candidate.detected)?.target ?? "project";
+  const rl = createInterface({ input, output });
+  try {
+    console.log("Select an installation target:");
+    INSTALL_TARGETS.forEach((target2, index) => {
+      const candidate = candidates.find((item) => item.target === target2);
+      const detectedLabel = candidate?.detected ? " [detected]" : "";
+      console.log(
+        `  ${index + 1}. ${target2} (${defaultBaseDirForTarget(target2)})${detectedLabel} - ${candidate?.reason ?? ""}`
+      );
+    });
+    const defaultIndex = INSTALL_TARGETS.indexOf(defaultTarget) + 1;
+    const answer = (await rl.question(`Target [${defaultIndex} ${defaultTarget}]: `)).trim();
+    const target = resolveTargetSelection(answer, defaultTarget);
+    const defaultDir = defaultBaseDirForTarget(target);
+    const override = (await rl.question(
+      `Directory override (leave blank to use ${defaultDir}, accepts relative or absolute paths): `
+    )).trim();
+    if (!override) {
+      return { target };
+    }
+    return { target, outDir: override };
+  } finally {
+    rl.close();
+  }
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.version) {
+    console.log(await getPackageVersion());
+    return;
+  }
+  if (parsed.command === "help") {
+    printHelp();
+    return;
+  }
+  const cwd = process.cwd();
+  const resolvedInput = parsed.target || parsed.outDir ? { target: parsed.target ?? await autoSelectTarget(cwd), outDir: parsed.outDir } : parsed.command === "install" && process.stdin.isTTY && process.stdout.isTTY ? await promptForInstallOptions(cwd) : { target: await autoSelectTarget(cwd), outDir: void 0 };
+  const options = {
+    cwd,
+    target: resolvedInput.target,
+    outDir: resolvedInput.outDir,
+    force: parsed.force,
+    dryRun: parsed.dryRun
+  };
+  if (parsed.command === "doctor") {
+    const result2 = await inspectInstallation(options);
+    if (parsed.json) {
+      console.log(JSON.stringify(result2, null, 2));
+      return;
+    }
+    console.log(`Target: ${result2.plan.target}`);
+    console.log(`Base dir: ${result2.plan.baseDir}`);
+    console.log(`Current CLI version: ${result2.currentVersion}`);
+    console.log(`Installed version: ${result2.version ?? "not installed"}`);
+    if (result2.exists && result2.upToDate) {
+      console.log("Status: installed and up to date");
+    } else if (result2.exists) {
+      console.log("Status: installed but needs refresh");
+    } else {
+      console.log("Status: missing files");
+    }
+    console.log("Checks:");
+    result2.checks.forEach((check) => {
+      console.log(`- ${check.exists ? "OK" : "MISS"} ${check.label}: ${check.path}`);
+    });
+    const detectedTargets = result2.detectedTargets.filter((candidate) => candidate.detected);
+    if (detectedTargets.length > 0) {
+      console.log("Detected targets:");
+      detectedTargets.forEach((candidate) => {
+        console.log(`- ${candidate.target}: ${candidate.baseDir} (${candidate.reason})`);
+      });
+    }
+    if (result2.exists && result2.upToDate) {
+      return;
+    }
+    if (result2.missingItems.length > 0) {
+      console.log("Missing items:");
+      result2.missingItems.forEach((item) => {
+        console.log(`- ${item}`);
+      });
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const result = await installSkill(options);
+  if (parsed.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const plan = resolveInstallPlan(options);
+  if (parsed.dryRun) {
+    console.log(`Dry run complete for ${result.version}`);
+  } else {
+    console.log(`Installed YH-UI skill ${result.version}`);
+  }
+  console.log(`Target: ${plan.target}`);
+  console.log(`Base dir: ${plan.baseDir}`);
+  console.log(`Skill: ${plan.skillDir}`);
+  console.log(`LLMS: ${plan.llmsPath}`);
+  console.log(`LLMS Full: ${plan.llmsFullPath}`);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`yh-ui-skill: ${message}`);
+  process.exit(1);
+});

package/dist/fs.d.ts

@@ -0,0 +1,5 @@
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function ensureParentDir(filePath: string): Promise<void>;
+export declare function copyDirectory(sourceDir: string, targetDir: string): Promise<void>;
+export declare function copyFile(sourcePath: string, targetPath: string): Promise<void>;
+export declare function removePath(filePath: string): Promise<void>;

package/dist/fs.mjs

@@ -0,0 +1,23 @@
+import { access, cp, mkdir, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export async function ensureParentDir(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+export async function copyDirectory(sourceDir, targetDir) {
+  await cp(sourceDir, targetDir, { recursive: true, force: true });
+}
+export async function copyFile(sourcePath, targetPath) {
+  await ensureParentDir(targetPath);
+  await cp(sourcePath, targetPath, { force: true });
+}
+export async function removePath(filePath) {
+  await rm(filePath, { recursive: true, force: true });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { parseArgs } from './args';
+export { installSkill, inspectInstallation, getPackageVersion } from './install';
+export { autoSelectTarget, defaultBaseDirForTarget, detectInstallTargetCandidates, isInstallTarget, resolveInstallPlan } from './targets';
+export { INSTALL_TARGETS } from './types';
+export type { DoctorResult, InstallOptions, InstallResult, InstallTarget, ParsedArgs, TargetCandidate } from './types';

package/dist/index.mjs

@@ -0,0 +1,10 @@
+export { parseArgs } from "./args.mjs";
+export { installSkill, inspectInstallation, getPackageVersion } from "./install.mjs";
+export {
+  autoSelectTarget,
+  defaultBaseDirForTarget,
+  detectInstallTargetCandidates,
+  isInstallTarget,
+  resolveInstallPlan
+} from "./targets.mjs";
+export { INSTALL_TARGETS } from "./types.mjs";

package/dist/install.d.ts

@@ -0,0 +1,4 @@
+import type { DoctorResult, InstallOptions, InstallResult } from './types';
+export declare function getPackageVersion(): Promise<string>;
+export declare function installSkill(options: InstallOptions): Promise<InstallResult>;
+export declare function inspectInstallation(options: InstallOptions): Promise<DoctorResult>;

package/dist/install.mjs

@@ -0,0 +1,117 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { join, relative } from "node:path";
+import { copyDirectory, copyFile, ensureParentDir, pathExists, removePath } from "./fs.mjs";
+import { detectInstallTargetCandidates, resolveInstallPlan } from "./targets.mjs";
+const PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const ASSETS_ROOT = join(PACKAGE_ROOT, "assets");
+const SKILL_ASSET_DIR = join(ASSETS_ROOT, "skills", "yh-ui");
+const LLMS_ASSET_PATH = join(ASSETS_ROOT, "llms.txt");
+const LLMS_FULL_ASSET_PATH = join(ASSETS_ROOT, "llms-full.txt");
+export async function getPackageVersion() {
+  const packageJson = JSON.parse(await readFile(join(PACKAGE_ROOT, "package.json"), "utf8"));
+  return packageJson.version;
+}
+async function assertAssetsAvailable() {
+  const requiredPaths = [SKILL_ASSET_DIR, LLMS_ASSET_PATH, LLMS_FULL_ASSET_PATH];
+  for (const requiredPath of requiredPaths) {
+    if (!await pathExists(requiredPath)) {
+      throw new Error(
+        `Skill assets are missing at "${requiredPath}". Run the package build before publishing or using the CLI.`
+      );
+    }
+  }
+}
+export async function installSkill(options) {
+  await assertAssetsAvailable();
+  const plan = resolveInstallPlan(options);
+  const version = await getPackageVersion();
+  const alreadyInstalled = await pathExists(plan.skillDir);
+  if (alreadyInstalled && !options.force) {
+    throw new Error(
+      `Destination "${plan.skillDir}" already exists. Re-run with --force to overwrite the previous installation.`
+    );
+  }
+  if (!options.dryRun && options.force) {
+    await Promise.all([
+      removePath(plan.skillDir),
+      removePath(plan.llmsPath),
+      removePath(plan.llmsFullPath),
+      removePath(plan.manifestPath)
+    ]);
+  }
+  if (!options.dryRun) {
+    await ensureParentDir(plan.skillDir);
+    await copyDirectory(SKILL_ASSET_DIR, plan.skillDir);
+    await copyFile(LLMS_ASSET_PATH, plan.llmsPath);
+    await copyFile(LLMS_FULL_ASSET_PATH, plan.llmsFullPath);
+    const manifest = {
+      packageName: "@yh-ui/yh-ui-skill",
+      version,
+      target: plan.target,
+      baseDir: plan.baseDir,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: [
+        "skills/yh-ui",
+        "skills/yh-ui/SKILL.md",
+        "llms.txt",
+        "llms-full.txt",
+        "yh-ui-skill.manifest.json"
+      ]
+    };
+    await ensureParentDir(plan.manifestPath);
+    await writeFile(plan.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  }
+  return { plan, version };
+}
+export async function inspectInstallation(options) {
+  const plan = resolveInstallPlan(options);
+  const currentVersion = await getPackageVersion();
+  const missingItems = [];
+  const checks = [
+    {
+      label: "Skill directory",
+      path: plan.skillDir,
+      exists: await pathExists(plan.skillDir)
+    },
+    {
+      label: "Skill entry",
+      path: join(plan.skillDir, "SKILL.md"),
+      exists: await pathExists(join(plan.skillDir, "SKILL.md"))
+    },
+    {
+      label: "llms.txt",
+      path: plan.llmsPath,
+      exists: await pathExists(plan.llmsPath)
+    },
+    {
+      label: "llms-full.txt",
+      path: plan.llmsFullPath,
+      exists: await pathExists(plan.llmsFullPath)
+    },
+    {
+      label: "Install manifest",
+      path: plan.manifestPath,
+      exists: await pathExists(plan.manifestPath)
+    }
+  ];
+  checks.filter((check) => !check.exists).forEach((check) => missingItems.push(relative(plan.baseDir, check.path).replace(/\\/g, "/")));
+  let version = null;
+  if (checks.at(-1)?.exists) {
+    const manifest = JSON.parse(await readFile(plan.manifestPath, "utf8"));
+    version = manifest.version;
+  }
+  const exists = missingItems.length === 0;
+  const upToDate = exists && version === currentVersion;
+  return {
+    plan,
+    version,
+    currentVersion,
+    exists,
+    upToDate,
+    missingItems,
+    checks,
+    detectedTargets: await detectInstallTargetCandidates(options.cwd)
+  };
+}

package/dist/targets.d.ts

@@ -0,0 +1,6 @@
+import type { InstallPlan, InstallTarget, ResolveInstallPlanOptions, TargetCandidate } from './types';
+export declare function isInstallTarget(value: string): value is InstallTarget;
+export declare function defaultBaseDirForTarget(target: InstallTarget): string;
+export declare function detectInstallTargetCandidates(cwd: string): Promise<TargetCandidate[]>;
+export declare function autoSelectTarget(cwd: string): Promise<InstallTarget>;
+export declare function resolveInstallPlan(options: ResolveInstallPlanOptions): InstallPlan;

package/dist/targets.mjs

@@ -0,0 +1,64 @@
+import { resolve } from "node:path";
+import { pathExists } from "./fs.mjs";
+const TARGET_BASE_DIRS = {
+  project: ".yh-ui",
+  cursor: ".cursor",
+  claude: ".claude",
+  codex: ".codex",
+  markdown: "yh-ui-skill"
+};
+export function isInstallTarget(value) {
+  return Object.hasOwn(TARGET_BASE_DIRS, value);
+}
+export function defaultBaseDirForTarget(target) {
+  return TARGET_BASE_DIRS[target];
+}
+export async function detectInstallTargetCandidates(cwd) {
+  const packageJsonExists = await pathExists(resolve(cwd, "package.json"));
+  const candidates = await Promise.all(
+    ["cursor", "claude", "codex", "project", "markdown"].map(
+      async (target) => {
+        const baseDir = resolve(cwd, defaultBaseDirForTarget(target));
+        const baseDirExists = await pathExists(baseDir);
+        if (target === "project") {
+          return {
+            target,
+            baseDir,
+            detected: packageJsonExists || baseDirExists,
+            reason: packageJsonExists ? "Detected package.json in the current workspace" : "Install into the default project knowledge directory"
+          };
+        }
+        if (target === "markdown") {
+          return {
+            target,
+            baseDir,
+            detected: false,
+            reason: "Export a portable Markdown knowledge bundle"
+          };
+        }
+        return {
+          target,
+          baseDir,
+          detected: baseDirExists,
+          reason: baseDirExists ? `Detected an existing ${defaultBaseDirForTarget(target)} directory` : `Use the default ${defaultBaseDirForTarget(target)} directory`
+        };
+      }
+    )
+  );
+  return candidates.sort((left, right) => Number(right.detected) - Number(left.detected));
+}
+export async function autoSelectTarget(cwd) {
+  const candidates = await detectInstallTargetCandidates(cwd);
+  return candidates.find((candidate) => candidate.detected)?.target ?? "project";
+}
+export function resolveInstallPlan(options) {
+  const baseDir = resolve(options.cwd, options.outDir ?? defaultBaseDirForTarget(options.target));
+  return {
+    target: options.target,
+    baseDir,
+    skillDir: resolve(baseDir, "skills", "yh-ui"),
+    llmsPath: resolve(baseDir, "llms.txt"),
+    llmsFullPath: resolve(baseDir, "llms-full.txt"),
+    manifestPath: resolve(baseDir, "yh-ui-skill.manifest.json")
+  };
+}

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+export declare const INSTALL_TARGETS: readonly ["project", "cursor", "claude", "codex", "markdown"];
+export type InstallTarget = (typeof INSTALL_TARGETS)[number];
+export interface ResolveInstallPlanOptions {
+    cwd: string;
+    target: InstallTarget;
+    outDir?: string;
+}
+export interface InstallPlan {
+    target: InstallTarget;
+    baseDir: string;
+    skillDir: string;
+    llmsPath: string;
+    llmsFullPath: string;
+    manifestPath: string;
+}
+export interface TargetCandidate {
+    target: InstallTarget;
+    baseDir: string;
+    detected: boolean;
+    reason: string;
+}
+export interface InstallOptions extends ResolveInstallPlanOptions {
+    force?: boolean;
+    dryRun?: boolean;
+}
+export interface InstallResult {
+    plan: InstallPlan;
+    version: string;
+}
+export interface DoctorResult {
+    plan: InstallPlan;
+    version: string | null;
+    currentVersion: string;
+    exists: boolean;
+    upToDate: boolean;
+    missingItems: string[];
+    checks: Array<{
+        label: string;
+        path: string;
+        exists: boolean;
+    }>;
+    detectedTargets: TargetCandidate[];
+}
+export interface ParsedArgs {
+    command: 'install' | 'doctor' | 'help';
+    target?: InstallTarget;
+    outDir?: string;
+    force: boolean;
+    dryRun: boolean;
+    json: boolean;
+    help: boolean;
+    version: boolean;
+}

package/dist/types.mjs

@@ -0,0 +1 @@
+export const INSTALL_TARGETS = ["project", "cursor", "claude", "codex", "markdown"];

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@yh-ui/yh-ui-skill",
+  "version": "1.0.30",
+  "description": "YH-UI skill installer for modern AI coding tools",
+  "type": "module",
+  "bin": {
+    "yh-ui-skill": "./dist/cli.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/1079161148/yh-ui.git",
+    "directory": "packages/yh-ui-skill"
+  },
+  "keywords": [
+    "yh-ui",
+    "ai",
+    "skill",
+    "cli",
+    "agent"
+  ],
+  "homepage": "https://1079161148.github.io/yh-ui/",
+  "author": "YH-UI Team",
+  "license": "MIT",
+  "scripts": {
+    "build": "node ../../scripts/sync-yh-ui-skill-assets.mjs && unbuild",
+    "dev": "node ../../scripts/sync-yh-ui-skill-assets.mjs && unbuild --stub",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint ."
+  }
+}