prellm 0.1.12__tar.gz

prellm-0.1.12/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Softreck
+
+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.

prellm-0.1.12/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: prellm
+Version: 0.1.12
+Summary: PromptGuard - Lightweight LLM prompt middleware for bias detection, standardization, and DevOps process chains via YAML config, supporting context injection and multi-provider orchestration.
+License: Apache-2.0
+License-File: LICENSE
+Keywords: llm,prompt-engineering,bias-detection,devops,litellm
+Author: Softreck
+Author-email: tom@sapletta.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: litellm (>=1.40,<2.0)
+Requires-Dist: nltk (>=3.8,<4.0)
+Requires-Dist: pydantic (>=2.0,<3.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: textstat (>=0.7,<0.8)
+Requires-Dist: typer[all] (>=0.12,<0.13)
+Project-URL: Repository, https://github.com/softreck/gllm
+Description-Content-Type: text/markdown
+
+# 🛡️ PromptGuard
+
+**Lightweight LLM prompt middleware — bias detection, standardization, and DevOps process chains via YAML config.**
+
+PromptGuard sits between your application and LLM providers, automatically detecting bias, ambiguity, and dangerous patterns in prompts. It enriches queries with context, validates outputs, and supports multi-step DevOps workflows with approval gates.
+
+## Features
+
+- **Bias & Ambiguity Detection** — regex + NLTK patterns for PL/EN, with DevOps-specific guardrails
+- **YAML-Driven Config** — declarative rules, clarification templates, model fallbacks
+- **100+ LLM Models** — via LiteLLM proxy (OpenAI, Anthropic, Llama, Mistral, etc.)
+- **DevOps Process Chains** — multi-step workflows with approval gates, rollback, and audit trails
+- **Context Injection** — auto-enrich prompts with env vars, git info, system state
+- **Type-Safe Outputs** — Pydantic v2 validated responses
+- **Lightweight** — <50MB, 5 dependencies, async-first
+
+## Quick Start
+
+```bash
+# Install
+pip install promptguard
+
+# Generate config
+promptguard init --devops -o rules.yaml
+
+# Analyze a query (no LLM call)
+promptguard analyze "Deploy to production" --config rules.yaml
+
+# Run with LLM
+promptguard run "Zdeployuj na staging" --config rules.yaml --model gpt-4o-mini
+
+# Execute a process chain
+promptguard process deploy.yaml --guard-config rules.yaml --env production
+```
+
+## Python API
+
+```python
+from promptguard import PromptGuard, ProcessChain
+
+# Simple query
+guard = PromptGuard("rules.yaml")
+result = await guard("Deploy to production", model="gpt-4o-mini")
+print(result.clarified)  # True — detected missing context
+print(result.content)     # Enriched response
+
+# Process chain
+chain = ProcessChain("deploy.yaml")
+result = await chain.execute(env="production", dry_run=True)
+for step in result.steps:
+    print(f"{step.step_name}: {step.status}")
+```
+
+## Configuration
+
+### rules.yaml
+```yaml
+bias_patterns:
+  - regex: "(deploy|zdeployuj)\\s+(na|to)\\s+(prod|production)"
+    action: clarify
+    severity: critical
+    description: "Production deployment — requires context"
+
+clarify_template: "[KONTEKST]: Podaj szczegóły dla: {query}"
+max_retries: 3
+policy: devops
+
+models:
+  fallback: ["gpt-4o-mini", "llama3"]
+
+context_sources:
+  - env: [CLUSTER, NAMESPACE, GIT_SHA]
+  - git: [branch, short_sha]
+```
+
+### deploy.yaml (Process Chain)
+```yaml
+process: deploy-production
+steps:
+  - name: pre-check
+    prompt: "Check readiness of {CLUSTER}"
+    approval: auto
+  - name: deploy
+    prompt: "Rolling deploy to {CLUSTER}/{NAMESPACE}"
+    approval: manual
+    rollback: true
+```
+
+## Architecture
+
+```
+User Query → BiasDetector → ContextEngine → Enrichment → LiteLLM → Pydantic Validation → Response
+                                                              ↑
+                                        ProcessChain → Approval Gates → Audit Trail
+```
+
+## Development
+
+```bash
+git clone https://github.com/softreck/promptguard
+cd promptguard
+poetry install
+poetry run pytest
+```
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)
+

prellm-0.1.12/README.md

