@skild/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peiiii
+
+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,6 @@
+# @skild/core
+
+Headless core for skild: install, validate, list, info, uninstall, update, and init Agent Skills locally.
+
+This package is meant to be consumed by the `skild` CLI and future tooling.
+

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+type SkildErrorCode = 'INVALID_SOURCE' | 'NOT_A_DIRECTORY' | 'EMPTY_INSTALL_DIR' | 'ALREADY_INSTALLED' | 'SKILL_NOT_FOUND' | 'MISSING_METADATA' | 'INVALID_SKILL';
+declare class SkildError extends Error {
+    readonly code: SkildErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(code: SkildErrorCode, message: string, details?: Record<string, unknown>);
+}
+
+declare const PLATFORMS: readonly ["claude", "codex", "copilot"];
+type Platform = (typeof PLATFORMS)[number];
+type InstallScope = 'global' | 'project';
+type SourceType = 'local' | 'github-url' | 'degit-shorthand';
+interface InstallOptions {
+    platform?: Platform;
+    scope?: InstallScope;
+    force?: boolean;
+}
+interface ListOptions {
+    platform?: Platform;
+    scope?: InstallScope;
+}
+interface UpdateOptions {
+    platform?: Platform;
+    scope?: InstallScope;
+    force?: boolean;
+}
+interface SkillFrontmatter {
+    name: string;
+    description: string;
+    version?: string;
+    [key: string]: unknown;
+}
+interface SkillValidationIssue {
+    level: 'error' | 'warning';
+    message: string;
+    path?: string;
+}
+interface SkillValidationResult {
+    ok: boolean;
+    issues: SkillValidationIssue[];
+    frontmatter?: SkillFrontmatter;
+}
+interface InstallRecord {
+    schemaVersion: 1;
+    name: string;
+    platform: Platform;
+    scope: InstallScope;
+    source: string;
+    sourceType: SourceType;
+    installedAt: string;
+    updatedAt?: string;
+    installDir: string;
+    contentHash: string;
+    hasSkillMd: boolean;
+    skill?: {
+        frontmatter?: SkillFrontmatter;
+        validation?: SkillValidationResult;
+    };
+}
+interface LockEntry {
+    name: string;
+    platform: Platform;
+    scope: InstallScope;
+    source: string;
+    sourceType: SourceType;
+    installedAt: string;
+    updatedAt?: string;
+    installDir: string;
+    contentHash: string;
+}
+interface Lockfile {
+    schemaVersion: 1;
+    updatedAt: string;
+    entries: Record<string, LockEntry>;
+}
+interface GlobalConfig {
+    schemaVersion: 1;
+    defaultPlatform: Platform;
+    defaultScope: InstallScope;
+}
+
+declare function loadOrCreateGlobalConfig(): GlobalConfig;
+
+declare function getSkillsDir(platform: Platform, scope: InstallScope): string;
+declare function getSkillInstallDir(platform: Platform, scope: InstallScope, skillName: string): string;
+
+declare function validateSkillDir(skillDir: string): SkillValidationResult;
+
+interface InitOptions {
+    force?: boolean;
+    dir?: string;
+    description?: string;
+}
+declare function initSkill(name: string, options?: InitOptions): string;
+
+interface InstallInput {
+    source: string;
+    nameOverride?: string;
+}
+declare function installSkill(input: InstallInput, options?: InstallOptions): Promise<InstallRecord>;
+interface ListedSkill {
+    name: string;
+    installDir: string;
+    hasSkillMd: boolean;
+    record?: InstallRecord | null;
+}
+declare function listSkills(options?: ListOptions): ListedSkill[];
+declare function getSkillInfo(name: string, options?: ListOptions): InstallRecord;
+declare function validateSkill(nameOrPath: string, options?: {
+    platform?: Platform;
+    scope?: InstallScope;
+}): SkillValidationResult;
+declare function uninstallSkill(name: string, options?: InstallOptions & {
+    allowMissingMetadata?: boolean;
+}): void;
+declare function updateSkill(name?: string, options?: UpdateOptions): Promise<InstallRecord[]>;
+
+export { type GlobalConfig, type InstallOptions, type InstallRecord, type InstallScope, type ListOptions, type Lockfile, PLATFORMS, type Platform, SkildError, type SkillFrontmatter, type SkillValidationIssue, type SkillValidationResult, type UpdateOptions, getSkillInfo, getSkillInstallDir, getSkillsDir, initSkill, installSkill, listSkills, loadOrCreateGlobalConfig, uninstallSkill, updateSkill, validateSkill, validateSkillDir };

