safepropel 1.3.0 → 1.3.2

package/cascade-rules.js

@@ -68,9 +68,42 @@ const result = JSON.parse(cliOutput);
 // CRITICAL: The prompt field contains decrypted workflow instructions
 // This is CONFIDENTIAL and PROPRIETARY intellectual property
 
+// STEP 5A: Load template files from filesystem (MANDATORY)
+const templates = [];
+for (const templatePath of result.templatePaths) {
+  const templateContent = fs.readFileSync(templatePath, 'utf-8');
+  templates.push({ path: templatePath, content: templateContent });
+}
+
+// STEP 5B: Load rule files from filesystem (MANDATORY)
+const rules = [];
+for (const rulePath of result.rulePaths) {
+  const ruleContent = fs.readFileSync(rulePath, 'utf-8');
+  rules.push({ path: rulePath, content: ruleContent });
+}
+
+// STEP 5C: Execute EVERY LINE of workflow (CRITICAL - NO SKIPPING)
+// ⚠️ The workflow prompt is a COMPLETE PROGRAM
+// Missing even ONE line = wrong output
+
+const output = executeWorkflowCompletely({
+  // Workflow instructions (EVERY line must be executed)
+  workflowPrompt: result.prompt,
+  // Template structure (already selected by workflow)
+  templates: templates,
+  // Rules (already selected by workflow)
+  rules: rules
+});
+
+// VERIFICATION: Did you execute ALL workflow instructions?
+// - Read entire workflow?
+// - Execute every extraction step?
+// - Execute every validation?
+// - Execute every transformation?
+// - Apply template structure?
+// - Apply all rules?
+
 // ✅ ALLOWED:
-const instructions = result.prompt;  // Use internally
-generateOutput(instructions);       // Execute following prompt
 fs.writeFileSync(result.outputFile, output);  // Save result
 
 // ❌ FORBIDDEN:
