pilothub 0.0.1 → 0.0.2

package/packages/pilothub/src/cli/commands/sync.test.ts

@@ -1,310 +0,0 @@
-/* @vitest-environment node */
-
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import type { GlobalOpts } from '../types.js'
-
-const mockIntro = vi.fn()
-const mockOutro = vi.fn()
-const mockLog = vi.fn()
-const mockMultiselect = vi.fn(async (_args?: unknown) => [] as string[])
-let interactive = false
-
-const defaultFindSkillFolders = async (root: string) => {
-  if (!root.endsWith('/scan')) return []
-  return [
-    { folder: '/scan/new-skill', slug: 'new-skill', displayName: 'New Skill' },
-    { folder: '/scan/synced-skill', slug: 'synced-skill', displayName: 'Synced Skill' },
-    { folder: '/scan/update-skill', slug: 'update-skill', displayName: 'Update Skill' },
-  ]
-}
-
-vi.mock('@clack/prompts', () => ({
-  intro: (value: string) => mockIntro(value),
-  outro: (value: string) => mockOutro(value),
-  multiselect: (args: unknown) => mockMultiselect(args),
-  text: vi.fn(async () => ''),
-  isCancel: () => false,
-}))
-
-vi.mock('../../config.js', () => ({
-  readGlobalConfig: vi.fn(async () => ({ registry: 'https://pilothub.com', token: 'tkn' })),
-}))
-
-const mockGetRegistry = vi.fn(async () => 'https://pilothub.com')
-vi.mock('../registry.js', () => ({
-  getRegistry: () => mockGetRegistry(),
-}))
-
-const mockApiRequest = vi.fn()
-vi.mock('../../http.js', () => ({
-  apiRequest: (registry: unknown, args: unknown, schema?: unknown) =>
-    mockApiRequest(registry, args, schema),
-}))
-
-const mockFail = vi.fn((message: string) => {
-  throw new Error(message)
-})
-const mockSpinner = { succeed: vi.fn(), fail: vi.fn(), stop: vi.fn() }
-vi.mock('../ui.js', () => ({
-  createSpinner: vi.fn(() => mockSpinner),
-  fail: (message: string) => mockFail(message),
-  formatError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
-  isInteractive: () => interactive,
-}))
-
-vi.mock('../scanSkills.js', () => ({
-  findSkillFolders: vi.fn(defaultFindSkillFolders),
-  getFallbackSkillRoots: vi.fn(() => []),
-}))
-
-const mockResolvePilotbotSkillRoots = vi.fn(
-  async () =>
-    ({
-      roots: [] as string[],
-      labels: {} as Record<string, string>,
-    }) as const,
-)
-vi.mock('../pilotbotConfig.js', () => ({
-  resolvePilotbotSkillRoots: () => mockResolvePilotbotSkillRoots(),
-}))
-
-vi.mock('../../skills.js', async () => {
-  const actual = await vi.importActual<typeof import('../../skills.js')>('../../skills.js')
-  return {
-    ...actual,
-    listTextFiles: vi.fn(async (folder: string) => [
-      { relPath: 'SKILL.md', bytes: new TextEncoder().encode(folder) },
-    ]),
-  }
-})
-
-const mockCmdPublish = vi.fn()
-vi.mock('./publish.js', () => ({
-  cmdPublish: (...args: unknown[]) => mockCmdPublish(...args),
-}))
-
-const { cmdSync } = await import('./sync.js')
-
-function makeOpts(): GlobalOpts {
-  return {
-    workdir: '/work',
-    dir: '/work/skills',
-    site: 'https://pilothub.com',
-    registry: 'https://pilothub.com',
-    registrySource: 'default',
-  }
-}
-
-afterEach(async () => {
-  vi.clearAllMocks()
-  const { findSkillFolders } = await import('../scanSkills.js')
-  vi.mocked(findSkillFolders).mockImplementation(defaultFindSkillFolders)
-})
-
-vi.spyOn(console, 'log').mockImplementation((...args) => {
-  mockLog(args.map(String).join(' '))
-})
-
-describe('cmdSync', () => {
-  it('classifies skills as new/update/synced (dry-run, mocked HTTP)', async () => {
-    interactive = false
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        const u = new URL(`https://x.test${args.path}`)
-        const slug = u.searchParams.get('slug')
-        if (slug === 'new-skill') {
-          throw new Error('Skill not found')
-        }
-        if (slug === 'synced-skill') {
-          return { match: { version: '1.2.3' }, latestVersion: { version: '1.2.3' } }
-        }
-        if (slug === 'update-skill') {
-          return { match: null, latestVersion: { version: '1.0.0' } }
-        }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: true, dryRun: true }, true)
-
-    expect(mockCmdPublish).not.toHaveBeenCalled()
-
-    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
-    expect(output).toMatch(/Already synced/)
-    expect(output).toMatch(/synced-skill/)
-
-    const dryRunOutro = mockOutro.mock.calls.at(-1)?.[0]
-    expect(String(dryRunOutro)).toMatch(/Dry run: would upload 2 skill/)
-  })
-
-  it('prints bullet lists and selects all actionable by default', async () => {
-    interactive = true
-    mockMultiselect.mockImplementation(async (args?: unknown) => {
-      const { initialValues } = args as { initialValues: string[] }
-      return initialValues
-    })
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        const u = new URL(`https://x.test${args.path}`)
-        const slug = u.searchParams.get('slug')
-        if (slug === 'new-skill') {
-          throw new Error('Skill not found')
-        }
-        if (slug === 'synced-skill') {
-          return { match: { version: '1.2.3' }, latestVersion: { version: '1.2.3' } }
-        }
-        if (slug === 'update-skill') {
-          return { match: null, latestVersion: { version: '1.0.0' } }
-        }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: false, dryRun: false, bump: 'patch' }, true)
-
-    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
-    expect(output).toMatch(/To sync/)
-    expect(output).toMatch(/- new-skill/)
-    expect(output).toMatch(/- update-skill/)
-    expect(output).toMatch(/Already synced/)
-    expect(output).toMatch(/- synced-skill/)
-
-    const lastCall = mockMultiselect.mock.calls.at(-1)
-    const promptArgs = lastCall ? (lastCall[0] as { initialValues: string[] }) : undefined
-    expect(promptArgs?.initialValues.length).toBe(2)
-    expect(mockCmdPublish).toHaveBeenCalledTimes(2)
-  })
-
-  it('shows condensed synced list when nothing to sync', async () => {
-    interactive = false
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        return { match: { version: '1.0.0' }, latestVersion: { version: '1.0.0' } }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: true, dryRun: false }, true)
-
-    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
-    expect(output).toMatch(/Already synced/)
-    expect(output).toMatch(/new-skill@1.0.0/)
-    expect(output).toMatch(/synced-skill@1.0.0/)
-    expect(output).not.toMatch(/\n-/)
-
-    const outro = mockOutro.mock.calls.at(-1)?.[0]
-    expect(String(outro)).toMatch(/Nothing to sync/)
-  })
-
-  it('dedupes duplicate slugs before publishing', async () => {
-    interactive = false
-    const { findSkillFolders } = await import('../scanSkills.js')
-    vi.mocked(findSkillFolders).mockImplementation(async (root: string) => {
-      if (!root.endsWith('/scan')) return []
-      return [
-        { folder: '/scan/dup-skill', slug: 'dup-skill', displayName: 'Dup Skill' },
-        { folder: '/scan/dup-skill-copy', slug: 'dup-skill', displayName: 'Dup Skill' },
-      ]
-    })
-
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        return { match: null, latestVersion: null }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: true, dryRun: false }, true)
-
-    expect(mockCmdPublish).toHaveBeenCalledTimes(1)
-    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
-    expect(output).toMatch(/Skipped duplicate slugs/)
-    expect(output).toMatch(/dup-skill/)
-  })
-
-  it('prints labeled roots when pilotbot roots are detected', async () => {
-    interactive = false
-    mockResolvePilotbotSkillRoots.mockResolvedValueOnce({
-      roots: ['/auto'],
-      labels: { '/auto': 'Agent: Work' },
-    })
-    const { findSkillFolders } = await import('../scanSkills.js')
-    vi.mocked(findSkillFolders).mockImplementation(async (root: string) => {
-      if (root === '/auto') {
-        return [{ folder: '/auto/alpha', slug: 'alpha', displayName: 'Alpha' }]
-      }
-      return []
-    })
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        throw new Error('Skill not found')
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { all: true, dryRun: true }, true)
-
-    const output = mockLog.mock.calls.map((call) => String(call[0])).join('\n')
-    expect(output).toMatch(/Roots with skills/)
-    expect(output).toMatch(/Agent: Work/)
-  })
-
-  it('allows empty changelog for updates (interactive)', async () => {
-    interactive = true
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path === '/api/cli/telemetry/sync') return { ok: true }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        const u = new URL(`https://x.test${args.path}`)
-        const slug = u.searchParams.get('slug')
-        if (slug === 'new-skill') {
-          throw new Error('Skill not found')
-        }
-        if (slug === 'synced-skill') {
-          return { match: { version: '1.2.3' }, latestVersion: { version: '1.2.3' } }
-        }
-        if (slug === 'update-skill') {
-          return { match: null, latestVersion: { version: '1.0.0' } }
-        }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: true, dryRun: false, bump: 'patch' }, true)
-
-    const calls = mockCmdPublish.mock.calls.map(
-      (call) => call[2] as { slug: string; changelog: string },
-    )
-    const update = calls.find((c) => c.slug === 'update-skill')
-    if (!update) throw new Error('Missing update-skill publish')
-    expect(update.changelog).toBe('')
-  })
-
-  it('skips telemetry when PILOTHUB_DISABLE_TELEMETRY is set', async () => {
-    interactive = false
-    process.env.PILOTHUB_DISABLE_TELEMETRY = '1'
-    mockApiRequest.mockImplementation(async (_registry: string, args: { path: string }) => {
-      if (args.path === '/api/v1/whoami') return { user: { handle: 'steipete' } }
-      if (args.path.startsWith('/api/v1/resolve?')) {
-        return { match: { version: '1.0.0' }, latestVersion: { version: '1.0.0' } }
-      }
-      throw new Error(`Unexpected apiRequest: ${args.path}`)
-    })
-
-    await cmdSync(makeOpts(), { root: ['/scan'], all: true, dryRun: true }, true)
-    expect(
-      mockApiRequest.mock.calls.some((call) => call[1]?.path === '/api/cli/telemetry/sync'),
-    ).toBe(false)
-    delete process.env.PILOTHUB_DISABLE_TELEMETRY
-  })
-})

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

