pilothub 0.0.1

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

@@ -0,0 +1,310 @@
+/* @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

@@ -0,0 +1,200 @@
+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

@@ -0,0 +1,26 @@
+/* @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'])
+  })
+})