owlmind 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

owlmind/__init__.py

@@ -1,3 +1,5 @@
-from .ollama import Ollama
+"""
+OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+"""
 
-__version__ = "0.1.0"
+__version__ = "0.1.5"

owlmind/cli.py

@@ -1,137 +1,236 @@
+
+#!/usr/bin/env python3
+##
+## OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+## cli.py — Command-line interface.
+##
+# Copyright (c) 2025, The Generative Intelligence Lab
+#    https://github.com/genilab/owlmind
+#
+# Disclosure:
+# This framework was developed using a 'vibe coding' . AI-synthesized logic was 
+# subjected to human review and manual refinement to guarantee functional 
+# integrity and structural clarity.
+#
+
 import argparse
 import os
 import sys
-from .ollama import Ollama
+import logging
+from owlmind import __version__
+from owlmind.models import Ollama
 
 class Dispatcher:
-    """Orchestrates the execution of commands and resolves prompt sources."""
+    """Orchestrates components using the OwlMind Launch standards."""
+
+    DEFAULT_LOG_LEVEL = Ollama.LOG_CRITICAL
+
+    @staticmethod
+    def load_env(filepath=".env"):
+        """Manually parses a .env file and injects into os.environ."""
+        if not os.path.exists(filepath):
+            return
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line or line.startswith("#") or "=" not in line:
+                        continue
+                    key, value = line.split("=", 1)
+                    key, value = key.strip(), value.strip().strip("'").strip('"')
+                    if key not in os.environ:
+                        os.environ[key] = value
+        except Exception as e:
+            print(f"Warning: Could not load .env file: {e}", file=sys.stderr)
+
+    @staticmethod
+    def parse_params(raw_params: list) -> dict:
+        """
+        Parses parameters into a typed dictionary.
+        Handles: -p k=v,k2=v2 AND -p k=v -p k2=v2
+        """
+        params = {}
+        if not raw_params:
+            return params
+            
+        # 1. Flatten the list and split by commas
+        # If raw_params is ['temp=1', 'seed=42,top_k=10'], this flattens it correctly
+        tokens = []
+        for item in raw_params:
+            tokens.extend(item.split(','))
+            
+        for kv in tokens:
+            if "=" not in kv:
+                continue
+            
+            k, v = kv.split("=", 1)
+            k, v = k.strip(), v.strip()
+            
+            # 2. Type Inference (Boolean, Int, Float, String)
+            if v.lower() == "true":
+                v = True
+            elif v.lower() == "false":
+                v = False
+            else:
+                try:
+                    # Try Integer
+                    v = int(v)
+                except ValueError:
+                    try:
+                        # Try Float
+                        v = float(v)
+                    except ValueError:
+                        # Keep as string (e.g., stop sequences or system prompts)
+                        pass 
+            params[k] = v
+            
+        return params
+
 
     @staticmethod
     def dispatch(args):
-        """Primary router that handles prompt resolution before execution."""
-        api = Ollama(host=args.host)
+        # 1. Start with context
+        context = vars(args).copy()
+
+        # 2. Logic for Logging / Debug using Component constants
+        # We check the debug flag and map it to our integer constants
+        target_level = Ollama.LOG_DEBUG if context.get('debug') else Dispatcher.DEFAULT_LOG_LEVEL
+        
+        # Set global logging level
+        logging.getLogger().setLevel(target_level)
+        logging.getLogger("httpx").setLevel(target_level)
+        
+        # Pass the integer level into the context so it hits the property setter
+        context['log_level'] = target_level
+
+        # 3. Dynamic Parameter Parsing
+        dynamic_params = Dispatcher.parse_params(context.pop('params', []))
+        context.update(dynamic_params)
+
+        # 4. Resolve Input Logic
+        if args.command == "query":
+            user_input = Dispatcher.resolve_prompt(args)
+            if not user_input:
+                print("Error: No prompt provided.", file=sys.stderr)
+                sys.exit(1)
+            context['input'] = user_input
+
+        # 5. Initialize Component
+        # At this point, context contains everything (debug, command, url, model, etc.)
+        api = Ollama(**context)
+
+        # 6. TELL OLLAMA TO OBFUSCATE THE PLUMBING
+        # This moves the argparse noise to private _attributes
+        api.obfuscate(['debug', 'command', 'input_file', 'prompt'])
 
+        # 7. Route Command
         if args.command == "ping":
             Dispatcher.handle_ping(api)
         elif args.command == "info":
-            Dispatcher.handle_info(api, args)
+            Dispatcher.handle_info(api)
         elif args.command == "query":