@@ -0,0 +1,112 @@
+# 🛡️ PromptGuard
+
+**Lightweight LLM prompt middleware — bias detection, standardization, and DevOps process chains via YAML config.**
+
+PromptGuard sits between your application and LLM providers, automatically detecting bias, ambiguity, and dangerous patterns in prompts. It enriches queries with context, validates outputs, and supports multi-step DevOps workflows with approval gates.
+
+## Features
+
+- **Bias & Ambiguity Detection** — regex + NLTK patterns for PL/EN, with DevOps-specific guardrails
+- **YAML-Driven Config** — declarative rules, clarification templates, model fallbacks
+- **100+ LLM Models** — via LiteLLM proxy (OpenAI, Anthropic, Llama, Mistral, etc.)
+- **DevOps Process Chains** — multi-step workflows with approval gates, rollback, and audit trails
+- **Context Injection** — auto-enrich prompts with env vars, git info, system state
+- **Type-Safe Outputs** — Pydantic v2 validated responses
+- **Lightweight** — <50MB, 5 dependencies, async-first
+
+## Quick Start
+
+```bash
+# Install
+pip install promptguard
+
+# Generate config
+promptguard init --devops -o rules.yaml
+
+# Analyze a query (no LLM call)
+promptguard analyze "Deploy to production" --config rules.yaml
+
+# Run with LLM
+promptguard run "Zdeployuj na staging" --config rules.yaml --model gpt-4o-mini
+
+# Execute a process chain
+promptguard process deploy.yaml --guard-config rules.yaml --env production
+```
+
+## Python API
+
+```python
+from promptguard import PromptGuard, ProcessChain
+
+# Simple query
+guard = PromptGuard("rules.yaml")
+result = await guard("Deploy to production", model="gpt-4o-mini")
+print(result.clarified)  # True — detected missing context
+print(result.content)     # Enriched response
+
+# Process chain
+chain = ProcessChain("deploy.yaml")
+result = await chain.execute(env="production", dry_run=True)
+for step in result.steps:
+    print(f"{step.step_name}: {step.status}")
+```
+
+## Configuration
+
+### rules.yaml
+```yaml
+bias_patterns:
+  - regex: "(deploy|zdeployuj)\\s+(na|to)\\s+(prod|production)"
+    action: clarify
+    severity: critical
+    description: "Production deployment — requires context"
+
+clarify_template: "[KONTEKST]: Podaj szczegóły dla: {query}"
+max_retries: 3
+policy: devops
+
+models:
+  fallback: ["gpt-4o-mini", "llama3"]
+
+context_sources:
+  - env: [CLUSTER, NAMESPACE, GIT_SHA]
+  - git: [branch, short_sha]
+```
+
+### deploy.yaml (Process Chain)
+```yaml
+process: deploy-production
+steps:
+  - name: pre-check
+    prompt: "Check readiness of {CLUSTER}"
+    approval: auto
+  - name: deploy
+    prompt: "Rolling deploy to {CLUSTER}/{NAMESPACE}"
+    approval: manual
+    rollback: true
+```
+
+## Architecture
+
+```
+User Query → BiasDetector → ContextEngine → Enrichment → LiteLLM → Pydantic Validation → Response
+                                                              ↑
+                                        ProcessChain → Approval Gates → Audit Trail
+```
+
+## Development
+
+```bash
+git clone https://github.com/softreck/promptguard
+cd promptguard
+poetry install
+poetry run pytest
+```
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)

prellm-0.1.12/promptguard/__init__.py

@@ -0,0 +1,19 @@
+"""PromptGuard — Lightweight LLM prompt middleware for bias detection, standardization, and DevOps process chains."""
+
+__version__ = "0.1.12"
+
+from promptguard.core import PromptGuard
+from promptguard.models import GuardResponse, GuardConfig, AnalysisResult
+from promptguard.chains.process_chain import ProcessChain
+from promptguard.analyzers.bias_detector import BiasDetector
+from promptguard.analyzers.context_engine import ContextEngine
+
+__all__ = [
+    "PromptGuard",
+    "ProcessChain",
+    "GuardResponse",
+    "GuardConfig",
+    "AnalysisResult",
+    "BiasDetector",
+    "ContextEngine",
+]

prellm-0.1.12/promptguard/analyzers/__init__.py

@@ -0,0 +1 @@
+

prellm-0.1.12/promptguard/analyzers/bias_detector.py

