pilothub 0.0.1 → 0.0.2

package/packages/pilothub/src/cli/pilotbotConfig.ts

@@ -1,147 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { basename, join, resolve } from 'node:path'
-import JSON5 from 'json5'
-
-type PilotbotConfig = {
-  agent?: { workspace?: string }
-  agents?: {
-    defaults?: { workspace?: string }
-    list?: Array<{
-      id?: string
-      name?: string
-      workspace?: string
-      default?: boolean
-    }>
-  }
-  routing?: {
-    agents?: Record<
-      string,
-      {
-        name?: string
-        workspace?: string
-      }
-    >
-  }
-  skills?: {
-    load?: {
-      extraDirs?: string[]
-    }
-  }
-}
-
-export type PilotbotSkillRoots = {
-  roots: string[]
-  labels: Record<string, string>
-}
-
-export async function resolvePilotbotSkillRoots(): Promise<PilotbotSkillRoots> {
-  const roots: string[] = []
-  const labels: Record<string, string> = {}
-
-  const stateDir = resolvePilotbotStateDir()
-  const sharedSkills = resolveUserPath(join(stateDir, 'skills'))
-  pushRoot(roots, labels, sharedSkills, 'Shared skills')
-
-  const config = await readPilotbotConfig()
-  if (!config) return { roots, labels }
-
-  const mainWorkspace = resolveUserPath(
-    config.agents?.defaults?.workspace ?? config.agent?.workspace ?? '',
-  )
-  if (mainWorkspace) {
-    pushRoot(roots, labels, join(mainWorkspace, 'skills'), 'Agent: main')
-  }
-
-  const listedAgents = config.agents?.list ?? []
-  for (const entry of listedAgents) {
-    const workspace = resolveUserPath(entry?.workspace ?? '')
-    if (!workspace) continue
-    const name = entry?.name?.trim() || entry?.id?.trim() || 'agent'
-    pushRoot(roots, labels, join(workspace, 'skills'), `Agent: ${name}`)
-  }
-
-  const agents = config.routing?.agents ?? {}
-  for (const [agentId, entry] of Object.entries(agents)) {
-    const workspace = resolveUserPath(entry?.workspace ?? '')
-    if (!workspace) continue
-    const name = entry?.name?.trim() || agentId
-    pushRoot(roots, labels, join(workspace, 'skills'), `Agent: ${name}`)
-  }
-
-  const extraDirs = config.skills?.load?.extraDirs ?? []
-  for (const dir of extraDirs) {
-    const resolved = resolveUserPath(String(dir))
-    if (!resolved) continue
-    const label = `Extra: ${basename(resolved) || resolved}`
-    pushRoot(roots, labels, resolved, label)
-  }
-
-  return { roots, labels }
-}
-
-export async function resolvePilotbotDefaultWorkspace(): Promise<string | null> {
-  const config = await readPilotbotConfig()
-  if (!config) return null
-
-  const defaultsWorkspace = resolveUserPath(
-    config.agents?.defaults?.workspace ?? config.agent?.workspace ?? '',
-  )
-  if (defaultsWorkspace) return defaultsWorkspace
-
-  const listedAgents = config.agents?.list ?? []
-  const defaultAgent =
-    listedAgents.find((entry) => entry.default) ?? listedAgents.find((entry) => entry.id === 'main')
-  const listWorkspace = resolveUserPath(defaultAgent?.workspace ?? '')
-  return listWorkspace || null
-}
-
-function resolvePilotbotStateDir() {
-  const override = process.env.PILOTBOT_STATE_DIR?.trim()
-  if (override) return resolveUserPath(override)
-  return join(homedir(), '.pilotbot')
-}
-
-function resolvePilotbotConfigPath() {
-  const override = process.env.PILOTBOT_CONFIG_PATH?.trim()
-  if (override) return resolveUserPath(override)
-  return join(resolvePilotbotStateDir(), 'pilotbot.json')
-}
-
-function resolveUserPath(input: string) {
-  const trimmed = input.trim()
-  if (!trimmed) return ''
-  if (trimmed.startsWith('~')) {
-    return resolve(trimmed.replace(/^~(?=$|[\\/])/, homedir()))
-  }
-  return resolve(trimmed)
-}
-
-async function readPilotbotConfig(): Promise<PilotbotConfig | null> {
-  try {
-    const raw = await readFile(resolvePilotbotConfigPath(), 'utf8')
-    const parsed = JSON5.parse(raw)
-    if (!parsed || typeof parsed !== 'object') return null
-    return parsed as PilotbotConfig
-  } catch {
-    return null
-  }
-}
-
-function pushRoot(roots: string[], labels: Record<string, string>, root: string, label?: string) {
-  const resolved = resolveUserPath(root)
-  if (!resolved) return
-  if (!roots.includes(resolved)) roots.push(resolved)
-  if (!label) return
-  const existing = labels[resolved]
-  if (!existing) {
-    labels[resolved] = label
-    return
-  }
-  const parts = existing
-    .split(', ')
-    .map((part) => part.trim())
-    .filter(Boolean)
-  if (parts.includes(label)) return
-  labels[resolved] = `${existing}, ${label}`
-}