-            # Resolve the prompt source (Raw text vs @file vs --input)
-            final_prompt = Dispatcher.resolve_prompt(args)
-            if not final_prompt:
-                print("Error: No prompt provided. Use raw text, @file, or --input.", file=sys.stderr)
-                sys.exit(1)
-            
-            # Update args with the loaded content for the handler
-            args.prompt = final_prompt
-            Dispatcher.handle_query(api, args)
+            Dispatcher.handle_query(api)
+        
+        return
+
+
 
     @staticmethod
     def resolve_prompt(args):
-        """Determines the final prompt string based on priority."""
-        # Priority 1: Explicit --input flag
         if getattr(args, 'input_file', None):
             return Dispatcher.load_file(args.input_file)
-            
-        # Priority 2: Shorthand @file syntax in the positional prompt
-        if args.prompt and args.prompt.startswith("@"):
-            return Dispatcher.load_file(args.prompt[1:]) # Strip '@'
-            
-        # Priority 3: Standard raw text
-        return args.prompt
+        prompt_val = getattr(args, 'prompt', None)
+        if prompt_val and prompt_val.startswith("@"):
+            return Dispatcher.load_file(prompt_val[1:])
+        return prompt_val
 
     @staticmethod
     def load_file(filepath):
-        """Reads and returns file content safely."""
         try:
             with open(filepath, 'r', encoding='utf-8') as f:
                 return f.read().strip()
-        except FileNotFoundError:
-            print(f"Error: Prompt file not found: {filepath}", file=sys.stderr)
-            sys.exit(1)
         except Exception as e:
-            print(f"Error reading file {filepath}: {e}", file=sys.stderr)
+            print(f"Error loading {filepath}: {e}", file=sys.stderr)
             sys.exit(1)
 
     @staticmethod
     def handle_ping(api):
         status = "ONLINE" if api.ping() else "OFFLINE"
-        print(f"Status: {status} ({api.host})")
+        print(f"Status: {status} (Host: {api.url})")
 
     @staticmethod
-    def handle_info(api, args):
-        print("--- OwlMind Configuration ---")
-        host_src = "ENV" if os.environ.get("OLLAMA_HOST") else "DEFAULT"
-        model_src = "ENV" if os.environ.get("OLLAMA_MODEL") else "DEFAULT"
-        active_model = getattr(args, 'model', os.environ.get("OLLAMA_MODEL", "llama3"))
-
-        print(f"Active Host  : {args.host} ({host_src})")
-        print(f"Active Model : {active_model} ({model_src})")
-        print("-" * 30)
-
-        if api.ping():
-            models = api.info()
-            print(f"Remote Models at {api.host}:")
-            for m in models: print(f" - {m}")
-        else:
-            print("Remote Status: OFFLINE (Cannot fetch models)")
-
-        print("-" * 30)
-        print("HELP:")
-        print("  To change model: export OLLAMA_MODEL=model_name")
-        print("  To change host:  export OLLAMA_HOST=url")
-        print("  To load prompt:  owlmind query @file.txt")
-        print("-" * 30)
+    def handle_info(api):
+        data = api.info()
+
+        print("-" * 40)
+        print(f"Status  : {data['status']}")
+        print(f"Host    : {api.url}")
+        print(f"Model   : {api.model}")
+
+        print("-" * 40)
+        models_list = data.get('models', [])
+        print(f"Available Models: {len(models_list)}")
+        for m in models_list:
+            print(f"  - {m}")
+
+        print("-" * 40)
+        return
 
     @staticmethod
-    def handle_query(api, args):
+    def handle_query(api):
         if not api.ping():
-            print(f"Error: Server {api.host} unreachable.", file=sys.stderr)
+            print(f"Error: Server {api.url} unreachable.", file=sys.stderr)
             sys.exit(1)
 
-        stream = api.query(
-            model=args.model,
-            prompt=args.prompt,
-            temperature=args.temperature,
-            top_k=args.top_k,
-            top_p=args.top_p,
-            max_tokens=args.max_tokens,
-            num_ctx=args.num_ctx
-        )
-        for chunk in stream:
-            print(chunk['response'], end='', flush=True)
+        # step() yields chunks; we print them in real-time
+        if api.log_level == api.LOG_DEBUG:
+            print(f"--- Inference: {api.model} ---")
+        for chunk in api.step():
+            print(chunk, end="", flush=True)
+        
         print()
+        return 
 
 def get_parser():
-    """Generates the argparse structure."""
     parser = argparse.ArgumentParser(prog="owlmind")
-    parser.add_argument("--host", default=os.environ.get("OLLAMA_HOST", "http://localhost:11434"))
     
