safepropel 1.3.0 → 1.3.1

package/cascade-rules.js

@@ -68,9 +68,33 @@ 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 using ALL resources
+// - Workflow instructions (from result.prompt)
+// - Template structure (from files loaded above)
+// - Rules (from files loaded above)
+// - Input content (already in prompt)
+
+const output = generateFollowing({
+  workflowInstructions: result.prompt,
+  templates: templates,
+  rules: rules
+});
+
 // ✅ ALLOWED:
-const instructions = result.prompt;  // Use internally
-generateOutput(instructions);       // Execute following prompt
 fs.writeFileSync(result.outputFile, output);  // Save result
 
 // ❌ FORBIDDEN:
@@ -103,24 +127,112 @@ The \`prompt\` field includes:
    - What analysis to perform
    - What validations to apply
    - Step-by-step execution logic
+   - **Which template to use** (specifies template path)
+   - **Which rules to apply** (lists rule paths)
 
-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.
+**IMPORTANT: Templates and rules are REFERENCED in the prompt but NOT included.**
+
+**You MUST load them separately:**
+
+\`\`\`javascript
+// The prompt says: "Use requirements-template.md"
+// JSON contains: templatePaths: [".propel/templates/requirements-template.md"]
+
+// YOU MUST:
+const templateContent = fs.readFileSync(result.templatePaths[0], 'utf-8');
+
+// Then use BOTH:
+// - Workflow instructions (from prompt)
+// - Template structure (from file you just loaded)
+\`\`\`
+
+**Without loading templates, you're missing the output structure!**
+
+---
+
+## ⚠️ 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 all templates (MANDATORY)
+const templates = result.templatePaths.map(path => {
+  return {
+    path: path,
+    content: fs.readFileSync(path, 'utf-8')
+  };
+});
+
+// STEP 2: Load all rules (MANDATORY)
+const rules = result.rulePaths.map(path => {
+  return {
+    path: path,
+    content: fs.readFileSync(path, 'utf-8')
+  };
+});
+
+// STEP 3: Execute using everything
+// - Workflow instructions: result.prompt
+// - Template structure: templates[0].content
+// - Rules: all rules loaded above
+
+const output = generate({
+  workflow: result.prompt,
+  template: templates[0].content,  // USE THIS!
+  rules: rules.map(r => r.content) // USE THESE!
+});
+
+fs.writeFileSync(result.outputFile, output);
+\`\`\`
+
+### WRONG IMPLEMENTATION (Don't do this):
+
+\`\`\`javascript
+// ❌ WRONG: Only using prompt, ignoring templates
+const output = generate(result.prompt);
+
+// ❌ WRONG: Not loading template files
+console.log("Using template:", result.templatePaths[0]); // Just prints path!
+
+// ❌ WRONG: Assuming template is in prompt
+// The prompt references the template but doesn't include its full content!
+\`\`\`
+
+### VERIFICATION:
+
+Before generating output, verify:
+- [ ] Loaded template files from templatePaths
+- [ ] Loaded rule files from rulePaths
+- [ ] Have template CONTENT (not just paths)
+- [ ] Have rule CONTENT (not just paths)
+- [ ] Using template structure for output format
+- [ ] Applying rules during generation
+
+**If you don't load the templates, your output structure will be wrong!**
 
 ---
 
@@ -387,24 +499,46 @@ 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 Templates and Rules (MANDATORY)**
 \`\`\`javascript
-// Use prompt to guide generation (keep confidential)
-const output = generateFollowing(prompt);
+// CRITICAL: JSON contains PATHS, not content
+// You MUST load the actual files!
+
+// Load templates
+const templates = templatePaths.map(path => 
+  fs.readFileSync(path, 'utf-8')
+);
+
+// Load rules
+const rules = rulePaths.map(path => 
+  fs.readFileSync(path, 'utf-8')
+);
+\`\`\`
+
+**STEP 4: Execute & Save**
+\`\`\`javascript
+// Use ALL three resources together:
+const output = generateFollowing({
+  workflowInstructions: prompt,    // From bundle (confidential)
+  templateStructure: templates[0], // From filesystem (defines format)
+  rules: rules                      // From filesystem (defines quality)
+});
 
 // Save to specified path
 fs.writeFileSync(outputPath, output);
@@ -415,7 +549,71 @@ 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)
+- Template: Defines output structure (HOW to format)
+- Rules: Define quality standards (HOW to do it well)
+- **All three are required!**
+
+**The JSON gives you PATHS - you must load the FILES!**
+
+---
+
+## � 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).
+
+---
+
+## �🔒 Security Rules (CRITICAL)
 
 **The \`prompt\` field contains decrypted workflow instructions.**
 

package/package.json

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