package/packages/pilothub/src/cli/registry.test.ts

@@ -1,63 +0,0 @@
-/* @vitest-environment node */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { GlobalOpts } from './types'
-
-const readGlobalConfig = vi.fn()
-const writeGlobalConfig = vi.fn()
-const discoverRegistryFromSite = vi.fn()
-
-vi.mock('../config.js', () => ({
-  readGlobalConfig: (...args: unknown[]) => readGlobalConfig(...args),
-  writeGlobalConfig: (...args: unknown[]) => writeGlobalConfig(...args),
-}))
-
-vi.mock('../discovery.js', () => ({
-  discoverRegistryFromSite: (...args: unknown[]) => discoverRegistryFromSite(...args),
-}))
-
-const { DEFAULT_REGISTRY, getRegistry, resolveRegistry } = await import('./registry')
-
-function makeOpts(overrides: Partial<GlobalOpts> = {}): GlobalOpts {
-  return {
-    workdir: '/work',
-    dir: '/work/skills',
-    site: 'https://pilothub.com',
-    registry: DEFAULT_REGISTRY,
-    registrySource: 'default',
-    ...overrides,
-  }
-}
-
-beforeEach(() => {
-  readGlobalConfig.mockReset()
-  writeGlobalConfig.mockReset()
-  discoverRegistryFromSite.mockReset()
-})
-
-describe('registry resolution', () => {
-  it('prefers explicit registry over discovery/cache', async () => {
-    readGlobalConfig.mockResolvedValue({ registry: 'https://auth.pilothub.com' })
-    discoverRegistryFromSite.mockResolvedValue({ apiBase: 'https://pilothub.com' })
-
-    const registry = await resolveRegistry(
-      makeOpts({ registry: 'https://custom.example', registrySource: 'cli' }),
-    )
-
-    expect(registry).toBe('https://custom.example')
-    expect(discoverRegistryFromSite).not.toHaveBeenCalled()
-  })
-
-  it('ignores legacy registry and updates cache from discovery', async () => {
-    readGlobalConfig.mockResolvedValue({ registry: 'https://auth.pilothub.com', token: 'tkn' })
-    discoverRegistryFromSite.mockResolvedValue({ apiBase: 'https://pilothub.com' })
-
-    const registry = await getRegistry(makeOpts(), { cache: true })
-
-    expect(registry).toBe('https://pilothub.com')
-    expect(writeGlobalConfig).toHaveBeenCalledWith({
-      registry: 'https://pilothub.com',
-      token: 'tkn',
-    })
-  })
-})

package/packages/pilothub/src/cli/registry.ts

@@ -1,43 +0,0 @@
-import { readGlobalConfig, writeGlobalConfig } from '../config.js'
-import { discoverRegistryFromSite } from '../discovery.js'
-import type { GlobalOpts } from './types.js'
-
-export const DEFAULT_SITE = 'https://pilothub.com'
-export const DEFAULT_REGISTRY = 'https://pilothub.com'
-const LEGACY_REGISTRY_HOSTS = new Set(['auth.pilothub.com'])
-
-export async function resolveRegistry(opts: GlobalOpts) {
-  const explicit = opts.registrySource !== 'default' ? opts.registry.trim() : ''
-  if (explicit) return explicit
-
-  const discovery = await discoverRegistryFromSite(opts.site).catch(() => null)
-  const discovered = discovery?.apiBase?.trim()
-  if (discovered) return discovered
-
-  const cfg = await readGlobalConfig()
-  const cached = cfg?.registry?.trim()
-  if (cached && !isLegacyRegistry(cached)) return cached
-  return DEFAULT_REGISTRY
-}
-
-export async function getRegistry(opts: GlobalOpts, params?: { cache?: boolean }) {
-  const cache = params?.cache !== false
-  const registry = await resolveRegistry(opts)
-  if (!cache) return registry
-  const cfg = await readGlobalConfig()
-  const cached = cfg?.registry?.trim()
-  const shouldUpdate =
-    !cached ||
-    isLegacyRegistry(cached) ||
-    (cached === DEFAULT_REGISTRY && registry !== DEFAULT_REGISTRY)
-  if (shouldUpdate) await writeGlobalConfig({ registry, token: cfg?.token })
-  return registry
-}
-
-function isLegacyRegistry(registry: string) {
-  try {
-    return LEGACY_REGISTRY_HOSTS.has(new URL(registry).hostname)
-  } catch {
-    return false
-  }
-}

