@skillshub-labs/cli 0.1.17

package/lib/services/kit-service.d.ts

@@ -0,0 +1,66 @@
+import type {
+  KitApplyResult,
+  KitLoadoutRecord,
+  KitPolicyRecord,
+  KitRecord,
+  KitSyncMode,
+} from '../core/kit-types'
+
+export function normalizeKitMode(value: unknown): KitSyncMode
+export function normalizeLoadoutItems(items: unknown): Array<{
+  skillPath: string
+  mode: KitSyncMode
+  sortOrder: number
+}>
+
+export function listKitPolicies(): KitPolicyRecord[]
+export function addKitPolicy(values: {
+  name: string
+  description?: string
+  content: string
+}): KitPolicyRecord
+export function updateKitPolicy(values: {
+  id: string
+  name?: string
+  description?: string
+  content?: string
+}): KitPolicyRecord
+export function deleteKitPolicy(id: string): boolean
+
+export function listKitLoadouts(): KitLoadoutRecord[]
+export function addKitLoadout(values: {
+  name: string
+  description?: string
+  items: Array<{ skillPath: string; mode?: KitSyncMode; sortOrder?: number }>
+}): KitLoadoutRecord
+export function updateKitLoadout(values: {
+  id: string
+  name?: string
+  description?: string
+  items?: Array<{ skillPath: string; mode?: KitSyncMode; sortOrder?: number }>
+}): KitLoadoutRecord
+export function deleteKitLoadout(id: string): boolean
+
+export function listKits(): KitRecord[]
+export function addKit(values: {
+  name: string
+  description?: string
+  policyId: string
+  loadoutId: string
+}): KitRecord
+export function updateKit(values: {
+  id: string
+  name?: string
+  description?: string
+  policyId?: string
+  loadoutId?: string
+}): KitRecord
+export function deleteKit(id: string): boolean
+
+export function applyKit(values: {
+  kitId: string
+  projectPath: string
+  agentName: string
+  mode?: KitSyncMode
+  overwriteAgentsMd?: boolean
+}): Promise<KitApplyResult>

package/lib/services/kit-service.mjs

