@cremini/skillpack 1.0.2 → 1.0.5

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Finpeak Inc
+Copyright (c) 2026 CreminiAI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,4 +1,4 @@
-# SkillPack - Pack AI Skills into Standalone Apps
+# SkillPack.sh - Pack AI Skills into Standalone Apps
 
 Go to [skillpack.sh](https://skillpack.sh) to pack skills and try existing skill packs.
 
@@ -27,12 +27,21 @@ Step-by-Step
 3. Add prompts to orchestrate and organize skills you added to accomplish tasks
 4. (Optional) bundle the result as a zip
 
+### Initialize from an Existing Config
+
+```bash
+npx @cremini/skillpack init --config ./skillpack.json
+npx @cremini/skillpack init commic_explainer --config https://raw.githubusercontent.com/CreminiAI/skillpack/refs/heads/main/examples/commic_explainer.json
+```
+
+This loads a local or remote config, writes `skillpack.json` into the target directory, installs the configured skills, and skips zip packaging unless you pass `--bundle`.
+
 ### 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
+npx @cremini/skillpack skills add ./my-local-skills --skill local-helper
 
 # 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"
@@ -47,7 +56,8 @@ npx @cremini/skillpack build
 | Command                  | Description                           |
 | ------------------------ | ------------------------------------- |
 | `create`                 | Create a skill pack interactively     |
-| `skills add <source>`    | Add a skill                           |
+| `init`                   | Initialize from a config path or URL  |
+| `skills add <source>`    | Add one or more skills with `--skill` |
 | `skills remove <name>`   | Remove a skill                        |
 | `skills list`            | List installed skills                 |
 | `prompts add <text>`     | Add a prompt                          |
@@ -61,7 +71,7 @@ The extracted archive looks like this:
 
 ```text
 skillpack/
-├── app.json             # App configuration
+├── skillpack.json       # Pack configuration
 ├── skills/              # Collected SKILL.md files
 ├── server/              # Express backend
 ├── web/                 # Web chat UI

package/dist/cli.js

@@ -2,16 +2,18 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 
 // src/commands/create.ts
+import fs4 from "fs";
+import path4 from "path";
 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";
+var PACK_FILE = "skillpack.json";
 function getPackPath(workDir) {
   return path.join(workDir, PACK_FILE);
 }
@@ -24,18 +26,87 @@ function createDefaultConfig(name, description) {
     skills: []
   };
 }
+function validateSkillEntry(value, sourceLabel, index) {
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "skills[${index}]" must be an object`
+    );
+  }
+  const skill = value;
+  if ("installSource" in skill || "specificSkills" in skill) {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: legacy skill fields are no longer supported; keep only "source", "name", and "description"`
+    );
+  }
+  if (typeof skill.source !== "string" || !skill.source.trim()) {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "skills[${index}].source" is required`
+    );
+  }
+  if (typeof skill.name !== "string" || !skill.name.trim()) {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "skills[${index}].name" is required`
+    );
+  }
+  if (typeof skill.description !== "string") {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "skills[${index}].description" must be a string`
+    );
+  }
+}
+function validateConfigShape(value, sourceLabel) {
+  if (!value || typeof value !== "object") {
+    throw new Error(`Invalid config from ${sourceLabel}: expected a JSON object`);
+  }
+  const config = value;
+  if (typeof config.name !== "string" || !config.name.trim()) {
+    throw new Error(`Invalid config from ${sourceLabel}: "name" is required`);
+  }
+  if (typeof config.description !== "string") {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "description" must be a string`
+    );
+  }
+  if (typeof config.version !== "string") {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "version" must be a string`
+    );
+  }
+  if (!Array.isArray(config.prompts) || !config.prompts.every((prompt) => typeof prompt === "string")) {
+    throw new Error(
+      `Invalid config from ${sourceLabel}: "prompts" must be a string array`
+    );
+  }
+  if (!Array.isArray(config.skills)) {
+    throw new Error(`Invalid config from ${sourceLabel}: "skills" must be an array`);
+  }
+  const names = /* @__PURE__ */ new Set();
+  config.skills.forEach((skill, index) => {
+    validateSkillEntry(skill, sourceLabel, index);
+    const normalizedName = skill.name.trim().toLowerCase();
+    if (names.has(normalizedName)) {
+      throw new Error(
+        `Invalid config from ${sourceLabel}: duplicate skill name "${skill.name}" is not allowed`
+      );
+    }
+    names.add(normalizedName);
+  });
+}
 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`
+      `Could not find ${PACK_FILE}. Run npx @cremini/skillpack create first or work in a directory that contains ${PACK_FILE}`
     );
   }
   const raw = fs.readFileSync(filePath, "utf-8");
-  return JSON.parse(raw);
+  const parsed = JSON.parse(raw);
+  validateConfigShape(parsed, filePath);
+  return parsed;
 }
 function saveConfig(workDir, config) {
   const filePath = getPackPath(workDir);
+  validateConfigShape(config, filePath);
   fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function configExists(workDir) {
@@ -50,98 +121,194 @@ import chalk2 from "chalk";
 import { fileURLToPath } from "url";
 
 // src/core/skill-manager.ts
-import { execSync } from "child_process";
+import { spawnSync } from "child_process";
 import fs2 from "fs";
 import path2 from "path";
 import chalk from "chalk";
 var SKILLS_DIR = "skills";
+function normalizeName(value) {
+  return value.trim().toLowerCase();
+}
 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) {
+function groupSkillsBySource(skills) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const source = skill.source.trim();
+    const name = skill.name.trim();
+    const names = groups.get(source) ?? [];
+    if (!names.some((entry) => normalizeName(entry) === normalizeName(name))) {
+      names.push(name);
+    }
+    groups.set(source, names);
+  }
+  return Array.from(groups, ([source, names]) => ({ source, names }));
+}
+function buildInstallArgs(group) {
+  const args = [
+    "-y",
+    "skills",
+    "add",
+    group.source,
+    "--agent",
+    "openclaw",
+    "--copy",
+    "-y"
+  ];
+  for (const name of group.names) {
+    args.push("--skill", name);
+  }
+  return args;
+}
+function installSkills(workDir, skills) {
+  if (skills.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}"`;
-      }
+  for (const group of groupSkillsBySource(skills)) {
+    const args = buildInstallArgs(group);
+    const displayArgs = args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ");
+    console.log(chalk.dim(`> npx ${displayArgs}`));
+    const result = spawnSync("npx", args, {
+      cwd: workDir,
+      stdio: "inherit",
+      encoding: "utf-8"
+    });
+    if (result.error) {
+      throw result.error;
     }
-    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}`));
+    if (result.status !== 0) {
+      throw new Error(
+        `Failed to install skills from ${group.source} (exit code ${result.status ?? "unknown"})`
+      );
     }
   }
-  config.skills = scanInstalledSkills(workDir);
-  saveConfig(workDir, config);
-  console.log(chalk.green(`  Skill installation complete.
-`));
 }
 function scanInstalledSkills(workDir) {
-  const results = [];
+  const installed = [];
   const skillsDir = getSkillsDir(workDir);
   if (!fs2.existsSync(skillsDir)) {
-    return results;
+    return installed;
   }
-  function findSkillFiles(dir) {
+  function visit(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);
-        }
+        visit(fullPath);
+        continue;
+      }
+      if (entry.name !== "SKILL.md") {
+        continue;
+      }
+      const skill = parseSkillMd(fullPath);
+      if (skill) {
+        installed.push(skill);
       }
     }
   }
-  findSkillFiles(skillsDir);
-  return results;
+  visit(skillsDir);
+  return installed;
 }
-function parseSkillMd(filePath, workDir) {
+function parseSkillMd(filePath) {
   try {
     const content = fs2.readFileSync(filePath, "utf-8");
     const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!frontmatterMatch) return null;
+    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;
+    if (!nameMatch) {
+      return null;
+    }
     return {
       name: nameMatch[1].trim(),
-      source: path2.relative(workDir, path2.dirname(filePath)),
-      description: descMatch ? descMatch[1].trim() : ""
+      description: descMatch ? descMatch[1].trim() : "",
+      dir: path2.dirname(filePath)
     };
   } catch {
     return null;
   }
 }
+function syncSkillDescriptions(workDir, config) {
+  const descriptionByName = /* @__PURE__ */ new Map();
+  for (const skill of scanInstalledSkills(workDir)) {
+    descriptionByName.set(normalizeName(skill.name), skill.description);
+  }
+  config.skills = config.skills.map((skill) => {
+    const description = descriptionByName.get(normalizeName(skill.name));
+    return description === void 0 ? skill : { ...skill, description };
+  });
+  return config;
+}
+function upsertSkills(config, skills) {
+  for (const skill of skills) {
+    const normalizedName = normalizeName(skill.name);
+    const normalizedSource = skill.source.trim();
+    const existing = config.skills.find(
+      (entry) => normalizeName(entry.name) === normalizedName
+    );
+    if (existing && existing.source.trim() !== normalizedSource) {
+      throw new Error(
+        `Skill "${skill.name}" is already declared from source "${existing.source}"`
+      );
+    }
+    const sameEntry = config.skills.findIndex(
+      (entry) => normalizeName(entry.name) === normalizedName && entry.source.trim() === normalizedSource
+    );
+    if (sameEntry >= 0) {
+      config.skills[sameEntry] = {
+        ...config.skills[sameEntry],
+        name: skill.name.trim(),
+        source: normalizedSource,
+        description: skill.description
+      };
+      continue;
+    }
+    config.skills.push({
+      name: skill.name.trim(),
+      source: normalizedSource,
+      description: skill.description
+    });
+  }
+  return config;
+}
+function installConfiguredSkills(workDir, config) {
+  installSkills(workDir, config.skills);
+}
+function refreshDescriptionsAndSave(workDir, config) {
+  syncSkillDescriptions(workDir, config);
+  saveConfig(workDir, config);
+  return config;
+}
 function removeSkill(workDir, skillName) {
   const config = loadConfig(workDir);
-  const idx = config.skills.findIndex(
-    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  const normalizedName = normalizeName(skillName);
+  const nextSkills = config.skills.filter(
+    (skill) => normalizeName(skill.name) !== normalizedName
   );
-  if (idx === -1) {
+  if (nextSkills.length === config.skills.length) {
     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);
+  config.skills = nextSkills;
   saveConfig(workDir, config);
+  const installedMatches = scanInstalledSkills(workDir).filter(
+    (skill) => normalizeName(skill.name) === normalizedName
+  );
+  if (installedMatches.length === 0) {
+    console.log(
+      chalk.yellow(`Removed config for ${skillName}, but no installed files were found`)
+    );
+    return true;
+  }
+  for (const skill of installedMatches) {
+    if (fs2.existsSync(skill.dir)) {
+      fs2.rmSync(skill.dir, { recursive: true, force: true });
+    }
+  }
   console.log(chalk.green(`Removed skill: ${skillName}`));
   return true;
 }
@@ -160,7 +327,9 @@ async function bundle(workDir) {
   if (!fs3.existsSync(runtimeDir)) {
     throw new Error(`Runtime directory not found: ${runtimeDir}`);
   }
-  await installPendingSkills(workDir, config);
+  installConfiguredSkills(workDir, config);
+  syncSkillDescriptions(workDir, config);
+  saveConfig(workDir, config);
   console.log(chalk2.blue(`Packaging ${config.name}...`));
   const output = fs3.createWriteStream(zipPath);
   const archive = archiver("zip", { zlib: { level: 9 } });
@@ -176,8 +345,8 @@ async function bundle(workDir) {
     archive.on("error", (err) => reject(err));
     archive.pipe(output);
     const prefix = config.name;
-    archive.file(path3.join(workDir, "app.json"), {
-      name: `${prefix}/app.json`
+    archive.file(getPackPath(workDir), {
+      name: `${prefix}/${PACK_FILE}`
     });
     const skillsDir = path3.join(workDir, "skills");
     if (fs3.existsSync(skillsDir)) {
@@ -221,8 +390,9 @@ function addRuntimeFiles(archive, runtimeDir, prefix) {
 }
 
 // src/commands/create.ts
-import fs4 from "fs";
-import path4 from "path";
+function parseSkillNames(value) {
+  return value.split(",").map((name) => name.trim()).filter(Boolean);
+}
 async function createCommand(directory) {
   const workDir = directory ? path4.resolve(directory) : process.cwd();
   if (directory) {
@@ -233,7 +403,7 @@ async function createCommand(directory) {
       {
         type: "confirm",
         name: "overwrite",
-        message: "An app.json file already exists in this directory. Overwrite it?",
+        message: `Overwrite the existing ${PACK_FILE}?`,
         default: false
       }
     ]);
@@ -248,7 +418,7 @@ async function createCommand(directory) {
       type: "input",
       name: "name",
       message: "App name:",
-      validate: (v) => v.trim() ? true : "Name is required"
+      validate: (value) => value.trim() ? true : "Name is required"
     },
     {
       type: "input",
@@ -258,20 +428,15 @@ async function createCommand(directory) {
     }
   ]);
   const config = createDefaultConfig(name.trim(), description.trim());
+  const requestedSkills = [];
   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"
-    )
+    chalk3.dim("  Supported formats: owner/repo, GitHub URL, or local path")
   );
+  console.log(chalk3.dim("  Example source: vercel-labs/agent-skills"));
+  console.log(chalk3.dim("  Example skill names: frontend-design, skill-creator\n"));
   while (true) {
     const { source } = await inquirer.prompt([
       {
@@ -280,51 +445,29 @@ async function createCommand(directory) {
         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();
+    if (!source.trim()) {
+      break;
     }
-    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 { skillNames } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "skillNames",
+        message: "Skill names (comma-separated):",
+        validate: (value) => parseSkillNames(value).length > 0 ? true : "Enter at least one skill name"
       }
-      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
-    });
+    ]);
+    const nextSkills = parseSkillNames(skillNames).map((skillName) => ({
+      source: source.trim(),
+      name: skillName,
+      description: ""
+    }));
+    upsertSkills(config, nextSkills);
+    requestedSkills.push(...nextSkills);
   }
   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"
+      "Use prompts to explain how the pack should orchestrate the selected skills\n"
     )
   );
   let promptIndex = 1;
@@ -335,15 +478,15 @@ async function createCommand(directory) {
         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
+        validate: isFirst ? (value) => value.trim() ? true : "The first Prompt cannot be empty" : void 0
       }
     ]);
-    if (!isFirst && !prompt.trim()) break;
+    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",
@@ -352,6 +495,14 @@ async function createCommand(directory) {
       default: true
     }
   ]);
+  saveConfig(workDir, config);
+  console.log(chalk3.green(`
+  ${PACK_FILE} saved
+`));
+  if (requestedSkills.length > 0) {
+    installConfiguredSkills(workDir, config);
+    refreshDescriptionsAndSave(workDir, config);
+  }
   if (shouldBundle) {
     await bundle(workDir);
   }
@@ -363,26 +514,111 @@ async function createCommand(directory) {
   }
 }
 
-// src/commands/skills-cmd.ts
+// src/commands/init.ts
+import fs5 from "fs";
+import path5 from "path";
+import inquirer2 from "inquirer";
 import chalk4 from "chalk";
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function readConfigSource(source) {
+  let raw = "";
+  if (isHttpUrl(source)) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to download config: ${response.status} ${response.statusText}`);
+    }
+    raw = await response.text();
+  } else {
+    const filePath = path5.resolve(source);
+    raw = fs5.readFileSync(filePath, "utf-8");
+  }
+  const parsed = JSON.parse(raw);
+  validateConfigShape(parsed, source);
+  return parsed;
+}
+async function initCommand(directory, options) {
+  const workDir = directory ? path5.resolve(directory) : process.cwd();
+  if (directory) {
+    fs5.mkdirSync(workDir, { recursive: true });
+  }
+  if (configExists(workDir)) {
+    const { overwrite } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: `A ${PACK_FILE} file already exists in this directory. Overwrite it?`,
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk4.yellow("Cancelled"));
+      return;
+    }
+  }
+  const config = await readConfigSource(options.config);
+  saveConfig(workDir, config);
+  console.log(chalk4.blue(`
+  Initialize ${config.name} from ${options.config}
+`));
+  installConfiguredSkills(workDir, config);
+  refreshDescriptionsAndSave(workDir, config);
+  if (options.bundle) {
+    await bundle(workDir);
+  }
+  console.log(chalk4.green(`
+  ${PACK_FILE} saved
+`));
+  console.log(chalk4.green("  Initialization complete.\n"));
+  if (!options.bundle) {
+    console.log(
+      chalk4.dim("  Run npx @cremini/skillpack build to create the zip when needed\n")
+    );
+  }
+}
+
+// src/commands/skills-cmd.ts
+import chalk5 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) => {
+    if (!opts.skill || opts.skill.length === 0) {
+      console.log(
+        chalk5.red(
+          "Specify at least one skill name with --skill when adding a source"
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
     const workDir = process.cwd();
     const config = loadConfig(workDir);
-    config.skills.push({
-      name: opts.skill ? opts.skill.join(", ") : source,
+    const requestedSkills = opts.skill.map((name) => ({
+      name: name.trim(),
       source,
-      description: "Pending installation",
-      installSource: source,
-      specificSkills: opts.skill && opts.skill.length > 0 ? opts.skill : void 0
-    });
+      description: ""
+    }));
+    upsertSkills(config, requestedSkills);
     saveConfig(workDir, config);
-    console.log(
-      chalk4.green(
-        `Skill list updated (${config.skills.length} total). Skills will be installed during build.`
-      )
-    );
+    try {
+      installSkills(workDir, requestedSkills);
+      refreshDescriptionsAndSave(workDir, config);
+    } catch (error) {
+      console.log(
+        chalk5.red(
+          `Skill installation failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk5.green(`Installed ${requestedSkills.length} skill(s).`));
   });
   skills.command("remove <name>").description("Remove a skill").action((name) => {
     removeSkill(process.cwd(), name);
@@ -390,16 +626,16 @@ function registerSkillsCommand(program2) {
   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"));
+      console.log(chalk5.dim("  No skills installed"));
       return;
     }
-    console.log(chalk4.blue(`
+    console.log(chalk5.blue(`
   ${config.name} Skills:
 `));
     for (const skill of config.skills) {
-      console.log(`  ${chalk4.green("\u25CF")} ${chalk4.bold(skill.name)}`);
+      console.log(`  ${chalk5.green("\u25CF")} ${chalk5.bold(skill.name)}`);
       if (skill.description) {
-        console.log(`    ${chalk4.dim(skill.description)}`);
+        console.log(`    ${chalk5.dim(skill.description)}`);
       }
     }
     console.log();
@@ -407,29 +643,29 @@ function registerSkillsCommand(program2) {
 }
 
 // src/commands/prompts-cmd.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 
 // src/core/prompts.ts
-import chalk5 from "chalk";
+import chalk6 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}`));
+  console.log(chalk6.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)`)
+      chalk6.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)}..."`)
+    chalk6.green(`Removed Prompt #${index}: "${removed.substring(0, 50)}..."`)
   );
   return true;
 }
@@ -447,7 +683,7 @@ function registerPromptsCommand(program2) {
   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"));
+      console.log(chalk7.red("Enter a valid numeric index"));
       return;
     }
     removePrompt(process.cwd(), num);
@@ -455,13 +691,13 @@ function registerPromptsCommand(program2) {
   prompts.command("list").description("List all prompts").action(() => {
     const prompts2 = listPrompts(process.cwd());
     if (prompts2.length === 0) {
-      console.log(chalk6.dim("  No prompts yet"));
+      console.log(chalk7.dim("  No prompts yet"));
       return;
     }
-    console.log(chalk6.blue("\n  Prompts:\n"));
+    console.log(chalk7.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 marker = i === 0 ? chalk7.green("\u2605") : chalk7.dim("\u25CF");
+      const label = i === 0 ? chalk7.dim(" (default)") : "";
       const display = u.length > 80 ? u.substring(0, 80) + "..." : u;
       console.log(`  ${marker} #${i + 1}${label} ${display}`);
     });
@@ -470,22 +706,27 @@ function registerPromptsCommand(program2) {
 }
 
 // src/cli.ts
-import fs5 from "fs";
+import fs6 from "fs";
 var packageJson = JSON.parse(
-  fs5.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs6.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);
 });
+program.command("init [directory]").description("Initialize a skills pack from a local config file or URL").requiredOption("--config <path-or-url>", "Path or URL to a skillpack.json file").option("--bundle", "Bundle as a zip after initialization").action(
+  async (directory, options) => {
+    await initCommand(directory, options);
+  }
+);
 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}`));
+    console.error(chalk8.red(`Packaging failed: ${err}`));
     process.exit(1);
   }
 });

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Turn Skills into a Standalone App with UI",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/FinpeakInc/skillpack.git"
+    "url": "git+https://github.com/CreminiAI/skillpack.git"
   },
   "bugs": {
-    "url": "https://github.com/FinpeakInc/skillpack/issues"
+    "url": "https://github.com/CreminiAI/skillpack/issues"
   },
-  "homepage": "https://github.com/FinpeakInc/skillpack#readme",
+  "homepage": "https://github.com/CreminiAI/skillpack#readme",
   "bin": {
     "skillpack": "dist/cli.js"
   },

package/runtime/scripts/start.sh

@@ -3,8 +3,8 @@ cd "$(dirname "$0")"
 
 # Read the pack name
 PACK_NAME="Skills Pack"
-if [ -f "app.json" ] && command -v node &> /dev/null; then
-  PACK_NAME=$(node -e "console.log(JSON.parse(require('fs').readFileSync('app.json','utf-8')).name)" 2>/dev/null || echo "Skills Pack")
+if [ -f "skillpack.json" ] && command -v node &> /dev/null; then
+  PACK_NAME=$(node -e "console.log(JSON.parse(require('fs').readFileSync('skillpack.json','utf-8')).name)" 2>/dev/null || echo "Skills Pack")
 fi
 
 echo ""

package/runtime/server/index.js

@@ -28,21 +28,25 @@ registerRoutes(app, server, rootDir);
 const HOST = process.env.HOST || "127.0.0.1";
 const DEFAULT_PORT = 26313;
 
+server.once("listening", () => {
+  const address = server.address();
+  const actualPort = typeof address === "string" ? address : address.port;
+  const url = `http://${HOST}:${actualPort}`;
+  console.log(`\n  Skills Pack Server`);
+  console.log(`  Running at ${url}\n`);
+
+  // Open the browser automatically
+  const cmd =
+    process.platform === "darwin"
+      ? `open ${url}`
+      : process.platform === "win32"
+        ? `start ${url}`
+        : `xdg-open ${url}`;
+  exec(cmd, () => {});
+});
+
 function tryListen(port) {
-  server.listen(port, HOST, () => {
-    const url = `http://${HOST}:${port}`;
-    console.log(`\n  Skills Pack Server`);
-    console.log(`  Running at ${url}\n`);
-
-    // Open the browser automatically
-    const cmd =
-      process.platform === "darwin"
-        ? `open ${url}`
-        : process.platform === "win32"
-          ? `start ${url}`
-          : `xdg-open ${url}`;
-    exec(cmd, () => {});
-  });
+  server.listen(port, HOST);
 
   server.once("error", (err) => {
     if (err.code === "EADDRINUSE") {

package/runtime/server/routes.js

@@ -5,11 +5,11 @@ import { WebSocketServer } from "ws";
 import { handleWsConnection } from "./chat-proxy.js";
 
 /**
- * Read the app.json config.
+ * Read the skillpack.json config.
  * @param {string} rootDir
  */
 function getPackConfig(rootDir) {
-  const raw = fs.readFileSync(path.join(rootDir, "app.json"), "utf-8");
+  const raw = fs.readFileSync(path.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
 
@@ -17,7 +17,7 @@ function getPackConfig(rootDir) {
  * Register all API routes.
  * @param {import("express").Express} app
  * @param {import("node:http").Server} server
- * @param {string} rootDir - Root directory containing app.json and skills/
+ * @param {string} rootDir - Root directory containing skillpack.json and skills/
  */
 export function registerRoutes(app, server, rootDir) {
   // API key and provider are stored in runtime memory

package/runtime/server/skills-loader.js

@@ -1,31 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-/**
- * Recursively load the contents of all SKILL.md files under skills/.
- * @param {string} rootDir - Root directory containing skills/
- * @returns {string[]} Array of SKILL.md file contents
- */
-export function loadSkillContents(rootDir) {
-  const skillsDir = path.join(rootDir, "skills");
-  const contents = [];
-
-  if (!fs.existsSync(skillsDir)) {
-    return contents;
-  }
-
-  function walk(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full);
-      } else if (entry.name === "SKILL.md") {
-        contents.push(fs.readFileSync(full, "utf-8"));
-      }
-    }
-  }
-
-  walk(skillsDir);
-  return contents;
-}