willuri 0.1.0__py3-none-any.whl

willuri/__init__.py

@@ -0,0 +1,29 @@
+"""willuri: Universal NL, URI, and specialized LLM router SSOT for Paxlet / Willman."""
+from .domains import DOMAIN_REGISTRY, DomainProfile, classify_domain
+from .router import UriRouter
+from .client import query_ollama
+from .dsl import parse_uri, with_params, format_uri, validate_uri
+from .models import MODEL_SPECS, get_model_for_domain, generate_modelfile
+from .prompts import build_routing_prompt, build_decomposition_prompt
+from .semantic import SemanticMatcher, compute_similarity, tokenize
+
+__version__ = "0.1.0"
+__all__ = [
+    "UriRouter",
+    "classify_domain",
+    "DOMAIN_REGISTRY",
+    "DomainProfile",
+    "query_ollama",
+    "parse_uri",
+    "with_params",
+    "format_uri",
+    "validate_uri",
+    "MODEL_SPECS",
+    "get_model_for_domain",
+    "generate_modelfile",
+    "build_routing_prompt",
+    "build_decomposition_prompt",
+    "SemanticMatcher",
+    "compute_similarity",
+    "tokenize",
+]

willuri/cli.py

@@ -0,0 +1,58 @@
+"""CLI for willuri router."""
+import argparse
+import json
+import sys
+from .router import UriRouter
+from .domains import classify_domain
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="willuri", description="Willuri: NL to URI Process Router")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("domains", help="List all registered domains and specialized models")
+
+    classify_cmd = sub.add_parser("classify", help="Classify instruction domain")
+    classify_cmd.add_argument("instruction", help="Natural language instruction")
+
+    route_cmd = sub.add_parser("route", help="Route instruction to URI via specialized LLM")
+    route_cmd.add_argument("instruction", help="Natural language instruction")
+    route_cmd.add_argument("--model", help="Override LLM model")
+    route_cmd.add_argument("--input", default="{}", help="Input JSON data")
+
+    args = parser.parse_args()
+
+    if args.command == "domains":
+        from .domains import DOMAIN_REGISTRY
+        res = {
+            name: {
+                "description": prof.description,
+                "preferred_models": prof.preferred_models,
+                "uri_prefixes": prof.uri_prefixes,
+                "keywords": prof.keywords,
+            }
+            for name, prof in DOMAIN_REGISTRY.items()
+        }
+        print(json.dumps(res, indent=2, ensure_ascii=False))
+        return 0
+
+    if args.command == "classify":
+        domain = classify_domain(args.instruction)
+        print(json.dumps({
+            "domain": domain.name,
+            "description": domain.description,
+            "preferred_models": domain.preferred_models,
+            "uri_prefixes": domain.uri_prefixes,
+        }, indent=2, ensure_ascii=False))
+        return 0
+
+    if args.command == "route":
+        input_data = json.loads(args.input)
+        router = UriRouter()
+        result = router.route(args.instruction, input_data=input_data, model_override=args.model)
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0 if result.get("status") in ("ok", "routed") else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

willuri/client.py

@@ -0,0 +1,37 @@
+"""Specialized LLM inference client for URI parameter extraction and routing."""
+from __future__ import annotations
+import json
+import os
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+
+def query_ollama(
+    model: str,
+    prompt: str,
+    schema: Optional[Dict[str, Any]] = None,
+    timeout: float = 30.0,
+    host: str = "http://127.0.0.1:11434",
+) -> Dict[str, Any]:
+    """Execute a structured generation query against local Ollama endpoint."""
+    url = f"{host.rstrip('/')}/api/generate"
+    payload: Dict[str, Any] = {
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+    }
+    if schema:
+        payload["format"] = schema
+    else:
+        payload["format"] = "json"
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    with urllib.request.urlopen(req, timeout=timeout) as response:
+        result = json.loads(response.read().decode("utf-8"))
+
+    raw_response = result.get("response", "").strip()
+    try:
+        return json.loads(raw_response)
+    except json.JSONDecodeError:
+        return {"raw": raw_response}

willuri/domains.py

