@cremini/skillpack 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Finpeak Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# SkillPack - Pack AI Skills into Standalone Apps
+
+Go to [skillpack.sh](https://skillpack.sh) to pack skills and try existing skill packs.
+
+One command to orchestrate [Skills](https://skills.sh), tools, mcps into a standalone app users can download and use on their own computer!
+
+```bash
+npx @cremini/skillpack create
+```
+
+If skills, tools, and MCPs are like LEGO pieces, a skill pack is the master piece that assembles them into a complete solution.
+
+Each Skill Pack should organize different skills to address a well-defined problem or complete specific tasks. For example, research a company by gathering information from various sources and create a PowerPoint presentation based on the findings.
+
+## Quick Start
+
+### Create a Skill Pack Interactively
+
+```bash
+npx @cremini/skillpack create
+```
+
+Step-by-Step
+
+1. Set the Pack name and description
+2. Add skills from a GitHub repos, URLs, or local paths
+3. Add prompts to orchestrate and organize skills you added to accomplish tasks
+4. (Optional) bundle the result as a zip
+
+### Step-by-Step Commands
+
+```bash
+# Add skills
+npx @cremini/skillpack skills add vercel-labs/agent-skills --skill frontend-design
+npx @cremini/skillpack skills add ./my-local-skills
+
+# Manage prompts
+npx @cremini/skillpack prompts add "Collect company data using Skill A, create charts from the data using Skill B, and compile the results into a PowerPoint using Skill C"
+npx @cremini/skillpack prompts list
+
+# Package the current app
+npx @cremini/skillpack build
+```
+
+## Commands
+
+| Command                  | Description                           |
+| ------------------------ | ------------------------------------- |
+| `create`                 | Create a skill pack interactively     |
+| `skills add <source>`    | Add a skill                           |
+| `skills remove <name>`   | Remove a skill                        |
+| `skills list`            | List installed skills                 |
+| `prompts add <text>`     | Add a prompt                          |
+| `prompts remove <index>` | Remove a prompt                       |
+| `prompts list`           | List all prompts                      |
+| `build`                  | Package the skill pack as a zip file  |
+
+## Zip Output
+
+The extracted archive looks like this:
+
+```text
+skillpack/
+├── app.json             # App configuration
+├── skills/              # Collected SKILL.md files
+├── server/              # Express backend
+├── web/                 # Web chat UI
+├── start.sh             # One-click launcher for macOS/Linux
+├── start.bat            # One-click launcher for Windows
+└── README.md
+```
+
+### Run the Skill Pack
+
+```bash
+# macOS / Linux
+chmod +x start.sh && ./start.sh
+
+# Windows
+start.bat
+```
+
+Then open [http://127.0.0.1:26313](http://127.0.0.1:26313), enter your API key, and start working and having fun!!!
+
+## Development
+
+For development details, see [Development Guide](docs/development.md).
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,492 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk7 from "chalk";
+
+// src/commands/create.ts
+import inquirer from "inquirer";
+import chalk3 from "chalk";
+
+// src/core/pack-config.ts
+import fs from "fs";
+import path from "path";
+var PACK_FILE = "app.json";
+function getPackPath(workDir) {
+  return path.join(workDir, PACK_FILE);
+}
+function createDefaultConfig(name, description) {
+  return {
+    name,
+    description,
+    version: "1.0.0",
+    prompts: [],
+    skills: []
+  };
+}
+function loadConfig(workDir) {
+  const filePath = getPackPath(workDir);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(
+      `Could not find ${PACK_FILE}. Run npx @cremini/skillpack create first or work in a directory that contains app.json`
+    );
+  }
+  const raw = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveConfig(workDir, config) {
+  const filePath = getPackPath(workDir);
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function configExists(workDir) {
+  return fs.existsSync(getPackPath(workDir));
+}
+
+// src/core/bundler.ts
+import fs3 from "fs";
+import path3 from "path";
+import archiver from "archiver";
+import chalk2 from "chalk";
+import { fileURLToPath } from "url";
+
+// src/core/skill-manager.ts
+import { execSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import chalk from "chalk";
+var SKILLS_DIR = "skills";
+function getSkillsDir(workDir) {
+  return path2.join(workDir, SKILLS_DIR);
+}
+async function installPendingSkills(workDir, config) {
+  const pendingSkills = config.skills.filter((s) => s.installSource);
+  if (pendingSkills.length === 0) {
+    return;
+  }
+  console.log(chalk.blue(`
+  Installing pending skills...`));
+  const skillsDir = getSkillsDir(workDir);
+  fs2.mkdirSync(skillsDir, { recursive: true });
+  for (const skill of pendingSkills) {
+    let addCmd = `npx -y skills add ${skill.installSource} --agent openclaw --copy -y`;
+    if (skill.specificSkills && skill.specificSkills.length > 0) {
+      for (const name of skill.specificSkills) {
+        addCmd += ` --skill "${name}"`;
+      }
+    }
+    console.log(chalk.dim(`> ${addCmd}`));
+    try {
+      execSync(addCmd, { encoding: "utf-8", cwd: workDir, stdio: "inherit" });
+    } catch (err) {
+      console.error(chalk.red(`Failed to install skill: ${err}`));
+    }
+  }
+  config.skills = scanInstalledSkills(workDir);
+  saveConfig(workDir, config);
+  console.log(chalk.green(`  Skill installation complete.
+`));
+}
+function scanInstalledSkills(workDir) {
+  const results = [];
+  const skillsDir = getSkillsDir(workDir);
+  if (!fs2.existsSync(skillsDir)) {
+    return results;
+  }
+  function findSkillFiles(dir) {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        findSkillFiles(fullPath);
+      } else if (entry.name === "SKILL.md") {
+        const skill = parseSkillMd(fullPath, workDir);
+        if (skill) {
+          results.push(skill);
+        }
+      }
+    }
+  }
+  findSkillFiles(skillsDir);
+  return results;
+}
+function parseSkillMd(filePath, workDir) {
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) return null;
+    const frontmatter = frontmatterMatch[1];
+    const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+    const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+    if (!nameMatch) return null;
+    return {
+      name: nameMatch[1].trim(),
+      source: path2.relative(workDir, path2.dirname(filePath)),
+      description: descMatch ? descMatch[1].trim() : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function removeSkill(workDir, skillName) {
+  const config = loadConfig(workDir);
+  const idx = config.skills.findIndex(
+    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  );
+  if (idx === -1) {
+    console.log(chalk.yellow(`Skill not found: ${skillName}`));
+    return false;
+  }
+  const skillDir = path2.join(workDir, config.skills[idx].source);
+  if (fs2.existsSync(skillDir)) {
+    fs2.rmSync(skillDir, { recursive: true });
+  }
+  config.skills.splice(idx, 1);
+  saveConfig(workDir, config);
+  console.log(chalk.green(`Removed skill: ${skillName}`));
+  return true;
+}
+
+// src/core/bundler.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+function getRuntimeDir() {
+  const projectRoot = path3.resolve(__dirname, "..");
+  return path3.join(projectRoot, "runtime");
+}
+async function bundle(workDir) {
+  const config = loadConfig(workDir);
+  const zipName = `${config.name}.zip`;
+  const zipPath = path3.join(workDir, zipName);
+  const runtimeDir = getRuntimeDir();
+  if (!fs3.existsSync(runtimeDir)) {
+    throw new Error(`Runtime directory not found: ${runtimeDir}`);
+  }
+  await installPendingSkills(workDir, config);
+  console.log(chalk2.blue(`Packaging ${config.name}...`));
+  const output = fs3.createWriteStream(zipPath);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  return new Promise((resolve, reject) => {
+    output.on("close", () => {
+      console.log(
+        chalk2.green(
+          `Packaging complete: ${zipName} (${(archive.pointer() / 1024).toFixed(1)} KB)`
+        )
+      );
+      resolve(zipPath);
+    });
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    const prefix = config.name;
+    archive.file(path3.join(workDir, "app.json"), {
+      name: `${prefix}/app.json`
+    });
+    const skillsDir = path3.join(workDir, "skills");
+    if (fs3.existsSync(skillsDir)) {
+      archive.directory(skillsDir, `${prefix}/skills`);
+    }
+    addRuntimeFiles(archive, runtimeDir, prefix);
+    archive.finalize();
+  });
+}
+function addRuntimeFiles(archive, runtimeDir, prefix) {
+  const serverDir = path3.join(runtimeDir, "server");
+  if (fs3.existsSync(serverDir)) {
+    archive.glob(
+      "**/*",
+      {
+        cwd: serverDir,
+        ignore: ["node_modules/**"]
+      },
+      { prefix: `${prefix}/server` }
+    );
+  }
+  const webDir = path3.join(runtimeDir, "web");
+  if (fs3.existsSync(webDir)) {
+    archive.directory(webDir, `${prefix}/web`);
+  }
+  const scriptsDir = path3.join(runtimeDir, "scripts");
+  if (fs3.existsSync(scriptsDir)) {
+    const startSh = path3.join(scriptsDir, "start.sh");
+    if (fs3.existsSync(startSh)) {
+      archive.file(startSh, { name: `${prefix}/start.sh`, mode: 493 });
+    }
+    const startBat = path3.join(scriptsDir, "start.bat");
+    if (fs3.existsSync(startBat)) {
+      archive.file(startBat, { name: `${prefix}/start.bat` });
+    }
+  }
+  const readme = path3.join(runtimeDir, "README.md");
+  if (fs3.existsSync(readme)) {
+    archive.file(readme, { name: `${prefix}/README.md` });
+  }
+}
+
+// src/commands/create.ts
+import fs4 from "fs";
+import path4 from "path";
+async function createCommand(directory) {
+  const workDir = directory ? path4.resolve(directory) : process.cwd();
+  if (directory) {
+    fs4.mkdirSync(workDir, { recursive: true });
+  }
+  if (configExists(workDir)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "An app.json file already exists in this directory. Overwrite it?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk3.yellow("Cancelled"));
+      return;
+    }
+  }
+  console.log(chalk3.blue("\n  Create a new Skill App\n"));
+  const { name, description } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "App name:",
+      validate: (v) => v.trim() ? true : "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: "A skill App, powered by SkillPack.sh"
+    }
+  ]);
+  const config = createDefaultConfig(name.trim(), description.trim());
+  console.log(
+    chalk3.blue("\n  Add Skills (enter a skill source, leave blank to skip)\n")
+  );
+  console.log(
+    chalk3.dim(
+      "  Supported formats: owner/repo, GitHub URL, local path, or a full npx skills add command"
+    )
+  );
+  console.log(chalk3.dim("  Example: vercel-labs/agent-skills"));
+  console.log(
+    chalk3.dim(
+      "  Example: npx skills add https://github.com/vercel-labs/skills --skill find-skillsclear\n"
+    )
+  );
+  while (true) {
+    const { source } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "source",
+        message: "Skill source (leave blank to skip):"
+      }
+    ]);
+    if (!source.trim()) break;
+    let parsedSource = source.trim();
+    let parsedSpecificSkill;
+    const skillMatch = parsedSource.match(/(.*?)\s+--skill\s+([^\s]+)(.*)/);
+    if (skillMatch) {
+      parsedSpecificSkill = skillMatch[2];
+      parsedSource = `${skillMatch[1]} ${skillMatch[3]}`.trim();
+    }
+    const npxMatch = parsedSource.match(/^npx\s+[^\s]+\s+add\s+(.+)$/);
+    if (npxMatch) {
+      parsedSource = npxMatch[1].trim();
+    }
+    if (!parsedSource) continue;
+    let specificSkill = parsedSpecificSkill;
+    if (specificSkill !== void 0) {
+      console.log(chalk3.dim(`  Auto-detected skill source: ${parsedSource}`));
+      console.log(
+        chalk3.dim(`  Auto-detected specific skill: ${specificSkill}`)
+      );
+    } else {
+      if (parsedSource !== source.trim()) {
+        console.log(chalk3.dim(`  Auto-detected skill source: ${parsedSource}`));
+      }
+      const answer = await inquirer.prompt([
+        {
+          type: "input",
+          name: "specificSkill",
+          message: "Specific skill name (leave blank to install all):"
+        }
+      ]);
+      specificSkill = answer.specificSkill;
+    }
+    const skillNames = specificSkill && specificSkill.trim() ? [specificSkill.trim()] : void 0;
+    config.skills.push({
+      name: skillNames ? skillNames.join(", ") : parsedSource,
+      source: parsedSource,
+      description: "Pending installation",
+      installSource: parsedSource,
+      specificSkills: skillNames
+    });
+  }
+  console.log(chalk3.blue("\n  Add Prompts\n"));
+  console.log(
+    chalk3.blue(
+      "Use a prompt to explain how you will organize the skills you added to complete the task\n"
+    )
+  );
+  let promptIndex = 1;
+  while (true) {
+    const isFirst = promptIndex === 1;
+    const { prompt } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "prompt",
+        message: isFirst ? `Prompt #${promptIndex} (required):` : `Prompt #${promptIndex} (leave blank to finish):`,
+        validate: isFirst ? (v) => v.trim() ? true : "The first Prompt cannot be empty" : void 0
+      }
+    ]);
+    if (!isFirst && !prompt.trim()) break;
+    config.prompts.push(prompt.trim());
+    promptIndex++;
+  }
+  saveConfig(workDir, config);
+  console.log(chalk3.green("\n  app.json saved\n"));
+  const { shouldBundle } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "shouldBundle",
+      message: "Bundle as a zip now?",
+      default: true
+    }
+  ]);
+  if (shouldBundle) {
+    await bundle(workDir);
+  }
+  console.log(chalk3.green("\n  Done!"));
+  if (!shouldBundle) {
+    console.log(
+      chalk3.dim("  Run npx @cremini/skillpack build to create the zip\n")
+    );
+  }
+}
+
+// src/commands/skills-cmd.ts
+import chalk4 from "chalk";
+function registerSkillsCommand(program2) {
+  const skills = program2.command("skills").description("Manage skills in the app");
+  skills.command("add <source>").description("Add a skill from a git repo, URL, or local path").option("-s, --skill <names...>", "Specify skill name(s)").action(async (source, opts) => {
+    const workDir = process.cwd();
+    const config = loadConfig(workDir);
+    config.skills.push({
+      name: opts.skill ? opts.skill.join(", ") : source,
+      source,
+      description: "Pending installation",
+      installSource: source,
+      specificSkills: opts.skill && opts.skill.length > 0 ? opts.skill : void 0
+    });
+    saveConfig(workDir, config);
+    console.log(
+      chalk4.green(
+        `Skill list updated (${config.skills.length} total). Skills will be installed during build.`
+      )
+    );
+  });
+  skills.command("remove <name>").description("Remove a skill").action((name) => {
+    removeSkill(process.cwd(), name);
+  });
+  skills.command("list").description("List installed skills").action(() => {
+    const config = loadConfig(process.cwd());
+    if (config.skills.length === 0) {
+      console.log(chalk4.dim("  No skills installed"));
+      return;
+    }
+    console.log(chalk4.blue(`
+  ${config.name} Skills:
+`));
+    for (const skill of config.skills) {
+      console.log(`  ${chalk4.green("\u25CF")} ${chalk4.bold(skill.name)}`);
+      if (skill.description) {
+        console.log(`    ${chalk4.dim(skill.description)}`);
+      }
+    }
+    console.log();
+  });
+}
+
+// src/commands/prompts-cmd.ts
+import chalk6 from "chalk";
+
+// src/core/prompts.ts
+import chalk5 from "chalk";
+function addPrompt(workDir, text) {
+  const config = loadConfig(workDir);
+  config.prompts.push(text);
+  saveConfig(workDir, config);
+  console.log(chalk5.green(`Added Prompt #${config.prompts.length}`));
+}
+function removePrompt(workDir, index) {
+  const config = loadConfig(workDir);
+  const idx = index - 1;
+  if (idx < 0 || idx >= config.prompts.length) {
+    console.log(
+      chalk5.yellow(`Invalid index: ${index} (${config.prompts.length} total)`)
+    );
+    return false;
+  }
+  const removed = config.prompts.splice(idx, 1)[0];
+  saveConfig(workDir, config);
+  console.log(
+    chalk5.green(`Removed Prompt #${index}: "${removed.substring(0, 50)}..."`)
+  );
+  return true;
+}
+function listPrompts(workDir) {
+  const config = loadConfig(workDir);
+  return config.prompts;
+}
+
+// src/commands/prompts-cmd.ts
+function registerPromptsCommand(program2) {
+  const prompts = program2.command("prompts").description("Manage prompts");
+  prompts.command("add <text>").description("Add a prompt").action((text) => {
+    addPrompt(process.cwd(), text);
+  });
+  prompts.command("remove <index>").description("Remove a prompt by number, starting from 1").action((index) => {
+    const num = parseInt(index, 10);
+    if (isNaN(num)) {
+      console.log(chalk6.red("Enter a valid numeric index"));
+      return;
+    }
+    removePrompt(process.cwd(), num);
+  });
+  prompts.command("list").description("List all prompts").action(() => {
+    const prompts2 = listPrompts(process.cwd());
+    if (prompts2.length === 0) {
+      console.log(chalk6.dim("  No prompts yet"));
+      return;
+    }
+    console.log(chalk6.blue("\n  Prompts:\n"));
+    prompts2.forEach((u, i) => {
+      const marker = i === 0 ? chalk6.green("\u2605") : chalk6.dim("\u25CF");
+      const label = i === 0 ? chalk6.dim(" (default)") : "";
+      const display = u.length > 80 ? u.substring(0, 80) + "..." : u;
+      console.log(`  ${marker} #${i + 1}${label} ${display}`);
+    });
+    console.log();
+  });
+}
+
+// src/cli.ts
+import fs5 from "fs";
+var packageJson = JSON.parse(
+  fs5.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+);
+var program = new Command();
+program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);
+program.command("create [directory]").description("Create a skills pack interactively").action(async (directory) => {
+  await createCommand(directory);
+});
+registerSkillsCommand(program);
+registerPromptsCommand(program);
+program.command("build").description("Package the current pack as a zip file").action(async () => {
+  try {
+    await bundle(process.cwd());
+  } catch (err) {
+    console.error(chalk7.red(`Packaging failed: ${err}`));
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@cremini/skillpack",
+  "version": "1.0.2",
+  "description": "Turn Skills into a Standalone App with UI",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FinpeakInc/skillpack.git"
+  },
+  "bugs": {
+    "url": "https://github.com/FinpeakInc/skillpack/issues"
+  },
+  "homepage": "https://github.com/FinpeakInc/skillpack#readme",
+  "bin": {
+    "skillpack": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "runtime/README.md",
+    "runtime/scripts",
+    "runtime/server/chat-proxy.js",
+    "runtime/server/index.js",
+    "runtime/server/package.json",
+    "runtime/server/routes.js",
+    "runtime/server/skills-loader.js",
+    "runtime/web",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "check": "tsc --noEmit",
+    "format": "prettier --write .",
+    "create": "node dist/cli.js create",
+    "verify-release": "npm run check && npm run build && npm pack --dry-run",
+    "prepublishOnly": "npm run verify-release"
+  },
+  "keywords": [
+    "skills",
+    "agent",
+    "ai",
+    "cli"
+  ],
+  "author": "Finpeak Inc",
+  "license": "MIT",
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "inquirer": "^13.3.0"
+  },
+  "devDependencies": {
+    "@types/archiver": "^7.0.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.5.0",
+    "prettier": "^3.8.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}