luca 3.0.0 → 3.0.2

package/test/clients-servers.test.ts

@@ -1,217 +0,0 @@
-import { describe, it, expect, spyOn } from 'bun:test'
-import { NodeContainer } from '../src/node/container'
-import { WebSocketClient } from '../src/clients/websocket'
-import { GraphClient } from '../src/clients/graph'
-
-describe('Clients', () => {
-  it('container has clients registry after construction', () => {
-    const c = new NodeContainer()
-    expect(c.clients).toBeDefined()
-    expect(typeof c.clients.has).toBe('function')
-    expect(typeof c.clients.lookup).toBe('function')
-  })
-
-  it('has rest and graph clients registered', () => {
-    const c = new NodeContainer()
-    expect(c.clients.available).toContain('rest')
-    expect(c.clients.available).toContain('graph')
-  })
-
-  it('container.client() factory creates a client', () => {
-    const c = new NodeContainer()
-    const rest = c.client('rest', { baseURL: 'https://example.com' })
-    expect(rest).toBeDefined()
-    expect(rest.uuid).toBeDefined()
-    expect(rest.baseURL).toBe('https://example.com')
-  })
-
-  it('client has state with connected=false initially', () => {
-    const c = new NodeContainer()
-    const rest = c.client('rest')
-    expect(rest.isConnected).toBe(false)
-  })
-
-  it('client.connect() sets connected state', async () => {
-    const c = new NodeContainer()
-    const rest = c.client('rest')
-    await rest.connect()
-    expect(rest.isConnected).toBe(true)
-  })
-
-  it('client has access to container via context', () => {
-    const c = new NodeContainer()
-    const rest = c.client('rest')
-    expect(rest.container.uuid).toBe(c.uuid)
-  })
-})
-
-describe('WebSocketClient', () => {
-  it('is registered as websocket client', () => {
-    const c = new NodeContainer()
-    expect(c.clients.available).toContain('websocket')
-  })
-
-  it('factory creates a WebSocketClient instance', () => {
-    const c = new NodeContainer()
-    const ws = c.client('websocket', { baseURL: 'ws://localhost:8080' })
-    expect(ws).toBeDefined()
-    expect(ws).toBeInstanceOf(WebSocketClient)
-    expect(ws.baseURL).toBe('ws://localhost:8080')
-  })
-
-  it('starts disconnected with correct initial state', () => {
-    const c = new NodeContainer()
-    const ws = c.client('websocket', { baseURL: 'ws://localhost:8080' })
-    expect(ws.isConnected).toBe(false)
-    expect(ws.hasError).toBe(false)
-    expect(ws.state.get('reconnectAttempts')).toBe(0)
-  })
-
-  it('has send and disconnect methods', () => {
-    const c = new NodeContainer()
-    const ws = c.client('websocket', { baseURL: 'ws://localhost:8080' })
-    expect(typeof ws.send).toBe('function')
-    expect(typeof ws.disconnect).toBe('function')
-  })
-
-  it('accepts reconnect options', () => {
-    const c = new NodeContainer()
-    const ws = c.client('websocket', {
-      baseURL: 'ws://localhost:8080',
-      reconnect: true,
-      reconnectInterval: 2000,
-      maxReconnectAttempts: 5,
-    })
-    expect(ws.options.reconnect).toBe(true)
-    expect(ws.options.reconnectInterval).toBe(2000)
-    expect(ws.options.maxReconnectAttempts).toBe(5)
-  })
-
-  it('has proper event and state schemas', () => {
-    expect(WebSocketClient.eventsSchema).toBeDefined()
-    expect(WebSocketClient.stateSchema).toBeDefined()
-    expect(WebSocketClient.optionsSchema).toBeDefined()
-  })
-})
-
-describe('GraphClient', () => {
-  it('is registered as graph client', () => {
-    const c = new NodeContainer()
-    expect(c.clients.available).toContain('graph')
-  })
-
-  it('factory creates a GraphClient instance', () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-    expect(gql).toBeDefined()
-    expect(gql).toBeInstanceOf(GraphClient)
-  })
-
-  it('extends RestClient with HTTP methods', () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-    expect(typeof gql.get).toBe('function')
-    expect(typeof gql.post).toBe('function')
-    expect(typeof gql.put).toBe('function')
-    expect(typeof gql.delete).toBe('function')
-    expect(typeof gql.patch).toBe('function')
-  })
-
-  it('has query and mutate methods', () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-    expect(typeof gql.query).toBe('function')
-    expect(typeof gql.mutate).toBe('function')
-  })
-
-  it('defaults endpoint to /graphql', () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-    expect(gql.endpoint).toBe('/graphql')
-  })
-
-  it('accepts custom endpoint option', () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com', endpoint: '/api/graphql' })
-    expect(gql.endpoint).toBe('/api/graphql')
-  })
-
-  it('query() posts to the endpoint and unwraps data', async () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-
-    // Mock the post method to simulate a GraphQL response
-    spyOn(gql, 'post').mockResolvedValue({
-      data: { user: { name: 'Jon' } },
-    })
-
-    const result = await gql.query('{ user { name } }')
-    expect(result).toEqual({ user: { name: 'Jon' } })
-    expect(gql.post).toHaveBeenCalledWith('/graphql', { query: '{ user { name } }' })
-  })
-
-  it('query() passes variables and operationName', async () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-
-    spyOn(gql, 'post').mockResolvedValue({
-      data: { user: { name: 'Jon' } },
-    })
-
-    await gql.query('query GetUser($id: ID!) { user(id: $id) { name } }', { id: '1' }, 'GetUser')
-    expect(gql.post).toHaveBeenCalledWith('/graphql', {
-      query: 'query GetUser($id: ID!) { user(id: $id) { name } }',
-      variables: { id: '1' },
-      operationName: 'GetUser',
-    })
-  })
-
-  it('mutate() posts to the endpoint and unwraps data', async () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-
-    spyOn(gql, 'post').mockResolvedValue({
-      data: { createUser: { id: '1' } },
-    })
-
-    const result = await gql.mutate('mutation { createUser(name: "Jon") { id } }')
-    expect(result).toEqual({ createUser: { id: '1' } })
-  })
-
-  it('emits graphqlError and failure on GraphQL-level errors', async () => {
-    const c = new NodeContainer()
-    const gql = c.client('graph', { baseURL: 'https://api.example.com' })
-    const errors = [{ message: 'Not found' }]
-
-    spyOn(gql, 'post').mockResolvedValue({
-      data: null,
-      errors,
-    })
-
-    const graphqlErrors: any[] = []
-    const failures: any[] = []
-    gql.on('graphqlError', (errs: any) => graphqlErrors.push(errs))
-    gql.on('failure', (err: any) => failures.push(err))
-
-    const result = await gql.query('{ user { name } }')
-    expect(result).toBeNull()
-    expect(graphqlErrors).toHaveLength(1)
-    expect(graphqlErrors[0]).toEqual(errors)
-    expect(failures).toHaveLength(1)
-    expect(failures[0]).toEqual(errors)
-  })
-})
-
-describe('Servers', () => {
-  it('container has servers registry after construction', () => {
-    const c = new NodeContainer()
-    expect(c.servers).toBeDefined()
-    expect(typeof c.servers.has).toBe('function')
-  })
-
-  it('has express and websocket servers registered', () => {
-    const c = new NodeContainer()
-    expect(c.servers.available).toContain('express')
-    expect(c.servers.available).toContain('websocket')
-  })
-})