@@ -0,0 +1,93 @@
+"""Specialized domain definitions and model bindings for URI routing."""
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass(frozen=True)
+class DomainProfile:
+    name: str
+    description: str
+    preferred_models: List[str]
+    uri_prefixes: List[str]
+    keywords: List[str]
+
+
+DOMAIN_REGISTRY: Dict[str, DomainProfile] = {
+    "code": DomainProfile(
+        name="code",
+        description="Software code synthesis, syntax verification, refactoring, and AST transformations.",
+        preferred_models=["qwen2.5-coder:3b", "willman-nlp:qwen2.5-3b"],
+        uri_prefixes=[
+            "willman://operation/code.",
+            "willman://operation/python.",
+            "willman://operation/git.resolve_conflicts",
+            "willman://operation/patch.",
+        ],
+        keywords=["kod", "funkcja", "refaktoryzacja", "błąd", "python", "rust", "skrypt", "code", "bug", "patch"],
+    ),
+    "api_ops": DomainProfile(
+        name="api_ops",
+        description="Structured API calls, GitHub issue tracking, Dockuri containers, Thunderbird mail, and filesystem operations.",
+        preferred_models=["willman-nlp:qwen2.5-3b", "granite4.1:3b"],
+        uri_prefixes=[
+            "willman://operation/github.",
+            "willman://operation/dockuri.",
+            "willman://operation/files.",
+            "willman://operation/thunderbird",
+            "dockuri://",
+        ],
+        keywords=["github", "issue", "zgłoszenie", "plik", "dockuri", "kontener", "katalog", "read", "view", "email", "mail", "thunderbird", "poczta", "wiadomości"],
+    ),
+    "planning": DomainProfile(
+        name="planning",
+        description="Sprint planning, ticket decomposition, subtask scheduling, and DAG dependencies.",
+        preferred_models=["willman-nlp:qwen2.5-3b", "qwen3.5:2b", "llama3.2:3b"],
+        uri_prefixes=[
+            "willman://operation/koru.",
+            "willman://operation/planfile.",
+            "willman://operation/schedule.",
+        ],
+        keywords=["ticket", "zadanie", "plan", "sprint", "koru", "zależności", "podzadanie", "split", "board"],
+    ),
+    "text": DomainProfile(
+        name="text",
+        description="Fast natural language text transformations, string normalization, whitespace, formatting.",
+        preferred_models=["willman-nlp:qwen2.5-3b", "willman-nlp:qwen2.5-1.5b"],
+        uri_prefixes=[
+            "willman://operation/text.",
+        ],
+        keywords=["tekst", "odstępy", "wielkie", "litery", "normalize", "format", "string", "whitespace"],
+    ),
+}
+
+
+def classify_domain(instruction: str, catalog_uris: Optional[List[str]] = None) -> DomainProfile:
+    """Classify the target domain from natural language instruction and optional URI catalog."""
+    lowered = instruction.lower()
+
+    # Keyword and prefix matching score
+    best_domain = DOMAIN_REGISTRY["text"]
+    best_score = -1
+
+    for domain in DOMAIN_REGISTRY.values():
+        score = 0
+        for kw in domain.keywords:
+            if kw in lowered:
+                score += 2
+        if catalog_uris:
+            for uri in catalog_uris:
+                if any(uri.startswith(prefix) for prefix in domain.uri_prefixes):
+                    score += 1
+        if score > best_score:
+            best_score = score
+            best_domain = domain
+
+    return best_domain
+
+
+def recommend_model(instruction: str, catalog_uris: Optional[List[str]] = None) -> str:
+    """Recommend the best specialized model for an instruction."""
+    profile = classify_domain(instruction, catalog_uris)
+    return profile.preferred_models[0]
+

willuri/dsl.py

