@hasna/skills 0.1.13 → 0.1.14

package/dist/index.d.ts

@@ -7,6 +7,8 @@
  * Or use the interactive CLI:
  *   skills
  */
-export { SKILLS, CATEGORIES, getSkill, getSkillsByCategory, searchSkills, getSkillsByTag, getAllTags, type SkillMeta, type Category, } from "./lib/registry.js";
-export { installSkill, installSkills, installSkillForAgent, removeSkillForAgent, getInstalledSkills, removeSkill, skillExists, getSkillPath, getAgentSkillsDir, getAgentSkillPath, AGENT_TARGETS, type InstallResult, type InstallOptions, type AgentTarget, type AgentScope, type AgentInstallOptions, } from "./lib/installer.js";
+export { SKILLS, CATEGORIES, getSkill, getSkillsByCategory, searchSkills, getSkillsByTag, getAllTags, findSimilarSkills, type SkillMeta, type Category, } from "./lib/registry.js";
+export { installSkill, installSkills, installSkillForAgent, removeSkillForAgent, getInstalledSkills, removeSkill, skillExists, getSkillPath, getAgentSkillsDir, getAgentSkillPath, AGENT_TARGETS, type InstallResult, type InstallOptions, type AgentTarget, type AgentScope, type AgentInstallOptions, getInstallMeta, disableSkill, enableSkill, getDisabledSkills, } from "./lib/installer.js";
 export { getSkillDocs, getSkillBestDoc, getSkillRequirements, runSkill, generateEnvExample, generateSkillMd, type SkillDocs, type SkillRequirements, } from "./lib/skillinfo.js";
+export { loadConfig, saveConfig, getConfigPath, type SkillsConfig, type ConfigScope, } from "./lib/config.js";
+export type { SkillResponse, SkillDetailResponse, CategoryResponse, TagResponse, InstallResponse, RemoveResponse, VersionResponse, ExportResponse, ImportResponse, SearchResponse, CategoryInstallResponse, ErrorResponse, } from "./types/api.js";

package/dist/index.js

@@ -1534,8 +1534,23 @@ function getAllTags() {
   }
   return Array.from(tagSet).sort();
 }
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1;i <= m; i++) {
+    for (let j = 1;j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+function findSimilarSkills(query, maxResults = 3) {
+  const q = query.toLowerCase();
+  const scored = SKILLS.map((s) => ({ name: s.name, dist: levenshtein(q, s.name.toLowerCase()) })).filter((s) => s.dist <= Math.max(3, Math.floor(q.length / 2))).sort((a, b) => a.dist - b.dist);
+  return scored.slice(0, maxResults).map((s) => s.name);
+}
 // src/lib/installer.ts
-import { existsSync, cpSync, mkdirSync, writeFileSync, rmSync, readdirSync, statSync, readFileSync } from "fs";
+import { existsSync, cpSync, mkdirSync, writeFileSync, rmSync, readdirSync, statSync, readFileSync, accessSync, constants } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
@@ -1602,6 +1617,7 @@ function installSkill(name, options = {}) {
       }
     });
     updateSkillsIndex(destDir);
