luca 2.0.0 → 3.0.0

package/test/assistant.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { AGIContainer } from '../src/agi/container.server'
+
+describe('Assistant', () => {
+	let container: AGIContainer
+
+	beforeEach(() => {
+		container = new AGIContainer()
+	})
+
+	describe('codingAssistant', () => {
+		it('loads a non-empty system prompt from CORE.md', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			expect(assistant.systemPrompt.length).toBeGreaterThan(0)
+			expect(assistant.systemPrompt).toContain('coding assistant')
+		})
+
+		it('loads tools from codingTools feature after start', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
+			const tools = assistant.availableTools
+			expect(tools).toContain('rg')
+			expect(tools).toContain('ls')
+			expect(tools).toContain('cat')
+			expect(tools.length).toBeGreaterThan(0)
+		})
+
+		it('tools have descriptions and parameter schemas', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
+			const { rg, ls, cat } = assistant.tools
+			expect(rg.description.length).toBeGreaterThan(0)
+			expect(rg.parameters.type).toBe('object')
+			expect(rg.parameters.properties).toHaveProperty('args')
+			expect(ls.parameters.properties).toHaveProperty('args')
+			expect(cat.parameters.properties).toHaveProperty('args')
+		})
+
+		it('loads hooks from hooks.ts via the VM', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			const hooks = assistant.state.get('hooks') as Record<string, Function>
+			expect(hooks).toBeDefined()
+			expect(typeof hooks.started).toBe('function')
+		})
+
+		it('hooks fire when the assistant starts', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+
+			// triggerHook emits 'hookFired' with the hook name each time a hook runs
+			const fired: string[] = []
+			assistant.on('hookFired', (eventName: string) => { fired.push(eventName) })
+
+			await assistant.start()
+			expect(fired).toContain('started')
+		})
+
+		it('tools are wired into the conversation after start', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
+			const convTools = assistant.conversation.tools
+			expect(Object.keys(convTools)).toContain('rg')
+			expect(Object.keys(convTools)).toContain('ls')
+		})
+	})
+})

package/test/bus.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test'
+import { Bus } from '../src/bus'
+
+describe('Bus', () => {
+  it('emits events to listeners', () => {
+    const bus = new Bus()
+    const listener = mock()
+    bus.on('test', listener)
+    bus.emit('test', 'arg1', 'arg2')
+    expect(listener).toHaveBeenCalledWith('arg1', 'arg2')
+  })
+
+  it('supports multiple listeners', () => {
+    const bus = new Bus()
+    const a = mock()
+    const b = mock()
+    bus.on('event', a)
+    bus.on('event', b)
+    bus.emit('event', 42)
+    expect(a).toHaveBeenCalledWith(42)
+    expect(b).toHaveBeenCalledWith(42)
+  })
+
+  it('off removes a specific listener', () => {
+    const bus = new Bus()
+    const listener = mock()
+    bus.on('test', listener)
+    bus.off('test', listener)
+    bus.emit('test')
+    expect(listener).not.toHaveBeenCalled()
+  })
+
+  it('off without listener removes all listeners for event', () => {
+    const bus = new Bus()
+    const a = mock()
+    const b = mock()
+    bus.on('test', a)
+    bus.on('test', b)
+    bus.off('test')
+    bus.emit('test')
+    expect(a).not.toHaveBeenCalled()
+    expect(b).not.toHaveBeenCalled()
+  })
+
+  it('once fires only once', () => {
+    const bus = new Bus()
+    const listener = mock()
+    bus.once('test', listener)
+    bus.emit('test', 'first')
+    bus.emit('test', 'second')
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(listener).toHaveBeenCalledWith('first')
+  })
+
+  it('waitFor returns a promise that resolves on emit', async () => {
+    const bus = new Bus()
+    const promise = bus.waitFor('done')
+    bus.emit('done', 'result')
+    const value = await promise
+    expect(value).toBe('result')
+  })
+
+  it('emit with no listeners does not throw', () => {
+    const bus = new Bus()
+    expect(() => bus.emit('nope')).not.toThrow()
+  })
+
+  describe('event stats tracking', () => {
+    it('tracks fire count for events', () => {
+      const bus = new Bus()
+      bus.emit('click')
+      bus.emit('click')
+      bus.emit('click')
+      const stats = bus.getEventStats('click')
+      expect(stats.fireCount).toBe(3)
+      expect(stats.event).toBe('click')
+    })
+
+    it('tracks lastFiredAt timestamp', () => {
+      const bus = new Bus()
+      const before = Date.now()
+      bus.emit('ping')
+      const after = Date.now()
+      const stats = bus.getEventStats('ping')
+      expect(stats.lastFiredAt).toBeGreaterThanOrEqual(before)
+      expect(stats.lastFiredAt).toBeLessThanOrEqual(after)
+    })
+
+    it('returns zero stats for events that never fired', () => {
+      const bus = new Bus()
+      const stats = bus.getEventStats('ghost')
+      expect(stats.fireCount).toBe(0)
+      expect(stats.lastFiredAt).toBeNull()
+      expect(stats.firesPerMinute).toBe(0)
+    })
+
+    it('history returns stats for all fired events', () => {
+      const bus = new Bus()
+      bus.emit('a')
+      bus.emit('b')
+      bus.emit('b')
+      bus.emit('c')
+      const history = bus.history
+      expect(history).toHaveLength(3)
+      expect(history.find(s => s.event === 'a')?.fireCount).toBe(1)
+      expect(history.find(s => s.event === 'b')?.fireCount).toBe(2)
+      expect(history.find(s => s.event === 'c')?.fireCount).toBe(1)
+    })
+
+    it('firedEvents lists all event names that have been emitted', () => {
+      const bus = new Bus()
+      bus.emit('x')
+      bus.emit('y')
+      bus.emit('x')
+      expect(bus.firedEvents).toEqual(['x', 'y'])
+    })
+
+    it('tracks events even with no listeners', () => {
+      const bus = new Bus()
+      bus.emit('orphan')
+      bus.emit('orphan')
+      expect(bus.getEventStats('orphan').fireCount).toBe(2)
+    })
+
+    it('computes firesPerMinute for recent events', () => {
+      const bus = new Bus()
+      bus.emit('rapid')
+      bus.emit('rapid')
+      bus.emit('rapid')
+      const stats = bus.getEventStats('rapid')
+      expect(stats.firesPerMinute).toBe(3)
+    })
+  })
+})

package/test/clients-servers.test.ts

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

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