package/packages/pilothub/src/cli/scanSkills.test.ts

@@ -1,64 +0,0 @@
-/* @vitest-environment node */
-
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join, resolve } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import { findSkillFolders, getFallbackSkillRoots } from './scanSkills'
-
-async function makeTmpDir() {
-  return mkdtemp(join(tmpdir(), 'pilothub-scan-'))
-}
-
-describe('scanSkills', () => {
-  it('detects a single skill folder (root contains SKILL.md)', async () => {
-    const root = await makeTmpDir()
-    try {
-      await writeFile(join(root, 'SKILL.md'), '# Skill\n', 'utf8')
-      const found = await findSkillFolders(root)
-      expect(found).toHaveLength(1)
-      expect(found[0]?.folder).toBe(resolve(root))
-      expect(found[0]?.slug).toBeTruthy()
-    } finally {
-      await rm(root, { recursive: true, force: true })
-    }
-  })
-
-  it('detects skills in a skills directory (subfolders)', async () => {
-    const root = await makeTmpDir()
-    try {
-      const skillsDir = join(root, 'skills')
-      const folder = join(skillsDir, 'cool-skill')
-      await mkdir(folder, { recursive: true })
-      await writeFile(join(folder, 'SKILL.md'), '# Skill\n', 'utf8')
-
-      const found = await findSkillFolders(skillsDir)
-      expect(found).toHaveLength(1)
-      expect(found[0]?.slug).toBe('cool-skill')
-      expect(found[0]?.folder).toBe(resolve(folder))
-    } finally {
-      await rm(root, { recursive: true, force: true })
-    }
-  })
-
-  it('ignores plural skills.md marker files', async () => {
-    const root = await makeTmpDir()
-    try {
-      const folder = join(root, 'docs')
-      await mkdir(folder, { recursive: true })
-      await writeFile(join(folder, 'skills.md'), '# Docs\n', 'utf8')
-
-      const found = await findSkillFolders(root)
-      expect(found).toHaveLength(0)
-    } finally {
-      await rm(root, { recursive: true, force: true })
-    }
-  })
-
-  it('includes known legacy roots', () => {
-    const roots = getFallbackSkillRoots('/tmp/anywhere')
-    expect(roots.some((p) => p.endsWith('/pilotbot/skills'))).toBe(true)
-    expect(roots.some((p) => p.endsWith('/pilot/skills'))).toBe(true)
-    expect(roots.some((p) => p.endsWith('/pilotbot/skills'))).toBe(true)
-  })
-})

package/packages/pilothub/src/cli/scanSkills.ts

@@ -1,84 +0,0 @@
-import { readdir, stat } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import { basename, join, resolve } from 'node:path'
-import { sanitizeSlug, titleCase } from './slug.js'
-
-export type SkillFolder = {
-  folder: string
-  slug: string
-  displayName: string
-}
-
-export async function findSkillFolders(root: string): Promise<SkillFolder[]> {
-  const absRoot = resolve(root)
-  const rootStat = await stat(absRoot).catch(() => null)
-  if (!rootStat || !rootStat.isDirectory()) return []
-
-  const direct = await isSkillFolder(absRoot)
-  if (direct) return [direct]
-
-  const entries = await readdir(absRoot, { withFileTypes: true }).catch(() => [])
-  const folders = entries
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => join(absRoot, entry.name))
-  const results: SkillFolder[] = []
-  for (const folder of folders) {
-    const found = await isSkillFolder(folder)
-    if (found) results.push(found)
-  }
-  return results.sort((a, b) => a.slug.localeCompare(b.slug))
-}
-
-export function getFallbackSkillRoots(workdir: string) {
-  const home = homedir()
-  const roots = [
-    // adjacent repo installs
-    resolve(workdir, '..', 'pilotbot', 'skills'),
-    resolve(workdir, '..', 'pilotbot', 'Skills'),
-    resolve(workdir, '..', 'pilotbot', 'skills'),
-    resolve(workdir, '..', 'pilotbot', 'Skills'),
-
-    // legacy locations
-    resolve(home, 'pilot', 'skills'),
-    resolve(home, 'pilot', 'Skills'),
-    resolve(home, '.pilot', 'skills'),
-    resolve(home, '.pilot', 'Skills'),
-
-    resolve(home, 'pilotbot', 'skills'),
-    resolve(home, 'pilotbot', 'Skills'),
-    resolve(home, '.pilotbot', 'skills'),
-    resolve(home, '.pilotbot', 'Skills'),
-
-    resolve(home, 'pilotbot', 'skills'),
-    resolve(home, 'pilotbot', 'Skills'),
-    resolve(home, '.pilotbot', 'skills'),
-    resolve(home, '.pilotbot', 'Skills'),
-
-    // macOS App Support legacy
-    resolve(home, 'Library', 'Application Support', 'pilotbot', 'skills'),
-    resolve(home, 'Library', 'Application Support', 'pilotbot', 'Skills'),
-    resolve(home, 'Library', 'Application Support', 'pilotbot', 'skills'),
-    resolve(home, 'Library', 'Application Support', 'pilotbot', 'Skills'),
-  ]
-  return Array.from(new Set(roots))
-}
-
-async function isSkillFolder(folder: string): Promise<SkillFolder | null> {
-  const marker = await findSkillMarker(folder)
-  if (!marker) return null
-  const base = basename(folder)
-  const slug = sanitizeSlug(base)
-  if (!slug) return null
-  const displayName = titleCase(base)
-  return { folder, slug, displayName }
-}
-
-async function findSkillMarker(folder: string) {
-  const candidates = ['SKILL.md', 'skill.md']
-  for (const name of candidates) {
-    const path = join(folder, name)
-    const st = await stat(path).catch(() => null)
-    if (st?.isFile()) return path
-  }
-  return null
-}

