@oneworks/cli 0.1.0-alpha.0

package/src/commands/clear.ts

@@ -0,0 +1,140 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import process from 'node:process'
+
+import {
+  mergeProcessEnvWithProjectEnv,
+  resolveLegacyProjectHomeSegmentPaths,
+  resolveProjectHomePath,
+  resolveProjectOoBaseDirName,
+  resolveProjectOoPath
+} from '@oneworks/utils'
+import type { Command } from 'commander'
+import fg from 'fast-glob'
+
+const CLEAR_PROJECT_HOME_TARGETS = [
+  'logs',
+  'caches'
+] as const
+
+const CLEAR_MOCK_TARGETS = [
+  '.mock/.claude/debug',
+  '.mock/.claude/todos',
+  '.mock/.claude/session-env',
+  '.mock/.claude/projects',
+  '.mock/.claude-core-router/logs',
+  '.mock/.claude-code-router/logs'
+] as const
+
+const BENCHMARK_LOG_PATTERNS = [
+  'benchmarks/specs/**/logs',
+  'benchmarks/entities/**/logs',
+  'benchmarks/cases/**/logs'
+] as const
+
+const CLAUDE_CODE_ROUTER_LOG_FILE_PATTERNS = [
+  '.claude-code-router/*.log',
+  '.claude-code-router/*.log.*'
+] as const
+
+const CLAUDE_CODE_ROUTER_SESSION_LOG_PATTERN = '.claude-code-router/*/logs'
+
+export interface RunClearCommandOptions {
+  cwd?: string
+}
+
+const resolveSegmentTargetDirs = (
+  cwd: string,
+  env: NodeJS.ProcessEnv,
+  segment: 'logs' | 'caches' | '.mock'
+) => {
+  const paths = resolveLegacyProjectHomeSegmentPaths(cwd, env, segment)
+  return [
+    paths.targetDir,
+    ...paths.sourceDirs
+  ]
+}
+
+const resolveMockTargetDirs = (cwd: string, env: NodeJS.ProcessEnv, target: string) => {
+  const mockRelativePath = target.replace(/^\.mock\//u, '')
+  return resolveSegmentTargetDirs(cwd, env, '.mock')
+    .map(mockRoot => path.resolve(mockRoot, ...mockRelativePath.split('/')))
+}
+
+async function collectClearTargets(cwd: string, env: NodeJS.ProcessEnv) {
+  const aiBaseDir = resolveProjectOoPath(cwd, env)
+  const logsDir = resolveProjectOoPath(cwd, env, 'logs')
+  const mockHomeDirs = resolveSegmentTargetDirs(cwd, env, '.mock')
+  const benchmarkLogDirs = await fg([...BENCHMARK_LOG_PATTERNS], {
+    cwd: aiBaseDir,
+    onlyDirectories: true,
+    deep: 10,
+    absolute: true
+  })
+
+  const claudeCodeRouterSessionLogDirs = (
+    await Promise.all(mockHomeDirs.map(mockHomeDir =>
+      fg(CLAUDE_CODE_ROUTER_SESSION_LOG_PATTERN, {
+        cwd: mockHomeDir,
+        onlyDirectories: true,
+        deep: 2,
+        absolute: true
+      })
+    ))
+  ).flat()
+
+  const claudeCodeRouterLogFiles = (
+    await Promise.all(mockHomeDirs.map(mockHomeDir =>
+      fg([...CLAUDE_CODE_ROUTER_LOG_FILE_PATTERNS], {
+        cwd: mockHomeDir,
+        onlyFiles: true,
+        deep: 1,
+        absolute: true
+      })
+    ))
+  ).flat()
+
+  return [
+    path.resolve(cwd, '.logs'),
+    ...CLEAR_PROJECT_HOME_TARGETS.flatMap(target => resolveSegmentTargetDirs(cwd, env, target)),
+    ...CLEAR_MOCK_TARGETS.flatMap(target => resolveMockTargetDirs(cwd, env, target)),
+    ...benchmarkLogDirs.filter(dir => dir !== logsDir && !dir.startsWith(`${logsDir}${path.sep}`)),
+    ...claudeCodeRouterSessionLogDirs.map(dir => path.dirname(dir)),
+    ...claudeCodeRouterLogFiles
+  ]
+}
+
+export async function runClearCommand(options: RunClearCommandOptions = {}) {
+  const cwd = options.cwd ?? process.cwd()
+  const env = mergeProcessEnvWithProjectEnv(undefined, { workspaceFolder: cwd })
+  const targets = Array.from(new Set(await collectClearTargets(cwd, env)))
+
+  await Promise.all(
+    targets.map(target => fs.rm(target, { force: true, recursive: true }))
+  )
+
+  await Promise.all([
+    fs.mkdir(resolveProjectOoPath(cwd, env, 'logs'), { recursive: true }),
+    fs.mkdir(resolveProjectOoPath(cwd, env, 'caches'), { recursive: true })
+  ])
+
+  await Promise.all([
+    fs.writeFile(resolveProjectOoPath(cwd, env, 'logs', '.gitkeep'), ''),
+    fs.writeFile(resolveProjectOoPath(cwd, env, 'caches', '.gitkeep'), '')
+  ])
+
+  console.log(
+    `Clear logs and cache successfully (${resolveProjectOoBaseDirName(env)} assets, ${
+      resolveProjectHomePath(cwd, env)
+    } runtime data)`
+  )
+}
+
+export function registerClearCommand(program: Command) {
+  program
+    .command('clear')
+    .description('Clear logs and cache of sub-agents')
+    .action(async () => {
+      await runClearCommand()
+    })
+}

package/src/commands/config/actions.ts

@@ -0,0 +1,196 @@
+import process from 'node:process'
+
+import {
+  getConfigSectionValueAtPath,
+  hasConfigSectionValue,
+  parseConfigSectionPath,
+  resolveConfigSectionPath,
+  setConfigSectionValueAtPath,
+  unsetConfigSectionValueAtPath,
+  updateConfigFile,
+  validateConfigSection
+} from '@oneworks/config'
+
+import { resolveReadableConfigValue } from './display-state'
+import { resolveSetPathInput, resolveSetValueInput, resolveWritableSource } from './interactive'
+import { resolveReadState } from './read-state'
+import { resolveClearedSectionValue, resolveListOutput, resolveTextListRows } from './section-state'
+import {
+  assertWritableConfigSection,
+  formatDisplayValue,
+  formatValidationIssues,
+  loadCommandState,
+  parseConfigValueInput,
+  printJsonResult,
+  resolveSourceSections
+} from './shared'
+import type { ConfigGetOptions, ConfigListOptions, ConfigSetOptions, ConfigUnsetOptions } from './shared'
+
+export const runListCommand = async (pathInput: string | undefined, opts: ConfigListOptions) => {
+  const source = opts.source ?? 'merged'
+  if (pathInput != null && pathInput.trim() !== '') {
+    const resolved = await resolveReadState(pathInput, source === 'all' ? 'merged' : source)
+    if (opts.json) {
+      printJsonResult({
+        ok: true,
+        workspaceFolder: resolved.cwd,
+        source: resolved.source,
+        path: resolved.resolvedPath?.normalizedPath ?? null,
+        section: resolved.resolvedPath?.section ?? null,
+        value: resolved.value
+      })
+      return
+    }
+    process.stdout.write(formatDisplayValue(resolveReadableConfigValue(resolved)))
+    return
+  }
+
+  const cwd = process.cwd()
+  const state = await loadCommandState(cwd)
+  if (opts.json) {
+    const output = {
+      ok: true,
+      workspaceFolder: cwd,
+      sections: resolveListOutput(state, source)
+    } as const
+    printJsonResult(
+      source === 'all'
+        ? {
+          ...output,
+          present: state.present
+        }
+        : output
+    )
+    return
+  }
+  console.log(`Workspace: ${cwd}`)
+  console.log(
+    `Config present: global=${state.present.global ? 'yes' : 'no'}, project=${
+      state.present.project ? 'yes' : 'no'
+    }, local=${state.present.user ? 'yes' : 'no'}`
+  )
+  console.table(resolveTextListRows(state, source))
+  console.log('Examples:')
+  console.log('  oneworks config get general.defaultModel')
+  console.log('  oneworks config set general.defaultModel gpt-5.4 --type string')
+}
+
+export const runGetCommand = async (pathInput: string | undefined, opts: ConfigGetOptions) => {
+  const resolved = await resolveReadState(pathInput, opts.source)
+  if (opts.json) {
+    printJsonResult({
+      ok: true,
+      workspaceFolder: resolved.cwd,
+      source: resolved.source,
+      path: resolved.resolvedPath?.normalizedPath ?? null,
+      section: resolved.resolvedPath?.section ?? null,
+      value: resolved.value
+    })
+    return
+  }
+  process.stdout.write(formatDisplayValue(resolveReadableConfigValue(resolved)))
+}
+
+export const runSetCommand = async (
+  pathInput: string | undefined,
+  valueInput: string | undefined,
+  opts: ConfigSetOptions
+) => {
+  const cwd = process.cwd()
+  const source = await resolveWritableSource(opts.source, opts.json)
+  const path = await resolveSetPathInput(pathInput, opts.json)
+  const type = opts.type ?? 'auto'
+  const rawValue = await resolveSetValueInput(valueInput, type, opts.json)
+  const nextValue = parseConfigValueInput(rawValue, type)
+  const resolvedPath = resolveConfigSectionPath(parseConfigSectionPath(path))
+  assertWritableConfigSection(source, resolvedPath.section)
+  const state = await loadCommandState(cwd)
+  const updatedSections = setConfigSectionValueAtPath(
+    resolveSourceSections(state, source),
+    resolvedPath,
+    nextValue
+  )
+  const sectionValue = updatedSections[resolvedPath.section]
+  const parsed = await validateConfigSection(resolvedPath.section, sectionValue, { cwd })
+  if (!parsed.success) {
+    throw new Error(`Invalid config value for ${resolvedPath.section}:\n${formatValidationIssues(parsed.error)}`)
+  }
+
+  const result = await updateConfigFile({
+    workspaceFolder: cwd,
+    source,
+    section: resolvedPath.section,
+    value: parsed.data
+  })
+
+  const updatedValue = getConfigSectionValueAtPath(updatedSections, resolvedPath).value
+  if (opts.json) {
+    printJsonResult({
+      ok: true,
+      workspaceFolder: cwd,
+      source,
+      path: resolvedPath.normalizedPath,
+      section: resolvedPath.section,
+      configPath: result.configPath,
+      value: updatedValue
+    })
+    return
+  }
+
+  console.log(`Updated ${resolvedPath.normalizedPath} in ${source} config.`)
+  console.log(`File: ${result.configPath}`)
+  process.stdout.write(formatDisplayValue(updatedValue))
+}
+
+export const runUnsetCommand = async (
+  pathInput: string | undefined,
+  opts: ConfigUnsetOptions
+) => {
+  const cwd = process.cwd()
+  const source = await resolveWritableSource(opts.source, opts.json)
+  const path = await resolveSetPathInput(pathInput, opts.json)
+  const resolvedPath = resolveConfigSectionPath(parseConfigSectionPath(path))
+  assertWritableConfigSection(source, resolvedPath.section)
+  const state = await loadCommandState(cwd)
+  const currentSections = resolveSourceSections(state, source)
+  const currentValue = getConfigSectionValueAtPath(currentSections, resolvedPath)
+  if (!currentValue.exists || (resolvedPath.sectionPath.length === 0 && !hasConfigSectionValue(currentValue.value))) {
+    throw new Error(`Config path "${resolvedPath.normalizedPath}" was not found in ${source} config.`)
+  }
+
+  const updatedSections = resolvedPath.sectionPath.length === 0
+    ? {
+      ...currentSections,
+      [resolvedPath.section]: resolveClearedSectionValue(resolvedPath.section)
+    }
+    : unsetConfigSectionValueAtPath(currentSections, resolvedPath)
+
+  const sectionValue = updatedSections[resolvedPath.section]
+  const parsed = await validateConfigSection(resolvedPath.section, sectionValue, { cwd })
+  if (!parsed.success) {
+    throw new Error(`Invalid config value for ${resolvedPath.section}:\n${formatValidationIssues(parsed.error)}`)
+  }
+
+  const result = await updateConfigFile({
+    workspaceFolder: cwd,
+    source,
+    section: resolvedPath.section,
+    value: parsed.data
+  })
+
+  if (opts.json) {
+    printJsonResult({
+      ok: true,
+      workspaceFolder: cwd,
+      source,
+      path: resolvedPath.normalizedPath,
+      section: resolvedPath.section,
+      configPath: result.configPath,
+      removed: true
+    })
+    return
+  }
+
+  console.log(`Removed ${resolvedPath.normalizedPath} from ${source} config.`)
+  console.log(`File: ${result.configPath}`)
+}

package/src/commands/config/display-state.ts

@@ -0,0 +1,108 @@
+import type { ModelMetadataConfig, ModelServiceConfig } from '@oneworks/types'
+
+import type { ResolvedReadState } from './read-state'
+
+const isRecord = (value: unknown): value is Record<string, unknown> => (
+  value != null &&
+  typeof value === 'object' &&
+  !Array.isArray(value)
+)
+
+const asModelMetadataRecord = (value: unknown): Record<string, ModelMetadataConfig> => (
+  isRecord(value) ? value as Record<string, ModelMetadataConfig> : {}
+)
+
+const asModelServiceRecord = (value: unknown): Record<string, ModelServiceConfig> => (
+  isRecord(value) ? value as Record<string, ModelServiceConfig> : {}
+)
+
+const resolveModelDisplayMetadata = (params: {
+  selector: string
+  serviceKey: string
+  model: string
+  modelMetadata: Record<string, ModelMetadataConfig>
+}) => {
+  const merged = {
+    ...(params.modelMetadata[params.serviceKey] ?? {}),
+    ...(params.modelMetadata[params.model] ?? {}),
+    ...(params.modelMetadata[params.selector] ?? {})
+  }
+
+  return Object.keys(merged).length === 0 ? undefined : merged
+}
+
+const buildModelsDisplayValue = (params: {
+  modelMetadata: Record<string, ModelMetadataConfig>
+  modelServices: Record<string, ModelServiceConfig>
+}) => {
+  const consumedMetadataKeys = new Set<string>()
+
+  const services = Object.fromEntries(
+    Object.entries(params.modelServices).flatMap(([serviceKey, serviceValue]) => {
+      const models = Array.isArray(serviceValue?.models)
+        ? serviceValue.models.filter((model): model is string => typeof model === 'string' && model.trim() !== '')
+        : []
+
+      if (models.length === 0) {
+        return []
+      }
+
+      const entries = Object.fromEntries(
+        models.map((model) => {
+          const selector = `${serviceKey},${model}`
+          const metadata = resolveModelDisplayMetadata({
+            selector,
+            serviceKey,
+            model,
+            modelMetadata: params.modelMetadata
+          })
+
+          consumedMetadataKeys.add(serviceKey)
+          consumedMetadataKeys.add(model)
+          consumedMetadataKeys.add(selector)
+
+          return [
+            model,
+            metadata == null
+              ? {
+                selector
+              }
+              : {
+                selector,
+                ...metadata
+              }
+          ]
+        })
+      )
+
+      return [[serviceKey, entries]]
+    })
+  )
+
+  if (Object.keys(services).length === 0) {
+    return params.modelMetadata
+  }
+
+  const remainingMetadata = Object.fromEntries(
+    Object.entries(params.modelMetadata)
+      .filter(([key]) => !consumedMetadataKeys.has(key))
+  )
+
+  return Object.keys(remainingMetadata).length === 0
+    ? services
+    : {
+      services,
+      metadata: remainingMetadata
+    }
+}
+
+export const resolveReadableConfigValue = (resolved: ResolvedReadState) => {
+  if (resolved.resolvedPath?.section !== 'models' || resolved.resolvedPath.sectionPath.length > 0) {
+    return resolved.value
+  }
+
+  return buildModelsDisplayValue({
+    modelMetadata: asModelMetadataRecord(resolved.state.sections[resolved.source].models),
+    modelServices: asModelServiceRecord(resolved.state.sections[resolved.source].modelServices)
+  })
+}

package/src/commands/config/index.ts

@@ -0,0 +1,135 @@
+import process from 'node:process'
+
+import { Option } from 'commander'
+import type { Command } from 'commander'
+
+import { runGetCommand, runListCommand, runSetCommand, runUnsetCommand } from './actions'
+import {
+  CONFIG_LIST_SOURCES,
+  CONFIG_READ_SOURCES,
+  CONFIG_SET_SOURCES,
+  CONFIG_VALUE_TYPES,
+  formatErrorMessage
+} from './shared'
+import type { ConfigGetOptions, ConfigListOptions, ConfigSetOptions, ConfigUnsetOptions } from './shared'
+
+const exitWithError = (error: unknown, json = false): never => {
+  const message = formatErrorMessage(error)
+  if (json) {
+    console.error(JSON.stringify({ ok: false, error: message }, null, 2))
+  } else {
+    console.error(message)
+  }
+  process.exit(1)
+}
+
+export function registerConfigCommand(program: Command) {
+  const configCommand = program
+    .command('config')
+    .description('Inspect and update workspace config files')
+
+  configCommand
+    .command('list [path]')
+    .description('List config sections or show a config subtree')
+    .addOption(
+      new Option('--source <source>', 'List a single source instead of all sources')
+        .choices([...CONFIG_LIST_SOURCES])
+    )
+    .option('--json', 'Print JSON output', false)
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks config list
+  oneworks config list models --json
+  oneworks config list adapters.codex --source project
+  oneworks config list --source all
+`
+    )
+    .action(async (path: string | undefined, opts: ConfigListOptions) => {
+      try {
+        await runListCommand(path, opts)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+
+  configCommand
+    .command('get [path]')
+    .description('Read a config section or a nested config value')
+    .addOption(
+      new Option('--source <source>', 'Read from a specific config source')
+        .choices([...CONFIG_READ_SOURCES])
+    )
+    .option('--json', 'Print JSON output', false)
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks config get general.defaultModel
+  oneworks config get permissions.allow --source project
+  oneworks config get '["models","gpt-4.1","title"]' --source merged --json
+`
+    )
+    .action(async (path: string | undefined, opts: ConfigGetOptions) => {
+      try {
+        await runGetCommand(path, opts)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+
+  configCommand
+    .command('set [path] [value]')
+    .description('Update a config section or nested config value')
+    .addOption(
+      new Option('--source <source>', 'Write to a specific config source')
+        .choices([...CONFIG_SET_SOURCES])
+    )
+    .addOption(
+      new Option('--type <type>', 'How to parse the provided value')
+        .choices([...CONFIG_VALUE_TYPES])
+    )
+    .option('--json', 'Print JSON output', false)
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks config set general.defaultModel gpt-5.4 --type string
+  oneworks config set general.permissions '{"allow":["Read"]}' --type json
+  echo '{"args":["--port","3000"]}' | oneworks config set mcp.mcpServers.docs --type json --json
+`
+    )
+    .action(async (path: string | undefined, value: string | undefined, opts: ConfigSetOptions) => {
+      try {
+        await runSetCommand(path, value, opts)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+
+  configCommand
+    .command('unset [path]')
+    .description('Remove a config section or nested config value')
+    .addOption(
+      new Option('--source <source>', 'Write to a specific config source')
+        .choices([...CONFIG_SET_SOURCES])
+    )
+    .option('--json', 'Print JSON output', false)
+    .addHelpText(
+      'after',
+      `
+Examples:
+  oneworks config unset general.defaultModel
+  oneworks config unset general.permissions.allow --source project
+  oneworks config unset plugins --source user --json
+`
+    )
+    .action(async (path: string | undefined, opts: ConfigUnsetOptions) => {
+      try {
+        await runUnsetCommand(path, opts)
+      } catch (error) {
+        exitWithError(error, opts.json)
+      }
+    })
+}

package/src/commands/config/interactive.ts

@@ -0,0 +1,121 @@
+import process from 'node:process'
+import { createInterface } from 'node:readline/promises'
+
+import type { ConfigSource } from '@oneworks/types'
+
+import { CONFIG_SET_SOURCES, isInteractiveTerminal } from './shared'
+import type { ConfigValueType } from './shared'
+
+const readAllStdin = async () =>
+  await new Promise<string>((resolve, reject) => {
+    const chunks: string[] = []
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', chunk => chunks.push(String(chunk)))
+    process.stdin.once('end', () => resolve(chunks.join('')))
+    process.stdin.once('error', reject)
+  })
+
+const promptSelect = async <TValue extends string>(params: {
+  question: string
+  choices: readonly TValue[]
+  defaultValue: TValue
+}) => {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  try {
+    while (true) {
+      console.log(params.choices.map((choice, index) => `  ${index + 1}. ${choice}`).join('\n'))
+      const answer = (await rl.question(`${params.question} [${params.defaultValue}]: `)).trim()
+      if (answer === '') {
+        return params.defaultValue
+      }
+
+      const matchedChoice = params.choices.find(choice => choice === answer)
+      if (matchedChoice != null) {
+        return matchedChoice
+      }
+
+      const index = Number.parseInt(answer, 10)
+      if (Number.isInteger(index) && index >= 1 && index <= params.choices.length) {
+        return params.choices[index - 1]!
+      }
+
+      console.log('Please choose one of the listed values.')
+    }
+  } finally {
+    rl.close()
+  }
+}
+
+const promptText = async (question: string) => {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  try {
+    return (await rl.question(question)).trim()
+  } finally {
+    rl.close()
+  }
+}
+
+export const resolveWritableSource = async (
+  source: ConfigSource | undefined,
+  json: boolean | undefined
+) => {
+  if (source != null) return source
+  if (json || !isInteractiveTerminal()) return 'project'
+
+  return await promptSelect({
+    question: 'Write target',
+    choices: CONFIG_SET_SOURCES,
+    defaultValue: 'project'
+  })
+}
+
+export const resolveSetPathInput = async (
+  pathInput: string | undefined,
+  json: boolean | undefined
+) => {
+  if (pathInput != null) return pathInput
+  if (json || !isInteractiveTerminal()) {
+    throw new TypeError('Config path is required for set.')
+  }
+
+  const prompted = await promptText(
+    'Config path (examples: general.defaultModel, general.permissions, ["models","gpt-4.1","title"]): '
+  )
+  if (prompted === '') {
+    throw new TypeError('Config path is required for set.')
+  }
+  return prompted
+}
+
+export const resolveSetValueInput = async (
+  valueInput: string | undefined,
+  type: ConfigValueType,
+  json: boolean | undefined
+) => {
+  if (valueInput != null) return valueInput
+
+  if (!process.stdin.isTTY) {
+    const stdinValue = await readAllStdin()
+    if (stdinValue !== '') {
+      return stdinValue
+    }
+  }
+
+  if (type === 'null') {
+    return undefined
+  }
+
+  if (json || !isInteractiveTerminal()) {
+    throw new TypeError('Config value is required. Pass it as an argument or pipe it via stdin.')
+  }
+
+  return await promptText(`Config value (${type === 'auto' ? 'auto' : type} parse mode): `)
+}