@oneworks/cli 0.1.0-alpha.0

package/src/commands/skills/progress.ts

@@ -0,0 +1,126 @@
+import process from 'node:process'
+
+export interface SkillsProgressReporter {
+  completeStep: (label: string) => void
+  fail: (label?: string) => void
+  failStep: (label: string) => void
+  finish: (summary?: string) => void
+  startStep: (label: string) => void
+}
+
+const BAR_WIDTH = 20
+const TICK_MS = 120
+const SPINNER_FRAMES = ['-', '\\', '|', '/']
+
+const formatElapsed = (startedAt: number) => {
+  const totalSeconds = Math.max(0, Math.floor((Date.now() - startedAt) / 1000))
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+  return `${minutes}:${seconds.toString().padStart(2, '0')}`
+}
+
+const trimToWidth = (value: string, width: number) => (
+  value.length <= width ? value : `${value.slice(0, Math.max(0, width - 3))}...`
+)
+
+export const createSkillsProgress = (params: {
+  enabled?: boolean
+} = {}): SkillsProgressReporter => {
+  const enabled = params.enabled !== false && process.env.VITEST_WORKER_ID == null
+  const startedAt = Date.now()
+  const tty = Boolean(process.stderr.isTTY)
+  let activeLabel: string | undefined
+  let completed = 0
+  let failed = false
+  let frame = 0
+  let interval: NodeJS.Timeout | undefined
+  let total = 0
+  let wrote = false
+
+  const buildLine = (label = activeLabel ?? 'Done') => {
+    const ratio = total === 0 ? 1 : completed / total
+    const filled = Math.max(0, Math.min(BAR_WIDTH, Math.round(ratio * BAR_WIDTH)))
+    const bar = `${'#'.repeat(filled)}${'.'.repeat(BAR_WIDTH - filled)}`
+    const spinner = activeLabel == null ? ' ' : SPINNER_FRAMES[frame % SPINNER_FRAMES.length]
+    return `[oneworks] ${spinner} [${bar}] ${completed}/${total} ${trimToWidth(label, 72)} ${formatElapsed(startedAt)}`
+  }
+
+  const render = () => {
+    if (!enabled || total === 0) return
+    wrote = true
+    if (tty) {
+      process.stderr.write(`\r${buildLine()}\x1B[K`)
+      frame++
+      return
+    }
+
+    if (activeLabel != null) {
+      process.stderr.write(`${buildLine(activeLabel)}\n`)
+    }
+  }
+
+  const ensureTicker = () => {
+    if (!enabled || !tty || interval != null) return
+    interval = setInterval(render, TICK_MS)
+    interval.unref()
+  }
+
+  const stopTicker = () => {
+    if (interval == null) return
+    clearInterval(interval)
+    interval = undefined
+  }
+
+  const finishLine = (summary?: string) => {
+    if (!enabled || !wrote) return
+    const label = summary ?? (failed ? 'Failed' : 'Done')
+    if (tty) {
+      process.stderr.write(`\r${buildLine(label)}\x1B[K\n`)
+      return
+    }
+    process.stderr.write(`[oneworks] ${label} (${formatElapsed(startedAt)})\n`)
+  }
+
+  return {
+    startStep(label) {
+      if (!enabled) return
+      total++
+      activeLabel = label
+      render()
+      ensureTicker()
+    },
+    completeStep(label) {
+      if (!enabled) return
+      completed = Math.min(total, completed + 1)
+      activeLabel = undefined
+      if (!tty) {
+        process.stderr.write(`[oneworks] done ${label} (${completed}/${total}, ${formatElapsed(startedAt)})\n`)
+      } else {
+        render()
+      }
+    },
+    failStep(label) {
+      if (!enabled) return
+      failed = true
+      activeLabel = undefined
+      if (!tty) {
+        process.stderr.write(`[oneworks] failed ${label} (${formatElapsed(startedAt)})\n`)
+      } else {
+        render()
+      }
+    },
+    fail(label) {
+      if (!enabled) return
+      failed = true
+      activeLabel = undefined
+      stopTicker()
+      finishLine(label ?? 'Failed')
+    },
+    finish(summary) {
+      if (!enabled) return
+      activeLabel = undefined
+      stopTicker()
+      finishLine(summary)
+    }
+  }
+}

package/src/commands/skills/publish-command.ts

