weifuwu 0.25.2 → 0.27.1

package/ai/provider.ts

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Context, Middleware } from '../types.ts'
+import { createOpenAI } from '@ai-sdk/openai'
+import {
+  embed as aiEmbed,
+  embedMany as aiEmbedMany,
+  generateText as aiGenerateText,
+  streamText as aiStreamText,
+  type LanguageModel,
+  type EmbeddingModel,
+} from 'ai'
+
+// Augment Context with ai property
+declare module '../types.ts' {
+  interface Context {
+    ai: AIProvider
+  }
+}
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+export interface AIProviderInjected {
+  ai: AIProvider
+}
+
+export interface AIProviderOptions {
+  /** API base URL (default: OPENAI_BASE_URL env or http://localhost:11434/v1). */
+  baseURL?: string
+  /** API key (default: OPENAI_API_KEY env or 'ollama'). */
+  apiKey?: string
+  /** Chat model name (default: OPENAI_MODEL env or 'qwen3:0.6b'). */
+  model?: string
+  /** Embedding model name (default: OPENAI_EMBEDDING_MODEL env or 'qwen3-embedding:0.6b'). */
+  embeddingModel?: string
+  /** Vector dimension (default: EMBEDDING_DIMENSION env or 1024). */
+  embeddingDimension?: number
+}
+
+export interface AIProvider {
+  /** Get the language model. Caches by default; pass a name to override. */
+  model(name?: string): LanguageModel
+  /** Get the embedding model. Caches by default; pass a name to override. */
+  embeddingModel(name?: string): EmbeddingModel
+  /** Embed a single text string into a vector. */
+  embed(text: string): Promise<number[]>
+  /** Embed multiple text strings in batch. */
+  embedMany(texts: string[]): Promise<number[][]>
+  /** The configured vector dimension. */
+  readonly dimension: number
+
+  /**
+   * Generate text using the configured model.
+   * All options are passed through to the AI SDK's `generateText`, with `model` auto-injected.
+   */
+  generateText(
+    params: Omit<Parameters<typeof aiGenerateText>[0], 'model'>,
+  ): ReturnType<typeof aiGenerateText>
+  /**
+   * Stream text using the configured model.
+   * All options are passed through to the AI SDK's `streamText`, with `model` auto-injected.
+   */
+  streamText(
+    params: Omit<Parameters<typeof aiStreamText>[0], 'model'>,
+  ): ReturnType<typeof aiStreamText>
+}
+
+// ── Factory ─────────────────────────────────────────────────────────────────
+
+export function aiProvider(
+  options?: AIProviderOptions,
+): Middleware<Context, Context & AIProviderInjected> & AIProvider {
+  const baseURL = options?.baseURL ?? process.env.OPENAI_BASE_URL ?? 'http://localhost:11434/v1'
+  const apiKey = options?.apiKey ?? process.env.OPENAI_API_KEY ?? 'ollama'
+  const modelName = options?.model ?? process.env.OPENAI_MODEL ?? 'qwen3:0.6b'
+  const embedModelName =
+    options?.embeddingModel ?? process.env.OPENAI_EMBEDDING_MODEL ?? 'qwen3-embedding:0.6b'
+  const dimension =
+    options?.embeddingDimension ?? parseInt(process.env.EMBEDDING_DIMENSION || '1024', 10)
+
+  const client = createOpenAI({ baseURL, apiKey })
+
+  let _model: LanguageModel | undefined
+  let _embedModel: EmbeddingModel | undefined
+
+  const provider: AIProvider = {
+    get dimension() {
+      return dimension
+    },
+
+    model(name?: string): LanguageModel {
+      const m = name ?? modelName
+      if (!_model) _model = client(m)
+      return _model
+    },
+
+    embeddingModel(name?: string): EmbeddingModel {
+      const m = name ?? embedModelName
+      if (!_embedModel) _embedModel = client.embedding(m)
+      return _embedModel
+    },
+
+    async embed(text: string): Promise<number[]> {
+      const result = await aiEmbed({ model: this.embeddingModel(), value: text })
+      return result.embedding
+    },
+
+    async embedMany(texts: string[]): Promise<number[][]> {
+      const result = await aiEmbedMany({ model: this.embeddingModel(), values: texts })
+      return result.embeddings
+    },
+
+    generateText(params: Omit<Parameters<typeof aiGenerateText>[0], 'model'>) {
+      return aiGenerateText({ ...params, model: this.model() } as any)
+    },
+
+    streamText(params: Omit<Parameters<typeof aiStreamText>[0], 'model'>) {
+      return aiStreamText({ ...params, model: this.model() } as any)
+    },
+  }
+
+  const mw: Middleware<Context, Context & AIProviderInjected> = async (req, ctx, next) => {
+    ;(ctx as Context & AIProviderInjected).ai = provider
+    return next(req, ctx as Context & AIProviderInjected)
+  }
+  mw.__meta = { injects: ['ai'], depends: [] }
+
+  return Object.assign(mw, provider) as Middleware<Context, Context & AIProviderInjected> &
+    AIProvider
+}

