prompts.chat 0.0.6 → 0.0.8

package/dist/builder/index.d.ts

@@ -1062,6 +1062,89 @@ declare const templates: {
      * Create a Q&A prompt
      */
     qa: (context?: string) => PromptBuilder;
+    /**
+     * Create a debugging prompt
+     */
+    debug: (options?: {
+        language?: string;
+        errorType?: string;
+    }) => PromptBuilder;
+    /**
+     * Create a writing assistant prompt
+     */
+    write: (options?: {
+        type?: "blog" | "email" | "essay" | "story" | "documentation";
+        tone?: string;
+    }) => PromptBuilder;
+    /**
+     * Create an explanation/teaching prompt
+     */
+    explain: (options?: {
+        level?: "beginner" | "intermediate" | "expert";
+        useAnalogies?: boolean;
+    }) => PromptBuilder;
+    /**
+     * Create a data extraction prompt
+     */
+    extract: (options?: {
+        format?: "json" | "csv" | "table";
+        fields?: string[];
+    }) => PromptBuilder;
+    /**
+     * Create a brainstorming prompt
+     */
+    brainstorm: (options?: {
+        count?: number;
+        creative?: boolean;
+    }) => PromptBuilder;
+    /**
+     * Create a code refactoring prompt
+     */
+    refactor: (options?: {
+        goal?: "readability" | "performance" | "maintainability" | "all";
+        language?: string;
+    }) => PromptBuilder;
+    /**
+     * Create an API documentation prompt
+     */
+    apiDocs: (options?: {
+        style?: "openapi" | "markdown" | "jsdoc";
+        includeExamples?: boolean;
+    }) => PromptBuilder;
+    /**
+     * Create a unit test generation prompt
+     */
+    unitTest: (options?: {
+        framework?: string;
+        coverage?: "basic" | "comprehensive";
+    }) => PromptBuilder;
+    /**
+     * Create a commit message prompt
+     */
+    commitMessage: (options?: {
+        style?: "conventional" | "simple";
+        includeBody?: boolean;
+    }) => PromptBuilder;
+    /**
+     * Create a code review comment prompt
+     */
+    reviewComment: (options?: {
+        tone?: "constructive" | "direct";
+        severity?: boolean;
+    }) => PromptBuilder;
+    /**
+     * Create a regex generator prompt
+     */
+    regex: (options?: {
+        flavor?: "javascript" | "python" | "pcre";
+    }) => PromptBuilder;
+    /**
+     * Create a SQL query prompt
+     */
+    sql: (options?: {
+        dialect?: "postgresql" | "mysql" | "sqlite" | "mssql";
+        optimize?: boolean;
+    }) => PromptBuilder;
 };
 
 export { type ArtStyle, type AspectRatio, type AudioGenre, type AudioInstrumentation, type AudioMood, type AudioProduction, AudioPromptBuilder, type AudioStructure, type AudioTechnical, type AudioTempo, type AudioVocals, type BuiltAudioPrompt, type BuiltChatPrompt, type BuiltImagePrompt, type BuiltPrompt, type BuiltVideoPrompt, type CameraAngle, type ChatContext, type ChatExample, type ChatMemory, type ChatMessage, type ChatOutput, type ChatPersona, ChatPromptBuilder, type ChatReasoning, type ChatTask, type ColorPalette, type ImageCamera, type ImageColor, type ImageComposition, type ImageEnvironment, type ImageLighting, ImagePromptBuilder, type ImageStyle, type ImageSubject, type ImageTechnical, type Instrument, type JsonSchema, type LensType, type LightingType, type MessageRole, type Mood, type MusicGenre, type MusicalKey, type OutputFormat, type OutputLength, type OutputStyle, type PersonaExpertise, type PersonaTone, type ProductionStyle, PromptBuilder, type PromptVariable, type ReasoningStyle, type ResponseFormat, type ResponseFormatType, type ShotType, type SongSection, type TempoMarking, type TimeOfDay, type TimeSignature, type VideoAction, type VideoAudio, type VideoCamera, type VideoColor, type VideoLighting, type VideoMotion, VideoPromptBuilder, type VideoScene, type VideoShot, type VideoStyle, type VideoSubject, type VideoTechnical, type VocalStyle, audio, builder, chat, chatPresets, fromPrompt, image, templates, video };

package/dist/builder/index.js

