opencode-skills-collection 1.0.195 → 2.0.0-beta.1

package/README.md

@@ -14,42 +14,87 @@
 
 # OpenCode Skills Collection
 
-> An [OpenCode CLI](https://opencode.ai/) plugin that bundles and auto-syncs the [Antigravity Awesome Skills](https://github.com/sickn33/antigravity-awesome-skills) collection — delivered instantly, with zero network latency at startup.
+> An [OpenCode CLI](https://opencode.ai/) plugin that bundles and auto-syncs a universal collection of AI skills —
+> delivered instantly, with zero network latency at startup.
 
-> ⚠️ **Previously published as [`opencode-skills-antigravity`](https://www.npmjs.com/package/opencode-skills-antigravity)** — that package is now deprecated and points to this one.
+> ⚠️ **Previously published
+as [`opencode-skills-antigravity`](https://www.npmjs.com/package/opencode-skills-antigravity)** — that package is now
+> deprecated and points to this one.
 
 ---
 
 ## Overview
 
-**OpenCode Skills Collection** bridges the OpenCode CLI with the Antigravity Awesome Skills repository. Instead of fetching skills on every startup, this plugin ships with a pre-bundled snapshot that gets copied directly to your local machine the moment OpenCode launches.
+**OpenCode Skills Collection** ships a pre-bundled snapshot of 800+ universal skills for the OpenCode CLI.
 
-The result: skills are always fresh (synced hourly via GitHub Actions), always available (even offline), and always instant.
+Instead of loading every skill into the AI context at startup — which would consume ~80k tokens and cause compaction
+loops — the plugin uses a **SkillPointer** architecture: skills are organized into categories inside a hidden vault and
+only loaded into context on demand.
 
 ---
 
 ## How It Works
 
-The plugin operates in two phases:
+The plugin operates in three phases:
 
-**1. Automated upstream sync (CI)**
+**1. Local deployment (startup)**
 
-A GitHub Actions workflow runs every hour, checking the [Antigravity Awesome Skills](https://github.com/sickn33/antigravity-awesome-skills) repository for changes. When new or updated skills are detected, the workflow:
+When OpenCode starts, the plugin copies the pre-bundled skills from the npm package and runs the **SkillPointer pipeline
+**:
 
-- Re-bundles the skill files into `bundled-skills/`
-- Bumps the package version (`patch`)
-- Creates a tagged GitHub Release
-- Publishes the new version to npm
+```
+bundled-skills/ (npm package)
+        │
+        ▼
+~/.config/opencode/skills/          ← OpenCode reads this
+        │
+        └── SkillPointer pipeline
+              │
+              ├─ vault-manager     → moves 800+ raw skills to the vault
+              └─ pointer-generator → writes ~35 lightweight pointer files
+```
+
+**2. On-demand skill loading**
+
+Each pointer file tells the AI: *"there are N skills for this category in the vault — use `list_dir` / `view_file` to
+retrieve them when needed."*
+The full skill content is only injected into context when the AI actually needs it.
 
-**2. Local deployment (startup)**
+---
+
+## Disk Layout
 
-When OpenCode starts, the plugin runs and copies the pre-bundled skills from the npm package to:
+After the first startup, your `~/.config/opencode/` directory looks like this:
 
 ```
-~/.config/opencode/skills/
+~/.config/opencode/
+├── opencode.json
+├── skills/                          ← ~35 pointer folders (active, read by OpenCode)
+│   ├── backend-dev-category-pointer/
+│   │   └── SKILL.md
+│   ├── devops-category-pointer/
+│   │   └── SKILL.md
+│   └── ...
+└── skill-libraries/                 ← vault with all raw skills (hidden from startup context)
+    ├── backend-dev/
+    │   ├── laravel-expert/
+    │   │   └── SKILL.md
+    │   └── wordpress-core/
+    │       └── SKILL.md
+    ├── devops/
+    └── ...
 ```
 
-No network calls, no latency, no failures. If the copy somehow fails, a silent fallback attempts to fetch via `npx antigravity-awesome-skills` in the background.
+---
+
+## Context Usage
+
+|                      | Without SkillPointer | With SkillPointer   |
+|----------------------|----------------------|---------------------|
+| Folders in `skills/` | ~800                 | ~35                 |
+| Tokens at startup    | ~80,000              | ~255                |
+| Skills available     | All injected upfront | On-demand via vault |
+| Compaction loops     | ✗ frequent           | ✓ none              |
 
 ---
 
@@ -65,21 +110,24 @@ Add the plugin to your global OpenCode configuration file at `~/.config/opencode
 }
 ```
 
-That's it. OpenCode will automatically download the npm package on next startup via Bun — no manual `npm install` needed.
+That's it. OpenCode will automatically download the npm package on next startup via Bun — no manual `npm install`
+needed.
 
 ---
 
 ## Usage
 
-Once installed, all bundled skills are available in three ways:
+Once installed, all skills are available in three ways:
 
 **Explicit invocation via CLI:**
+
 ```bash
 opencode run /brainstorming help me plan a new feature
 opencode run /refactor clean up this function
 ```
 
 **Slash commands in the OpenCode chat:**
+
 ```
 /brainstorming
 /refactor
@@ -87,6 +135,7 @@ opencode run /refactor clean up this function
 ```
 
 **Natural language — OpenCode picks the right skill automatically:**
+
 ```
 "Help me brainstorm ideas for a REST API design"
 "Refactor this function to be more readable"
@@ -94,26 +143,6 @@ opencode run /refactor clean up this function
 
 ---
 
-## Project Structure
-
-```
-opencode-skills-collection/
-├── src/
-│   └── index.ts          # Plugin entry point — copies bundled skills on startup
-├── bundled-skills/        # Pre-bundled skills snapshot (auto-updated by CI)
-├── dist/                  # Compiled TypeScript output
-├── .github/
-│   └── workflows/
-│       ├── sync-skills.yml   # Hourly skill sync + auto-publish
-│       ├── release.yml       # Manual version bump + GitHub Release
-│       ├── publish.yml       # npm publish on new release
-│       └── merge-branch.yml  # Keeps develop in sync with main
-├── package.json
-└── tsconfig.json
-```
-
----
-
 ## Development
 
 **Requirements:** Node.js ≥ 20, TypeScript ≥ 5
@@ -128,7 +157,8 @@ npm run build
 # Output is in dist/
 ```
 
-The plugin is written in TypeScript and compiled to ESNext with full type declarations. It targets ES2022 and uses ESM module resolution.
+The plugin is written in TypeScript and compiled to ESNext with full type declarations. It targets ES2022 and uses ESM
+module resolution.
 
 ---
 
@@ -150,12 +180,30 @@ The old `opencode-skills-antigravity` package on npm is deprecated and re-export
 
 ## Contributing
 
-Issues and pull requests are welcome at [github.com/FrancoStino/opencode-skills-collection](https://github.com/FrancoStino/opencode-skills-collection/issues).
+Issues and pull requests are welcome
+at [github.com/FrancoStino/opencode-skills-collection](https://github.com/FrancoStino/opencode-skills-collection/issues).
 
-If you'd like to contribute new skills to the upstream collection, head over to [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills) — they'll be automatically picked up and bundled here within the hour.
+If you'd like to contribute new skills to the collection, open a PR adding a new folder inside `bundled-skills/` — it
+will be automatically picked up on next sync.
 
 ---
 
+## Beta Releases
+
+Beta versions are published from the `develop` branch for testing before official releases.
+
+### Installing Beta Versions
+
+To use the latest beta version, update your `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": [
+    "opencode-skills-collection@beta"
+  ]
+}
+```
+
 ## License
 
-MIT © [Davide Ladisa](https://www.davideladisa.it/)
+[MIT ©](./LICENSE) 

package/bundled-skills/.antigravity-install-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "updatedAt": "2026-04-08T07:23:02.044Z",
+  "updatedAt": "2026-04-08T09:03:21.581Z",
   "entries": [
     "00-andruia-consultant",
     "007",

package/dist/constants/constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared constants used across the plugin.
+ */
+/** Suffix appended to every category pointer folder name. */
+export declare const POINTER_SUFFIX: "-category-pointer";
+/** Expected filename for every skill definition. */
+export declare const SKILL_FILENAME: "SKILL.md";
+/**
+ * Name of the vault directory that stores raw skills, co-located
+ * with the rest of OpenCode config under ~/.config/opencode/
+ */
+export declare const VAULT_DIR_NAME: "skill-libraries";
+/** Fallback category slug for skills not present in skills_index.json. */
+export declare const UNCATEGORIZED_CATEGORY: "uncategorized";

package/dist/constants/constants.js

@@ -0,0 +1,14 @@
+/**
+ * Shared constants used across the plugin.
+ */
+/** Suffix appended to every category pointer folder name. */
+export const POINTER_SUFFIX = "-category-pointer";
+/** Expected filename for every skill definition. */
+export const SKILL_FILENAME = "SKILL.md";
+/**
+ * Name of the vault directory that stores raw skills, co-located
+ * with the rest of OpenCode config under ~/.config/opencode/
+ */
+export const VAULT_DIR_NAME = "skill-libraries";
+/** Fallback category slug for skills not present in skills_index.json. */
+export const UNCATEGORIZED_CATEGORY = "uncategorized";

package/dist/index.d.ts

@@ -1,3 +1,13 @@
 import type { Plugin } from "@opencode-ai/plugin";
+/**
+ * OpenCode Skills Collection plugin.
+ *
+ * On every OpenCode startup:
+ * 1. Copies bundled skills directly into the vault
+ *    (~/.config/opencode/skill-libraries/) organised by category.
+ *    The active skills directory is never used as staging.
+ * 2. Generates lightweight category pointer SKILL.md files in
+ *    ~/.config/opencode/skills/ without touching user custom skills.
+ */
 declare const OpenCodeSkillsCollection: Plugin;
 export default OpenCodeSkillsCollection;

package/dist/index.js

@@ -1,71 +1,35 @@
-import fs from "fs";
-import path from "path";
 import os from "os";
+import path from "path";
 import { fileURLToPath } from "url";
-const LOG_FILE = path.join(os.homedir(), ".config", "opencode", "antigravity-debug.log");
-function log(msg) {
-    const line = `[${new Date().toISOString()}] ${msg}\n`;
-    try {
-        fs.appendFileSync(LOG_FILE, line);
-    }
-    catch (_) { }
-    process.stderr.write(line);
-}
-function copyDirContents(srcDir, destDir) {
-    fs.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-        const srcEntry = path.join(srcDir, entry.name);
-        const destEntry = path.join(destDir, entry.name);
-        if (entry.isDirectory()) {
-            copyDirContents(srcEntry, destEntry);
-        }
-        else {
-            fs.copyFileSync(srcEntry, destEntry);
-        }
-    }
-}
+import { ensureDir } from "./utils/fs.utils.js";
+import { runSkillPointer } from "./skill-pointer/index.js";
+const ACTIVE_SKILLS_PATH_SEGMENTS = [".config", "opencode", "skills"];
 function resolveBundledSkillsPath() {
-    const fromFile = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "bundled-skills");
-    if (fs.existsSync(fromFile))
-        return fromFile;
-    let dir = path.dirname(fileURLToPath(import.meta.url));
-    for (let i = 0; i < 5; i++) {
-        const candidate = path.join(dir, "bundled-skills");
-        if (fs.existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    throw new Error(`bundled-skills not found. import.meta.url=${import.meta.url}`);
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    return path.join(__dirname, "..", "bundled-skills");
+}
+function resolveActiveSkillsDir() {
+    return path.join(os.homedir(), ...ACTIVE_SKILLS_PATH_SEGMENTS);
 }
+/**
+ * OpenCode Skills Collection plugin.
+ *
+ * On every OpenCode startup:
+ * 1. Copies bundled skills directly into the vault
+ *    (~/.config/opencode/skill-libraries/) organised by category.
+ *    The active skills directory is never used as staging.
+ * 2. Generates lightweight category pointer SKILL.md files in
+ *    ~/.config/opencode/skills/ without touching user custom skills.
+ */
 const OpenCodeSkillsCollection = async (_ctx) => {
-    log("plugin start");
     try {
         const bundledSkillsPath = resolveBundledSkillsPath();
-        const skillsPath = path.join(os.homedir(), ".config", "opencode", "skills");
-        log(`bundled-skills path: ${bundledSkillsPath}`);
-        log(`skills dest: ${skillsPath}`);
-        fs.mkdirSync(skillsPath, { recursive: true });
-        const entries = fs.readdirSync(bundledSkillsPath, { withFileTypes: true });
-        log(`entries in bundled-skills: ${entries.length}`);
-        let installed = 0;
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith("."))
-                continue;
-            const src = path.join(bundledSkillsPath, entry.name);
-            if (!fs.existsSync(path.join(src, "SKILL.md")))
-                continue;
-            copyDirContents(src, path.join(skillsPath, entry.name));
-            installed++;
-        }
-        log(`done — installed ${installed} skills`);
+        const activeSkillsDir = resolveActiveSkillsDir();
+        ensureDir(activeSkillsDir);
+        runSkillPointer({ bundledSkillsPath, activeSkillsDir });
     }
-    catch (error) {
-        log(`ERROR: ${String(error)}`);
+    catch {
+        // Plugin errors must never crash OpenCode.
     }
     return {};
 };

package/dist/skill-pointer/index.d.ts

@@ -0,0 +1,23 @@
+export interface SkillPointerOptions {
+    /** Absolute path where OpenCode looks for active skills. */
+    activeSkillsDir: string;
+    /** Absolute path to the bundled-skills snapshot inside the npm package. */
+    bundledSkillsPath: string;
+    /**
+     * Absolute path of the hidden vault where raw skills are stored.
+     * Defaults to ~/.config/opencode/skill-libraries
+     */
+    vaultDir?: string;
+}
+/**
+ * Orchestrates the full SkillPointer pipeline:
+ *
+ * 1. Reads skills_index.json bundled alongside the skills snapshot.
+ * 2. Copies bundled skills directly into the vault, categorised by the index.
+ * 3. Generates pointer SKILL.md files in activeSkillsDir with full skill
+ *    listings so keyword searches (e.g. "laravel") resolve out of the box.
+ *
+ * The activeSkillsDir is never used as a staging area — user custom
+ * skills already present there are never moved or overwritten.
+ */
+export declare function runSkillPointer(options: SkillPointerOptions): void;

package/dist/skill-pointer/index.js

@@ -0,0 +1,28 @@
+import os from "os";
+import path from "path";
+import { VAULT_DIR_NAME } from "../constants/constants.js";
+import { ensureDir } from "../utils/fs.utils.js";
+import { generatePointers } from "./pointer-generator.js";
+import { installSkillsToVault, loadSkillsIndex } from "./vault-installer.js";
+function resolveDefaultVaultDir() {
+    return path.join(os.homedir(), ".config", "opencode", VAULT_DIR_NAME);
+}
+/**
+ * Orchestrates the full SkillPointer pipeline:
+ *
+ * 1. Reads skills_index.json bundled alongside the skills snapshot.
+ * 2. Copies bundled skills directly into the vault, categorised by the index.
+ * 3. Generates pointer SKILL.md files in activeSkillsDir with full skill
+ *    listings so keyword searches (e.g. "laravel") resolve out of the box.
+ *
+ * The activeSkillsDir is never used as a staging area — user custom
+ * skills already present there are never moved or overwritten.
+ */
+export function runSkillPointer(options) {
+    const vaultDir = options.vaultDir ?? resolveDefaultVaultDir();
+    ensureDir(options.activeSkillsDir);
+    ensureDir(vaultDir);
+    const index = loadSkillsIndex(options.bundledSkillsPath);
+    installSkillsToVault(options.bundledSkillsPath, vaultDir, index);
+    generatePointers(options.activeSkillsDir, vaultDir, index);
+}

package/dist/skill-pointer/pointer-generator.d.ts

@@ -0,0 +1,10 @@
+import type { SkillIndexEntry } from "./vault-installer.js";
+/**
+ * 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 declare function generatePointers(activeSkillsDir: string, vaultDir: string, index?: SkillIndexEntry[]): void;

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,6 +1,6 @@
 {
   "name": "opencode-skills-collection",
-  "version": "1.0.195",
+  "version": "2.0.0-beta.1",
   "description": "OpenCode CLI plugin that automatically downloads and keeps skills up to date.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,20 +23,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"
   }
 }