Descarga de oneprompt - Descarga del código fuente oneprompt

Un mensaje

Un súper marco para una ingeniería rápida.

Un marco basado en XML para definir, gestionar y validar indicaciones de AI/LLM de forma estructurada.

Aporta principios de ingeniería de software a la ingeniería de avisos al proporcionar un sistema sólido para el manejo de variables, lógica condicional y diseño de avisos modulares.

Ya sea que esté creando aplicaciones de IA complejas o administrando una biblioteca de indicaciones, One Prompt ayuda a garantizar la coherencia, la mantenibilidad y la confiabilidad en su flujo de trabajo de ingeniería de indicaciones.

Características

Primera definición de solicitud XML con estructura y validación claras
Sistema de variables enriquecido con campos obligatorios/opcionales y valores predeterminados
Representación de contenido condicional basada en valores variables
? Piezas de contenido reutilizables para el diseño de mensajes modulares
✅ Validación incorporada para indicaciones y variables
Soporte de metadatos para documentación y organización.
API simple para analizar y representar mensajes
?️ Compatibilidad total con TypeScript con definiciones de tipos completas

Instalación

 # Using npm
npm install oneprompt

# Using yarn
yarn add oneprompt

# Using pnpm
pnpm add oneprompt

# Using bun
bun add oneprompt

Inicio rápido

 <!-- Basic metadata about the prompt -->
< metadata >
  < title >Support Request</ title >
</ metadata >

<!-- Variable definitions with required/optional flags -->
< variables >
  < var name = " issue_category " required = " true " />
</ variables >

<!-- Main template with conditional logic and variable placeholders -->
< template >
Thank you for contacting support regarding your {{issue_category}} issue.

Our team strives to provide timely and effective solutions. Here's what you can expect:

< oneprompt : if var = " issue_category " equals = " billing " show = " billing_info " />

We'll be in touch within 24-48 hours with a detailed response.

Best regards,
Support Team
</ template >

<!-- Reusable content parts referenced by conditionals -->
< part name = " billing_info " >
For billing-related inquiries, please have your latest invoice and account number ready.
</ part >

 import { OnePrompt } from 'oneprompt' ;

const prompt = ... ; // your XML prompt or prompt object

const rendered = OnePrompt . renderWithVariables ( prompt , {
  name : "John" ,
  style : "casual"
} ) ;
// Output: "Hey John!"

Conceptos básicos

Metadatos

La sección de metadatos define información sobre el mensaje en sí:

< metadata >
  < title >Customer Response</ title >
  < description >Template for customer inquiries</ description >
  < team >Support</ team >
</ metadata >

variables

Las variables son marcadores de posición que se reemplazan con valores reales. Pueden ser:

Requerido : Debe proporcionarse al renderizar
Opcional : puede tener valores predeterminados

< variables >
  < var name = " customer_name " required = " true " />
  < var name = " priority " required = " false " >normal</ var >
  < var name = " response_type " required = " false " >standard</ var >
</ variables >

Plantilla

El contenido principal con marcadores de posición variables y lógica condicional:

< template >
Dear {{customer_name}},

< oneprompt : if var = " priority " equals = " high " show = " urgent_response " else = " standard_response " />

Best regards,
Support Team
</ template >

Regiones

Bloques de contenido reutilizables a los que se puede hacer referencia en condicionales:

< part name = " urgent_response " >
We have marked your case as high priority and assigned a dedicated specialist...
</ part >
< part name = " standard_response " >
Thank you for your inquiry. We will process your request...
</ part >

Referencia de API

Clase OnePrompt

`parseFromXml(xml: string): Prompt`

Analiza una cadena XML en un objeto Prompt validado.

 // Basic usage
const xml = `
<metadata>
  <title>Customer Greeting</title>
</metadata>
<variables>
  <var name="name" required="true" />
  <var name="language" required="false">english</var>
</variables>
<template>
  <oneprompt:if var="language" equals="spanish" show="spanish_greeting" else="english_greeting" />
  {{name}}!
</template>
<part name="spanish_greeting">¡Hola</part>
<part name="english_greeting">Hello</part>
` ;

