luca 3.0.0 → 3.0.2

package/test/interceptor-chain.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { InterceptorChain } from '../src/agi/lib/interceptor-chain'
-
-describe('InterceptorChain', () => {
-	it('runs interceptors in order then the final', async () => {
-		const chain = new InterceptorChain<{ log: string[] }>()
-		chain.add(async (ctx, next) => { ctx.log.push('a'); await next() })
-		chain.add(async (ctx, next) => { ctx.log.push('b'); await next() })
-
-		const ctx = { log: [] as string[] }
-		await chain.run(ctx, async () => { ctx.log.push('final') })
-
-		expect(ctx.log).toEqual(['a', 'b', 'final'])
-	})
-
-	it('skips the final when an interceptor does not call next', async () => {
-		const chain = new InterceptorChain<{ log: string[] }>()
-		chain.add(async (ctx, _next) => { ctx.log.push('blocker') })
-		chain.add(async (ctx, next) => { ctx.log.push('never'); await next() })
-
-		const ctx = { log: [] as string[] }
-		await chain.run(ctx, async () => { ctx.log.push('final') })
-
-		expect(ctx.log).toEqual(['blocker'])
-	})
-
-	it('allows interceptors to mutate ctx before and after next', async () => {
-		const chain = new InterceptorChain<{ value: number }>()
-		chain.add(async (ctx, next) => {
-			ctx.value *= 2
-			await next()
-			ctx.value += 100
-		})
-
-		const ctx = { value: 5 }
-		await chain.run(ctx, async () => { ctx.value += 1 })
-
-		expect(ctx.value).toBe(111) // (5*2)=10, final +1=11, after +100=111
-	})
-
-	it('reports hasInterceptors and size', () => {
-		const chain = new InterceptorChain<{}>()
-		expect(chain.hasInterceptors).toBe(false)
-		expect(chain.size).toBe(0)
-
-		const fn = async (_ctx: {}, next: () => Promise<void>) => { await next() }
-		chain.add(fn)
-		expect(chain.hasInterceptors).toBe(true)
-		expect(chain.size).toBe(1)
-
-		chain.remove(fn)
-		expect(chain.hasInterceptors).toBe(false)
-	})
-
-	it('runs just the final when no interceptors are registered', async () => {
-		const chain = new InterceptorChain<{ ran: boolean }>()
-		const ctx = { ran: false }
-		await chain.run(ctx, async () => { ctx.ran = true })
-		expect(ctx.ran).toBe(true)
-	})
-})

