owlmind 0.1.2__py3-none-any.whl

owlmind/__init__.py

@@ -0,0 +1,3 @@
+from .ollama import Ollama
+
+__version__ = "0.1.0"

owlmind/cli.py

@@ -0,0 +1,137 @@
+import argparse
+import os
+import sys
+from .ollama import Ollama
+
+class Dispatcher:
+    """Orchestrates the execution of commands and resolves prompt sources."""
+
+    @staticmethod
+    def dispatch(args):
+        """Primary router that handles prompt resolution before execution."""
+        api = Ollama(host=args.host)
+
+        if args.command == "ping":
+            Dispatcher.handle_ping(api)
+        elif args.command == "info":
+            Dispatcher.handle_info(api, args)
+        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)
+
+    @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
+
+    @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)
+            sys.exit(1)
+
+    @staticmethod
+    def handle_ping(api):
+        status = "ONLINE" if api.ping() else "OFFLINE"
+        print(f"Status: {status} ({api.host})")
+
+    @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)
+
+    @staticmethod
+    def handle_query(api, args):
+        if not api.ping():
+            print(f"Error: Server {api.host} 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)
+        print()
+
+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"))
+    
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser("ping")
+    subparsers.add_parser("info")
+
+    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")
+
+    return parser
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+    Dispatcher.dispatch(args)
+
+if __name__ == "__main__":
+    main()
+
+

owlmind/model.py

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,62 @@
+
+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/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: owlmind
+Version: 0.1.2
+Summary: A modular CLI for local Ollama control
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: ollama
+
+
+<!---
+<img src="https://generativeintelligencelab.ai/images/owlmind-banner.png" width=800>
+--->
+
+# OwlMind
+
+<div align="left">
+  <img src="https://img.shields.io/badge/Generative_AI-Lab-blueviolet?style=for-the-badge&logo=openai&logoColor=white" alt="Generative AI" />
+  <img src="https://img.shields.io/badge/Ollama-Supported-000000?style=for-the-badge&logo=ollama&logoColor=white" alt="Ollama" />
+  <img src="https://img.shields.io/badge/Python-3.14-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Python 3.14" />
+  <img src="https://img.shields.io/badge/License-MIT-green?style=for-the-badge" alt="License" />
+</div>
+
+---
+
+## 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
+
+Installation:
+
+```bash
+pip install owlmind
+```
+
+---
+
+## Commands
+
+#### Configuration 
+Control OwlMind via environment variables
+
+```bash
+# OLLAMA_HOST -- URL of the Ollama server
+export OLLAMA_HOST=http://localhost:11434
+
+# OLLAMA_MODEL -- Default model for queries	llama3
+export OLLAMA_MODEL=llama3
+```
+
+
+#### System Audit
+View your current environment configuration
+
+```bash
+owlmind info
+```
+
+#### Connectivity Check 
+Verify if your model provider is online.
+
+```bash
+owlmind ping
+```
+
+
+#### Generation
+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:
+
+```bash
+$ owlmind query --help
+usage: owlmind query [-h] [--input INPUT_FILE] [--model MODEL] [--temp TEMPERATURE] [--top-k TOP_K]
+                     [--top-p TOP_P] [--max-tokens MAX_TOKENS] [--ctx-size NUM_CTX]
+                     [prompt]
+
+positional arguments:
+  prompt                Prompt text or @filename
+
+options:
+  -h, --help            show this help message and exit
+  --input, -i INPUT_FILE
+                        Explicit path to a prompt file
+  --model, -m MODEL
+  --temp, -t TEMPERATURE
+  --top-k, -k TOP_K
+  --top-p, -p TOP_P
+  --max-tokens, -n MAX_TOKENS
+  --ctx-size, -c NUM_CTX
+```
+
+
+#### Prompt Loading (@file syntax)
+OwlMind supports loading prompts directly from files using the @ prefix. This is ideal for long-form instructions or code analysis.
+
+```bash
+owlmind query @my_prompt.txt
+```
+
+Explicit Flag:
+
+```bash
+owlmind query --input research_paper.md
+```
+

owlmind-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+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,,

owlmind-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

owlmind-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+owlmind = owlmind.cli:main

owlmind-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+owlmind