@@ -0,0 +1,53 @@
+"""Universal URI DSL for Paxlet / Willman ecosystem."""
+from __future__ import annotations
+import json
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+from typing import Any, Dict, Tuple, Set
+
+SUPPORTED_SCHEMES: Set[str] = {"willman", "proc", "dockuri", "paxlet"}
+
+
+def with_params(uri: str, params: Dict[str, Any]) -> str:
+    """Encode query parameters onto a base URI with deterministic JSON encoding."""
+    if urlsplit(uri).query:
+        raise ValueError("Base URI already has query parameters")
+    if not isinstance(params, dict):
+        raise ValueError("URI parameters must be a JSON object")
+    query = urlencode([
+        (str(key), json.dumps(value, ensure_ascii=False, separators=(",", ":")))
+        for key, value in sorted(params.items())
+    ])
+    return uri + ("?" + query if query else "")
+
+
+def parse_uri(uri: str) -> Tuple[str, Dict[str, Any]]:
+    """Parse a URI into base URI and decoded parameter dictionary."""
+    parsed = urlsplit(uri)
+    if parsed.scheme not in SUPPORTED_SCHEMES or not parsed.netloc or parsed.fragment:
+        raise ValueError(f"Expected valid URI scheme in {SUPPORTED_SCHEMES} without fragment, got: {uri}")
+    values: Dict[str, Any] = {}
+    for key, raw in parse_qsl(parsed.query, keep_blank_values=True, strict_parsing=True):
+        if key in values:
+            raise ValueError(f"Duplicate URI parameter: {key}")
+        try:
+            values[key] = json.loads(raw)
+        except json.JSONDecodeError:
+            values[key] = raw
+    base = urlunsplit((parsed.scheme, parsed.netloc, parsed.path, "", ""))
+    return base, values
+
+
+def format_uri(scheme: str, entity_type: str, path: str, params: Dict[str, Any] | None = None) -> str:
+    """Construct a canonical URI for an operation, container, or task."""
+    clean_path = path.lstrip("/")
+    base = f"{scheme}://{entity_type}/{clean_path}"
+    return with_params(base, params) if params else base
+
+
+def validate_uri(uri: str) -> bool:
+    """Check whether a URI is syntactically valid."""
+    try:
+        parse_uri(uri)
+        return True
+    except Exception:
+        return False

willuri/models.py

@@ -0,0 +1,90 @@
+"""Central model catalog and configuration templates for small specialized LLMs."""
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+
+@dataclass(frozen=True)
+class ModelSpec:
+    name: str
+    family: str
+    parameters: str
+    vram_mb: int
+    context_tokens: int
+    domains: List[str]
+    description: str
+    system_prompt: str
+
+
+MODEL_SPECS: Dict[str, ModelSpec] = {
+    "qwen2.5-coder:3b": ModelSpec(
+        name="qwen2.5-coder:3b",
+        family="qwen2.5",
+        parameters="3B",
+        vram_mb=2100,
+        context_tokens=8192,
+        domains=["code"],
+        description="High-precision code synthesis, AST analysis, Git conflicts, and automated patches.",
+        system_prompt="You are a code synthesis and AST transformation specialist. Return structured code or JSON.",
+    ),
+    "willman-nlp:qwen2.5-3b": ModelSpec(
+        name="willman-nlp:qwen2.5-3b",
+        family="qwen2.5",
+        parameters="3B",
+        vram_mb=2100,
+        context_tokens=8192,
+        domains=["code", "api_ops", "planning", "text"],
+        description="Paxlet tuned generalist model for NL routing, URI parameter extraction, and operations.",
+        system_prompt="You are the Paxlet Willman NL-to-URI routing engine. Return exact JSON operations.",
+    ),
+    "granite4.1:3b": ModelSpec(
+        name="granite4.1:3b",
+        family="granite",
+        parameters="3B",
+        vram_mb=1900,
+        context_tokens=8192,
+        domains=["api_ops"],
+        description="Enterprise tool-calling and structured API operations (GitHub, Dockuri, filesystem).",
+        system_prompt="You are an API operations specialist. Generate exact JSON API parameters and URI targets.",
+    ),
+    "llama3.2:3b": ModelSpec(
+        name="llama3.2:3b",
+        family="llama",
+        parameters="3B",
+        vram_mb=2200,
+        context_tokens=8192,
+        domains=["planning"],
+        description="Sprint ticket decomposition, dependency DAG planning, and agile backlog management.",
+        system_prompt="You are a planning and sprint scheduling specialist. Break tasks into structured DAG steps.",
+    ),
+    "qwen2.5:1.5b": ModelSpec(
+        name="qwen2.5:1.5b",
+        family="qwen2.5",
+        parameters="1.5B",
+        vram_mb=1100,
+        context_tokens=4096,
+        domains=["text"],
+        description="Ultra-lightweight text normalization, string formatting, and fast status checks.",
+        system_prompt="You are a fast text transformer. Clean, normalize, and format text strings concisely.",
+    ),
+}
+
+
+def get_model_for_domain(domain: str) -> str:
+    """Return the primary recommended model for a given domain."""
+    for name, spec in MODEL_SPECS.items():
+        if domain in spec.domains:
+            return name
+    return "willman-nlp:qwen2.5-3b"
+
+
+def generate_modelfile(model_name: str, context_tokens: int = 8192) -> str:
+    """Generate an Ollama Modelfile content string for a model."""
+    spec = MODEL_SPECS.get(model_name)
+    base_from = model_name
+    system = spec.system_prompt if spec else "You are an autonomous engineering operations agent."
+    return f"""FROM {base_from}
+PARAMETER num_ctx {context_tokens}
+PARAMETER temperature 0.1
+SYSTEM \"\"\"{system}\"\"\"
+"""