@@ -0,0 +1,266 @@
+import fs from 'fs-extra'
+import os from 'os'
+import path from 'path'
+import {
+  addKit as addKitCore,
+  addKitLoadout as addKitLoadoutCore,
+  addKitPolicy as addKitPolicyCore,
+  deleteKit as deleteKitCore,
+  deleteKitLoadout as deleteKitLoadoutCore,
+  deleteKitPolicy as deleteKitPolicyCore,
+  getKitById,
+  getKitLoadoutById,
+  getKitPolicyById,
+  listKitLoadouts as listKitLoadoutsCore,
+  listKitPolicies as listKitPoliciesCore,
+  listKits as listKitsCore,
+  markKitApplied,
+  updateKit as updateKitCore,
+  updateKitLoadout as updateKitLoadoutCore,
+  updateKitPolicy as updateKitPolicyCore,
+} from '../core/kit-core.mjs'
+
+const CONFIG_PATH = path.join(os.homedir(), '.skills-hub', 'config.json')
+
+function normalizeKitMode(value) {
+  return value === 'link' ? 'link' : 'copy'
+}
+
+function normalizeLoadoutItems(items) {
+  if (!Array.isArray(items)) {
+    throw new Error('Skills package items must be an array.')
+  }
+
+  const seen = new Set()
+  const normalized = []
+
+  for (const [index, item] of items.entries()) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) continue
+    const raw = item
+    const skillPath = String(raw.skillPath || '').trim()
+    if (!skillPath || seen.has(skillPath)) continue
+
+    normalized.push({
+      skillPath,
+      mode: normalizeKitMode(raw.mode),
+      sortOrder: Number.isInteger(raw.sortOrder) ? Number(raw.sortOrder) : index,
+    })
+    seen.add(skillPath)
+  }
+
+  return normalized
+}
+
+async function readRuntimeConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf-8')
+    if (!raw.trim()) {
+      return { projects: [], agents: [] }
+    }
+
+    const parsed = JSON.parse(raw)
+    const projects = Array.isArray(parsed.projects)
+      ? parsed.projects.map((entry) => String(entry || '').trim()).filter(Boolean)
+      : []
+    const agents = Array.isArray(parsed.agents)
+      ? parsed.agents.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+      : []
+
+    return { projects, agents }
+  } catch {
+    return { projects: [], agents: [] }
+  }
+}
+
+async function atomicWriteText(filePath, content) {
+  const dirPath = path.dirname(filePath)
+  await fs.ensureDir(dirPath)
+  const tempPath = path.join(
+    dirPath,
+    `.${path.basename(filePath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`
+  )
+  await fs.writeFile(tempPath, content, 'utf-8')
+  await fs.move(tempPath, filePath, { overwrite: true })
+}
+
+async function syncSkill(sourcePath, destParentPath, syncMode = 'copy') {
+  const skillDirName = path.basename(sourcePath)
+  const destPath = path.join(destParentPath, skillDirName)
+
+  if (sourcePath === destPath) {
+    return destPath
+  }
+
+  await fs.ensureDir(destParentPath)
+
+  if (syncMode === 'link') {
+    await fs.remove(destPath)
+    await fs.ensureSymlink(sourcePath, destPath)
+    return destPath
+  }
+
+  const isSymlink = await fs
+    .lstat(destPath)
+    .then((stat) => stat.isSymbolicLink())
+    .catch(() => false)
+
+  if (isSymlink) {
+    await fs.remove(destPath)
+  }
+
+  await fs.copy(sourcePath, destPath, { overwrite: true, errorOnExist: false })
+  return destPath
+}
+
+function listKitPolicies() {
+  return listKitPoliciesCore()
+}
+
+function addKitPolicy(values) {
+  return addKitPolicyCore(values)
+}
+
+function updateKitPolicy(values) {
+  return updateKitPolicyCore(values)
+}
+
+function deleteKitPolicy(id) {
+  return deleteKitPolicyCore(id)
+}
+
+function listKitLoadouts() {
+  return listKitLoadoutsCore()
+}
+
+function addKitLoadout(values) {
+  return addKitLoadoutCore({
+    ...values,
+    items: normalizeLoadoutItems(values.items || []),
+  })
+}
+
+function updateKitLoadout(values) {
+  return updateKitLoadoutCore({
+    ...values,
+    items: values.items === undefined ? undefined : normalizeLoadoutItems(values.items),
+  })
+}
+
+function deleteKitLoadout(id) {
+  return deleteKitLoadoutCore(id)
+}
+
+function listKits() {
+  return listKitsCore()
+}
+
+function addKit(values) {
+  return addKitCore(values)
+}
+
+function updateKit(values) {
+  return updateKitCore(values)
+}
+
+function deleteKit(id) {
+  return deleteKitCore(id)
+}
+
+async function applyKit(values) {
+  const kitId = String(values?.kitId || '').trim()
+  const projectPath = String(values?.projectPath || '').trim()
+  const agentName = String(values?.agentName || '').trim()
+  const applyMode = normalizeKitMode(values?.mode)
+  const overwriteAgentsMd = values?.overwriteAgentsMd === true
+
+  if (!kitId) throw new Error('kitId is required')
+  if (!projectPath) throw new Error('projectPath is required')
+  if (!agentName) throw new Error('agentName is required')
+
+  const kit = getKitById(kitId)
+  if (!kit) throw new Error(`Kit not found: ${kitId}`)
+
+  const policy = getKitPolicyById(kit.policyId)
+  if (!policy) throw new Error(`AGENTS.md not found: ${kit.policyId}`)
+
+  const loadout = getKitLoadoutById(kit.loadoutId)
+  if (!loadout) throw new Error(`Skills package not found: ${kit.loadoutId}`)
+
+  const config = await readRuntimeConfig()
+  const projectExists = config.projects.includes(projectPath)
+  if (!projectExists) {
+    throw new Error('Target project is not registered in Skills Hub.')
+  }
+
+  const targetAgent = config.agents.find((agent) => agent.enabled && agent.name === agentName)
+  if (!targetAgent) {
+    throw new Error('Target agent is not enabled or not found.')
+  }
+
+  const targetSkillParent = path.join(projectPath, targetAgent.projectPath)
+  const loadoutResults = []
+
+  for (const item of loadout.items) {
+    try {
+      const destination = await syncSkill(item.skillPath, targetSkillParent, applyMode)
+      loadoutResults.push({
+        skillPath: item.skillPath,
+        mode: applyMode,
+        destination,
+        status: 'success',
+      })
+    } catch (error) {
+      loadoutResults.push({
+        skillPath: item.skillPath,
+        mode: applyMode,
+        destination: path.join(targetSkillParent, path.basename(item.skillPath)),
+        status: 'failed',
+        error: error instanceof Error ? error.message : String(error),
+      })
+      throw new Error(`Failed to sync skill: ${item.skillPath}`)
+    }
+  }
+
+  const policyPath = path.join(projectPath, 'AGENTS.md')
+  const policyExists = await fs.pathExists(policyPath)
+  if (policyExists && !overwriteAgentsMd) {
+    throw new Error(`AGENTS_MD_EXISTS::${policyPath}`)
+  }
+
+  const policyContent = policy.content.endsWith('\n') ? policy.content : `${policy.content}\n`
+  await atomicWriteText(policyPath, policyContent)
+
+  const applied = markKitApplied({ id: kitId, projectPath, agentName })
+  if (!applied) {
+    throw new Error('Failed to record kit application metadata.')
+  }
+
+  return {
+    kitId,
+    kitName: applied.name,
+    policyPath,
+    projectPath,
+    agentName,
+    appliedAt: applied.lastAppliedAt || Date.now(),
+    overwroteAgentsMd: policyExists && overwriteAgentsMd,
+    loadoutResults,
+  }
+}
+
+export {
+  normalizeKitMode,
+  normalizeLoadoutItems,
+  listKitPolicies,
+  addKitPolicy,
+  updateKitPolicy,
+  deleteKitPolicy,
+  listKitLoadouts,
+  addKitLoadout,
+  updateKitLoadout,
+  deleteKitLoadout,
+  listKits,
+  addKit,
+  updateKit,
+  deleteKit,
+  applyKit,
+}