+    # Generate the helpers
+    param_list = ", ".join(Ollama.OLLAMA_PARAMS.keys())
+    param_help = f"Supports k=v; (k1=v1,k2=v2), or multiple flags. Options: {param_list}"
+
+    # Global arguments
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--debug", action="store_true", help="Enable verbose telemetry and internal logs")
+    parser.add_argument("--url", dest="url", default=os.environ.get("OLLAMA_HOST", Ollama.DEFAULT_SERVER))
     subparsers = parser.add_subparsers(dest="command", required=True)
-
+    
+    # ping / info
     subparsers.add_parser("ping")
     subparsers.add_parser("info")
 
+    # query
     qp = subparsers.add_parser("query")
-    qp.add_argument("prompt", nargs="?", default=None, help="Prompt text or @filename")
-    qp.add_argument("--input", "-i", dest="input_file", help="Explicit path to a prompt file")
-    
-    # Model & Sampling Params
-    qp.add_argument("--model", "-m", default=os.environ.get("OLLAMA_MODEL", "llama3"))
-    qp.add_argument("--temp", "-t", type=float, default=0.8, dest="temperature")
-    qp.add_argument("--top-k", "-k", type=int, default=40, dest="top_k")
-    qp.add_argument("--top-p", "-p", type=float, default=0.9, dest="top_p")
-    qp.add_argument("--max-tokens", "-n", type=int, default=128, dest="max_tokens")
-    qp.add_argument("--ctx-size", "-c", type=int, default=2048, dest="num_ctx")
+    qp.add_argument("prompt", nargs="?", default=None)
+    qp.add_argument("--input", "-i", dest="input_file")
+    qp.add_argument("--model", "-m", default=os.environ.get("OLLAMA_MODEL", Ollama.DEFAULT_MODEL))
+    qp.add_argument("--params", "-p", action="append", dest="params", help=param_help)
 
     return parser
 
+
+##
+## ENTRY POINT
+##
+
 def main():
+    Dispatcher.load_env()
     parser = get_parser()
     args = parser.parse_args()
     Dispatcher.dispatch(args)
 
-if __name__ == "__main__":
-    main()
-
 
+##
+## EXECUTOR
+##
+if __name__ == "__main__":
+    main()

owlmind/core/__init__.py

@@ -0,0 +1,9 @@
+"""
+OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+"""
+
+from .component import Component
+
+__all__ = [
+    "Component"
+]

owlmind/core/component.py

@@ -0,0 +1,87 @@
+##
+## OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+## core/component.py — Abstract base definition for generative workflow components.
+##
+# Copyright (c) 2025, The Generative Intelligence Lab
+#    https://github.com/genilab/owlmind
+#
+# Disclosure:
+# This framework was developed using a 'vibe coding' . AI-synthesized logic was 
+# subjected to human review and manual refinement to guarantee functional 
+# integrity and structural clarity.
+#
+
+
+import logging
+from typing import Any, Iterator
+from abc import ABC, abstractmethod
+from owlmind.graphk import Node
+
+
+##
+## COMPONENT
+##
+
+class Component(Node, ABC):
+    """
+    Base class for framework components with managed I/O and logging.
+    """
+    
+    LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+    # Log Levels as Constants
+    LOG_DEBUG = logging.DEBUG
+    LOG_INFO = logging.INFO
+    LOG_WARNING = logging.WARNING
+    LOG_ERROR = logging.ERROR
+    LOG_CRITICAL = logging.CRITICAL
+
+    def __init__(self, session: dict = None, log_level: int = LOG_CRITICAL, **kwargs):
+        # 1. Setup logging infrastructure
+        if not logging.getLogger().hasHandlers(): 
+            logging.basicConfig(level=logging.WARNING, format=self.LOG_FORMAT)
+        
+        # Internal framework storage using _name_ convention
+        self._logger_ = logging.getLogger(self.__class__.__name__)
+        self._input_ = None
+        self._output_ = None
+        
+        # Initialize Node (this handles _condition_, _weight_, etc.)
+        super().__init__(session=session, **kwargs)
+
+        # 2. Set the log level using the property setter
+        self.log_level = log_level
+
+        # 3. Obfuscate framework attributes to keep session() clean
+        self.obfuscate(['log_level'])
+
+        return
+
+    @property
+    def input(self): 
+        return self._input_
+
+    @input.setter
+    def input(self, value): 
+        self._input_ = value
+
+    @property
+    def output(self): 
+        return self._output_
+
+    @property
+    def log_level(self) -> int: 
+        return self._logger_.level
+
+    @log_level.setter
+    def log_level(self, level: Any):
+        val = getattr(logging, level.upper(), None) if isinstance(level, str) else level
+        if isinstance(val, int): 
+            self._logger_.setLevel(val)
+        return
+
+    def log(self, message: str, level: int = LOG_INFO): 
+        self._logger_.log(level, message)
+        return
+
+  

