@zenobius/opencode-skillful 1.2.3 → 1.2.4-next.2

package/dist/index.js

@@ -16152,6 +16152,7 @@ function createInstructionInjector(ctx) {
     await ctx.client.session.prompt({
       path: { id: props.sessionId },
       body: {
+        agent: props.agent,
         noReply: true,
         parts: [{ type: "text", text }]
       }
@@ -17565,6 +17566,17 @@ var SkillFrontmatterSchema = tool.schema.object({
   "allowed-tools": tool.schema.array(tool.schema.string()).optional(),
   metadata: tool.schema.record(tool.schema.string(), tool.schema.string()).optional()
 });
+var stripTrailingPathSeparators = (path) => path.replace(/[\\/]+$/, "");
+var suggestSkillsDirectoryPath = (path) => {
+  const trimmedPath = stripTrailingPathSeparators(path);
+  if (trimmedPath.toLowerCase() === "skill") {
+    return "skills";
+  }
+  if (!/[\\/]skill$/i.test(trimmedPath)) {
+    return null;
+  }
+  return trimmedPath.replace(/skill$/i, () => "skills");
+};
 function createSkillRegistryController() {
   const store = new Map;
   const controller = {
@@ -17602,6 +17614,19 @@ async function createSkillRegistry(config2, logger) {
       const existingBasePaths = config2.basePaths.filter(doesPathExist);
       if (existingBasePaths.length === 0) {
         logger.warn("[OpencodeSkillful] No valid base paths found for skill discovery:", config2.basePaths);
+        const typoCandidates = config2.basePaths.flatMap((basePath) => {
+          const suggestedPath = suggestSkillsDirectoryPath(basePath);
+          if (!suggestedPath) {
+            return [];
+          }
+          if (doesPathExist(suggestedPath)) {
+            return [`${basePath} -> ${suggestedPath}`];
+          }
+          return [];
+        });
+        if (typoCandidates.length > 0) {
+          logger.warn('[OpencodeSkillful] Detected possible "skill" vs "skills" typo in basePaths:', typoCandidates);
+        }
         controller.ready.setStatus("ready");
         return;
       }
@@ -17881,7 +17906,7 @@ import { join as join2, relative as relative3, resolve as resolve2 } from "path"
 import process2 from "process";
 import { existsSync as existsSync22, mkdirSync, readdirSync, writeFileSync } from "fs";
 import { dirname as dirname4, resolve } from "path";
-import process from "process";
+import process3 from "process";
 import { Buffer as Buffer2 } from "buffer";
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
 import { closeSync, createReadStream, createWriteStream, existsSync as existsSync222, fsyncSync, openSync, writeFileSync as writeFileSync2 } from "fs";
@@ -17891,7 +17916,7 @@ import process5 from "process";
 import { pipeline } from "stream/promises";
 import { createGzip } from "zlib";
 import process4 from "process";
-import process3 from "process";
+import process32 from "process";
 import { Buffer as Buffer22 } from "buffer";
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2 } from "crypto";
 import { closeSync as closeSync2, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync4, fsyncSync as fsyncSync2, openSync as openSync2, writeFileSync as writeFileSync4 } from "fs";
@@ -18293,7 +18318,7 @@ async function loadConfig({
   cwd,
   defaultConfig
 }) {
-  const baseDir = cwd || process.cwd();
+  const baseDir = cwd || process3.cwd();
   const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
   const configPaths = [
     `${name}.config`,
@@ -18324,8 +18349,8 @@ async function loadConfig({
   } catch {}
   return defaultConfig;
 }
-var defaultConfigDir = resolve(process.cwd(), "config");
-var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
+var defaultConfigDir = resolve(process3.cwd(), "config");
+var defaultGeneratedDir = resolve(process3.cwd(), "src/generated");
 function getProjectRoot(filePath, options2 = {}) {
   let path3 = process2.cwd();
   while (path3.includes("storage"))
@@ -18374,24 +18399,24 @@ async function loadConfig2() {
 }
 var config2 = await loadConfig2();
 function isBrowserProcess() {
-  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
     return false;
   }
   return typeof window !== "undefined";
 }
 async function isServerProcess() {
-  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
     return true;
   }
   if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
     return true;
   }
-  if (typeof process3 !== "undefined") {
-    const type = process3.type;
+  if (typeof process32 !== "undefined") {
+    const type = process32.type;
     if (type === "renderer" || type === "worker") {
       return false;
     }
-    return !!(process3.versions && (process3.versions.node || process3.versions.bun));
+    return !!(process32.versions && (process32.versions.node || process32.versions.bun));
   }
   return false;
 }
@@ -22917,79 +22942,89 @@ var defaultConfigDir3 = resolve7(process12.cwd(), "config");
 var defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
 
 // src/config.ts
-import { join as join4 } from "path";
-
-// node_modules/env-paths/index.js
-import path3 from "path";
-import os from "os";
-import process13 from "process";
-var homedir3 = os.homedir();
-var tmpdir = os.tmpdir();
-var { env } = process13;
-var macos = (name) => {
-  const library = path3.join(homedir3, "Library");
-  return {
-    data: path3.join(library, "Application Support", name),
-    config: path3.join(library, "Preferences", name),
-    cache: path3.join(library, "Caches", name),
-    log: path3.join(library, "Logs", name),
-    temp: path3.join(tmpdir, name)
-  };
-};
-var windows = (name) => {
-  const appData = env.APPDATA || path3.join(homedir3, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path3.join(homedir3, "AppData", "Local");
-  return {
-    data: path3.join(localAppData, name, "Data"),
-    config: path3.join(appData, name, "Config"),
-    cache: path3.join(localAppData, name, "Cache"),
-    log: path3.join(localAppData, name, "Log"),
-    temp: path3.join(tmpdir, name)
-  };
-};
-var linux = (name) => {
-  const username = path3.basename(homedir3);
-  return {
-    data: path3.join(env.XDG_DATA_HOME || path3.join(homedir3, ".local", "share"), name),
-    config: path3.join(env.XDG_CONFIG_HOME || path3.join(homedir3, ".config"), name),
-    cache: path3.join(env.XDG_CACHE_HOME || path3.join(homedir3, ".cache"), name),
-    log: path3.join(env.XDG_STATE_HOME || path3.join(homedir3, ".local", "state"), name),
-    temp: path3.join(tmpdir, username, name)
-  };
-};
-function envPaths(name, { suffix = "nodejs" } = {}) {
-  if (typeof name !== "string") {
-    throw new TypeError(`Expected a string, got ${typeof name}`);
+import { homedir as homedir3 } from "os";
+import { isAbsolute as isAbsolute2, join as join4, normalize, resolve as resolve8 } from "path";
+function getOpenCodeConfigPaths() {
+  const home = homedir3();
+  const paths = [];
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    paths.push(join4(xdgConfig, "opencode"));
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) {
+      paths.push(join4(localAppData, "opencode"));
+    }
+    paths.push(join4(home, ".config", "opencode"));
+  } else {
+    paths.push(join4(home, ".config", "opencode"));
   }
-  if (suffix) {
-    name += `-${suffix}`;
+  paths.push(join4(home, ".opencode"));
+  return paths;
+}
+function expandTildePath(path3) {
+  if (path3 === "~") {
+    return homedir3();
   }
-  if (process13.platform === "darwin") {
-    return macos(name);
+  if (path3.startsWith("~/")) {
+    return join4(homedir3(), path3.slice(2));
   }
-  if (process13.platform === "win32") {
-    return windows(name);
+  return path3;
+}
+var createPathKey = (absolutePath) => {
+  const normalizedPath = normalize(absolutePath);
+  if (process.platform === "win32") {
+    return normalizedPath.toLowerCase();
   }
-  return linux(name);
+  return normalizedPath;
+};
+function resolveBasePath(basePath, projectDirectory) {
+  const trimmedPath = basePath.trim();
+  if (trimmedPath.length === 0) {
+    return "";
+  }
+  const expandedPath = expandTildePath(trimmedPath);
+  if (isAbsolute2(expandedPath)) {
+    return normalize(expandedPath);
+  }
+  return resolve8(projectDirectory, expandedPath);
 }
-
-// src/config.ts
-var OpenCodePaths = envPaths("opencode", { suffix: "" });
+function normalizeBasePaths(basePaths, projectDirectory) {
+  const uniquePaths = new Set;
+  const normalizedPaths = [];
+  for (const basePath of basePaths) {
+    const normalizedPath = resolveBasePath(basePath, projectDirectory);
+    if (!normalizedPath) {
+      continue;
+    }
+    const key = createPathKey(normalizedPath);
+    if (uniquePaths.has(key)) {
+      continue;
+    }
+    uniquePaths.add(key);
+    normalizedPaths.push(normalizedPath);
+  }
+  return normalizedPaths;
+}
+var defaultSkillBasePaths = getOpenCodeConfigPaths().map((configPath) => join4(configPath, "skills"));
 var options2 = {
   name: "opencode-skillful",
   cwd: "./",
   defaultConfig: {
     debug: false,
-    basePaths: [
-      join4(OpenCodePaths.config, "skills")
-    ],
+    basePaths: defaultSkillBasePaths,
     promptRenderer: "xml",
     modelRenderers: {}
   }
 };
 async function getPluginConfig(ctx) {
   const resolvedConfig = await loadConfig5(options2);
-  resolvedConfig.basePaths.push(join4(ctx.directory, ".opencode", "skills"));
+  const configuredBasePaths = [
+    ...resolvedConfig.basePaths,
+    join4(ctx.directory, ".opencode", "skills")
+  ];
+  resolvedConfig.basePaths = normalizeBasePaths(configuredBasePaths, ctx.directory);
   return resolvedConfig;
 }
 
@@ -23452,7 +23487,8 @@ var SkillsPlugin = async (ctx) => {
           const results = await api2.loadSkill(args.skill_names);
           for await (const skill of results.loaded) {
             await sendPrompt(renderer({ data: skill, type: "Skill" }), {
-              sessionId: toolCtx.sessionID
+              sessionId: toolCtx.sessionID,
+              agent: toolCtx.agent
             });
           }
           return JSON.stringify({
@@ -23502,7 +23538,8 @@ var SkillsPlugin = async (ctx) => {
             throw new Error("Failed to read resource");
           }
           await sendPrompt(renderer({ data: result.injection, type: "SkillResource" }), {
-            sessionId: toolCtx.sessionID
+            sessionId: toolCtx.sessionID,
+            agent: toolCtx.agent
           });
           return JSON.stringify({
             result: "Resource injected successfully",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenobius/opencode-skillful",
-  "version": "1.2.3",
+  "version": "1.2.4-next.2",
   "description": "OpenCode Skills Plugin - Anthropic Agent Skills Specification implementation",
   "type": "module",
   "module": "src/index.ts",
@@ -22,7 +22,6 @@
     "@opencode-ai/plugin": "1.0.85",
     "bunfig": "^0.15.6",
     "dedent": "^1.7.1",
-    "env-paths": "^3.0.0",
     "gray-matter": "^4.0.3",
     "mime": "^4.1.0",
     "ramda": "^0.30.0",