package/lib/services/provider-service.d.ts

@@ -0,0 +1,63 @@
+import type {
+  AppType,
+  ProviderRecord,
+  ProviderSwitchResult,
+  UniversalProviderApps,
+  UniversalProviderModels,
+  UniversalProviderRecord,
+} from '../core/provider-types'
+
+export const APP_TYPES: AppType[]
+
+export function assertAppType(appType: string): asserts appType is AppType
+export function normalizeProviderConfig(config: unknown): Record<string, unknown>
+
+export function listProvidersMasked(appType?: string): ProviderRecord[]
+export function getCurrentProviderMasked(appType: string): ProviderRecord | null
+export function getProviderRaw(id: string): ProviderRecord
+export function addProviderRecord(values: {
+  appType: string
+  name: string
+  config: unknown
+}): ProviderRecord
+export function updateProviderRecord(values: {
+  id: string
+  name?: string
+  config?: unknown
+}): ProviderRecord
+export function deleteProviderRecord(id: string): boolean
+export function switchProviderRecord(values: {
+  appType: string
+  providerId: string
+}): Promise<ProviderSwitchResult>
+export function getLatestProviderBackup(appType: string): unknown
+export function restoreLatestProviderBackup(appType: string): Promise<unknown>
+export function captureProviderFromLiveRecord(values: {
+  appType: string
+  name: string
+  profile?: Record<string, unknown>
+}): Promise<ProviderRecord>
+
+export function listUniversalProvidersMasked(): UniversalProviderRecord[]
+export function getUniversalProviderRaw(id: string): UniversalProviderRecord
+export function addUniversalProviderRecord(values: {
+  name: string
+  baseUrl: string
+  apiKey: string
+  websiteUrl?: string
+  notes?: string
+  apps?: Partial<UniversalProviderApps>
+  models?: UniversalProviderModels
+}): UniversalProviderRecord
+export function updateUniversalProviderRecord(values: {
+  id: string
+  name?: string
+  baseUrl?: string
+  apiKey?: string
+  websiteUrl?: string
+  notes?: string
+  apps?: Partial<UniversalProviderApps>
+  models?: UniversalProviderModels
+}): UniversalProviderRecord
+export function deleteUniversalProviderRecord(id: string): boolean
+export function applyUniversalProviderRecord(id: string): ProviderRecord[]