willuri/prompts.py

@@ -0,0 +1,62 @@
+"""Standard system prompt templates and structured JSON schemas for willuri."""
+from __future__ import annotations
+import json
+from typing import Any, Dict, List, Optional
+
+
+def build_routing_prompt(
+    domain_name: str,
+    catalog: List[Dict[str, Any]],
+    instruction: str,
+    input_data: Optional[Dict[str, Any]] = None,
+) -> str:
+    """Build a deterministic routing prompt for small LLMs."""
+    ops_lines = []
+    for op in catalog:
+        uri = op.get("uri", "")
+        desc = op.get("description", "")
+        ops_lines.append(f"- {uri}: {desc}")
+    catalog_str = "\n".join(ops_lines) if ops_lines else "No predefined operations; synthesize best URI."
+
+    return f"""You are a specialized URI Router for domain '{domain_name}'.
+Available target process URIs:
+{catalog_str}
+
+User Instruction: {instruction}
+Input context: {json.dumps(input_data or {}, ensure_ascii=False)}
+
+Respond ONLY with a JSON object conforming to this schema:
+{{
+  "uri": "exact target operation URI",
+  "input": {{ "param1": "value1" }},
+  "domain": "{domain_name}",
+  "reasoning": "brief justification"
+}}
+"""
+
+
+def build_decomposition_prompt(ticket_title: str, ticket_description: str, catalog: List[Dict[str, Any]]) -> str:
+    """Build a prompt for breaking down a high-level sprint ticket into discrete operations."""
+    ops_lines = [f"- {op.get('uri')}: {op.get('description', '')}" for op in catalog]
+    catalog_str = "\n".join(ops_lines)
+
+    return f"""You are a sprint ticket decomposition specialist.
+Break down the following ticket into an ordered sequence of discrete URI operation steps.
+
+Available operations:
+{catalog_str}
+
+Ticket: {ticket_title}
+Description: {ticket_description}
+
+Respond ONLY with a JSON object:
+{{
+  "subtasks": [
+    {{
+      "title": "Subtask title",
+      "uri": "willman://operation/...",
+      "input": {{}}
+    }}
+  ]
+}}
+"""

willuri/router.py