package/packages/pilothub/src/cli/slug.ts

@@ -1,16 +0,0 @@
-export function sanitizeSlug(value: string) {
-  const raw = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, '-')
-  const cleaned = raw.replace(/^-+/, '').replace(/-+$/, '').replace(/--+/g, '-')
-  return cleaned
-}
-
-export function titleCase(value: string) {
-  return value
-    .trim()
-    .replace(/[-_]+/g, ' ')
-    .replace(/\s+/g, ' ')
-    .replace(/\b\w/g, (char) => char.toUpperCase())
-}

package/packages/pilothub/src/cli/types.ts

@@ -1,12 +0,0 @@
-export type GlobalOpts = {
-  workdir: string
-  dir: string
-  site: string
-  registry: string
-  registrySource: 'cli' | 'env' | 'default'
-}
-
-export type ResolveResult = {
-  match: { version: string } | null
-  latestVersion: { version: string } | null
-}

package/packages/pilothub/src/cli/ui.ts

@@ -1,75 +0,0 @@
-import { spawn } from 'node:child_process'
-import { stdin } from 'node:process'
-import { confirm, isCancel } from '@clack/prompts'
-import ora from 'ora'
-
-export async function promptHidden(prompt: string) {
-  if (!stdin.isTTY) return ''
-  process.stdout.write(prompt)
-  const chunks: Buffer[] = []
-  stdin.setRawMode(true)
-  stdin.resume()
-  return new Promise<string>((resolvePromise) => {
-    function onData(data: Buffer) {
-      const text = data.toString('utf8')
-      if (text === '\r' || text === '\n') {
-        stdin.setRawMode(false)
-        stdin.pause()
-        stdin.off('data', onData)
-        process.stdout.write('\n')
-        resolvePromise(Buffer.concat(chunks).toString('utf8').trim())
-        return
-      }
-      if (text === '\u0003') {
-        stdin.setRawMode(false)
-        stdin.pause()
-        stdin.off('data', onData)
-        process.stdout.write('\n')
-        fail('Canceled')
-      }
-      if (text === '\u007f') {
-        chunks.pop()
-        return
-      }
-      chunks.push(data)
-    }
-    stdin.on('data', onData)
-  })
-}
-
-export async function promptConfirm(prompt: string) {
-  const answer = await confirm({ message: prompt })
-  if (isCancel(answer)) return false
-  return Boolean(answer)
-}
-
-export function openInBrowser(url: string) {
-  const args =
-    process.platform === 'darwin'
-      ? ['open', url]
-      : process.platform === 'win32'
-        ? ['cmd', '/c', 'start', '', url]
-        : ['xdg-open', url]
-  const [command, ...commandArgs] = args
-  if (!command) return
-  const child = spawn(command, commandArgs, { stdio: 'ignore', detached: true })
-  child.unref()
-}
-
-export function isInteractive() {
-  return Boolean(process.stdout.isTTY && stdin.isTTY)
-}
-
-export function createSpinner(text: string) {
-  return ora({ text, spinner: 'dots', isEnabled: isInteractive() }).start()
-}
-
-export function formatError(error: unknown) {
-  if (error instanceof Error) return error.message
-  return String(error)
-}
-
-export function fail(message: string): never {
-  console.error(`Error: ${message}`)
-  process.exit(1)
-}