@unityclaw/skills 1.0.0

package/dist/index.cjs

@@ -0,0 +1,197 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  executeSkill: () => executeSkill,
+  getClaudeSkillsDir: () => getClaudeSkillsDir,
+  getOpenClawSkillsDir: () => getOpenClawSkillsDir,
+  getSkillsDir: () => getSkillsDir,
+  installSkills: () => installSkills,
+  listSkills: () => listSkills,
+  parseSkill: () => parseSkill
+});
+module.exports = __toCommonJS(index_exports);
+var import_child_process = require("child_process");
+var import_promises = require("fs/promises");
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_meta = {};
+function getSkillsDir() {
+  let currentDir;
+  try {
+    if (typeof import_meta !== "undefined" && import_meta.url) {
+      const { fileURLToPath } = require("url");
+      currentDir = import_path.default.dirname(fileURLToPath(import_meta.url));
+    } else if (typeof __dirname !== "undefined") {
+      currentDir = __dirname;
+    } else {
+      currentDir = process.cwd();
+    }
+  } catch {
+    currentDir = process.cwd();
+  }
+  let searchDir = currentDir;
+  const root = import_path.default.parse(searchDir).root;
+  while (searchDir !== root) {
+    try {
+      const entries = (0, import_fs.readdirSync)(searchDir);
+      const hasSkills = entries.some((e) => /^unityclaw-/.test(e) || /^unityclaw-/.test(e));
+      if (hasSkills) {
+        return searchDir;
+      }
+    } catch {
+    }
+    searchDir = import_path.default.dirname(searchDir);
+  }
+  return import_path.default.dirname(currentDir);
+}
+async function parseSkill(skillPath) {
+  try {
+    const content = await (0, import_promises.readFile)(skillPath, "utf-8");
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) return null;
+    const frontmatter = frontmatterMatch[1];
+    const meta = {};
+    for (const line of frontmatter.split("\n")) {
+      const match = line.match(/^(\w+(?:\.\w+)*):\s*(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        if (key.includes(".")) {
+          const parts = key.split(".");
+          let current = meta;
+          for (let i = 0; i < parts.length - 1; i++) {
+            if (!current[parts[i]]) current[parts[i]] = {};
+            current = current[parts[i]];
+          }
+          current[parts[parts.length - 1]] = value.replace(/^["']|["']$/g, "");
+        } else {
+          meta[key] = value.replace(/^["']|["']$/g, "");
+        }
+      }
+    }
+    return meta;
+  } catch {
+    return null;
+  }
+}
+async function listSkills() {
+  const skillsDir = getSkillsDir();
+  const skills = [];
+  try {
+    const entries = await (0, import_promises.readdir)(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith("unityclaw-") && !entry.name.startsWith("unityclaw-")) continue;
+      if (entry.name === "src" || entry.name === "dist" || entry.name === "node_modules") continue;
+      const skillFile = import_path.default.join(skillsDir, entry.name, "SKILL.md");
+      if ((0, import_fs.existsSync)(skillFile)) {
+        const meta = await parseSkill(skillFile);
+        skills.push({
+          name: entry.name,
+          path: skillFile,
+          meta
+        });
+      }
+    }
+  } catch (error) {
+    console.error("Error listing skills:", error);
+  }
+  return skills;
+}
+function getClaudeSkillsDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  return import_path.default.join(homeDir, ".claude", "skills");
+}
+function getOpenClawSkillsDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  return process.env.OPENCLAW_SKILLS_DIR || import_path.default.join(homeDir, ".openclaw", "skills");
+}
+async function installSkills(target, skills) {
+  const targetDir = target === "claude" ? getClaudeSkillsDir() : getOpenClawSkillsDir();
+  const skillsDir = getSkillsDir();
+  console.log(`Installing skills to ${target}...`);
+  console.log(`Target directory: ${targetDir}`);
+  if (!(0, import_fs.existsSync)(targetDir)) {
+    await (0, import_promises.mkdir)(targetDir, { recursive: true });
+  }
+  const availableSkills = await listSkills();
+  const skillsToInstall = skills && skills.length > 0 ? availableSkills.filter((s) => skills.includes(s.name)) : availableSkills;
+  if (skillsToInstall.length === 0) {
+    console.log("No skills to install.");
+    return;
+  }
+  console.log(`
+Installing ${skillsToInstall.length} skill(s):
+`);
+  for (const skill of skillsToInstall) {
+    const srcDir = import_path.default.join(skillsDir, skill.name);
+    const destDir = import_path.default.join(targetDir, skill.name);
+    try {
+      await (0, import_promises.cp)(srcDir, destDir, { recursive: true });
+      console.log(`  \u2705 ${skill.name}${skill.meta ? ` - ${skill.meta.description}` : ""}`);
+    } catch (error) {
+      console.log(`  \u274C ${skill.name} - Error: ${error}`);
+    }
+  }
+  console.log(`
+\u2728 Done! Skills installed to: ${targetDir}`);
+}
+async function executeSkill(skillCommand) {
+  const fullCommand = `claude "${skillCommand}"`;
+  console.log(`Executing: ${fullCommand}
+`);
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)("claude", [skillCommand], {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with code ${code}`));
+      }
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeSkill,
+  getClaudeSkillsDir,
+  getOpenClawSkillsDir,
+  getSkillsDir,
+  installSkills,
+  listSkills,
+  parseSkill
+});

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @unityclaw/skills
+ * UnityClaw Skills - Install and execute skills for Claude Code and OpenClaw
+ */
+/** Skill metadata */
+interface SkillMeta {
+    name: string;
+    description: string;
+    version: string;
+    metadata?: {
+        openclaw?: {
+            emoji?: string;
+            homepage?: string;
+        };
+    };
+}
+/** Get the skills directory */
+declare function getSkillsDir(): string;
+/** Parse skill markdown file and extract metadata */
+declare function parseSkill(skillPath: string): Promise<SkillMeta | null>;
+/** List all available skills */
+declare function listSkills(): Promise<Array<{
+    name: string;
+    path: string;
+    meta: SkillMeta | null;
+}>>;
+/** Get Claude Code skills directory */
+declare function getClaudeSkillsDir(): string;
+/** Get OpenClaw skills directory */
+declare function getOpenClawSkillsDir(): string;
+/** Install skills to target directory */
+declare function installSkills(target: 'claude' | 'openclaw', skills?: string[]): Promise<void>;
+/** Execute a skill via Claude Code CLI */
+declare function executeSkill(skillCommand: string): Promise<void>;
+
+export { type SkillMeta, executeSkill, getClaudeSkillsDir, getOpenClawSkillsDir, getSkillsDir, installSkills, listSkills, parseSkill };

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @unityclaw/skills
+ * UnityClaw Skills - Install and execute skills for Claude Code and OpenClaw
+ */
+/** Skill metadata */
+interface SkillMeta {
+    name: string;
+    description: string;
+    version: string;
+    metadata?: {
+        openclaw?: {
+            emoji?: string;
+            homepage?: string;
+        };
+    };
+}
+/** Get the skills directory */
+declare function getSkillsDir(): string;
+/** Parse skill markdown file and extract metadata */
+declare function parseSkill(skillPath: string): Promise<SkillMeta | null>;
+/** List all available skills */
+declare function listSkills(): Promise<Array<{
+    name: string;
+    path: string;
+    meta: SkillMeta | null;
+}>>;
+/** Get Claude Code skills directory */
+declare function getClaudeSkillsDir(): string;
+/** Get OpenClaw skills directory */
+declare function getOpenClawSkillsDir(): string;
+/** Install skills to target directory */
+declare function installSkills(target: 'claude' | 'openclaw', skills?: string[]): Promise<void>;
+/** Execute a skill via Claude Code CLI */
+declare function executeSkill(skillCommand: string): Promise<void>;
+
+export { type SkillMeta, executeSkill, getClaudeSkillsDir, getOpenClawSkillsDir, getSkillsDir, installSkills, listSkills, parseSkill };

package/dist/index.js

@@ -0,0 +1,18 @@
+import {
+  executeSkill,
+  getClaudeSkillsDir,
+  getOpenClawSkillsDir,
+  getSkillsDir,
+  installSkills,
+  listSkills,
+  parseSkill
+} from "./chunk-KHQZYC3Y.js";
+export {
+  executeSkill,
+  getClaudeSkillsDir,
+  getOpenClawSkillsDir,
+  getSkillsDir,
+  installSkills,
+  listSkills,
+  parseSkill
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@unityclaw/skills",
+  "version": "1.0.0",
+  "description": "UnityClaw Skills - Claude Code and OpenClaw skill definitions for AI-powered image/video generation, media analysis, and more",
+  "type": "module",
+  "bin": {
+    "unityclaw-skills": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "unityclaw-*/SKILL.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "unityclaw",
+    "claude-code",
+    "openclaw",
+    "skills",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "media-analysis"
+  ],
+  "author": "UnityClaw",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "fs-extra": "^11.2.0",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/unityclaw/sdk.git",
+    "directory": "packages/skills"
+  },
+  "homepage": "https://unityclaw.com"
+}