# assemble.py
import utils

def main():
    input_data = utils.load_json("input.json")
    processed_data = utils.process_data(input_data)
    utils.save_output(processed_data, "output.json")

if __name__ == "__main__":
    main()

# utils.py
import json

def load_json(filepath):
    with open(filepath, 'r') as f:
        return json.load(f)

def save_output(data, filepath):
    with open(filepath, 'w') as f:
        json.dump(data, f, indent=4)

def process_data(data):
    # Example data processing logic
    return {k: v.upper() for k, v in data.items()}

# automation-adoption.py
import json
from utils import chat_with_llm, parse_llm_json_response, saveToFile

flowUUID = None # Global variable for flow UUID

def generate_automation_adoption(input_data, save_inputs=False):
    """Generate detailed information about automation adoption phases for a specific topic."""
    # Extract information from input data
    topic = input_data.get("topic", "")
    model = input_data.get("model", "gemma3")
    parameters = input_data.get("parameters", {})

    # Generate automation adoption phases using LLM
    systemMsg = (
        "You are an AI assistant specialized in analyzing automation adoption patterns. "
        "Your task is to identify and explain the different phases of automation adoption "
        "in a specific field or topic, from basic mechanical assistance to full end-to-end automation."
    )

    user_msg = (
        f"Create a detailed breakdown of automation adoption phases for: {topic}\n\n"
        "Please structure your response in 4 phases:\n"
        "Phase 1: Basic Mechanical Assistance (Currently widespread)\n"
        "Phase 2: Integrated Semi-Automation (Currently in transition)\n"
        "Phase 3: Advanced Automation Systems (Emerging technology)\n"
        "Phase 4: Full End-to-End Automation (Future development)\n\n"
        "For each phase:\n"
        "1. Provide 4-6 specific examples of automation technology or processes\n"
        "2. Make sure the automation complexity increases with each phase\n"
        "3. Be specific to the domain rather than generic\n\n"
        "Format your response as a JSON object with the following structure:\n"
        "{\n"
        "  \"phase1\": {\n"
        "    \"title\": \"Basic Mechanical Assistance\",\n"
        "    \"status\": \"Currently widespread\",\n"
        "    \"examples\": [\"example1\", \"example2\", ...]\n"
        "  },\n"
        "  \"phase2\": { ... },\n"
        "  \"phase3\": { ... },\n"
        "  \"phase4\": { ... }\n"
        "}\n\n"
        "Only include examples that are significantly relevant to the topic."
    )

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/5-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate automation adoption phases
    response = chat_with_llm(model, systemMsg, user_msg, parameters)

    try:
        # Try to parse JSON response
        adoption_phases = parse_llm_json_response(response)
        return adoption_phases
    except json.JSONDecodeError:
        print("Error: LLM response is not valid JSON. Full response: " + response)
        return None

graph TD
    A[assemble.py] --> B(utils.py)
    A --> C[automation-adoption.py]
    C --> B
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#ccf,stroke:#333,stroke-width:2px
    style C fill:#ccf,stroke:#333,stroke-width:2px

sequenceDiagram
    participant User
    participant assemble.py
    participant automation-adoption.py
    participant utils.py
    participant LLM

    User->>assemble.py: Run assemble.py
    assemble.py->>automation-adoption.py: Call generate_automation_adoption(input_data)
    automation-adoption.py->>utils.py: Call chat_with_llm(model, systemMsg, user_msg, parameters)
    utils.py->>LLM: Send prompt
    LLM-->>utils.py: Return response
    utils.py-->>automation-adoption.py: Return response
    automation-adoption.py->>utils.py: Call parse_llm_json_response(response)
    utils.py-->>automation-adoption.py: Return metadata
    automation-adoption.py-->>assemble.py: Return adoption_phases
    assemble.py->>User: Output result

# utils.py
import json

def load_json(filepath):
    """Loads JSON data from a file.

    Args:
        filepath (str): The path to the JSON file.

    Returns:
        dict: The loaded JSON data as a dictionary.
        None: If the file does not exist or contains invalid JSON.
    """
    try:
        with open(filepath, 'r') as f:
            data = json.load(f)
        return data
    except FileNotFoundError:
        print(f"Error: File not found at {filepath}")
        return None
    except json.JSONDecodeError:
        print(f"Error: Invalid JSON in file {filepath}")
        return None

