prd-to-skill 1.0.2 → 1.0.3

package/README.md

@@ -39,12 +39,12 @@ Output directories are created automatically if they don't exist.
 
 The tool auto-detects your provider from environment variables (checked in this order):
 
-| Provider  | Env Var             | Default Model              |
-| --------- | ------------------- | -------------------------- |
+| Provider  | Env Var             | Default Model                |
+| --------- | ------------------- | ---------------------------- |
 | Anthropic | `ANTHROPIC_API_KEY` | `claude-sonnet-4-6-20250217` |
-| OpenAI    | `OPENAI_API_KEY`    | `gpt-5.4`                   |
-| Google    | `GOOGLE_API_KEY`    | `gemini-2.5-flash`         |
-| Mistral   | `MISTRAL_API_KEY`   | `mistral-large-latest`     |
+| OpenAI    | `OPENAI_API_KEY`    | `gpt-5.4`                    |
+| Google    | `GOOGLE_API_KEY`    | `gemini-2.5-flash`           |
+| Mistral   | `MISTRAL_API_KEY`   | `mistral-large-latest`       |
 
 ## Usage
 

package/dist/index.js

@@ -35,6 +35,22 @@ var extractText = async (filePath) => {
   }
   return text;
 };
+var TRUNCATION_PATTERNS = [
+  /[a-z,]\s*$/,
+  // ends mid-word or after a comma
+  /\(\s*e\.g\.\s*,?\s*$/,
+  // ends mid-parenthetical like "(e.g.,"
+  /:\s*$/,
+  // ends with a colon expecting more
+  /\b(and|or|the|a|an|to|for|in|of|with|by|from|as|is|are|was|were|that|this|which|when|where|how|but|if|not|on|at|into|about|than|then|such|each|per|via)\s*$/i
+];
+var detectTruncation = (text) => {
+  const lastLine = text.split("\n").filter(Boolean).pop() ?? "";
+  const trimmed = lastLine.trim();
+  if (!trimmed) return false;
+  if (!/[.!?:)\]"']$/.test(trimmed)) return true;
+  return TRUNCATION_PATTERNS.some((p) => p.test(trimmed));
+};
 
 // src/prompt.ts
 var BASE_SYSTEM_PROMPT = `You are a technical writer specializing in AI coding assistant instruction files. You will receive the text content of a Product Requirements Document (PRD). Your job is to convert it into an instruction file for an AI coding tool.
@@ -88,14 +104,27 @@ Convert the PRD requirements into ACTIONABLE INSTRUCTIONS for an AI agent. Do NO
 - Remove filler, marketing language, and non-technical content
 
 Output ONLY the complete file. No preamble, no explanation, no code fences wrapping the entire output.`;
-var buildMessages = (prdText, name, target, description) => {
-  const systemPrompt = `${BASE_SYSTEM_PROMPT}
+var buildMessages = (prdText, name, target, description, truncated = false) => {
+  let systemPrompt = `${BASE_SYSTEM_PROMPT}
 
 ## Output Format (${target.name})
 
 You are generating a file for: ${target.description}
 
 ${target.formatInstructions}`;
+  if (truncated) {
+    systemPrompt += `
+
+## Important: Incomplete Document
+
+The provided PRD appears to be truncated \u2014 it ends abruptly mid-sentence or mid-section. Handle this as follows:
+- Generate the instruction file based ONLY on the content that is present. Do NOT invent or guess missing requirements.
+- At the very end of the output, add a section:
+
+## Incomplete Sections
+
+Note which sections or topics appear to be cut off or missing based on context clues (e.g., a numbered list that stops, a heading with no content, a sentence that ends mid-thought). List them as bullet points so the user knows what to add.`;
+  }
   let userContent = `Here is the PRD content to convert into an AI coding instruction file:
 
 <prd>
@@ -383,6 +412,32 @@ var writeSkillFile = async (content, outputPath) => {
   await writeFile(outputPath, normalized, "utf-8");
 };
 
+// src/spinner.ts
+var frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var createSpinner = (message) => {
+  let i = 0;
+  const stream = process.stderr;
+  const write = (text) => {
+    stream.write(`\r\x1B[K${text}`);
+  };
+  write(`${frames[0]} ${message}`);
+  const timer = setInterval(() => {
+    i = (i + 1) % frames.length;
+    write(`${frames[i]} ${message}`);
+  }, 80);
+  return {
+    update: (msg) => {
+      message = msg;
+      write(`${frames[i]} ${message}`);
+    },
+    stop: (msg) => {
+      clearInterval(timer);
+      write(`${msg}
+`);
+    }
+  };
+};
+
 // src/generate.ts
 var generate = async (options) => {
   const provider = detectProvider(options.provider);
@@ -395,22 +450,68 @@ var generate = async (options) => {
     console.error(`Provider: ${provider.name}`);
     console.error(`Model: ${model}`);
     console.error(`Target: ${target.name} (${target.description})`);
-    console.error(`Extracting text from: ${options.filePath}`);
   }
+  const spinner = createSpinner("Extracting text from document...");
   const prdText = await extractText(options.filePath);
-  if (options.verbose) {
-    console.error(`Extracted ${prdText.length} characters`);
+  const isTruncated = detectTruncation(prdText);
+  if (isTruncated) {
+    spinner.stop(
+      `\u26A0 Extracted ${prdText.length.toLocaleString()} characters \u2014 document appears to be incomplete or cut off`
+    );
+    console.error(
+      "  The document ends abruptly. The generated output will cover only what was provided."
+    );
+  } else {
+    spinner.stop(`\u2713 Extracted ${prdText.length.toLocaleString()} characters`);
   }
-  const messages = buildMessages(prdText, name, target, options.description);
   if (options.verbose) {
-    console.error("Sending to LLM...");
+    console.error(`  Source: ${options.filePath}`);
   }
+  const messages = buildMessages(prdText, name, target, options.description, isTruncated);
+  const llmSpinner = createSpinner(
+    `Generating ${target.name} file via ${provider.name} (${model})...`
+  );
+  const startTime = Date.now();
+  const elapsed = setInterval(() => {
+    const secs = Math.floor((Date.now() - startTime) / 1e3);
+    llmSpinner.update(
+      `Generating ${target.name} file via ${provider.name} (${model})... ${secs}s`
+    );
+  }, 1e3);
   const result = await provider.complete(
     { apiKey, model, maxTokens: options.maxTokens },
     messages
   );
+  clearInterval(elapsed);
+  const totalSecs = ((Date.now() - startTime) / 1e3).toFixed(1);
+  const outputTruncated = detectTruncation(result);
+  if (outputTruncated) {
+    llmSpinner.stop(`\u26A0 Generated in ${totalSecs}s \u2014 output appears cut off`);
+  } else {
+    llmSpinner.stop(`\u2713 Generated in ${totalSecs}s`);
+  }
+  const writeSpinner = createSpinner("Writing file...");
   await writeSkillFile(result, outputPath);
-  console.log(`${target.name} file written to: ${outputPath}`);
+  writeSpinner.stop(`\u2713 Saved to ${outputPath}`);
+  if (outputTruncated) {
+    const nextMaxTokens = options.maxTokens * 2;
+    console.error("");
+    console.error(
+      "\u26A0 The generated output appears incomplete \u2014 the LLM likely hit the token limit."
+    );
+    console.error("");
+    console.error("  To fix this, try one of the following:");
+    console.error("");
+    console.error(
+      `  1. Increase max tokens:    prd-to-skill ${options.filePath} --max-tokens ${nextMaxTokens}`
+    );
+    console.error(`  2. Use a higher-capacity model with a larger output window`);
+    console.error(
+      `  3. Split your PRD into smaller focused documents and generate a skill for each`
+    );
+    console.error("");
+    console.error(`  Current --max-tokens: ${options.maxTokens}`);
+  }
 };
 
 // src/help.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prd-to-skill",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Convert PRD documents (PDF/DOCX) into AI coding assistant instruction files",
   "type": "module",
   "bin": {