package/lib/services/provider-service.mjs

@@ -0,0 +1,183 @@
+import {
+  APP_TYPES,
+  addProvider,
+  addUniversalProvider,
+  applyUniversalProvider,
+  captureProviderFromLive,
+  deleteProvider,
+  deleteUniversalProvider,
+  getCurrentProvider,
+  getLatestBackup,
+  getProviderById,
+  getUniversalProviderById,
+  listProviders,
+  listUniversalProviders,
+  maskProvider,
+  maskProviders,
+  restoreBackup,
+  switchProvider,
+  updateProvider,
+  updateUniversalProvider,
+} from '../core/provider-core.mjs'
+
+function assertAppType(appType) {
+  if (!APP_TYPES.includes(appType)) {
+    throw new Error(`Unsupported app type: ${appType}`)
+  }
+}
+
+function normalizeProviderConfig(config) {
+  if (typeof config === 'string') {
+    const parsed = JSON.parse(config)
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('Provider config must be a JSON object.')
+    }
+    return parsed
+  }
+
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error('Provider config must be an object.')
+  }
+
+  return config
+}
+
+function maskUniversalProvider(provider) {
+  return {
+    ...provider,
+    apiKey: provider.apiKey.trim() ? `${provider.apiKey.slice(0, 3)}****` : '',
+  }
+}
+
+function listProvidersMasked(appType) {
+  if (appType) assertAppType(appType)
+  const providers = listProviders(appType)
+  return maskProviders(providers)
+}
+
+function getCurrentProviderMasked(appType) {
+  assertAppType(appType)
+  return maskProvider(getCurrentProvider(appType))
+}
+
+function getProviderRaw(id) {
+  const provider = getProviderById(id)
+  if (!provider) {
+    throw new Error(`Provider not found: ${id}`)
+  }
+  return provider
+}
+
+function addProviderRecord(values) {
+  assertAppType(values.appType)
+  return maskProvider(
+    addProvider({
+      appType: values.appType,
+      name: values.name,
+      config: normalizeProviderConfig(values.config),
+    })
+  )
+}
+
+function updateProviderRecord(values) {
+  return maskProvider(
+    updateProvider({
+      id: values.id,
+      name: values.name,
+      config: values.config === undefined ? undefined : normalizeProviderConfig(values.config),
+    })
+  )
+}
+
+function deleteProviderRecord(id) {
+  return deleteProvider(id)
+}
+
+async function switchProviderRecord(values) {
+  assertAppType(values.appType)
+  return switchProvider({
+    appType: values.appType,
+    providerId: values.providerId,
+  })
+}
+
+function getLatestProviderBackup(appType) {
+  assertAppType(appType)
+  return getLatestBackup(appType)
+}
+
+async function restoreLatestProviderBackup(appType) {
+  assertAppType(appType)
+  return restoreBackup(appType)
+}
+
+async function captureProviderFromLiveRecord(values) {
+  assertAppType(values.appType)
+  return maskProvider(
+    await captureProviderFromLive({
+      appType: values.appType,
+      name: values.name,
+      profile: values.profile,
+    })
+  )
+}
+
+function listUniversalProvidersMasked() {
+  const providers = listUniversalProviders()
+  return providers.map(maskUniversalProvider)
+}
+
+function getUniversalProviderRaw(id) {
+  const provider = getUniversalProviderById(id)
+  if (!provider) {
+    throw new Error(`Universal provider not found: ${id}`)
+  }
+  return provider
+}
+
+function addUniversalProviderRecord(values) {
+  const provider = addUniversalProvider(values)
+  if (!provider) {
+    throw new Error('Failed to create universal provider')
+  }
+  return maskUniversalProvider(provider)
+}
+
+function updateUniversalProviderRecord(values) {
+  const provider = updateUniversalProvider(values)
+  if (!provider) {
+    throw new Error('Failed to update universal provider')
+  }
+  return maskUniversalProvider(provider)
+}
+
+function deleteUniversalProviderRecord(id) {
+  return deleteUniversalProvider(id)
+}
+
+function applyUniversalProviderRecord(id) {
+  const applied = applyUniversalProvider({ id })
+  return maskProviders(applied)
+}
+
+export {
+  APP_TYPES,
+  assertAppType,
+  normalizeProviderConfig,
+  listProvidersMasked,
+  getCurrentProviderMasked,
+  getProviderRaw,
+  addProviderRecord,
+  updateProviderRecord,
+  deleteProviderRecord,
+  switchProviderRecord,
+  getLatestProviderBackup,
+  restoreLatestProviderBackup,
+  captureProviderFromLiveRecord,
+  listUniversalProvidersMasked,
+  getUniversalProviderRaw,
+  addUniversalProviderRecord,
+  updateUniversalProviderRecord,
+  deleteUniversalProviderRecord,
+  applyUniversalProviderRecord,
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@skillshub-labs/cli",
+  "version": "0.1.17",
+  "description": "Unify your AI toolbox. A local hub to visualize, manage, and sync skills across Antigravity, Claude, Cursor, Trae, and other AI agents.",
+  "keywords": [
+    "skills",
+    "ai",
+    "agent",
+    "claude",
+    "cursor",
+    "antigravity",
+    "cli"
+  ],
+  "author": "PotatoDog1669",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PotatoDog1669/skills-hub.git"
+  },
+  "homepage": "https://github.com/PotatoDog1669/skills-hub",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "skills-hub": "bin/skills-hub"
+  },
+  "files": [
+    "bin/skills-hub",
+    "lib/core/provider-core.mjs",
+    "lib/core/provider-core.d.ts",
+    "lib/core/kit-core.mjs",
+    "lib/core/kit-core.d.ts",
+    "lib/core/kit-types.ts",
+    "lib/services/provider-service.mjs",
+    "lib/services/provider-service.d.ts",
+    "lib/services/kit-service.mjs",
+    "lib/services/kit-service.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "npm run tauri:dev",
+    "build": "npm run tauri:ui:build",
+    "tauri:ui:dev": "vite --config apps/desktop-ui/vite.config.ts --host 127.0.0.1 --port 1420",
+    "tauri:ui:build": "vite build --config apps/desktop-ui/vite.config.ts",
+    "tauri:dev": "tauri dev --config src-tauri/tauri.conf.json",
+    "tauri:build": "tauri build --config src-tauri/tauri.conf.json",
+    "lint": "eslint",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "prepack": "npm run typecheck"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tauri-apps/api": "^2.8.0",
+    "@tauri-apps/plugin-dialog": "^2.0.0",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "better-sqlite3": "^12.6.2",
+    "clsx": "^2.1.1",
+    "fs-extra": "^11.3.3",
+    "gray-matter": "^4.0.3",
+    "lucide-react": "^0.562.0",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "react-markdown": "^10.1.0",
+    "react-syntax-highlighter": "^16.1.0",
+    "remark-gfm": "^4.0.1",
+    "simple-git": "^3.30.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@tauri-apps/cli": "^2.9.2",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@vitejs/plugin-react": "^5.1.2",
+    "autoprefixer": "^10.4.23",
+    "eslint": "^9",
+    "globals": "^17.3.0",
+    "jsdom": "^27.4.0",
+    "lint-staged": "^16.2.7",
+    "postcss": "^8.5.6",
+    "prettier": "^3.8.0",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5",
+    "typescript-eslint": "^8.55.0",
+    "vite": "^7.1.11",
+    "vitest": "^4.0.17"
+  }
+}