@hasna/skills 0.1.14 → 0.1.16

package/dist/lib/config.d.ts

@@ -3,7 +3,8 @@
  *
  * Loads configuration from:
  *   1. Project-local: ./skills.config.json (highest priority)
- *   2. Global: ~/.skillsrc (JSON format, lowest priority)
+ *   2. Global: ~/.hasna/skills/config.json (JSON format, lowest priority)
+ *      (backward compat: also checks ~/.skillsrc)
  *
  * Values from the project config override global config.
  */
@@ -13,6 +14,12 @@ export interface SkillsConfig {
     format?: "compact" | "json" | "csv";
 }
 export type ConfigScope = "global" | "project";
+/**
+ * Get the data directory for skills global config/data.
+ * New default: ~/.hasna/skills/
+ * Auto-migrates from ~/.skillsrc if the new config doesn't exist yet.
+ */
+export declare function getDataDir(): string;
 /**
  * Get the config file path for a given scope
  */

package/dist/lib/installer.d.ts

@@ -59,9 +59,11 @@ export declare function getInstalledSkills(targetDir?: string): string[];
  * Remove an installed skill
  */
 export declare function removeSkill(name: string, targetDir?: string): boolean;
-export type AgentTarget = "claude" | "codex" | "gemini";
+export type AgentTarget = "claude" | "codex" | "gemini" | "pi" | "opencode";
 export type AgentScope = "global" | "project";
 export declare const AGENT_TARGETS: AgentTarget[];
+/** Human-readable labels for each agent */
+export declare const AGENT_LABELS: Record<AgentTarget, string>;
 /**
  * Resolve an agent argument ("all" or a specific agent name) to a list of AgentTarget values.
  * Throws if the agent name is not recognized.
@@ -73,7 +75,14 @@ export interface AgentInstallOptions {
     projectDir?: string;
 }
 /**
- * Get the skills directory for a given agent and scope
+ * Get the skills directory for a given agent and scope.
+ *
+ * Agent config dir conventions:
+ *   claude  — ~/.claude/skills/          | .claude/skills/
+ *   codex   — ~/.codex/skills/           | .codex/skills/
+ *   gemini  — ~/.gemini/skills/          | .gemini/skills/
+ *   pi      — ~/.pi/agent/skills/        | .pi/skills/
+ *   opencode — ~/.opencode/skills/       | .opencode/skills/
  */
 export declare function getAgentSkillsDir(agent: AgentTarget, scope?: AgentScope, projectDir?: string): string;
 /**

package/dist/lib/registry.d.ts

@@ -8,10 +8,23 @@ export interface SkillMeta {
     category: string;
     tags: string[];
     dependencies?: string[];
+    source?: "official" | "custom";
 }
 export declare const CATEGORIES: readonly ["Development Tools", "Business & Marketing", "Productivity & Organization", "Project Management", "Content Generation", "Finance & Compliance", "Data & Analysis", "Media Processing", "Design & Branding", "Web & Browser", "Research & Writing", "Science & Academic", "Education & Learning", "Communication", "Health & Wellness", "Travel & Lifestyle", "Event Management"];
 export type Category = (typeof CATEGORIES)[number];
 export declare const SKILLS: SkillMeta[];
+/**
+ * Load the full registry: official skills merged with custom skills from:
+ * - ~/.hasna/skills/custom/ (global custom, new path)
+ * - ~/.skills/ (global custom, legacy path)
+ * - ./.custom-skills/ (project-level custom, relative to cwd)
+ *
+ * Custom skills with the same name as official skills take precedence.
+ * Results are cached for 5 seconds.
+ */
+export declare function loadRegistry(cwd?: string): SkillMeta[];
+/** Invalidate the registry cache (e.g. after installing a custom skill). */
+export declare function clearRegistryCache(): void;
 export declare function getSkillsByCategory(category: Category): SkillMeta[];
 export declare function searchSkills(query: string): SkillMeta[];
 export declare function getSkill(name: string): SkillMeta | undefined;

