tjs-lang 0.2.8 → 0.3.0

package/src/lang/typescript-syntax.test.ts

@@ -42,7 +42,7 @@ describe('Basic Types', () => {
           return x * 2
         }
       `)
-      expect(getFirstFunc(metadata).params.x.type.kind).toBe('number')
+      expect(getFirstFunc(metadata).params.x.type.kind).toBe('integer')
     })
 
     test('boolean parameter', () => {
@@ -76,7 +76,7 @@ describe('Basic Types', () => {
         'string'
       )
       expect(getFirstFunc(metadata).params.user.type.shape?.age.kind).toBe(
-        'number'
+        'integer'
       )
     })
 
@@ -101,7 +101,9 @@ describe('Basic Types', () => {
         }
       `)
       expect(getFirstFunc(metadata).params.nums.type.kind).toBe('array')
-      expect(getFirstFunc(metadata).params.nums.type.items?.kind).toBe('number')
+      expect(getFirstFunc(metadata).params.nums.type.items?.kind).toBe(
+        'integer'
+      )
     })
 
     test('array of objects', () => {
@@ -729,7 +731,7 @@ describe('Literal Types', () => {
         return n
       }
     `)
-    expect(getFirstFunc(metadata).params.n.type.kind).toBe('number')
+    expect(getFirstFunc(metadata).params.n.type.kind).toBe('integer')
   })
 
   test('literal union type alias emits TJS Union', () => {

package/src/types/Type.test.ts

@@ -137,6 +137,70 @@ describe('Type()', () => {
       expect(Email.check(Email.example)).toBe(true)
     })
   })
+
+  describe('Schema examples support', () => {
+    it('extracts examples from schema metadata', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob', 'charlie'] })
+      )
+
+      expect(Username.examples).toEqual(['alice', 'bob', 'charlie'])
+    })
+
+    it('sets example to first schema example when no explicit example given', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob'] })
+      )
+
+      expect(Username.example).toBe('alice')
+    })
+
+    it('preserves explicit example over schema examples', () => {
+      const Username = Type(
+        'username',
+        s.string.meta({ examples: ['alice', 'bob'] }),
+        'explicit_user'
+      )
+
+      expect(Username.example).toBe('explicit_user')
+      expect(Username.examples).toEqual(['alice', 'bob'])
+    })
+
+    it('has no examples when schema lacks metadata', () => {
+      const Name = Type('name', s.string)
+
+      expect(Name.examples).toBeUndefined()
+    })
+
+    it('has no examples for predicate-based types', () => {
+      const Even = Type(
+        'even number',
+        (n) => typeof n === 'number' && n % 2 === 0
+      )
+
+      expect(Even.examples).toBeUndefined()
+    })
+
+    it('has no examples for simple form', () => {
+      const Name = Type('name', 'Alice')
+
+      expect(Name.examples).toBeUndefined()
+      expect(Name.example).toBe('Alice')
+    })
+
+    it('validates using schema even with examples', () => {
+      const ShortString = Type(
+        'short string',
+        s.string.max(5).meta({ examples: ['hi', 'hey'] })
+      )
+
+      expect(ShortString.check('hi')).toBe(true)
+      expect(ShortString.check('toolong')).toBe(false)
+      expect(ShortString.examples).toEqual(['hi', 'hey'])
+    })
+  })
 })
 
 describe('Built-in Types', () => {

package/src/types/Type.ts

@@ -40,8 +40,10 @@ export interface RuntimeType<T = unknown> {
   readonly schema?: Schema
   /** The predicate function (if predicate-based) */
   readonly predicate?: (value: unknown) => boolean
-  /** Example value (for documentation and implicit testing) */
+  /** Example value (for documentation and signature testing) */
   readonly example?: T
+  /** Multiple example values (from schema metadata, for autocomplete hints) */
+  readonly examples?: T[]
   /** Default value (for instantiation) */
   readonly default?: T
   /** Brand for type identification */
@@ -150,6 +152,24 @@ export function Type<T = unknown>(
     description = schemaToDescription(schema)
   }
 
+  // Extract examples from schema metadata (if any)
+  let examples: T[] | undefined
+  if (schema) {
+    const jsonSchema = (schema as any)?.schema ?? schema
+    if (
+      jsonSchema &&
+      typeof jsonSchema === 'object' &&
+      Array.isArray((jsonSchema as any).examples)
+    ) {
+      examples = (jsonSchema as any).examples as T[]
+    }
+  }
+
+  // If no explicit example was provided, use first schema example for autocomplete
+  if (example === undefined && examples && examples.length > 0) {
+    example = examples[0]
+  }
+
   // Build the check function
   const check = (value: unknown): value is T => {
     if (predicate) {
@@ -167,6 +187,7 @@ export function Type<T = unknown>(
     schema,
     predicate,
     example,
+    examples,
     default: defaultValue,
     __runtimeType: true as const,
   }

package/src/use-cases/transpiler-integration.test.ts

@@ -134,7 +134,7 @@ describe('Transpiler Integration', () => {
       expect(signature.parameters.query.type.kind).toBe('string')
       expect(signature.parameters.query.required).toBe(true)
       expect(signature.parameters.query.description).toBe('Search terms')
-      expect(signature.parameters.limit.type.kind).toBe('number')
+      expect(signature.parameters.limit.type.kind).toBe('integer')
       expect(signature.parameters.limit.required).toBe(false)
       expect(signature.parameters.limit.default).toBe(10)
       expect(signature.parameters.limit.description).toBe('Max results')
@@ -153,7 +153,7 @@ describe('Transpiler Integration', () => {
       expect(signature.parameters.user.type.kind).toBe('object')
       expect(signature.parameters.user.type.shape?.name.kind).toBe('string')
       expect(signature.parameters.user.type.shape?.email.kind).toBe('string')
-      expect(signature.parameters.user.type.shape?.age.kind).toBe('number')
+      expect(signature.parameters.user.type.shape?.age.kind).toBe('integer')
       expect(signature.parameters.user.required).toBe(true)
 
       expect(signature.parameters.options.type.kind).toBe('object')
@@ -383,16 +383,16 @@ describe('Transpiler Integration', () => {
           let answer = ''
           let valid = false
           let tries = 0
-          
+
           while (!valid && tries < 3) {
             answer = llmPredict({ prompt: question })
             tries = tries + 1
-            
+
             if (answer == 'A' || answer == 'B' || answer == 'C' || answer == 'D') {
               valid = true
             }
           }
-          
+
           return { answer, tries, valid }
         }
       `)
@@ -772,9 +772,9 @@ describe('Transpiler Integration', () => {
       const ast = ajs(`
         function test() {
           let d = Date('2024-06-15T10:30:00Z')
-          return { 
-            year: d.year, 
-            month: d.month, 
+          return {
+            year: d.year,
+            month: d.month,
             day: d.day,
             hours: d.hours,
             minutes: d.minutes
@@ -826,7 +826,7 @@ describe('Transpiler Integration', () => {
       const ast = ajs(`
         function test() {
           let d = Date('2024-06-15T14:30:45Z')
-          return { 
+          return {
             iso: d.format('ISO'),
             date: d.format('date'),
             custom: d.format('YYYY-MM-DD')
@@ -847,7 +847,7 @@ describe('Transpiler Integration', () => {
         function test() {
           let a = Date('2024-01-15')
           let b = Date('2024-01-20')
-          return { 
+          return {
             aBeforeB: a.isBefore(b),
             aAfterB: a.isAfter(b)
           }

package/src/vm/atoms/batteries.ts

@@ -145,6 +145,7 @@ export const llmPredictBattery = defineAtom(
     responseFormat: s.any.optional,
   }),
   s.object({
+    role: s.string.optional,
     content: s.string.optional,
     tool_calls: s.array(s.any).optional,
   }),
@@ -189,6 +190,7 @@ export const llmVision = defineAtom(
     responseFormat: s.any.optional,
   }),
   s.object({
+    role: s.string.optional,
     content: s.string.optional,
     tool_calls: s.array(s.any).optional,
   }),