fix: cjs build (#33)

locate-character does not export a CJS module so we need to transpile it
to ESM at build time.

Author: geclos

.gitignore

@@ -57,3 +57,4 @@ TODO.md
 .env.sentry-build-plugin
 bin
 
+AGENTS.md

package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptl-ai",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "author": "Latitude Data",
   "license": "MIT",
   "description": "Compiler for PromptL, the prompt language",
@@ -39,16 +39,16 @@
     "code-red": "^1.0.3",
     "fast-sha256": "^1.3.0",
     "locate-character": "^3.0.0",
-    "yaml": "^2.4.5",
     "openai": "^4.98.0",
+    "yaml": "^2.4.5",
     "zod": "^3.23.8"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.17.0",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-node-resolve": "^15.3.1",
     "@rollup/plugin-typescript": "^11.1.6",
     "@types/estree": "^1.0.1",
     "@types/node": "^20.12.12",

pnpm-lock.yaml

@@ -4,6 +4,7 @@ import * as url from 'url'
 import alias from '@rollup/plugin-alias'
 import typescript from '@rollup/plugin-typescript'
 import { dts } from 'rollup-plugin-dts'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
 
 /**
  * We have a internal circular dependency in the compiler,
@@ -39,6 +40,7 @@ export default [
       { file: 'dist/index.cjs', format: 'cjs' },
     ],
     plugins: [
+      nodeResolve(),
       typescript({
         noEmit: true,
         tsconfig: './tsconfig.json',
@@ -48,8 +50,6 @@ export default [
     external: [
       'openai',
       'acorn',
-      'locate-character',
-      'code-red',
       'node:crypto',
       'yaml',
       'crypto',

rollup.config.mjs

@@ -0,0 +1,145 @@
+import { execSync } from 'child_process'
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { describe, expect, it, beforeAll } from 'vitest'
+
+const DIST_DIR = join(process.cwd(), 'dist')
+const CJS_FILE = join(DIST_DIR, 'index.cjs')
+const ESM_FILE = join(DIST_DIR, 'index.js')
+const DTS_FILE = join(DIST_DIR, 'index.d.ts')
+
+describe('Build Output Verification', () => {
+  beforeAll(() => {
+    // Ensure build exists
+    if (!existsSync(DIST_DIR)) {
+      execSync('pnpm build', { stdio: 'inherit' })
+    }
+  })
+
+  it('should generate all required build files', () => {
+    expect(existsSync(CJS_FILE)).toBe(true)
+    expect(existsSync(ESM_FILE)).toBe(true)
+    expect(existsSync(DTS_FILE)).toBe(true)
+  })
+
+  it('should generate valid CommonJS format', () => {
+    const cjsContent = readFileSync(CJS_FILE, 'utf8')
+    
+    // Should start with 'use strict'
+    expect(cjsContent).toMatch(/^'use strict'/)
+    
+    // Should use require() for dependencies
+    expect(cjsContent).toMatch(/require\(['"]/)
+    
+    // Should not contain ES6 import statements
+    expect(cjsContent).not.toMatch(/^import\s+/)
+  })
+
+  it('should generate valid ES module format', () => {
+    const esmContent = readFileSync(ESM_FILE, 'utf8')
+    
+    // Should use import statements
+    expect(esmContent).toMatch(/^import\s+/)
+    
+    // Should not contain require() calls
+    expect(esmContent).not.toMatch(/require\(['"]/)
+  })
+
+  it('should generate TypeScript definitions', () => {
+    const dtsContent = readFileSync(DTS_FILE, 'utf8')
+    
+    // Should contain export declarations
+    expect(dtsContent).toMatch(/export\s+/)
+    
+    // Should contain key function types
+    expect(dtsContent).toMatch(/parse/)
+    expect(dtsContent).toMatch(/render/)
+  })
+
+  it('should load CJS build correctly', async () => {
+    // Use dynamic require to avoid bundler issues
+    const cjsModule = await import(CJS_FILE)
+    
+    expect(typeof cjsModule.parse).toBe('function')
+    expect(typeof cjsModule.render).toBe('function')
+    expect(typeof cjsModule.createChain).toBe('function')
+    expect(cjsModule.CompileError).toBeDefined()
+    
+    // Should have all expected exports
+    const exports = Object.keys(cjsModule)
+    expect(exports).toContain('parse')
+    expect(exports).toContain('render')
+    expect(exports).toContain('CompileError')
+    expect(exports).toContain('ContentType')
+    expect(exports).toContain('MessageRole')
+  })
+
+  it('should load ESM build correctly', async () => {
+    const esmModule = await import(ESM_FILE)
+    
+    expect(typeof esmModule.parse).toBe('function')
+    expect(typeof esmModule.render).toBe('function')
+    expect(typeof esmModule.createChain).toBe('function')
+    expect(esmModule.CompileError).toBeDefined()
+    
+    // Should have all expected exports
+    const exports = Object.keys(esmModule)
+    expect(exports).toContain('parse')
+    expect(exports).toContain('render')
+    expect(exports).toContain('CompileError')
+    expect(exports).toContain('ContentType')
+    expect(exports).toContain('MessageRole')
+  })
+
+  it('should have functional parse and render in CJS build', async () => {
+    const { parse, render } = await import(CJS_FILE)
+    
+    const template = 'Hello {{name}}!'
+    const parsed = parse(template)
+    
+    expect(parsed).toBeDefined()
+    expect(parsed.type).toBe('Fragment')
+    
+    const rendered = await render({ 
+      prompt: template, 
+      parameters: { name: 'World' } 
+    })
+    
+    expect(rendered).toBeDefined()
+    expect(rendered.messages).toBeDefined()
+    expect(rendered.config).toBeDefined()
+    expect(Array.isArray(rendered.messages)).toBe(true)
+  })
+
+  it('should have functional parse and render in ESM build', async () => {
+    const { parse, render } = await import(ESM_FILE)
+    
+    const template = 'Hello {{name}}!'
+    const parsed = parse(template)
+    
+    expect(parsed).toBeDefined()
+    expect(parsed.type).toBe('Fragment')
+    
+    const rendered = await render({ 
+      prompt: template, 
+      parameters: { name: 'World' } 
+    })
+    
+    expect(rendered).toBeDefined()
+    expect(rendered.messages).toBeDefined()
+    expect(rendered.config).toBeDefined()
+    expect(Array.isArray(rendered.messages)).toBe(true)
+  })
+
+  it('should have identical exports between CJS and ESM builds', async () => {
+    const cjsModule = await import(CJS_FILE)
+    const esmModule = await import(ESM_FILE)
+    
+    // Filter out 'default' export which is expected to differ between CJS and ESM
+    const cjsExports = Object.keys(cjsModule).filter(key => key !== 'default').sort()
+    const esmExports = Object.keys(esmModule).filter(key => key !== 'default').sort()
+    
+    expect(cjsExports).toEqual(esmExports)
+    expect(cjsExports.length).toBeGreaterThan(10) // Ensure we have substantial exports
+  })
+})