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"
});

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

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

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

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

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}%`);
}

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
});

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

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

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

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"
});

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

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

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}`);
}

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

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

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}%`);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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}`);
  }
}

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

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

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
});