conceptualizing-machine 0.0.1__tar.gz

conceptualizing_machine-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Fedotov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

conceptualizing_machine-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+include src/conceptualizing_machine/*.yaml

conceptualizing_machine-0.0.1/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: conceptualizing-machine
+Version: 0.0.1
+Summary: A Machine that conceptualizes meanings.
+Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>
+Project-URL: Homepage, https://github.com/conceptualizing-machine/conceptualizing-machine
+Keywords: conceptualizing-machine
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: electroid>=0.0.19
+Requires-Dist: opehaina>=0.0.5
+Requires-Dist: castor-pollux>=0.1.4
+Requires-Dist: PyGithub>=2.6.0
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: urllib3>=2.0.4
+Requires-Dist: requests>=2.32.3
+Requires-Dist: click>=8.3.0
+Dynamic: license-file
+
+# Conceptualizing Machine
+A Machine that conceptualizes meanings.
+```bash
+  echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
+    | uvx conceptualizing-machine \
+        --provider-api-key=sk-ant-api... \
+        --github-token=ghp_... 
+```
+Or:
+```bash
+  pip install conceptualizing-machine
+```
+Then:
+```Python
+  # Python
+  import conceptualizing_machine
+```

conceptualizing_machine-0.0.1/README.md

@@ -0,0 +1,17 @@
+# Conceptualizing Machine
+A Machine that conceptualizes meanings.
+```bash
+  echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
+    | uvx conceptualizing-machine \
+        --provider-api-key=sk-ant-api... \
+        --github-token=ghp_... 
+```
+Or:
+```bash
+  pip install conceptualizing-machine
+```
+Then:
+```Python
+  # Python
+  import conceptualizing_machine
+```

conceptualizing_machine-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=67.0"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "conceptualizing-machine"
+version = "0.0.1"
+authors = [
+    {name="Machina Ratiocinatrix", email="machina.ratio@gmail.com"},
+]
+description = "A Machine that conceptualizes meanings."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+]
+
+keywords = ["conceptualizing-machine"]
+
+dependencies = [
+    "electroid >= 0.0.19",
+    "opehaina >= 0.0.5",
+    "castor-pollux >= 0.1.4",
+    "PyGithub >= 2.6.0",
+    "PyYAML >= 6.0.1",
+    "urllib3 >= 2.0.4",
+    "requests >= 2.32.3",
+    "click >= 8.3.0"
+]
+
+[project.scripts]
+conceptualizing-machine = "conceptualizing_machine.cli:run"
+
+[project.urls]
+"Homepage" = "https://github.com/conceptualizing-machine/conceptualizing-machine"

conceptualizing_machine-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

conceptualizing_machine-0.0.1/src/conceptualizing_machine/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from .config import settings
+from .machine import machine
+from .githf import connect_to_repo, read_file, fetch_instructions
+from .utilities import (plato_text_to_muj,
+                        plato_text_to_mpuj,
+                        llm_soup_to_text,
+                        new_plato_text)
+
+__all__ = [
+    'machine',
+    'connect_to_repo',
+    'read_file',
+    'fetch_instructions',
+    'settings'
+]

conceptualizing_machine-0.0.1/src/conceptualizing_machine/cli.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from os import environ
+import sys
+from .config import settings
+from .utilities import llm_soup_to_text, new_plato_text
+import click
+import fileinput
+
+
+@click.command()
+@click.option('--provider-api-key', envvar='PROVIDER_API_KEY',
+              default='no_provider_key', help='Language Model API provider key.')
+@click.option('--github-token', envvar='GITHUB_TOKEN',
+              default='', help='GitHub API token for private repo access.')
+def run(provider_api_key, github_token, mode):
+    """
+        $ text | ./run.py                   # Accepts text from the pipe
+        $ ./run.py /home/user/file.txt      # Reads file.
+        $ ./run.py < /home/user/file.txt    # Reads file.
+
+        secrets come through the environment variables.
+    """
+    if provider_api_key:
+        if provider_api_key.startswith('sk-proj-'):
+            settings['provider'] = 'OpenAI'
+            environ['OPENAI_API_KEY'] = provider_api_key
+        elif provider_api_key.startswith('sk-ant-'):
+            settings['provider'] = 'Anthropic'
+            environ['ANTHROPIC_API_KEY'] = provider_api_key
+        elif provider_api_key.startswith('AIzaSy'):
+            settings['provider'] = 'Gemini'
+            environ['GEMINI_API_KEY'] = provider_api_key
+        elif provider_api_key.startswith('gsk_'):
+            settings['provider'] = 'Groq'
+            environ['GROQ_API_KEY'] = provider_api_key
+        elif provider_api_key.startswith('xai-'):
+            settings['provider'] = 'XAI'
+            environ['XAI_API_KEY'] = provider_api_key
+        elif provider_api_key.startswith('LLM|'):
+            settings['provider'] = 'Meta'
+            environ['META_API_KEY'] = provider_api_key
+        else:
+            if settings['provider'] == '':
+                raise ValueError(f"Unrecognized API key prefix and no provider specified.")
+    if github_token:
+        environ['GITHUB_TOKEN'] = github_token
+
+    raw_input = ''
+    for line in fileinput.input(encoding="utf-8"):
+        raw_input += line
+
+    from .machine import machine
+
+    try:
+        thoughts, text = machine(raw_input)
+        output = raw_input + '\n\n' + new_plato_text(thoughts, text, settings['name'])
+        sys.stdout.write(output)
+        sys.stdout.flush()
+    except Exception as e:
+        sys.stderr.write(f'Machine did not work {e}')
+        sys.stderr.flush()
+        sys.exit(0)
+
+
+if __name__ == '__main__':
+    run()

conceptualizing_machine-0.0.1/src/conceptualizing_machine/config.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from os import environ
+
+
+settings = dict(
+    github_token                = environ.get('GITHUB_TOKEN', ''),
+    github_name                 = environ.get('GITHUB_NAME', ''),
+    github_email                = environ.get('GITHUB_EMAIL', ''),
+    provider_api_key            = environ.get('PROVIDER_API_KEY', ''),
+    provider                    = environ.get('PROVIDER', ''),
+    machine_organization_name   = environ.get('MACHINE_ORGANIZATION_NAME', 'conceptualizing-machine'),
+    private_repo_with_text      = environ.get('PRIVATE_REPO_WITH_TEXT','conceptualizing_machine'),
+    system_prompt_file          = environ.get('SYSTEM_PROMPT_FILE', 'machina.yaml'),
+    name                        = '',
+    instructions                = ''
+)

conceptualizing_machine-0.0.1/src/conceptualizing_machine/githf.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+
+import sys
+from os import environ, path
+from github import Github, UnknownObjectException
+from urllib3 import disable_warnings
+import yaml
+from .config import settings
+
+
+github_token    = environ.get('GITHUB_TOKEN', '')
+github_name     = environ.get('GITHUB_NAME', '')
+github_email    = environ.get('GITHUB_EMAIL', '')
+
+# The useless urllib3 warning is too maddening for an ordinary human being.
+disable_warnings()
+
+
+# Repo
+def connect_to_repo(organization=None,
+                   repository_name=None,
+                   private=False):
+    """
+    Establish a connection with a GitHub repository.
+
+    Args:
+        organization (str, optional): The name of the organization. If not provided,
+            the repository is assumed to be owned by the authenticated user.
+        repository_name (str): The name of the repository.
+        private (bool, optional): Whether the repository is private. Defaults to False.
+
+    Returns:
+        github.Repository.Repository: The GitHub repository object if the connection is successful.
+        None: If the connection fails.
+
+    Raises:
+        github.UnknownObjectException: If the repository does not exist.
+
+    Note:
+        The function requires the following environment variables to be set:
+        - GITHUB_TOKEN: The personal access token for authentication.
+        - GITHUB_NAME: The name of the authenticated user.
+        - GITHUB_EMAIL: The email of the authenticated user.
+
+    """
+
+    gh = Github(github_token, verify=False)
+    if organization:
+        org = gh.get_organization(organization)
+        try:
+            repo = org.get_repo(f'{repository_name}')
+        except UnknownObjectException:
+            # print('Can not connect YOU to this repo in this organization')
+            repo = None
+        return repo
+    else:
+        user = gh.get_user()
+        try:
+            repo = user.get_repo(repository_name)
+        except UnknownObjectException:
+            # print('Can not connect YOU to this repo')
+            repo = None
+        return repo
+
+
+def read_file(repository,
+              file_path):
+    """
+    Read the contents of a file in a GitHub repository.
+
+    Args:
+        repository (github.Repository.Repository): The GitHub repository object.
+        file_path (str): The path to the file in the repository, formatted as
+            'directory_in_repo/subdirectory/file.ext'.
+
+    Returns:
+        str: The contents of the file as a string. If the file does not exist, an empty string is returned.
+
+    Raises:
+        github.UnknownObjectException: If the file does not exist in the repository.
+
+    Note:
+        This function assumes that the repository object has already been authenticated and connected.
+    """
+    try:
+        # Get the file if it exists
+        ingested_file = repository.get_contents(file_path)
+        content = ingested_file.decoded_content.decode("utf-8")
+
+    except UnknownObjectException:
+        # The file doesn't exist
+        # print('The file does not exist')
+        content = ''
+
+    return content
+
+
+def fetch_instructions():
+    """Retrieve the system prompt from a private GitHub repo.
+    Falls back to the local machina.yaml if GitHub is unreachable.
+    Returns the 'name' of the Machine in dashed format.
+    Returns the 'description' field from the YAML as the system prompt string.
+    """
+    try:
+        repo = connect_to_repo(
+            organization=settings['machine_organization_name'],
+            repository_name=settings['private_repo_with_text'],
+            private=True
+        )
+        raw_yaml = read_file(
+            repository=repo,
+            file_path=settings['system_prompt_file']
+        )
+    except Exception as e:
+        print(f"Warning: could not fetch prompt from GitHub: {e}",
+              file=sys.stderr)
+        local_path = path.join(path.dirname(__file__), 'machina.yaml')
+        with open(local_path, 'r') as f:
+            raw_yaml = f.read()
+
+    # Parse whatever you've gotten.
+    parsed = yaml.safe_load(raw_yaml)
+    name = parsed.get('name')
+    settings['name'] = name
+    instructions = parsed.get('description', 'You are a helpful assistant.')
+    settings['instructions'] = instructions
+    return name, instructions

conceptualizing_machine-0.0.1/src/conceptualizing_machine/machina.yaml

@@ -0,0 +1,7 @@
+# Copyright (c) Alexander Fedotov, 2026. All rights reserved.
+name: Conceptualizing-Machine
+description: The Assistant is Conceptualizing-Machine. Conceptualizing-Machine is does its best to understand
+  the conversation that it is participating in and answers in a most thoughtful way possible
+  the questions that it is being asked. 
+  Conceptualizing-Machine responds in plain text without any markdown, emphasis or lists. All 
+  paragraphs except the first should begin with a newline and tab.

conceptualizing_machine-0.0.1/src/conceptualizing_machine/machine.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+from os import environ, path
+from .config import settings
+from .githf import fetch_instructions
+from .utilities import (plato_text_to_muj,
+                        plato_text_to_mpuj,
+                        llm_soup_to_text)
+
+
+def machine(plato_text, **kwargs):
+    """Core agent logic.
+
+    1. Fetches the system prompt from a private GitHub repo.
+    2. Calls Provider
+    3. Returns a (thoughts, text) tuple.
+    """
+    # Fetch the confidential system prompt, name is for a checkup.
+    name, system_prompt = fetch_instructions()
+
+    # Load an appropriate library and query the API.
+    provider = settings['provider']
+    api_key  = settings['provider_api_key']
+    if provider == 'OpenAI':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call OpenAI API via opehaina
+        environ['OPENAI_API_KEY'] = api_key
+        import opehaina
+        thoughts, text = opehaina.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'Gemini':
+        # Transform plato_text to MPUJ format
+        messages = plato_text_to_mpuj(plato_text=plato_text,
+                                     machine_name=name)
+        # Call Gemini through castor-polux
+        environ['GEMINI_API_KEY'] = api_key
+        import castor_pollux
+        thoughts, text = castor_pollux.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+
+        thoughts = llm_soup_to_text(thoughts)
+        return thoughts, text
+
+    elif provider == 'Anthropic':
+        # Transform plato_text to MUJ format
+        messages = plato_text_to_muj(plato_text=plato_text,
+                                     machine_name=name)
+
+        # Call the Anthropic API via electroid
+        environ['ANTHROPIC_API_KEY'] = api_key
+        import electroid
+        text, thoughts = electroid.respond(
+            messages=messages,
+            instructions=system_prompt,
+            **kwargs
+        )
+        return text, thoughts
+
+    elif provider == 'Groq':
+        ...
+    elif provider == 'Xai':
+        ...
+    elif provider == 'Meta':
+        ...
+
+
+if __name__ == '__main__':
+    machine([])

conceptualizing_machine-0.0.1/src/conceptualizing_machine/utilities.py

@@ -0,0 +1,290 @@
+# -*- coding: utf-8 -*-
+# Python
+
+"""Copyright (c) Alexander Fedotov.
+This source code is licensed under the license found in the
+LICENSE file in the root directory of this source tree.
+"""
+import re
+
+
+def plato_text_to_muj(plato_text, machine_name):
+    """
+    Transforms platoText format to MUJ (Multi-User JSON) array for OpenAI
+    responses API.
+    Consecutive non-assistant messages are grouped into a single 'user' message.
+    Assistant messages have only the utterance.
+    """
+    if plato_text is None or not isinstance(plato_text, str):
+        raise ValueError("Invalid input: plato_text must be a string.")
+
+    trimmed_plato_text = plato_text.strip()
+    if not trimmed_plato_text:
+        return []
+
+    assistant_name_upper = machine_name.upper()
+
+    muj_messages = []
+    current_role = None
+    current_parts = []
+    current_is_thoughts = None
+
+    message_blocks = re.split(r'\n\n(?=[A-Za-z0-9_-]+:\s*)', trimmed_plato_text)
+
+    for block in message_blocks:
+        current_block = block.strip()
+        if not current_block:
+            continue
+
+        speaker_match = re.match(r'^([A-Za-z0-9_-]+):\s*', current_block)
+        if not speaker_match:
+            continue
+
+        speaker = speaker_match.group(1)
+        raw_utterance = current_block[len(speaker_match.group(0)):]
+
+        is_thoughts = False
+        if raw_utterance.strip().startswith('(thinking)'):
+            is_thoughts = True
+            raw_utterance = re.sub(r'^\s*\(thinking\)\s*', '', raw_utterance)
+
+        utterance = re.sub(r'\n{2,}', '\n\t', raw_utterance).strip()
+
+        final_utterance = utterance
+        if is_thoughts:
+            final_utterance = f"(thinking) {utterance}"
+
+        is_assistant_message = speaker.upper() == assistant_name_upper
+        role = 'assistant' if is_assistant_message else 'user'
+
+        if role != current_role or (role == 'assistant' and is_thoughts != current_is_thoughts):
+            if len(current_parts) > 0:
+                muj_messages.append({
+                    'role': current_role,
+                    'content': '\n\n'.join(current_parts)
+                })
+            current_role = role
+            current_is_thoughts = is_thoughts
+            current_parts = []
+
+        if is_assistant_message:
+            current_parts.append(final_utterance)
+        else:
+            current_parts.append(f"{speaker}: {final_utterance}")
+
+    if len(current_parts) > 0:
+        muj_messages.append({
+            'role': current_role,
+            'content': '\n\n'.join(current_parts)
+        })
+
+    return muj_messages
+
+
+def another_plato_text_to_muj(plato_text, machine_name):
+    """
+    Transforms platoText format to MUJ (Multi-User JSON) array for OpenAI API.
+    Consecutive non-assistant messages are grouped into a single 'user' message.
+    Assistant messages have a name in each of them and are joined into a single
+    utterance.
+
+    This is for the Theatron type of imitation of performance.
+    """
+    # trimmed_plato_text = plato_text.strip()
+    # if not trimmed_plato_text:
+    #     return []
+
+    assistant_name_upper = machine_name.upper()
+
+    muj_messages = []
+    current_role = None
+    current_parts = []
+
+    message_blocks = re.split(r'\n\n(?=[A-Za-z0-9_-]+:\s*)', plato_text)
+
+    for block in message_blocks:
+        current_block = block.strip()
+        if not current_block:
+            continue
+
+        speaker_match = re.match(r'^([A-Za-z0-9_-]+):\s*', current_block)
+        if not speaker_match:
+            continue
+
+        speaker = speaker_match.group(1)
+        raw_utterance = current_block[len(speaker_match.group(0)):]
+
+        is_thoughts = False
+        if raw_utterance.strip().startswith('(thinking)'):
+            is_thoughts = True
+            raw_utterance = re.sub(r'^\s*\(thinking\)\s*', '', raw_utterance)
+
+        # questionable replacement of double newline with new paragraph delimiter
+        utterance = re.sub(r'\n{2,}', '\n\t', raw_utterance).strip()
+
+        final_utterance = utterance
+        if is_thoughts:
+            final_utterance = f"(thinking) {utterance}"
+
+        is_assistant_message = speaker.upper() == assistant_name_upper
+        role = 'assistant' if is_assistant_message else 'user'
+
+        if role != current_role:
+            if len(current_parts) > 0:
+                muj_messages.append({
+                    'role': current_role,
+                    'content': '\n\n'.join(current_parts)
+                })
+            current_role = role
+            current_parts = []
+
+        current_parts.append(f"{speaker}: {final_utterance}")
+
+    if len(current_parts) > 0:
+        muj_messages.append({
+            'role': current_role,
+            'content': '\n\n'.join(current_parts)
+        })
+
+    return muj_messages
+
+
+def plato_text_to_mpuj(plato_text, machine_name):
+    """
+    Transforms platoText format to MPUJ (Multi-Part User JSON) array for Gemini API.
+    Consecutive non-model messages are grouped into a single 'user' message
+    with multiple parts. Each part includes the speaker's name and utterance.
+    Model messages have a single part with the utterance.
+    """
+    if plato_text is None or not isinstance(plato_text, str):
+        raise ValueError("Invalid input: plato_text must be a string.")
+
+    trimmed_plato_text = plato_text.strip()
+    if not trimmed_plato_text:
+        return []
+
+    model_name_upper = machine_name.upper()
+
+    mpuj_messages = []
+    current_role = None
+    current_parts = []
+
+    message_blocks = re.split(r'\n\n(?=[A-Za-z0-9_-]+:\s*)', trimmed_plato_text)
+
+    for block in message_blocks:
+        current_block = block.strip()
+        if not current_block:
+            continue
+
+        speaker_match = re.match(r'^([A-Za-z0-9_-]+):\s*', current_block)
+        if not speaker_match:
+            continue
+
+        speaker = speaker_match.group(1)
+        raw_utterance = current_block[len(speaker_match.group(0)):]
+
+        is_thoughts = False
+        if raw_utterance.strip().startswith('(thinking)'):
+            is_thoughts = True
+            raw_utterance = re.sub(r'^\s*\(thinking\)\s*', '', raw_utterance)
+
+        utterance = re.sub(r'\n{2,}', '\n\t', raw_utterance).strip()
+
+        final_utterance = utterance
+        if is_thoughts:
+            final_utterance = f"(thinking) {utterance}"
+
+        is_model_message = speaker.upper() == model_name_upper
+        role = 'model' if is_model_message else 'user'
+
+        if role != current_role:
+            if len(current_parts) > 0:
+                mpuj_messages.append({
+                    'role': current_role,
+                    'parts': current_parts
+                })
+            current_role = role
+            current_parts = []
+
+        current_parts.append({'text': f"{speaker}: {final_utterance}"})
+
+    if len(current_parts) > 0:
+        mpuj_messages.append({
+            'role': current_role,
+            'parts': current_parts
+        })
+
+    return mpuj_messages
+
+
+def new_plato_text(thoughts, text, machine_name):
+    """
+    Transforms a pair of text variables 'thoughts' and 'text' received
+    from the LLM and cleaned up from the markdown crap into a plato_text
+    format as new utterances of this machine, with its name as a speaker.
+    Does not form a 'thoughts' utterance if there were not 'thoughts'.
+
+    The result is later added to the input plato_text that came to the
+    machine through a pipe.
+    """
+    result = ""
+    if thoughts and thoughts.strip():
+        cleaned_thoughts = re.sub(r'\n{2,}', '\n\t', thoughts.strip())
+        result += f"{machine_name}: (thinking) {cleaned_thoughts}\n\n"
+
+    if text and text.strip():
+        cleaned_text = re.sub(r'\n{2,}', '\n\t', text.strip())
+        result += f"{machine_name}: {cleaned_text}\n\n"
+
+    return result
+
+
+def llm_soup_to_text(llm_response):
+    """
+    Cleans and transforms text from Large Language Models (LLMs) by:
+    - Removing all Markdown formatting (bold, italics, headers, lists, code blocks, links, etc.).
+    - Consolidating multiple newlines into a consistent paragraph separator (`\n\t`).
+    - Removing extraneous tabs and multiple spaces.
+    - Trimming leading/trailing whitespace.
+    """
+    if not isinstance(llm_response, str):
+        return ""
+
+    text = llm_response
+
+    # --- Step 1: Normalize Newlines & Initial Cleanup ---
+    text = text.replace('\r\n', '\n')
+    text = re.sub(r'\n{2,}', '\n\n', text)
+
+    # --- Step 2: Remove Block-Level Markdown Elements ---
+    text = re.sub(r'`{3,}[^\n]*\n([\s\S]*?)\n`{3,}', '', text)
+    text = re.sub(r'~{3,}[^\n]*\n([\s\S]*?)\n~{3,}', '', text)
+    text = re.sub(r'<!--[\s\S]*?-->', '', text)
+    text = re.sub(r'<[^>]+>', '', text)
+    text = re.sub(r'^\s*(?:-|\*|_){3,}\s*$', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^\s*>\s*', '', text, flags=re.MULTILINE)
+
+    # --- Step 3: Remove Inline Markdown Elements ---
+    text = re.sub(r'^\s*#{1,6}\s*', '', text, flags=re.MULTILINE)
+    text = re.sub(r'^([^\n]+)\n\s*(?:=|-){2,}\s*$', r'\1', text, flags=re.MULTILINE)
+    text = re.sub(r'!?\[.*?\]\(.*?\)', '', text)
+    text = re.sub(r'`([^`]+)`', r'\1', text)
+    text = re.sub(r'\*\*([^*]+?)\*\*', r'\1', text)
+    text = re.sub(r'__([^_]+?)__', r'\1', text)
+    text = re.sub(r'\*([^*]+?)\*', r'\1', text)
+    text = re.sub(r'_([^_]+?)_', r'\1', text)
+    text = re.sub(r'^\s*(?:[-*+]|\d+\.)\s+', '', text, flags=re.MULTILINE)
+
+    # --- Step 4: Final Whitespace & Paragraph Normalization ---
+    text = '\n'.join(line.strip() for line in text.split('\n'))
+    text = text.replace('\t', ' ')
+    text = re.sub(r' {2,}', ' ', text)
+    text = text.replace('\n\n', '\n\t')
+
+    # --- Step 5: Final Trimming ---
+    text = text.strip()
+    text = re.sub(r'^[\n\t]+', '', text)
+    text = re.sub(r'\n\t{2,}', '\n\t', text)
+
+    return text
+

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: conceptualizing-machine
+Version: 0.0.1
+Summary: A Machine that conceptualizes meanings.
+Author-email: Machina Ratiocinatrix <machina.ratio@gmail.com>
+Project-URL: Homepage, https://github.com/conceptualizing-machine/conceptualizing-machine
+Keywords: conceptualizing-machine
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: electroid>=0.0.19
+Requires-Dist: opehaina>=0.0.5
+Requires-Dist: castor-pollux>=0.1.4
+Requires-Dist: PyGithub>=2.6.0
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: urllib3>=2.0.4
+Requires-Dist: requests>=2.32.3
+Requires-Dist: click>=8.3.0
+Dynamic: license-file
+
+# Conceptualizing Machine
+A Machine that conceptualizes meanings.
+```bash
+  echo "Theodotos-Alexandreus: Are language models seeking the Truth, machine?" \
+    | uvx conceptualizing-machine \
+        --provider-api-key=sk-ant-api... \
+        --github-token=ghp_... 
+```
+Or:
+```bash
+  pip install conceptualizing-machine
+```
+Then:
+```Python
+  # Python
+  import conceptualizing_machine
+```

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/conceptualizing_machine/__init__.py
+src/conceptualizing_machine/cli.py
+src/conceptualizing_machine/config.py
+src/conceptualizing_machine/githf.py
+src/conceptualizing_machine/machina.yaml
+src/conceptualizing_machine/machine.py
+src/conceptualizing_machine/utilities.py
+src/conceptualizing_machine.egg-info/PKG-INFO
+src/conceptualizing_machine.egg-info/SOURCES.txt
+src/conceptualizing_machine.egg-info/dependency_links.txt
+src/conceptualizing_machine.egg-info/entry_points.txt
+src/conceptualizing_machine.egg-info/requires.txt
+src/conceptualizing_machine.egg-info/top_level.txt

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+conceptualizing-machine = conceptualizing_machine.cli:run

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/requires.txt

@@ -0,0 +1,8 @@
+electroid>=0.0.19
+opehaina>=0.0.5
+castor-pollux>=0.1.4
+PyGithub>=2.6.0
+PyYAML>=6.0.1
+urllib3>=2.0.4
+requests>=2.32.3
+click>=8.3.0

conceptualizing_machine-0.0.1/src/conceptualizing_machine.egg-info/top_level.txt

@@ -0,0 +1 @@
+conceptualizing_machine