package/ai/stream.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Context } from '../types.ts'
+import { Router } from '../core/router.ts'
+import type { AIProvider } from './provider.ts'
+
+export type AIHandler = (
+  req: Request,
+  ctx: Context,
+) => Record<string, unknown> | Promise<Record<string, unknown>>
+
+export const _ai: Record<string, any> = {}
+
+async function getStreamText() {
+  if (!_ai.streamText) _ai.streamText = (await import('ai')).streamText
+  return _ai.streamText
+}
+
+async function getStreamObject() {
+  if (!_ai.streamObject) _ai.streamObject = (await import('ai')).streamObject
+  return _ai.streamObject
+}
+
+/**
+ * Create a streaming AI endpoint.
+ *
+ * @param handler - Returns options for `streamText` or `streamObject` (if `schema` is present).
+ * @param provider - Optional AI provider. If provided and the handler does not return a `model`,
+ *                   `provider.model()` is used as the default.
+ */
+export async function aiStream(handler: AIHandler, provider?: AIProvider): Promise<Router> {
+  const r = new Router()
+
+  r.post('/', async (req, ctx) => {
+    let options
+    try {
+      options = await handler(req, ctx)
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      return new Response(JSON.stringify({ error: message }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    // Inject default model from provider if handler didn't specify one
+    if (provider && !options.model) {
+      options.model = provider.model()
+    }
+
+    if (options.schema) {
+      const streamObject = await getStreamObject()
+      const { schema, ...params } = options
+      const result = streamObject({ ...params, schema: schema as any, output: 'object' as const })
+      return result.toTextStreamResponse()
+    }
+
+    const streamText = await getStreamText()
+    const result = streamText(options)
+    return result.toTextStreamResponse()
+  })
+
+  return r
+}

package/{dist/cli.d.ts → cli.js}

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import('./cli.ts')

package/cli.ts

@@ -1,29 +1,23 @@
 #!/usr/bin/env node
 /* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { mkdir, writeFile, copyFile, readFile, cp } from 'node:fs/promises'
-import { existsSync, readdirSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 import { execSync } from 'node:child_process'
-import { homedir } from 'node:os'
 import { join, dirname, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { parseArgs } from 'node:util'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
 const pkgRoot = existsSync(join(__dirname, 'package.json')) ? __dirname : resolve(__dirname, '..')
 
-async function readPkg(): Promise<any> {
-  return JSON.parse(await readFile(join(pkgRoot, 'package.json'), 'utf-8'))
-}
-
-// ── Commands ────────────────────────────────────────────────────────────
-
-async function cmdSkill() {
-  const targetDir = join(homedir(), '.agents', 'skills', 'weifuwu')
-  await mkdir(targetDir, { recursive: true })
-  await copyFile(join(pkgRoot, 'README.md'), join(targetDir, 'SKILL.md'))
-  console.log('✅ Installed weifuwu skill to ~/.agents/skills/weifuwu/')
+async function readPkg() {
+  return JSON.parse(
+    await import('node:fs/promises').then((fs) =>
+      fs.readFile(join(pkgRoot, 'package.json'), 'utf-8'),
+    ),
+  )
 }
 
 async function cmdVersion() {
@@ -31,91 +25,43 @@ async function cmdVersion() {
   console.log(pkg.version)
 }
 
-async function cmdInit(name: string, opts: { minimal?: boolean; skipInstall?: boolean }) {
+async function cmdInit(name: string, opts: { skipInstall?: boolean }) {
   const targetDir = resolve(process.cwd(), name)
-  const pkg = await readPkg()
-  const v = pkg.version
-  // Map of known type package versions that align with our runtime deps
-  const typeVersions: Record<string, string> = {
-    '@types/react': '^19',
-    '@types/react-dom': '^19',
-    '@types/node': '^22',
-  }
-  const depVer = (depName: string) =>
-    typeVersions[depName] || `^${(pkg.devDependencies?.[depName] || '0.0.0').replace(/^\^/, '')}`
-
-  await mkdir(targetDir, { recursive: true })
-
-  // Copy templates
-  const templateDir = join(pkgRoot, 'cli', 'template')
-  await cp(templateDir, targetDir, { recursive: true })
 
-  // Rewrite local imports → package imports
-  for (const file of ['app.ts', 'index.ts']) {
-    const fp = join(targetDir, file)
-    let content = await readFile(fp, 'utf-8')
-    content = content
-      .replace(/from '\.\.\/\.\.\/index\.ts'/g, "from 'weifuwu'")
-      .replace(/from '\.\.\/\.\.\/\.\.\/react\.ts'/g, "from 'weifuwu/react'")
-    await writeFile(fp, content)
-  }
-
-  // Rewrite UI imports
-  const uiPage = join(targetDir, 'ui', 'app', 'page.tsx')
-  if (existsSync(uiPage)) {
-    let content = await readFile(uiPage, 'utf-8')
-    content = content.replace(/from '\.\.\/\.\.\/\.\.\/\.\.\/react\.ts'/g, "from 'weifuwu/react'")
-    await writeFile(uiPage, content)
+  if (existsSync(targetDir)) {
+    console.error(`Directory ${name} already exists.`)
+    process.exit(1)
   }
 
-  // Minimal mode: strip SSR/i18n/theme, keep only HTTP core
-  if (opts.minimal) {
-    try {
-      await rmrf(join(targetDir, 'ui'))
-    } catch {}
-    try {
-      await rmrf(join(targetDir, 'locales'))
-    } catch {}
+  const pkg = await readPkg()
 
-    // Write minimal app.ts
-    await writeFile(
-      join(targetDir, 'app.ts'),
-      [
-        `import { Router } from 'weifuwu'`,
-        ``,
-        `export const app = new Router()`,
-        ``,
-        `app.get('/', () => new Response('Hello from ${name}!'))`,
-        `app.get('/api/ping', () => Response.json({ pong: true, time: new Date().toISOString() }))`,
-        ``,
-      ].join('\n'),
-    )
+  await mkdir(targetDir, { recursive: true })
 
-    // Write minimal index.ts
-    await writeFile(
-      join(targetDir, 'index.ts'),
-      [
-        `import { serve } from 'weifuwu'`,
-        `import { app } from './app.ts'`,
-        ``,
-        `const port = Number(process.env.PORT) || 3000`,
-        `serve(app.handler(), { port })`,
-        ``,
-      ].join('\n'),
-    )
-  }
+  await writeFile(
+    join(targetDir, 'app.ts'),
+    [
+      `import { Router } from 'weifuwu'`,
+      ``,
+      `export const app = new Router()`,
+      ``,
+      `app.get('/', () => new Response('Hello from ${name}!'))`,
+      `app.get('/api/ping', () => Response.json({ pong: true, time: new Date().toISOString() }))`,
+      ``,
+    ].join('\n'),
+  )
 
-  // Write package.json
-  const deps: Record<string, string> = { weifuwu: `^${v}` }
-  const devDeps: Record<string, string> = {}
-  if (!opts.minimal) {
-    deps['react'] = '^19'
-    deps['react-dom'] = '^19'
-    deps['tailwindcss'] = '^4'
-    devDeps['@types/react'] = depVer('@types/react')
-    devDeps['@types/react-dom'] = depVer('@types/react-dom')
-  }
-  devDeps['@types/node'] = depVer('@types/node')
+  await writeFile(
+    join(targetDir, 'index.ts'),
+    [
+      `import { loadEnv, serve } from 'weifuwu'`,
+      `import { app } from './app.ts'`,
+      ``,
+      `loadEnv()`,
+      `const port = Number(process.env.PORT) || 3000`,
+      `serve(app.handler(), { port })`,
+      ``,
+    ].join('\n'),
+  )
 
   await writeFile(
     join(targetDir, 'package.json'),
@@ -124,19 +70,18 @@ async function cmdInit(name: string, opts: { minimal?: boolean; skipInstall?: bo
         name,
         type: 'module',
         scripts: {
-          dev: 'NODE_ENV=development node --watch index.ts',
+          dev: 'node --watch index.ts',
           start: 'node index.ts',
         },
-        dependencies: deps,
-        devDependencies: devDeps,
+        dependencies: {
+          weifuwu: `^${pkg.version}`,
+        },
       },
       null,
       2,
     ) + '\n',
   )
 
-  // Write tsconfig.json
-  const include = opts.minimal ? ['*.ts'] : ['*.ts', 'ui/**/*.ts', 'ui/**/*.tsx']
   await writeFile(
     join(targetDir, 'tsconfig.json'),
     JSON.stringify(
@@ -146,204 +91,57 @@ async function cmdInit(name: string, opts: { minimal?: boolean; skipInstall?: bo
           module: 'NodeNext',
           moduleResolution: 'NodeNext',
           strict: true,
-          jsx: 'react-jsx',
           skipLibCheck: true,
           noEmit: true,
           allowImportingTsExtensions: true,
         },
-        include,
+        include: ['*.ts'],
       },
       null,
       2,
     ) + '\n',
   )
 
-  await writeFile(join(targetDir, '.gitignore'), 'node_modules\ndist\n.env\n.sessions\n.weifuwu\n')
+  await writeFile(join(targetDir, '.gitignore'), 'node_modules\n.env\n')
   await writeFile(join(targetDir, '.env'), 'PORT=3000\n')
-  await writeFile(
-    join(targetDir, 'AGENTS.md'),
-    [
-      `# ${name}`,
-      '',
-      `This is a [weifuwu](https://weifuwu.io) application — pure Node.js, no build step.`,
-      '',
-      '## Commands',
-      '',
-      '- `npm run dev` — start dev server with hot reload',
-      '- `npm start` — start production server',
-      '- `npm install` — install dependencies',
-      '- `npx tsc --noEmit` — type-check',
-      '',
-      '## API Reference',
-      '',
-      'See `node_modules/weifuwu/README.md` for the full documentation.',
-      '',
-    ].join('\n'),
-  )
 
   if (!opts.skipInstall) {
     console.log('\nInstalling dependencies...')
     execSync('npm install', { cwd: targetDir, stdio: 'inherit' })
   }
-  console.log(
-    `\n✅ Created ${name}/ — cd ${name} && ${opts.skipInstall ? 'npm install && ' : ''}npm run dev`,
-  )
-}
-
-async function cmdDev() {
-  const entry = existsSync('index.ts') ? 'index.ts' : existsSync('app.ts') ? 'app.ts' : null
 
-  if (!entry) {
-    console.error('No index.ts or app.ts found in current directory.')
-    console.error('Run `npx weifuwu init <name>` to create a new project.')
-    process.exit(1)
-  }
-
-  console.log(`Starting dev server (${entry})...`)
-  execSync(`NODE_ENV=development node --watch ${entry}`, { stdio: 'inherit' })
-}
-
-async function cmdGenerate(type: string, name: string) {
-  if (type !== 'module') {
-    console.error(`Unknown generate type: ${type}. Usage: npx weifuwu generate module <name>`)
-    process.exit(1)
-  }
-
-  const dir = join(process.cwd(), name)
-  if (existsSync(dir)) {
-    console.error(`Directory ${name} already exists.`)
-    process.exit(1)
-  }
-
-  await mkdir(dir, { recursive: true })
-  await writeFile(
-    join(dir, 'index.ts'),
-    [
-      `import type { Middleware } from 'weifuwu'`,
-      ``,
-      `export interface ${capitalize(name)}Options {`,
-      `  // Add your options here`,
-      `}`,
-      ``,
-      `export function ${name}(opts?: ${capitalize(name)}Options): Middleware {`,
-      `  return async (req, ctx, next) => {`,
-      `    // Your middleware logic here`,
-      `    return next(req, ctx)`,
-      `  }`,
-      `}`,
-      ``,
-    ].join('\n'),
-  )
-
-  await mkdir(join(dir, '..', 'test'), { recursive: true })
-  await writeFile(
-    join(dir, '..', 'test', `${name}.test.ts`),
-    [
-      `import { describe, it } from 'node:test'`,
-      `import assert from 'node:assert/strict'`,
-      `import { ${name} } from '../${name}/index.ts'`,
-      `import { Router } from 'weifuwu'`,
-      ``,
-      `describe('${name}', () => {`,
-      `  it('works as middleware', async () => {`,
-      `    const app = new Router()`,
-      `    app.use(${name}())`,
-      `    app.get('/', () => new Response('ok'))`,
-      ``,
-      `    const res = await app.handler()(`,
-      `      new Request('http://localhost/'),`,
-      `      { params: {}, query: {} } as any,`,
-      `    )`,
-      `    assert.equal(res.status, 200)`,
-      `  })`,
-      `})`,
-      ``,
-    ].join('\n'),
-  )
-
-  console.log(`✅ Created module ${name}/ with index.ts and test/${name}.test.ts`)
-}
-
-function capitalize(s: string): string {
-  return s.charAt(0).toUpperCase() + s.slice(1)
-}
-
-// Minimal rm -rf
-async function rmrf(dir: string) {
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true })
-    for (const entry of entries) {
-      const p = join(dir, entry.name)
-      if (entry.isDirectory()) {
-        await rmrf(p)
-      } else {
-        const { unlink } = await import('node:fs/promises')
-        await unlink(p)
-      }
-    }
-    const { rmdir } = await import('node:fs/promises')
-    await rmdir(dir)
-  } catch {
-    /* ignore */
-  }
+  console.log(`\n✅ Created ${name}/`)
+  console.log(`   cd ${name}`)
+  if (opts.skipInstall) console.log(`   npm install`)
+  console.log(`   npm run dev`)
 }
 