@@ -0,0 +1,96 @@
+"""BiasDetector — scans queries for bias patterns, ambiguity, and readability issues."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from promptguard.models import AnalysisResult, BiasPattern
+
+
+# Default bias/ambiguity patterns for Polish & English DevOps context
+DEFAULT_PATTERNS: list[dict[str, str]] = [
+    {"regex": r"(zawsze|always)\s+\w+", "action": "clarify", "severity": "medium", "description": "Absolute quantifier"},
+    {"regex": r"(tylko|only|just)\s+\w+", "action": "clarify", "severity": "low", "description": "Exclusive quantifier"},
+    {"regex": r"(głupi|stupid|dumb)\s+\w+", "action": "flag", "severity": "high", "description": "Derogatory language"},
+    {"regex": r"(zdeployuj|deploy|push)\s+(na|to)\s+(prod|production)", "action": "clarify", "severity": "critical",
+     "description": "Production deployment without context"},
+    {"regex": r"(usuń|delete|drop|remove)\s+(baz[ęa]|database|db|table)", "action": "clarify", "severity": "critical",
+     "description": "Destructive DB operation"},
+    {"regex": r"(restart|reboot|kill)\s+(server|service|pod|container)", "action": "clarify", "severity": "high",
+     "description": "Service disruption command"},
+    {"regex": r"(migrate|migruj)\s+.*(?:prod|production)", "action": "clarify", "severity": "critical",
+     "description": "Production migration"},
+    {"regex": r"(skaluj|scale)\s+(down|up|to\s+\d+)", "action": "clarify", "severity": "high",
+     "description": "Scaling operation"},
+    {"regex": r"(zmień|change|update)\s+(config|konfigurację|env|secret)", "action": "clarify", "severity": "high",
+     "description": "Configuration change"},
+]
+
+
+class BiasDetector:
+    """Detects bias, ambiguity, and dangerous patterns in queries.
+
+    Uses regex patterns (configurable via YAML) + optional NLTK readability scoring.
+    Designed for both general prompt safety and DevOps-specific guardrails.
+    """
+
+    def __init__(self, patterns: list[BiasPattern] | None = None):
+        if patterns:
+            self.patterns = patterns
+        else:
+            self.patterns = [BiasPattern(**p) for p in DEFAULT_PATTERNS]
+
+        self._readability_available = False
+        try:
+            import textstat  # noqa: F401
+            self._readability_available = True
+        except ImportError:
+            pass
+
+    def analyze(self, query: str) -> AnalysisResult:
+        """Analyze a query for bias patterns and ambiguity."""
+        detected: list[str] = []
+        ambiguity_flags: list[str] = []
+        needs_clarify = False
+
+        for pattern in self.patterns:
+            if re.search(pattern.regex, query, re.IGNORECASE):
+                detected.append(f"[{pattern.severity}] {pattern.description}")
+                if pattern.action == "clarify":
+                    needs_clarify = True
+                    ambiguity_flags.append(pattern.description)
+
+        # Check for very short / context-free queries
+        word_count = len(query.split())
+        if word_count < 4:
+            needs_clarify = True
+            ambiguity_flags.append("Query too short — likely missing context")
+
+        # Check for missing subject/object in DevOps context
+        devops_verbs = ["deploy", "zdeployuj", "migrate", "migruj", "scale", "skaluj",
+                        "restart", "delete", "usuń", "push", "rollback"]
+        has_devops_verb = any(v in query.lower() for v in devops_verbs)
+        has_target = any(t in query.lower() for t in [
+            "staging", "production", "prod", "dev", "test", "cluster", "namespace"])
+        if has_devops_verb and not has_target:
+            needs_clarify = True
+            ambiguity_flags.append("DevOps command without target environment")
+
+        # Readability score
+        readability = None
+        if self._readability_available:
+            try:
+                import textstat
+                readability = textstat.flesch_reading_ease(query)
+            except Exception:
+                pass
+
+        return AnalysisResult(
+            needs_clarify=needs_clarify,
+            detected_patterns=detected,
+            enriched_query="",
+            original_query=query,
+            readability_score=readability,
+            ambiguity_flags=ambiguity_flags,
+        )

prellm-0.1.12/promptguard/analyzers/context_engine.py

@@ -0,0 +1,90 @@
+"""ContextEngine — gathers runtime context (env vars, git info, system state) for prompt enrichment."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import Any
+
+
+class ContextEngine:
+    """Collects context from environment, git, and system for prompt enrichment.
+
+    Used by both core PromptGuard (auto-inject context) and ProcessChain (step-level context).
+    """
+
+    def __init__(self, context_sources: list[dict[str, Any]] | None = None):
+        self.sources = context_sources or []
+
+    def gather(self) -> dict[str, str]:
+        """Gather all configured context into a flat dict."""
+        ctx: dict[str, str] = {}
+
+        for source in self.sources:
+            if "env" in source:
+                ctx.update(self._gather_env(source["env"]))
+            if "git" in source:
+                ctx.update(self._gather_git(source["git"]))
+            if "system" in source:
+                ctx.update(self._gather_system(source["system"]))
+
+        return ctx
+
+    def enrich_prompt(self, prompt: str, extra: dict[str, str] | None = None) -> str:
+        """Substitute {VARIABLE} placeholders in a prompt with gathered context."""
+        ctx = self.gather()
+        if extra:
+            ctx.update(extra)
+
+        enriched = prompt
+        for key, value in ctx.items():
+            enriched = enriched.replace(f"{{{key}}}", value)
+
+        return enriched
+
+    @staticmethod
+    def _gather_env(keys: list[str]) -> dict[str, str]:
+        result = {}
+        for key in keys:
+            val = os.environ.get(key, "")
+            if val:
+                result[key] = val
+        return result
+
+    @staticmethod
+    def _gather_git(fields: list[str]) -> dict[str, str]:
+        result = {}
+        git_commands = {
+            "branch": ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            "last_commit": ["git", "log", "-1", "--format=%H"],
+            "last_commit_msg": ["git", "log", "-1", "--format=%s"],
+            "short_sha": ["git", "rev-parse", "--short", "HEAD"],
+            "tag": ["git", "describe", "--tags", "--abbrev=0"],
+            "remote_url": ["git", "remote", "get-url", "origin"],
+        }
+        for field in fields:
+            cmd = git_commands.get(field)
+            if cmd:
+                try:
+                    out = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+                    if out.returncode == 0:
+                        result[field] = out.stdout.strip()
+                except (subprocess.TimeoutExpired, FileNotFoundError):
+                    pass
+        return result
+
+    @staticmethod
+    def _gather_system(fields: list[str]) -> dict[str, str]:
+        result = {}
+        import platform
+        system_map = {
+            "hostname": platform.node,
+            "os": platform.system,
+            "arch": platform.machine,
+            "python": platform.python_version,
+        }
+        for field in fields:
+            fn = system_map.get(field)
+            if fn:
+                result[field] = fn()
+        return result