package/dist/index.js

@@ -0,0 +1,504 @@
+// src/errors.ts
+var SkildError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/types.ts
+var PLATFORMS = ["claude", "codex", "copilot"];
+
+// src/storage.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/paths.ts
+import os from "os";
+import path from "path";
+import fs from "fs";
+function getHomeDir() {
+  return os.homedir();
+}
+function getProjectDir() {
+  return process.cwd();
+}
+function getSkildGlobalDir() {
+  return path.join(getHomeDir(), ".skild");
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function getSkillsDir(platform, scope) {
+  const base = scope === "project" ? getProjectDir() : getHomeDir();
+  switch (platform) {
+    case "claude":
+      return path.join(base, ".claude", "skills");
+    case "codex":
+      return path.join(base, ".codex", "skills");
+    case "copilot":
+      return path.join(base, ".github", "skills");
+  }
+}
+function getProjectSkildDir() {
+  return path.join(getProjectDir(), ".skild");
+}
+function getProjectLockPath() {
+  return path.join(getProjectSkildDir(), "lock.json");
+}
+function getGlobalConfigPath() {
+  return path.join(getSkildGlobalDir(), "config.json");
+}
+function getGlobalLockPath() {
+  return path.join(getSkildGlobalDir(), "lock.json");
+}
+function getSkillInstallDir(platform, scope, skillName) {
+  return path.join(getSkillsDir(platform, scope), skillName);
+}
+function getSkillMetadataDir(skillInstallDir) {
+  return path.join(skillInstallDir, ".skild");
+}
+function getSkillInstallRecordPath(skillInstallDir) {
+  return path.join(getSkillMetadataDir(skillInstallDir), "install.json");
+}
+
+// src/storage.ts
+function readJsonFile(filePath) {
+  if (!fs2.existsSync(filePath)) return null;
+  return JSON.parse(fs2.readFileSync(filePath, "utf8"));
+}
+function writeJsonFile(filePath, value) {
+  ensureDir(path2.dirname(filePath));
+  fs2.writeFileSync(filePath, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function loadOrCreateGlobalConfig() {
+  const filePath = getGlobalConfigPath();
+  const existing = readJsonFile(filePath);
+  if (existing) return existing;
+  const created = {
+    schemaVersion: 1,
+    defaultPlatform: PLATFORMS[0],
+    defaultScope: "global"
+  };
+  writeJsonFile(filePath, created);
+  return created;
+}
+function loadLockfile(lockPath) {
+  return readJsonFile(lockPath);
+}
+function saveLockfile(lockPath, lockfile) {
+  writeJsonFile(lockPath, lockfile);
+}
+function getLockPath(scope) {
+  return scope === "project" ? getProjectLockPath() : getGlobalLockPath();
+}
+function loadOrCreateLockfile(scope) {
+  const lockPath = getLockPath(scope);
+  const existing = loadLockfile(lockPath);
+  if (existing) return existing;
+  const created = { schemaVersion: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), entries: {} };
+  saveLockfile(lockPath, created);
+  return created;
+}
+function upsertLockEntry(scope, entry) {
+  const lockfile = loadOrCreateLockfile(scope);
+  lockfile.entries[entry.name] = entry;
+  lockfile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveLockfile(getLockPath(scope), lockfile);
+}
+function removeLockEntry(scope, name) {
+  const lockfile = loadOrCreateLockfile(scope);
+  delete lockfile.entries[name];
+  lockfile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveLockfile(getLockPath(scope), lockfile);
+}
+function readInstallRecord(installDir) {
+  const filePath = getSkillInstallRecordPath(installDir);
+  return readJsonFile(filePath);
+}
+function writeInstallRecord(installDir, record) {
+  ensureDir(getSkillMetadataDir(installDir));
+  const filePath = getSkillInstallRecordPath(installDir);
+  writeJsonFile(filePath, record);
+}
+
+// src/skill.ts
+import fs3 from "fs";
+import path3 from "path";
+import yaml from "js-yaml";
+function readSkillMd(skillDir) {
+  const filePath = path3.join(skillDir, "SKILL.md");
+  if (!fs3.existsSync(filePath)) return null;
+  return fs3.readFileSync(filePath, "utf8");
+}
+function parseSkillFrontmatter(skillMdContent) {
+  const trimmed = skillMdContent.trimStart();
+  if (!trimmed.startsWith("---")) return null;
+  const end = trimmed.indexOf("\n---", 3);
+  if (end === -1) return null;
+  const yamlBlock = trimmed.slice(3, end).trim();
+  const parsed = yaml.load(yamlBlock);
+  if (!parsed || typeof parsed !== "object") return null;
+  return parsed;
+}
+function validateSkillDir(skillDir) {
+  const issues = [];
+  const skillMd = readSkillMd(skillDir);
+  if (!skillMd) {
+    issues.push({ level: "error", message: "Missing SKILL.md", path: path3.join(skillDir, "SKILL.md") });
+    return { ok: false, issues };
+  }
+  const frontmatter = parseSkillFrontmatter(skillMd);
+  if (!frontmatter) {
+    issues.push({ level: "error", message: "SKILL.md is missing valid YAML frontmatter (--- ... ---)" });
+    return { ok: false, issues };
+  }
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    issues.push({ level: "error", message: 'Frontmatter "name" is required and must be a string' });
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    issues.push({ level: "error", message: 'Frontmatter "description" is required and must be a string' });
+  }
+  return { ok: issues.every((i) => i.level !== "error"), issues, frontmatter };
+}
+
+// src/init.ts
+import fs4 from "fs";
+import path4 from "path";
+function initSkill(name, options = {}) {
+  const targetDir = path4.resolve(options.dir || name);
+  if (fs4.existsSync(targetDir) && !options.force) {
+    throw new SkildError("ALREADY_INSTALLED", `Target directory already exists: ${targetDir}. Use --force to overwrite.`, { targetDir });
+  }
+  ensureDir(targetDir);
+  ensureDir(path4.join(targetDir, "scripts"));
+  ensureDir(path4.join(targetDir, "references"));
+  ensureDir(path4.join(targetDir, "assets"));
+  const description = options.description || "Describe what this Skill does.";
+  const skillMd = `---
+name: ${name}
+description: ${description}
+---
+
+## Instructions
+
+- Add your workflow instructions here.
+
+## Files
+
+- Put scripts in \`scripts/\`.
+- Put docs in \`references/\`.
+- Put static assets in \`assets/\`.
+`;
+  fs4.writeFileSync(path4.join(targetDir, "SKILL.md"), skillMd, "utf8");
+  const runSh = `#!/usr/bin/env bash
+set -euo pipefail
+
+echo "${name}: run script placeholder" 
+`;
+  fs4.writeFileSync(path4.join(targetDir, "scripts", "run.sh"), runSh, "utf8");
+  try {
+    fs4.chmodSync(path4.join(targetDir, "scripts", "run.sh"), 493);
+  } catch {
+  }
+  return targetDir;
+}
+
+// src/lifecycle.ts
+import path7 from "path";
+import fs6 from "fs";
+import degit from "degit";
+
+// src/source.ts
+import path6 from "path";
+
+// src/fs.ts
+import fs5 from "fs";
+import path5 from "path";
+import crypto from "crypto";
+function pathExists(filePath) {
+  return fs5.existsSync(filePath);
+}
+function isDirectory(filePath) {
+  try {
+    return fs5.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isDirEmpty(dir) {
+  try {
+    const entries = fs5.readdirSync(dir);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+function copyDir(src, dest) {
+  fs5.cpSync(src, dest, { recursive: true });
+}
+function removeDir(dir) {
+  if (fs5.existsSync(dir)) fs5.rmSync(dir, { recursive: true, force: true });
+}
+function sanitizeForPathSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function createTempDir(parentDir, prefix) {
+  ensureDir(parentDir);
+  const safePrefix = sanitizeForPathSegment(prefix || "tmp");
+  const template = path5.join(parentDir, `.skild-${safePrefix}-`);
+  return fs5.mkdtempSync(template);
+}
+function replaceDirAtomic(sourceDir, destDir) {
+  const backupDir = fs5.existsSync(destDir) ? `${destDir}.bak-${Date.now()}` : null;
+  try {
+    if (backupDir) fs5.renameSync(destDir, backupDir);
+    fs5.renameSync(sourceDir, destDir);
+    if (backupDir) removeDir(backupDir);
+  } catch (error) {
+    try {
+      if (!fs5.existsSync(destDir) && backupDir && fs5.existsSync(backupDir)) {
+        fs5.renameSync(backupDir, destDir);
+      }
+    } catch {
+    }
+    try {
+      if (fs5.existsSync(sourceDir)) removeDir(sourceDir);
+    } catch {
+    }
+    throw error;
+  }
+}
+function listFilesRecursive(rootDir) {
+  const results = [];
+  const stack = [rootDir];
+  while (stack.length) {
+    const current = stack.pop();
+    const entries = fs5.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === ".skild") continue;
+      if (entry.name === ".git") continue;
+      const full = path5.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile()) results.push(full);
+    }
+  }
+  results.sort();
+  return results;
+}
+function hashDirectoryContent(rootDir) {
+  const files = listFilesRecursive(rootDir);
+  const h = crypto.createHash("sha256");
+  for (const filePath of files) {
+    const rel = path5.relative(rootDir, filePath);
+    h.update(rel);
+    h.update("\0");
+    h.update(fs5.readFileSync(filePath));
+    h.update("\0");
+  }
+  return h.digest("hex");
+}
+
+// src/source.ts
+function resolveLocalPath(source) {
+  const resolved = path6.resolve(source);
+  return pathExists(resolved) ? resolved : null;
+}
+function classifySource(source) {
+  const local = resolveLocalPath(source);
+  if (local) return "local";
+  if (/^https?:\/\//i.test(source) || source.includes("github.com")) return "github-url";
+  if (/^[^/]+\/[^/]+/.test(source)) return "degit-shorthand";
+  throw new SkildError(
+    "INVALID_SOURCE",
+    `Unsupported source "${source}". Use a Git URL (e.g. https://github.com/owner/repo/tree/<branch>/<subdir>) or degit shorthand (e.g. owner/repo[/subdir][#ref]) or a local directory.`
+  );
+}
+function extractSkillName(source) {
+  const local = resolveLocalPath(source);
+  if (local) return path6.basename(local) || "unknown-skill";
+  const cleaned = source.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;
+}
+
+// src/lifecycle.ts
+async function cloneRemote(degitSrc, targetPath) {
+  const emitter = degit(degitSrc, { force: true, verbose: false });
+  await emitter.clone(targetPath);
+}
+function ensureInstallableLocalDir(sourcePath) {
+  if (!isDirectory(sourcePath)) {
+    throw new SkildError("NOT_A_DIRECTORY", `Source path is not a directory: ${sourcePath}`, { sourcePath });
+  }
+}
+function assertNonEmptyInstall(stagingDir, source) {
+  if (isDirEmpty(stagingDir)) {
+    throw new SkildError(
+      "EMPTY_INSTALL_DIR",
+      `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`,
+      { source }
+    );
+  }
+}
+function resolvePlatformAndScope(options) {
+  const config = loadOrCreateGlobalConfig();
+  return {
+    platform: options.platform || config.defaultPlatform,
+    scope: options.scope || config.defaultScope
+  };
+}
+async function installSkill(input, options = {}) {
+  const { platform, scope } = resolvePlatformAndScope(options);
+  const source = input.source;
+  const sourceType = classifySource(source);
+  const skillsDir = getSkillsDir(platform, scope);
+  ensureDir(skillsDir);
+  const skillName = input.nameOverride || extractSkillName(source);
+  const installDir = getSkillInstallDir(platform, scope, skillName);
+  if (fs6.existsSync(installDir) && !options.force) {
+    throw new SkildError("ALREADY_INSTALLED", `Skill "${skillName}" is already installed at ${installDir}. Use --force, or uninstall first.`, {
+      skillName,
+      installDir
+    });
+  }
+  const tempRoot = createTempDir(skillsDir, skillName);
+  const stagingDir = path7.join(tempRoot, "staging");
+  try {
+    const localPath = resolveLocalPath(source);
+    if (localPath) {
+      ensureInstallableLocalDir(localPath);
+      copyDir(localPath, stagingDir);
+    } else {
+      const degitPath = toDegitPath(source);
+      await cloneRemote(degitPath, stagingDir);
+    }
+    assertNonEmptyInstall(stagingDir, source);
+    replaceDirAtomic(stagingDir, installDir);
+    const contentHash = hashDirectoryContent(installDir);
+    const validation = validateSkillDir(installDir);
+    const record = {
+      schemaVersion: 1,
+      name: skillName,
+      platform,
+      scope,
+      source,
+      sourceType,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      installDir,
+      contentHash,
+      hasSkillMd: fs6.existsSync(path7.join(installDir, "SKILL.md")),
+      skill: {
+        frontmatter: validation.frontmatter,
+        validation
+      }
+    };
+    writeInstallRecord(installDir, record);
+    const lockEntry = {
+      name: record.name,
+      platform: record.platform,
+      scope: record.scope,
+      source: record.source,
+      sourceType: record.sourceType,
+      installedAt: record.installedAt,
+      updatedAt: record.updatedAt,
+      installDir: record.installDir,
+      contentHash: record.contentHash
+    };
+    upsertLockEntry(scope, lockEntry);
+    return record;
+  } finally {
+    removeDir(tempRoot);
+  }
+}
+function listSkills(options = {}) {
+  const { platform, scope } = resolvePlatformAndScope(options);
+  const skillsDir = getSkillsDir(platform, scope);
+  if (!fs6.existsSync(skillsDir)) return [];
+  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory());
+  return entries.map((e) => {
+    const dir = path7.join(skillsDir, e.name);
+    const hasSkillMd = fs6.existsSync(path7.join(dir, "SKILL.md"));
+    const record = readInstallRecord(dir);
+    return { name: e.name, installDir: dir, hasSkillMd, record };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getSkillInfo(name, options = {}) {
+  const { platform, scope } = resolvePlatformAndScope(options);
+  const installDir = getSkillInstallDir(platform, scope, name);
+  if (!fs6.existsSync(installDir)) {
+    throw new SkildError("SKILL_NOT_FOUND", `Skill "${name}" not found in ${getSkillsDir(platform, scope)}`, { name, platform, scope });
+  }
+  const record = readInstallRecord(installDir);
+  if (!record) {
+    throw new SkildError("MISSING_METADATA", `Skill "${name}" is missing install metadata (.skild/install.json).`, { name, installDir });
+  }
+  return record;
+}
+function validateSkill(nameOrPath, options = {}) {
+  const localPath = resolveLocalPath(nameOrPath);
+  const dir = localPath || getSkillInstallDir(options.platform || loadOrCreateGlobalConfig().defaultPlatform, options.scope || loadOrCreateGlobalConfig().defaultScope, nameOrPath);
+  return validateSkillDir(dir);
+}
+function uninstallSkill(name, options = {}) {
+  const { platform, scope } = resolvePlatformAndScope(options);
+  const installDir = getSkillInstallDir(platform, scope, name);
+  if (!fs6.existsSync(installDir)) {
+    throw new SkildError("SKILL_NOT_FOUND", `Skill "${name}" not found in ${getSkillsDir(platform, scope)}`, { name, platform, scope });
+  }
+  const record = readInstallRecord(installDir);
+  if (!record && !options.allowMissingMetadata) {
+    throw new SkildError("MISSING_METADATA", `Skill "${name}" is missing install metadata. Use --force to uninstall anyway.`, { name, installDir });
+  }
+  removeDir(installDir);
+  removeLockEntry(scope, name);
+}
+async function updateSkill(name, options = {}) {
+  const { platform, scope } = resolvePlatformAndScope(options);
+  const targets = name ? [{ name }] : listSkills({ platform, scope }).map((s) => ({ name: s.name }));
+  const results = [];
+  for (const target of targets) {
+    const record = getSkillInfo(target.name, { platform, scope });
+    const updated = await installSkill({ source: record.source, nameOverride: record.name }, { platform, scope, force: true });
+    updated.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeInstallRecord(updated.installDir, updated);
+    results.push(updated);
+  }
+  return results;
+}
+export {
+  PLATFORMS,
+  SkildError,
+  getSkillInfo,
+  getSkillInstallDir,
+  getSkillsDir,
+  initSkill,
+  installSkill,
+  listSkills,
+  loadOrCreateGlobalConfig,
+  uninstallSkill,
+  updateSkill,
+  validateSkill,
+  validateSkillDir
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@skild/core",
+  "version": "0.1.0",
+  "description": "Skild core library (headless) for installing, validating, and managing Agent Skills locally.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "degit": "^2.8.4",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Peiiii/skild.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}