@@ -0,0 +1,155 @@
+"""Core URI Router converting Natural Language into targeted URI operations."""
+from __future__ import annotations
+import json
+import time
+from typing import Any, Dict, List, Optional
+
+from .domains import classify_domain, DOMAIN_REGISTRY, DomainProfile
+from .client import query_ollama
+
+
+class UriRouter:
+    """Specialized NL-to-URI process router selecting domain-specific models."""
+
+    def __init__(
+        self,
+        catalog: Optional[List[Dict[str, Any]]] = None,
+        ollama_host: str = "http://127.0.0.1:11434",
+        provider: Optional[Any] = None,
+    ):
+        self.catalog = list(catalog or [])
+        self.ollama_host = ollama_host
+        self.provider = provider or query_ollama
+
+    def add_operation(self, uri: str, description: str, input_schema: Optional[Dict[str, Any]] = None):
+        self.catalog.append({
+            "uri": uri,
+            "description": description,
+            "input_schema": input_schema or {},
+        })
+
+    def route(
+        self,
+        instruction: str,
+        input_data: Optional[Dict[str, Any]] = None,
+        model_override: Optional[str] = None,
+        timeout: float = 20.0,
+    ) -> Dict[str, Any]:
+        """Route an NL instruction to the best URI operation using a domain-specialized small LLM."""
+        start_time = time.monotonic()
+
+        # AC: empty catalog unsupported
+        if not self.catalog:
+            return {
+                "status": "unsupported",
+                "error": "empty_catalog",
+                "message": "Empty catalog: routing unsupported without registered operations",
+                "uri": None,
+                "input": {},
+                "domain": None,
+                "model_used": None,
+                "duration_ms": 0.0,
+            }
+
+        catalog_uris = [op["uri"] for op in self.catalog]
+        domain: DomainProfile = classify_domain(instruction, catalog_uris)
+        selected_model = model_override or domain.preferred_models[0]
+
+        # Build compact catalog prompt
+        ops_text = []
+        for op in self.catalog:
+            schema_desc = f" (schema: {json.dumps(op.get('input_schema', {}))})" if op.get("input_schema") else ""
+            ops_text.append(f"- {op['uri']}: {op.get('description', '')}{schema_desc}")
+        catalog_str = "\n".join(ops_text)
+
+        prompt = f"""You are a specialized URI Router for domain '{domain.name}'.
+Given the following available registered process URIs:
+{catalog_str}
+
+User Instruction: {instruction}
+Input context: {json.dumps(input_data or {}, ensure_ascii=False)}
+
+Respond ONLY with a JSON object containing:
+- "uri": exact matched registered process URI from the list above, or null if no registered URI matches
+- "input": dictionary of extracted arguments matching the operation schema
+- "domain": "{domain.name}"
+"""
+        try:
+            response = self.provider(
+                model=selected_model,
+                prompt=prompt,
+                timeout=timeout,
+                host=self.ollama_host,
+            )
+        except Exception as ex:
+            duration_ms = round((time.monotonic() - start_time) * 1000, 2)
+            return {
+                "status": "unsupported",
+                "error": "provider_unavailable",
+                "message": f"LLM provider error: {ex}",
+                "uri": None,
+                "input": {},
+                "domain": domain.name,
+                "model_used": selected_model,
+                "duration_ms": duration_ms,
+            }
+
+        duration_ms = round((time.monotonic() - start_time) * 1000, 2)
+
+        matched_uri = response.get("uri")
+        if not matched_uri:
+            return {
+                "status": "unsupported",
+                "error": "no_matched_uri",
+                "message": "Instruction could not be resolved to any registered URI",
+                "uri": None,
+                "input": {},
+                "domain": domain.name,
+                "model_used": selected_model,
+                "duration_ms": duration_ms,
+                "raw": response,
+            }
+
+        # AC: only selected registered URI yields success; reject invented operations
+        target_op = next((op for op in self.catalog if op.get("uri") == matched_uri), None)
+        if not target_op:
+            return {
+                "status": "unsupported",
+                "error": "unregistered_uri",
+                "message": f"Operation '{matched_uri}' is not registered in catalog",
+                "uri": None,
+                "input": {},
+                "domain": domain.name,
+                "model_used": selected_model,
+                "duration_ms": duration_ms,
+                "raw": response,
+            }
+
+        input_args = response.get("input", {})
+        schema = target_op.get("input_schema")
+        if schema:
+            try:
+                import jsonschema
+                jsonschema.validate(instance=input_args, schema=schema)
+            except Exception as ve:
+                return {
+                    "status": "clarify",
+                    "error": "invalid_arguments",
+                    "message": f"Argument validation against schema failed: {ve}",
+                    "uri": target_op["uri"],
+                    "input": input_args,
+                    "domain": domain.name,
+                    "model_used": selected_model,
+                    "duration_ms": duration_ms,
+                    "raw": response,
+                }
+
+        return {
+            "status": "ok",
+            "uri": target_op["uri"],
+            "input": input_args,
+            "domain": domain.name,
+            "model_used": selected_model,
+            "duration_ms": duration_ms,
+            "raw": response,
+        }

willuri/semantic.py

