skillbox 0.1.1

package/dist/lib/project-root.js

@@ -0,0 +1,25 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+const exists = async (target) => {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const findProjectRoot = async (startDir) => {
+    let current = path.resolve(startDir);
+    while (true) {
+        const gitDir = path.join(current, ".git");
+        if (await exists(gitDir)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return startDir;
+        }
+        current = parent;
+    }
+};

package/dist/lib/projects.js

@@ -0,0 +1,31 @@
+import fs from "node:fs/promises";
+import { skillboxProjectsPath, skillboxRoot } from "./paths.js";
+const emptyProjects = () => ({ version: 1, projects: [] });
+export const loadProjects = async () => {
+    const filePath = skillboxProjectsPath();
+    try {
+        const content = await fs.readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return emptyProjects();
+        }
+        throw error;
+    }
+};
+export const saveProjects = async (index) => {
+    await fs.mkdir(skillboxRoot(), { recursive: true });
+    const json = JSON.stringify(index, null, 2);
+    await fs.writeFile(skillboxProjectsPath(), `${json}\n`, "utf8");
+};
+export const upsertProject = (index, root) => {
+    const existing = index.projects.find((project) => project.root === root);
+    if (existing) {
+        return index;
+    }
+    return { ...index, projects: [...index.projects, { root }] };
+};
+export const findProject = (index, root) => {
+    return index.projects.find((project) => project.root === root);
+};

package/dist/lib/runtime.js

@@ -0,0 +1,24 @@
+import { loadConfig } from "./config.js";
+import { findProjectRoot } from "./project-root.js";
+import { loadProjects, findProject, saveProjects, upsertProject } from "./projects.js";
+import { resolveAgentList } from "./options.js";
+export const resolveRuntime = async (options) => {
+    const projectRoot = await findProjectRoot(process.cwd());
+    const config = await loadConfig();
+    const scope = options.global ? "user" : (config.defaultScope ?? "project");
+    const agentList = resolveAgentList(options.agents, config);
+    return { projectRoot, scope, agentList };
+};
+export const ensureProjectRegistered = async (projectRoot, scope) => {
+    if (scope !== "project") {
+        return undefined;
+    }
+    const projects = await loadProjects();
+    let projectEntry = findProject(projects, projectRoot);
+    if (!projectEntry) {
+        const merged = upsertProject(projects, projectRoot);
+        await saveProjects(merged);
+        projectEntry = findProject(merged, projectRoot);
+    }
+    return projectEntry;
+};

package/dist/lib/skill-parser.js

@@ -0,0 +1,61 @@
+import { hashContent } from "./skill-store.js";
+const frontmatterRegex = /^---\n([\s\S]*?)\n---\n/;
+export const parseSkillMarkdown = (markdown) => {
+    const match = markdown.match(frontmatterRegex);
+    let name;
+    let description;
+    if (match) {
+        const frontmatter = match[1];
+        for (const line of frontmatter.split("\n")) {
+            const [key, ...rest] = line.split(":");
+            if (!key || rest.length === 0) {
+                continue;
+            }
+            const value = rest.join(":").trim();
+            if (key.trim() === "name") {
+                name = value;
+            }
+            if (key.trim() === "description") {
+                description = value;
+            }
+        }
+    }
+    const checksum = hashContent(markdown);
+    return {
+        name,
+        description,
+        markdown,
+        checksum,
+    };
+};
+export const inferNameFromUrl = (url) => {
+    const cleaned = url.split("?")[0].split("#")[0];
+    const parts = cleaned.split("/").filter(Boolean);
+    if (parts.length === 0) {
+        return null;
+    }
+    const last = parts[parts.length - 1];
+    const base = last.toLowerCase();
+    if (base === "skill.md" || base === "skill" || base === "skill.json") {
+        if (parts.length < 2) {
+            return null;
+        }
+        return parts[parts.length - 2];
+    }
+    return last.replace(/\.md$/, "");
+};
+export const buildMetadata = (parsed, source, nameOverride) => {
+    const name = nameOverride ?? parsed.name;
+    if (!name) {
+        throw new Error("Skill metadata requires a name.");
+    }
+    return {
+        name,
+        version: "0.1.0",
+        description: parsed.description,
+        entry: "SKILL.md",
+        source,
+        checksum: parsed.checksum,
+        updatedAt: new Date().toISOString(),
+    };
+};