package/dist/lib/scheduler.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Skill scheduler — cron-based scheduling for skills
+ *
+ * Schedules are stored in .skills/schedules.json in the project directory.
+ * Each schedule entry defines a skill to run on a cron expression.
+ *
+ * Cron format: standard 5-field (minute hour dom month dow)
+ * e.g. "0 9 * * *" = every day at 9am
+ */
+export interface SkillSchedule {
+    id: string;
+    name: string;
+    skill: string;
+    cron: string;
+    args?: string[];
+    enabled: boolean;
+    createdAt: string;
+    lastRun?: string;
+    lastRunStatus?: "success" | "error";
+    nextRun?: string;
+}
+/** Validate a 5-field cron expression (basic syntax check). */
+export declare function validateCron(expr: string): {
+    valid: boolean;
+    error?: string;
+};
+/** Compute the next run time for a cron expression relative to a given date. */
+export declare function getNextRun(cron: string, from?: Date): Date | null;
+/** Add a new schedule. Returns the created schedule. */
+export declare function addSchedule(skill: string, cron: string, options?: {
+    name?: string;
+    args?: string[];
+    targetDir?: string;
+}): {
+    schedule: SkillSchedule | null;
+    error?: string;
+};
+/** List all schedules. */
+export declare function listSchedules(targetDir?: string): SkillSchedule[];
+/** Remove a schedule by id or name. Returns true if removed. */
+export declare function removeSchedule(idOrName: string, targetDir?: string): boolean;
+/** Enable or disable a schedule by id or name. */
+export declare function setScheduleEnabled(idOrName: string, enabled: boolean, targetDir?: string): boolean;
+/** Get all schedules that are due now (nextRun <= now and enabled). */
+export declare function getDueSchedules(targetDir?: string): SkillSchedule[];
+/** Mark a schedule as having just run. Updates lastRun and nextRun. */
+export declare function recordScheduleRun(id: string, status: "success" | "error", targetDir?: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/skills",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Skills library for AI coding agents",
   "type": "module",
   "bin": {
@@ -60,6 +60,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "@hasna/cloud": "^0.1.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",

package/skills/_common/index.ts

@@ -21,3 +21,7 @@ export {
   type AssistantType,
 } from './installer';
 export { handleInstallCommand } from './skill-install';
+
+// Vision client — multi-provider (anthropic/openai/xai/gemini)
+// import { analyzeImage, detectProvider } from './vision.js'
+export * from './vision.js';

package/skills/_common/vision.ts

@@ -0,0 +1,374 @@
+/**
+ * Unified vision client for AI providers.
+ * Follows @hasna/connectors pattern — auto-detects from env vars.
+ * Providers: anthropic, openai, xai, gemini
+ *
+ * Uses built-in fetch only — no external SDK dependencies.
+ */
+
+export type VisionProvider = "anthropic" | "openai" | "xai" | "gemini";
+
+export interface VisionOptions {
+  provider?: VisionProvider;
+  model?: string;
+  maxTokens?: number;
+  systemPrompt?: string;
+  jsonMode?: boolean; // wrap prompt to request JSON response
+}
+
+export interface VisionResult {
+  text: string;
+  provider: VisionProvider;
+  model: string;
+  inputTokens?: number;
+  outputTokens?: number;
+}
+
+// Default models per provider (vision-capable)
+export const DEFAULT_MODELS: Record<VisionProvider, string> = {
+  anthropic: "claude-sonnet-4-6",
+  openai: "gpt-4o",
+  xai: "grok-2-vision-1212",
+  gemini: "gemini-2.0-flash",
+};
+
+// API key env vars per provider
+export const API_KEY_VARS: Record<VisionProvider, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  xai: "XAI_API_KEY",
+  gemini: "GEMINI_API_KEY",
+};
+
+// Base URLs
+const BASE_URLS: Record<VisionProvider, string> = {
+  anthropic: "https://api.anthropic.com/v1/messages",
+  openai: "https://api.openai.com/v1/chat/completions",
+  xai: "https://api.x.ai/v1/chat/completions",
+  gemini: "https://generativelanguage.googleapis.com/v1beta/models",
+};
+
+/**
+ * Auto-detect provider from env vars.
+ * Priority: ANTHROPIC_API_KEY → OPENAI_API_KEY → XAI_API_KEY → GEMINI_API_KEY
+ */
+export function detectProvider(): VisionProvider | null {
+  const order: VisionProvider[] = ["anthropic", "openai", "xai", "gemini"];
+  for (const provider of order) {
+    if (process.env[API_KEY_VARS[provider]]) {
+      return provider;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get API key for a provider. Throws if not set.
+ */
+export function getApiKey(provider: VisionProvider): string {
+  const key = process.env[API_KEY_VARS[provider]];
+  if (!key) {
+    throw new Error(
+      `${API_KEY_VARS[provider]} is not set. Run: connectors setup ${provider}`
+    );
+  }
+  return key;
+}
+
+/**
+ * Strip markdown code fences and JSON.parse.
+ * Throws with raw text on failure.
+ */
+export function parseJsonResponse(text: string): unknown {
+  let str = text.trim();
+  if (str.startsWith("```")) {
+    str = str
+      .replace(/^```(?:json)?\n?/, "")
+      .replace(/\n?```$/, "")
+      .trim();
+  }
+  try {
+    return JSON.parse(str);
+  } catch {
+    throw new Error(
+      `Failed to parse response as JSON.\nRaw response:\n${text}`
+    );
+  }
+}
+
+/**
+ * Returns all providers that have an API key set.
+ */
+export function listAvailableProviders(): VisionProvider[] {
+  return (["anthropic", "openai", "xai", "gemini"] as VisionProvider[]).filter(
+    (p) => !!process.env[API_KEY_VARS[p]]
+  );
+}
+
+/**
+ * Returns availability status for all providers.
+ */
+export function getProviderInfo(): Record<
+  VisionProvider,
+  { available: boolean; model: string; keyVar: string }
+> {
+  return {
+    anthropic: {
+      available: !!process.env[API_KEY_VARS.anthropic],
+      model: DEFAULT_MODELS.anthropic,
+      keyVar: API_KEY_VARS.anthropic,
+    },
+    openai: {
+      available: !!process.env[API_KEY_VARS.openai],
+      model: DEFAULT_MODELS.openai,
+      keyVar: API_KEY_VARS.openai,
+    },
+    xai: {
+      available: !!process.env[API_KEY_VARS.xai],
+      model: DEFAULT_MODELS.xai,
+      keyVar: API_KEY_VARS.xai,
+    },
+    gemini: {
+      available: !!process.env[API_KEY_VARS.gemini],
+      model: DEFAULT_MODELS.gemini,
+      keyVar: API_KEY_VARS.gemini,
+    },
+  };
+}
+
+// ============================================================================
+// Provider implementations
+// ============================================================================
+
+async function analyzeWithAnthropic(
+  imageBase64: string,
+  mediaType: string,
+  prompt: string,
+  model: string,
+  options: VisionOptions
+): Promise<VisionResult> {
+  const apiKey = getApiKey("anthropic");
+  const body: Record<string, unknown> = {
+    model,
+    max_tokens: options.maxTokens ?? 1024,
+    messages: [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image",
+            source: { type: "base64", media_type: mediaType, data: imageBase64 },
+          },
+          { type: "text", text: prompt },
+        ],
+      },
+    ],
+  };
+  if (options.systemPrompt) {
+    body.system = options.systemPrompt;
+  }
+
+  const response = await fetch(BASE_URLS.anthropic, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${err}`);
+  }
+
+  const data = (await response.json()) as {
+    content: Array<{ type: string; text: string }>;
+    usage: { input_tokens: number; output_tokens: number };
+  };
+
+  return {
+    text: data.content[0].text,
+    provider: "anthropic",
+    model,
+    inputTokens: data.usage?.input_tokens,
+    outputTokens: data.usage?.output_tokens,
+  };
+}
+
+async function analyzeWithOpenAICompat(
+  provider: "openai" | "xai",
+  imageBase64: string,
+  mediaType: string,
+  prompt: string,
+  model: string,
+  options: VisionOptions
+): Promise<VisionResult> {
+  const apiKey = getApiKey(provider);
+  const messages: unknown[] = [];
+
+  if (options.systemPrompt) {
+    messages.push({ role: "system", content: options.systemPrompt });
+  }
+
+  messages.push({
+    role: "user",
+    content: [
+      {
+        type: "image_url",
+        image_url: {
+          url: `data:${mediaType};base64,${imageBase64}`,
+          detail: "high",
+        },
+      },
+      { type: "text", text: prompt },
+    ],
+  });
+
+  const body = {
+    model,
+    max_tokens: options.maxTokens ?? 1024,
+    messages,
+  };
+
+  const response = await fetch(BASE_URLS[provider], {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(
+      `${provider.toUpperCase()} API error ${response.status}: ${err}`
+    );
+  }
+
+  const data = (await response.json()) as {
+    choices: Array<{ message: { content: string } }>;
+    usage: { prompt_tokens: number; completion_tokens: number };
+  };
+
+  return {
+    text: data.choices[0].message.content,
+    provider,
+    model,
+    inputTokens: data.usage?.prompt_tokens,
+    outputTokens: data.usage?.completion_tokens,
+  };
+}
+
+async function analyzeWithGemini(
+  imageBase64: string,
+  mediaType: string,
+  prompt: string,
+  model: string,
+  options: VisionOptions
+): Promise<VisionResult> {
+  const apiKey = getApiKey("gemini");
+  const url = `${BASE_URLS.gemini}/${model}:generateContent?key=${apiKey}`;
+
+  const body: Record<string, unknown> = {
+    contents: [
+      {
+        parts: [
+          { inlineData: { mimeType: mediaType, data: imageBase64 } },
+          { text: prompt },
+        ],
+      },
+    ],
+    generationConfig: {
+      maxOutputTokens: options.maxTokens ?? 1024,
+      ...(options.jsonMode ? { responseMimeType: "application/json" } : {}),
+    },
+  };
+
+  if (options.systemPrompt) {
+    body.systemInstruction = { parts: [{ text: options.systemPrompt }] };
+  }
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`Gemini API error ${response.status}: ${err}`);
+  }
+
+  const data = (await response.json()) as {
+    candidates: Array<{
+      content: { parts: Array<{ text: string }> };
+    }>;
+    usageMetadata?: { promptTokenCount: number; candidatesTokenCount: number };
+  };
+
+  return {
+    text: data.candidates[0].content.parts[0].text,
+    provider: "gemini",
+    model,
+    inputTokens: data.usageMetadata?.promptTokenCount,
+    outputTokens: data.usageMetadata?.candidatesTokenCount,
+  };
+}
+
+// ============================================================================
+// Main entry point
+// ============================================================================
+
+/**
+ * Analyze an image with a vision-capable model.
+ * Auto-detects provider from env vars unless options.provider is specified.
+ */
+export async function analyzeImage(
+  imageBase64: string,
+  mediaType: string,
+  prompt: string,
+  options: VisionOptions = {}
+): Promise<VisionResult> {
+  const provider = options.provider ?? detectProvider();
+  if (!provider) {
+    throw new Error(
+      "No AI provider API key found. Set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY, GEMINI_API_KEY"
+    );
+  }
+
+  const model = options.model ?? DEFAULT_MODELS[provider];
+  const jsonPrompt =
+    options.jsonMode
+      ? `${prompt}\n\nIMPORTANT: Respond ONLY with valid JSON. No markdown, no code fences, no commentary.`
+      : prompt;
+
+  switch (provider) {
+    case "anthropic":
+      return analyzeWithAnthropic(
+        imageBase64,
+        mediaType,
+        jsonPrompt,
+        model,
+        options
+      );
+    case "openai":
+    case "xai":
+      return analyzeWithOpenAICompat(
+        provider,
+        imageBase64,
+        mediaType,
+        jsonPrompt,
+        model,
+        options
+      );
+    case "gemini":
+      return analyzeWithGemini(imageBase64, mediaType, jsonPrompt, model, options);
+    default: {
+      const _exhaustive: never = provider;
+      throw new Error(`Unknown provider: ${_exhaustive}`);
+    }
+  }
+}

package/skills/skill-colorextract/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: colorextract
+description: Extract color palettes from screenshots and images using Claude Vision. Outputs open-styles-compatible profiles.
+---
+
+# Color Extract Skill
+
+Analyze any screenshot or image and extract a complete color palette — hex values, usage context, and an open-styles compatible profile.
+
+## Usage
+
+```bash
+# Extract from local screenshot
+skill-colorextract extract --image ./screenshot.png
+
+# Extract from image URL
+skill-colorextract extract --image https://example.com/screenshot.png
+
+# Output as open-styles profile JSON
+skill-colorextract extract --image ./screenshot.png --format profile
+
+# Save result to file
+skill-colorextract extract --image ./screenshot.png --output ./colors.json
+```
+
+## Environment Variables
+
+- `ANTHROPIC_API_KEY` — required for Claude Vision analysis
+
+## Output
+
+Returns a JSON object with:
+- `colors`: all extracted colors with hex, name, usage context, frequency estimate
+- `palette`: categorized palette (primary, secondary, accent, neutral, background, text)
+- `openStylesProfile`: ready-to-import open-styles profile

package/skills/skill-colorextract/bun.lock

@@ -0,0 +1,102 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "skill-colorextract",
+      "dependencies": {
+        "@anthropic-ai/sdk": "^0.39.0",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+    },
+  },
+  "packages": {
+    "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.39.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-eMyDIPRZbt1CCLErRCi3exlAvNkBtRe+kW5vvJyef93PmNr/clstYgHhtvmkxN82nlKgzyGPCyGxrm0JQ1ZIdg=="],
+
+    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
+
+    "@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
+
+    "@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
+
+    "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
+
+    "agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
+
+    "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
+
+    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
+
+    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
+
+    "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
+
+    "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
+
+    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
+
+    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+    "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
+
+    "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
+
+    "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
+
+    "form-data": ["form-data@4.0.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="],
+
+    "form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
+
+    "formdata-node": ["formdata-node@4.4.1", "", { "dependencies": { "node-domexception": "1.0.0", "web-streams-polyfill": "4.0.0-beta.3" } }, "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ=="],
+
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
+
+    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
+
+    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
+
+    "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
+
+    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
+
+    "humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
+
+    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
+
+    "mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+
+    "mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="],
+
+    "node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
+
+    "tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
+
+    "undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
+
+    "web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
+
+    "webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
+
+    "whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
+
+    "@types/node-fetch/@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
+
+    "bun-types/@types/node": ["@types/node@25.5.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw=="],
+
+    "@types/node-fetch/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+
+    "bun-types/@types/node/undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+  }
+}

package/skills/skill-colorextract/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "skill-colorextract",
+  "version": "1.0.0",
+  "description": "Extract color palettes from screenshots and images using AI Vision (anthropic/openai/xai/gemini)",
+  "main": "src/index.ts",
+  "type": "module",
+  "bin": { "skill-colorextract": "src/index.ts" },
+  "scripts": { "start": "bun run src/index.ts" },
+  "keywords": ["colors", "palette", "design", "vision", "screenshot", "extract"],
+  "license": "Apache-2.0",
+  "dependencies": {},
+  "devDependencies": { "@types/bun": "latest" }
+}