pilothub 0.0.1 → 0.0.2

package/packages/pilothub/src/cli/commands/skills.ts

@@ -1,380 +0,0 @@
-import { mkdir, rm, stat } from 'node:fs/promises'
-import { join } from 'node:path'
-import semver from 'semver'
-import { apiRequest, downloadZip } from '../../http.js'
-import {
-  ApiRoutes,
-  ApiV1SearchResponseSchema,
-  ApiV1SkillListResponseSchema,
-  ApiV1SkillResolveResponseSchema,
-  ApiV1SkillResponseSchema,
-} from '../../schema/index.js'
-import {
-  extractZipToDir,
-  hashSkillFiles,
-  listTextFiles,
-  readLockfile,
-  readSkillOrigin,
-  writeLockfile,
-  writeSkillOrigin,
-} from '../../skills.js'
-import { getRegistry } from '../registry.js'
-import type { GlobalOpts, ResolveResult } from '../types.js'
-import { createSpinner, fail, formatError, isInteractive, promptConfirm } from '../ui.js'
-
-export async function cmdSearch(opts: GlobalOpts, query: string, limit?: number) {
-  if (!query) fail('Query required')
-
-  const registry = await getRegistry(opts, { cache: true })
-  const spinner = createSpinner('Searching')
-  try {
-    const url = new URL(ApiRoutes.search, registry)
-    url.searchParams.set('q', query)
-    if (typeof limit === 'number' && Number.isFinite(limit)) {
-      url.searchParams.set('limit', String(limit))
-    }
-    const result = await apiRequest(
-      registry,
-      { method: 'GET', url: url.toString() },
-      ApiV1SearchResponseSchema,
-    )
-
-    spinner.stop()
-    for (const entry of result.results) {
-      const slug = entry.slug ?? 'unknown'
-      const name = entry.displayName ?? slug
-      const version = entry.version ? ` v${entry.version}` : ''
-      console.log(`${slug}${version}  ${name}  (${entry.score.toFixed(3)})`)
-    }
-  } catch (error) {
-    spinner.fail(formatError(error))
-    throw error
-  }
-}
-
-export async function cmdInstall(
-  opts: GlobalOpts,
-  slug: string,
-  versionFlag?: string,
-  force = false,
-) {
-  const trimmed = slug.trim()
-  if (!trimmed) fail('Slug required')
-
-  const registry = await getRegistry(opts, { cache: true })
-  await mkdir(opts.dir, { recursive: true })
-  const target = join(opts.dir, trimmed)
-  if (!force) {
-    const exists = await fileExists(target)
-    if (exists) fail(`Already installed: ${target} (use --force)`)
-  } else {
-    await rm(target, { recursive: true, force: true })
-  }
-
-  const spinner = createSpinner(`Resolving ${trimmed}`)
-  try {
-    const resolvedVersion =
-      versionFlag ??
-      (
-        await apiRequest(
-          registry,
-          { method: 'GET', path: `${ApiRoutes.skills}/${encodeURIComponent(trimmed)}` },
-          ApiV1SkillResponseSchema,
-        )
-      ).latestVersion?.version ??
-      null
-    if (!resolvedVersion) fail('Could not resolve latest version')
-
-    spinner.text = `Downloading ${trimmed}@${resolvedVersion}`
-    const zip = await downloadZip(registry, { slug: trimmed, version: resolvedVersion })
-    await extractZipToDir(zip, target)
-
-    await writeSkillOrigin(target, {
-      version: 1,
-      registry,
-      slug: trimmed,
-      installedVersion: resolvedVersion,
-      installedAt: Date.now(),
-    })
-
-    const lock = await readLockfile(opts.workdir)
-    lock.skills[trimmed] = {
-      version: resolvedVersion,
-      installedAt: Date.now(),
-    }
-    await writeLockfile(opts.workdir, lock)
-    spinner.succeed(`OK. Installed ${trimmed} -> ${target}`)
-  } catch (error) {
-    spinner.fail(formatError(error))
-    throw error
-  }
-}
-
-export async function cmdUpdate(
-  opts: GlobalOpts,
-  slugArg: string | undefined,
-  options: { all?: boolean; version?: string; force?: boolean },
-  inputAllowed: boolean,
-) {
-  const slug = slugArg?.trim()
-  const all = Boolean(options.all)
-  if (!slug && !all) fail('Provide <slug> or --all')
-  if (slug && all) fail('Use either <slug> or --all')
-  if (options.version && !slug) fail('--version requires a single <slug>')
-  if (options.version && !semver.valid(options.version)) fail('--version must be valid semver')
-  const allowPrompt = isInteractive() && inputAllowed !== false
-
-  const registry = await getRegistry(opts, { cache: true })
-  const lock = await readLockfile(opts.workdir)
-  const slugs = slug ? [slug] : Object.keys(lock.skills)
-  if (slugs.length === 0) {
-    console.log('No installed skills.')
-    return
-  }
-
-  for (const entry of slugs) {
-    const spinner = createSpinner(`Checking ${entry}`)
-    try {
-      const target = join(opts.dir, entry)
-      const exists = await fileExists(target)
-
-      let localFingerprint: string | null = null
-      if (exists) {
-        const filesOnDisk = await listTextFiles(target)
-        if (filesOnDisk.length > 0) {
-          const hashed = hashSkillFiles(filesOnDisk)
-          localFingerprint = hashed.fingerprint
-        }
-      }
-
-      let resolveResult: ResolveResult
-      if (localFingerprint) {
-        resolveResult = await resolveSkillVersion(registry, entry, localFingerprint)
-      } else {
-        const meta = await apiRequest(
-          registry,
-          { method: 'GET', path: `${ApiRoutes.skills}/${encodeURIComponent(entry)}` },
-          ApiV1SkillResponseSchema,
-        )
-        resolveResult = { match: null, latestVersion: meta.latestVersion ?? null }
-      }
-
-      const latest = resolveResult.latestVersion?.version ?? null
-      const matched = resolveResult.match?.version ?? null
-
-      if (matched && lock.skills[entry]?.version !== matched) {
-        lock.skills[entry] = {
-          version: matched,
-          installedAt: lock.skills[entry]?.installedAt ?? Date.now(),
-        }
-      }
-
-      if (!latest) {
-        spinner.fail(`${entry}: not found`)
-        continue
-      }
-
-      if (!matched && localFingerprint && !options.force) {
-        spinner.stop()
-        if (!allowPrompt) {
-          console.log(`${entry}: local changes (no match). Use --force to overwrite.`)
-          continue
-        }
-        const confirm = await promptConfirm(
-          `${entry}: local changes (no match). Overwrite with ${options.version ?? latest}?`,
-        )
-        if (!confirm) {
-          console.log(`${entry}: skipped`)
-          continue
-        }
-        spinner.start(`Updating ${entry} -> ${options.version ?? latest}`)
-      }
-
-      const targetVersion = options.version ?? latest
-      if (options.version) {
-        if (matched && matched === targetVersion) {
-          spinner.succeed(`${entry}: already at ${matched}`)
-          continue
-        }
-      } else if (matched && semver.valid(matched) && semver.gte(matched, targetVersion)) {
-        spinner.succeed(`${entry}: up to date (${matched})`)
-        continue
-      }
-
-      if (spinner.isSpinning) {
-        spinner.text = `Updating ${entry} -> ${targetVersion}`
-      } else {
-        spinner.start(`Updating ${entry} -> ${targetVersion}`)
-      }
-      await rm(target, { recursive: true, force: true })
-      const zip = await downloadZip(registry, { slug: entry, version: targetVersion })
-      await extractZipToDir(zip, target)
-
-      const existingOrigin = await readSkillOrigin(target)
-      await writeSkillOrigin(target, {
-        version: 1,
-        registry: existingOrigin?.registry ?? registry,
-        slug: existingOrigin?.slug ?? entry,
-        installedVersion: targetVersion,
-        installedAt: existingOrigin?.installedAt ?? Date.now(),
-      })
-
-      lock.skills[entry] = { version: targetVersion, installedAt: Date.now() }
-      spinner.succeed(`${entry}: updated -> ${targetVersion}`)
-    } catch (error) {
-      spinner.fail(formatError(error))
-      throw error
-    }
-  }
-
-  await writeLockfile(opts.workdir, lock)
-}
-
-export async function cmdList(opts: GlobalOpts) {
-  const lock = await readLockfile(opts.workdir)
-  const entries = Object.entries(lock.skills)
-  if (entries.length === 0) {
-    console.log('No installed skills.')
-    return
-  }
-  for (const [slug, entry] of entries) {
-    console.log(`${slug}  ${entry.version ?? 'latest'}`)
-  }
-}
-
-type ExploreSort = 'newest' | 'downloads' | 'rating' | 'installs' | 'installsAllTime' | 'trending'
-type ApiExploreSort =
-  | 'updated'
-  | 'downloads'
-  | 'stars'
-  | 'installsCurrent'
-  | 'installsAllTime'
-  | 'trending'
-
-export async function cmdExplore(
-  opts: GlobalOpts,
-  options: { limit?: number; sort?: string; json?: boolean } = {},
-) {
-  const registry = await getRegistry(opts, { cache: true })
-  const spinner = createSpinner('Fetching latest skills')
-  try {
-    const url = new URL(ApiRoutes.skills, registry)
-    const boundedLimit = clampLimit(options.limit ?? 25)
-    const { apiSort } = resolveExploreSort(options.sort)
-    url.searchParams.set('limit', String(boundedLimit))
-    if (apiSort !== 'updated') url.searchParams.set('sort', apiSort)
-    const result = await apiRequest(
-      registry,
-      { method: 'GET', url: url.toString() },
-      ApiV1SkillListResponseSchema,
-    )
-
-    spinner.stop()
-    if (options.json) {
-      console.log(JSON.stringify(result, null, 2))
-      return
-    }
-    if (result.items.length === 0) {
-      console.log('No skills found.')
-      return
-    }
-
-    for (const item of result.items) {
-      console.log(formatExploreLine(item))
-    }
-  } catch (error) {
-    spinner.fail(formatError(error))
-    throw error
-  }
-}
-
-export function formatExploreLine(item: {
-  slug: string
-  summary?: string | null
-  updatedAt: number
-  latestVersion?: { version: string } | null
-}) {
-  const version = item.latestVersion?.version ?? '?'
-  const age = formatRelativeTime(item.updatedAt)
-  const summary = item.summary ? `  ${truncate(item.summary, 50)}` : ''
-  return `${item.slug}  v${version}  ${age}${summary}`
-}
-
-export function clampLimit(limit: number, fallback = 25) {
-  if (!Number.isFinite(limit)) return fallback
-  return Math.min(Math.max(1, limit), 200)
-}
-
-function formatRelativeTime(timestamp: number): string {
-  const now = Date.now()
-  const diff = now - timestamp
-  const seconds = Math.floor(diff / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-  const days = Math.floor(hours / 24)
-
-  if (days > 30) {
-    const months = Math.floor(days / 30)
-    return `${months}mo ago`
-  }
-  if (days > 0) return `${days}d ago`
-  if (hours > 0) return `${hours}h ago`
-  if (minutes > 0) return `${minutes}m ago`
-  return 'just now'
-}
-
-function truncate(str: string, maxLen: number): string {
-  if (str.length <= maxLen) return str
-  return `${str.slice(0, maxLen - 1)}…`
-}
-
-function resolveExploreSort(raw?: string): { sort: ExploreSort; apiSort: ApiExploreSort } {
-  const normalized = raw?.trim().toLowerCase()
-  if (!normalized || normalized === 'newest' || normalized === 'updated') {
-    return { sort: 'newest', apiSort: 'updated' }
-  }
-  if (normalized === 'downloads' || normalized === 'download') {
-    return { sort: 'downloads', apiSort: 'downloads' }
-  }
-  if (normalized === 'rating' || normalized === 'stars' || normalized === 'star') {
-    return { sort: 'rating', apiSort: 'stars' }
-  }
-  if (
-    normalized === 'installs' ||
-    normalized === 'install' ||
-    normalized === 'installscurrent' ||
-    normalized === 'installs-current' ||
-    normalized === 'current'
-  ) {
-    return { sort: 'installs', apiSort: 'installsCurrent' }
-  }
-  if (normalized === 'installsalltime' || normalized === 'installs-all-time') {
-    return { sort: 'installsAllTime', apiSort: 'installsAllTime' }
-  }
-  if (normalized === 'trending') {
-    return { sort: 'trending', apiSort: 'trending' }
-  }
-  fail(
-    `Invalid sort "${raw}". Use newest, downloads, rating, installs, installsAllTime, or trending.`,
-  )
-}
-
-async function resolveSkillVersion(registry: string, slug: string, hash: string) {
-  const url = new URL(ApiRoutes.resolve, registry)
-  url.searchParams.set('slug', slug)
-  url.searchParams.set('hash', hash)
-  return apiRequest(
-    registry,
-    { method: 'GET', url: url.toString() },
-    ApiV1SkillResolveResponseSchema,
-  )
-}
-
-async function fileExists(path: string) {
-  try {
-    await stat(path)
-    return true
-  } catch {
-    return false
-  }
-}

package/packages/pilothub/src/cli/commands/star.ts

@@ -1,46 +0,0 @@
-import { readGlobalConfig } from '../../config.js'
-import { apiRequest } from '../../http.js'
-import { ApiRoutes, ApiV1StarResponseSchema } from '../../schema/index.js'
-import { getRegistry } from '../registry.js'
-import type { GlobalOpts } from '../types.js'
-import { createSpinner, fail, formatError, isInteractive, promptConfirm } from '../ui.js'
-
-async function requireToken() {
-  const cfg = await readGlobalConfig()
-  const token = cfg?.token
-  if (!token) fail('Not logged in. Run: pilothub login')
-  return token
-}
-
-export async function cmdStarSkill(
-  opts: GlobalOpts,
-  slugArg: string,
-  options: { yes?: boolean },
-  inputAllowed: boolean,
-) {
-  const slug = slugArg.trim().toLowerCase()
-  if (!slug) fail('Slug required')
-  const allowPrompt = isInteractive() && inputAllowed !== false
-
-  if (!options.yes) {
-    if (!allowPrompt) fail('Pass --yes (no input)')
-    const ok = await promptConfirm(`Star ${slug}?`)
-    if (!ok) return
-  }
-
-  const token = await requireToken()
-  const registry = await getRegistry(opts, { cache: true })
-  const spinner = createSpinner(`Starring ${slug}`)
-  try {
-    const result = await apiRequest(
-      registry,
-      { method: 'POST', path: `${ApiRoutes.stars}/${encodeURIComponent(slug)}`, token },
-      ApiV1StarResponseSchema,
-    )
-    spinner.succeed(result.alreadyStarred ? `OK. ${slug} already starred.` : `OK. Starred ${slug}`)
-    return result
-  } catch (error) {
-    spinner.fail(formatError(error))
-    throw error
-  }
-}