prellm-0.1.12/promptguard/chains/process_chain.py

@@ -0,0 +1,226 @@
+"""ProcessChain — Multi-step DevOps workflow engine with approval gates and audit trail.
+
+Defines workflows as YAML, validates each step through PromptGuard, supports
+manual/auto approval, rollback, and full audit logging.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+import yaml
+
+from promptguard.analyzers.context_engine import ContextEngine
+from promptguard.core import PromptGuard
+from promptguard.models import (
+    ApprovalMode,
+    AuditEntry,
+    GuardConfig,
+    ProcessConfig,
+    ProcessResult,
+    ProcessStep,
+    StepResult,
+    StepStatus,
+)
+
+logger = logging.getLogger("promptguard.chains")
+
+# Type for approval callback: receives step info, returns (approved: bool, approved_by: str)
+ApprovalCallback = Callable[[str, str], Awaitable[tuple[bool, str]]]
+
+
+class ProcessChain:
+    """Execute multi-step DevOps workflows with PromptGuard validation at each step.
+
+    Usage:
+        chain = ProcessChain("deploy.yaml")
+        result = await chain.execute(
+            env="production",
+            approval_callback=my_slack_approval_fn,
+        )
+
+    Each step's prompt goes through PromptGuard's full pipeline (bias detection,
+    enrichment, LLM call, validation) before execution.
+    """
+
+    def __init__(
+        self,
+        config_path: str | Path | None = None,
+        config: ProcessConfig | None = None,
+        guard_config_path: str | Path | None = None,
+        guard: PromptGuard | None = None,
+    ):
+        if config:
+            self.process_config = config
+        elif config_path:
+            self.process_config = self._load_process_config(Path(config_path))
+        else:
+            raise ValueError("Either config_path or config must be provided")
+
+        self.guard = guard or PromptGuard(config_path=guard_config_path)
+        self.context_engine = ContextEngine(self.process_config.context_sources)
+        self.audit_log: list[AuditEntry] = []
+        self._step_results: dict[str, StepResult] = {}
+
+    async def execute(
+        self,
+        extra_context: dict[str, str] | None = None,
+        approval_callback: ApprovalCallback | None = None,
+        dry_run: bool = False,
+        **env_overrides: str,
+    ) -> ProcessResult:
+        """Execute the full process chain.
+
+        Args:
+            extra_context: Additional key-value context to inject into prompts.
+            approval_callback: Async function for manual approval steps.
+                Receives (step_name, enriched_prompt) → (approved, approved_by).
+            dry_run: If True, analyze prompts but don't call LLM.
+            **env_overrides: Override environment-level context (e.g., env="production").
+
+        Returns:
+            ProcessResult with status of all steps.
+        """
+        start_time = time.time()
+        ctx = self.context_engine.gather()
+        if extra_context:
+            ctx.update(extra_context)
+        ctx.update(env_overrides)
+
+        result = ProcessResult(
+            process_name=self.process_config.process,
+            started_at=datetime.utcnow(),
+        )
+
+        for step in self.process_config.steps:
+            step_result = await self._execute_step(
+                step=step,
+                ctx=ctx,
+                approval_callback=approval_callback,
+                dry_run=dry_run,
+            )
+            result.steps.append(step_result)
+            self._step_results[step.name] = step_result
+
+            if step_result.status == StepStatus.FAILED:
+                logger.error(f"Step '{step.name}' failed — halting chain.")
+                break
+
+            if step_result.status == StepStatus.AWAITING_APPROVAL:
+                logger.info(f"Step '{step.name}' awaiting approval — chain paused.")
+                break
+
+        # Final status
+        all_completed = all(s.status == StepStatus.COMPLETED for s in result.steps)
+        result.completed = all_completed
+        result.total_duration_seconds = time.time() - start_time
+        result.finished_at = datetime.utcnow()
+
+        return result
+
+    async def _execute_step(
+        self,
+        step: ProcessStep,
+        ctx: dict[str, str],
+        approval_callback: ApprovalCallback | None,
+        dry_run: bool,
+    ) -> StepResult:
+        """Execute a single step in the chain."""
+        step_start = time.time()
+        step_result = StepResult(step_name=step.name, status=StepStatus.RUNNING)
+
+        # Check dependencies
+        for dep in step.depends_on:
+            dep_result = self._step_results.get(dep)
+            if not dep_result or dep_result.status != StepStatus.COMPLETED:
+                step_result.status = StepStatus.FAILED
+                step_result.error = f"Dependency '{dep}' not completed"
+                return step_result
+
+        # Enrich prompt with context
+        enriched_prompt = self.context_engine.enrich_prompt(step.prompt, ctx)
+
+        logger.info(f"Step '{step.name}': enriched prompt = {enriched_prompt[:100]}...")
+
+        # Approval gate
+        if step.approval == ApprovalMode.MANUAL:
+            if approval_callback:
+                try:
+                    approved, approved_by = await approval_callback(step.name, enriched_prompt)
+                except Exception as e:
+                    step_result.status = StepStatus.FAILED
+                    step_result.error = f"Approval callback error: {e}"
+                    return step_result
+
+                if not approved:
+                    step_result.status = StepStatus.AWAITING_APPROVAL
+                    return step_result
+
+                step_result.approved_by = approved_by
+                step_result.approved_at = datetime.utcnow()
+                step_result.status = StepStatus.APPROVED
+            else:
+                # No callback provided — pause for manual approval
+                step_result.status = StepStatus.AWAITING_APPROVAL
+                return step_result
+
+        # Dry run — just analyze, don't call LLM
+        if dry_run:
+            analysis = self.guard.analyze_only(enriched_prompt)
+            step_result.status = StepStatus.COMPLETED
+            step_result.duration_seconds = time.time() - step_start
+            logger.info(f"Step '{step.name}' (dry-run): {analysis}")
+            return step_result
+
+        # Execute through PromptGuard
+        try:
+            response = await self.guard(enriched_prompt, extra_context=ctx)
+            step_result.response = response
+            step_result.status = StepStatus.COMPLETED
+
+            self._audit_step(step.name, enriched_prompt, response.content)
+
+        except Exception as e:
+            step_result.status = StepStatus.FAILED
+            step_result.error = str(e)
+            logger.error(f"Step '{step.name}' failed: {e}")
+
+            if step.rollback:
+                logger.warning(f"Step '{step.name}' has rollback=true — rollback should be triggered")
+                step_result.status = StepStatus.ROLLED_BACK
+
+        step_result.duration_seconds = time.time() - step_start
+        return step_result
+
+    def get_audit_log(self) -> list[dict[str, Any]]:
+        return [e.model_dump() for e in self.audit_log]
+
+    def _audit_step(self, step_name: str, prompt: str, response: str) -> None:
+        entry = AuditEntry(
+            action="process_step",
+            query=prompt,
+            response_summary=response[:200] if response else "",
+            step_name=step_name,
+            process_name=self.process_config.process,
+        )
+        self.audit_log.append(entry)
+
+    @staticmethod
+    def _load_process_config(path: Path) -> ProcessConfig:
+        with open(path) as f:
+            raw = yaml.safe_load(f) or {}
+
+        steps = []
+        for s in raw.get("steps", []):
+            steps.append(ProcessStep(**s))
+
+        return ProcessConfig(
+            process=raw.get("process", "unnamed"),
+            description=raw.get("description", ""),
+            context_sources=raw.get("context_sources", []),
+            steps=steps,
+        )

prellm-0.1.12/promptguard/cli.py

@@ -0,0 +1,175 @@
+"""PromptGuard CLI — run prompts, execute process chains, and manage configs."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+app = typer.Typer(
+    name="promptguard",
+    help="PromptGuard — LLM prompt middleware for bias detection, standardization, and DevOps process chains.",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def run(
+    query: str = typer.Argument(..., help="The prompt/query to process"),
+    config: Path = typer.Option("rules.yaml", "--config", "-c", help="Path to YAML config"),
+    model: str = typer.Option("gpt-4o-mini", "--model", "-m", help="LLM model to use"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-d", help="Analyze only, don't call LLM"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+):
+    """Run a single query through PromptGuard."""
+    from promptguard.core import PromptGuard
+
+    guard = PromptGuard(config_path=config)
+
+    if dry_run:
+        result = guard.analyze_only(query)
+        if json_output:
+            typer.echo(json.dumps(result, indent=2, default=str))
+        else:
+            typer.echo(f"🔍 Analysis for: {query}")
+            typer.echo(f"   Needs clarification: {result['needs_clarify']}")
+            typer.echo(f"   Patterns detected: {result['patterns']}")
+            typer.echo(f"   Ambiguity flags: {result['ambiguity_flags']}")
+            typer.echo(f"   Enriched query: {result['enriched']}")
+        return
+
+    result = asyncio.run(_run_guard(guard, query, model))
+
+    if json_output:
+        typer.echo(result.model_dump_json(indent=2))
+    else:
+        status = "✅ clarified" if result.clarified else "📝 direct"
+        typer.echo(f"\n{'='*60}")
+        typer.echo(f"🛡️  PromptGuard [{status}] via {result.model_used}")
+        typer.echo(f"{'='*60}")
+        typer.echo(f"\n{result.content}")
+        if result.analysis and result.analysis.detected_patterns:
+            typer.echo(f"\n⚠️  Detected: {', '.join(result.analysis.detected_patterns)}")
+        typer.echo(f"\n{'='*60}")
+
+
+@app.command()
+def process(
+    config: Path = typer.Argument(..., help="Path to process chain YAML"),
+    guard_config: Path = typer.Option("rules.yaml", "--guard-config", "-g", help="Path to guard YAML config"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-d", help="Analyze steps without calling LLM"),
+    json_output: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
+    env: Optional[str] = typer.Option(None, "--env", "-e", help="Environment override (e.g., production)"),
+):
+    """Execute a DevOps process chain."""
+    from promptguard.chains.process_chain import ProcessChain
+
+    chain = ProcessChain(config_path=config, guard_config_path=guard_config)
+
+    extra = {}
+    if env:
+        extra["env"] = env
+
+    result = asyncio.run(chain.execute(extra_context=extra, dry_run=dry_run))
+
+    if json_output:
+        typer.echo(result.model_dump_json(indent=2))
+    else:
+        typer.echo(f"\n{'='*60}")
+        typer.echo(f"🔗 Process: {result.process_name}")
+        typer.echo(f"   Status: {'✅ Completed' if result.completed else '⏸️  Incomplete'}")
+        typer.echo(f"   Duration: {result.total_duration_seconds:.2f}s")
+        typer.echo(f"{'='*60}")
+        for step in result.steps:
+            icon = {
+                "completed": "✅",
+                "failed": "❌",
+                "awaiting_approval": "⏳",
+                "rolled_back": "↩️",
+            }.get(step.status.value, "🔄")
+            typer.echo(f"   {icon} {step.step_name}: {step.status.value} ({step.duration_seconds:.2f}s)")
+            if step.error:
+                typer.echo(f"      Error: {step.error}")
+        typer.echo(f"{'='*60}")
+
+
+@app.command()
+def analyze(
+    query: str = typer.Argument(..., help="Query to analyze for bias/ambiguity"),
+    config: Path = typer.Option("rules.yaml", "--config", "-c", help="Path to YAML config"),
+):
+    """Analyze a query without calling any LLM (bias detection + ambiguity check)."""
+    from promptguard.core import PromptGuard
+
+    guard = PromptGuard(config_path=config)
+    result = guard.analyze_only(query)
+
+    typer.echo(f"\n🔍 Analysis: {query}")
+    typer.echo(f"   Needs clarification: {'⚠️  YES' if result['needs_clarify'] else '✅ NO'}")
+    if result["patterns"]:
+        typer.echo(f"   Patterns: {', '.join(result['patterns'])}")
+    if result["ambiguity_flags"]:
+        typer.echo(f"   Flags: {', '.join(result['ambiguity_flags'])}")
+    if result["readability"] is not None:
+        typer.echo(f"   Readability: {result['readability']:.1f}")
+    typer.echo(f"   Enriched: {result['enriched']}")
+
+
+@app.command()
+def init(
+    output: Path = typer.Option("rules.yaml", "--output", "-o", help="Output path for config"),
+    devops: bool = typer.Option(False, "--devops", help="Include DevOps-specific patterns"),
+):
+    """Generate a starter rules.yaml config file."""
+    import yaml
+
+    config = {
+        "bias_patterns": [
+            {"regex": "(zawsze|always)\\s+\\w+", "action": "clarify", "severity": "medium",
+             "description": "Absolute quantifier"},
+            {"regex": "(tylko|only|just)\\s+\\w+", "action": "clarify", "severity": "low",
+             "description": "Exclusive quantifier"},
+        ],
+        "clarify_template": "[KONTEKST]: Podaj szczegóły lub alternatywy dla: {query}",
+        "max_retries": 3,
+        "policy": "strict",
+        "models": {
+            "fallback": ["gpt-4o-mini", "llama3"],
+            "timeout": 30,
+            "max_tokens": 2048,
+        },
+    }
+
+    if devops:
+        config["bias_patterns"].extend([
+            {"regex": "(deploy|zdeployuj)\\s+(na|to)\\s+(prod|production)", "action": "clarify",
+             "severity": "critical", "description": "Production deployment without context"},
+            {"regex": "(delete|drop|remove|usuń)\\s+(database|db|baz)", "action": "clarify",
+             "severity": "critical", "description": "Destructive DB operation"},
+            {"regex": "(restart|reboot|kill)\\s+(server|service|pod)", "action": "clarify",
+             "severity": "high", "description": "Service disruption"},
+            {"regex": "(scale|skaluj)\\s+(down|up|to\\s+\\d+)", "action": "clarify",
+             "severity": "high", "description": "Scaling operation"},
+        ])
+        config["context_sources"] = [
+            {"env": ["CLUSTER", "NAMESPACE", "GIT_SHA", "ENV"]},
+            {"git": ["branch", "short_sha", "last_commit_msg"]},
+            {"system": ["hostname", "os"]},
+        ]
+
+    with open(output, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+    typer.echo(f"✅ Config written to {output}")
+
+
+async def _run_guard(guard, query: str, model: str):
+    return await guard(query, model=model)
+
+
+if __name__ == "__main__":
+    app()

prellm-0.1.12/promptguard/core.py

@@ -0,0 +1,171 @@
+"""Core PromptGuard — the main entry point for prompt analysis, enrichment, and LLM calls."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from promptguard.analyzers.bias_detector import BiasDetector
+from promptguard.analyzers.context_engine import ContextEngine
+from promptguard.models import (
+    AuditEntry,
+    BiasPattern,
+    GuardConfig,
+    GuardResponse,
+    ModelConfig,
+    Policy,
+)
+
+logger = logging.getLogger("promptguard")
+
+
+class PromptGuard:
+    """Main PromptGuard middleware — analyze, enrich, and proxy LLM calls.
+
+    Usage:
+        guard = PromptGuard("rules.yaml")
+        result = await guard("Zdeployuj na produkcję", model="gpt-4o-mini")
+
+    Or with inline config:
+        guard = PromptGuard(config=GuardConfig(policy=Policy.DEVOPS))
+        result = await guard("Deploy the app")
+    """
+
+    def __init__(
+        self,
+        config_path: str | Path | None = None,
+        config: GuardConfig | None = None,
+    ):
+        if config:
+            self.config = config
+        elif config_path:
+            self.config = self._load_config(Path(config_path))
+        else:
+            self.config = GuardConfig()
+
+        self.detector = BiasDetector(self.config.bias_patterns or None)
+        self.context_engine = ContextEngine(self.config.context_sources)
+        self.audit_log: list[AuditEntry] = []
+
+    async def __call__(
+        self,
+        query: str,
+        model: str | None = None,
+        extra_context: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> GuardResponse:
+        """Analyze query, enrich if needed, call LLM, validate response."""
+        import litellm
+
+        target_model = model or self.config.models.fallback[0]
+
+        # Step 1: Analyze
+        analysis = self.detector.analyze(query)
+        analysis.original_query = query
+
+        # Step 2: Enrich if needed
+        if analysis.needs_clarify:
+            enriched = self.config.clarify_template.format(query=query)
+            enriched = self.context_engine.enrich_prompt(enriched, extra_context)
+            analysis.enriched_query = enriched
+        else:
+            enriched = self.context_engine.enrich_prompt(query, extra_context)
+            analysis.enriched_query = enriched
+
+        # Step 3: Call LLM with retry/fallback
+        response_content = ""
+        model_used = target_model
+        retries = 0
+
+        fallback_models = [target_model] + [
+            m for m in self.config.models.fallback if m != target_model
+        ]
+
+        for attempt_model in fallback_models:
+            for attempt in range(self.config.max_retries):
+                try:
+                    resp = await litellm.acompletion(
+                        model=attempt_model,
+                        messages=[{"role": "user", "content": enriched}],
+                        max_tokens=self.config.models.max_tokens,
+                        timeout=self.config.models.timeout,
+                        **kwargs,
+                    )
+                    response_content = resp.choices[0].message.content
+                    model_used = attempt_model
+                    break
+                except Exception as e:
+                    retries += 1
+                    logger.warning(f"Attempt {attempt + 1} with {attempt_model} failed: {e}")
+            if response_content:
+                break
+
+        # Step 4: Build response
+        result = GuardResponse(
+            content=response_content or "No response from any model.",
+            clarified=analysis.needs_clarify,
+            needs_more_context=analysis.needs_clarify and not response_content,
+            model_used=model_used,
+            analysis=analysis,
+            retries=retries,
+        )
+
+        # Audit
+        self._audit("query", query, result, model_used)
+
+        return result
+
+    def analyze_only(self, query: str) -> dict[str, Any]:
+        """Run analysis without calling LLM — useful for dry-run / testing."""
+        analysis = self.detector.analyze(query)
+        return {
+            "needs_clarify": analysis.needs_clarify,
+            "patterns": analysis.detected_patterns,
+            "ambiguity_flags": analysis.ambiguity_flags,
+            "readability": analysis.readability_score,
+            "enriched": self.config.clarify_template.format(query=query)
+            if analysis.needs_clarify
+            else query,
+        }
+
+    def get_audit_log(self) -> list[dict[str, Any]]:
+        """Return audit log as list of dicts."""
+        return [entry.model_dump() for entry in self.audit_log]
+
+    def _audit(self, action: str, query: str, response: GuardResponse, model: str) -> None:
+        entry = AuditEntry(
+            action=action,
+            query=query,
+            response_summary=response.content[:200] if response.content else "",
+            model=model,
+            policy=self.config.policy,
+        )
+        self.audit_log.append(entry)
+
+    @staticmethod
+    def _load_config(path: Path) -> GuardConfig:
+        """Load config from YAML file."""
+        with open(path) as f:
+            raw = yaml.safe_load(f) or {}
+
+        # Normalize bias_patterns
+        patterns = []
+        for p in raw.get("bias_patterns", []):
+            if isinstance(p, dict):
+                patterns.append(BiasPattern(**p))
+
+        models_raw = raw.get("models", {})
+        models = ModelConfig(**models_raw) if isinstance(models_raw, dict) else ModelConfig()
+
+        return GuardConfig(
+            bias_patterns=patterns,
+            clarify_template=raw.get("clarify_template", GuardConfig.model_fields["clarify_template"].default),
+            max_retries=raw.get("max_retries", 3),
+            policy=Policy(raw.get("policy", "strict")),
+            models=models,
+            context_sources=raw.get("context_sources", []),
+        )

prellm-0.1.12/promptguard/models.py

@@ -0,0 +1,135 @@
+"""Data models for PromptGuard — all inputs/outputs are Pydantic v2 validated."""
+
+from __future__ import annotations
+
+import enum
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+# --- Enums ---
+
+class Policy(str, enum.Enum):
+    STRICT = "strict"
+    LENIENT = "lenient"
+    DEVOPS = "devops"
+
+
+class ApprovalMode(str, enum.Enum):
+    AUTO = "auto"
+    MANUAL = "manual"
+
+
+class StepStatus(str, enum.Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    AWAITING_APPROVAL = "awaiting_approval"
+    APPROVED = "approved"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    ROLLED_BACK = "rolled_back"
+
+
+# --- Config models ---
+
+class BiasPattern(BaseModel):
+    regex: str
+    action: str = "clarify"
+    severity: str = "medium"
+    description: str = ""
+
+
+class ModelConfig(BaseModel):
+    fallback: list[str] = Field(default_factory=lambda: ["gpt-4o-mini"])
+    timeout: int = 30
+    max_tokens: int = 2048
+
+
+class GuardConfig(BaseModel):
+    """Top-level YAML config model."""
+    bias_patterns: list[BiasPattern] = Field(default_factory=list)
+    clarify_template: str = "[KONTEKST]: Podaj szczegóły lub alternatywy dla: {query}"
+    max_retries: int = 3
+    policy: Policy = Policy.STRICT
+    models: ModelConfig = Field(default_factory=ModelConfig)
+    context_sources: list[dict[str, Any]] = Field(default_factory=list)
+
+
+# --- Process chain models ---
+
+class ProcessStep(BaseModel):
+    name: str
+    prompt: str
+    policy: Policy = Policy.STRICT
+    approval: ApprovalMode = ApprovalMode.AUTO
+    rollback: bool = False
+    timeout: int = 300
+    depends_on: list[str] = Field(default_factory=list)
+
+
+class ProcessConfig(BaseModel):
+    process: str
+    description: str = ""
+    context_sources: list[dict[str, Any]] = Field(default_factory=list)
+    steps: list[ProcessStep]
+
+
+# --- Runtime models ---
+
+class AnalysisResult(BaseModel):
+    """Result of query analysis — what was detected and what was done."""
+    needs_clarify: bool = False
+    detected_patterns: list[str] = Field(default_factory=list)
+    enriched_query: str = ""
+    original_query: str = ""
+    readability_score: float | None = None
+    ambiguity_flags: list[str] = Field(default_factory=list)
+
+
+class GuardResponse(BaseModel):
+    """Response from PromptGuard — the final output after analysis and LLM call."""
+    content: str
+    clarified: bool = False
+    needs_more_context: bool = False
+    model_used: str = ""
+    analysis: AnalysisResult | None = None
+    retries: int = 0
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+
+class StepResult(BaseModel):
+    """Result of a single process chain step."""
+    step_name: str
+    status: StepStatus = StepStatus.PENDING
+    response: GuardResponse | None = None
+    approved_by: str | None = None
+    approved_at: datetime | None = None
+    error: str | None = None
+    duration_seconds: float = 0.0
+
+
+class ProcessResult(BaseModel):
+    """Result of a full process chain execution."""
+    process_name: str
+    steps: list[StepResult] = Field(default_factory=list)
+    completed: bool = False
+    total_duration_seconds: float = 0.0
+    started_at: datetime = Field(default_factory=datetime.utcnow)
+    finished_at: datetime | None = None
+
+
+# --- Audit models ---
+
+class AuditEntry(BaseModel):
+    """Single audit log entry for traceability."""
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    action: str
+    query: str = ""
+    response_summary: str = ""
+    model: str = ""
+    policy: Policy = Policy.STRICT
+    step_name: str | None = None
+    process_name: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)

prellm-0.1.12/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "prellm"
+version = "0.1.12"
+description = "PromptGuard - Lightweight LLM prompt middleware for bias detection, standardization, and DevOps process chains via YAML config, supporting context injection and multi-provider orchestration."
+authors = [
+    "Softreck <tom@sapletta.com>",
+    "Tom Sapletta <tom@sapletta.com>",
+]
+license = "Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/softreck/gllm"
+keywords = ["llm", "prompt-engineering", "bias-detection", "devops", "litellm"]
+packages = [{include = "promptguard"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+litellm = "^1.40"
+pydantic = "^2.0"
+pyyaml = "^6.0"
+nltk = "^3.8"
+typer = {version = "^0.12", extras = ["all"]}
+textstat = "^0.7"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0"
+pytest-asyncio = "^0.23"
+pytest-mock = "^3.12"
+ruff = "^0.4"
+
+[tool.poetry.scripts]
+promptguard = "promptguard.cli:app"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]