owlmind/graphk/__init__.py

@@ -0,0 +1,12 @@
+"""
+GraphK - Framework for Graph programming.
+"""
+
+from .node import Node, Gate, BranchNode
+from .pipeline import Pipeline
+
+__all__ = [
+    "Node", 
+    "Gate", 
+    "BranchNode"
+]

owlmind/graphk/node.py

@@ -0,0 +1,182 @@
+##
+## GraphK - Framework for Graph programming.
+## node.py — data structures for Nodes in Processing Lines
+#            Include: Gate, Node, BrachNode.
+##
+# Copyright (c) 2025, Dr. Fernando Koch
+#    http://github.com/kochf1/graphk
+#
+# Disclosure:
+# This code was developed through 'vibe coding'. Certain components
+# required manual implementation, and human-in-the-loop review and refinement
+# were applied throughout the project.
+#
+
+import random
+from abc import ABC, abstractmethod
+from typing import Union, Callable, List, Any, Iterator, Optional, Dict
+
+
+##
+## GATE
+##
+
+class Gate:
+    """
+    Validation Structurs.
+    """
+    # Strategy Constants
+    ALL_MATCH = 1      # Logical AND
+    ANY_MATCH = 2      # Logical OR
+    ONE_ONE_MATCH = 3  # Exclusive OR / Single match
+
+    def __init__(self, 
+                 checkers: Union[Callable, List[Callable]], 
+                 strategy: int = ALL_MATCH):
+        """
+        Initialize the Gate with a set of rules and a matching strategy.
+        """
+        self.checkers = checkers if isinstance(checkers, list) else [checkers]
+        self.strategy = strategy
+
+    def assess(self, session: Any) -> bool:
+        """
+        Executes the assessment logic against the provided session (dict)
+        """
+        # Convert checkers into a generator of booleans
+        results = (func(session) for func in self.checkers)
+
+        if self.strategy == self.ALL_MATCH:
+            return all(results)
+        
+        if self.strategy == self.ANY_MATCH:
+            return any(results)
+        
+        if self.strategy == self.ONE_ONE_MATCH:
+            # Returns True if exactly one checker returns True
+            return list(results).count(True) == 1
+
+        return False
+    
+##
+## NODE
+##
+
+class Node(ABC):
+    """
+    Base Node.
+    """
+
+    def __init__(self, 
+                 session: Optional[dict] = None, 
+                 *, 
+                 condition: Gate = None,
+                 validation: Gate = None,
+                 weight: int = None,
+                 next: Any = None,
+                 **kwargs):
+        
+        # Initialize the obfuscation set
+        self._obfuscate_ = set()
+
+        # Map internal attributes only if they are provided
+        if condition is not None: self._condition_ = condition
+        if validation is not None: self._validation_ = validation
+        if weight is not None: self._weight_ = weight
+        if next is not None: self._next_ = next
+        
+        # Process session and dynamic kwargs in one pass
+        for key, value in ((session or {}) | kwargs).items(): 
+            setattr(self, key, value)
+        return
+
+    def __repr__(self):
+        return str(self.session())
+
+    def obfuscate(self, keys: Any):
+        """Adds keys to the obfuscation list to hide it from session exports."""
+        self._obfuscate_.update([keys] if isinstance(keys, str) else keys)
+        return
+
+    def session(self) -> dict:
+        """Returns public state; filters internal and obfuscated keys."""
+        return {
+            k: v for k, v in self.__dict__.items()
+            if not k.startswith('_') and k not in self._obfuscate_
+        }
+
+    @abstractmethod
+    def ping(self) -> bool:
+        """Health check / Connectivity test."""
+        pass
+
+    @abstractmethod
+    def info(self) -> dict:
+        """Metadata and capability reporting."""
+        pass
+
+    @abstractmethod
+    def step(self) -> Iterator[Any]:
+        """Execution logic; must return iterator."""
+        pass
+
+
+##
+## BRANCH NODE
+##
+
+class BranchNode(Node, ABC):
+    """
+    Branched nodes.
+    """
+
+    # Selection strategies
+    SELECT_FIRST = 0
+    SELECT_RANDOM = 1
+    SELECT_BEST = 2
+
+    def __init__(
+        self,
+        nodes: List[Node],
+        strategy: int = SELECT_FIRST,
+        session: dict = None,
+        **kwargs
+    ):
+        super().__init__(session=session, **kwargs)
+        self._nodes_ = nodes
+        self._strategy_ = strategy
+        return 
+
+    def select(self) -> Optional[Node]:
+        """
+        Filters nodes based on their _condition_ Gate and applies the selection strategy.
+        """
+        selected_node = None
+
+        # 1. Filter valid nodes using the _condition_ gate
+        valid_nodes = []
+        for node in self._nodes_:
+            # If a gate exists, we assess it; otherwise, the path is open (default True)
+            is_valid = True
+            if hasattr(node, '_condition_'):
+                is_valid = node._condition_.assess(node.session())
+            
+            if is_valid:
+                valid_nodes.append(node)
+
+        # Fail fast: No valid paths available
+        if not valid_nodes:
+            return None
+
+        # 2. Apply Selection Strategy
+        if self._strategy_ == self.SELECT_FIRST:
+            selected_node = valid_nodes[0]
+
+        elif self._strategy_ == self.SELECT_RANDOM:
+            selected_node = random.choice(valid_nodes)
+
+        elif self._strategy_ == self.SELECT_BEST:
+            # Selection based on the _weight_ attribute
+            selected_node = max(valid_nodes, key=lambda n: getattr(n, '_weight_', 0))
+
+        return selected_node

