✨(schema): Add YAML schema deparser for LLM context optimization

frontend/internal-packages/agent/src/db-agent/nodes/designSchemaNode.ts

@@ -1,5 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables'
-import { convertSchemaToText } from '../../utils/convertSchemaToText'
+import { yamlSchemaDeparser } from '@liam-hq/schema'
+import { Result } from 'neverthrow'
 import { WorkflowTerminationError } from '../../utils/errorHandling'
 import { getConfigurable } from '../../utils/getConfigurable'
 import { removeReasoningFromMessages } from '../../utils/messageCleanup'
@@ -14,16 +15,15 @@ export async function designSchemaNode(
   state: DbAgentState,
   config: RunnableConfig,
 ): Promise<DbAgentState> {
-  const configurableResult = getConfigurable(config)
-  if (configurableResult.isErr()) {
-    throw new WorkflowTerminationError(
-      configurableResult.error,
-      'designSchemaNode',
-    )
-  }
-  const { repositories } = configurableResult.value
+  const combinedResult = Result.combine([
+    getConfigurable(config),
+    yamlSchemaDeparser(state.schemaData),
+  ])
 
-  const schemaText = convertSchemaToText(state.schemaData)
+  if (combinedResult.isErr()) {
+    throw new WorkflowTerminationError(combinedResult.error, 'designSchemaNode')
+  }
+  const [{ repositories }, schemaText] = combinedResult.value
 
   // Remove reasoning field from AIMessages to avoid API issues
   // This prevents the "reasoning without required following item" error

frontend/internal-packages/agent/src/pm-agent/nodes/analyzeRequirementsNode.ts

@@ -1,5 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables'
-import { convertSchemaToText } from '../../utils/convertSchemaToText'
+import { yamlSchemaDeparser } from '@liam-hq/schema'
+import { Result } from 'neverthrow'
 import { WorkflowTerminationError } from '../../utils/errorHandling'
 import { getConfigurable } from '../../utils/getConfigurable'
 import { invokePmAnalysisAgent } from '../invokePmAnalysisAgent'
@@ -13,20 +14,24 @@ export async function analyzeRequirementsNode(
   state: PmAgentState,
   config: RunnableConfig,
 ): Promise<Partial<PmAgentState>> {
-  const configurableResult = getConfigurable(config)
-  if (configurableResult.isErr()) {
+  const combinedResult = Result.combine([
+    getConfigurable(config),
+    yamlSchemaDeparser(state.schemaData),
+  ])
+
+  if (combinedResult.isErr()) {
     throw new WorkflowTerminationError(
-      configurableResult.error,
+      combinedResult.error,
       'analyzeRequirementsNode',
     )
   }
 
-  const schemaText = convertSchemaToText(state.schemaData)
+  const [configurable, schemaText] = combinedResult.value
 
   const analysisResult = await invokePmAnalysisAgent(
     { schemaText },
     state.messages,
-    configurableResult.value,
+    configurable,
   )
 
   if (analysisResult.isErr()) {

frontend/internal-packages/agent/src/qa-agent/testcaseGeneration/generateTestcaseNode.ts

@@ -5,7 +5,7 @@ import {
 } from '@langchain/core/messages'
 import { ChatOpenAI } from '@langchain/openai'
 import { fromAsyncThrowable } from '@liam-hq/neverthrow'
-import { convertSchemaToText } from '../../utils/convertSchemaToText'
+import { yamlSchemaDeparser } from '@liam-hq/schema'
 import { removeReasoningFromMessages } from '../../utils/messageCleanup'
 import { streamLLMResponse } from '../../utils/streamingLlmUtils'
 import { saveTestcaseTool } from '../tools/saveTestcaseTool'
@@ -36,7 +36,11 @@ export async function generateTestcaseNode(
 ): Promise<{ messages: BaseMessage[] }> {
   const { currentTestcase, schemaData, goal, messages } = state
 
-  const schemaContext = convertSchemaToText(schemaData)
+  const schemaContextResult = yamlSchemaDeparser(schemaData)
+  if (schemaContextResult.isErr()) {
+    throw schemaContextResult.error
+  }
+  const schemaContext = schemaContextResult.value
 
   const contextMessage = await humanPromptTemplateForTestcaseGeneration.format({
     schemaContext,

frontend/internal-packages/agent/src/qa-agent/testcaseGeneration/validateSchemaRequirementsNode.ts

@@ -2,8 +2,8 @@ import { HumanMessage, SystemMessage } from '@langchain/core/messages'
 import { Command, END } from '@langchain/langgraph'
 import { ChatOpenAI } from '@langchain/openai'
 import { fromPromise } from '@liam-hq/neverthrow'
+import { yamlSchemaDeparser } from '@liam-hq/schema'
 import * as v from 'valibot'
-import { convertSchemaToText } from '../../utils/convertSchemaToText'
 import { toJsonSchema } from '../../utils/jsonSchema'
 import type { testcaseAnnotation } from './testcaseAnnotation'
 
@@ -47,7 +47,11 @@ export async function validateSchemaRequirementsNode(
 ): Promise<Command> {
   const { currentTestcase, schemaData, goal } = state
 
-  const schemaContext = convertSchemaToText(schemaData)
+  const schemaContextResult = yamlSchemaDeparser(schemaData)
+  if (schemaContextResult.isErr()) {
+    throw schemaContextResult.error
+  }
+  const schemaContext = schemaContextResult.value
 
   const contextMessage = `
 # Database Schema Context

frontend/packages/schema/package.json

@@ -23,6 +23,7 @@
     "neverthrow": "8.2.0",
     "pg-query-emscripten": "5.1.0",
     "valibot": "1.1.0",
+    "yaml": "2.8.1",
     "zod": "3.25.76"
   },
   "devDependencies": {

frontend/packages/schema/src/deparser/postgresql/operationDeparser.ts

@@ -53,7 +53,7 @@ import {
   isReplaceTableCommentOperation,
   isReplaceTableNameOperation,
 } from '../../operation/schema/table.js'
-import type { OperationDeparser } from '../type.js'
+import type { LegacyOperationDeparser } from '../type.js'
 import {
   generateAddCheckConstraintStatement,
   generateAddColumnStatement,
@@ -605,7 +605,12 @@ function generateAlterConstraintUpdateFromOperation(
   )
 }
 
-export const postgresqlOperationDeparser: OperationDeparser = (
+/**
+ * PostgreSQL operation deparser
+ * @deprecated This implementation uses LegacyOperationDeparser type.
+ * TODO: Migrate to new OperationDeparser type (Result<string, Error>) for better error handling.
+ */
+export const postgresqlOperationDeparser: LegacyOperationDeparser = (
   operation: Operation,
   // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor to reduce complexity
 ) => {

frontend/packages/schema/src/deparser/postgresql/schemaDeparser.ts

@@ -5,7 +5,7 @@ import type {
   Schema,
   Table,
 } from '../../schema/index.js'
-import type { SchemaDeparser } from '../type.js'
+import type { LegacySchemaDeparser } from '../type.js'
 import {
   generateAddConstraintStatement,
   generateCreateEnumStatement,
@@ -14,7 +14,14 @@ import {
   generateCreateTableStatement,
 } from './utils.js'
 
-export const postgresqlSchemaDeparser: SchemaDeparser = (schema: Schema) => {
+/**
+ * PostgreSQL schema deparser
+ * @deprecated This implementation uses LegacySchemaDeparser type.
+ * TODO: Migrate to new SchemaDeparser type (Result<string, Error>) for better error handling.
+ */
+export const postgresqlSchemaDeparser: LegacySchemaDeparser = (
+  schema: Schema,
+) => {
   const ddlStatements: string[] = []
   const errors: { message: string }[] = []
 

frontend/packages/schema/src/deparser/type.ts

@@ -1,14 +1,31 @@
+import type { Result } from 'neverthrow'
 import type { Operation } from '../operation/schema/index.js'
 import type { Schema } from '../schema/index.js'
 
+// Legacy types - TODO: Migrate all implementations to use the new types
 type DeparserError = {
   message: string
 }
 
-type DeparserResult = {
+type LegacyDeparserResult = {
   value: string
   errors: DeparserError[]
 }
 
-export type SchemaDeparser = (schema: Schema) => DeparserResult
-export type OperationDeparser = (operation: Operation) => DeparserResult
+/**
+ * @deprecated Use SchemaDeparser instead. This type is kept for backward compatibility.
+ * TODO: Migrate existing implementations to use the new SchemaDeparser type.
+ */
+export type LegacySchemaDeparser = (schema: Schema) => LegacyDeparserResult
+
+/**
+ * @deprecated Use OperationDeparser instead. This type is kept for backward compatibility.
+ * TODO: Migrate existing implementations to use the new OperationDeparser type.
+ */
+export type LegacyOperationDeparser = (
+  operation: Operation,
+) => LegacyDeparserResult
+
+// New types using neverthrow
+export type SchemaDeparser = (schema: Schema) => Result<string, Error>
+export type OperationDeparser = (operation: Operation) => Result<string, Error>

frontend/packages/schema/src/deparser/yaml/index.ts

@@ -0,0 +1 @@
+export { yamlSchemaDeparser } from './schemaDeparser.js'