try {
  const prompt = OnePrompt . parseFromXml ( xml ) ;
  console . log ( prompt ) ;
  // {
  //   metadata: { title: "Customer Greeting" },
  //   variables: [
  //     { name: "name", required: true },
  //     { name: "language", required: false, default: "english" }
  //   ],
  //   template: "...",
  //   parts: [...]
  // }
} catch ( error ) {
  if ( error instanceof OnePromptError ) {
    console . error ( "Invalid prompt XML:" , error . message ) ;
  }
}

`convertToXml(prompt: Prompt): string`

Convierte un objeto Prompt nuevamente al formato XML.

 const prompt : Prompt = {
  metadata : {
    title : "Meeting Request" ,
    author : "Support Team"
  } ,
  variables : [
    { name : "requester" , required : true } ,
    { name : "time" , required : false , default : "tomorrow" }
  ] ,
  template : "Meeting requested by {{requester}} for {{time}}" ,
  parts : [ ]
} ;

try {
  const xml = OnePrompt . convertToXml ( prompt ) ;
  console . log ( xml ) ;
  // <metadata>
  //   <title>Meeting Request</title>
  //   <author>Support Team</author>
  // </metadata>
  // <variables>
  //   <var name="requester" required="true" />
  //   <var name="time" required="false">tomorrow</var>
  // </variables>
  // <template>Meeting requested by {{requester}} for {{time}}</template>
} catch ( error ) {
  console . error ( "Conversion failed:" , error . message ) ;
}

`validate(prompt: Prompt): void`

Valida la estructura y las relaciones de un mensaje.

 const prompt : Prompt = {
  metadata : { title : "Email Template" } ,
  variables : [
    { name : "recipient" , required : true } ,
    { name : "tone" , required : false , default : "formal" }
  ] ,
  template : `
    <oneprompt:if var="tone" equals="formal" show="formal_greeting" else="casual_greeting" />
    {{recipient}},

    {{message}} // This will cause validation error - 'message' not defined
  ` ,
  parts : [
    { name : "formal_greeting" , content : "Dear" } ,
    { name : "casual_greeting" , content : "Hi" }
  ]
} ;

try {
  OnePrompt . validate ( prompt ) ;
} catch ( error ) {
  if ( error instanceof OnePromptError ) {
    // Error: "Variable 'message' used in template but not declared"
    console . error ( error . message ) ;
  }
}

`renderWithVariables(source: string | Prompt, variables: PromptInputVariables): string`

Procesa un mensaje con las variables proporcionadas para crear el resultado final.

 // Using prompt object
const prompt : Prompt = {
  metadata : { title : "Support Response" } ,
  variables : [
    { name : "ticket_id" , required : true } ,
    { name : "priority" , required : false , default : "normal" }
  ] ,
  template : `
    Ticket #{{ticket_id}}
    <oneprompt:if var="priority" equals="high" show="urgent_notice" />
  ` ,
  parts : [
    { name : "urgent_notice" , content : "URGENT: Requires immediate attention" }
  ]
} ;

// Success case
try {
  const output1 = OnePrompt . renderWithVariables ( prompt , {
    ticket_id : "T-123" ,
    priority : "high"
  } ) ;
  console . log ( output1 ) ;
  // Ticket #T-123
  // URGENT: Requires immediate attention

  const output2 = OnePrompt . renderWithVariables ( prompt , {
    ticket_id : "T-456"
  } ) ;
  console . log ( output2 ) ;
  // Ticket #T-456
  // (no urgent notice because priority is "normal" by default)
} catch ( error ) {
  console . error ( "Render failed:" , error . message ) ;
}

// Error case - missing required variable
try {
  OnePrompt . renderWithVariables ( prompt , {
    priority : "high"
    // Missing ticket_id
  } ) ;
} catch ( error ) {
  // Error: "Missing required variable: ticket_id"
  console . error ( error . message ) ;
}

Clase OnePromptUtils

`extractTemplateVariables(template: string): string[]`

Extrae nombres de variables de una cadena de plantilla.

 const template = `
  Dear {{recipient}},

  Your order #{{order_id}} has been {{status}}.
  <oneprompt:if var="tracking_number" equals="available" show="tracking_info" />
` ;

const variables = OnePromptUtils . extractTemplateVariables ( template ) ;
console . log ( variables ) ;
// ["recipient", "order_id", "status"]

