feat: improve text parsing performance (#28)

* feat: improve text parsing performance

From AI:

1. **Escape Checking**: The code rechecks all trailing backslashes in the accumulated `data` string for every character, which becomes increasingly expensive as `data` grows.

2. **String Slicing**: When an escape character is found, `data = data.slice(0, -1)` creates a new string by copying almost the entire accumulated text.

3. **Repeated String Concatenation**: Adding to `data` one character at a time with `data += char` creates a new string object each time.

4. **Regular Expression Replacements**: At the end, it uses complex regex replacements that need to scan the entire string.

5. **Repeated Delimiter Checking**: For each character, it checks against multiple delimiters with `template.startsWith()`, which involves multiple string comparisons.

Our optimization approach for the `text` method focused on several improvements:

1. **Simplified Escape Handling**:
   - Instead of recounting backslashes for every character, we now use a boolean flag `isEscaped` to track whether the current character is escaped
   - When we encounter a backslash, we toggle the escape state and skip adding it to the data string directly
   - This eliminates the expensive backslash counting operation that grew in cost with the size of the text

2. **Eliminated String Slicing**:
   - We no longer use `data.slice(0, -1)` which was creating a new string by copying almost the entire accumulated text
   - Instead, we simply don't add the backslash to the data string at all

3. **More Efficient Processing Flow**:
   - The code now has a clearer path for handling escaped characters
   - We continue to the next iteration immediately after processing an escape sequence, reducing unnecessary checks

4. **Simplified Data Processing**:
   - We removed the complex regular expression replacements at the end
   - Since we're already handling escape sequences correctly during parsing, we don't need additional processing

* feat: expose parser API (#29)

Parsing is an expensive computation, we now expose it to the client and
accept the ast as an argument in both scan method and Chain constructor,
so that clients can optimize performance.

* chore: add CD

Author: geclos

.github/workflows/publish.yml

@@ -0,0 +1,82 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    name: Build and Publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: 9
+
+      - name: Get pnpm store directory
+        shell: bash
+        run: |
+          echo "STORE_PATH=$(pnpm store path --silent)" >> $GITHUB_ENV
+
+      - name: Setup pnpm cache
+        uses: actions/cache@v3
+        with:
+          path: ${{ env.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
+      - name: Get package version
+        id: get_version
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          echo "version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+      - name: Check version on npm
+        id: check_version
+        run: |
+          NPM_VERSION=$(npm view promptl-ai version 2>/dev/null || echo "0.0.0")
+          if [ "${{ steps.get_version.outputs.version }}" != "$NPM_VERSION" ]; then
+            echo "should_publish=true" >> $GITHUB_OUTPUT
+          else
+            echo "should_publish=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Install dependencies
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm install
+
+      - name: Build package (with workspace dependencies)
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm run build
+
+      - name: Run linter
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm run lint
+
+      - name: Run typescript checker
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm run tc
+
+      - name: Run tests
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm run test
+
+      - name: Publish to npm
+        if: steps.check_version.outputs.should_publish == 'true'
+        run: pnpm publish --access public --no-git-checks
+
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptl-ai",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "author": "Latitude Data",
   "license": "MIT",
   "description": "Compiler for PromptL, the prompt language",
@@ -20,9 +20,7 @@
       }
     }
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "scripts": {
     "dev": "rollup -c -w",
     "build": "rollup -c",

rollup.config.mjs

@@ -54,6 +54,7 @@ export default [
       'yaml',
       'crypto',
       'zod',
+      'fast-sha256',
     ],
   },
   {

src/compiler/base/nodes/tags/ref.ts

@@ -1,6 +1,6 @@
 import Scope from '$promptl/compiler/scope'
 import errors from '$promptl/error/errors'
-import parse from '$promptl/parser'
+import { parse } from '$promptl/parser'
 import { Fragment, ReferenceTag } from '$promptl/parser/interfaces'
 
 import { CompileNodeContext, TemplateNodeWithStatus } from '../../types'

src/compiler/chain.ts

@@ -3,7 +3,7 @@ import {
   SerializedProps,
 } from '$promptl/compiler/deserializeChain'
 import { CHAIN_STEP_ISOLATED_ATTR } from '$promptl/constants'
-import parse from '$promptl/parser'
+import { parse } from '$promptl/parser'
 import { Fragment } from '$promptl/parser/interfaces'
 import {
   AdapterMessageType,
@@ -41,15 +41,14 @@ type BuildStepResponseContent = {
 export class Chain<M extends AdapterMessageType = Message> {
   public rawText: string
 
-  private compileOptions: CompileOptions
-  private ast: Fragment
-  private scope: Scope
-  private didStart: boolean = false
   private _completed: boolean = false
-
   private adapter: ProviderAdapter<M>
-  private globalMessages: Message[] = []
+  private ast: Fragment
+  private compileOptions: CompileOptions
+  private didStart: boolean = false
   private globalConfig: Config | undefined
+  private globalMessages: Message[] = []
+  private scope: Scope
   private wasLastStepIsolated: boolean = false
 
   static deserialize(args: SerializedProps) {
@@ -67,24 +66,21 @@ export class Chain<M extends AdapterMessageType = Message> {
     parameters?: Record<string, unknown>
     adapter?: ProviderAdapter<M>
     serialized?: {
-      ast: Fragment
-      scope: Scope
-      didStart: boolean
-      completed: boolean
-      globalConfig: Config | undefined
-      globalMessages: Message[]
+      ast?: Fragment
+      scope?: Scope
+      didStart?: boolean
+      completed?: boolean
+      globalConfig?: Config
+      globalMessages?: Message[]
     }
   } & CompileOptions) {
     this.rawText = prompt
-
-    // Init from a serialized chain
     this.ast = serialized?.ast ?? parse(prompt)
     this.scope = serialized?.scope ?? new Scope(parameters)
     this.didStart = serialized?.didStart ?? false
     this._completed = serialized?.completed ?? false
     this.globalConfig = serialized?.globalConfig
     this.globalMessages = serialized?.globalMessages ?? []
-
     this.adapter = adapter
     this.compileOptions = compileOptions
 

src/compiler/index.ts

@@ -10,6 +10,7 @@ import { z } from 'zod'
 import { Chain } from './chain'
 import { Scan } from './scan'
 import type { CompileOptions, Document, ReferencePromptFn } from './types'
+import { Fragment } from '$promptl/parser/interfaces'
 
 export async function render<M extends AdapterMessageType = Message>({
   prompt,
@@ -39,13 +40,15 @@ export function createChain({
 
 export function scan({
   prompt,
+  serialized,
   fullPath,
   referenceFn,
   withParameters,
   configSchema,
   requireConfig,
 }: {
   prompt: string
+  serialized?: Fragment
   fullPath?: string
   referenceFn?: ReferencePromptFn
   withParameters?: string[]
@@ -54,6 +57,7 @@ export function scan({
 }): Promise<ConversationMetadata> {
   return new Scan({
     document: { path: fullPath ?? '', content: prompt },
+    serialized,
     referenceFn,
     withParameters,
     configSchema,

src/compiler/scan.ts

@@ -8,7 +8,7 @@ import {
 } from '$promptl/constants'
 import CompileError, { error } from '$promptl/error/error'
 import errors from '$promptl/error/errors'
-import parse from '$promptl/parser/index'
+import { parse } from '$promptl/parser/index'
 import type {
   Attribute,
   BaseNode,
@@ -70,20 +70,24 @@ export class Scan {
   private references: { [from: string]: string[] } = {}
   private referencedHashes: string[] = []
   private referenceDepth: number = 0
+  private serialized?: Fragment
 
   constructor({
     document,
     referenceFn,
     withParameters,
     configSchema,
     requireConfig,
+    serialized,
   }: {
     document: Document
     referenceFn?: ReferencePromptFn
     withParameters?: string[]
     configSchema?: z.ZodType
     requireConfig?: boolean
+    serialized?: Fragment
   }) {
+    this.serialized = serialized
     this.rawText = document.content
     this.referenceFn = referenceFn
     this.fullPath = document.path
@@ -107,7 +111,7 @@ export class Scan {
     let fragment: Fragment
 
     try {
-      fragment = parse(this.rawText)
+      fragment = this.serialized ?? parse(this.rawText)
     } catch (e) {
       const parseError = e as CompileError
       if (parseError instanceof CompileError) {

src/index.ts

@@ -1,5 +1,6 @@
 export * from './types'
 export * from './compiler'
+export * from './parser'
 export * from './providers'
 
 export { default as CompileError } from './error/error'

src/parser/index.ts

@@ -7,7 +7,7 @@ import type { BaseNode, Fragment } from './interfaces'
 import fragment from './state/fragment'
 import fullCharCodeAt from './utils/full_char_code_at'
 
-export default function parse(template: string) {
+export function parse(template: string) {
   return new Parser(template).parse()
 }
 

src/parser/parser.test.ts

@@ -3,7 +3,7 @@ import CompileError from '$promptl/error/error'
 import { getExpectedError } from '$promptl/test/helpers'
 import { describe, expect, it } from 'vitest'
 
-import parse from '.'
+import { parse } from '.'
 import { TemplateNode } from './interfaces'
 
 describe('Fragment', async () => {