# prompt.py

def create_prompt(template, data):
    """Creates a prompt by substituting data into a template.

    Args:
        template (str): The prompt template with placeholders.
        data (dict): A dictionary containing the data to substitute.

    Returns:
        str: The formatted prompt.
    """
    try:
        prompt = template.format(**data)
        return prompt
    except KeyError as e:
        print(f"Error: Missing key in data: {e}")
        return None

# reconstructor.py
import json
import re

def parse_llm_json_response(response):
    """
    Extracts a JSON object from a string response, handling potential surrounding text.

    Args:
        response (str): The string containing the JSON object.

    Returns:
        dict: The extracted JSON object as a dictionary, or None if extraction fails.
    """
    try:
        # Use regex to find the JSON-like substring
        match = re.search(r"\{.*\}", response, re.DOTALL)  # Match JSON-like structures
        if match:
            json_str = match.group(0)
            # Attempt to parse the JSON string
            data = json.loads(json_str)
            return data
        else:
            print("Error: No JSON object found in the response.")
            return None
    except json.JSONDecodeError as e:
        print(f"Error decoding JSON: {e}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return None

graph TD
    A[User Input] --> B(Prompt Generation - prompt.py);
    B --> C(LLM);
    C --> D(Response - Raw Text);
    D --> E(JSON Extraction - reconstructor.py);
    E --> F{Valid JSON?};
    F -- Yes --> G(Data Processing);
    F -- No --> H(Error Handling);
    G --> I[Output];
    H --> I;
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style I fill:#f9f,stroke:#333,stroke-width:2px

graph TD
    A[Gather Ingredients] --> B[Mix Dough];
    B --> C[First Proofing];
    C --> D[Shape Dough];
    D --> E[Second Proofing];
    E --> F[Bake];
    F --> G[Cool];
    G --> H[Enjoy];

# generate-metadata.py
breadcrumbs_path = os.path.join(flow_dir, "breadcrumbs.txt")
with open(breadcrumbs_path, "w", encoding="utf-8") as f:
    f.write(breadcrumbs)
print(f"Breadcrumbs saved: {breadcrumbs}")

graph TD
    A[Resource Acquisition] --> B[Component Manufacturing];
    B --> C[Assembly in Orbit];
    C --> D[Energy Transmission];
    D --> E[System Integration];

# assemble.py
output_html = template.render(context)

# Write output
# Generate slug from processed metadata title
slug = processed_metadata.get('slug', processed_metadata.get('title', 'output').lower().replace(' ', '-'))
# Ensure slug is filesystem-safe (basic example)
slug = "".join(c for c in slug if c.isalnum() or c in ('-', '_')).rstrip() or "output"
output_path = Path(output_dir) / f"{slug}.html"
output_path.parent.mkdir(parents=True, exist_ok=True)

with open(output_path, 'w', encoding='utf-8') as f:
    f.write(output_html)

python assemble.py <input_directory> <output_directory>

# assemble.py
metadata_path = os.path.join(flow_dir, "metadata.json")
specs_path = os.path.join(flow_dir, "specifications-industrial.json")
alt_trees_path = os.path.join(flow_dir, "hallucinate-tree.json")

metadata_data = load_json(metadata_path)
specs_data = load_json(specs_path)
alt_trees_data = load_json(alt_trees_path)

graph TD
    A[generate-metadata.py] --> B[hallucinate-tree.py];
    B --> C[generate-automation-timeline.py];
    C --> D[generate-automation-challenges.py];
    D --> E[automation-adoption.py];
    E --> F[current-implementations.py];
    F --> G[return-analysis.py];
    G --> H[future-technology.py];
    H --> I[specifications-industrial.py];
    I --> J[assemble.py];


---

<a id='page-4'></a>

## Extending and Customizing Routines

### Related Files

- `flow-maker.py`
- `generate-metadata.py`
- `README.md`

### Related Pages

Related topics: [Example Workflows and Use Cases](#page-3)

## Extending and Customizing Routines

This page details how to extend and customize the `routines` repository, focusing on `flow-maker.py`, `generate-metadata.py`, and the information available in `README.md`.

### Purpose and Functionality

The `routines` repository appears to be designed for automated generation of documentation, specifically for creating a "Universal Automation Wiki." It uses a series of Python scripts and LLMs (Language Model) to generate content, assemble it, and output a structured document.

-   **`flow-maker.py`**: This script seems to orchestrate the overall workflow. It defines the sequence of programs to run, manages input and output file paths, and handles the execution of each step. It also manages breadcrumbs for navigation.
-   **`generate-metadata.py`**: This script generates metadata for a given topic using an LLM. It takes a topic as input, constructs a prompt, sends it to the LLM, parses the JSON response, and returns the metadata. The generated metadata includes information like automation progress, explanatory text, and a summary.
-   **`README.md`**: This file provides general information about the repository, including setup instructions, usage examples, and a description of the project's goals.

### Code Examples and Explanations

#### `flow-maker.py`

This script is the main orchestrator.  Here's a snippet highlighting the program execution flow:

```python
# flow-maker.py
import os
import sys
import json
import uuid
import shutil
from datetime import datetime
import subprocess
from utils import load_json, saveToFile, parse_llm_json_response, chat_with_llm, handle_command_args, get_output_filepath

def main():
    usage_msg = "Usage: python flow-maker.py <input_json> [flow_dir] [-uuid=\"UUID\"] [-force] [-saveInputs] [-model=\"MODEL\"]"
    input_filepath, flow_dir, custom_uuid, force_overwrite, save_inputs, model = handle_command_args(usage_msg)

    if not flow_dir:
        flow_dir = os.path.join("flow", datetime.now().strftime("%Y%m%d_%H%M%S"))
    if custom_uuid:
        flow_uuid = custom_uuid
    else:
        flow_uuid = str(uuid.uuid4())

    flowUUID = flow_uuid # Set the global variable
    flow_dir = os.path.join(flow_dir, flowUUID)

    if os.path.exists(flow_dir):
        if force_overwrite:
            shutil.rmtree(flow_dir)
        else:
            print(f"Error: Flow directory '{flow_dir}' already exists. Use -force to overwrite.")
            sys.exit(1)

    os.makedirs(flow_dir, exist_ok=True)
    os.makedirs(os.path.join(flow_dir, "inputs"), exist_ok=True)

    # Copy input file to flow directory
    input_copy_path = os.path.join(flow_dir, "input.json")
    shutil.copy2(input_filepath, input_copy_path)
    print(f"Copied input file to: {input_copy_path}")

    # Create breadcrumbs file
    topic = load_json(input_filepath).get("topic", "Unknown Topic")
    breadcrumbs = f"Home > {topic}"
    breadcrumbs_path = os.path.join(flow_dir, "breadcrumbs.txt")
    with open(breadcrumbs_path, "w", encoding="utf-8") as f:
        f.write(breadcrumbs)
    print(f"Breadcrumbs saved: {breadcrumbs}")

    # Define the programs to run in order
    programs = [
        ("generate-metadata.py", "1.json"),  # 1. metadata.py
        ("hallucinate-tree.py", "2.json"),   # 2. hallucinate-tree.py
        ("generate-automation-timeline.py", "3.json"),  # 3. generate-automation-timeline.py
        ("generate-automation-challenges.py", "4.json"), # 4. generate-automation-challenges.py
        ("automation-adoption.py", "5.json"),  # 5. automation-adoption.py
        ("current-implementations.py", "6.json"),  # 6. current-implementations.py
        ("return-analysis.py", "7.json"),  # 7. return-analysis.py
        ("future-technology.py", "8.json"),  # 8. future-technology.py
        ("specifications-industrial.py", "9.json"),  # 9. specifications-industrial.py
        ("assemble.py", None),  # 10. assemble.py - Output filename handled differently
    ]

    # Run each program in sequence
    for i, (program, output_filename) in enumerate(programs):
        print(f"\nStep {i+1}/{len(programs)}: Running {program}")

        # Default input is the copied input.json
        current_input_path = input_copy_path

        # Define output path for this program
        # For assemble.py, the output path is the flow directory itself
        if program == "assemble.py":
            output_path = flow_dir
            current_input_path = flow_dir # assemble.py takes the flow dir as input now
        else:
            output_path = os.path.join(flow_dir, output_filename)

        # Construct command
        command = [
            sys.executable,
            program,
            current_input_path,
            output_path,
            f"-uuid={flow_uuid}",
            f"-flow_uuid={flowUUID}"
        ]
        if save_inputs:
            command.append("-saveInputs")
        if model:
            command.append(f"-model={model}")

        # Execute command
        try:
            subprocess.run(command, check=True)
            print(f"Successfully executed {program}")
        except subprocess.CalledProcessError as e:
            print(f"Error executing {program}: {e}")
            sys.exit(1)

    print("\nFlow execution completed.")

if __name__ == "__main__":
    main()

# generate-metadata.py
import json
import sys
from datetime import datetime
from utils import load_json, saveToFile, parse_llm_json_response, chat_with_llm, handle_command_args, get_output_filepath

def generate_page_metadata(input_data, save_inputs=False, model="gpt-4"):
    """Generates metadata for a Universal Automation Wiki page using an LLM."""
    global flowUUID
    topic = input_data.get("topic", "Default Topic")

    parameters = {
        "temperature": 0.7,
        "top_p": 0.9
    }

    systemMsg = (
        "You are an expert content creator for a Universal Automation Wiki. "
        "Your task is to generate concise and informative metadata for a given topic. "
        "The metadata should include the following fields:\n"
        "- Title (1-2 sentences)\n"
        "- Summary (2-3 sentences)\n"
        "- Keywords (5-10 relevant keywords)\n"
        "- automation_progress: progress toward full automation (as a percentage). BE CRITICAL, do not exaggerate current status. E.g., '25%' would be appropriate for topics where some partial automation is POSSIBLE."
        "- Explanatory text (2-3 FULL paragraphs) that describes the topic and its automation journey."
        "Format your response as a JSON object with these fields."
    )

    user_msg = f"Create metadata for a Universal Automation Wiki page about: {topic}"

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/1-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate metadata
    response = chat_with_llm(model, systemMsg, user_msg, parameters)
    # Parse JSON using shared utility to extract JSON block reliably
    metadata = parse_llm_json_response(response)
    if not isinstance(metadata, dict):
        print("Error: Parsed metadata is not a JSON object. Full response: " + response)
        return None
    return metadata

def main():
    """Main function to run the metadata generation."""
    global flowUUID
    usage_msg = "Usage: python generate-metadata.py <input_json> [output_json] [-saveInputs] [-uuid=\"UUID\"] [-flow_uuid=\"FLOW-UUID\"]"
    input_filepath, specified_output_filepath, save_inputs, custom_uuid, flow_uuid_arg = handle_command_args(usage_msg)
    flowUUID = flow_uuid_arg # Set the global variable

    print("Working...")
    start_time = datetime.now()

    input_data = load_json(input_filepath)
    metadata = generate_page_metadata(input_data, save_inputs)

    if metadata is None:
        print("Failed to generate metadata.")
        sys.exit(1)

    # Get output filepath and UUID
    output_filepath, output_uuid = get_output_filepath(
        "metadata", 
        specified_output_filepath, 
        input_filepath, 
        flowUUID
    )

    # Save the updated metadata to the output file
    saveToFile(metadata, filepath=output_filepath)

    end_time = datetime.now()
    duration = end_time - start_time
    print(f"Finished. Took {duration}")

if __name__ == "__main__":
    main()

graph TD
    A[input.json] --> B(flow-maker.py)
    B --> C{generate-metadata.py}
    C --> D[1.json]
    B --> E{hallucinate-tree.py}
    E --> F[2.json]
    B --> G{generate-automation-timeline.py}
    G --> H[3.json]
    B --> I{generate-automation-challenges.py}
    I --> J[4.json]
    B --> K{automation-adoption.py}
    K --> L[5.json]
    B --> M{current-implementations.py}
    M --> N[6.json]
    B --> O{return-analysis.py}
    O --> P[7.json]
    B --> Q{future-technology.py}
    Q --> R[8.json]
    B --> S{specifications-industrial.py}
    S --> T[9.json]
    B --> U{assemble.py}
    U --> V[Output Wiki Pages]
    style B fill:#f9f,stroke:#333,stroke-width:2px

graph TD
    A[Input JSON] --> B(generate-metadata.py)
    B --> C[Metadata JSON]
    C --> D(hallucinate-tree.py)
    D --> E[Outline JSON]
    E --> F(generate-automation-timeline.py)
    F --> G[Timeline JSON]
    G --> H(generate-automation-challenges.py)
    H --> I[Challenges JSON]
    I --> J(automation-adoption.py)
    J --> K[Adoption Phases JSON]
    K --> L(current-implementations.py)
    L --> M[Implementations JSON]
    M --> N(return-analysis.py)
    N --> O[Return Analysis JSON]
    O --> P(future-technology.py)
    P --> Q[Future Tech JSON]
    Q --> R(specifications-industrial.py)
    R --> S[Specifications JSON]
    S --> T(assemble.py)
    T --> U[Output Wiki Pages]
    style B,D,F,H,J,L,N,P,R,T fill:#ccf,stroke:#333,stroke-width:2px

sequenceDiagram
    participant User
    participant flow-maker.py
    participant generate-metadata.py
    participant LLM
    participant assemble.py

    User->>flow-maker.py: Run flow-maker.py with input.json
    flow-maker.py->>generate-metadata.py: Execute generate-metadata.py
    generate-metadata.py->>LLM: Send prompt for metadata generation
    LLM->>generate-metadata.py: Return metadata in JSON format
    generate-metadata.py->>flow-maker.py: Save metadata to 1.json
    flow-maker.py->>assemble.py: Execute assemble.py
    assemble.py->>flow-maker.py: Read all JSON files
    assemble.py->>User: Generate and output final wiki pages


---

<a id='page-5'></a>

## Natural Language Processing and Simplification

### Related Files

- `simplified-technical-english.py`
- `basic-english.py`
- `examples/simplified-technical-english-in.json`
- `examples/basic-english-in.json`

# Natural Language Processing and Simplification

This page details the natural language processing and simplification tools available in the `routines` repository, focusing on `simplified-technical-english.py` and `basic-english.py`. These tools aim to convert complex text into more accessible formats.

## Purpose and Functionality

The primary goal is to simplify text, making it easier to understand for a broader audience.  This is achieved through two main approaches:

1.  **Simplified Technical English (STE):**  Transforms technical documentation into a controlled language with specific rules for vocabulary and grammar.  This enhances clarity and reduces ambiguity.
2.  **Basic English:** Converts text into a subset of English with a limited vocabulary, suitable for language learners or situations requiring utmost simplicity.

## File Breakdown

*   **`simplified-technical-english.py`:** Contains the `generate_page_metadata` and `adoption_phases` functions. These functions use a large language model (LLM) to generate metadata for a Universal Automation Wiki page and to generate automation adoption phases. It takes an input topic and returns a JSON object containing metadata such as title, percentage of automation, and explanatory text. It uses `chat_with_llm` to interact with the LLM and `parse_llm_json_response` to parse the LLM's JSON response.
*   **`basic-english.py`:** Currently, there is no functionality in this file based on the context provided.
*   **`examples/simplified-technical-english-in.json`:** Provides example input JSON for the `simplified-technical-english.py` script.
*   **`examples/basic-english-in.json`:**  Likely intended to hold example input for future `basic-english.py` functionality, but based on the context, no such file exists or has content.

## Code Examples and Explanations

### `simplified-technical-english.py`

```python
# simplified-technical-english.py
import json
import sys
from datetime import datetime
from routines.llm import chat_with_llm, parse_llm_json_response
from routines.utils import load_json, saveToFile, get_output_filepath, handle_command_args

def generate_page_metadata(input_data, save_inputs=False):
    """Generates metadata for a Universal Automation Wiki page about a given topic."""
    topic = input_data.get("topic")
    model = input_data.get("model", "gpt-3.5-turbo")
    parameters = input_data.get("parameters", {"temperature": 0.7, "max_tokens": 500})
    global flowUUID  # Access the global flowUUID variable

    systemMsg = (
        "You are a Universal Automation Wiki page generator. "
        "Your task is to create JSON metadata for a wiki page about a given topic.\n"
        "Include the following fields:\n"
        "- title (string): A concise title for the wiki page.\n"
        "- automation_potential (integer): Estimated current progress toward full automation (as a percentage). BE CRITICAL, do not exaggerate current status. E.g., '25%' would be appropriate for topics where some partial automation is POSSIBLE.\n"
        "- Explanatory text (2-3 FULL paragraphs) that describes the topic and its automation journey.\n"
        "Format your response as a JSON object with these fields."
    )

    user_msg = f"Create metadata for a Universal Automation Wiki page about: {topic}"

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/1-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate metadata
    response = chat_with_llm(model, systemMsg, user_msg, parameters)
    # Parse JSON using shared utility to extract JSON block reliably
    metadata = parse_llm_json_response(response)
    if not isinstance(metadata, dict):
        print("Error: Parsed metadata is not a JSON object. Full response: " + response)
        return None
    return metadata

def generate_automation_adoption_phases(input_data, save_inputs=False):
    """Generates phases of automation adoption for a given topic."""
    topic = input_data.get("topic")
    model = input_data.get("model", "gpt-3.5-turbo")
    parameters = input_data.get("parameters", {"temperature": 0.7, "max_tokens": 1000})
    global flowUUID  # Access the global flowUUID variable

    systemMsg = (
        "You are an expert in automation technologies and processes."
        "Your task is to outline the phases of automation adoption for a given topic.\n"
        "End-to-End Automation (Future development)\n\n"
        "For each phase:\n"
        "1. Provide 4-6 specific examples of automation technology or processes\n"
        "2. Make sure the automation complexity increases with each phase\n"
        "3. Be specific to the domain rather than generic\n\n"
        "Format your response as a JSON object with the following structure:\n"
        "{\n"
        "  \"phase1\": {\n"
        "    \"title\": \"Basic Mechanical Assistance\",\n"
        "    \"status\": \"Currently widespread\",\n"
        "    \"examples\": [\"example1\", \"example2\", ...]\n"
        "  },\n"
        "  \"phase2\": { ... },\n"
        "  \"phase3\": { ... },\n"
        "  \"phase4\": { ... }\n"
        "}\n\n"
        "Only include examples that are significantly relevant to the topic."
    )

    user_msg = f"Outline the phases of automation adoption for: {topic}"

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/5-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate automation adoption phases
    response = chat_with_llm(model, systemMsg, user_msg, parameters)

    try:
        # Try to parse JSON response
        adoption_phases = parse_llm_json_response(response)
        return adoption_phases
    except json.JSONDecodeError:
        print("Error: LLM response is not valid JSON. Full response: " + response)
        return None

graph TD
    subgraph Routines
        LLM[chat_with_llm]
        JSON[parse_llm_json_response]
        UTILS[routines.utils]
    end

    STE[simplified-technical-english.py] --> LLM
    STE --> JSON
    STE --> UTILS
    EXAMPLES[examples/simplified-technical-english-in.json] --> STE
    style STE fill:#f9f,stroke:#333,stroke-width:2px

sequenceDiagram
    participant User
    participant STE
    participant LLM
    participant JSON

    User->>STE: Input Data (topic)
    STE->>STE: Construct System & User Messages
    STE->>LLM: Send Prompt
    LLM->>STE: LLM Response (JSON String)
    STE->>JSON: Parse JSON Response
    JSON->>STE: Metadata (Dict)
    STE->>User: Return Metadata

python simplified-technical-english.py examples/simplified-technical-english-in.json output.json

# File: search-queries.py
import json
import sys
from datetime import datetime
from utils import (
    load_json, save_output, chat_with_llm, parse_llm_json_response,
    create_output_metadata, get_output_filepath, handle_command_args,
    saveToFile
)

flowUUID = None # Global variable for flow UUID

def generate_page_metadata(input_data, save_inputs=False):
    """Generate standardized metadata for a topic page."""
    # Extract information from input data
    topic = input_data.get("topic", "")
    model = input_data.get("model", "gemma3")
    parameters = input_data.get("parameters", {})

    # If input already contains metadata fields, use them directly
    if "metadata" in input_data:
        return input_data["metadata"]

    # Otherwise, generate metadata using LLM
    systemMsg = (
        "You are an AI assistant specialized in creating consistent metadata for technical topics. "
        "Generate appropriate metadata for the topic provided, including: "
        "- A descriptive title (using the topic name) MAXIMUM 2-3 WORDS DO NOT INCLDUE A SUBTITLE (e.g., ANYTHING AFTER A SEMICOLON) "
        "- A subtitle that explains the scope "
        "- Current automation status (No Automation, Very Early Automation, Early Automation, Some Automation, Partially Fully Automated, Mostly Fully Automated, or Fully Automated) "
        "- Percentage estimate of progress toward full automation (as a percentage). BE CRITICAL, do not exaggerate current status. E.g., '25%' would be appropriate for topics where some partial automation is POSSIBLE."
        "- Explanatory text (2-3 FULL paragraphs) that describes the topic and its automation journey."
        "Format your response as a JSON object with these fields."
    )

    user_msg = f"Create metadata for a Universal Automation Wiki page about: {topic}"

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/1-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate metadata
    response = chat_with_llm(model, systemMsg, user_msg, parameters)
    # Parse JSON using shared utility to extract JSON block reliably
    metadata = parse_llm_json_response(response)
    if not isinstance(metadata, dict):
        print("Error: Parsed metadata is not a JSON object. Full response: " + response)
        return None
    return metadata

def generate_automation_adoption(input_data, save_inputs=False):
    """Generate detailed information about automation adoption phases for a specific topic."""
    # Extract information from input data
    topic = input_data.get("topic", "")
    model = input_data.get("model", "gemma3")
    parameters = input_data.get("parameters", {})

    # Generate automation adoption phases using LLM
    systemMsg = (
        "You are an AI assistant specialized in analyzing automation adoption patterns. "
        "Your task is to identify and explain the different phases of automation adoption "
        "in a specific field or topic, from basic mechanical assistance to full end-to-end automation."
    )

    user_msg = (
        f"Create a detailed breakdown of automation adoption phases for: {topic}\n\n"
        "Please structure your response in 4 phases:\n"
        "Phase 1: Basic Mechanical Assistance (Currently widespread)\n"
        "Phase 2: Integrated Semi-Automation (Currently in transition)\n"
        "Phase 3: Advanced Automation Systems (Emerging technology)\n"
        "Phase 4: Full End-to-End Automation (Future development)\n\n"
        "For each phase:\n"
        "1. Provide 4-6 specific examples of automation technology or processes\n"
        "2. Make sure the automation complexity increases with each phase\n"
        "3. Be specific to the domain rather than generic\n\n"
        "Format your response as a JSON object with the following structure:\n"
        "{\n"
        "  \"phase1\": {\n"
        "    \"title\": \"Basic Mechanical Assistance\",\n"
        "    \"status\": \"Currently widespread\",\n"
        "    \"examples\": [\"example1\", \"example2\", ...]\n"
        "  },\n"
        "  \"phase2\": { ... },\n"
        "  \"phase3\": { ... },\n"
        "  \"phase4\": { ... }\n"
        "}\n\n"
        "Only include examples that are significantly relevant to the topic."
    )

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/5-in.json"
        saveToFile(systemMsg, user_msg, save_path)

    # Use chat_with_llm to generate automation adoption phases
    response = chat_with_llm(model, systemMsg, user_msg, parameters)

    try:
        # Try to parse JSON response
        adoption_phases = parse_llm_json_response(response)
        return adoption_phases
    except json.JSONDecodeError:
        print("Error: LLM response is not valid JSON. Full response: " + response)
        return None

def generate_industrial_specifications(input_data, save_inputs=False):
    """Generate detailed industrial specifications for a given topic."""
    # Extract information from input data
    topic = input_data.get("topic", "")
    model = input_data.get("model", "gemma3")
    parameters = input_data.get("parameters", {})

    # Define the system message for the LLM
    systemMsg = (
        "You are an AI assistant specialized in industrial engineering and specifications. "
        "For the given topic, provide a comprehensive overview of industrial/commercial specifications "
        "including performance metrics and implementation requirements. "
        "Be precise with numerical values and include ranges where appropriate. "
        "Focus on practical technical details that would be relevant to professionals in the field."
    )

    user_msg = (f"Create detailed industrial specifications for: {topic}\n\n"
                "Format your response as a JSON object with these categories:\n"
                "1. performance_metrics: An array of metrics with names, values/ranges, and descriptions\n"
                "2. implementation_requirements: An array of requirements with names, specifications, and descriptions\n"
                "3. industry_standards: An array of relevant standards and certifications\n"
                "4. key_suppliers: An array of major equipment/technology suppliers for this industry\n"
                "5. operational_considerations: An array of important operational factors\n"
                "\nPlease provide realistic values for industrial/commercial scale implementations.\n"
                "\nReturn ONLY valid JSON without any additional text, explanation, or code block formatting."
    )

    # Save inputs to file if requested
    if save_inputs:
        save_path = f"flow/{flowUUID}/inputs/9-in.json"
        saveToFile(systemMsg, user_msg, parameters)

    # Use chat_with_llm to generate industrial specifications
    response = chat_with_llm(model, systemMsg, user_msg, parameters)

    # Parse JSON response
    try:
        industrial_specs = parse_llm_json_response(response)
        return industrial_specs
    except json.JSONDecodeError:
        print("Error: LLM response is not valid JSON. Full response: " + response)
        return None

def main():
    """Main function to run the metadata generation."""
    global flowUUID
    usage_msg = "Usage: python generate-metadata.py <input_json> [output_json] [-saveInputs] [-uuid=\"UUID\"] [-flow_uuid=\"FLOW-UUID\"]"
    input_filepath, specified_output_filepath, save_inputs, custom_uuid, flow_uuid_arg = handle_command_args(usage_msg)
    flowUUID = flow_uuid_arg # Set the global variable

    print("Working...")
    start_time = datetime.now()

    input_data = load_json(input_filepath)
    metadata = generate_page_metadata(input_data, save_inputs)

    if metadata is None:
        print("Failed to generate metadata.")
        sys.exit(1)

    # Get output filepath and UUID
    output_filepath, output_uuid = get_output_filepath(
        "metadata", 
        specified_output_filepath, 
        custom_uuid
    )

    # Create output metadata
    output_metadata = create_output_metadata(
        input_filepath, 
        output_filepath, 
        start_time, 
        input_data, 
        metadata
    )

    # Save the output
    save_output(output_metadata, output_filepath)
    print(f"Metadata generated and saved to {output_filepath}")

if __name__ == "__main__":
    main()

graph TD
    A[Input JSON: Topic, Model, Parameters] --> B(generate_page_metadata)
    B --> C{LLM Interaction: System & User Messages}
    C --> D[LLM Response: JSON Metadata]
    D --> E(parse_llm_json_response)
    E --> F{Metadata Dictionary}
    F --> G(create_output_metadata)
    G --> H[Output JSON: Metadata, Provenance]
    H --> I(save_output)
    I --> J[Output File]

{
    "topic": "Cloud Computing",
    "model": "gemma3",
    "parameters": {
        "temperature": 0.7
    }
}

{
    "input_file": "examples/search-queries-in.json",
    "output_file": "examples/search-queries-out.json",
    "start_time": "2024-01-01T12:00:00",
    "input_data": {
        "topic": "Cloud Computing",
        "model": "gemma3",
        "parameters": {
            "temperature": 0.7
        }
    },
    "metadata": {
        "title": "Cloud Computing",
        "subtitle": "Overview and Scope",
        "automation_status": "Some Automation",
        "progress_percentage": 40,
        "explanatory_text": [
            "Cloud computing has seen some automation in areas like resource provisioning and scaling. However, many aspects still require manual intervention, such as security configuration and complex deployment scenarios.",
            "Further automation is being explored through technologies like Infrastructure as Code (IaC) and automated compliance checks, aiming for more efficient and reliable cloud environments."
        ]
    }
}

graph TD
    A[Basic Mechanical Assistance] --> B[Integrated Semi-Automation]
    B --> C[Advanced Automation Systems]
    C --> D[Full End-to-End Automation]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#ccf,stroke:#333,stroke-width:2px
    style C fill:#ccf,stroke:#333,stroke-width:2px
    style D fill:#f9f,stroke:#333,stroke-width:2px