skild 0.0.8 → 0.1.1

package/README.md

@@ -23,4 +23,13 @@ skild install https://github.com/anthropics/skills/tree/main/skills/pdf -t codex
 
 # List installed skills
 skild list -t codex --local
+
+# Inspect / Validate / Update / Uninstall
+skild info pdf -t codex --local
+skild validate pdf -t codex --local
+skild update pdf -t codex --local
+skild uninstall pdf -t codex --local
+
+# Create a new Skill
+skild init my-skill
 ```

package/dist/index.js

@@ -2,260 +2,12 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk9 from "chalk";
 import { createRequire } from "module";
 
 // src/commands/install.ts
 import chalk2 from "chalk";
-
-// src/services/skill-installer.ts
-import degit from "degit";
-import path4 from "path";
-
-// src/utils/fs-helpers.ts
-import fs from "fs";
-import path from "path";
-function isDirEmpty(dir) {
-  try {
-    const entries = fs.readdirSync(dir);
-    return entries.length === 0;
-  } catch {
-    return true;
-  }
-}
-function safeRemoveDir(dir) {
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-}
-function isDirectory(filePath) {
-  try {
-    return fs.statSync(filePath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function pathExists(filePath) {
-  return fs.existsSync(filePath);
-}
-function copyDir(src, dest) {
-  fs.cpSync(src, dest, { recursive: true });
-}
-function hasSkillMd(skillPath) {
-  return fs.existsSync(path.join(skillPath, "SKILL.md"));
-}
-function getSubdirectories(dir) {
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-function sanitizeForPathSegment(value) {
-  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function createTempDir(parentDir, prefix) {
-  const safePrefix = sanitizeForPathSegment(prefix || "tmp");
-  const template = path.join(parentDir, `.skild-${safePrefix}-`);
-  return fs.mkdtempSync(template);
-}
-function replaceDirAtomic(sourceDir, destDir) {
-  const backupDir = fs.existsSync(destDir) ? `${destDir}.bak-${Date.now()}` : null;
-  try {
-    if (backupDir) {
-      fs.renameSync(destDir, backupDir);
-    }
-    fs.renameSync(sourceDir, destDir);
-    if (backupDir) {
-      safeRemoveDir(backupDir);
-    }
-  } catch (error) {
-    try {
-      if (!fs.existsSync(destDir) && backupDir && fs.existsSync(backupDir)) {
-        fs.renameSync(backupDir, destDir);
-      }
-    } catch {
-    }
-    try {
-      if (fs.existsSync(sourceDir)) {
-        safeRemoveDir(sourceDir);
-      }
-    } catch {
-    }
-    throw error;
-  }
-}
-
-// src/services/source-parser.ts
-import path2 from "path";
-function classifySource(source) {
-  const resolvedPath = path2.resolve(source);
-  if (pathExists(resolvedPath)) {
-    return "local";
-  }
-  if (/^https?:\/\//i.test(source) || source.includes("github.com")) {
-    return "github-url";
-  }
-  if (/^[^/]+\/[^/]+/.test(source)) {
-    return "degit-shorthand";
-  }
-  return "unknown";
-}
-function extractSkillName(url) {
-  const maybeLocalPath = path2.resolve(url);
-  if (pathExists(maybeLocalPath)) {
-    return path2.basename(maybeLocalPath) || "unknown-skill";
-  }
-  const cleaned = url.replace(/[#?].*$/, "");
-  const treeMatch = cleaned.match(/\/tree\/[^/]+\/(.+?)(?:\/)?$/);
-  if (treeMatch) {
-    return treeMatch[1].split("/").pop() || "unknown-skill";
-  }
-  const repoMatch = cleaned.match(/github\.com\/[^/]+\/([^/]+)/);
-  if (repoMatch) {
-    return repoMatch[1].replace(/\.git$/, "");
-  }
-  const parts = cleaned.split("/").filter(Boolean);
-  if (parts.length >= 2) {
-    return parts[parts.length - 1] || "unknown-skill";
-  }
-  return cleaned || "unknown-skill";
-}
-function toDegitPath(url) {
-  const treeMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+?)(?:\/)?$/);
-  if (treeMatch) {
-    const [, owner, repo, branch, subpath] = treeMatch;
-    return `${owner}/${repo}/${subpath}#${branch}`;
-  }
-  const repoMatch = url.match(/github\.com\/([^/]+\/[^/]+)/);
-  if (repoMatch) {
-    return repoMatch[1].replace(/\.git$/, "");
-  }
-  return url;
-}
-function resolveLocalPath(source) {
-  const resolvedPath = path2.resolve(source);
-  return pathExists(resolvedPath) ? resolvedPath : null;
-}
-
-// src/utils/config.ts
-import os from "os";
-import path3 from "path";
-import fs2 from "fs";
-
-// src/constants.ts
-var PLATFORMS = ["claude", "codex", "copilot"];
-var DEFAULT_PLATFORM = "claude";
-var ERROR_MESSAGES = {
-  EMPTY_INSTALL_DIR: (source) => `Installed directory is empty for source: ${source}
-Source likely does not point to a valid subdirectory.
-Try: https://github.com/<owner>/<repo>/tree/<branch>/skills/<skill-name>
-Example: https://github.com/anthropics/skills/tree/main/skills/pdf`,
-  INVALID_SOURCE: (source) => `Unsupported source "${source}". Use a Git URL (e.g. https://github.com/owner/repo) or degit shorthand (e.g. owner/repo[/subdir][#ref]).`,
-  NOT_A_DIRECTORY: (path6) => `Source path is not a directory: ${path6}`,
-  NO_SKILLS_INSTALLED: "No skills installed.",
-  INSTALL_HINT: "Use `skild install <url>` to install a skill."
-};
-var SUCCESS_MESSAGES = {
-  SKILL_MD_FOUND: "SKILL.md found \u2713",
-  SKILL_MD_WARNING: "Warning: No SKILL.md found"
-};
-
-// src/utils/config.ts
-function getSkillsDir(platform = DEFAULT_PLATFORM, projectLevel = false) {
-  const base = projectLevel ? process.cwd() : os.homedir();
-  switch (platform) {
-    case "claude":
-      return path3.join(base, ".claude", "skills");
-    case "codex":
-      return path3.join(base, ".codex", "skills");
-    case "copilot":
-      return path3.join(base, ".github", "skills");
-    default:
-      return path3.join(base, ".claude", "skills");
-  }
-}
-var SKILLS_DIR = getSkillsDir(DEFAULT_PLATFORM, false);
-function ensureSkillsDir(platform = DEFAULT_PLATFORM, projectLevel = false) {
-  const dir = getSkillsDir(platform, projectLevel);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function getSkillPath(skillName, platform = DEFAULT_PLATFORM, projectLevel = false) {
-  return path3.join(getSkillsDir(platform, projectLevel), skillName);
-}
-
-// src/services/skill-installer.ts
-async function cloneRemote(degitSrc, targetPath) {
-  const emitter = degit(degitSrc, { force: true, verbose: false });
-  await emitter.clone(targetPath);
-}
-function copyLocal(sourcePath, targetPath) {
-  if (!isDirectory(sourcePath)) {
-    throw new Error(ERROR_MESSAGES.NOT_A_DIRECTORY(sourcePath));
-  }
-  copyDir(sourcePath, targetPath);
-}
-function validateStaging(stagingPath, source) {
-  if (isDirEmpty(stagingPath)) {
-    throw new Error(ERROR_MESSAGES.EMPTY_INSTALL_DIR(source));
-  }
-}
-function resolveInstallContext(source, options = {}) {
-  const platform = options.target || DEFAULT_PLATFORM;
-  const projectLevel = options.local || false;
-  const skillName = extractSkillName(source);
-  const skillsDir = getSkillsDir(platform, projectLevel);
-  const targetPath = getSkillPath(skillName, platform, projectLevel);
-  const locationLabel = projectLevel ? "project" : "global";
-  const localPath = resolveLocalPath(source);
-  const sourceType = localPath ? "local" : classifySource(source);
-  if (!localPath && sourceType === "unknown") {
-    throw new Error(ERROR_MESSAGES.INVALID_SOURCE(source));
-  }
-  const degitPath = localPath ? null : toDegitPath(source);
-  return {
-    source,
-    sourceType,
-    localPath,
-    degitPath,
-    skillName,
-    platform,
-    projectLevel,
-    skillsDir,
-    targetPath,
-    locationLabel
-  };
-}
-async function installSkillFromContext(context) {
-  ensureSkillsDir(context.platform, context.projectLevel);
-  const tempRoot = createTempDir(context.skillsDir, context.skillName);
-  const stagingPath = path4.join(tempRoot, "staging");
-  try {
-    if (context.localPath) {
-      copyLocal(context.localPath, stagingPath);
-    } else {
-      if (!context.degitPath) {
-        throw new Error(ERROR_MESSAGES.INVALID_SOURCE(context.source));
-      }
-      await cloneRemote(context.degitPath, stagingPath);
-    }
-    validateStaging(stagingPath, context.source);
-    replaceDirAtomic(stagingPath, context.targetPath);
-    return {
-      skillName: context.skillName,
-      platform: context.platform,
-      projectLevel: context.projectLevel,
-      targetPath: context.targetPath,
-      hasSkillMd: hasSkillMd(context.targetPath)
-    };
-  } finally {
-    safeRemoveDir(tempRoot);
-  }
-}
+import { installSkill, SkildError } from "@skild/core";
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -303,10 +55,10 @@ var logger = {
   /**
    * Log a skill entry with status indicator.
    */
-  skillEntry: (name, path6, hasSkillMd2) => {
-    const status = hasSkillMd2 ? chalk.green("\u2713") : chalk.yellow("\u26A0");
+  skillEntry: (name, path, hasSkillMd) => {
+    const status = hasSkillMd ? chalk.green("\u2713") : chalk.yellow("\u26A0");
     console.log(`  ${status} ${chalk.cyan(name)}`);
-    console.log(chalk.dim(`    \u2514\u2500 ${path6}`));
+    console.log(chalk.dim(`    \u2514\u2500 ${path}`));
   },
   /**
    * Log installation result details.
@@ -319,84 +71,212 @@ var logger = {
 
 // src/commands/install.ts
 async function install(source, options = {}) {
-  let context;
-  try {
-    context = resolveInstallContext(source, options);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(chalk2.red(message));
-    process.exitCode = 1;
-    return;
-  }
-  const spinner = createSpinner(
-    `Installing ${chalk2.cyan(context.skillName)} to ${chalk2.dim(context.platform)} (${context.locationLabel})...`
-  );
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  const spinner = createSpinner(`Installing ${chalk2.cyan(source)} to ${chalk2.dim(platform)} (${scope})...`);
   try {
-    const result = await installSkillFromContext(context);
-    spinner.succeed(`Installed ${chalk2.green(result.skillName)} to ${chalk2.dim(result.targetPath)}`);
-    if (result.hasSkillMd) {
-      logger.installDetail(SUCCESS_MESSAGES.SKILL_MD_FOUND);
+    const record = await installSkill(
+      { source },
+      {
+        platform,
+        scope,
+        force: Boolean(options.force)
+      }
+    );
+    spinner.succeed(`Installed ${chalk2.green(record.name)} to ${chalk2.dim(record.installDir)}`);
+    if (options.json) {
+      console.log(JSON.stringify(record, null, 2));
+      return;
+    }
+    if (record.hasSkillMd) {
+      logger.installDetail("SKILL.md found \u2713");
     } else {
-      logger.installDetail(SUCCESS_MESSAGES.SKILL_MD_WARNING, true);
+      logger.installDetail("Warning: No SKILL.md found", true);
+    }
+    if (record.skill?.validation && !record.skill.validation.ok) {
+      logger.installDetail(`Validation: ${chalk2.yellow("failed")} (${record.skill.validation.issues.length} issues)`, true);
+    } else if (record.skill?.validation?.ok) {
+      logger.installDetail(`Validation: ${chalk2.green("ok")}`);
     }
   } catch (error) {
-    spinner.fail(`Failed to install ${chalk2.red(context.skillName)}`);
-    const message = error instanceof Error ? error.message : String(error);
+    spinner.fail(`Failed to install ${chalk2.red(source)}`);
+    const message = error instanceof SkildError ? error.message : error instanceof Error ? error.message : String(error);
     console.error(chalk2.red(message));
     process.exitCode = 1;
   }
 }
 
 // src/commands/list.ts
-import path5 from "path";
+import chalk3 from "chalk";
+import { listSkills } from "@skild/core";
 async function list(options = {}) {
-  const platform = options.target || DEFAULT_PLATFORM;
-  const projectLevel = options.local || false;
-  const skillsDir = ensureSkillsDir(platform, projectLevel);
-  const skills = getSubdirectories(skillsDir);
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  const skills = listSkills({ platform, scope });
+  if (options.json) {
+    console.log(JSON.stringify(skills, null, 2));
+    return;
+  }
   if (skills.length === 0) {
-    logger.dim(ERROR_MESSAGES.NO_SKILLS_INSTALLED);
-    logger.dim(ERROR_MESSAGES.INSTALL_HINT);
+    console.log(chalk3.dim("No skills installed."));
+    console.log(chalk3.dim(`Use ${chalk3.cyan("skild install <source>")} to install a skill.`));
     return;
   }
-  const locationLabel = projectLevel ? "project" : "global";
-  logger.header(`
-\u{1F4E6} Installed Skills (${skills.length}) \u2014 ${platform} (${locationLabel}):
-`);
-  for (const skillName of skills) {
-    const skillPath = path5.join(skillsDir, skillName);
-    const hasSkill = hasSkillMd(skillPath);
-    logger.skillEntry(skillName, skillPath, hasSkill);
+  console.log(chalk3.bold(`
+\u{1F4E6} Installed Skills (${skills.length}) \u2014 ${platform} (${scope}):
+`));
+  for (const s of skills) {
+    const status = s.hasSkillMd ? chalk3.green("\u2713") : chalk3.yellow("\u26A0");
+    console.log(`  ${status} ${chalk3.cyan(s.name)}`);
+    console.log(chalk3.dim(`    \u2514\u2500 ${s.installDir}`));
   }
   console.log("");
 }
 
-// src/types/index.ts
-function isPlatform(value) {
-  return typeof value === "string" && PLATFORMS.includes(value);
+// src/commands/info.ts
+import chalk4 from "chalk";
+import { getSkillInfo, SkildError as SkildError2 } from "@skild/core";
+async function info(skill, options = {}) {
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  try {
+    const record = getSkillInfo(skill, { platform, scope });
+    if (options.json) {
+      console.log(JSON.stringify(record, null, 2));
+      return;
+    }
+    console.log(chalk4.bold(`
+${chalk4.cyan(record.name)}
+`));
+    console.log(`  ${chalk4.dim("Path:")} ${record.installDir}`);
+    console.log(`  ${chalk4.dim("Source:")} ${record.source}`);
+    console.log(`  ${chalk4.dim("Target:")} ${record.platform} (${record.scope})`);
+    console.log(`  ${chalk4.dim("Installed:")} ${record.installedAt}`);
+    if (record.updatedAt) console.log(`  ${chalk4.dim("Updated:")} ${record.updatedAt}`);
+    console.log(`  ${chalk4.dim("Hash:")} ${record.contentHash}`);
+    console.log(`  ${chalk4.dim("SKILL.md:")} ${record.hasSkillMd ? chalk4.green("yes") : chalk4.yellow("no")}`);
+    const validation = record.skill?.validation;
+    if (validation) {
+      console.log(`  ${chalk4.dim("Validate:")} ${validation.ok ? chalk4.green("ok") : chalk4.red("failed")}`);
+      if (!validation.ok) {
+        for (const issue of validation.issues) {
+          const color = issue.level === "error" ? chalk4.red : chalk4.yellow;
+          console.log(`    - ${color(issue.level)}: ${issue.message}`);
+        }
+      }
+    }
+    console.log("");
+  } catch (error) {
+    const message = error instanceof SkildError2 ? error.message : error instanceof Error ? error.message : String(error);
+    console.error(chalk4.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/uninstall.ts
+import chalk5 from "chalk";
+import { uninstallSkill, SkildError as SkildError3 } from "@skild/core";
+async function uninstall(skill, options = {}) {
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  const spinner = createSpinner(`Uninstalling ${chalk5.cyan(skill)} from ${chalk5.dim(platform)} (${scope})...`);
+  try {
+    uninstallSkill(skill, { platform, scope, allowMissingMetadata: Boolean(options.force) });
+    spinner.succeed(`Uninstalled ${chalk5.green(skill)}`);
+  } catch (error) {
+    spinner.fail(`Failed to uninstall ${chalk5.red(skill)}`);
+    const message = error instanceof SkildError3 ? error.message : error instanceof Error ? error.message : String(error);
+    console.error(chalk5.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/update.ts
+import chalk6 from "chalk";
+import { updateSkill, SkildError as SkildError4 } from "@skild/core";
+async function update(skill, options = {}) {
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  const label = skill ? skill : "all skills";
+  const spinner = createSpinner(`Updating ${chalk6.cyan(label)} on ${chalk6.dim(platform)} (${scope})...`);
+  try {
+    const results = await updateSkill(skill, { platform, scope });
+    spinner.succeed(`Updated ${chalk6.green(results.length.toString())} skill(s).`);
+    if (options.json) {
+      console.log(JSON.stringify(results, null, 2));
+    }
+  } catch (error) {
+    spinner.fail(`Failed to update ${chalk6.red(label)}`);
+    const message = error instanceof SkildError4 ? error.message : error instanceof Error ? error.message : String(error);
+    console.error(chalk6.red(message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/validate.ts
+import chalk7 from "chalk";
+import { validateSkill } from "@skild/core";
+async function validate(target, options = {}) {
+  const platform = options.target || "claude";
+  const scope = options.local ? "project" : "global";
+  const value = target || ".";
+  const result = validateSkill(value, { platform, scope });
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    process.exitCode = result.ok ? 0 : 1;
+    return;
+  }
+  if (result.ok) {
+    console.log(chalk7.green("\u2713"), "Valid skill");
+    if (result.frontmatter?.name) console.log(chalk7.dim(`  name: ${result.frontmatter.name}`));
+    return;
+  }
+  console.error(chalk7.red("\u2717"), "Invalid skill");
+  for (const issue of result.issues) {
+    const color = issue.level === "error" ? chalk7.red : chalk7.yellow;
+    console.error(`  - ${color(issue.level)}: ${issue.message}`);
+  }
+  process.exitCode = 1;
+}
+
+// src/commands/init.ts
+import chalk8 from "chalk";
+import { initSkill, SkildError as SkildError5 } from "@skild/core";
+async function init(name, options = {}) {
+  const spinner = createSpinner(`Initializing ${chalk8.cyan(name)}...`);
+  try {
+    const createdDir = initSkill(name, {
+      dir: options.dir,
+      description: options.description,
+      force: Boolean(options.force)
+    });
+    spinner.succeed(`Created ${chalk8.green(name)} at ${chalk8.dim(createdDir)}`);
+    console.log(chalk8.dim(`Next: cd ${createdDir} && skild validate .`));
+  } catch (error) {
+    spinner.fail(`Failed to init ${chalk8.red(name)}`);
+    const message = error instanceof SkildError5 ? error.message : error instanceof Error ? error.message : String(error);
+    console.error(chalk8.red(message));
+    process.exitCode = 1;
+  }
 }
 
 // src/index.ts
+import { PLATFORMS } from "@skild/core";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program = new Command();
 program.name("skild").description("The npm for Agent Skills \u2014 Discover, install, manage, and publish AI Agent Skills with ease.").version(version);
-program.command("install <source>").alias("i").description("Install a Skill from a Git URL, degit shorthand, or local directory").option("-t, --target <platform>", "Target platform: claude, codex, copilot", DEFAULT_PLATFORM).option("-l, --local", "Install to project-level directory instead of global").action(async (source, options) => {
-  const platform = isPlatform(options.target) ? options.target : DEFAULT_PLATFORM;
-  await install(source, {
-    target: platform,
-    local: options.local
-  });
-});
-program.command("list").alias("ls").description("List installed Skills").option("-t, --target <platform>", "Target platform: claude, codex, copilot", DEFAULT_PLATFORM).option("-l, --local", "List project-level directory instead of global").action(async (options) => {
-  const platform = isPlatform(options.target) ? options.target : DEFAULT_PLATFORM;
-  await list({
-    target: platform,
-    local: options.local
-  });
+program.command("install <source>").alias("i").description("Install a Skill from a Git URL, degit shorthand, or local directory").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "Install to project-level directory instead of global").option("-f, --force", "Overwrite existing installation").option("--json", "Output JSON").action(async (source, options) => {
+  await install(source, options);
 });
+program.command("list").alias("ls").description("List installed Skills").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "List project-level directory instead of global").option("--json", "Output JSON").action(async (options) => list(options));
+program.command("info <skill>").description("Show installed Skill details").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "Use project-level directory instead of global").option("--json", "Output JSON").action(async (skill, options) => info(skill, options));
+program.command("uninstall <skill>").alias("rm").description("Uninstall a Skill").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "Use project-level directory instead of global").option("-f, --force", "Uninstall even if metadata is missing").action(async (skill, options) => uninstall(skill, options));
+program.command("update [skill]").alias("up").description("Update one or all installed Skills").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "Use project-level directory instead of global").option("--json", "Output JSON").action(async (skill, options) => update(skill, options));
+program.command("validate [target]").alias("v").description("Validate a Skill folder (path) or an installed Skill name").option("-t, --target <platform>", `Target platform: ${PLATFORMS.join(", ")}`, "claude").option("-l, --local", "Use project-level directory instead of global").option("--json", "Output JSON").action(async (target, options) => validate(target, options));
+program.command("init <name>").description("Create a new Skill project").option("--dir <path>", "Target directory (defaults to <name>)").option("--description <text>", "Skill description").option("-f, --force", "Overwrite target directory if it exists").action(async (name, options) => init(name, options));
 program.action(() => {
-  console.log(chalk3.bold("\n\u{1F6E1}\uFE0F skild \u2014 Get your agents skilled.\n"));
+  console.log(chalk9.bold("\n\u{1F6E1}\uFE0F skild \u2014 Get your agents skilled.\n"));
   program.outputHelp();
 });
 var argv = process.argv.slice();

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "skild",
-  "version": "0.0.8",
+  "version": "0.1.1",
   "description": "The npm for Agent Skills — Discover, install, manage, and publish AI Agent Skills with ease.",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
-    "skild": "./dist/index.js"
+    "skild": "dist/index.js"
   },
   "files": [
     "dist",
@@ -35,12 +35,11 @@
   "dependencies": {
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "degit": "^2.8.4",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "@skild/core": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",
-    "bumpp": "^10.3.2",
     "tsup": "^8.0.0",
     "typescript": "^5.3.0"
   },
@@ -51,7 +50,6 @@
     "build": "tsup src/index.ts --format esm --dts --clean",
     "dev": "tsup src/index.ts --format esm --watch",
     "start": "node dist/index.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "release": "pnpm build && bumpp && pnpm publish --no-git-checks"
+    "typecheck": "pnpm -C ../core build && tsc -p tsconfig.json --noEmit"
   }
 }