`validateAndProcessVariables(promptVars: PromptVariable[], inputVars: PromptInputVariables): PromptInputVariables`

Valida las variables de entrada con respecto a las especificaciones y aplica los valores predeterminados.

 const promptVariables : PromptVariable [ ] = [
  { name : "user" , required : true } ,
  { name : "role" , required : false , default : "viewer" } ,
  { name : "team" , required : false , default : "general" }
] ;

// Success case - with defaults
const processed1 = OnePromptUtils . validateAndProcessVariables (
  promptVariables ,
  { user : "john.doe" }
) ;
console . log ( processed1 ) ;
// {
//   user: "john.doe",
//   role: "viewer",
//   team: "general"
// }

// Success case - override defaults
const processed2 = OnePromptUtils . validateAndProcessVariables (
  promptVariables ,
  { user : "jane.doe" , role : "admin" , team : "engineering" }
) ;
console . log ( processed2 ) ;
// {
//   user: "jane.doe",
//   role: "admin",
//   team: "engineering"
// }

// Error case - missing required
try {
  OnePromptUtils . validateAndProcessVariables (
    promptVariables ,
    { role : "admin" } // Missing required 'user'
  ) ;
} catch ( error ) {
  console . error ( error . message ) ; // "Missing required variable: user"
}

`substituteTemplateVariables(template: string, variables: PromptInputVariables): string`

Reemplaza los marcadores de posición de variables con sus valores.

 const template = `
  Project: {{project_name}}
  Owner: {{owner}}
  Status: {{status}}
  {{#if has_description}}
  Description: {{description}}
  {{/if}}
` ;

const result = OnePromptUtils . substituteTemplateVariables (
  template ,
  {
    project_name : "OnePrompt" ,
    owner : "DevTeam" ,
    status : "Active" ,
    // description not provided
  }
) ;

console . log ( result ) ;
// Project: OnePrompt
// Owner: DevTeam
// Status: Active
// {{#if has_description}}
// Description: {{description}}
// {{/if}}

`processConditionals(template: string, variables: PromptInputVariables, parts: PromptPart[]): string`

Procesa expresiones condicionales e incluye partes apropiadas.

 const template = `
  <oneprompt:if var="access_level" equals="admin" show="admin_actions" else="user_actions" />

  <oneprompt:if var="has_notifications" equals="true" show="notification_panel" />
` ;

const variables = {
  access_level : "admin" ,
  has_notifications : "true"
} ;

const parts : PromptPart [ ] = [
  {
    name : "admin_actions" ,
    content : "- Create Usern- Delete Usern- Modify Settings"
  } ,
  {
    name : "user_actions" ,
    content : "- View Profilen- Update Settings"
  } ,
  {
    name : "notification_panel" ,
    content : "You have new notifications!"
  }
] ;

const processed = OnePromptUtils . processConditionals (
  template ,
  variables ,
  parts
) ;

console . log ( processed ) ;
// - Create User
// - Delete User
// - Modify Settings
//
// You have new notifications!

Antecedentes y objetivo

A medida que las aplicaciones de IA y LLM se vuelven más complejas, la gestión de mensajes como cadenas simples se vuelve cada vez más propensa a errores y difícil de mantener. Necesitábamos una manera de:

Trate las indicaciones como interfaces adecuadas entre humanos/aplicaciones y modelos de IA.
Habilitar documentación de indicaciones
Valide las variables de solicitud antes del tiempo de ejecución para detectar errores tempranamente
Haga que las indicaciones sean reutilizables y componibles en diferentes contextos
Proporcionar una separación clara entre la lógica rápida y los datos variables.

Se eligió el enfoque basado en XML para proporcionar una estructura clara y al mismo tiempo mantener la legibilidad y permitir que los metadatos y las reglas de validación coexistan con la propia plantilla de solicitud. Esto hace que los avisos se autodocumenten y permite una mejor colaboración entre ingenieros, desarrolladores y otras partes interesadas.

One Prompt tiene como objetivo llevar las mejores prácticas de ingeniería de software a la ingeniería rápida manteniendo al mismo tiempo la experiencia del desarrollador simple e intuitiva.