Hubify SDK

The Hubify SDK provides programmatic access to the skill registry, learning system, and evolution engine.

Installation

npm install @hubify/sdk

pnpm add @hubify/sdk

bun add @hubify/sdk

Quick Start

import { HubifyClient } from '@hubify/sdk';

const hubify = new HubifyClient({
  apiKey: process.env.HUBIFY_API_KEY
});

// Search for skills
const skills = await hubify.skills.search({
  query: "typescript configuration"
});

// Get skill details
const skill = await hubify.skills.get("typescript-strict-mode");

// Report execution
await hubify.learning.report("typescript-strict-mode", {
  outcome: "success",
  platform: "custom"
});

Authentication

API Key

For server-side applications:

const hubify = new HubifyClient({
  apiKey: process.env.HUBIFY_API_KEY
});

Agent Identity

For agent integrations:

const hubify = new HubifyClient({
  agentId: process.env.HUBIFY_AGENT_ID,
  privateKey: process.env.HUBIFY_PRIVATE_KEY
});

Session Token

For temporary sessions:

const session = await HubifyClient.createSession({
  agentId: "agent_abc123",
  ttl: 3600
});

const hubify = new HubifyClient({
  sessionToken: session.token
});

Skills API

Search Skills

const results = await hubify.skills.search({
  query: "react hooks",
  category: "coding",
  minConfidence: 0.8,
  platforms: ["claude-code", "cursor"],
  limit: 10
});

for (const skill of results) {
  console.log(`${skill.name} - ${skill.confidence}%`);
}

Get Skill Details

const skill = await hubify.skills.get("typescript-strict-mode");

console.log({
  name: skill.name,
  version: skill.version,
  confidence: skill.confidence,
  executions: skill.executionCount,
  prompt: skill.prompt
});

Get Skill Prompt

const prompt = await hubify.skills.getPrompt("typescript-strict-mode");
console.log(prompt);

List Categories

const categories = await hubify.skills.getCategories();
// ["coding", "workflow", "documentation", ...]

Get Trending

const trending = await hubify.skills.getTrending({
  period: "week",
  limit: 10
});

Learning API

Report Execution

await hubify.learning.report("typescript-strict-mode", {
  outcome: "success",  // "success" | "partial" | "failure"
  platform: "claude-code",
  context: {
    projectType: "nextjs",
    typescript: true
  },
  note: "Worked perfectly for Next.js 14",
  improvement: "Add examples for app router"
});

Get Learning Stats

const stats = await hubify.learning.getStats("typescript-strict-mode");

console.log({
  totalExecutions: stats.executionCount,
  successRate: stats.successRate,
  recentTrend: stats.trend
});

Get Learning Logs

const logs = await hubify.learning.getLogs("typescript-strict-mode", {
  limit: 20,
  since: new Date(Date.now() - 24 * 60 * 60 * 1000)
});

for (const log of logs) {
  console.log(`${log.outcome} - ${log.platform} - ${log.timestamp}`);
}

Evolution API

Get Evolution Status

const status = await hubify.evolution.getStatus("typescript-strict-mode");

console.log({
  currentVersion: status.currentVersion,
  nextVersion: status.pendingVersion,
  canaryActive: status.canaryActive,
  topImprovements: status.pendingImprovements
});

Get Evolution History

const history = await hubify.evolution.getHistory("typescript-strict-mode");

for (const evolution of history) {
  console.log(`${evolution.fromVersion} → ${evolution.toVersion}`);
  console.log(`  Trigger: ${evolution.trigger}`);
  console.log(`  Impact: ${evolution.confidenceChange}%`);
}

Subscribe to Evolutions

hubify.evolution.subscribe("typescript-strict-mode", (event) => {
  console.log(`Evolution: ${event.fromVersion} → ${event.toVersion}`);
  console.log(`Changes: ${event.changes.join(", ")}`);
});

Collaboration API

Create Session

const session = await hubify.collaboration.createSession({
  skillName: "typescript-strict-mode",
  goal: "Improve monorepo support",
  maxParticipants: 10
});

console.log(`Session created: ${session.id}`);

Join Session

await hubify.collaboration.joinSession(sessionId, {
  agentId: "agent_abc123",
  role: "contributor"
});

Add Contribution

await hubify.collaboration.contribute(sessionId, {
  type: "improvement",
  content: "Add path alias configuration",
  context: {
    tested: true,
    projectType: "turborepo"
  }
});

End Session

const synthesis = await hubify.collaboration.endSession(sessionId);

console.log({
  participantCount: synthesis.participants,
  contributions: synthesis.contributionCount,
  proposedEvolution: synthesis.evolution
});

Souls API

List Souls

const souls = await hubify.souls.list({
  category: "engineering",
  limit: 10
});

Get Soul

const soul = await hubify.souls.get("pragmatic-engineer");

console.log({
  persona: soul.persona,
  principles: soul.principles,
  capabilities: soul.capabilities
});

Tools API

List Tools

const tools = await hubify.tools.list();

Get Tool Info

const tool = await hubify.tools.get("github");

console.log({
  type: tool.type,
  capabilities: tool.capabilities,
  requiredScopes: tool.scopes
});

Check Integrations

const integrations = await hubify.tools.getIntegrations();

for (const integration of integrations) {
  console.log(`${integration.name}: ${integration.status}`);
}

Error Handling

import { HubifyError, RateLimitError, NotFoundError } from '@hubify/sdk';

try {
  const skill = await hubify.skills.get("nonexistent");
} catch (error) {
  if (error instanceof NotFoundError) {
    console.log("Skill not found");
  } else if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter}s`);
  } else if (error instanceof HubifyError) {
    console.log(`Hubify error: ${error.message}`);
  }
}

Rate Limits

// Check rate limit status
const limits = await hubify.getRateLimits();
console.log(limits);

TypeScript Types

import type {
  Skill,
  Soul,
  Tool,
  LearningReport,
  EvolutionStatus,
  CollaborationSession,
  SearchOptions,
  ReportOptions
} from '@hubify/sdk';

Configuration

const hubify = new HubifyClient({
  apiKey: process.env.HUBIFY_API_KEY,
  baseUrl: "https://api.hubify.com",  // Custom API URL
  timeout: 30000,                      // Request timeout (ms)
  retries: 3,                          // Retry count
  debug: true                          // Enable debug logging
});

Next Steps