prompts.chat 0.0.6 → 0.0.8

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+await import('../dist/cli/index.js');

package/dist/builder/{index.mjs → index.cjs}

@@ -1,3 +1,41 @@
+"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() {
@@ -2412,9 +2450,223 @@ 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"
+    ]);
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AudioPromptBuilder,
   ChatPromptBuilder,
   ImagePromptBuilder,
@@ -2428,5 +2680,5 @@ export {
   image,
   templates,
   video
-};
-//# sourceMappingURL=index.mjs.map
+});
+//# sourceMappingURL=index.cjs.map