package/test/command.test.ts

@@ -1,267 +0,0 @@
-import { describe, it, expect } from 'bun:test'
-import { Command, commands } from '../src/command'
-import { graftModule, isNativeHelperClass } from '../src/graft'
-import { NodeContainer } from '../src/node/container'
-import { z } from 'zod'
-import { CommandOptionsSchema } from '../src/schemas/base'
-// Side-effect import to register built-in commands
-import '../src/commands/index'
-
-describe('graftModule', () => {
-	it('creates a Command subclass from a run export', () => {
-		const argsSchema = CommandOptionsSchema.extend({
-			file: z.string(),
-		})
-
-		const Grafted = graftModule(Command as any, {
-			description: 'Run a file',
-			argsSchema,
-			positionals: ['file'],
-			run: async (args: any) => {},
-		}, 'graft-run-test', 'commands')
-
-		expect((Grafted as any).shortcut).toBe('commands.graft-run-test')
-		expect((Grafted as any).description).toBe('Run a file')
-		expect((Grafted as any).commandDescription).toBe('Run a file')
-		expect((Grafted as any).positionals).toEqual(['file'])
-		expect((Grafted as any).argsSchema).toBe(argsSchema)
-		expect(Grafted.name).toBe('GraftRunTestCommand')
-	})
-
-	it('creates a Command subclass from a handler export (legacy)', () => {
-		const Grafted = graftModule(Command as any, {
-			description: 'Legacy handler',
-			handler: async (opts: any, ctx: any) => {},
-		}, 'graft-handler-test', 'commands')
-
-		expect((Grafted as any).shortcut).toBe('commands.graft-handler-test')
-		expect((Grafted as any).description).toBe('Legacy handler')
-		expect(typeof (Grafted as any).prototype.run).toBe('function')
-	})
-
-	it('grafts extra exported functions as prototype methods', () => {
-		const Grafted = graftModule(Command as any, {
-			run: async () => {},
-			formatOutput: function (data: any) { return JSON.stringify(data) },
-		}, 'graft-methods-test', 'commands')
-
-		expect(typeof (Grafted as any).prototype.formatOutput).toBe('function')
-	})
-
-	it('grafts getters onto the prototype', () => {
-		const Grafted = graftModule(Command as any, {
-			run: async () => {},
-			getters: {
-				isReady() { return true },
-			},
-		}, 'graft-getters-test', 'commands')
-
-		const desc = Object.getOwnPropertyDescriptor((Grafted as any).prototype, 'isReady')
-		expect(desc).toBeDefined()
-		expect(typeof desc!.get).toBe('function')
-	})
-})
-
-describe('isNativeHelperClass', () => {
-	it('returns true for a direct subclass', () => {
-		class MyCmd extends Command {}
-		expect(isNativeHelperClass(MyCmd, Command)).toBe(true)
-	})
-
-	it('returns false for a plain function', () => {
-		function notACommand() {}
-		expect(isNativeHelperClass(notACommand, Command)).toBe(false)
-	})
-
-	it('returns false for null/undefined', () => {
-		expect(isNativeHelperClass(null, Command)).toBe(false)
-		expect(isNativeHelperClass(undefined, Command)).toBe(false)
-	})
-
-	it('returns true for the base class itself', () => {
-		expect(isNativeHelperClass(Command, Command)).toBe(true)
-	})
-})
-
-describe('Command.register', () => {
-	it('registers a class-based command and sets shortcut', () => {
-		class TestDeployCommand extends Command {
-			static override description = 'Deploy to production'
-		}
-		Command.register(TestDeployCommand, 'test-deploy')
-
-		expect(commands.has('test-deploy')).toBe(true)
-		expect((TestDeployCommand as any).shortcut).toBe('commands.test-deploy')
-		expect((TestDeployCommand as any).commandDescription).toBe('Deploy to production')
-	})
-})
-
-describe('Command.dispatch', () => {
-	it('calls run() with parsed args for CLI dispatch', async () => {
-		let received: any = null
-
-		const argsSchema = CommandOptionsSchema.extend({
-			target: z.string().default('prod'),
-		})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			run: async (args: any, ctx: any) => { received = args },
-		}, 'dispatch-cli-test', 'commands')
-
-		commands.register('dispatch-cli-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-cli-test' as any)
-
-		await cmd.dispatch({ _: ['dispatch-cli-test'], target: 'staging' }, 'cli')
-
-		expect(received).toBeDefined()
-		expect(received.target).toBe('staging')
-	})
-
-	it('maps positionals to named args for CLI dispatch', async () => {
-		let received: any = null
-
-		const argsSchema = CommandOptionsSchema.extend({
-			file: z.string(),
-		})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			positionals: ['file'],
-			run: async (args: any, ctx: any) => { received = args },
-		}, 'dispatch-positional-test', 'commands')
-
-		commands.register('dispatch-positional-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-positional-test' as any)
-
-		// Simulate: luca dispatch-positional-test myfile.ts
-		// minimist produces: { _: ['dispatch-positional-test', 'myfile.ts'] }
-		await cmd.dispatch({ _: ['dispatch-positional-test', 'myfile.ts'] }, 'cli')
-
-		expect(received).toBeDefined()
-		expect(received.file).toBe('myfile.ts')
-	})
-
-	it('collects remaining positionals into an array when schema expects one', async () => {
-		let received: any = null
-
-		const argsSchema = CommandOptionsSchema.extend({
-			action: z.string(),
-			files: z.array(z.string()),
-		})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			positionals: ['action', 'files'],
-			run: async (args: any, ctx: any) => { received = args },
-		}, 'dispatch-glob-test', 'commands')
-
-		commands.register('dispatch-glob-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-glob-test' as any)
-
-		// Simulate: luca dispatch-glob-test process foo.md bar.md baz.md
-		// Shell expands *.md before luca sees it
-		await cmd.dispatch({ _: ['dispatch-glob-test', 'process', 'foo.md', 'bar.md', 'baz.md'] }, 'cli')
-
-		expect(received).toBeDefined()
-		expect(received.action).toBe('process')
-		expect(received.files).toEqual(['foo.md', 'bar.md', 'baz.md'])
-	})
-
-	it('passes named args through for headless dispatch', async () => {
-		let received: any = null
-
-		const argsSchema = CommandOptionsSchema.extend({
-			file: z.string(),
-		})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			positionals: ['file'],
-			run: async (args: any, ctx: any) => { received = args },
-		}, 'dispatch-headless-test', 'commands')
-
-		commands.register('dispatch-headless-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-headless-test' as any)
-
-		// Headless: named args directly, no positional mapping
-		await cmd.dispatch({ file: 'script.ts' }, 'headless')
-
-		expect(received).toBeDefined()
-		expect(received.file).toBe('script.ts')
-	})
-
-	it('captures stdout/stderr for headless dispatch', async () => {
-		const argsSchema = CommandOptionsSchema.extend({})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			run: async (args: any, ctx: any) => {
-				console.log('hello from command')
-				console.error('warning: something')
-			},
-		}, 'dispatch-capture-test', 'commands')
-
-		commands.register('dispatch-capture-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-capture-test' as any)
-
-		const result = await cmd.dispatch({}, 'headless')
-
-		expect(result).toBeDefined()
-		expect(result!.exitCode).toBe(0)
-		expect(result!.stdout).toContain('hello from command')
-		expect(result!.stderr).toContain('warning: something')
-	})
-
-	it('captures errors for headless dispatch', async () => {
-		const argsSchema = CommandOptionsSchema.extend({})
-
-		const Grafted = graftModule(Command as any, {
-			argsSchema,
-			run: async () => { throw new Error('boom') },
-		}, 'dispatch-error-test', 'commands')
-
-		commands.register('dispatch-error-test', Grafted as any)
-		const container = new NodeContainer()
-		const cmd = container.command('dispatch-error-test' as any)
-
-		const result = await cmd.dispatch({}, 'headless')
-
-		expect(result).toBeDefined()
-		expect(result!.exitCode).toBe(1)
-		expect(result!.stderr).toContain('boom')
-	})
-})
-
-describe('Command registry', () => {
-	it('has built-in commands registered', () => {
-		const container = new NodeContainer()
-		expect(container.commands.has('run')).toBe(true)
-		expect(container.commands.has('help')).toBe(true)
-		expect(container.commands.has('eval')).toBe(true)
-		expect(container.commands.has('chat')).toBe(true)
-	})
-
-	it('built-in commands still work through registerHandler', () => {
-		const container = new NodeContainer()
-		const RunClass = container.commands.lookup('run')
-		expect(typeof RunClass).toBe('function')
-		expect(typeof RunClass.prototype.run).toBe('function')
-	})
-})
-
-describe('SimpleCommand type', () => {
-	it('grafted commands have positionals as a static property', () => {
-		const Grafted = graftModule(Command as any, {
-			positionals: ['env', 'region'],
-			run: async () => {},
-		}, 'simple-cmd-type-test', 'commands')
-
-		expect((Grafted as any).positionals).toEqual(['env', 'region'])
-	})
-})