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

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

@@ -19,11 +19,38 @@ 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
+- [ ] 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
@@ -213,7 +240,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 +269,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
@@ -401,19 +473,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 +514,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')
@@ -547,6 +628,43 @@ 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) |
+
+### 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 +709,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

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

@@ -0,0 +1,282 @@
+import requests
+from pathlib import Path
+import os
+import ast
+import sys
+import click
+
+"""
+Creates wiki file from test/behave/behave.log, with rule use.
+
+Tips
+* use 2 spaces (at end) for newline
+* for tab: & emsp;
+
+"""
+
+tab = " "
+behave_debug_info = " # "
+wiki_data = []
+debug_scenario = "XXGood Order Custom Service"
+
+scenario_doc_strings = {}
+""" dict of scenario_name, array of strings """
+
+
+def remove_trailer(line: str) -> str:
+    """ remove everything after the ## """
+    end_here = line.find("\t\t##")
+    result = line[0:end_here]
+    return result
+
+def line_spacer():
+    wiki_data.append("\n")
+    wiki_data.append(" ")
+    wiki_data.append(" ")
+    wiki_data.append("\n")
+
+
+def get_current_readme(prepend_wiki: str):
+    """ initialize wiki_data with readme up to {report_name} """
+    report_name = "Behave Logic Report"
+    with open(prepend_wiki) as readme:
+        readme_lines = readme.readlines()
+    need_spacer = True
+    for each_readme_line in readme_lines:
+        if '# ' + report_name in each_readme_line:
+            need_spacer = False
+            break
+        wiki_data.append(each_readme_line[0:-1])
+    if need_spacer:
+        line_spacer()
+    wiki_data.append(f'# {report_name}')
+
+def get_truncated_scenario_name(scenario_name: str) -> str:
+    """ address max file length (chop at 26), illegal characters """
+    scenario_trunc = scenario_name
+    if scenario_trunc is not None and len(scenario_trunc) >= 26:
+        scenario_trunc = scenario_name[0:25]
+    scenario_trunc = f'{str(scenario_trunc).replace(" ", "_")}'
+    return scenario_trunc
+
+
+def show_logic(scenario: str, logic_logs_dir: str):
+    """ insert s{logic_logs_dir}/scenario.log into wiki_data as disclosure area """
+    scenario_trunc = get_truncated_scenario_name(scenario)
+    logic_file_name = f'{logic_logs_dir}/{scenario_trunc}.log'
+    logic_file_name_path = Path(logic_file_name)
+    if not logic_file_name_path.is_file():  # debug code
+        # wiki_data.append(f'unable to find Logic Log file: {logic_file_name}')
+        if scenario == debug_scenario:
+            print(f'RELATIVE: {logic_file_name} in {os.getcwd()}')
+            full_name = f'{os.getcwd()}/{logic_file_name}'
+            print(f'..FULL: {os.getcwd()}/{logic_file_name}')
+            logic_file_name = '{logic_logs_dir}/test.log'
+            with open(logic_file_name) as logic:
+                logic_lines = logic.readlines()
+    else:
+        logic_log = []
+        rules_used = []
+        wiki_data.append("<details markdown>")
+        wiki_data.append("<summary>Tests - and their logic - are transparent.. click to see Logic</summary>")
+        line_spacer()
+        scenario_trunc = get_truncated_scenario_name(scenario)
+        if scenario_trunc in scenario_doc_strings:
+            wiki_data.append(f'**Logic Doc** for scenario: {scenario}')
+            wiki_data.append("   ")
+            for each_doc_string_line in scenario_doc_strings[scenario_trunc]:
+                wiki_data.append(each_doc_string_line[0: -1])
+            line_spacer()
+        wiki_data.append(f'**Rules Used** in Scenario: {scenario}')
+        wiki_data.append("```")
+        with open(logic_file_name) as logic:
+            logic_lines = logic.readlines()
+        is_logic_log = True
+        last_rules_start = -1
+        last_rules_end = -1
+        
+        # First, find the LAST "These Rules Fired" section
+        for i, each_logic_line in enumerate(logic_lines):
+            if "These Rules Fired" in each_logic_line:
+                last_rules_start = i + 1  # Start collecting from next line
+                last_rules_end = -1  # Reset end marker to find the next COMPLETE
+            elif last_rules_start > 0 and last_rules_end == -1:
+                if 'Logic Phase:' in each_logic_line and 'COMPLETE' in each_logic_line:
+                    last_rules_end = i
+                    
+        # Now process the file, collecting logic log and extracting the last rules section
+        for i, each_logic_line in enumerate(logic_lines):
+            each_logic_line = remove_trailer(each_logic_line)
+            
+            if is_logic_log:
+                if "These Rules Fired" in each_logic_line:
+                    is_logic_log = False
+                else:
+                    logic_log.append(each_logic_line)
+            
+            # Extract rules from the last "These Rules Fired" section
+            if last_rules_start <= i < last_rules_end:
+                # Skip empty lines
+                if each_logic_line.strip():
+                    wiki_data.append(each_logic_line + "  ")
+        
+        wiki_data.append("```")
+        wiki_data.append(f'**Logic Log** in Scenario: {scenario}')
+        wiki_data.append("```")
+        for each_logic_log in logic_log:
+            each_line = remove_trailer(each_logic_log)
+            wiki_data.append(each_line)
+        wiki_data.append("```")
+        wiki_data.append("</details>")
+
+
+def get_docStrings(steps_dir: str):
+    steps_dir_files = os.listdir(steps_dir)
+    indent = 4  # skip leading blanks
+    for each_steps_dir_file in steps_dir_files:
+        each_steps_dir_file_path = Path(steps_dir).joinpath(each_steps_dir_file)
+        if each_steps_dir_file_path.is_file():
+            with open(each_steps_dir_file_path) as f:
+                step_code = f.readlines()
+            # print(f'Found File: {str(each_steps_dir_file_path)}')
+            for index, each_step_code_line in enumerate(step_code):
+                if each_step_code_line.startswith('@when'):
+                    comment_start = index + 2
+                    if '"""' in step_code[comment_start]:
+                        # print(".. found doc string")
+                        doc_string_line = comment_start+1
+                        doc_string = []
+                        while (True):
+                            if '"""' in step_code[doc_string_line]:
+                                break
+                            doc_string.append(step_code[doc_string_line][indent:])
+                            doc_string_line += 1
+                        scenario_line = doc_string_line+1
+                        if 'scenario_name' not in step_code[scenario_line]:
+                            print(f'\n** Warning - scenario_name not found '\
+                                f'in file {str(each_steps_dir_file_path)}, '\
+                                f'after line {scenario_line} -- skipped')
+                        else:
+                            scenario_code_line = step_code[scenario_line]
+                            scenario_name_start = scenario_code_line.find("'") + 1
+                            scenario_name_end = scenario_code_line[scenario_name_start+1:].find("'")
+                            scenario_name = scenario_code_line[scenario_name_start: 
+                                scenario_name_end + scenario_name_start+1]
+                            if scenario_name == debug_scenario:
+                                print(f'got {debug_scenario}')
+                            scenario_trunc = get_truncated_scenario_name(scenario_name)
+                            # print(f'.... truncated scenario_name: {scenario_trunc} in {scenario_code_line}')
+                            scenario_doc_strings[scenario_trunc] = doc_string
+    # print("that's all, folks")
+
+
+def main(behave_log: str, scenario_logs: str, wiki: str, prepend_wiki: str):
+    """ main driver """
+    get_docStrings(steps_dir="features/steps")
+
+    get_current_readme(prepend_wiki=prepend_wiki)
+
+    contents = None
+    with open(behave_log) as f:
+        contents = f.readlines()
+
+    just_saw_then = False
+    current_scenario = ""
+    previous_scenario = ""
+    for each_line in contents:
+        if just_saw_then and each_line == "\n":
+            show_logic(scenario=current_scenario, logic_logs_dir=scenario_logs)
+            just_saw_then = False
+            previous_scenario = ""
+        if each_line.startswith("Feature"):
+            wiki_data.append("&nbsp;")
+            wiki_data.append("&nbsp;")
+            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:
+            current_scenario = each_line[18:]
+            previous_scenario = current_scenario
+            wiki_data.append("&nbsp;")
+            wiki_data.append("&nbsp;")
+            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()