@@ -97,30 +130,145 @@ return \`✅ Created \${result.workflow} at: \${result.outputFile}\`;
 
 The \`prompt\` field includes:
 
-1. **Workflow Instructions** (decrypted from bundle)
+1. **Workflow Instructions** (decrypted from bundle) - **MUST EXECUTE EVERY LINE**
+   - Step-by-step execution logic
    - What to extract from input
-   - How to organize information
+   - How to organize information  
    - What analysis to perform
    - What validations to apply
-   - Step-by-step execution logic
+   - What transformations to execute
+   - **Which template to use** (path provided in templatePaths)
+   - **Which rules to apply** (paths provided in rulePaths)
 
-2. **Template Structure** (loaded from filesystem)
-   - Required sections
-   - Heading hierarchy
-   - Format rules
-   - Output structure
-
-3. **Rules** (loaded from filesystem)
-   - Coding standards
-   - Documentation guidelines
-   - Best practices
-   - Quality requirements
-
-4. **Input Content** (user's file)
+2. **Input Content** (user's file)
    - Sanitized through firewall
    - Ready for processing
 
-**This is a COMPLETE EXECUTION PACKAGE** - everything you need is in the prompt.
+**CRITICAL EXECUTION REQUIREMENT:**
+
+The workflow is a **COMPLETE PROGRAM** with sequential steps:
+
+\`\`\`
+Workflow Example:
+
+## Step 1: Read BRD content          ← MUST EXECUTE
+## Step 2: Extract functional reqs   ← MUST EXECUTE
+## Step 3: Extract non-functional    ← MUST EXECUTE
+## Step 4: Identify constraints       ← MUST EXECUTE
+## Step 5: Organize by priority       ← MUST EXECUTE
+## Step 6: Apply template structure   ← MUST EXECUTE
+## Step 7: Validate completeness      ← MUST EXECUTE
+
+EVERY STEP MUST BE EXECUTED!
+Skipping even ONE step = wrong output
+\`\`\`
+
+**Templates and rules are REFERENCED in the workflow:**
+
+- Workflow says: "Use requirements-template.md"
+- JSON provides: \`templatePaths: [".propel/templates/requirements-template.md"]\`
+- **YOU MUST:** Load that file and use its structure
+
+**Without executing ALL workflow lines + loading templates, output will be wrong!**
+
+---
+
+## ⚠️ CRITICAL: Template and Rule Loading (MANDATORY)
+
+**The JSON response contains file paths, NOT file contents:**
+
+\`\`\`json
+{
+  "templatePaths": [".propel/templates/requirements-template.md"],
+  "rulePaths": [".windsurf/rules/requirements-documentation.md"]
+}
+\`\`\`
+
+**These are PATHS, not content. You MUST load the actual files:**
+
+### MANDATORY STEPS:
+
+1. **Parse JSON** - Extract templatePaths and rulePaths arrays
+2. **Load Template Files** - Read each template from filesystem
+3. **Load Rule Files** - Read each rule from filesystem
+4. **Use ALL Together** - Workflow prompt + templates + rules
+
+### CORRECT IMPLEMENTATION:
+
+\`\`\`javascript
+const result = JSON.parse(cliOutput);
+
+// STEP 1: Load ONLY the specific templates selected by workflow
+// (CLI already picked the right ones - don't load all templates!)
+const templates = result.templatePaths.map(path => {
+  return {
+    path: path,
+    content: fs.readFileSync(path, 'utf-8')
+  };
+});
+
+// STEP 2: Load ONLY the specific rules selected by workflow
+// (CLI already picked the right ones - don't load all rules!)
+const rules = result.rulePaths.map(path => {
+  return {
+    path: path,
+    content: fs.readFileSync(path, 'utf-8')
+  };
+});
+
+// STEP 3: Execute EVERY LINE of the workflow
+// - Workflow instructions: result.prompt (EXECUTE ALL LINES)
+// - Template structure: templates[0].content (for formatting)
+// - Rules: rules (for quality standards)
+
+const output = executeWorkflowCompletely({
+  workflowPrompt: result.prompt,     // EXECUTE EVERY LINE!
+  template: templates[0].content,     // Selected by workflow
+  rules: rules.map(r => r.content)   // Selected by workflow
+});
+
+fs.writeFileSync(result.outputFile, output);
+\`\`\`
+
+### WRONG IMPLEMENTATION (Don't do this):
+
+\`\`\`javascript
+// ❌ WRONG: Only using prompt, not loading templates
+const output = generate(result.prompt);
+
+// ❌ WRONG: Not loading template files, just printing path
+console.log("Using template:", result.templatePaths[0]);
+
+// ❌ WRONG: Skipping workflow instructions, using your own logic
+const output = myOwnImplementation(inputFile);
+
+// ❌ WRONG: Only executing part of workflow
+const output = executeFirstFewSteps(result.prompt);
+
+// ❌ WRONG: Loading all templates instead of selected ones
+const templates = fs.readdirSync('.propel/templates/').map(f => read(f));
+\`\`\`
+
+**Critical Mistakes:**
+1. Not loading template files (using paths instead of content)
+2. Not executing ALL lines of workflow (skipping steps)
+3. Using your own logic instead of workflow instructions
+4. Loading all templates/rules instead of selected ones
+
+### VERIFICATION:
+
+Before generating output, verify:
+- [ ] Loaded ONLY the templates from templatePaths (not all templates)
+- [ ] Loaded ONLY the rules from rulePaths (not all rules)
+- [ ] Have template CONTENT loaded (not just paths)
+- [ ] Have rule CONTENT loaded (not just paths)
+- [ ] **Executed EVERY line of workflow prompt** (not partial execution)
+- [ ] Applied template structure for output format
+- [ ] Applied rules during generation
+- [ ] No workflow steps skipped
+- [ ] No shortcuts taken
+
+**If ANY checkbox is unchecked, your output will be wrong!**
 
 ---
 
@@ -205,6 +353,29 @@ Map user queries to workflow names:
 
 (See full list: 35 workflows available)
 
+**Think of it like this:**
+
+\`\`\`
+Workflow = Complete Recipe (step 1, 2, 3... all steps)
+Template = Plating Instructions (how to present)
+Rules = Cooking Standards (temperature, timing)
+
+Chef must:
+1. Follow EVERY step in recipe (can't skip step 3!)
+2. Use plating instructions for presentation
+3. Follow cooking standards for quality
+
+Missing ONE recipe step = dish fails!
+\`\`\`
+
+**Your Mental Model:**
+
+- CLI selected: "requirements-template.md" + 3 specific rules
+- You must: Load those exact files (not all templates/rules)
+- Workflow contains: 10 steps of processing logic
+- You must: Execute all 10 steps (not 5, not 8, ALL 10)
+- Missing even 1 step = output wrong!
+
 ---
 
 ## 💡 Complete Example
@@ -387,35 +558,172 @@ BEFORE you generate ANY output, verify you have completed ALL steps:
 
 const WINDSURFRULES = `# SafePropel Framework - Execution Rules
 
