opencode-skills-collection 1.0.210 → 2.0.0-beta.2

package/dist/skill-pointer/pointer-generator.js

@@ -0,0 +1,69 @@
+import fs from "fs";
+import path from "path";
+import { POINTER_SUFFIX, SKILL_FILENAME, UNCATEGORIZED_CATEGORY } from "../constants/constants.js";
+import { ensureDir, listSubdirectories } from "../utils/fs.utils.js";
+function buildPointerContent(category, skills, libraryPath) {
+    const title = category
+        .replace(/-/g, " ")
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+    const normalizedPath = libraryPath.replace(/\\/g, "/");
+    const skillCount = skills.length;
+    const skillList = skills
+        .map((s) => `- **${s.id}** — ${s.description || s.name}`)
+        .join("\n");
+    return `---
+name: ${category}${POINTER_SUFFIX}
+description: "Pointer to a library of ${skillCount} specialized ${title} skills. Use when working on ${category}-related tasks."
+risk: safe
+---
+
+# ${title} Capability Library 🎯
+
+This is a **pointer skill**. The ${skillCount} specialized ${title} skills are stored in a hidden vault to keep your startup context minimal.
+
+## Available skills in this category
+
+${skillList}
+
+## How to load a skill
+
+1. Identify the skill name above matching your task.
+2. Use \`view_file\` to read its \`SKILL.md\` from the vault:
+   \`${normalizedPath}/<skill-name>/SKILL.md\`
+3. Follow those instructions to complete the request.
+
+**Vault path:** \`${normalizedPath}\`
+
+> Do not guess best practices — always read from the vault first.
+`;
+}
+/**
+ * Scans every category directory in the vault and writes
+ * a lightweight pointer SKILL.md into the active skills directory.
+ *
+ * Each pointer includes the full list of skill names + descriptions
+ * so keyword searches (e.g. "laravel", "wordpress") resolve correctly
+ * via get_available_skills without loading every SKILL.md.
+ */
+export function generatePointers(activeSkillsDir, vaultDir, index = []) {
+    const categoryDirs = listSubdirectories(vaultDir);
+    const byCategory = new Map();
+    for (const entry of index) {
+        const cat = entry.category ?? UNCATEGORIZED_CATEGORY;
+        if (!byCategory.has(cat))
+            byCategory.set(cat, []);
+        byCategory.get(cat).push(entry);
+    }
+    for (const categoryName of categoryDirs) {
+        const categoryVaultPath = path.join(vaultDir, categoryName);
+        const skills = byCategory.get(categoryName) ?? [];
+        if (skills.length === 0) {
+            const subDirs = fs.readdirSync(categoryVaultPath).filter((e) => fs.statSync(path.join(categoryVaultPath, e)).isDirectory());
+            if (subDirs.length === 0)
+                continue;
+        }
+        const pointerDir = path.join(activeSkillsDir, `${categoryName}${POINTER_SUFFIX}`);
+        ensureDir(pointerDir);
+        fs.writeFileSync(path.join(pointerDir, SKILL_FILENAME), buildPointerContent(categoryName, skills, categoryVaultPath), "utf-8");
+    }
+}

package/dist/skill-pointer/vault-installer.d.ts

@@ -0,0 +1,17 @@
+export interface SkillIndexEntry {
+    id: string;
+    category: string;
+    name: string;
+    description: string;
+}
+/**
+ * Loads the pre-built skills_index.json from the project root.
+ * Falls back to a dynamically generated index from SKILL.md frontmatter
+ * when the file is missing, so the plugin always works correctly.
+ */
+export declare function loadSkillsIndex(bundledSkillsPath: string): SkillIndexEntry[];
+/**
+ * Copies every skill folder from bundledSkillsPath directly into
+ * the vault under the appropriate category sub-directory.
+ */
+export declare function installSkillsToVault(bundledSkillsPath: string, vaultDir: string, index: SkillIndexEntry[]): void;

package/dist/skill-pointer/vault-installer.js