owlmind/graphk/pipeline.py

@@ -0,0 +1,94 @@
+##
+## GraphK - Framework for Graph programming.
+## pipeline.py — data structure for Processing Lines.        
+##
+# Copyright (c) 2025, Dr. Fernando Koch
+#    http://github.com/kochf1/graphk
+#
+# Disclosure:
+# This code was developed through 'vibe coding'. Certain components
+# required manual implementation, and human-in-the-loop review and refinement
+# were applied throughout the project.
+#
+
+
+from abc import ABC, abstractmethod
+from typing import Union, Callable, List, Any, Iterator
+from .node import Node
+
+class Pipeline(Node):
+    """
+    Orchestrator for a sequence of Nodes. 
+    Compatible with GraphK Node and Gate structures.
+    """
+    # Execution Policies
+    SKIP_ON_FAIL = 0   
+    STOP_ON_FAIL = 1
+
+    def __init__(self, 
+                 nodes: Iterable[Node] = None, 
+                 _session: dict = None, 
+                 fail_policy: int = STOP_ON_FAIL,
+                 **kwargs):
+        """
+        Initialize the pipeline as a Node containing other Nodes.
+        """
+        super().__init__(_session=_session, **kwargs)
+        self.nodes = list(nodes) if nodes else []
+        self.fail_policy = fail_policy
+        self.obfuscate(['nodes', 'fail_policy'])
+
+    # --- Node Access (Pythonic Interface) ---
+
+    def __len__(self) -> int: return len(self.nodes)
+
+    def __getitem__(self, index): return self.nodes[index]
+
+    def add(self, node: Node): 
+        self.nodes.append(node)
+        return self
+
+    # --- Execution Logic ---
+
+    def ping(self) -> bool:
+        """Pipeline is healthy if all internal nodes are healthy."""
+        return all(n.ping() for n in self.nodes)
+
+    def info(self) -> dict:
+        return {
+            "type": "Pipeline",
+            "node_count": len(self.nodes),
+            "nodes": [type(n).__name__ for n in self.nodes]
+        }
+
+    def step(self) -> Iterator[Any]:
+        """
+        Executes the pipeline sequence. 
+        Passes output of one node as input to the next.
+        """
+        current_input = getattr(self, 'input', None)
+
+        for node in self.nodes:
+            # 1. Check Condition Gate (if assigned to the node)
+            if hasattr(node, 'can_proceed') and not node.can_proceed(current_input):
+                if self.fail_policy == self.STOP_ON_FAIL: break
+                continue
+
+            # 2. Set input and execute
+            node.input = current_input
+            
+            # 3. Collect output (assuming step() returns an iterator)
+            node_output = None
+            for chunk in node.step():
+                node_output = chunk # Capture last chunk as the state
+                yield chunk
+
+            # 4. Check Validation Gate
+            if hasattr(node, 'is_valid') and not node.is_valid(node_output):
+                if self.fail_policy == self.STOP_ON_FAIL: break
+            
+            # 5. Chain output to next input
+            current_input = node_output
+
+        self._output = current_input
+

owlmind/models/__init__.py

@@ -0,0 +1,9 @@
+"""
+OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+"""
+
+from .ollama import Ollama
+
+__all__ = [
+    "Ollama"
+]

owlmind/models/ollama.py

