ApiLogicServer 15.2.0__py3-none-any.whl → 15.2.7__py3-none-any.whl

api_logic_server_cli/prototypes/manager/.github/.copilot-instructions.md

@@ -1,20 +1,49 @@
+---
+title: Copilot Instructions for Manager Workspace
+Description: Manager-level instructions for creating projects
+Source: ApiLogicServer-src/prototypes/manager/.github/.copilot-instructions.md
+Propagation: BLT process → Manager workspace
+Usage: AI assistants read this when user opens Manager workspace
+version: 2.1
+changelog:
+  - 2.1 (Oct 2025) - Added "What is the Project Manager?" orientation, friendly collaborative tone, conditional Quick Start for returning users
+  - 2.0 (Oct 2025) - OBX improvements, strengthen basic_demo as default path
+  - 1.0 (Initial) - Established project creation methods
+---
+
 # GitHub Copilot Instructions for GenAI-Logic (aka API Logic Server) - Project Manager
 
-⚠️ **IMPORTANT FOR AI ASSISTANTS**: Always read and follow these instructions when helping users with this project.
+⚠️ **IMPORTANT FOR AI ASSISTANTS**: Always read and follow these instructions when helping with this project.
+
+## What is the Project Manager?
+
+Welcome! This is the **Project Manager** - think of it as your workspace for creating and managing API Logic Server projects.
+
+**What's here:**
+- Sample databases you can use to create projects (`samples/dbs/`)
+- Training materials and examples (`system/genai/examples/`)
+- A shared virtual environment for all your projects (`venv/`)
+- A place to create new projects (they'll appear as subdirectories)
 
-The Project Manager contains genai training, a virtual environment, and provides a convenient place to create projects.
+**What you'll do here:**
+Create projects from databases - each project becomes a complete, working microservice with API, Admin UI, and business logic support. Once created, you'll work inside that project to customize and extend it.
 
-> Note: your virtual environment is automatically configured in most cases; verify it with `genai-logic` - it it's not there, activate the `venv` in this project.
+> Note: Your virtual environment is automatically configured in most cases; verify it with `genai-logic` - if it's not there, activate the `venv` in this project.
 
-## Quick Start for New Users
+## Quick Start
 
-**ALWAYS start new users with the basic_demo** - it's the best introduction to the system.
+**First time here?** Let's start with the 20-minute basic_demo tutorial - it's the best way to see what GenAI-Logic can do.
 
-It's a small sqlite database, and provides a readme that explores the project, and how to customize it:
+Run this command:
 
 ```bash
 genai-logic create --project_name=basic_demo --db_url=basic_demo
 ```
+
+After it runs, the project will auto-open with its own README and I'll guide you through a hands-on tour.
+
+**Already have basic_demo?** Open it and say "Guide me through basic_demo" for the hands-on tour, or ask me what else we can work on.
+
 <br>
 
 ## Creating Projects
@@ -27,7 +56,7 @@ There are multiple ways to create projects (aka systems, microservices) - see th
 
 ### Method 1: Create Projects from an existing database (Infrastructure Only)
 
-If the user provides a database reference, use the command below.  (Note: sqlite sample databases at `samples/dbs`). 
+If you have a database reference, I can create a project from it. (Sample databases are in `samples/dbs`). 
 
 ```bash
 genai-logic create  --project_name=nw --db_url=sqlite:///samples/dbs/nw.sqlite
@@ -35,13 +64,11 @@ genai-logic create  --project_name=nw --db_url=sqlite:///samples/dbs/nw.sqlite
 
 **Important:** This creates the project structure, API, Admin App, and database models, but **NO business logic rules**.
 
-**To add logic:** Users must add rules separately using:
-- Natural language with Copilot/AI assistant in `logic/declare_logic.py`, or
-- Manual coding with IDE code completion
+**To add logic:** We can add rules together using natural language in `logic/declare_logic.py`, or you can code them manually with IDE autocomplete.
 
 ### Method 2: Create Projects with GenAI (Complete System with Logic)
 
-**Use this when the user provides both database AND business logic requirements.**
+**Use this when you have both database AND business logic requirements.**
 
 Describe database and logic in Natural Language in a prompt file.
 
@@ -58,25 +85,25 @@ genai-logic genai --using=system/genai/examples/genai_demo/genai_demo.prompt --p
 4. Creates test data
 5. Creates API, Admin App, and complete project structure
 
-**When to use:** User provides requirements like "Customer balance is sum of orders" or "Check credit limit" - the LLM will generate the corresponding `Rule.sum`, `Rule.constraint`, etc.
+**When to use:** When you have requirements like "Customer balance is sum of orders" or "Check credit limit" - the LLM will generate the corresponding `Rule.sum`, `Rule.constraint`, etc.
 
 ### Method 3: Create Projects with new databases (Manual Approach)
 
-If the user provides a description but you want to create the database manually:
+If you provide a description but want to create the database manually:
 
-1. Create a sqlite database from the description.  Be sure to include foreign keys.  The system works well with `id INTEGER PRIMARY KEY AUTOINCREMENT`.
-2. Then, use the `genai-logic create` command above.
-3. If logic is provided, translate it using Copilot or `system/genai/learning_requests/logic_bank_api.prompt`.
+1. I'll create a sqlite database from your description. I'll be sure to include foreign keys. The system works well with `id INTEGER PRIMARY KEY AUTOINCREMENT`.
+2. Then, I'll use the `genai-logic create` command above.
+3. If you have logic requirements, we can translate them together using `system/genai/learning_requests/logic_bank_api.prompt`.
 
-## AI Assistant Guidelines
+## Working Together
 
-When users ask "what do I do now?" or similar questions:
+When you ask "what should I do now?" or similar:
 
-1. **Always recommend starting with basic_demo** using the command above
-2. **Use CLI commands** (genai-logic) not Docker scripts for project creation
-3. **Refer to existing sample databases** in `samples/dbs/` for examples
-4. **Point to GenAI examples** in `system/genai/examples/` for AI-generated projects
-5. **Emphasize the 20-minute evaluation workflow** described in the main README
+1. **I'll recommend starting with basic_demo** using the command above
+2. **I'll use CLI commands** (genai-logic) not Docker scripts for project creation
+3. **I'll point you to sample databases** in `samples/dbs/` for examples
+4. **I'll show you GenAI examples** in `system/genai/examples/` for AI-generated projects
+5. **We'll follow the 20-minute workflow** described in the main README
 
 ## Available Databases
 - `basic_demo` - Best for first-time users

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/.github/.copilot-instructions.md

@@ -26,6 +26,9 @@ This is a **GenAI-Logic (aka API Logic Server) project** - a complete, working m
 
 3. **Automatic Business Logic**: All APIs (standard and custom) automatically inherit LogicBank rules without additional code.
 
+4. **CLI Commands**: Use `genai-logic --help` to see all available commands. When CLI commands exist for a task (e.g., `add-auth`, `genai-add-mcp-client`, `genai-add-app`), ALWAYS use them instead of manual configuration - they handle all setup correctly.
+
+
 ## ⚠️ IMPORTANT: What's Already Built
 
 **DO NOT recreate these - they're already working:**

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/docs/training/testing.md

@@ -19,11 +19,41 @@ Step 1c. Scan api/api_discovery/*.py → Discover custom APIs (PHASE 2!)
 Step 2.  Decide Phase 1 vs Phase 2 → Based on custom API existence
 Step 3.  Generate .feature files → Business language scenarios
 Step 4.  Implement steps/*.py → Using discovered APIs or CRUD
-Step 5.  Run tests → python behave_run.py
+Step 4b. VERIFY STEP ORDERING → Multi-item BEFORE single-item (Rule #0.5!)
+Step 5.  SUGGEST how to run tests (DO NOT run automatically)
 ```
 
+**CRITICAL PRE-TEST CHECKLIST:**
+- [ ] Step 1c completed? (Custom APIs discovered)
+- [ ] **Database values verified?** (Rule #10: Run SQL to check actual prices/flags)
+  - [ ] `sqlite3 db.sqlite "SELECT name, unit_price, carbon_neutral FROM product;"`
+  - [ ] Don't assume product attributes - verify BEFORE writing expectations!
+- [ ] **Step ordering verified?** (Most specific → Most general)
+  - [ ] @when patterns: carbon neutral > multi-item > single-item
+  - [ ] @given patterns: multi-item > single-item
+  - [ ] Use `grep -n "@when('.*with" steps/*.py` to verify order
+- [ ] **Clear scenario language?** (Rule #13: Action-oriented wording)
+  - [ ] Use "Order is created" not "Order exists" (shows when rules fire)
+  - [ ] Makes test flow obvious: setup → action → verify
+- [ ] Test data uses timestamps? (Rule #0: Repeatability)
+- [ ] Security config read? (SECURITY_ENABLED value)
+
 **DO NOT skip Step 1c!** Custom APIs change the entire testing approach.
 
+**DO NOT skip Step 4b!** Wrong step ordering causes silent failures with balance=0.
+
+**DO NOT run tests automatically!** Instead, suggest this workflow:
+
+```bash
+# 1. Start the server (in separate terminal or background)
+python api_logic_server_run.py
+
+# 2. Run the tests (in another terminal)
+python test/api_logic_server_behave/behave_run.py
+```
+
+**Why manual execution?** Tests require a running server. The AI cannot manage multiple terminals or background processes reliably.
+
 ## Phase 1 vs Phase 2: The Core Decision
 
 ### Phase 1: CRUD-Level Testing
@@ -140,7 +170,7 @@ def step_impl(context, qty):
     r = requests.patch(url=patch_uri, json=patch_data)
 ```
 
-## The 6 Critical Rules (Read FIRST!)
+## The Critical Rules (Read FIRST!)
 
 ### Rule #0: TEST REPEATABILITY (MOST CRITICAL!) ⚠️
 
@@ -213,7 +243,7 @@ def step_impl_general(context, customer_name, quantity, product_name):
     ...
 ```
 
-**Example 2: Multi-Item Orders**
+**Example 2: Multi-Item Orders (GIVEN pattern)**
 
 ```python
 # ❌ WRONG ORDER - Single-item pattern matches "3 Widget and 2 Gadget"
@@ -242,6 +272,51 @@ def step_impl_single(context, customer_name, quantity, product_name):
     ...
 ```
 
+**Example 3: Multi-Item Orders (WHEN pattern) - Real Bug Found!**
+
+```python
+# ❌ WRONG ORDER - Causes silent failure with balance=0 instead of expected value
+@when('B2B order placed for "{customer_name}" with {quantity:d} {product_name}')
+def step_impl_single(context, customer_name, quantity, product_name):
+    # This matches "3 Widget and 2 Gadget" FIRST!
+    # product_name becomes "Widget and 2 Gadget" (entire string)
+    # OrderB2B API tries to find product "Widget and 2 Gadget" → fails
+    # Returns 200 but no order created → customer balance stays 0
+    # Test fails: "expected 570, got 0.0"
+    ...
+
+@when('B2B order placed for "{customer_name}" with {qty1:d} {product1} and {qty2:d} {product2}')
+def step_impl_multi(context, customer_name, qty1, product1, qty2, product2):
+    # NEVER REACHED! Single-item pattern matched first
+    ...
+
+# ✅ CORRECT ORDER - Multi-item pattern MUST come before single-item
+@when('B2B order placed for "{customer_name}" with {qty1:d} {product1} and {qty2:d} {product2}')
+def step_impl_multi(context, customer_name, qty1, product1, qty2, product2):
+    # Now matches "3 Widget and 2 Gadget" correctly
+    # Creates order with 2 items, balance = 570
+    ...
+
+@when('B2B order placed for "{customer_name}" with {quantity:d} {product_name}')
+def step_impl_single(context, customer_name, quantity, product_name):
+    # Now only matches single product patterns
+    ...
+```
+
+**CRITICAL FILE ORGANIZATION:**
+Within each decorator type (@given, @when, @then), organize patterns like this:
+
+```python
+# For @when patterns:
+@when('... with {qty:d} carbon neutral {product}')  # Most specific (3+ keywords)
+@when('... with {qty1:d} {p1} and {qty2:d} {p2}')  # More specific (multi-param + "and")
+@when('... with {quantity:d} {product_name}')      # General (fewest keywords)
+
+# For @given patterns:
+@given('... with {qty1:d} {p1} and {qty2:d} {p2}')  # More specific (multi-param + "and")
+@given('... with {quantity:d} {product_name}')      # General (fewer params)
+```
+
 **Why This Matters:**
 - Wrong order → context.item_id not set → "Then Item amount" step fails with "item_id not set in context"
 - Behave doesn't warn about unreachable patterns
@@ -314,18 +389,65 @@ Scenario: Exceed Credit (Constraint FAIL - negative test)
 
 **CRITICAL:** Check `logic/declare_logic.py` for custom Python logic affecting calculations (e.g., discounts, adjustments) before writing constraint test expectations!
 
-### Rule #5: Security Configuration
+### Rule #5: Security Configuration - JWT Authentication
+
+**CRITICAL:** When `SECURITY_ENABLED=True`, tests MUST obtain JWT token and include Authorization header.
+
 ```python
-# Read config/default.env FIRST
-SECURITY_ENABLED = False  # or True
+from pathlib import Path
+import os
+from dotenv import load_dotenv
 
-# Match in test code
-if SECURITY_ENABLED == False:
-    headers = {}  # Empty
-else:
-    headers = test_utils.login()
+# Load config to check SECURITY_ENABLED
+config_path = Path(__file__).parent.parent.parent.parent.parent / 'config' / 'default.env'
+load_dotenv(config_path)
+
+# Cache for auth token (obtained once per test session)
+_auth_token = None
+
+def get_auth_token():
+    """Login and get JWT token if security is enabled"""
+    global _auth_token
+    
+    if _auth_token is not None:
+        return _auth_token
+    
+    # Login with default admin credentials
+    login_url = f'{BASE_URL}/api/auth/login'
+    login_data = {'username': 'admin', 'password': 'p'}
+    
+    response = requests.post(login_url, json=login_data)
+    if response.status_code == 200:
+        _auth_token = response.json().get('access_token')
+        return _auth_token
+    else:
+        raise Exception(f"Login failed: {response.status_code}")
+
+def get_headers():
+    """Get headers including auth token if security is enabled"""
+    security_enabled = os.getenv('SECURITY_ENABLED', 'false').lower() not in ['false', 'no']
+    
+    headers = {'Content-Type': 'application/json'}
+    
+    if security_enabled:
+        token = get_auth_token()
+        if token:
+            headers['Authorization'] = f'Bearer {token}'
+    
+    return headers
+
+# Use in ALL API requests
+response = requests.post(url=api_url, json=data, headers=get_headers())
+response = requests.get(url=api_url, headers=get_headers())
+response = requests.patch(url=api_url, json=data, headers=get_headers())
 ```
 
+**Key Points:**
+- Tests DO NOT automatically include auth - you must code the pattern above
+- Token is cached globally to avoid repeated login calls
+- Works for both `SECURITY_ENABLED=True` and `SECURITY_ENABLED=False`
+- See complete example: `test/api_logic_server_behave/features/steps/order_processing_steps.py`
+
 ### Rule #6: Logic Logging
 ```python
 @when('Good Order Placed')
@@ -401,19 +523,28 @@ Rule.sum(derive=Customer.balance, as_sum_of=Order.amount_total,
 ```python
 # ALWAYS check actual product prices/flags before writing test expectations!
 
-# Check prices:
-# sqlite3 db.sqlite "SELECT name, unit_price, carbon_neutral FROM Product;"
+# Check prices AND flags:
+# sqlite3 db.sqlite "SELECT name, unit_price, carbon_neutral FROM product;"
 
-# Widget=90, Gadget=150, Green=109
+# Results:
+# 1|Gadget|150|1        ← carbon_neutral = 1 (TRUE)
+# 2|Widget|90|          ← carbon_neutral = NULL (not carbon neutral!)
+# 3|Thingamajig|5075|
+# 4|Doodad|110|
+# 5|Green|109|1         ← carbon_neutral = 1 (TRUE)
 
-# ❌ WRONG - Assumed Widget=$100
-# Expected: 10 * 100 = 1000
+# ❌ WRONG - Assumed Widget is carbon neutral
+# Scenario: Carbon Neutral Discount
+#   When B2B order placed with 10 carbon neutral Widget
+#   Then balance should be 810  # Expected 10 * 90 * 0.9 = 810
+# FAILS: Widget is NOT carbon neutral → no discount → balance = 900
 
-# ✅ CORRECT - Verified Widget=$90  
-# Expected: 10 * 90 = 900
+# ✅ CORRECT - Verified Gadget IS carbon neutral (flag = 1)
+# Scenario: Carbon Neutral Discount
+#   When B2B order placed with 10 carbon neutral Gadget
+#   Then balance should be 1350  # Correct: 10 * 150 * 0.9 = 1350
 
-# For carbon neutral discount (10% off when qty >= 10):
-# Expected: 10 * 90 * 0.9 = 810
+# CRITICAL: Don't assume product attributes - VERIFY with SQL first!
 ```
 
 ### Rule #11: Step Definitions Must Match Feature Files ⚠️ NEW
@@ -433,7 +564,7 @@ def step_impl(context, customer_name):  # Missing balance and limit parameters!
     limit = 1000
 ```
 
-### Rule #10: Always Initialize Context Variables ⚠️ NEW
+### Rule #12: Always Initialize Context Variables ⚠️ NEW
 ```python
 # ✅ CORRECT - prevents KeyError in subsequent steps
 @when('B2B order placed')
@@ -454,6 +585,40 @@ def step_impl(context):
         return  # Skip gracefully
 ```
 
+### Rule #13: Use Clear, Action-Oriented Scenario Language ⚠️ NEW
+```gherkin
+# ❌ AMBIGUOUS - "exists" is passive, doesn't show when balance changes
+Scenario: Ship Order Excludes from Balance
+  Given Customer "Charlie" with balance 0 and credit limit 2000
+  And Order exists for "Charlie" with 2 Widget
+  When Order is shipped
+  Then Customer balance should be 0
+
+# Question: How can Charlie have balance 0 AND an order for widgets?
+# Answer: The order EXISTS at test start, but balance calculation is unclear
+
+# ✅ CLEAR - "is created" shows action that triggers rule
+Scenario: Ship Order Excludes from Balance
+  Given Customer "Charlie" with balance 0 and credit limit 2000
+  And Order is created for "Charlie" with 2 Widget  # Action! Balance becomes 180
+  When Order is shipped                              # Action! Balance drops to 0
+  Then Customer balance should be 0                  # Verification
+
+# Now it's obvious:
+# 1. Customer starts with balance 0
+# 2. Creating unshipped order → rule fires → balance becomes 180
+# 3. Shipping order → WHERE clause excludes it → balance drops to 0
+
+# More examples:
+# ❌ "And Shipped order exists for..."
+# ✅ "And Shipped order is created for..."
+
+# Why this matters:
+# - Shows WHEN rules fire (on creation, not just existence)
+# - Makes test flow obvious (setup → action → verify)
+# - Clarifies that declarative rules execute automatically on changes
+```
+
 ## Complete Phase 2 Example
 
 ### .feature File
@@ -547,6 +712,45 @@ def step_impl(context, expected):
 | "row altered by another user" | Use direct FK: `"customer_id": int(id)` |
 | "circular import" | Remove imports from logic/, database/ |
 | "empty logic log" | Add `test_utils.prt(msg, scenario_name)` |
+| **"balance: expected 570, got 0.0"** | **Step ordering issue (Rule #0.5)! Multi-item pattern after single-item** |
+| **"context has no attribute 'item_id'"** | **Step ordering issue! Specific pattern defined after general pattern** |
+| "Order created but no items" | Check if wrong step matched (print debug in step) |
+| **"expected 810, got 900"** (carbon neutral) | **Rule #10: Verify actual database values! Check product flags with SQL first** |
+| **"How can balance be 0 with an order?"** | **Rule #13: Use "is created" not "exists" - shows when rules fire** |
+
+### Debugging Step Ordering Issues
+
+**Symptom**: Test passes WHEN step but THEN assertions fail with unexpected values (often 0 or None).
+
+**Diagnosis**:
+1. **Check which step executed**: Look at test output for line numbers
+   ```
+   When B2B order placed for "Kevin" with 3 Widget and 2 Gadget # line=261
+   ```
+   If line 261 is single-item but you expected line 320 (multi-item), wrong pattern matched!
+
+2. **Verify database**: Check if records were actually created
+   ```bash
+   sqlite3 db.sqlite "SELECT * FROM 'order' WHERE customer_id = X;"
+   sqlite3 db.sqlite "SELECT * FROM item WHERE order_id = Y;"
+   ```
+
+3. **Check step file organization**: Count literal keywords in each pattern
+   ```python
+   # line 202: "carbon neutral" = 2 keywords (most specific)
+   # line 261: {quantity:d} {product_name} = 0 keywords (general)
+   # line 320: {qty1} {p1} "and" {qty2} {p2} = 1 keyword (more specific)
+   ```
+   Line 320 MUST come BEFORE line 261!
+
+**Quick Fix**:
+```bash
+# Find all @when patterns in your steps file
+grep -n "@when('.*with.*{" features/steps/*.py
+
+# Reorder so patterns with MORE keywords/parameters come FIRST
+# Rule: Most specific → Most general (top to bottom)
+```
 
 ## Test Generation Workflow
 
@@ -591,3 +795,83 @@ def step_impl(context, expected):
 
 **The Magic:** Users built OrderB2B for partners → Same API provides natural test scenarios!
 
+## Automated Step Ordering Verification
+
+**Command to verify step ordering in your test files:**
+
+```bash
+# List all @when patterns with line numbers (should be ordered specific→general)
+cd test/api_logic_server_behave
+grep -n "@when('.*with.*{" features/steps/*.py
+
+# Expected output (line numbers ascending = correct order):
+# 202: @when('... with {qty:d} carbon neutral {product}')  # Most specific
+# 265: @when('... with {qty1:d} {p1} and {qty2:d} {p2}')    # More specific  
+# 318: @when('... with {quantity:d} {product_name}')        # General
+
+# If multi-item (line 265) comes AFTER single-item (line 318) = WRONG!
+```
+
+**Python script to auto-check ordering** (add to test directory):
+
+```python
+#!/usr/bin/env python3
+"""Verify Behave step ordering for multi-param patterns."""
+import re, sys
+from pathlib import Path
+
+def check_step_order(steps_file):
+    """Check if multi-item patterns come before single-item patterns."""
+    with open(steps_file) as f:
+        lines = f.readlines()
+    
+    issues = []
+    when_patterns = []
+    
+    for i, line in enumerate(lines, 1):
+        if match := re.match(r"@when\('.*with.*\{", line):
+            # Count parameters and keywords
+            param_count = line.count('{')
+            has_and = ' and ' in line
+            has_special_keyword = any(k in line for k in ['carbon neutral', 'shipped'])
+            
+            specificity = param_count + (2 if has_and else 0) + (3 if has_special_keyword else 0)
+            when_patterns.append((i, specificity, line.strip()))
+    
+    # Check if patterns are in descending specificity order
+    for i in range(len(when_patterns) - 1):
+        curr_line, curr_spec, curr_text = when_patterns[i]
+        next_line, next_spec, next_text = when_patterns[i + 1]
+        
+        if next_spec > curr_spec:
+            issues.append(f"❌ Line {next_line} (specificity={next_spec}) should come BEFORE line {curr_line} (specificity={curr_spec})")
+            issues.append(f"   More specific: {next_text}")
+            issues.append(f"   Less specific: {curr_text}")
+    
+    return issues
+
+if __name__ == '__main__':
+    steps_dir = Path('features/steps')
+    all_issues = []
+    
+    for steps_file in steps_dir.glob('*_steps.py'):
+        issues = check_step_order(steps_file)
+        if issues:
+            all_issues.extend([f"\n{steps_file}:"] + issues)
+    
+    if all_issues:
+        print("Step Ordering Issues Found:")
+        print('\n'.join(all_issues))
+        sys.exit(1)
+    else:
+        print("✅ All step patterns correctly ordered (specific → general)")
+        sys.exit(0)
+```
+
+**Usage:**
+```bash
+cd test/api_logic_server_behave
+python check_step_order.py  # Run before committing tests
+```
+
+This automation prevents Rule #0.5 violations across ALL databases and projects!

api_logic_server_cli/prototypes/manager/samples/basic_demo_sample/test/api_logic_server_behave/behave_logic_report.py

@@ -193,90 +193,19 @@ def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
             wiki_data.append(" ")
             each_line = "## " + each_line
         if each_line.startswith("  Scenario"):
-            # Before starting new scenario, show logic for previous one if we saw Then
-            if just_saw_then and previous_scenario:
-                show_logic(scenario=previous_scenario, logic_logs_dir=scenario_logs)
-            just_saw_then = False
-            each_line = tab + each_line
-        if each_line.startswith("    Given") or \
-                each_line.startswith("    When") or \
-                each_line.startswith("    Then"):
-            if each_line.startswith("    Then"):
-                just_saw_then = True
-            each_line = tab + tab + each_line
-
-        each_line = each_line[:-1]
-        debug_loc = each_line.find(behave_debug_info)
-        if debug_loc > 0:
-            each_line = each_line[0 : debug_loc]
-        each_line = each_line.rstrip()
-        if "Scenario" in each_line:
+            # Extract scenario name for logic lookup
             current_scenario = each_line[18:]
-            previous_scenario = current_scenario
             wiki_data.append(" ")
             wiki_data.append(" ")
-            wiki_data.append("### " + each_line[8:])
-
-        each_line = each_line + "  "  # wiki for "new line"
-        
-        wiki_data.append(each_line)
-    
-    # Show logic for the last scenario if we saw Then
-    if just_saw_then and current_scenario:
-        show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
-
-    with open(wiki, 'w') as rpt:
-        rpt.write('\n'.join(wiki_data))
-    wiki_full_path = Path(wiki).absolute()
-    print(f'Wiki Output: {wiki_full_path}\n\n')
-
-
-
-def print_args(args, msg):
-    print(msg)
-    for each_arg in args:
-        print(f'  {each_arg}')
-    print(" ")
-
-
-@click.group()
-@click.pass_context
-def cli(ctx):
-    """
-    Combine behave.log and scenario_logic_logs to create Behave Logic Report
-
-    """
-    pass
-
-
-@cli.command("run")
-@click.pass_context
-@click.option('--behave_log',
-              default=f'logs/behave.log',  # cwd set to test/api_logic_server_behave
-              # prompt="Log from behave test suite run [behave.log]",
-              help="Help")
-@click.option('--scenario_logs',
-              default=f'logs/scenario_logic_logs',
-              # prompt="Logic Log directory from ",
-              help="Help")
-@click.option('--wiki',
-              default=f'reports/Behave Logic Report.md',
-              # prompt="Log from behave test suite run [api_logic_server_behave]",
-              help="Help")
-@click.option('--prepend_wiki',
-              default=f'reports/Behave Logic Report Intro micro.md',
-              # prompt="Log from behave test suite run [Behave Logic Report Intro]",
-              help="Help")
-def run(ctx, behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
-    main(behave_log = behave_log, scenario_logs = scenario_logs, wiki = wiki, prepend_wiki = prepend_wiki)
-
-
-if __name__ == '__main__':  # debugger & python command line start here
-    # eg: python api_logic_server_cli/cli.py create --project_name=~/Desktop/test_project
-    # unix: python api_logic_server_cli/cli.py create --project_name=/home/ApiLogicProject
-
-    print(f'\nBehave Logic Report 1.1, started at {os.getcwd()}')
-    commands = sys.argv
-    if len(sys.argv) > 1:
-        print_args(commands, f'\n\nCommand Line Arguments:')
-    cli()
+            # Remove the debug info (# features/...) from the scenario name
+            debug_loc = current_scenario.find(behave_debug_info)
+            if debug_loc > 0:
+                current_scenario = current_scenario[0:debug_loc].strip()
+            wiki_data.append(" ")
+            wiki_data.append(" ")
+            # Remove debug info from header line too
+            header_line = each_line[2:]
+            debug_loc = header_line.find(behave_debug_info)
+            if debug_loc > 0:
+                header_line = header_line[0:debug_loc].rstrip()
+            wiki_data.append("### " + header_line)  # Add scenario header