+    recordInstall(destDir, name);
     const meta = getSkill(name);
     if (meta?.dependencies && meta.dependencies.length > 0) {
       const installed = getInstalledSkills(targetDir);
@@ -1630,7 +1646,9 @@ function installSkills(names, options = {}) {
 }
 function updateSkillsIndex(skillsDir) {
   const indexPath = join(skillsDir, "index.ts");
-  const skills = readdirSync(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes("."));
+  const meta = loadMeta(skillsDir);
+  const disabledSet = new Set(meta.disabled || []);
+  const skills = readdirSync(skillsDir).filter((f) => f.startsWith("skill-") && !f.includes(".") && !disabledSet.has(f.replace("skill-", "")));
   const exports = skills.map((s) => {
     const name = s.replace("skill-", "").replace(/-/g, "_");
     return `export * as ${name} from './${s}/src/index.js';`;
@@ -1645,6 +1663,74 @@ ${exports}
 `;
   writeFileSync(indexPath, content);
 }
+function getMetaPath(skillsDir) {
+  return join(skillsDir, ".meta.json");
+}
+function loadMeta(skillsDir) {
+  const metaPath = getMetaPath(skillsDir);
+  if (existsSync(metaPath)) {
+    try {
+      return JSON.parse(readFileSync(metaPath, "utf-8"));
+    } catch {}
+  }
+  return { skills: {} };
+}
+function saveMeta(skillsDir, meta) {
+  writeFileSync(getMetaPath(skillsDir), JSON.stringify(meta, null, 2));
+}
+function recordInstall(skillsDir, name) {
+  const meta = loadMeta(skillsDir);
+  const skillName = normalizeSkillName(name);
+  let version = "unknown";
+  try {
+    const pkgPath = join(skillsDir, skillName, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      version = pkg.version || "unknown";
+    }
+  } catch {}
+  meta.skills[name] = { installedAt: new Date().toISOString(), version };
+  saveMeta(skillsDir, meta);
+}
+function recordRemove(skillsDir, name) {
+  const meta = loadMeta(skillsDir);
+  delete meta.skills[name];
+  saveMeta(skillsDir, meta);
+}
+function getInstallMeta(targetDir = process.cwd()) {
+  return loadMeta(join(targetDir, ".skills"));
+}
+function disableSkill(name, targetDir = process.cwd()) {
+  const skillsDir = join(targetDir, ".skills");
+  const skillName = normalizeSkillName(name);
+  if (!existsSync(join(skillsDir, skillName)))
+    return false;
+  const meta = loadMeta(skillsDir);
+  const disabled = new Set(meta.disabled || []);
+  if (disabled.has(name))
+    return false;
+  disabled.add(name);
+  meta.disabled = [...disabled];
+  saveMeta(skillsDir, meta);
+  updateSkillsIndex(skillsDir);
+  return true;
+}
+function enableSkill(name, targetDir = process.cwd()) {
+  const skillsDir = join(targetDir, ".skills");
+  const meta = loadMeta(skillsDir);
+  const disabled = new Set(meta.disabled || []);
+  if (!disabled.has(name))
+    return false;
+  disabled.delete(name);
+  meta.disabled = [...disabled];
+  saveMeta(skillsDir, meta);
+  updateSkillsIndex(skillsDir);
+  return true;
+}
+function getDisabledSkills(targetDir = process.cwd()) {
+  const meta = loadMeta(join(targetDir, ".skills"));
+  return meta.disabled || [];
+}
 function getInstalledSkills(targetDir = process.cwd()) {
   const skillsDir = join(targetDir, ".skills");
   if (!existsSync(skillsDir)) {
@@ -1664,6 +1750,7 @@ function removeSkill(name, targetDir = process.cwd()) {
   }
   rmSync(skillPath, { recursive: true, force: true });
   updateSkillsIndex(skillsDir);
+  recordRemove(skillsDir, name);
   return true;
 }
 var AGENT_TARGETS = ["claude", "codex", "gemini"];
@@ -1696,6 +1783,30 @@ function installSkillForAgent(name, options, generateSkillMd) {
     return { skill: name, success: false, error: `No SKILL.md found and could not generate one for '${name}'` };
   }
   const destDir = getAgentSkillPath(name, agent, scope, projectDir);
+  if (scope === "global") {
+    const agentBaseDir = join(homedir(), `.${agent}`);
+    if (!existsSync(agentBaseDir)) {
+      const agentLabels = {
+        claude: "Claude Code",
+        codex: "Codex CLI",
+        gemini: "Gemini CLI"
+      };
+      return {
+        skill: name,
+        success: false,
+        error: `Agent directory ${agentBaseDir} does not exist. Is ${agentLabels[agent]} installed?`
+      };
+    }
+    try {
+      accessSync(agentBaseDir, constants.W_OK);
+    } catch {
+      return {
+        skill: name,
+        success: false,
+        error: `Agent directory ${agentBaseDir} is not writable. Check permissions.`
+      };
+    }
+  }
   try {
     mkdirSync(destDir, { recursive: true });
     writeFileSync(join(destDir, "SKILL.md"), skillMdContent);
@@ -1998,12 +2109,83 @@ function readIfExists(path) {
   } catch {}
   return null;
 }
+// src/lib/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+var VALID_KEYS = {
+  defaultAgent: ["claude", "codex", "gemini", "all"],
+  defaultScope: ["global", "project"],
+  format: ["compact", "json", "csv"]
+};
+function getConfigPath(scope) {
+  if (scope === "global") {
+    return join3(homedir2(), ".skillsrc");
+  }
+  return join3(process.cwd(), "skills.config.json");
+}
+function readConfigFile(path) {
+  if (!existsSync3(path))
+    return {};
+  try {
+    const raw = readFileSync3(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return {};
+    const config = {};
+    for (const [key, allowed] of Object.entries(VALID_KEYS)) {
+      const val = parsed[key];
+      if (typeof val === "string" && allowed.includes(val)) {
+        config[key] = val;
+      }
+    }
+    return config;
+  } catch {
+    return {};
+  }
+}
+function loadConfig() {
+  const globalConfig = readConfigFile(getConfigPath("global"));
+  const projectConfig = readConfigFile(getConfigPath("project"));
+  return { ...globalConfig, ...projectConfig };
+}
+function saveConfig(key, value, scope = "project") {
+  if (!(key in VALID_KEYS)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: ${Object.keys(VALID_KEYS).join(", ")}`);
+  }
+  const allowed = VALID_KEYS[key];
+  if (!allowed.includes(value)) {
+    throw new Error(`Invalid value '${value}' for ${key}. Allowed: ${allowed.join(", ")}`);
+  }
+  const filePath = getConfigPath(scope);
+  let existing = {};
+  if (existsSync3(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync3(filePath, "utf-8"));
+      if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+        existing = {};
+      }
+    } catch {
+      existing = {};
+    }
+  } else {
+    const dir = dirname2(filePath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  existing[key] = value;
+  writeFileSync2(filePath, JSON.stringify(existing, null, 2) + `
+`);
+}
 export {
   skillExists,
   searchSkills,
+  saveConfig,
   runSkill,
   removeSkillForAgent,
   removeSkill,
+  loadConfig,
   installSkills,
   installSkillForAgent,
   installSkill,
@@ -2015,11 +2197,17 @@ export {
   getSkillBestDoc,
   getSkill,
   getInstalledSkills,
+  getInstallMeta,
+  getDisabledSkills,
+  getConfigPath,
   getAllTags,
   getAgentSkillsDir,
   getAgentSkillPath,
   generateSkillMd,
   generateEnvExample,
+  findSimilarSkills,
+  enableSkill,
+  disableSkill,
   SKILLS,
   CATEGORIES,
   AGENT_TARGETS

package/dist/lib/config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Config file support for Open Skills
+ *
+ * Loads configuration from:
+ *   1. Project-local: ./skills.config.json (highest priority)
+ *   2. Global: ~/.skillsrc (JSON format, lowest priority)
+ *
+ * Values from the project config override global config.
+ */
+export interface SkillsConfig {
+    defaultAgent?: "claude" | "codex" | "gemini" | "all";
+    defaultScope?: "global" | "project";
+    format?: "compact" | "json" | "csv";
+}
+export type ConfigScope = "global" | "project";
+/**
+ * Get the config file path for a given scope
+ */
+export declare function getConfigPath(scope: ConfigScope): string;
+/**
+ * Load merged config: project-local overrides global
+ */
+export declare function loadConfig(): SkillsConfig;
+/**
+ * Save a single config key-value pair to the specified scope
+ */
+export declare function saveConfig(key: string, value: string, scope?: ConfigScope): void;

package/dist/lib/config.test.d.ts

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

package/dist/lib/installer.d.ts

@@ -27,6 +27,30 @@ export declare function installSkill(name: string, options?: InstallOptions): In
  * Install multiple skills
  */
 export declare function installSkills(names: string[], options?: InstallOptions): InstallResult[];
+interface SkillMeta {
+    installedAt: string;
+    version: string;
+}
+interface MetaFile {
+    skills: Record<string, SkillMeta>;
+    disabled?: string[];
+}
+/**
+ * Get installation metadata for installed skills
+ */
+export declare function getInstallMeta(targetDir?: string): MetaFile;
+/**
+ * Disable a skill (exclude from .skills/index.ts without removing files)
+ */
+export declare function disableSkill(name: string, targetDir?: string): boolean;
+/**
+ * Enable a previously disabled skill (re-add to .skills/index.ts)
+ */
+export declare function enableSkill(name: string, targetDir?: string): boolean;
+/**
+ * Get list of disabled skills
+ */
+export declare function getDisabledSkills(targetDir?: string): string[];
 /**
  * Get list of installed skills in a directory
  */
@@ -65,3 +89,4 @@ export declare function installSkillForAgent(name: string, options: AgentInstall
  * Remove a skill from an agent's skill directory
  */
 export declare function removeSkillForAgent(name: string, options: AgentInstallOptions): boolean;
+export {};

package/dist/lib/registry.d.ts

@@ -23,3 +23,7 @@ export declare function getSkillsByTag(tag: string): SkillMeta[];
  * Return all unique tags across every skill, sorted alphabetically.
  */
 export declare function getAllTags(): string[];
+/**
+ * Find skills with names similar to the given query (for "did you mean?" suggestions)
+ */
+export declare function findSimilarSkills(query: string, maxResults?: number): string[];

package/dist/types/api.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared API response types used by both the HTTP server and the dashboard.
+ * Import from "@hasna/skills" to get type-safe API responses.
+ */
+export interface SkillResponse {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    tags: string[];
+    installed: boolean;
+    envVars: string[];
+    envVarsSet: string[];
+    systemDeps: string[];
+    cliCommand: string | null;
+}
+export interface SkillDetailResponse extends SkillResponse {
+    docs: string | null;
+}
+export interface CategoryResponse {
+    name: string;
+    count: number;
+}
+export interface TagResponse {
+    name: string;
+    count: number;
+}
+export interface InstallResponse {
+    skill: string;
+    success: boolean;
+    error?: string;
+    results?: Array<{
+        skill: string;
+        success: boolean;
+        error?: string;
+    }>;
+}
+export interface RemoveResponse {
+    skill: string;
+    success: boolean;
+}
+export interface VersionResponse {
+    version: string;
+    name: string;
+}
+export interface ExportResponse {
+    version: number;
+    skills: string[];
+    timestamp: string;
+}
+export interface ImportResponse {
+    imported: number;
+    total: number;
+    results: Array<{
+        skill: string;
+        success: boolean;
+        error?: string;
+    }>;
+}
+export interface SearchResponse extends SkillResponse {
+}
+export interface CategoryInstallResponse {
+    category: string;
+    count: number;
+    success: boolean;
+    results: Array<{
+        skill: string;
+        success: boolean;
+        error?: string;
+    }>;
+}
+export interface ErrorResponse {
+    error: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/skills",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Skills library for AI coding agents",
   "type": "module",
   "bin": {
@@ -23,9 +23,12 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+    "clean": "rm -rf bin/ dist/",
+    "build": "bun run clean && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test",
     "dev": "bun run ./src/cli/index.tsx",
+    "dev:watch": "bun --watch run ./src/cli/index.tsx",
+    "dev:mcp": "bun --watch run ./src/mcp/index.ts",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build",
     "dashboard:dev": "cd dashboard && bun run dev",

package/skills/skill-academic-journal-matcher/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-academic-journal-matcher");
+}
+
+const program = new Command();
+
+program
+  .name("skill-academic-journal-matcher")
+  .description("Academic Journal Matcher skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/skills/skill-action-item-router/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-action-item-router");
+}
+
+const program = new Command();
+
+program
+  .name("skill-action-item-router")
+  .description("Action Item Router skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/skills/skill-ad-creative-generator/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-ad-creative-generator");
+}
+
+const program = new Command();
+
+program
+  .name("skill-ad-creative-generator")
+  .description("Ad Creative Generator skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/skills/skill-advanced-math/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-advanced-math");
+}
+
+const program = new Command();
+
+program
+  .name("skill-advanced-math")
+  .description("Advanced Math skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/skills/skill-analyze-data/bin/cli.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+
+const program = new Command();
+
+program
+  .name("skill-analyze-data")
+  .description("Data science insights for CSV and JSON")
+  .version("0.1.0");
+
+program
+  .command("run", { isDefault: true })
+  .description("Run the skill")
+  .allowUnknownOption(true)
+  .action(async () => {
+    await import("../src/index.js");
+  });
+
+program.parse();

package/skills/skill-anomaly-investigator/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-anomaly-investigator");
+}
+
+const program = new Command();
+
+program
+  .name("skill-anomaly-investigator")
+  .description("Anomaly Investigator skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/skills/skill-api-test-suite/bin/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { homedir } from "os";
+import { join } from "path";
+
+function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".skill", "skill-api-test-suite");
+}
+
+const program = new Command();
+
+program
+  .name("skill-api-test-suite")
+  .description("Api Test Suite skill")
+  .version("0.1.0");
+
+program
+  .command("run")
+  .description("Run the skill")
+  .option("-o, --output <path>", "Output directory", join(getDataDir(), "output"))
+  .allowUnknownOption(true)
+  .action(async (options, command) => {
+    try {
+      const args = command.args;
+      process.env.DATA_DIR = process.env.DATA_DIR || getDataDir();
+      await import("../src/index.js");
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();