pilothub 0.0.1

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

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

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

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

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

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

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

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

@@ -0,0 +1,75 @@
+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)
+}