@antseed/cli 0.1.0 → 0.1.2

package/src/cli/commands/plugin-create.test.ts

@@ -1,60 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-import { mkdtemp, readFile, rm } from 'node:fs/promises'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { scaffoldPlugin } from './plugin-create.js'
-
-test('scaffoldPlugin creates provider project structure', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'antseed-test-'))
-  try {
-    await scaffoldPlugin(dir, {
-      name: 'test-provider',
-      type: 'provider',
-      displayName: 'Test Provider',
-      description: 'A test provider plugin',
-    })
-
-    const pkg = JSON.parse(await readFile(join(dir, 'package.json'), 'utf-8')) as { name: string }
-    assert.equal(pkg.name, '@antseed/provider-test-provider')
-
-    const tsconfig = await readFile(join(dir, 'tsconfig.json'), 'utf-8')
-    assert.ok(tsconfig.includes('NodeNext'))
-
-    const index = await readFile(join(dir, 'src', 'index.ts'), 'utf-8')
-    assert.ok(index.includes("type: 'provider'"))
-    assert.ok(index.includes('AntseedProviderPlugin'))
-
-    const provider = await readFile(join(dir, 'src', 'provider.ts'), 'utf-8')
-    assert.ok(provider.includes('createProvider'))
-
-    const testFile = await readFile(join(dir, 'src', 'index.test.ts'), 'utf-8')
-    assert.ok(testFile.includes("'provider'"))
-
-    const readme = await readFile(join(dir, 'README.md'), 'utf-8')
-    assert.ok(readme.includes('test-provider'))
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})
-
-test('scaffoldPlugin creates router project structure', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'antseed-test-'))
-  try {
-    await scaffoldPlugin(dir, {
-      name: 'test-router',
-      type: 'router',
-      displayName: 'Test Router',
-      description: 'A test router plugin',
-    })
-
-    const index = await readFile(join(dir, 'src', 'index.ts'), 'utf-8')
-    assert.ok(index.includes("type: 'router'"))
-    assert.ok(index.includes('AntseedRouterPlugin'))
-
-    const router = await readFile(join(dir, 'src', 'router.ts'), 'utf-8')
-    assert.ok(router.includes('createRouter'))
-  } finally {
-    await rm(dir, { recursive: true, force: true })
-  }
-})

package/src/cli/commands/plugin-create.ts