@@ -0,0 +1,86 @@
+import fs from "fs";
+import path from "path";
+import { ensureDir } from "../utils/fs.utils.js";
+import { UNCATEGORIZED_CATEGORY } from "../constants/constants.js";
+/**
+ * Extracts a frontmatter field value from a SKILL.md string.
+ * Handles both quoted and unquoted values.
+ */
+function parseFrontmatterField(content, field) {
+    const match = content.match(new RegExp(`^${field}:\\s*["']?([^"'\\n]+)["']?`, "m"));
+    return match ? match[1].trim() : "";
+}
+/**
+ * Derives a category slug from a skill folder name by taking the
+ * first hyphen-separated segment (e.g. "laravel-expert" → "laravel",
+ * "wordpress-core" → "wordpress", "php-pro" → "php").
+ * Falls back to UNCATEGORIZED_CATEGORY for single-word names.
+ */
+function categoryFromFolderName(folderName) {
+    const parts = folderName.split("-");
+    return parts.length > 1 ? parts[0] : UNCATEGORIZED_CATEGORY;
+}
+/**
+ * Builds a SkillIndexEntry[] by scanning every skill folder in
+ * bundledSkillsPath and reading its SKILL.md frontmatter.
+ * This is used as fallback when skills_index.json is absent.
+ */
+function buildIndexFromBundledSkills(bundledSkillsPath) {
+    const index = [];
+    for (const entry of fs.readdirSync(bundledSkillsPath)) {
+        if (entry.startsWith(".") || entry === "skills_index.json" || entry === "README.md")
+            continue;
+        const skillDir = path.join(bundledSkillsPath, entry);
+        if (!fs.statSync(skillDir).isDirectory())
+            continue;
+        const skillMdPath = path.join(skillDir, "SKILL.md");
+        if (!fs.existsSync(skillMdPath))
+            continue;
+        const content = fs.readFileSync(skillMdPath, "utf-8");
+        const name = parseFrontmatterField(content, "name") || entry;
+        const description = parseFrontmatterField(content, "description") || name;
+        const category = parseFrontmatterField(content, "category") || categoryFromFolderName(entry);
+        index.push({ id: entry, category, name, description });
+    }
+    return index;
+}
+/**
+ * Loads the pre-built skills_index.json from the project root.
+ * Falls back to a dynamically generated index from SKILL.md frontmatter
+ * when the file is missing, so the plugin always works correctly.
+ */
+export function loadSkillsIndex(bundledSkillsPath) {
+    const indexPath = path.join(bundledSkillsPath, "..", "skills_index.json");
+    if (fs.existsSync(indexPath)) {
+        try {
+            const raw = fs.readFileSync(indexPath, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            // fall through to dynamic generation
+        }
+    }
+    return buildIndexFromBundledSkills(bundledSkillsPath);
+}
+/**
+ * Copies every skill folder from bundledSkillsPath directly into
+ * the vault under the appropriate category sub-directory.
+ */
+export function installSkillsToVault(bundledSkillsPath, vaultDir, index) {
+    if (!fs.existsSync(bundledSkillsPath))
+        return;
+    const categoryMap = new Map(index.map((e) => [e.id, e.category ?? UNCATEGORIZED_CATEGORY]));
+    for (const entry of fs.readdirSync(bundledSkillsPath)) {
+        if (entry.startsWith(".") ||
+            entry === "skills_index.json" ||
+            entry === "README.md")
+            continue;
+        const srcPath = path.join(bundledSkillsPath, entry);
+        if (!fs.statSync(srcPath).isDirectory())
+            continue;
+        const category = categoryMap.get(entry) ?? UNCATEGORIZED_CATEGORY;
+        const destPath = path.join(vaultDir, category, entry);
+        ensureDir(path.join(vaultDir, category));
+        fs.cpSync(srcPath, destPath, { recursive: true, force: true });
+    }
+}

package/dist/utils/fs.utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ensures a directory exists, creating it recursively if needed.
+ */
+export declare function ensureDir(dirPath: string): void;
+/**
+ * Returns the names of all direct child directories inside a given path.
+ */
+export declare function listSubdirectories(dirPath: string): string[];

package/dist/utils/fs.utils.js

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Ensures a directory exists, creating it recursively if needed.
+ */
+export function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+/**
+ * Returns the names of all direct child directories inside a given path.
+ */
+export function listSubdirectories(dirPath) {
+    if (!fs.existsSync(dirPath))
+        return [];
+    return fs
+        .readdirSync(dirPath)
+        .filter((entry) => {
+        const fullPath = path.join(dirPath, entry);
+        return fs.statSync(fullPath).isDirectory();
+    });
+}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "opencode-skills-collection",
-  "version": "1.0.210",
+  "version": "2.0.0-beta.2",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist",
-    "bundled-skills"
+    "bundled-skills",
+    "skills_index.json"
   ],
   "repository": {
     "type": "git",
@@ -23,20 +24,21 @@
   "keywords": [
     "opencode",
     "opencode-plugin",
-    "antigravity",
     "skills",
+    "skills-collection",
+    "skills-pointer",
     "ai",
     "agent"
   ],
-  "author": "Davide Ladisa <rawsar@gmail.com>",
+  "author": "Davide Ladisa <info@davideladisa.it>",
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "^1.0.0"
+    "@opencode-ai/plugin": "^1.4.0"
   },
   "devDependencies": {
-    "@opencode-ai/sdk": "^1.0.0",
+    "@opencode-ai/sdk": "^1.4.0",
     "@types/bun": "latest",
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.5.2",
     "typescript": "^6.0.2"
   }
 }