package/dist/lib/skill-store.js

@@ -0,0 +1,28 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { skillboxSkillsDir } from "./paths.js";
+export const ensureSkillsDir = async () => {
+    await fs.mkdir(skillboxSkillsDir(), { recursive: true });
+};
+export const skillDir = (name) => {
+    return path.join(skillboxSkillsDir(), name);
+};
+export const writeSkillFiles = async (name, skillMarkdown, metadata) => {
+    const targetDir = skillDir(name);
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.writeFile(path.join(targetDir, "SKILL.md"), `${skillMarkdown}\n`, "utf8");
+    await fs.writeFile(path.join(targetDir, "skill.json"), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+};
+export const readSkillMetadata = async (name) => {
+    const targetDir = skillDir(name);
+    const content = await fs.readFile(path.join(targetDir, "skill.json"), "utf8");
+    return JSON.parse(content);
+};
+export const writeSkillMetadata = async (name, metadata) => {
+    const targetDir = skillDir(name);
+    await fs.writeFile(path.join(targetDir, "skill.json"), `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+};
+export const hashContent = (content) => {
+    return crypto.createHash("sha256").update(content).digest("hex");
+};

package/dist/lib/sync.js

@@ -0,0 +1,43 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { skillDir } from "./skill-store.js";
+export const ensureDir = async (dir) => {
+    await fs.mkdir(dir, { recursive: true });
+};
+const copyFiles = async (sourceDir, targetDir) => {
+    const entries = await fs.readdir(sourceDir);
+    for (const entry of entries) {
+        const sourcePath = path.join(sourceDir, entry);
+        const destPath = path.join(targetDir, entry);
+        const stat = await fs.stat(sourcePath);
+        if (stat.isDirectory()) {
+            continue;
+        }
+        await fs.copyFile(sourcePath, destPath);
+    }
+};
+export const copySkillToTargets = async (skillName, targets) => {
+    const sourceDir = skillDir(skillName);
+    const writtenPaths = [];
+    for (const targetRoot of targets) {
+        const targetDir = path.join(targetRoot, skillName);
+        await ensureDir(targetDir);
+        await copyFiles(sourceDir, targetDir);
+        writtenPaths.push(targetDir);
+    }
+    return writtenPaths;
+};
+export const copySkillToInstallPaths = async (skillName, installPaths) => {
+    const sourceDir = skillDir(skillName);
+    for (const installPath of installPaths) {
+        await ensureDir(installPath);
+        await copyFiles(sourceDir, installPath);
+    }
+};
+export const buildTargets = (agent, paths, scope) => {
+    if (scope === "system") {
+        return (paths.system ?? []).map((pathValue) => ({ agent, scope, path: pathValue }));
+    }
+    const list = scope === "user" ? paths.user : paths.project;
+    return list.map((pathValue) => ({ agent, scope, path: pathValue }));
+};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "skillbox",
+  "version": "0.1.1",
+  "description": "Local-first, agent-agnostic skills manager",
+  "license": "MIT",
+  "author": "Christian Anagnostou",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/christiananagnostou/skillbox.git"
+  },
+  "homepage": "https://github.com/christiananagnostou/skillbox",
+  "bugs": {
+    "url": "https://github.com/christiananagnostou/skillbox/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "skillbox": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node-esm src/cli.ts",
+    "prepare": "npm run build",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "lint:ci": "oxlint --deny-warnings",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "prepublishOnly": "npm run lint:ci && npm run format:check && npm run build"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "node-fetch": "^3.3.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.19",
+    "oxfmt": "^0.16.0",
+    "oxlint": "^0.16.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.2"
+  }
+}