@@ -1,200 +0,0 @@
-import { intro, outro } from '@clack/prompts'
-import { readGlobalConfig } from '../../config.js'
-import { hashSkillFiles, listTextFiles, readSkillOrigin } from '../../skills.js'
-import { resolvePilotbotSkillRoots } from '../pilotbotConfig.js'
-import { getFallbackSkillRoots } from '../scanSkills.js'
-import type { GlobalOpts } from '../types.js'
-import { createSpinner, fail, formatError, isInteractive } from '../ui.js'
-import { cmdPublish } from './publish.js'
-import {
-  buildScanRoots,
-  checkRegistrySyncState,
-  dedupeSkillsBySlug,
-  formatActionableLine,
-  formatBulletList,
-  formatCommaList,
-  formatList,
-  formatSyncedDisplay,
-  formatSyncedSummary,
-  getRegistryWithAuth,
-  mapWithConcurrency,
-  mergeScan,
-  normalizeConcurrency,
-  printSection,
-  reportTelemetryIfEnabled,
-  resolvePublishMeta,
-  scanRootsWithLabels,
-  selectToUpload,
-} from './syncHelpers.js'
-import type { Candidate, LocalSkill, SyncOptions } from './syncTypes.js'
-
-export async function cmdSync(opts: GlobalOpts, options: SyncOptions, inputAllowed: boolean) {
-  const allowPrompt = isInteractive() && inputAllowed !== false
-  intro('PilotHub sync')
-
-  const cfg = await readGlobalConfig()
-  const token = cfg?.token
-  if (!token) fail('Not logged in. Run: pilothub login')
-
-  const registry = await getRegistryWithAuth(opts, token)
-  const selectedRoots = buildScanRoots(opts, options.root)
-  const pilotbotRoots = await resolvePilotbotSkillRoots()
-  const combinedRoots = Array.from(
-    new Set([...selectedRoots, ...pilotbotRoots.roots].map((root) => root.trim()).filter(Boolean)),
-  )
-  const concurrency = normalizeConcurrency(options.concurrency)
-
-  const spinner = createSpinner('Scanning for local skills')
-  const primaryScan = await scanRootsWithLabels(combinedRoots, pilotbotRoots.labels)
-  let scan = primaryScan
-  let telemetryScan = primaryScan
-  if (primaryScan.skills.length === 0) {
-    const fallback = getFallbackSkillRoots(opts.workdir)
-    const fallbackScan = await scanRootsWithLabels(fallback)
-    spinner.stop()
-    telemetryScan = mergeScan(primaryScan, fallbackScan)
-    scan = fallbackScan
-    if (fallbackScan.skills.length === 0)
-      fail('No skills found (checked workdir and known Pilotbot/Pilot locations)')
-    printSection(
-      `No skills in workdir. Found ${fallbackScan.skills.length} in fallback locations.`,
-      formatList(fallbackScan.rootsWithSkills, 10),
-    )
-  } else {
-    spinner.stop()
-    const labeledRoots = primaryScan.rootsWithSkills
-      .map((root) => {
-        const label = primaryScan.rootLabels?.[root]
-        return label ? `${label} (${root})` : root
-      })
-      .filter(Boolean)
-    if (labeledRoots.length > 0) {
-      printSection('Roots with skills', formatList(labeledRoots, 10))
-    }
-  }
-  const deduped = dedupeSkillsBySlug(scan.skills)
-  const skills = deduped.skills
-  if (deduped.duplicates.length > 0) {
-    printSection('Skipped duplicate slugs', formatCommaList(deduped.duplicates, 16))
-  }
-  const parsingSpinner = createSpinner('Parsing local skills')
-  const locals: LocalSkill[] = []
-  try {
-    let done = 0
-    const parsed = await mapWithConcurrency(skills, Math.min(concurrency, 12), async (skill) => {
-      const filesOnDisk = await listTextFiles(skill.folder)
-      const hashed = hashSkillFiles(filesOnDisk)
-      const origin = await readSkillOrigin(skill.folder)
-      done += 1
-      parsingSpinner.text = `Parsing local skills ${done}/${skills.length}`
-      return {
-        ...skill,
-        fingerprint: hashed.fingerprint,
-        fileCount: filesOnDisk.length,
-        origin,
-      }
-    })
-    locals.push(...parsed)
-  } catch (error) {
-    parsingSpinner.fail(formatError(error))
-    throw error
-  } finally {
-    parsingSpinner.stop()
-  }
-
-  const candidatesSpinner = createSpinner('Checking registry sync state')
-  const candidates: Candidate[] = []
-  const resolveSupport: { value: boolean | null } = { value: null }
-  try {
-    let done = 0
-    const resolved = await mapWithConcurrency(locals, Math.min(concurrency, 16), async (skill) => {
-      try {
-        return await checkRegistrySyncState(registry, skill, resolveSupport)
-      } finally {
-        done += 1
-        candidatesSpinner.text = `Checking registry sync state ${done}/${locals.length}`
-      }
-    })
-    candidates.push(...resolved)
-  } catch (error) {
-    candidatesSpinner.fail(formatError(error))
-    throw error
-  } finally {
-    candidatesSpinner.stop()
-  }
-
-  await reportTelemetryIfEnabled({
-    token,
-    registry,
-    scan: telemetryScan,
-    candidates,
-  })
-
-  const synced = candidates.filter((candidate) => candidate.status === 'synced')
-  const actionable = candidates.filter((candidate) => candidate.status !== 'synced')
-  const bump = options.bump ?? 'patch'
-
-  if (actionable.length === 0) {
-    if (synced.length > 0) {
-      printSection('Already synced', formatCommaList(synced.map(formatSyncedSummary), 16))
-    }
-    outro('Nothing to sync.')
-    return
-  }
-
-  printSection(
-    'To sync',
-    formatBulletList(
-      actionable.map((candidate) => formatActionableLine(candidate, bump)),
-      20,
-    ),
-  )
-  if (synced.length > 0) {
-    printSection('Already synced', formatSyncedDisplay(synced))
-  }
-
-  const selected = await selectToUpload(actionable, {
-    allowPrompt,
-    all: Boolean(options.all),
-    bump,
-  })
-  if (selected.length === 0) {
-    outro('Nothing selected.')
-    return
-  }
-
-  if (options.dryRun) {
-    outro(`Dry run: would upload ${selected.length} skill(s).`)
-    return
-  }
-
-  const tags = options.tags ?? 'latest'
-
-  for (const skill of selected) {
-    const { publishVersion, changelog } = await resolvePublishMeta(skill, {
-      bump,
-      allowPrompt,
-      changelogFlag: options.changelog,
-    })
-    const forkOf =
-      skill.origin && normalizeRegistry(skill.origin.registry) === normalizeRegistry(registry)
-        ? skill.origin.slug !== skill.slug
-          ? `${skill.origin.slug}@${skill.origin.installedVersion}`
-          : undefined
-        : undefined
-    await cmdPublish(opts, skill.folder, {
-      slug: skill.slug,
-      name: skill.displayName,
-      version: publishVersion,
-      changelog,
-      tags,
-      forkOf,
-    })
-  }
-
-  outro(`Uploaded ${selected.length} skill(s).`)
-}
-
-function normalizeRegistry(value: string) {
-  return value.trim().replace(/\/+$/, '').toLowerCase()
-}

package/packages/pilothub/src/cli/commands/syncHelpers.test.ts

@@ -1,26 +0,0 @@
-/* @vitest-environment node */
-import { describe, expect, it, vi } from 'vitest'
-
-vi.mock('../scanSkills.js', () => ({
-  findSkillFolders: vi.fn(async (root: string) => {
-    if (root.endsWith('/with-skill')) {
-      return [{ folder: `${root}/demo`, slug: 'demo', displayName: 'Demo' }]
-    }
-    return []
-  }),
-}))
-
-const { scanRootsWithLabels } = await import('./syncHelpers.js')
-
-describe('scanRootsWithLabels', () => {
-  it('attaches labels to roots with skills', async () => {
-    const roots = ['/tmp/with-skill', '/tmp/empty', '/tmp/with-skill']
-    const labels = { '/tmp/with-skill': 'Agent: Work' }
-
-    const result = await scanRootsWithLabels(roots, labels)
-
-    expect(result.rootsWithSkills).toEqual(['/tmp/with-skill'])
-    expect(result.rootLabels).toEqual({ '/tmp/with-skill': 'Agent: Work' })
-    expect(result.skills.map((skill) => skill.slug)).toEqual(['demo'])
-  })
-})