@unityclaw/skills 1.0.0

package/README.md

@@ -0,0 +1,125 @@
+# @unityclaw/skills
+
+UnityClaw Skills - Claude Code and OpenClaw skill definitions for AI-powered image/video generation, media analysis, and document processing.
+
+## Installation
+
+```bash
+# Install globally for CLI usage
+npm install -g @unityclaw/skills
+
+# Or use with npx (no installation required)
+npx @unityclaw/skills --help
+```
+
+All skills require the `@unityclaw/sdk` package and an API key:
+
+```bash
+export UNITYCLAW_API_KEY=your-api-key
+```
+
+## CLI Commands
+
+### Install Skills
+
+Install skills to Claude Code or OpenClaw:
+
+```bash
+# Install all skills to Claude Code
+npx @unityclaw/skills install
+
+# Install specific skills
+npx @unityclaw/skills install unityclaw-image-generation unityclaw-video-generation-sora
+
+# Install to OpenClaw
+npx @unityclaw/skills install --target openclaw
+```
+
+### List Available Skills
+
+```bash
+npx @unityclaw/skills list
+```
+
+### Update Packages
+
+Update SDK and skills to the latest version:
+
+```bash
+# Update local packages
+npx @unityclaw/skills update
+
+# Update global packages
+npx @unityclaw/skills update --global
+```
+
+### Execute Skills Directly
+
+Execute a skill via Claude Code CLI:
+
+```bash
+# Generate an image
+npx @unityclaw/skills /unityclaw-image-generation 我要一张竖屏的桌面背景图
+
+# Analyze a video
+npx @unityclaw/skills /unityclaw-media-analysis https://youtube.com/watch?v=...
+```
+
+## Available Skills
+
+### Image Skills
+
+| Skill | Description | Emoji |
+|-------|-------------|-------|
+| [unityclaw-image-generation](./unityclaw-image-generation/SKILL.md) | Generate images using Gemini or JiMeng models | 🎨 |
+| [unityclaw-image-compress](./unityclaw-image-compress/SKILL.md) | Compress images with quality control | 🗜️ |
+
+### Video Skills
+
+| Skill | Description | Emoji |
+|-------|-------------|-------|
+| [unityclaw-video-generation-sora](./unityclaw-video-generation-sora/SKILL.md) | Generate videos using OpenAI Sora | 🎬 |
+| [unityclaw-video-generation-veo](./unityclaw-video-generation-veo/SKILL.md) | Generate videos using Google Veo | 🎥 |
+| [unityclaw-video-generation-kling](./unityclaw-video-generation-kling/SKILL.md) | Generate videos using Kling AI | 📹 |
+| [unityclaw-video-generation-other](./unityclaw-video-generation-other/SKILL.md) | Generate videos using Doubao, Wan, MiniMax, JiMeng | 🎞️ |
+
+### Document Skills
+
+| Skill | Description | Emoji |
+|-------|-------------|-------|
+| [unityclaw-document-translation](./unityclaw-document-translation/SKILL.md) | Translate documents between languages | 🌐 |
+| [unityclaw-document-convert](./unityclaw-document-convert/SKILL.md) | Convert document formats (PDF/Word/PPT/Excel/Image) | 📄 |
+
+### Media Skills
+
+| Skill | Description | Emoji |
+|-------|-------------|-------|
+| [unityclaw-media-analysis](./unityclaw-media-analysis/SKILL.md) | Analyze video/audio content and extract insights | 📊 |
+
+## Programmatic Usage
+
+```typescript
+import { listSkills, installSkills, executeSkill } from '@unityclaw/skills';
+
+// List available skills
+const skills = await listSkills();
+console.log(skills);
+
+// Install skills to Claude Code
+await installSkills('claude', ['unityclaw-image-generation']);
+
+// Install all skills to OpenClaw
+await installSkills('openclaw');
+
+// Execute a skill
+await executeSkill('/unityclaw-image-generation A beautiful sunset');
+```
+
+## SDK Documentation
+
+- [npm: @unityclaw/sdk](https://www.npmjs.com/package/@unityclaw/sdk)
+- [UnityClaw Homepage](https://unityclaw.com)
+
+## License
+
+MIT

package/dist/chunk-KHQZYC3Y.js

@@ -0,0 +1,163 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { spawn } from "child_process";
+import { cp, mkdir, readdir, readFile } from "fs/promises";
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+function getSkillsDir() {
+  let currentDir;
+  try {
+    if (typeof import.meta !== "undefined" && import.meta.url) {
+      const { fileURLToPath } = __require("url");
+      currentDir = path.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 = path.parse(searchDir).root;
+  while (searchDir !== root) {
+    try {
+      const entries = readdirSync(searchDir);
+      const hasSkills = entries.some((e) => /^unityclaw-/.test(e) || /^unityclaw-/.test(e));
+      if (hasSkills) {
+        return searchDir;
+      }
+    } catch {
+    }
+    searchDir = path.dirname(searchDir);
+  }
+  return path.dirname(currentDir);
+}
+async function parseSkill(skillPath) {
+  try {
+    const content = await 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 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 = path.join(skillsDir, entry.name, "SKILL.md");
+      if (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 path.join(homeDir, ".claude", "skills");
+}
+function getOpenClawSkillsDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  return process.env.OPENCLAW_SKILLS_DIR || path.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 (!existsSync(targetDir)) {
+    await 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 = path.join(skillsDir, skill.name);
+    const destDir = path.join(targetDir, skill.name);
+    try {
+      await 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 = 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);
+    });
+  });
+}
+
+export {
+  getSkillsDir,
+  parseSkill,
+  listSkills,
+  getClaudeSkillsDir,
+  getOpenClawSkillsDir,
+  installSkills,
+  executeSkill
+};

package/dist/cli.cjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+var import_child_process2 = require("child_process");
+
+// src/index.ts
+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);
+    });
+  });
+}
+
+// src/cli.ts
+import_commander.program.name("unityclaw-skills").description("UnityClaw Skills - Install and execute skills for Claude Code and OpenClaw").version("1.0.0");
+import_commander.program.command("install [skills...]").description("Install skills to Claude Code or OpenClaw").option("-t, --target <target>", "Target platform: claude or openclaw", "claude").action(async (skills, options) => {
+  if (options.target !== "claude" && options.target !== "openclaw") {
+    console.error(`Error: Invalid target "${options.target}". Use "claude" or "openclaw".`);
+    process.exit(1);
+  }
+  await installSkills(options.target, skills);
+});
+import_commander.program.command("list").description("List all available skills").action(async () => {
+  const skills = await listSkills();
+  console.log("\nAvailable skills:\n");
+  for (const skill of skills) {
+    const emoji = skill.meta?.metadata?.openclaw?.emoji || "\u{1F4E6}";
+    console.log(`  ${emoji} ${skill.name}`);
+    if (skill.meta?.description) {
+      console.log(`     ${skill.meta.description}`);
+    }
+    console.log();
+  }
+});
+import_commander.program.command("update").description("Update @unityclaw/sdk and @unityclaw/skills to the latest version").option("-g, --global", "Update globally installed packages").action(async (options) => {
+  console.log("Updating @unityclaw packages...\n");
+  const useGlobal = options.global ? ["-g"] : [];
+  const packages = ["@unityclaw/sdk", "@unityclaw/skills"];
+  for (const pkg of packages) {
+    console.log(`Updating ${pkg}...`);
+    try {
+      await new Promise((resolve, reject) => {
+        const child = (0, import_child_process2.spawn)("npm", ["install", ...useGlobal, `${pkg}@latest`], {
+          stdio: "inherit",
+          shell: true
+        });
+        child.on("close", (code) => {
+          if (code === 0) {
+            console.log(`\u2705 ${pkg} updated successfully
+`);
+            resolve();
+          } else {
+            reject(new Error(`Failed to update ${pkg}`));
+          }
+        });
+        child.on("error", reject);
+      });
+    } catch (error) {
+      console.error(`\u274C Failed to update ${pkg}:`, error);
+    }
+  }
+  console.log("\n\u2728 Update complete!");
+});
+var args = process.argv.slice(2);
+if (args.length > 0 && args[0].startsWith("/")) {
+  const skillCommand = args.join(" ");
+  executeSkill(skillCommand).catch((error) => {
+    console.error("Error executing skill:", error);
+    process.exit(1);
+  });
+} else {
+  import_commander.program.parse();
+}

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  executeSkill,
+  installSkills,
+  listSkills
+} from "./chunk-KHQZYC3Y.js";
+
+// src/cli.ts
+import { program } from "commander";
+import { spawn } from "child_process";
+program.name("unityclaw-skills").description("UnityClaw Skills - Install and execute skills for Claude Code and OpenClaw").version("1.0.0");
+program.command("install [skills...]").description("Install skills to Claude Code or OpenClaw").option("-t, --target <target>", "Target platform: claude or openclaw", "claude").action(async (skills, options) => {
+  if (options.target !== "claude" && options.target !== "openclaw") {
+    console.error(`Error: Invalid target "${options.target}". Use "claude" or "openclaw".`);
+    process.exit(1);
+  }
+  await installSkills(options.target, skills);
+});
+program.command("list").description("List all available skills").action(async () => {
+  const skills = await listSkills();
+  console.log("\nAvailable skills:\n");
+  for (const skill of skills) {
+    const emoji = skill.meta?.metadata?.openclaw?.emoji || "\u{1F4E6}";
+    console.log(`  ${emoji} ${skill.name}`);
+    if (skill.meta?.description) {
+      console.log(`     ${skill.meta.description}`);
+    }
+    console.log();
+  }
+});
+program.command("update").description("Update @unityclaw/sdk and @unityclaw/skills to the latest version").option("-g, --global", "Update globally installed packages").action(async (options) => {
+  console.log("Updating @unityclaw packages...\n");
+  const useGlobal = options.global ? ["-g"] : [];
+  const packages = ["@unityclaw/sdk", "@unityclaw/skills"];
+  for (const pkg of packages) {
+    console.log(`Updating ${pkg}...`);
+    try {
+      await new Promise((resolve, reject) => {
+        const child = spawn("npm", ["install", ...useGlobal, `${pkg}@latest`], {
+          stdio: "inherit",
+          shell: true
+        });
+        child.on("close", (code) => {
+          if (code === 0) {
+            console.log(`\u2705 ${pkg} updated successfully
+`);
+            resolve();
+          } else {
+            reject(new Error(`Failed to update ${pkg}`));
+          }
+        });
+        child.on("error", reject);
+      });
+    } catch (error) {
+      console.error(`\u274C Failed to update ${pkg}:`, error);
+    }
+  }
+  console.log("\n\u2728 Update complete!");
+});
+var args = process.argv.slice(2);
+if (args.length > 0 && args[0].startsWith("/")) {
+  const skillCommand = args.join(" ");
+  executeSkill(skillCommand).catch((error) => {
+    console.error("Error executing skill:", error);
+    process.exit(1);
+  });
+} else {
+  program.parse();
+}