@@ -0,0 +1,47 @@
+"""Fast local lexical matcher and candidate ranker for operations.
+
+Uses Jaccard token overlap for lexical keyword pre-filtering across catalog operations.
+Note: For semantic vector retrieval, use an embedding adapter rather than lexical overlap.
+"""
+from __future__ import annotations
+import math
+import re
+from typing import Any, Dict, List, Tuple
+
+
+def tokenize(text: str) -> List[str]:
+    """Tokenize text into lowercase alphanumeric keywords."""
+    return [t for t in re.findall(r"\w+", text.lower()) if len(t) > 1]
+
+
+def compute_similarity(tokens_a: List[str], tokens_b: List[str]) -> float:
+    """Compute Jaccard token similarity with term frequency weighting."""
+    if not tokens_a or not tokens_b:
+        return 0.0
+    set_a = set(tokens_a)
+    set_b = set(tokens_b)
+    intersection = set_a.intersection(set_b)
+    union = set_a.union(set_b)
+    return len(intersection) / len(union) if union else 0.0
+
+
+class SemanticMatcher:
+    """Ranks and pre-filters catalog operations against natural language instructions."""
+
+    def __init__(self, catalog: List[Dict[str, Any]]):
+        self.catalog = catalog
+
+    def match(self, instruction: str, top_k: int = 5) -> List[Tuple[Dict[str, Any], float]]:
+        """Return the top_k most relevant operations with relevance scores."""
+        inst_tokens = tokenize(instruction)
+        scored: List[Tuple[Dict[str, Any], float]] = []
+
+        for op in self.catalog:
+            text = f"{op.get('uri', '')} {op.get('description', '')} {' '.join(op.get('aliases', {}).keys())}"
+            op_tokens = tokenize(text)
+            score = compute_similarity(inst_tokens, op_tokens)
+            if score > 0.0:
+                scored.append((op, round(score, 4)))
+
+        scored.sort(key=lambda x: x[1], reverse=True)
+        return scored[:top_k]

willuri-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: willuri
+Version: 0.1.0
+Summary: Natural language to specialized URI process router with domain-specific small LLMs
+Author-email: Tom Sapletta <tom@sapletta.com>
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# willuri
+
+Natural language to specialized process URI router powered by domain-specific lightweight LLMs.
+
+## Overview
+
+In the Paxlet / Willman ecosystem, every capability is addressed by an explicit process URI (`willman://operation/...`, `dockuri://...`). 
+`willuri` maps natural language user instructions or tickets from the board to specialized process URIs using small, fast, domain-targeted LLMs instead of a monolithic general-purpose model.
+
+### Specialized Domain Models
+
+| Domain | Process URI Scope | Primary Model | Alternative | Focus |
+| :--- | :--- | :--- | :--- | :--- |
+| **`code`** | `willman://operation/code.*`, `git.resolve_conflicts` | `qwen2.5-coder:3b` | `willman-nlp:qwen2.5-3b` | Code synthesis, AST edits, diffs, bug repairs |
+| **`api_ops`** | `willman://operation/github.*`, `dockuri.*`, `files.*` | `granite4.1:3b` | `willman-nlp:qwen2.5-3b` | Structured API tools, JSON schema, enterprise ops |
+| **`planning`** | `willman://operation/koru.*`, `planfile.*`, `schedule.*` | `llama3.2:3b` | `willman-nlp:qwen2.5-3b` | Ticket decomposition, sprint planning, DAG subtasks |
+| **`text`** | `willman://operation/text.*` | `willman-nlp:qwen2.5-1.5b` | `willman-nlp:qwen2.5-3b` | String normalization, fast formatting, prose |
+
+## Usage
+
+### Python API
+```python
+from willuri.router import UriRouter
+
+router = UriRouter()
+router.add_operation("willman://operation/text.normalize/v1", "Normalize whitespace")
+router.add_operation("willman://operation/git.resolve_conflicts/v1", "Resolve git merge conflicts")
+
+result = router.route("Rozwiąż konflikty git w repozytorium")
+print(result["uri"])
+# => "willman://operation/git.resolve_conflicts/v1"
+print(result["model_used"])
+# => "qwen2.5-coder:3b"
+```
+
+### CLI
+```bash
+willuri classify "Popraw błąd w funkcji liczącej sumę"
+willuri route "Znormalizuj odstępy w tekście 'Ala   ma   kota'"
+```
+
+## Verification
+```bash
+python3 -m unittest discover -s tests -v
+```