@@ -0,0 +1,85 @@
+import type { Command } from 'commander'
+
+import {
+  publishSkillsCli,
+  resolveConfiguredSkillRegistries,
+  resolveProjectSkillPublishSpec,
+  resolveSkillsRegistry
+} from '@oneworks/utils'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import { exitWithError, loadSkillsConfigState, printResult } from './shared'
+import type { SkillsPublishOptions } from './types'
+
+export const registerPublishSkillSubcommand = (skillsCommand: Command) => {
+  skillsCommand
+    .command('publish <skill>')
+    .description('Publish a local project skill, local path, or remote skill spec through the active skills CLI')
+    .option('--access <access>', 'Publish access level passed to the skills CLI')
+    .option('--group [name]', 'Publish to a specific group; pass bare --group to select interactively')
+    .option('--region <region>', 'Publish region passed to the skills CLI')
+    .option('--registry <registry>', 'Package registry used to install the managed skills CLI')
+    .option('-y, --yes', 'Skip confirmation prompts when the underlying skills CLI supports it', false)
+    .option('--json', 'Print JSON output', false)
+    .action(async (skill: string, opts: SkillsPublishOptions) => {
+      try {
+        const workspaceFolder = resolveCliWorkspaceCwd()
+        const state = await loadSkillsConfigState(workspaceFolder)
+        const resolved = await resolveProjectSkillPublishSpec({
+          selector: skill,
+          workspaceFolder
+        })
+        const publishSource = typeof resolved.publish?.source === 'string'
+          ? resolved.publish.source
+          : resolved.publish?.registry
+        const boundRegistry = typeof publishSource === 'string'
+          ? resolveConfiguredSkillRegistries(state.mergedConfig).find(entry => entry.source === publishSource)
+          : undefined
+        if (publishSource != null && boundRegistry == null && opts.registry == null) {
+          throw new Error(
+            `Configured publish source "${publishSource}" was not found in skillRegistries.`
+          )
+        }
+        const published = await publishSkillsCli({
+          access: opts.access ?? resolved.publish?.access ?? boundRegistry?.publish?.access,
+          cwd: workspaceFolder,
+          group: opts.group ?? resolved.publish?.group ?? boundRegistry?.publish?.group,
+          region: opts.region ?? resolved.publish?.region ?? boundRegistry?.publish?.region,
+          registry: opts.registry ?? boundRegistry?.registry ?? resolveSkillsRegistry(state.mergedConfig.skills),
+          skillSpec: resolved.skillSpec,
+          yes: opts.yes
+        })
+
+        if (opts.json) {
+          printResult({
+            action: 'publish',
+            boundSource: boundRegistry?.source,
+            output: published.output,
+            requested: resolved.requested,
+            skillSpec: resolved.skillSpec,
+            source: resolved.kind,
+            workspaceFolder
+          }, true)
+          return
+        }
+
+        const output = published.output.trim()
+        if (output !== '') {
+          console.log(output)
+          return
+        }
+
+        printResult({
+          action: 'publish',
+          ...(boundRegistry != null ? { boundSource: boundRegistry.source } : {}),
+          requested: resolved.requested,
+          skillSpec: resolved.skillSpec,
+          source: resolved.kind,
+          workspaceFolder
+        })
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+}

package/src/commands/skills/register.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'commander'
+
+import { registerAddSkillSubcommand } from './add-command'
+import { registerInstallSkillSubcommands } from './install-command'
+import { registerPublishSkillSubcommand } from './publish-command'
+import { registerRemoveSkillSubcommand } from './remove-command'
+
+export function registerSkillsCommand(program: Command) {
+  const skillsCommand = program
+    .command('skills')
+    .description('Install and manage project skills declared in workspace config')
+
+  registerAddSkillSubcommand(skillsCommand)
+  registerInstallSkillSubcommands(skillsCommand)
+  registerRemoveSkillSubcommand(skillsCommand)
+  registerPublishSkillSubcommand(skillsCommand)
+}

package/src/commands/skills/remove-command.ts

@@ -0,0 +1,102 @@
+import { Option } from 'commander'
+import type { Command } from 'commander'
+
+import type { ConfigSource } from '@oneworks/config'
+import { updateConfigFile } from '@oneworks/config'
+import { normalizeProjectSkillInstall, removeProjectSkill, resolveConfiguredSkillInstalls } from '@oneworks/utils'
+
+import { resolveCliWorkspaceCwd } from '#~/workspace.js'
+
+import {
+  buildGeneralSkillsUpdateValue,
+  exitWithError,
+  getRawSourceConfig,
+  loadSkillsConfigState,
+  matchesSkillSelector,
+  normalizeString,
+  printResult,
+  resolveInstalledSkillDirNames
+} from './shared'
+import { CONFIG_REMOVE_SOURCES } from './types'
+import type { SkillsRemoveOptions } from './types'
+
+export const registerRemoveSkillSubcommand = (skillsCommand: Command) => {
+  skillsCommand
+    .command('remove <skill>')
+    .description('Remove a configured project skill and delete the local installed directory')
+    .addOption(
+      new Option('--config-source <source>', 'Config source(s) to update').choices([...CONFIG_REMOVE_SOURCES]).default(
+        'all'
+      )
+    )
+    .option('--keep-files', 'Only update config and keep local installed files', false)
+    .option('--json', 'Print JSON output', false)
+    .action(async (skill: string, opts: SkillsRemoveOptions) => {
+      try {
+        const workspaceFolder = resolveCliWorkspaceCwd()
+        const state = await loadSkillsConfigState(workspaceFolder)
+        const selector = normalizeString(skill)
+        if (selector == null) {
+          throw new Error('Skill selector is required.')
+        }
+
+        const removedConfigSources: string[] = []
+        const removedDirNames = new Set<string>()
+        const sources: ConfigSource[] = opts.configSource === 'all'
+          ? ['global', 'project', 'user']
+          : [opts.configSource ?? 'project']
+
+        for (const source of sources) {
+          const sourceConfig = getRawSourceConfig(state, source)
+          const configured = resolveConfiguredSkillInstalls(sourceConfig?.skills)
+          const remaining = configured.filter(item => !matchesSkillSelector(selector, item))
+          const matched = configured.filter(item => matchesSkillSelector(selector, item))
+          if (matched.length === 0) continue
+
+          for (const item of matched) {
+            const normalized = normalizeProjectSkillInstall(item)
+            if (normalized != null) {
+              removedDirNames.add(normalized.targetDirName)
+            }
+          }
+
+          await updateConfigFile({
+            workspaceFolder,
+            source,
+            section: 'general',
+            value: buildGeneralSkillsUpdateValue(sourceConfig, remaining)
+          })
+          removedConfigSources.push(source)
+        }
+
+        const installedDirNames = await resolveInstalledSkillDirNames(workspaceFolder, selector)
+        for (const dirName of installedDirNames) {
+          removedDirNames.add(dirName)
+        }
+
+        const removedDirs = opts.keepFiles === true
+          ? []
+          : await Promise.all(
+            Array.from(removedDirNames).map(dirName =>
+              removeProjectSkill({
+                dirName,
+                workspaceFolder
+              })
+            )
+          )
+
+        if (removedConfigSources.length === 0 && removedDirs.length === 0) {
+          throw new Error(`No configured or installed skill matched "${selector}".`)
+        }
+
+        printResult({
+          action: 'remove',
+          removedConfigSources,
+          removedDirs: removedDirs.map(item => item.installDir),
+          workspaceFolder
+        }, opts.json)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+}

package/src/commands/skills/shared.ts

@@ -0,0 +1,117 @@
+import { access } from 'node:fs/promises'
+import process from 'node:process'
+
+import type { ConfigSource } from '@oneworks/config'
+import { buildConfigJsonVariables, loadConfigState } from '@oneworks/config'
+import type { Config, ConfiguredSkillInstallConfig } from '@oneworks/types'
+import {
+  buildSkillsConfigValue,
+  isSameDeclaredSkill,
+  matchesDeclaredSkillSelector,
+  readProjectSkills,
+  toSkillSlug
+} from '@oneworks/utils'
+
+const normalizeString = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
+)
+
+const pathExists = async (targetPath: string) => {
+  try {
+    await access(targetPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const printResult = (value: unknown, json = false) => {
+  if (json) {
+    console.log(JSON.stringify(
+      value != null && typeof value === 'object' && !Array.isArray(value)
+        ? { ok: true, ...(value as Record<string, unknown>) }
+        : { ok: true, value },
+      null,
+      2
+    ))
+    return
+  }
+
+  if (typeof value === 'string') {
+    console.log(value)
+    return
+  }
+
+  console.log(JSON.stringify(value, null, 2))
+}
+
+export const exitWithError = (error: unknown, json = false): never => {
+  const message = error instanceof Error ? error.message : String(error)
+  if (json) {
+    console.error(JSON.stringify({ ok: false, error: message }, null, 2))
+  } else {
+    console.error(message)
+  }
+  process.exit(1)
+}
+
+export const loadSkillsConfigState = async (cwd: string) => (
+  await loadConfigState({
+    cwd,
+    jsonVariables: buildConfigJsonVariables(cwd, process.env)
+  })
+)
+
+export const getResolvedSourceConfig = (
+  state: Awaited<ReturnType<typeof loadSkillsConfigState>>,
+  source: ConfigSource
+) => {
+  switch (source) {
+    case 'global':
+      return state.globalConfig
+    case 'project':
+      return state.projectSource?.resolvedConfig
+    case 'user':
+      return state.userConfig
+  }
+}
+
+export const getRawSourceConfig = (state: Awaited<ReturnType<typeof loadSkillsConfigState>>, source: ConfigSource) => {
+  switch (source) {
+    case 'global':
+      return state.globalSource?.rawConfig
+    case 'project':
+      return state.projectSource?.rawConfig
+    case 'user':
+      return state.userSource?.rawConfig
+  }
+}
+
+export const buildGeneralSkillsUpdateValue = (
+  sourceConfig: Config | undefined,
+  nextSkills: Array<string | ConfiguredSkillInstallConfig>
+) => {
+  const value: Record<string, unknown> = {
+    skills: buildSkillsConfigValue({
+      items: nextSkills,
+      current: sourceConfig?.skills
+    })
+  }
+  return value
+}
+
+export const resolveInstalledSkillDirNames = async (workspaceFolder: string, selector: string) => {
+  const trimmedSelector = selector.trim()
+  const selectorSlug = toSkillSlug(trimmedSelector)
+  const skills = await readProjectSkills(workspaceFolder)
+  return skills
+    .filter(skill => (
+      skill.dirName === trimmedSelector ||
+      skill.name === trimmedSelector ||
+      skill.dirName === selectorSlug ||
+      toSkillSlug(skill.name) === selectorSlug
+    ))
+    .map(skill => skill.dirName)
+}
+
+export { isSameDeclaredSkill, matchesDeclaredSkillSelector as matchesSkillSelector, normalizeString, pathExists }