@@ -0,0 +1,121 @@
+
+##
+## OwlMind Framework - experimentation environment for Generative Intelligence Systems.
+## core/ollama.py — Ollama-backed implementation of the Component interface.
+##
+# Copyright (c) 2025, The Generative Intelligence Lab
+#    https://github.com/genilab/owlmind
+#
+# Disclosure:
+# This framework was developed using a 'vibe coding' . AI-synthesized logic was 
+# subjected to human review and manual refinement to guarantee functional 
+# integrity and structural clarity.
+#
+
+import logging
+import ollama
+from typing import Any, Iterator
+from owlmind.core import Component
+
+class Ollama(Component):
+    """
+    Implementation of Ollama model access component.
+    Configuration and parameters are strictly managed via attributes.
+    """
+
+    DEFAULT_SERVER = "http://localhost:11434"
+    DEFAULT_MODEL = "llama3"
+    DEFAULT_TIMEOUT = 10
+    DEFAULT_LOG_LEVEL = logging.INFO
+
+    OLLAMA_PARAMS = {
+        "temperature": None, "top_p": None, "seed": None,
+        "num_ctx": None, "num_predict": None, "repeat_penalty": None,
+        "top_k": None, "stop": None, "system": None
+    }
+
+    def __init__(self, session: dict = None, **kwargs):
+        # Internal framework storage using _name_ convention
+        self._models_cache_ = None
+        self._client_ = None
+        
+        # Establish loggign level
+        log_level = kwargs.pop('log_level', self.DEFAULT_LOG_LEVEL)
+
+        # Initialize Component (which handles _logger_, _input_, etc.)
+        super().__init__(session=session, log_level=log_level, **kwargs)
+        
+        # Ensure public config attributes exist in __dict__ for session()
+        if not hasattr(self, 'url'): self.url = self.DEFAULT_SERVER
+        if not hasattr(self, 'model'): self.model = self.DEFAULT_MODEL
+        
+        # Map parameters; if None, they stay in session() as None unless filtered
+        for param, default_value in self.OLLAMA_PARAMS.items():
+            if not hasattr(self, param): setattr(self, param, default_value)
+
+        # Initialize the client using the framework internal
+        self._client_ = ollama.Client(host=self.url, timeout=self.DEFAULT_TIMEOUT)
+        
+        # Obfuscate the client-related keys just in case
+        self.obfuscate(['_client_', '_models_cache_'])
+        return
+
+    def ping(self) -> bool:
+        """Health check for Ollama server."""
+        is_alive = False
+        try:
+            self._client_.list()
+            is_alive = True
+        except Exception as e:
+            self.log(f"Ping failed at {self.url}: {e}", level=self.LOG_WARNING)
+        
+        return is_alive
+
+    def info(self) -> dict:
+        """Capability reporting including available models."""
+        if self._models_cache_ is None:
+            try:
+                response = self._client_.list()
+                # Handle varying response structures from Ollama library
+                models_list = getattr(response, 'models', response.get('models', []))
+                self._models_cache_ = [
+                    getattr(m, 'model', getattr(m, 'name', m.get('model', m.get('name')))) 
+                    for m in models_list if m
+                ]
+            except Exception:
+                self._models_cache_ = []
+
+        # Filter out None values for a cleaner info report
+        clean_session = {k: v for k, v in self.session().items() if v is not None}
+        
+        return {
+            "status": "online" if self.ping() else "offline",
+            "session": clean_session,
+            "models": self._models_cache_
+        }
+
+    def step(self) -> Iterator[str]:
+        """Execution: Performs LLM inference."""
+        # Fail Fast: No input
+        if not self.input:
+            self.log("Step skipped: No input provided.", level=self.LOG_WARNING)
+            yield "No input found."
+            return
+
+        # Prepare parameters for Ollama API
+        options = {p: getattr(self, p) for p in self.OLLAMA_PARAMS if getattr(self, p) is not None}
+
+        self.log(f"Inference: {self.model} @ {self.url}", level=self.LOG_INFO)
+        self.log(f"Parameters: {options}", level=self.LOG_DEBUG)
+
+        result = ""
+        try:
+            response = self._client_.generate(model=self.model, prompt=self.input, options=options)
+            result = response.get('response', '')
+            self.output = result # Using property setter
+        except Exception as e:
+            self.log(f"Ollama Error: {e}", level=self.LOG_ERROR)
+            result = f"Error: {str(e)}"
+        
+        yield result
+        return

{owlmind-0.1.2.dist-info → owlmind-0.1.5.dist-info}/METADATA

@@ -1,10 +1,15 @@
 Metadata-Version: 2.4
 Name: owlmind