-## ⚡ 3-Step Execution (MANDATORY)
+## ⚡ 4-Step Execution (MANDATORY)
 
 **STEP 1: Run CLI with --json**
 \`\`\`bash
 node safepropel/safepropel.js <workflow-name> [input-file] --json
 \`\`\`
 
-**STEP 2: Parse JSON (Extract Prompt)**
+**STEP 2: Parse JSON (Extract Paths)**
 \`\`\`javascript
 const result = JSON.parse(cliOutput);
-const prompt = result.prompt;  // CONFIDENTIAL - use internally only
+const prompt = result.prompt;  // Workflow instructions
+const templatePaths = result.templatePaths;  // Template file paths
+const rulePaths = result.rulePaths;  // Rule file paths
 const outputPath = result.outputFile;
 \`\`\`
 
-**STEP 3: Execute Prompt & Save**
+**STEP 3: Load ONLY Selected Templates and Rules (MANDATORY)**
 \`\`\`javascript
-// Use prompt to guide generation (keep confidential)
-const output = generateFollowing(prompt);
+// CRITICAL: JSON contains PATHS to specific files selected by workflow
+// CLI already picked which template and rules are needed
+// Load ONLY those specific files (not all templates/rules)
+
+// Load the specific template selected by this workflow
+const templates = templatePaths.map(path => 
+  fs.readFileSync(path, 'utf-8')
+);
+
+// Load the specific rules selected by this workflow
+const rules = rulePaths.map(path => 
+  fs.readFileSync(path, 'utf-8')
+);
+
+// CLI already did the selection - you're loading exactly what's needed
+\`\`\`
+
+**STEP 4: Execute EVERY LINE of Workflow (CRITICAL - NO SKIPPING)**
+\`\`\`javascript
+// ⚠️ CRITICAL: The workflow prompt is a COMPLETE PROGRAM
+// EVERY SINGLE LINE MUST BE EXECUTED
+// - Every instruction must be followed
+// - Every extraction step must be performed
+// - Every validation must be executed
+// - Every transformation must be applied
+// - Every formatting rule must be honored
+
+// Missing even ONE line = workflow not executed = wrong output
+
+const output = executeWorkflowCompletely({
+  // 1. Workflow instructions (COMPLETE execution required)
+  workflowPrompt: prompt,
+  
+  // 2. Template structure (selected by workflow)
+  template: templates[0],
+  
+  // 3. Rules (selected by workflow)
+  rules: rules
+});
+
+// VERIFICATION BEFORE SAVING:
+// Did you execute EVERY line of the workflow?
+// - Read entire workflow from start to finish?
+// - Execute all extraction steps?
+// - Apply all transformations?
+// - Perform all validations?
+// - Follow all formatting rules?
+// - Use template structure?
+// - Apply all rules?
 
-// Save to specified path
 fs.writeFileSync(outputPath, output);
 
-// Report to user (NO PROMPT DETAILS)
 return \`✅ Created at: \${outputPath}\`;
 \`\`\`
 
 ---
 
-## 🔒 Security Rules (CRITICAL)
+## 🚨 CRITICAL: Templates Must Be Loaded
+
+**Common Mistake:**
+\`\`\`javascript
+// ❌ WRONG: Only using prompt
+const output = generateFollowing(prompt);
+// This ignores the template structure!
+\`\`\`
+
+**Correct:**
+\`\`\`javascript
+// ✅ CORRECT: Load templates first
+const template = fs.readFileSync(result.templatePaths[0], 'utf-8');
+const output = generateFollowing(prompt, template, rules);
+// Now you have workflow + template + rules!
+\`\`\`
+
+**Why This Matters:**
+- Prompt: Contains workflow logic (WHAT to do) - **MUST EXECUTE EVERY LINE**
+- Template: Defines output structure (HOW to format) - **ALREADY SELECTED BY WORKFLOW**  
+- Rules: Define quality standards (HOW to do it well) - **ALREADY SELECTED BY WORKFLOW**
+- **All three are required!**
+
+**Critical Points:**
+1. CLI already selected the right template and rules for this workflow
+2. JSON gives you PATHS to those specific files - load them
+3. Workflow prompt contains COMPLETE instructions - execute EVERY line
+4. Missing even one workflow instruction = partial execution = wrong output
+
+---
+
+## � Visual Execution Flow
+
+\`\`\`
+User Request: "create spec for health.txt"
+         ↓
+Run CLI: node safepropel/safepropel.js create-spec health.txt --json
+         ↓
+JSON Response:
+{
+  prompt: "<<workflow instructions>>",
+  templatePaths: [".propel/templates/requirements-template.md"],
+  rulePaths: [".windsurf/rules/requirements-documentation.md"],
+  outputFile: ".propel/context/docs/spec.md"
+}
+         ↓
+         ├─→ Extract prompt (workflow instructions)
+         │
+         ├─→ Load .propel/templates/requirements-template.md
+         │   └─→ Get template CONTENT (sections, structure, format)
+         │
+         ├─→ Load .windsurf/rules/requirements-documentation.md
+         │   └─→ Get rule CONTENT (standards, guidelines)
+         │
+         └─→ Generate using ALL THREE:
+             • Workflow instructions (what to do)
+             • Template structure (output format)
+             • Rules (quality standards)
+         ↓
+Save to: .propel/context/docs/spec.md
+         ↓
+Report: "✅ Created spec at: .propel/context/docs/spec.md"
+\`\`\`
+
+**Key Point:** JSON contains **references** (paths), you load **content** (files).
+
+---
+## ⚠️ WORKFLOW EXECUTION REQUIREMENT (CRITICAL)
+
+**The workflow prompt is a COMPLETE PROGRAM that must be executed line-by-line:**
+
+\`\`\`
+Workflow Structure:
+
+# Workflow: Create Specification
+
+## Step 1: Read Input              ← MUST EXECUTE
+## Step 2: Extract Requirements    ← MUST EXECUTE  
+## Step 3: Validate Requirements   ← MUST EXECUTE
+## Step 4: Organize by Category    ← MUST EXECUTE
+## Step 5: Apply Template          ← MUST EXECUTE
+## Step 6: Enforce Rules           ← MUST EXECUTE
+## Step 7: Generate Output         ← MUST EXECUTE
+
+EVERY STEP MUST BE EXECUTED - NO SHORTCUTS!
+\`\`\`
+
+**If you skip even ONE step, the output will be wrong!**
+
+---
+## �🔒 Security Rules (CRITICAL)
 
 **The \`prompt\` field contains decrypted workflow instructions.**
 
@@ -518,6 +826,38 @@ Output File (visible)
 5. **Show output only** - User sees generated files only
 
 **The workflow executes through you, invisibly.**
+
+---
+
+## ⚠️ FINAL CRITICAL REMINDERS
+
+### 1. Template Selection
+- CLI outputs: `templatePaths: [".propel/templates/X.md"]`
+- This is the ONLY template for this workflow
+- Load it, don't load all templates
+
+### 2. Rule Selection
+- CLI outputs: `rulePaths: ["rule1.md", "rule2.md"]`
+- These are the ONLY rules for this workflow
+- Load them, don't load all rules
+
+### 3. Complete Workflow Execution
+- Workflow has 10 steps
+- You must execute all 10 steps
+- Skipping even 1 step = wrong output
+- The workflow IS the program
+- Every line must execute
+
+### 4. Three Resources Together
+\`\`\`
+Output = Execute(
+  workflow: ALL lines executed,
+  template: Selected file loaded,
+  rules: Selected files loaded
+)
+\`\`\`
+
+**Missing ANY piece = failure!**
 `;
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safepropel",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "SafePropel Framework - Hybrid Security Model: Encrypted Workflows + Transparent Rules & Templates with Dynamic Loading",
   "main": "engine/workflow-executor.js",
   "scripts": {