willuri-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+willuri/__init__.py,sha256=2UduPG-PNE4NwN3eFSYlt6xP20eKbo7BZg2K9LoX9rs,913
+willuri/cli.py,sha256=DMGPCANefZmqcPisVSbmbN0MhKAVbkgXg7k9YMPwQg8,2137
+willuri/client.py,sha256=dhN-6GXKhhjIA1EtfPb0-dnTcCAGcdx_ha6C2UCZ9y4,1170
+willuri/domains.py,sha256=zjXs4KuT2pGhovBLrMFsruDRTkdL6GBIFCJAIuL-9Bs,3632
+willuri/dsl.py,sha256=Mx3OZc1gM5DvSrZzrgmaRFVAo7ntkKM2BFzROOTf0BE,2123
+willuri/models.py,sha256=0K4WiQQGNT-HDac3gFQBQMVdAx_1ndGKUOIcrjSMfro,3269
+willuri/prompts.py,sha256=HkYtMcp1BzTxfGCp2gf9fGh4Pr_1iYvKKv5roifJCyM,1858
+willuri/router.py,sha256=tens17O9Mjlnqkj3jA1ZkYB2y_Rej4rC5Oblc6pa92M,5718
+willuri/semantic.py,sha256=E0QHdKia_w1dcT5ANUIgKGUjN9m13-v8LlfSFxlzYSA,1805
+willuri-0.1.0.dist-info/licenses/LICENSE,sha256=rtJN2PQxbee7jzTmeZ63miF9k-OVgiojG8uodj7k-zE,6762
+willuri-0.1.0.dist-info/METADATA,sha256=QqF4_hvsUuiXfBBRUVMh8OVTlbK3VzJk7fYLHQ8OgaE,2289
+willuri-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+willuri-0.1.0.dist-info/entry_points.txt,sha256=FYhMOxK1R306eoXj_wODmKM_ASTGqJIaGgQU6_sC-BE,45
+willuri-0.1.0.dist-info/top_level.txt,sha256=fIXohf-YQe-BnCPfp2gGsOOLoyWqR24kHGaLFBJ5RZ4,8
+willuri-0.1.0.dist-info/RECORD,,

willuri-0.1.0.dist-info/WHEEL

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

willuri-0.1.0.dist-info/entry_points.txt

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