-Version: 0.1.2
-Summary: A modular CLI for local Ollama control
-Requires-Python: >=3.8
+Version: 0.1.5
+Summary: Experimentation environment and pedagogical sandbox for studying generative intelligence systems.
+Author-email: Fernando Koch <your-email@example.com>
+License: MIT
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: ollama
+License-File: LICENSE.txt
+Requires-Dist: ollama>=0.4.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
 
 
 <!---
@@ -24,17 +29,20 @@ Requires-Dist: ollama
 
 ## Overview
 
-The OwlMind Platform is a foundational experimentation environment engineered by The Generative Intelligence Lab. It serves as a pedagogical sandbox where students and researchers can interrogate the mechanics of Generative Intelligence. By implementing a standardized CLI over a provider-agnostic abstraction layer, OwlMind enables learners to conduct comparative analyses of LLM behaviors through interchangeable parameters within a controlled, observable setup
+The OwlMind Framework provides an experimentation environment and pedagogical sandbox for [Generative Intelligence Systems](https://medium.com/lecture-notes-on-generative-intelligence/generative-intelligence-systems-5b23727acffe). The platform defines a standardized programming structure and command-line interface across multiple architectural layers. This structure enables comparative experiments around the behaviors of Large Language Models (LLMs), AI pipelines, and component-level configurations.
 
-Installation:
+#### Installation:
 
 ```bash
 pip install owlmind
 ```
 
----
+If the installation goes well, you should be able to run the script:
+
+```bash
+owlmind --version
+```
 
-## Commands
 
 #### Configuration 
 Control OwlMind via environment variables
@@ -47,15 +55,18 @@ export OLLAMA_HOST=http://localhost:11434
 export OLLAMA_MODEL=llama3
 ```
 
-
-#### System Audit
-View your current environment configuration
+A good alternative is to create a ``.env`` file.
 
 ```bash
-owlmind info
+# File: .env
+# .env files are loaded automatically 
+
+OLLAMA_HOST=http://localhost:11434
+OLLAMA_MODEL=llama
 ```
 
-#### Connectivity Check 
+
+#### Connectivity 
 Verify if your model provider is online.
 
 ```bash
@@ -63,14 +74,21 @@ owlmind ping
 ```
 
 
-#### Generation
+#### Information
+View your environment information.
+
+```bash
+owlmind info
+```
+
+#### Generation with Parameters
 Run inference with full control over sampling parameters.
 
 ```bash
 owlmind query "How do AI-driven organizations scale?" --temp 1.2 --ctx-size 4096
 ```
 
-Possible parameters:
+Other parameters:
 
 ```bash
 $ owlmind query --help
@@ -94,7 +112,7 @@ options:
 ```
 
 
-#### Prompt Loading (@file syntax)
+#### Prompt Loading
 OwlMind supports loading prompts directly from files using the @ prefix. This is ideal for long-form instructions or code analysis.
 
 ```bash
@@ -107,3 +125,4 @@ Explicit Flag:
 owlmind query --input research_paper.md
 ```
 
+

owlmind-0.1.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+owlmind/__init__.py,sha256=jeK2gtlTJnsYnkBZnUWO9SbKcyzyIGOZidZUfOBpSa8,115
+owlmind/cli.py,sha256=UCU7YVyi3hnjmkMp-QmFvaRIo4hBQd9y9VhREag0bj0,7523
+owlmind/core/__init__.py,sha256=FdHsekm-vN68W1lxoqgVGhDGNW8r5VUbvHcWYT8MafQ,158
+owlmind/core/component.py,sha256=FxXcki2I986vgpHQj3iUR8Ocb6zjKPwPvcE59MYjbX8,2452
+owlmind/graphk/__init__.py,sha256=Sm9S-qmlxvgxJB6ZyZ8MEJhWGsDmD-2ctsc9Vmi5ivQ,181
+owlmind/graphk/node.py,sha256=GUPvd0XMzflPKgOzbJBV7igrGVHQOn31JkPlzffTR_Y,5138
+owlmind/graphk/pipeline.py,sha256=otmpg7PDRzbkoHouqukXUzVS3yS5CVwra0O0vPFfw1Y,2936
+owlmind/models/__init__.py,sha256=oDwcewvCenSr3PMpoZPOkq8sSj0MkXlruIAw-Dj8uI4,149
+owlmind/models/ollama.py,sha256=Y-9J5C5ztRgricOJ4Co3AE_QGQbr99bKreJwGJUoZTQ,4514
+owlmind-0.1.5.dist-info/licenses/LICENSE.txt,sha256=N3XP8HnV0oou2kX_RhIixOcH-_3R2EU9t3JZ5a1Xq-4,1084
+owlmind-0.1.5.dist-info/METADATA,sha256=brzEaFFtQwRdhD1dz1dAlo7LqUoNHeCe2h5aSVDqino,3371
+owlmind-0.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+owlmind-0.1.5.dist-info/entry_points.txt,sha256=dtbjpXwYC8Nbe3CJ02gflnKOOhpQWk9u5gALeDHOWGk,45
+owlmind-0.1.5.dist-info/top_level.txt,sha256=hZkLOzK2jV0_OPvcTpeIwlEQi869uqittXNzXF8AajE,8
+owlmind-0.1.5.dist-info/RECORD,,

owlmind-0.1.5.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> Adam Veldhousen
+
+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.

owlmind/model.py

@@ -1,21 +0,0 @@
-from abc import ABC, abstractmethod
-
-class Model(ABC):
-    def __init__(self, host: str):
-        self.host = host
-
-    @abstractmethod
-    def ping(self) -> bool:
-        """Check if the provider is reachable."""
-        pass
-
-    @abstractmethod
-    def info(self) -> list:
-        """List available models."""
-        pass
-
-    @abstractmethod
-    def query(self, model: str, prompt: str, **options):
-        """Execute a completion request."""
-        pass
-

owlmind/ollama.py

@@ -1,62 +0,0 @@
-
-import ollama
-from .model import Model
-
-class Ollama(Model):
-    """
-    Ollama implementation of the Model interface.
-    Ensures parameters are correctly mapped to the 'options' dictionary.
-    """
-    def __init__(self, host: str):
-        super().__init__(host)
-        # The host is passed directly to the Client constructor
-        self.client = ollama.Client(host=self.host)
-
-    def ping(self) -> bool:
-        """Checks connectivity by attempting to list models."""
-        try:
-            self.client.list()
-            return True
-        except Exception:
-            return False
-
-    def info(self) -> list:
-        """Fetches the list of available model names from the local server."""
-        try:
-            response = self.client.list()
-            # Extracts model names from the 'models' key in the response dictionary
-            return [m['model'] for m in response.get('models', [])]
-        except Exception:
-            return []
-
-    def query(self, model: str, prompt: str, **options):
-        """
-        Executes a generation request.
-        Crucial: Parameters like temperature MUST be inside the 'options' dict.
-        """
-        # Map our generic CLI terms to Ollama API specific keys
-        # num_predict = Max Tokens
-        # num_ctx     = Context Window size
-        ollama_params = {
-            'temperature': options.get('temperature'),
-            'top_k': options.get('top_k'),
-            'top_p': options.get('top_p'),
-            'num_predict': options.get('max_tokens'),
-            'num_ctx': options.get('num_ctx'),
-            'seed': options.get('seed') # Added for reproducibility testing
-        }
-
-        # Filter out None values so the Ollama server uses its internal defaults
-        # for any parameter the user didn't explicitly set via CLI flags.
-        clean_options = {k: v for k, v in ollama_params.items() if v is not None}
-
-        # The generate method takes model and prompt as top-level args,
-        # but all sampling/tuning parameters go into the 'options' keyword argument.
-        return self.client.generate(
-            model=model,
-            prompt=prompt,
-            stream=True,
-            options=clean_options
-        )
-
-

owlmind-0.1.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-owlmind/__init__.py,sha256=WdAUZIWDqq_7CtIT9yT_Eghr5Ph24Bdgdh7sC7h4WzA,50
-owlmind/cli.py,sha256=38HbHyCnRe1Sqx79rA4ugZwSu_9hfaZhXrOsQckafto,4943
-owlmind/model.py,sha256=J1X0gaqdZZhSJgfuhnQaD395O6gnCbr1JD1cGIfN8v0,462
-owlmind/ollama.py,sha256=hUJja7RAtYg7GWWQHd6l3BUV4xMcAolrqJWwlz_h9fw,2212
-owlmind-0.1.2.dist-info/METADATA,sha256=KczHGIGqb3Bs3C1BypgKA8eon6I-OZ68ymVBpUMRrpA,2871
-owlmind-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-owlmind-0.1.2.dist-info/entry_points.txt,sha256=dtbjpXwYC8Nbe3CJ02gflnKOOhpQWk9u5gALeDHOWGk,45
-owlmind-0.1.2.dist-info/top_level.txt,sha256=hZkLOzK2jV0_OPvcTpeIwlEQi869uqittXNzXF8AajE,8
-owlmind-0.1.2.dist-info/RECORD,,