weifuwu 0.19.10 → 0.22.0

package/cli/template/index.ts

@@ -3,6 +3,4 @@ import { app } from './app.ts'
 
 loadEnv()
 const port = Number(process.env.PORT) || 3000
-const server = serve(app.handler(), { port, websocket: app.websocketHandler() })
-await server.ready
-console.log(`Listening on http://localhost:${server.port}`)
+serve(app.handler(), { port, websocket: app.websocketHandler() })

package/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { mkdir, writeFile, copyFile, readFile, cp } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
+import { existsSync, readdirSync } from 'node:fs'
 import { execSync } from 'node:child_process'
 import { homedir } from 'node:os'
 import { join, dirname, resolve } from 'node:path'
@@ -11,6 +11,12 @@ 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 })
@@ -19,24 +25,25 @@ async function cmdSkill() {
 }
 
 async function cmdVersion() {
-  const pkg = JSON.parse(await readFile(join(pkgRoot, 'package.json'), 'utf-8'))
+  const pkg = await readPkg()
   console.log(pkg.version)
 }
 
-async function cmdInit(name: string) {
+async function cmdInit(name: string, opts: { minimal?: boolean; skipInstall?: boolean }) {
   const targetDir = resolve(process.cwd(), name)
-  const pkg = JSON.parse(await readFile(join(pkgRoot, 'package.json'), 'utf-8'))
+  const pkg = await readPkg()
   const v = pkg.version
-  const depVer = (depName: string) => `^${pkg.devDependencies[depName].replace(/^\^/, '')}`
+  const depVer = (depName: string) =>
+    `^${(pkg.devDependencies?.[depName] || '0.0.0').replace(/^\^/, '')}`
 
   await mkdir(targetDir, { recursive: true })
 
-  // Copy code templates
+  // Copy templates
   const templateDir = join(pkgRoot, 'cli', 'template')
   await cp(templateDir, targetDir, { recursive: true })
 
-  // Rewrite local imports → package imports for the copied project
-  for (const file of ['app.ts', 'index.ts', 'ui/app/page.tsx']) {
+  // 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
@@ -45,23 +52,64 @@ async function cmdInit(name: string) {
     await writeFile(fp, content)
   }
 
-  // Write config files
+  // 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)
+  }
+
+  // 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 {}
+
+    // 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'))
+
+    // 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'))
+  }
+
+  // Write package.json
+  const deps: Record<string, string> = { weifuwu: `^${v}` }
+  const devDeps: Record<string, string> = {}
+  if (!opts.minimal) {
+    devDeps['@types/react'] = depVer('@types/react')
+    devDeps['@types/react-dom'] = depVer('@types/react-dom')
+  }
+  devDeps['@types/node'] = depVer('@types/node')
+
   await writeFile(join(targetDir, 'package.json'), JSON.stringify({
     name,
     type: 'module',
     scripts: {
-      dev: 'NODE_ENV=development node index.ts',
+      dev: 'NODE_ENV=development node --watch index.ts',
       start: 'node index.ts',
     },
-    dependencies: {
-      weifuwu: `^${v}`,
-    },
-    devDependencies: {
-      '@types/node': depVer('@types/node'),
-      '@types/react': depVer('@types/react'),
-    },
+    dependencies: deps,
+    devDependencies: devDeps,
   }, null, 2) + '\n')
 
+  // Write tsconfig.json
+  const include = opts.minimal ? ['*.ts'] : ['*.ts', 'ui/**/*.ts', 'ui/**/*.tsx']
   await writeFile(join(targetDir, 'tsconfig.json'), JSON.stringify({
     compilerOptions: {
       target: 'ESNext',
@@ -73,52 +121,182 @@ async function cmdInit(name: string) {
       noEmit: true,
       allowImportingTsExtensions: true,
     },
-    include: ['*.ts', 'ui/**/*.ts', 'ui/**/*.tsx'],
+    include,
   }, null, 2) + '\n')
 
   await writeFile(join(targetDir, '.gitignore'), 'node_modules\ndist\n.env\n.sessions\n.weifuwu\n')
   await writeFile(join(targetDir, '.env'), 'PORT=3000\n')
-
   await writeFile(join(targetDir, 'AGENTS.md'), [
     `# ${name}`,
     '',
-    'This is a [weifuwu](https://weifuwu.io) HTTP application — pure Node.js, no build step.',
-    '',
-    '## Before you start',
-    '',
-    'Read `node_modules/weifuwu/README.md` first.',
+    `This is a [weifuwu](https://weifuwu.io) application — pure Node.js, no build step.`,
     '',
     '## Commands',
     '',
-    '- `npm run dev` — start dev server with `--watch`',
+    '- `npm run dev` — start dev server with hot reload',
     '- `npm start` — start production server',
     '- `npm install` — install dependencies',
-    '- `npx tsc --noEmit` — type-check without emitting',
+    '- `npx tsc --noEmit` — type-check',
     '',
     '## API Reference',
     '',
-    'See `node_modules/weifuwu/README.md` for the full weifuwu API documentation.',
+    'See `node_modules/weifuwu/README.md` for the full documentation.',
     '',
   ].join('\n'))
 
-  console.log('\nInstalling dependencies...')
-  execSync('npm install', { cwd: targetDir, stdio: 'inherit' })
-  console.log(`\n✅ Created ${name}/ — cd ${name} && npm start`)
+  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 */ }
+}
+
+import { parseArgs } from 'node:util'
+
+// ── CLI dispatcher ──────────────────────────────────────────────────────
+
 const cmd = process.argv[2]
 