-import { parseArgs } from 'node:util'
-
-// ── CLI dispatcher ──────────────────────────────────────────────────────
-
 const cmd = process.argv[2]
 
 const HELP = `
-weifuwu — Web-standard HTTP framework for Node.js
+weifuwu — Web-standard HTTP microframework for Node.js
 
 Usage:
-  npx weifuwu init <name>              Create a new project (SSR + i18n + theme)
-  npx weifuwu init <name> --minimal    Create a minimal HTTP project
+  npx weifuwu init <name>              Create a new project
   npx weifuwu init <name> --skip-install  Create project, skip npm install
-  npx weifuwu dev                       Start dev server in current directory
-  npx weifuwu generate module <name>    Scaffold a new module
-  npx weifuwu version                   Print version
+  npx weifuwu version                  Print version
 `
 
 if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
   cmdVersion().catch(console.error)
-} else if (cmd === 'skill') {
-  cmdSkill().catch(console.error)
 } else if (cmd === 'init') {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(3),
-    options: {
-      minimal: { type: 'boolean', short: 'm' },
-      'skip-install': { type: 'boolean' },
-    },
+    options: { 'skip-install': { type: 'boolean' } },
     strict: false,
     allowPositionals: true,
   })
   const name = positionals[0]
   if (!name) {
-    console.error('Usage: npx weifuwu init <name> [--minimal] [--skip-install]')
-    process.exit(1)
-  }
-  cmdInit(name, { minimal: !!values.minimal, skipInstall: !!values['skip-install'] }).catch(
-    console.error,
-  )
-} else if (cmd === 'dev') {
-  cmdDev()
-} else if (cmd === 'generate' || cmd === 'g') {
-  const { positionals } = parseArgs({
-    args: process.argv.slice(3),
-    options: {},
-    strict: false,
-    allowPositionals: true,
-  })
-  const type = positionals[0]
-  const name = positionals[1]
-  if (!type || !name) {
-    console.error('Usage: npx weifuwu generate module <name>')
+    console.error('Usage: npx weifuwu init <name> [--skip-install]')
     process.exit(1)
   }
-  cmdGenerate(type, name).catch(console.error)
+  cmdInit(name, { skipInstall: !!values['skip-install'] }).catch(console.error)
 } else {
   console.log(HELP)
 }