@@ -1,230 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import { createInterface } from 'node:readline/promises'
-import { mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-
-interface PluginScaffoldOptions {
-  name: string
-  type: 'provider' | 'router'
-  displayName: string
-  description: string
-}
-
-function generatePackageJson(opts: PluginScaffoldOptions): string {
-  return JSON.stringify(
-    {
-      name: `@antseed/${opts.type}-${opts.name}`,
-      version: '0.1.0',
-      description: opts.description,
-      type: 'module',
-      main: 'dist/index.js',
-      types: 'dist/index.d.ts',
-      scripts: {
-        build: 'tsc',
-        test: 'node --test dist/**/*.test.js',
-        prepublishOnly: 'npm run build',
-      },
-      keywords: ['antseed', 'plugin', opts.type],
-      peerDependencies: {
-        '@antseed/node': '>=0.1.0',
-      },
-      devDependencies: {
-        '@antseed/node': 'workspace:*',
-        '@types/node': '^20.11.0',
-        typescript: '^5.3.0',
-      },
-    },
-    null,
-    2,
-  )
-}
-
-function generateTsconfig(): string {
-  return JSON.stringify(
-    {
-      compilerOptions: {
-        target: 'ES2022',
-        module: 'NodeNext',
-        moduleResolution: 'NodeNext',
-        outDir: 'dist',
-        rootDir: 'src',
-        strict: true,
-        esModuleInterop: true,
-        skipLibCheck: true,
-        declaration: true,
-        sourceMap: true,
-      },
-      include: ['src/**/*.ts'],
-      exclude: ['node_modules', 'dist'],
-    },
-    null,
-    2,
-  )
-}
-
-function generateIndexTs(opts: PluginScaffoldOptions): string {
-  const importType = opts.type === 'provider' ? 'AntseedProviderPlugin' : 'AntseedRouterPlugin'
-  const methodImport = opts.type === 'provider'
-    ? `import { createProvider } from './${opts.type}.js'`
-    : `import { createRouter } from './${opts.type}.js'`
-  const method = opts.type === 'provider' ? 'createProvider' : 'createRouter'
-
-  return `import type { ${importType}, ConfigField } from '@antseed/node'
-${methodImport}
-
-const configSchema: ConfigField[] = [
-  // Define your plugin's configuration fields here
-  // { key: 'API_KEY', label: 'API Key', type: 'secret', required: true, description: 'Your API key' },
-]
-
-const plugin: ${importType} = {
-  name: '${opts.name}',
-  displayName: '${opts.displayName}',
-  version: '0.1.0',
-  description: '${opts.description}',
-  type: '${opts.type}',
-  configSchema,
-  ${method},
-}
-
-export default plugin
-`
-}
-
-function generateProviderTs(opts: PluginScaffoldOptions): string {
-  return `import type { Provider, SerializedHttpRequest, SerializedHttpResponse } from '@antseed/node'
-
-export function createProvider(config: Record<string, string>): Provider {
-  return {
-    name: '${opts.name}',
-    models: [],
-    pricing: {
-      defaults: { inputUsdPerMillion: 0, outputUsdPerMillion: 0 },
-    },
-    maxConcurrency: 1,
-    async handleRequest(req: SerializedHttpRequest): Promise<SerializedHttpResponse> {
-      // Implement your provider logic here
-      throw new Error('Not implemented')
-    },
-    getCapacity() {
-      return { current: 0, max: 1 }
-    },
-  }
-}
-`
-}
-
-function generateRouterTs(_opts: PluginScaffoldOptions): string {
-  return `import type { Router, PeerInfo, SerializedHttpRequest } from '@antseed/node'
-
-export function createRouter(config: Record<string, string>): Router {
-  return {
-    selectPeer(req: SerializedHttpRequest, peers: PeerInfo[]): PeerInfo | null {
-      // Implement your router logic here
-      return peers[0] ?? null
-    },
-    onResult(peer: PeerInfo, result: { success: boolean; latencyMs: number; tokens: number }): void {
-      // Track peer performance here
-    },
-  }
-}
-`
-}
-
-function generateTestTs(opts: PluginScaffoldOptions): string {
-  return `import assert from 'node:assert/strict'
-import test from 'node:test'
-
-test('${opts.name} plugin exports valid manifest', async () => {
-  const { default: plugin } = await import('./index.js')
-  assert.equal(plugin.type, '${opts.type}')
-  assert.equal(plugin.name, '${opts.name}')
-  assert.ok(plugin.displayName)
-  assert.ok(plugin.version)
-  assert.ok(Array.isArray(plugin.configSchema))
-})
-`
-}
-
-function generateReadme(opts: PluginScaffoldOptions): string {
-  return `# antseed-${opts.type}-${opts.name}
-
-${opts.description}
-
-## Installation
-
-\`\`\`bash
-antseed plugin add antseed-${opts.type}-${opts.name}
-\`\`\`
-
-## Configuration
-
-Configure via interactive prompt:
-
-\`\`\`bash
-antseed plugin config <instance-id>
-\`\`\`
-
-## Development
-
-\`\`\`bash
-npm install
-npm run build
-npm test
-\`\`\`
-`
-}
-
-export async function scaffoldPlugin(dir: string, opts: PluginScaffoldOptions): Promise<void> {
-  await mkdir(join(dir, 'src'), { recursive: true })
-  await writeFile(join(dir, 'package.json'), generatePackageJson(opts), 'utf-8')
-  await writeFile(join(dir, 'tsconfig.json'), generateTsconfig(), 'utf-8')
-  await writeFile(join(dir, 'src', 'index.ts'), generateIndexTs(opts), 'utf-8')
-
-  if (opts.type === 'provider') {
-    await writeFile(join(dir, 'src', 'provider.ts'), generateProviderTs(opts), 'utf-8')
-  } else {
-    await writeFile(join(dir, 'src', 'router.ts'), generateRouterTs(opts), 'utf-8')
-  }
-
-  await writeFile(join(dir, 'src', 'index.test.ts'), generateTestTs(opts), 'utf-8')
-  await writeFile(join(dir, 'README.md'), generateReadme(opts), 'utf-8')
-}
-
-export function registerPluginCreateCommand(pluginCmd: Command): void {
-  pluginCmd
-    .command('create')
-    .description('Scaffold a new plugin project')
-    .action(async () => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout })
-      try {
-        const name = (await rl.question('Plugin name (lowercase, no spaces): ')).trim()
-        if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
-          console.log(chalk.red('Invalid plugin name. Use lowercase letters, numbers, and hyphens.'))
-          process.exit(1)
-        }
-
-        const typeAnswer = (await rl.question('Plugin type (provider/router): ')).trim()
-        if (typeAnswer !== 'provider' && typeAnswer !== 'router') {
-          console.log(chalk.red('Plugin type must be "provider" or "router".'))
-          process.exit(1)
-        }
-        const type = typeAnswer as 'provider' | 'router'
-
-        const displayName = (await rl.question('Display name: ')).trim() || name
-        const description = (await rl.question('Description: ')).trim() || `Antseed ${type} plugin`
-
-        const dir = join(process.cwd(), `antseed-${type}-${name}`)
-        await scaffoldPlugin(dir, { name, type, displayName, description })
-
-        console.log(chalk.green(`\nScaffolded plugin at: ${dir}`))
-        console.log(chalk.dim('\nNext steps:'))
-        console.log(chalk.dim(`  cd antseed-${type}-${name}`))
-        console.log(chalk.dim('  npm install'))
-        console.log(chalk.dim('  npm run build'))
-      } finally {
-        rl.close()
-      }
-    })
-}