+const HELP = `
+weifuwu — Web-standard HTTP framework 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> --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
+`
+
 if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
   cmdVersion().catch(console.error)
 } else if (cmd === 'skill') {
   cmdSkill().catch(console.error)
 } else if (cmd === 'init') {
-  const name = process.argv[3]
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(3),
+    options: {
+      minimal: { type: 'boolean', short: 'm' },
+      'skip-install': { type: 'boolean' },
+    },
+    strict: false,
+    allowPositionals: true,
+  })
+  const name = positionals[0]
   if (!name) {
-    console.error('Usage: npx weifuwu init <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>')
     process.exit(1)
   }
-  cmdInit(name).catch(console.error)
+  cmdGenerate(type, name).catch(console.error)
 } else {
-  console.log('\nUsage:\n  npx weifuwu version          Print version\n  npx weifuwu init <name>    Create a new weifuwu project\n  npx weifuwu skill           Install weifuwu skill to ~/.agents/skills/\n')
+  console.log(HELP)
 }

package/dist/agent/rest.d.ts

@@ -3,6 +3,7 @@ import type { BoundTable } from '../postgres/schema/index.ts';
 import type { RunParams } from './types.ts';
 interface RestDeps {
     agents: BoundTable<any>;
+    runs: BoundTable<any>;
     knowledge: BoundTable<any>;
     runner: {
         run: (agentId: number, params: RunParams) => Promise<any>;

package/dist/agent/run.d.ts

@@ -5,6 +5,7 @@ import type { RunParams, RunResult, KnowledgeDoc } from './types.ts';
 interface RunnerDeps {
     sql: Sql<{}>;
     agents: BoundTable<any>;
+    runs: BoundTable<any>;
     knowledge: BoundTable<any>;
     getModel: () => LanguageModel;
     getEmbeddingModel: () => EmbeddingModel;

package/dist/cache.d.ts

@@ -0,0 +1,74 @@
+import type { Context, Middleware } from './types.ts';
+import type { Redis } from './vendor.ts';
+export interface CachedResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    createdAt: number;
+    tags: string[];
+}
+export interface CacheStore {
+    get(key: string): Promise<CachedResponse | null>;
+    set(key: string, entry: CachedResponse, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    invalidate(tag: string): Promise<void>;
+    flush(): Promise<void>;
+}
+export interface CacheOptions {
+    /** TTL in milliseconds. Default: 300_000 (5 min). */
+    ttl?: number;
+    /** Cache store. 'memory' (default) or 'redis'. */
+    store?: 'memory' | 'redis' | CacheStore;
+    /** Redis client (required when store: 'redis'). */
+    redis?: Redis;
+    /** Custom cache key function. Default: SHA256 of method + URL. */
+    key?: (req: Request) => string;
+    /** Tag function for grouped invalidation. Called after handler runs (ctx available). */
+    tag?: (req: Request, ctx: Context) => string | string[] | undefined;
+    /** Whether to cache responses with Set-Cookie. Default: false. */
+    cacheCookies?: boolean;
+    /** Status codes to cache. Default: [200]. */
+    cacheStatus?: number[];
+    /** Maximum number of bytes per cached body. Default: 1MB. Larger bodies are skipped. */
+    maxBodySize?: number;
+}
+export interface CacheMiddleware extends Middleware {
+    /** Invalidate all entries with a given tag. */
+    invalidate(tag: string): Promise<void>;
+    /** Flush all cached entries. */
+    flush(): Promise<void>;
+    /** Cleanup. */
+    close(): void;
+    /** Store reference (for testing). */
+    store: CacheStore;
+}
+export declare class MemoryCache implements CacheStore {
+    private store;
+    private tagIndex;
+    private interval;
+    constructor(cleanupMs?: number);
+    get(key: string): Promise<CachedResponse | null>;
+    set(key: string, data: CachedResponse, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    invalidate(tag: string): Promise<void>;
+    flush(): Promise<void>;
+    private cleanup;
+    close(): void;
+    /** Testing only. */
+    get size(): number;
+}
+export declare class RedisCache implements CacheStore {
+    private redis;
+    private prefix;
+    private tagPrefix;
+    constructor(redis: Redis, prefix?: string);
+    private key;
+    private tagKey;
+    get(key: string): Promise<CachedResponse | null>;
+    set(key: string, entry: CachedResponse, ttl: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    invalidate(tag: string): Promise<void>;
+    flush(): Promise<void>;
+}
+export declare function cache(options?: CacheOptions): CacheMiddleware;