package/test/node-container.test.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect, mock } from 'bun:test'
-import { NodeContainer } from '../src/node/container'
-
-describe('NodeContainer', () => {
-  it('creates a container with a uuid', () => {
-    const c = new NodeContainer()
-    expect(c.uuid).toBeDefined()
-    expect(typeof c.uuid).toBe('string')
-    expect(c.uuid.length).toBeGreaterThan(0)
-  })
-
-  it('has a cwd', () => {
-    const c = new NodeContainer()
-    expect(c.cwd).toBe(process.cwd())
-  })
-
-  it('accepts a custom cwd', () => {
-    const c = new NodeContainer({ cwd: '/tmp' })
-    expect(c.cwd).toBe('/tmp')
-  })
-
-  it('detects node environment', () => {
-    const c = new NodeContainer()
-    expect(c.isNode).toBe(true)
-    expect(c.isBrowser).toBe(false)
-  })
-
-  it('has state with started=false initially', () => {
-    const c = new NodeContainer()
-    expect(c.currentState.started).toBe(false)
-  })
-
-  it('start() sets started state and emits event', async () => {
-    const c = new NodeContainer()
-    const listener = mock()
-    c.on('started', listener)
-    await c.start()
-    expect(c.currentState.started).toBe(true)
-    expect(listener).toHaveBeenCalled()
-  })
-
-  it('has utils with hashObject, stringUtils, uuid, lodash', () => {
-    const c = new NodeContainer()
-    expect(typeof c.utils.hashObject).toBe('function')
-    expect(typeof c.utils.stringUtils.camelCase).toBe('function')
-    expect(typeof c.utils.stringUtils.kebabCase).toBe('function')
-    expect(typeof c.utils.uuid).toBe('function')
-    expect(typeof c.utils.lodash.uniq).toBe('function')
-  })
-
-  it('utils.hashObject produces deterministic results', () => {
-    const c = new NodeContainer()
-    const a = c.utils.hashObject({ x: 1, y: 2 })
-    const b = c.utils.hashObject({ x: 1, y: 2 })
-    expect(a).toBe(b)
-  })
-
-  it('paths.resolve works relative to cwd', () => {
-    const c = new NodeContainer({ cwd: '/tmp' })
-    expect(c.paths.resolve('foo')).toBe('/tmp/foo')
-    expect(c.paths.resolve('foo', 'bar')).toBe('/tmp/foo/bar')
-  })
-
-  it('paths.join works relative to cwd', () => {
-    const c = new NodeContainer({ cwd: '/tmp' })
-    expect(c.paths.join('a', 'b')).toBe('/tmp/a/b')
-  })
-
-  it('bus() creates a new Bus instance', () => {
-    const c = new NodeContainer()
-    const bus = c.bus()
-    expect(typeof bus.on).toBe('function')
-    expect(typeof bus.emit).toBe('function')
-  })
-
-  it('newState() creates a new State instance', () => {
-    const c = new NodeContainer()
-    const state = c.newState({ count: 0 })
-    expect(state.get('count')).toBe(0)
-    state.set('count', 5)
-    expect(state.get('count')).toBe(5)
-  })
-
-  it('event system works (on, emit, off)', () => {
-    const c = new NodeContainer()
-    const listener = mock()
-    c.on('custom', listener)
-    c.emit('custom', 'hello')
-    expect(listener).toHaveBeenCalledWith('hello')
-    c.off('custom', listener)
-    c.emit('custom', 'world')
-    expect(listener).toHaveBeenCalledTimes(1)
-  })
-
-  it('waitFor resolves when event fires', async () => {
-    const c = new NodeContainer()
-    const promise = c.waitFor('ready')
-    c.emit('ready', 42)
-    expect(await promise).toBe(42)
-  })
-
-  it('each container gets a unique uuid', () => {
-    const a = new NodeContainer()
-    const b = new NodeContainer()
-    expect(a.uuid).not.toBe(b.uuid)
-  })
-
-  describe('plugin system', () => {
-    it('use() with a plugin object calls attach', () => {
-      const c = new NodeContainer()
-      const plugin = { attach: mock() }
-      c.use(plugin)
-      expect(plugin.attach).toHaveBeenCalledWith(c, {})
-    })
-
-    it('use() with an unknown feature string throws', () => {
-      const c = new NodeContainer()
-      expect(() => c.use('nonexistent_feature_xyz' as any)).toThrow()
-    })
-  })
-})

package/test/python-session.test.ts

@@ -1,105 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
-
-describe('Python Persistent Session', () => {
-  let container: any
-  let python: any
-
-  beforeAll(async () => {
-    const mod = await import('../src/node.js')
-    container = mod.default
-    python = container.feature('python', { dir: container.cwd })
-    await python.enable()
-    await python.startSession()
-  })
-
-  afterAll(async () => {
-    if (python?.state?.get('sessionActive')) {
-      await python.stopSession()
-    }
-  })
-
-  it('session is active after start', () => {
-    expect(python.state.get('sessionActive')).toBe(true)
-    expect(python.state.get('sessionId')).toBeTruthy()
-  })
-
-  it('run() executes code and captures stdout', async () => {
-    const result = await python.run('print("hello from bridge")')
-    expect(result.ok).toBe(true)
-    expect(result.stdout).toContain('hello from bridge')
-  })
-
-  it('state persists across calls', async () => {
-    await python.run('x = 42')
-    const result = await python.eval('x + 1')
-    expect(result).toBe(43)
-  })
-
-  it('variables are injected', async () => {
-    const result = await python.run('print(name)', { name: 'luca' })
-    expect(result.ok).toBe(true)
-    expect(result.stdout).toContain('luca')
-  })
-
-  it('importModule() works', async () => {
-    await python.importModule('json')
-    const result = await python.eval('json.dumps({"a": 1})')
-    expect(result).toBe('{"a": 1}')
-  })
-
-  it('call() invokes functions', async () => {
-    await python.run('def add(a, b): return a + b')
-    const result = await python.call('add', [3, 4])
-    expect(result).toBe(7)
-  })
-
-  it('getLocals() returns namespace', async () => {
-    await python.run('y = 99')
-    const locals = await python.getLocals()
-    expect(locals.y).toBe(99)
-    expect(locals.x).toBe(42)
-  })
-
-  it('handles errors gracefully without crashing the session', async () => {
-    const result = await python.run('raise ValueError("test error")')
-    expect(result.ok).toBe(false)
-    expect(result.error).toContain('test error')
-    // Session should still be alive
-    const check = await python.run('print("still alive")')
-    expect(check.ok).toBe(true)
-    expect(check.stdout).toContain('still alive')
-  })
-
-  it('resetSession() clears state', async () => {
-    await python.run('z = 123')
-    await python.resetSession()
-    const result = await python.run('print(z)')
-    expect(result.ok).toBe(false)
-    expect(result.error).toContain('is not defined')
-  })
-
-  it('stopSession() cleans up', async () => {
-    await python.stopSession()
-    expect(python.state.get('sessionActive')).toBe(false)
-    expect(python.state.get('sessionId')).toBeNull()
-  })
-
-  it('can start a new session after stopping', async () => {
-    await python.startSession()
-    expect(python.state.get('sessionActive')).toBe(true)
-    const result = await python.run('print("fresh session")')
-    expect(result.ok).toBe(true)
-    expect(result.stdout).toContain('fresh session')
-  })
-})
-
-describe('Python backward compatibility', () => {
-  it('execute() still works without a session', async () => {
-    const mod = await import('../src/node.js')
-    const container = mod.default
-    const python = container.feature('python', { dir: container.cwd })
-    await python.enable()
-    const result = await python.execute('print("stateless")')
-    expect(result.stdout).toContain('stateless')
-  })
-})