willuri-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,110 @@
+PROPRIETARY AND CONFIDENTIAL SOURCE CODE LICENSE
+STRICT ANTI-AI / ANTI-MINING RESERVATION OF RIGHTS
+
+Copyright (c) 2026 Tomasz Sapletta Prototypowanie.pl NIP: 5881918662, REGON: 220665410. All rights reserved.
+Właścicielem oprogramowania jest Tomasz Sapletta Prototypowanie.pl NIP: 5881918662, REGON: 220665410.
+
+================================================================================
+IMPORTANT NOTICE - PROPRIETARY AND CONFIDENTIAL
+================================================================================
+
+This software, source code, documentation, specifications, schemas, models,
+algorithms, and associated digital assets ("the Software") are the confidential
+and proprietary intellectual property of Tomasz Sapletta Prototypowanie.pl
+(NIP: 5881918662, REGON: 220665410) and its licensors.
+
+The Software is NOT licensed under any open source, free software, or
+source-available license (such as MIT, Apache 2.0, BSD, GPL, AGPL, BSL, or SSPL).
+All rights not expressly granted under a separate, signed written commercial
+agreement executed by Tomasz Sapletta Prototypowanie.pl are strictly reserved.
+
+================================================================================
+SECTION 1. STRICT PROHIBITION ON ARTIFICIAL INTELLIGENCE & MACHINE LEARNING INGESTION
+================================================================================
+
+Under no circumstances may any portion of the Software, whether in human-readable
+source code, compiled binary, abstract syntax tree (AST), intermediate representation,
+documentation, ticket history, or commit metadata, be:
+
+1.1. Ingested, scraped, crawled, harvested, indexed, tokenized, cached, or stored
+     for the purpose of training, pre-training, fine-tuning, evaluating, or weighting
+     any artificial intelligence system, machine learning model, large language
+     model (LLM), code-generation model, neural network, diffusion model, or
+     multimodal model.
+
+1.2. Used by, or fed into the training datasets, prompt contexts, retrieval-augmented
+     generation (RAG) stores, vector databases, or telemetry caches of any commercial
+     or non-commercial AI system, including but not limited to:
+     - GitHub Copilot / Microsoft Copilot (Microsoft Corporation)
+     - OpenAI ChatGPT, Codex, GPT-4, GPT-5, o-series, and related APIs (OpenAI Inc.)
+     - Google Gemini, PaLM, Codey, Vertex AI, and DeepMind systems (Google LLC / Alphabet)
+     - Anthropic Claude, Constitutional AI, and related models (Anthropic PBC)
+     - Meta LLaMA, Code Llama, and related foundation models (Meta Platforms, Inc.)
+     - Amazon CodeWhisperer, Bedrock, and Titan models (Amazon.com, Inc.)
+     - Mistral AI, Cohere, Cursor AI, Tabnine, Replit Ghostwriter, or any automated
+       code-synthesis engine or AI coding assistant.
+
+1.3. Processed or analyzed by any automated tool, bot, crawler, or scraper to generate
+     synthetic code, code suggestions, autocomplete suggestions, embeddings, or
+     derivative software models.
+
+================================================================================
+SECTION 2. STATUTORY RESERVATION OF RIGHTS (EU DIRECTIVE 2019/790)
+================================================================================
+
+2.1. In accordance with Article 4(3) of Directive (EU) 2019/790 of the European
+     Parliament and of the Council on copyright and related rights in the Digital
+     Single Market, the rights holder hereby EXPRESSLY RESERVES ALL RIGHTS
+     regarding Text and Data Mining (TDM) for this Software, its source repositories,
+     documentation, schemas, and all associated materials.
+
+2.2. Any extraction, automated reading, indexing, or reproduction of the Software
+     for text and data mining purposes within the meaning of Directive (EU) 2019/790
+     is strictly prohibited without prior written authorization from the rights holder.
+
+2.3. This reservation applies worldwide and is declared in machine-readable form
+     within the repository metadata, headers, and this License specification.
+
+================================================================================
+SECTION 3. HOSTING & PLATFORM PREEMPTION CLAUSE
+================================================================================
+
+3.1. The presence of this source code or repository on any third-party hosting service,
+     code forge, version control platform, or cloud provider (including but not
+     limited to GitHub, GitLab, Bitbucket, or AWS) does NOT constitute a waiver,
+     license grant, or implied consent to the hosting provider, its parent,
+     subsidiaries, or third parties to:
+     (a) use the Software for machine learning training, telemetry harvesting, or
+         model improvement;
+     (b) distribute or reproduce the Software to other users or automated agents;
+     (c) index the Software in any public search or retrieval system.
+
+3.2. Any terms of service, platform agreements, or automated licenses purporting
+     to grant the platform operator an implied, royalty-free, or transferable
+     license to utilize hosted code for artificial intelligence development, model
+     training, or feature synthesis are hereby explicitly rejected, preempted,
+     and declared null and void with respect to this Software.
+
+================================================================================
+SECTION 4. PROHIBITED USES & RESTRICTIONS
+================================================================================
+
+Except as expressly authorized under a valid, executed commercial enterprise license
+with Tomasz Sapletta Prototypowanie.pl, you may NOT:
+- Copy, modify, adapt, translate, reverse engineer, decompile, or disassemble the Software.
+- Distribute, sublicense, rent, lease, lend, sell, or publicly display the Software.
+- Use the Software to provide competitive time-sharing, SaaS, cloud twin, or virtualization services.
+- Remove, alter, or obscure any proprietary notices, copyright labels, or license files.
+
+================================================================================
+SECTION 5. ENFORCEMENT & REMEDIES
+================================================================================
+
+Any breach of this License, including unauthorized scraping, tokenization, or ingestion
+into an artificial intelligence system, constitutes willful copyright infringement,
+unauthorized access, and breach of contract. Tomasz Sapletta Prototypowanie.pl reserves
+the right to seek immediate injunctive relief, statutory damages, compensation for commercial
+harm, and mandatory destruction of all derivative model weights, embeddings, and training
+caches containing representations of the Software.
+
+For licensing inquiries and commercial authorization, contact: tom@prototypowanie.pl / legal@clonerd.com

willuri-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+willuri