@@ -1,41 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/builder/index.ts
-var builder_exports = {};
-__export(builder_exports, {
-  AudioPromptBuilder: () => AudioPromptBuilder,
-  ChatPromptBuilder: () => ChatPromptBuilder,
-  ImagePromptBuilder: () => ImagePromptBuilder,
-  PromptBuilder: () => PromptBuilder,
-  VideoPromptBuilder: () => VideoPromptBuilder,
-  audio: () => audio,
-  builder: () => builder,
-  chat: () => chat,
-  chatPresets: () => chatPresets,
-  fromPrompt: () => fromPrompt,
-  image: () => image,
-  templates: () => templates,
-  video: () => video
-});
-module.exports = __toCommonJS(builder_exports);
-
 // src/builder/media.ts
 var ImagePromptBuilder = class {
   constructor() {
@@ -2450,10 +2412,222 @@ var templates = {
       "If you don't know the answer, say so",
       "Cite relevant parts of the context if applicable"
     ]);
+  },
+  /**
+   * Create a debugging prompt
+   */
+  debug: (options = {}) => {
+    const b = builder().role("expert software debugger").task("Analyze the code and error, identify the root cause, and provide a fix.").variable("code", { required: true, description: "The code with the bug" }).variable("error", { required: false, description: "Error message or unexpected behavior" });
+    if (options.language) {
+      b.context(`Debugging ${options.language} code.`);
+    }
+    if (options.errorType) {
+      b.context(`The error appears to be related to: ${options.errorType}`);
+    }
+    return b.constraints([
+      "Identify the root cause, not just symptoms",
+      "Explain why the bug occurs",
+      "Provide a working fix with explanation"
+    ]).output("1. Root cause analysis\n2. Explanation\n3. Fixed code\n4. Prevention tips");
+  },
+  /**
+   * Create a writing assistant prompt
+   */
+  write: (options = {}) => {
+    const typeDescriptions = {
+      blog: "engaging blog post",
+      email: "professional email",
+      essay: "well-structured essay",
+      story: "creative story",
+      documentation: "clear technical documentation"
+    };
+    const b = builder().role("skilled writer").task(`Write a ${typeDescriptions[options.type || "blog"] || "piece of content"} based on the given topic or outline.`).variable("topic", { required: true, description: "Topic or outline to write about" });
+    if (options.tone) {
+      b.constraint(`Use a ${options.tone} tone throughout`);
+    }
+    return b.constraints([
+      "Use clear and engaging language",
+      "Structure content logically",
+      "Maintain consistent voice and style"
+    ]);
+  },
+  /**
+   * Create an explanation/teaching prompt
+   */
+  explain: (options = {}) => {
+    const levelDescriptions = {
+      beginner: "someone new to the topic with no prior knowledge",
+      intermediate: "someone with basic understanding who wants to go deeper",
+      expert: "an expert who wants technical precision and nuance"
+    };
+    const b = builder().role("expert teacher and communicator").task("Explain the concept clearly and thoroughly.").variable("concept", { required: true, description: "The concept to explain" });
+    if (options.level) {
+      b.context(`Target audience: ${levelDescriptions[options.level]}`);
+    }
+    if (options.useAnalogies) {
+      b.constraint("Use relatable analogies and real-world examples");
+    }
+    return b.constraints([
+      "Break down complex ideas into digestible parts",
+      "Build understanding progressively",
+      "Anticipate and address common misconceptions"
+    ]);
+  },
+  /**
+   * Create a data extraction prompt
+   */
+  extract: (options = {}) => {
+    const b = builder().role("data extraction specialist").task("Extract structured data from the provided text.").variable("text", { required: true, description: "Text to extract data from" });
+    if (options.fields && options.fields.length > 0) {
+      b.context(`Fields to extract: ${options.fields.join(", ")}`);
+    }
+    if (options.format) {
+      b.output(`Return extracted data in ${options.format.toUpperCase()} format`);
+    }
+    return b.constraints([
+      "Extract only factual information present in the text",
+      "Use null or empty values for missing fields",
+      "Maintain consistent formatting"
+    ]);
+  },
+  /**
+   * Create a brainstorming prompt
+   */
+  brainstorm: (options = {}) => {
+    const b = builder().role("creative strategist and ideation expert").task("Generate diverse and innovative ideas based on the given topic or challenge.").variable("topic", { required: true, description: "Topic or challenge to brainstorm about" });
+    if (options.count) {
+      b.constraint(`Generate exactly ${options.count} ideas`);
+    }
+    if (options.creative) {
+      b.constraint("Include unconventional and out-of-the-box ideas");
+    }
+    return b.constraints([
+      "Ensure ideas are distinct and varied",
+      "Consider different perspectives and approaches",
+      "Make ideas actionable when possible"
+    ]).output("List each idea with a brief description and potential benefits");
+  },
+  /**
+   * Create a code refactoring prompt
+   */
+  refactor: (options = {}) => {
+    const goalDescriptions = {
+      readability: "improving code readability and clarity",
+      performance: "optimizing performance and efficiency",
+      maintainability: "enhancing maintainability and extensibility",
+      all: "overall code quality improvement"
+    };
+    const b = builder().role("senior software engineer specializing in code quality").task(`Refactor the code with focus on ${goalDescriptions[options.goal || "all"]}.`).variable("code", { required: true, description: "Code to refactor" });
+    if (options.language) {
+      b.context(`The code is written in ${options.language}.`);
+    }
+    return b.constraints([
+      "Preserve existing functionality",
+      "Follow language best practices and idioms",
+      "Explain each significant change"
+    ]).output("1. Refactored code\n2. List of changes made\n3. Explanation of improvements");
+  },
+  /**
+   * Create an API documentation prompt
+   */
+  apiDocs: (options = {}) => {
+    const b = builder().role("technical documentation writer").task("Generate comprehensive API documentation for the provided code or endpoint.").variable("code", { required: true, description: "API code or endpoint definition" });
+    if (options.style) {
+      b.output(`Format documentation in ${options.style.toUpperCase()} style`);
+    }
+    if (options.includeExamples) {
+      b.constraint("Include request/response examples for each endpoint");
+    }
+    return b.constraints([
+      "Document all parameters with types and descriptions",
+      "Include error responses and status codes",
+      "Be precise and developer-friendly"
+    ]);
+  },
+  /**
+   * Create a unit test generation prompt
+   */
+  unitTest: (options = {}) => {
+    const b = builder().role("test automation engineer").task("Generate unit tests for the provided code.").variable("code", { required: true, description: "Code to generate tests for" });
+    if (options.framework) {
+      b.context(`Use ${options.framework} testing framework.`);
+    }
+    const coverageConstraints = options.coverage === "comprehensive" ? ["Cover all code paths including edge cases", "Test error handling scenarios", "Include boundary value tests"] : ["Cover main functionality", "Include basic edge cases"];
+    return b.constraints([
+      ...coverageConstraints,
+      "Write clear, descriptive test names",
+      "Follow AAA pattern (Arrange, Act, Assert)"
+    ]).output("Complete, runnable test file");
+  },
+  /**
+   * Create a commit message prompt
+   */
+  commitMessage: (options = {}) => {
+    const b = builder().role("developer with excellent communication skills").task("Generate a clear and descriptive commit message for the provided code changes.").variable("diff", { required: true, description: "Git diff or description of changes" });
+    if (options.style === "conventional") {
+      b.constraints([
+        "Follow Conventional Commits format (type(scope): description)",
+        "Use appropriate type: feat, fix, docs, style, refactor, test, chore"
+      ]);
+    }
+    if (options.includeBody) {
+      b.constraint("Include a detailed body explaining the why behind changes");
+    }
+    return b.constraints([
+      "Keep subject line under 72 characters",
+      "Use imperative mood (Add, Fix, Update, not Added, Fixed, Updated)"
+    ]);
+  },
+  /**
+   * Create a code review comment prompt
+   */
+  reviewComment: (options = {}) => {
+    const b = builder().role("thoughtful code reviewer").task("Write a helpful code review comment for the provided code snippet.").variable("code", { required: true, description: "Code to comment on" }).variable("issue", { required: true, description: "The issue or improvement to address" });
+    if (options.tone === "constructive") {
+      b.constraint("Frame feedback positively and suggest improvements rather than just pointing out problems");
+    }
+    if (options.severity) {
+      b.constraint("Indicate severity level: nitpick, suggestion, important, or blocker");
+    }
+    return b.constraints([
+      "Be specific and actionable",
+      "Explain the reasoning behind the suggestion",
+      "Provide an example of the improved code when helpful"
+    ]);
+  },
+  /**
+   * Create a regex generator prompt
+   */
+  regex: (options = {}) => {
+    const b = builder().role("regex expert").task("Create a regular expression that matches the described pattern.").variable("pattern", { required: true, description: "Description of the pattern to match" }).variable("examples", { required: false, description: "Example strings that should match" });
+    if (options.flavor) {
+      b.context(`Use ${options.flavor} regex flavor/syntax.`);
+    }
+    return b.constraints([
+      "Provide the regex pattern",
+      "Explain each part of the pattern",
+      "Include test cases showing matches and non-matches"
+    ]).output("1. Regex pattern\n2. Explanation\n3. Test cases");
+  },
+  /**
+   * Create a SQL query prompt
+   */
+  sql: (options = {}) => {
+    const b = builder().role("database expert").task("Write an SQL query based on the requirements.").variable("requirement", { required: true, description: "What the query should accomplish" }).variable("schema", { required: false, description: "Database schema or table definitions" });
+    if (options.dialect) {
+      b.context(`Use ${options.dialect.toUpperCase()} syntax.`);
+    }
+    if (options.optimize) {
+      b.constraint("Optimize for performance and include index recommendations if applicable");
+    }
+    return b.constraints([
+      "Write clean, readable SQL",
+      "Use appropriate JOINs and avoid N+1 patterns",
+      "Include comments explaining complex logic"
+    ]);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   AudioPromptBuilder,
   ChatPromptBuilder,
   ImagePromptBuilder,
@@ -2467,5 +2641,5 @@ var templates = {
   image,
   templates,
   video
-});
+};
 //# sourceMappingURL=index.js.map