@antseed/cli 0.1.0

package/src/cli/commands/init.ts

@@ -0,0 +1,99 @@
+import type { Command } from 'commander'
+import chalk from 'chalk'
+import ora from 'ora'
+import { getGlobalOptions } from './types.js'
+import { loadConfig, saveConfig } from '../../config/loader.js'
+import { TRUSTED_PLUGINS } from '../../plugins/registry.js'
+import { installPlugin } from '../../plugins/manager.js'
+import type { CLIProviderConfig } from '../../config/types.js'
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command('init')
+    .description('Interactive setup — install trusted plugins and configure providers')
+    .option('--auth-type <type>', 'auth type for providers: apikey, oauth, or claude-code', 'claude-code')
+    .option('--api-key <key>', 'API key (required when auth-type is apikey)')
+    .action(async (options) => {
+      const globalOpts = getGlobalOptions(program)
+      const config = await loadConfig(globalOpts.config)
+
+      console.log(chalk.bold('\nAntseed — Setup\n'))
+
+      // 1. Install plugins
+      const providers = TRUSTED_PLUGINS.filter((p) => p.type === 'provider')
+      const routers = TRUSTED_PLUGINS.filter((p) => p.type === 'router')
+
+      console.log(chalk.bold('Installing plugins:\n'))
+
+      if (providers.length > 0) {
+        console.log(chalk.dim('  PROVIDERS  (for: antseed seed)'))
+        for (const p of providers) {
+          console.log(`    ${chalk.cyan(p.name.padEnd(16))} ${p.description}`)
+        }
+        console.log('')
+      }
+
+      if (routers.length > 0) {
+        console.log(chalk.dim('  ROUTERS  (for: antseed connect)'))
+        for (const r of routers) {
+          console.log(`    ${chalk.cyan(r.name.padEnd(16))} ${r.description}`)
+        }
+        console.log('')
+      }
+
+      for (const plugin of TRUSTED_PLUGINS) {
+        const spinner = ora(`Installing ${plugin.package}...`).start()
+        try {
+          await installPlugin(plugin.package)
+          spinner.succeed(chalk.green(`Installed ${plugin.package}`))
+        } catch (err) {
+          spinner.fail(chalk.red(`Failed to install ${plugin.package}: ${(err as Error).message}`))
+        }
+      }
+
+      // 2. Configure providers in the config file
+      const authType = options.authType as 'apikey' | 'oauth' | 'claude-code'
+      const apiKey = options.apiKey as string | undefined
+
+      if (authType === 'apikey' && !apiKey) {
+        console.log('')
+        console.log(chalk.yellow('Skipping provider config — no --api-key provided.'))
+        console.log(chalk.dim('  Add later: antseed config add-provider -t anthropic -k <key>'))
+      } else {
+        for (const plugin of providers) {
+          const existing = config.providers.find(p => p.type === plugin.name)
+          if (!existing) {
+            const provider: CLIProviderConfig = {
+              type: plugin.name,
+              endpoint: 'https://api.anthropic.com',
+              authHeaderName: authType === 'claude-code' ? 'authorization' : 'x-api-key',
+              authValue: apiKey ?? '',
+              authType,
+            }
+            config.providers.push(provider)
+            config.seller.enabledProviders.push(plugin.name)
+          } else {
+            existing.authType = authType
+            if (apiKey) existing.authValue = apiKey
+          }
+        }
+
+        await saveConfig(globalOpts.config, config)
+        console.log('')
+        console.log(chalk.green(`Config saved with auth type: ${authType}`))
+      }
+
+      console.log('')
+      console.log(chalk.bold('Next steps:'))
+      console.log(`  ${chalk.cyan('antseed config seller set pricing.defaults.inputUsdPerMillion 12')}`)
+      console.log(`  ${chalk.cyan('antseed config seller set pricing.defaults.outputUsdPerMillion 36')}`)
+      console.log(`  ${chalk.cyan('antseed config buyer set preferredProviders \'["anthropic","openai"]\'')}`)
+      console.log(`  ${chalk.cyan('antseed config buyer set maxPricing.defaults.inputUsdPerMillion 25')}`)
+      console.log(`  ${chalk.cyan('antseed config buyer set maxPricing.defaults.outputUsdPerMillion 75')}`)
+      console.log(`  ${chalk.cyan('antseed seed --provider anthropic')}`)
+      console.log(`  ${chalk.cyan('antseed connect --router claude-code')}`)
+      console.log('')
+      console.log(chalk.dim('Seller settings live under seller.* and buyer preferences live under buyer.* in your config file.'))
+      console.log('')
+    })
+}

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

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

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

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