package/src/cli/commands/plugin.test.ts

@@ -1,55 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-import { TRUSTED_PLUGINS } from '../../plugins/registry.js'
-import { buildPluginConfig, LEGACY_PACKAGE_MAP } from '../../plugins/loader.js'
-
-test('TRUSTED_PLUGINS contains 6 official plugins', () => {
-  assert.equal(TRUSTED_PLUGINS.length, 6)
-  const names = TRUSTED_PLUGINS.map(p => p.name)
-  assert.ok(names.includes('anthropic'))
-  assert.ok(names.includes('claude-code'))
-  assert.ok(names.includes('openrouter'))
-  assert.ok(names.includes('local-llm'))
-  assert.ok(names.includes('local-proxy'))
-  assert.ok(names.includes('local-chat'))
-})
-
-test('TRUSTED_PLUGINS all have scoped package names', () => {
-  for (const plugin of TRUSTED_PLUGINS) {
-    assert.ok(plugin.package.startsWith('@antseed/'), `${plugin.name} package should be scoped`)
-  }
-})
-
-test('buildPluginConfig uses priority: instanceConfig < env < overrides', () => {
-  const keys = [
-    { key: 'API_KEY', label: 'API Key', type: 'string' as const },
-    { key: 'MODEL', label: 'Model', type: 'string' as const },
-  ]
-  const instanceConfig = { API_KEY: 'from-instance', MODEL: 'from-instance' }
-  const original = process.env['API_KEY']
-  process.env['API_KEY'] = 'from-env'
-  try {
-    const result = buildPluginConfig(keys, { API_KEY: 'from-override' }, instanceConfig)
-    assert.equal(result['API_KEY'], 'from-override')
-    assert.equal(result['MODEL'], 'from-instance')
-  } finally {
-    if (original === undefined) {
-      delete process.env['API_KEY']
-    } else {
-      process.env['API_KEY'] = original
-    }
-  }
-})
-
-test('buildPluginConfig works without instanceConfig (backwards compatible)', () => {
-  const keys = [
-    { key: 'TEST_KEY_COMPAT', label: 'Test', type: 'string' as const },
-  ]
-  const result = buildPluginConfig(keys, { TEST_KEY_COMPAT: 'override' })
-  assert.equal(result['TEST_KEY_COMPAT'], 'override')
-})
-
-test('LEGACY_PACKAGE_MAP maps old names to scoped names', () => {
-  assert.equal(LEGACY_PACKAGE_MAP['antseed-provider-anthropic'], '@antseed/provider-claude-code')
-  assert.equal(LEGACY_PACKAGE_MAP['antseed-router-claude-code'], '@antseed/router-local-proxy')
-})