package/test/rate-limit.test.ts

@@ -1,272 +0,0 @@
-import { NodeContainer } from '../src/node/container'
-import { Endpoint, type EndpointModule } from '../src/endpoint'
-
-/** Creates a minimal mock Express app that records registered routes and lets us fire requests. */
-function createMockApp() {
-  const routes: Record<string, Function> = {}
-
-  const app: any = {}
-  for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
-    app[method] = (path: string, handler: Function) => {
-      routes[`${method}:${path}`] = handler
-    }
-  }
-
-  /** Simulate a request hitting a registered route */
-  async function request(method: string, path: string, options: { ip?: string; query?: any; body?: any; params?: any } = {}) {
-    const handler = routes[`${method}:${path}`]
-    if (!handler) throw new Error(`No route for ${method} ${path}`)
-
-    let statusCode = 200
-    let responseBody: any = null
-    let headersSent = false
-
-    const req = {
-      ip: options.ip || '127.0.0.1',
-      socket: { remoteAddress: options.ip || '127.0.0.1' },
-      query: options.query || {},
-      body: options.body || {},
-      params: options.params || {},
-    }
-
-    const res = {
-      status(code: number) {
-        statusCode = code
-        return res
-      },
-      json(body: any) {
-        responseBody = body
-        headersSent = true
-      },
-      get headersSent() {
-        return headersSent
-      },
-    }
-
-    await handler(req, res)
-    return { status: statusCode, body: responseBody }
-  }
-
-  return { app, routes, request }
-}
-
-function createEndpoint(mod: EndpointModule) {
-  const c = new NodeContainer()
-  const endpoint = new Endpoint({ path: mod.path }, c.context)
-  endpoint.load(mod)
-  return endpoint
-}
-
-describe('Endpoint Rate Limiting', () => {
-  it('allows requests under the limit', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 5 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    for (let i = 0; i < 5; i++) {
-      const res = await request('get', '/api/test')
-      expect(res.status).toBe(200)
-      expect(res.body).toEqual({ ok: true })
-    }
-  })
-
-  it('returns 429 when rate limit is exceeded', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 3 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    // First 3 should succeed
-    for (let i = 0; i < 3; i++) {
-      const res = await request('get', '/api/test')
-      expect(res.status).toBe(200)
-    }
-
-    // 4th should be rate limited
-    const res = await request('get', '/api/test')
-    expect(res.status).toBe(429)
-    expect(res.body).toEqual({ error: 'Too Many Requests' })
-  })
-
-  it('emits error event when rate limited', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 1 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    const errors: any[] = []
-    endpoint.on('error', (err: any) => errors.push(err))
-
-    await request('get', '/api/test') // allowed
-    await request('get', '/api/test') // rate limited
-
-    expect(errors).toHaveLength(1)
-    expect(errors[0].message).toContain('Rate limit exceeded')
-  })
-
-  it('tracks rate limits per IP address', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 2 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    // IP A uses its 2 requests
-    await request('get', '/api/test', { ip: '10.0.0.1' })
-    await request('get', '/api/test', { ip: '10.0.0.1' })
-    const limitedA = await request('get', '/api/test', { ip: '10.0.0.1' })
-    expect(limitedA.status).toBe(429)
-
-    // IP B should still be allowed
-    const okB = await request('get', '/api/test', { ip: '10.0.0.2' })
-    expect(okB.status).toBe(200)
-  })
-
-  it('supports per-method rate limits that override endpoint-level', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 10 },       // general: 10 rps
-      getRateLimit: { maxRequests: 2 },      // GET: 2 rps
-      get: async () => ({ method: 'get' }),
-      post: async () => ({ method: 'post' }),
-    })
-    endpoint.mount(app)
-
-    // GET should be limited at 2
-    await request('get', '/api/test')
-    await request('get', '/api/test')
-    const limited = await request('get', '/api/test')
-    expect(limited.status).toBe(429)
-
-    // POST should still use the general limit of 10
-    for (let i = 0; i < 10; i++) {
-      const res = await request('post', '/api/test')
-      expect(res.status).toBe(200)
-    }
-    const postLimited = await request('post', '/api/test')
-    expect(postLimited.status).toBe(429)
-  })
-
-  it('does not rate limit when no rateLimit is set', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    // Should handle many requests without 429
-    for (let i = 0; i < 100; i++) {
-      const res = await request('get', '/api/test')
-      expect(res.status).toBe(200)
-    }
-  })
-
-  it('resets the window after time passes', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 2, windowSeconds: 0.1 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    await request('get', '/api/test')
-    await request('get', '/api/test')
-    const limited = await request('get', '/api/test')
-    expect(limited.status).toBe(429)
-
-    // Wait for the 100ms window to expire
-    await new Promise((resolve) => setTimeout(resolve, 150))
-
-    const allowed = await request('get', '/api/test')
-    expect(allowed.status).toBe(200)
-  })
-
-  it('rateLimitFor returns correct config', () => {
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 10 },
-      postRateLimit: { maxRequests: 2 },
-      get: async () => ({}),
-      post: async () => ({}),
-    })
-
-    // GET falls back to endpoint-level rateLimit
-    expect(endpoint.rateLimitFor('get')).toEqual({ maxRequests: 10 })
-    // POST uses its own override
-    expect(endpoint.rateLimitFor('post')).toEqual({ maxRequests: 2 })
-    // DELETE has no handler but we can still query the config
-    expect(endpoint.rateLimitFor('delete')).toEqual({ maxRequests: 10 })
-  })
-
-  it('rateLimiter.reset() clears all tracking', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 1 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    await request('get', '/api/test')
-    const limited = await request('get', '/api/test')
-    expect(limited.status).toBe(429)
-
-    // Reset the limiter
-    endpoint.rateLimiter.reset()
-
-    const allowed = await request('get', '/api/test')
-    expect(allowed.status).toBe(200)
-  })
-
-  it('does not increment requestCount on rate-limited requests', async () => {
-    const { app, request } = createMockApp()
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 2 },
-      get: async () => ({ ok: true }),
-    })
-    endpoint.mount(app)
-
-    await request('get', '/api/test')
-    await request('get', '/api/test')
-    await request('get', '/api/test') // rate limited
-
-    expect(endpoint.state.get('requestCount')).toBe(2)
-  })
-
-  it('includes 429 in OpenAPI spec when rate limit is configured', () => {
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      rateLimit: { maxRequests: 5 },
-      get: async () => ({}),
-    })
-
-    const spec = endpoint.toOpenAPIPathItem()
-    expect(spec.get.responses['429']).toEqual({ description: 'Rate limit exceeded' })
-  })
-
-  it('omits 429 from OpenAPI spec when no rate limit is configured', () => {
-    const endpoint = createEndpoint({
-      path: '/api/test',
-      get: async () => ({}),
-    })
-
-    const spec = endpoint.toOpenAPIPathItem()
-    expect(spec.get.responses['429']).toBeUndefined()
-  })
-})