@hasna/skills 0.1.61 → 0.1.63

package/skills/_common/http-client.ts

@@ -1,143 +0,0 @@
-/**
- * Skill HTTP Client
- *
- * Generic HTTP client for calling the remote skill API server
- * Usage: import and call executeSkill() from your skill CLI
- */
-
-// No default endpoint. An unconfigured install has no instance to talk to, and
-// guessing one would send this skill's payload and API key to a host the
-// operator never chose.
-const SKILL_API_URL = process.env.SKILLS_API_URL || process.env.SKILL_API_URL || "";
-
-const MISSING_API_URL_MESSAGE =
-  "Set SKILLS_API_URL to the origin of the Skills instance you run, " +
-  "or run `skills setup --api-url <origin>`";
-
-export interface SkillRequest {
-  skill: string;
-  command?: string;
-  provider?: string;
-  prompt?: string;
-  text?: string;
-  output?: string;
-  [key: string]: unknown;
-}
-
-export interface SkillResponse {
-  success: boolean;
-  output?: string;
-  error?: string;
-  details?: string;
-}
-
-/**
- * Execute a skill on the remote server
- */
-export async function executeSkill(request: SkillRequest): Promise<SkillResponse | Blob> {
-  const { skill, ...params } = request;
-
-  if (!SKILL_API_URL) {
-    return {
-      success: false,
-      error: "Missing SKILLS_API_URL",
-      details: MISSING_API_URL_MESSAGE,
-    };
-  }
-
-  const url = `${SKILL_API_URL}/${skill}/`;
-
-  // Get API key from environment
-  const apiKey = process.env.SKILLS_API_KEY || process.env.SKILL_API_KEY;
-  if (!apiKey) {
-    return {
-      success: false,
-      error: "Missing SKILLS_API_KEY",
-      details: "Set SKILLS_API_KEY environment variable or run `skills auth login`"
-    };
-  }
-
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "User-Agent": `skill-${skill}-cli/1.0`,
-        "X-API-Key": apiKey
-      },
-      body: JSON.stringify(params)
-    });
-
-    if (!response.ok) {
-      const error = await response.json();
-      return {
-        success: false,
-        error: error.error || `HTTP ${response.status}`,
-        details: error.details || error.message
-      };
-    }
-
-    // Check if response is a file (binary)
-    const contentType = response.headers.get("Content-Type") || "";
-    if (contentType.includes("image/") ||
-        contentType.includes("audio/") ||
-        contentType.includes("video/") ||
-        contentType.includes("application/")) {
-      return await response.blob();
-    }
-
-    // Otherwise JSON
-    return await response.json();
-
-  } catch (error) {
-    return {
-      success: false,
-      error: "Network error",
-      details: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-
-/**
- * Save a blob to a file
- */
-export async function saveBlob(blob: Blob, outputPath: string): Promise<void> {
-  const buffer = await blob.arrayBuffer();
-  await Bun.write(outputPath, buffer);
-}
-
-/**
- * Helper to execute a skill and save file if needed
- */
-export async function executeAndSave(request: SkillRequest): Promise<boolean> {
-  if (SKILL_API_URL) console.log(`🔗 Connecting to ${SKILL_API_URL}...`);
-
-  const result = await executeSkill(request);
-
-  if (result instanceof Blob) {
-    // File response
-    if (!request.output) {
-      console.error("❌ Error: No output path specified");
-      return false;
-    }
-
-    await saveBlob(result, request.output);
-    console.log(`✅ Saved to: ${request.output}`);
-    return true;
-  }
-
-  // JSON response
-  if (!result.success) {
-    console.error(`❌ Error: ${result.error}`);
-    if (result.details) {
-      console.error(`   ${result.details}`);
-    }
-    return false;
-  }
-
-  if (result.output) {
-    console.log(result.output);
-  }
-
-  return true;
-}

package/skills/_common/index.ts

@@ -1,26 +0,0 @@
-/**
- * Shared SDK for skills
- *
- * Common utilities used across audio, browse, codefix, convert, deploy,
- * extract, image, transcript, video, and write.
- */
-
-export { checkSkillAuth, isRemoteExecution, requireAuthIfRemote } from './auth';
-export {
-  executeSkill,
-  saveBlob,
-  executeAndSave,
-  type SkillRequest,
-  type SkillResponse,
-} from './http-client';
-export {
-  SkillInstaller,
-  runInstaller,
-  type SkillConfig,
-  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/install.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-echo "Direct per-skill installers are disabled."
-echo "Render skills into native agent folders instead:"
-echo "  skills render"
-exit 1

package/skills/_common/installer.ts

@@ -1,72 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Legacy per-skill installer boundary.
- *
- * Agent-native skill folders are intentionally unmanaged by legacy installers.
- * The root Skills CLI renders skills into those folders instead.
- */
-
-export interface SkillConfig {
-  name: string;
-  description: string;
-  version: string;
-  commands: Array<{
-    name: string;
-    description: string;
-    usage: string;
-    examples: string[];
-  }>;
-  requiredEnvVars?: string[];
-  optionalEnvVars?: string[];
-}
-
-export type AssistantType = "claude" | "codex" | "windsurf" | "cursor";
-
-export class SkillInstaller {
-  private config: SkillConfig;
-
-  constructor(config: SkillConfig, _currentFilePath: string) {
-    this.config = config;
-  }
-
-  async install(assistant: AssistantType): Promise<void> {
-    throw new Error(registrationMessage(this.config.name, assistant));
-  }
-
-  async uninstall(assistant: AssistantType): Promise<void> {
-    throw new Error(
-      `Direct agent skill-folder uninstalls are disabled for ${this.config.name}. ` +
-        "Render skills into native agent folders instead: skills render",
-    );
-  }
-}
-
-export async function runInstaller(
-  config: SkillConfig,
-  currentFilePath: string,
-  args: string[] = process.argv.slice(2),
-): Promise<boolean> {
-  const command = args[0];
-  if (command !== "install" && command !== "uninstall") {
-    return false;
-  }
-
-  const assistant = args.find((arg): arg is AssistantType =>
-    ["claude", "codex", "windsurf", "cursor"].includes(arg),
-  );
-  const installer = new SkillInstaller(config, currentFilePath);
-  if (command === "install") {
-    await installer.install(assistant ?? "claude");
-  } else {
-    await installer.uninstall(assistant ?? "claude");
-  }
-  return true;
-}
-
-function registrationMessage(skillName: string, assistant: AssistantType): string {
-  return (
-    `Direct agent skill-folder installs are disabled for ${skillName}. ` +
-    "Render skills into native agent folders instead: skills render"
-  );
-}

package/skills/_common/skill-install.ts

@@ -1,37 +0,0 @@
-/**
- * Legacy install command boundary for bundled skill packages.
- *
- * Per-skill packages must not write into agent-native skill directories.
- * The root Skills CLI renders skills into agent-native skill directories.
- */
-
-interface SkillMeta {
-  name: string;
-  description: string;
-  version: string;
-  commands: string;
-  requiredEnvVars?: string[];
-}
-
-export async function handleInstallCommand(meta: SkillMeta, args: string[]): Promise<boolean> {
-  const command = args[0];
-  const assistant = args[1];
-
-  if (command !== "install" && command !== "uninstall") {
-    return false;
-  }
-
-  if (!assistant || !["claude", "codex", "windsurf", "cursor"].includes(assistant)) {
-    console.error("Direct per-skill installs are disabled.");
-    console.error("Use: skills render");
-    process.exit(1);
-  }
-
-  if (command === "install") {
-    console.error(`Direct installs for ${meta.name} are disabled.`);
-  } else {
-    console.error(`Direct uninstalls for ${meta.name} are disabled.`);
-  }
-  console.error("Use: skills render");
-  process.exit(1);
-}

package/skills/_common/vision.ts

@@ -1,374 +0,0 @@
-/**
- * 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}`);
-    }
-  }
-}