package/src/cli/commands/plugin.ts

@@ -1,295 +0,0 @@
-import type { Command } from 'commander'
-import chalk from 'chalk'
-import ora from 'ora'
-import { createInterface } from 'node:readline/promises'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
-import { installPlugin, removePlugin, listInstalledPlugins, getPluginsDir } from '../../plugins/manager.js'
-import { TRUSTED_PLUGINS } from '../../plugins/registry.js'
-import {
-  addInstance,
-  removeInstance,
-  getInstance,
-  getInstances,
-  updateInstanceConfig,
-  loadPluginModule,
-} from '@antseed/node'
-import type { ConfigField, AntseedPlugin } from '@antseed/node'
-import { registerPluginCreateCommand } from './plugin-create.js'
-
-const CONFIG_PATH = join(homedir(), '.antseed', 'config.json')
-
-function generateInstanceId(pluginName: string): string {
-  const suffix = Math.random().toString(36).slice(2, 8)
-  return `${pluginName}-${suffix}`
-}
-
-function getConfigSchema(plugin: AntseedPlugin): ConfigField[] {
-  return plugin.configSchema ?? plugin.configKeys ?? []
-}
-
-function maskSecret(value: string): string {
-  if (value.length <= 4) return '****'
-  return '****' + value.slice(-4)
-}
-
-async function promptForFields(
-  rl: ReturnType<typeof createInterface>,
-  schema: ConfigField[],
-  existingConfig?: Record<string, unknown>,
-): Promise<Record<string, unknown>> {
-  const config: Record<string, unknown> = {}
-  for (const field of schema) {
-    const defaultVal = existingConfig?.[field.key] ?? field.default
-    const defaultHint = field.type === 'secret' && typeof defaultVal === 'string' && defaultVal
-      ? ` [${maskSecret(defaultVal)}]`
-      : defaultVal !== undefined
-        ? ` [${String(defaultVal)}]`
-        : ''
-    const requiredHint = field.required ? ' (required)' : ''
-    const desc = field.description ? ` — ${field.description}` : ''
-    const prompt = `  ${field.label}${requiredHint}${desc}${defaultHint}: `
-
-    let answer: string
-    if (field.type === 'secret') {
-      process.stdout.write(prompt)
-      const stdin = process.stdin
-      const wasRaw = stdin.isRaw
-      if (stdin.isTTY) stdin.setRawMode(true)
-      let secret = ''
-      answer = await new Promise<string>((resolve) => {
-        const onData = (chunk: Buffer) => {
-          const ch = chunk.toString()
-          if (ch === '\n' || ch === '\r') {
-            stdin.removeListener('data', onData)
-            if (stdin.isTTY && wasRaw !== undefined) stdin.setRawMode(wasRaw)
-            process.stdout.write('\n')
-            resolve(secret)
-          } else if (ch === '\u007f' || ch === '\b') {
-            secret = secret.slice(0, -1)
-          } else if (ch === '\u0003') {
-            stdin.removeListener('data', onData)
-            if (stdin.isTTY && wasRaw !== undefined) stdin.setRawMode(wasRaw)
-            process.exit(0)
-          } else {
-            secret += ch
-          }
-        }
-        stdin.on('data', onData)
-      })
-    } else {
-      answer = await rl.question(prompt)
-    }
-
-    const trimmed = answer.trim()
-    if (trimmed) {
-      if (field.type === 'number') {
-        config[field.key] = Number(trimmed)
-      } else if (field.type === 'boolean') {
-        config[field.key] = trimmed === 'true' || trimmed === 'yes' || trimmed === '1'
-      } else {
-        config[field.key] = trimmed
-      }
-    } else if (defaultVal !== undefined) {
-      config[field.key] = defaultVal
-    } else if (field.required) {
-      console.log(chalk.red(`    ${field.label} is required.`))
-      // Re-prompt by recursing on just this field
-      const retry = await promptForFields(rl, [field], existingConfig)
-      config[field.key] = retry[field.key]!
-    }
-  }
-  return config
-}
-
-export function registerPluginCommand(program: Command): void {
-  const pluginCmd = program
-    .command('plugin')
-    .description('Manage antseed plugins')
-
-  // Task 1: plugin add with interactive config
-  pluginCmd
-    .command('add <package>')
-    .description('Install a plugin from npm and configure an instance')
-    .action(async (packageName: string) => {
-      const spinner = ora(`Installing ${packageName}...`).start()
-      try {
-        await installPlugin(packageName)
-        spinner.succeed(chalk.green(`Installed ${packageName}`))
-      } catch (err) {
-        spinner.fail(chalk.red(`Failed to install ${packageName}: ${(err as Error).message}`))
-        process.exit(1)
-      }
-
-      // Load plugin module to read configSchema
-      let plugin: AntseedPlugin
-      try {
-        plugin = await loadPluginModule(packageName, getPluginsDir())
-      } catch (err) {
-        console.log(chalk.yellow(`\nInstalled but could not load plugin module: ${(err as Error).message}`))
-        return
-      }
-
-      const schema = getConfigSchema(plugin)
-      if (schema.length === 0) {
-        console.log(chalk.dim('\nPlugin has no configuration fields.'))
-        const instanceId = generateInstanceId(plugin.name)
-        await addInstance(CONFIG_PATH, {
-          id: instanceId,
-          package: packageName,
-          type: plugin.type,
-          config: {},
-          enabled: true,
-          createdAt: new Date().toISOString(),
-        }, schema)
-        console.log(chalk.green(`\nCreated instance: ${instanceId}`))
-        return
-      }
-
-      console.log(chalk.bold(`\nConfigure ${plugin.displayName}:\n`))
-      const rl = createInterface({ input: process.stdin, output: process.stdout })
-      try {
-        const config = await promptForFields(rl, schema)
-        const instanceId = generateInstanceId(plugin.name)
-        await addInstance(CONFIG_PATH, {
-          id: instanceId,
-          package: packageName,
-          type: plugin.type,
-          config,
-          enabled: true,
-          createdAt: new Date().toISOString(),
-        }, schema)
-        console.log(chalk.green(`\nCreated instance: ${instanceId}`))
-      } finally {
-        rl.close()
-      }
-    })
-
-  // Task 2: plugin config command
-  pluginCmd
-    .command('config <id>')
-    .description('Update configuration for a plugin instance')
-    .action(async (instanceId: string) => {
-      const instance = await getInstance(CONFIG_PATH, instanceId)
-      if (!instance) {
-        console.log(chalk.red(`Instance "${instanceId}" not found.`))
-        process.exit(1)
-      }
-
-      let plugin: AntseedPlugin
-      try {
-        plugin = await loadPluginModule(instance.package, getPluginsDir())
-      } catch (err) {
-        console.log(chalk.red(`Could not load plugin: ${(err as Error).message}`))
-        process.exit(1)
-        return // unreachable but satisfies TS
-      }
-
-      const schema = getConfigSchema(plugin)
-      if (schema.length === 0) {
-        console.log(chalk.dim('Plugin has no configuration fields.'))
-        return
-      }
-
-      console.log(chalk.bold(`\nConfigure ${plugin.displayName} (${instanceId}):\n`))
-
-      // Show current values
-      for (const field of schema) {
-        const current = instance.config[field.key]
-        if (current !== undefined) {
-          const display = field.type === 'secret' ? maskSecret(String(current)) : String(current)
-          console.log(chalk.dim(`  Current ${field.label}: ${display}`))
-        }
-      }
-      console.log('')
-
-      const rl = createInterface({ input: process.stdin, output: process.stdout })
-      try {
-        const newConfig = await promptForFields(rl, schema, instance.config)
-        await updateInstanceConfig(CONFIG_PATH, instanceId, newConfig, schema)
-        console.log(chalk.green(`\nUpdated instance: ${instanceId}`))
-      } finally {
-        rl.close()
-      }
-    })
-
-  // Task 5: plugin remove with instance handling
-  pluginCmd
-    .command('remove <name>')
-    .description('Remove a plugin instance or uninstall a package')
-    .action(async (name: string) => {
-      // Check if name matches an instance ID
-      const instance = await getInstance(CONFIG_PATH, name)
-      if (instance) {
-        const rl = createInterface({ input: process.stdin, output: process.stdout })
-        try {
-          const confirm = await rl.question(`Remove instance "${name}"? (y/N): `)
-          if (confirm.trim().toLowerCase() !== 'y') {
-            console.log(chalk.dim('Cancelled.'))
-            return
-          }
-          await removeInstance(CONFIG_PATH, name)
-          console.log(chalk.green(`Removed instance: ${name}`))
-
-          const uninstall = await rl.question(`Also uninstall npm package "${instance.package}"? (y/N): `)
-          if (uninstall.trim().toLowerCase() === 'y') {
-            const spinner = ora(`Removing ${instance.package}...`).start()
-            try {
-              await removePlugin(instance.package)
-              spinner.succeed(chalk.green(`Uninstalled ${instance.package}`))
-            } catch (err) {
-              spinner.fail(chalk.red(`Failed to uninstall: ${(err as Error).message}`))
-            }
-          }
-        } finally {
-          rl.close()
-        }
-        return
-      }
-
-      // Fall through: treat as npm package name
-      const spinner = ora(`Removing ${name}...`).start()
-      try {
-        await removePlugin(name)
-        spinner.succeed(chalk.green(`Removed ${name}`))
-      } catch (err) {
-        spinner.fail(chalk.red(`Failed to remove ${name}: ${(err as Error).message}`))
-        process.exit(1)
-      }
-    })
-
-  // Task 4: plugin list with instances
-  pluginCmd
-    .command('list')
-    .description('List installed plugins and configured instances')
-    .action(async () => {
-      const installed = await listInstalledPlugins()
-      const trusted = new Set(TRUSTED_PLUGINS.map((p) => p.package))
-
-      if (installed.length === 0) {
-        console.log(chalk.dim('No plugins installed. Run: antseed init'))
-      } else {
-        console.log(chalk.bold('\nInstalled plugins:\n'))
-        for (const plugin of installed) {
-          const isTrusted = trusted.has(plugin.package)
-          const badge = isTrusted ? chalk.green(' [trusted]') : ''
-          console.log(`  ${chalk.cyan(plugin.package)} ${chalk.dim(plugin.version)}${badge}`)
-        }
-        console.log('')
-      }
-
-      // Show configured instances
-      const instances = await getInstances(CONFIG_PATH)
-      if (instances.length > 0) {
-        console.log(chalk.bold('Configured instances:\n'))
-        for (const inst of instances) {
-          const status = inst.enabled === false ? chalk.red(' [disabled]') : chalk.green(' [enabled]')
-          console.log(`  ${chalk.cyan(inst.id)} ${chalk.dim(inst.package)}${status}`)
-        }
-        console.log('')
-      }
-    })
-
-  // Register plugin create subcommand (Task 3)
-  registerPluginCreateCommand(pluginCmd)
-}