@cremini/skillpack 1.0.5 → 1.0.7

package/README.md

@@ -27,14 +27,14 @@ 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
+### Initialize with Configuration
 
 ```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`.
+Bootstrap a SkillPack using a local file or remote URL.
 
 ### Step-by-Step Commands
 
@@ -73,11 +73,11 @@ The extracted archive looks like this:
 skillpack/
 ├── skillpack.json       # Pack configuration
 ├── skills/              # Collected SKILL.md files
-├── server/              # Express backend
-├── web/                 # Web chat UI
+├── server/              # Runtime backend
+├── web/                 # Runtime web UI
 ├── start.sh             # One-click launcher for macOS/Linux
 ├── start.bat            # One-click launcher for Windows
-└── README.md
+└── README.md            # Runtime guide
 ```
 
 ### Run the Skill Pack

package/dist/cli.js

@@ -5,8 +5,8 @@ import { Command } from "commander";
 import chalk8 from "chalk";
 
 // src/commands/create.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import inquirer from "inquirer";
 import chalk3 from "chalk";
 
@@ -114,11 +114,10 @@ function configExists(workDir) {
 }
 
 // src/core/bundler.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import archiver from "archiver";
 import chalk2 from "chalk";
-import { fileURLToPath } from "url";
 
 // src/core/skill-manager.ts
 import { spawnSync } from "child_process";
@@ -313,25 +312,98 @@ function removeSkill(workDir, skillName) {
   return true;
 }
 
-// src/core/bundler.ts
+// src/core/runtime-template.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 function getRuntimeDir() {
   const projectRoot = path3.resolve(__dirname, "..");
   return path3.join(projectRoot, "runtime");
 }
+function assertRuntimeDirExists(runtimeDir) {
+  if (!fs3.existsSync(runtimeDir)) {
+    throw new Error(`Runtime directory not found: ${runtimeDir}`);
+  }
+}
+function collectRuntimeTemplateEntries(runtimeDir) {
+  assertRuntimeDirExists(runtimeDir);
+  const entries = [];
+  function visit(currentDir, relativeDir = "") {
+    const dirEntries = fs3.readdirSync(currentDir, { withFileTypes: true });
+    for (const dirEntry of dirEntries) {
+      if (dirEntry.name === "node_modules") {
+        continue;
+      }
+      const absolutePath = path3.join(currentDir, dirEntry.name);
+      const relativePath = relativeDir ? path3.posix.join(relativeDir, dirEntry.name) : dirEntry.name;
+      const stats = fs3.statSync(absolutePath);
+      if (dirEntry.isDirectory()) {
+        entries.push({
+          absolutePath,
+          relativePath,
+          stats,
+          type: "directory"
+        });
+        visit(absolutePath, relativePath);
+        continue;
+      }
+      if (dirEntry.isFile()) {
+        entries.push({
+          absolutePath,
+          relativePath,
+          stats,
+          type: "file"
+        });
+      }
+    }
+  }
+  visit(runtimeDir);
+  return entries;
+}
+function copyRuntimeTemplate(runtimeDir, workDir) {
+  const entries = collectRuntimeTemplateEntries(runtimeDir);
+  for (const entry of entries) {
+    const destinationPath = path3.join(workDir, entry.relativePath);
+    if (entry.type === "directory") {
+      fs3.mkdirSync(destinationPath, { recursive: true });
+      continue;
+    }
+    fs3.mkdirSync(path3.dirname(destinationPath), { recursive: true });
+    fs3.copyFileSync(entry.absolutePath, destinationPath);
+    fs3.chmodSync(destinationPath, entry.stats.mode);
+  }
+}
+function addRuntimeFiles(archive, runtimeDir, prefix) {
+  const entries = collectRuntimeTemplateEntries(runtimeDir);
+  for (const entry of entries) {
+    const archivePath = `${prefix}/${entry.relativePath}`;
+    if (entry.type === "directory") {
+      archive.append("", {
+        name: `${archivePath}/`,
+        mode: entry.stats.mode
+      });
+      continue;
+    }
+    archive.file(entry.absolutePath, {
+      name: archivePath,
+      mode: entry.stats.mode
+    });
+  }
+}
+
+// src/core/bundler.ts
 async function bundle(workDir) {
   const config = loadConfig(workDir);
   const zipName = `${config.name}.zip`;
-  const zipPath = path3.join(workDir, zipName);
+  const zipPath = path4.join(workDir, zipName);
   const runtimeDir = getRuntimeDir();
-  if (!fs3.existsSync(runtimeDir)) {
-    throw new Error(`Runtime directory not found: ${runtimeDir}`);
-  }
+  assertRuntimeDirExists(runtimeDir);
   installConfiguredSkills(workDir, config);
   syncSkillDescriptions(workDir, config);
   saveConfig(workDir, config);
   console.log(chalk2.blue(`Packaging ${config.name}...`));
-  const output = fs3.createWriteStream(zipPath);
+  const output = fs4.createWriteStream(zipPath);
   const archive = archiver("zip", { zlib: { level: 9 } });
   return new Promise((resolve, reject) => {
     output.on("close", () => {
@@ -348,55 +420,23 @@ async function bundle(workDir) {
     archive.file(getPackPath(workDir), {
       name: `${prefix}/${PACK_FILE}`
     });
-    const skillsDir = path3.join(workDir, "skills");
-    if (fs3.existsSync(skillsDir)) {
+    const skillsDir = path4.join(workDir, "skills");
+    if (fs4.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
 function parseSkillNames(value) {
   return value.split(",").map((name) => name.trim()).filter(Boolean);
 }
 async function createCommand(directory) {
-  const workDir = directory ? path4.resolve(directory) : process.cwd();
+  const workDir = directory ? path5.resolve(directory) : process.cwd();
   if (directory) {
-    fs4.mkdirSync(workDir, { recursive: true });
+    fs5.mkdirSync(workDir, { recursive: true });
   }
   if (configExists(workDir)) {
     const { overwrite } = await inquirer.prompt([
@@ -515,8 +555,8 @@ async function createCommand(directory) {
 }
 
 // src/commands/init.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 function isHttpUrl(value) {
@@ -536,17 +576,17 @@ async function readConfigSource(source) {
     }
     raw = await response.text();
   } else {
-    const filePath = path5.resolve(source);
-    raw = fs5.readFileSync(filePath, "utf-8");
+    const filePath = path6.resolve(source);
+    raw = fs6.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();
+  const workDir = directory ? path6.resolve(directory) : process.cwd();
   if (directory) {
-    fs5.mkdirSync(workDir, { recursive: true });
+    fs6.mkdirSync(workDir, { recursive: true });
   }
   if (configExists(workDir)) {
     const { overwrite } = await inquirer2.prompt([
@@ -569,12 +609,14 @@ async function initCommand(directory, options) {
 `));
   installConfiguredSkills(workDir, config);
   refreshDescriptionsAndSave(workDir, config);
+  copyRuntimeTemplate(getRuntimeDir(), workDir);
   if (options.bundle) {
     await bundle(workDir);
   }
   console.log(chalk4.green(`
   ${PACK_FILE} saved
 `));
+  console.log(chalk4.green("  Runtime template expanded.\n"));
   console.log(chalk4.green("  Initialization complete.\n"));
   if (!options.bundle) {
     console.log(
@@ -706,16 +748,18 @@ function registerPromptsCommand(program2) {
 }
 
 // src/cli.ts
-import fs6 from "fs";
+import fs7 from "fs";
 var packageJson = JSON.parse(
-  fs6.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs7.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(
+program.command("init [directory]").description(
+  "Initialize a skills pack from a local config file or URL and expand runtime files"
+).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);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Turn Skills into a Standalone App with UI",
   "type": "module",
   "repository": {
@@ -16,14 +16,7 @@
   },
   "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",
+    "runtime",
     "README.md",
     "LICENSE"
   ],
@@ -61,4 +54,4 @@
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
-}
+}