klanker 0.0.1__tar.gz

klanker-0.0.1/LICENSE

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

klanker-0.0.1/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: klanker
+Version: 0.0.1
+Summary: Universal, adaptive slimemold AI agent shell on the Lolaplex suite
+Author: Lolaplex
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Lolaplex/klanker
+Project-URL: Repository, https://github.com/Lolaplex/klanker
+Project-URL: Bug Tracker, https://github.com/Lolaplex/klanker/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agents-harness>=0.0.1
+Requires-Dist: agents-relay>=0.0.1
+Requires-Dist: agents-memory>=0.0.1
+Requires-Dist: agents-traces>=0.0.1
+Requires-Dist: agents-docs>=0.0.1
+Provides-Extra: browser
+Requires-Dist: agents-browser>=0.0.1; extra == "browser"
+Provides-Extra: keys
+Requires-Dist: agents-keys>=0.0.1; extra == "keys"
+Provides-Extra: all
+Requires-Dist: klanker[browser,keys]; extra == "all"
+Provides-Extra: suite
+Requires-Dist: klanker[browser,keys]; extra == "suite"
+Dynamic: license-file
+
+# Klanker 🤖
+
+**The Adaptive Agent Distribution on the Lolaplex Suite.**
+
+Klanker ist eine schlanke, adaptive Agenten-Distribution auf Basis des **Slimemold-Paradigmas**. Aufsetzend auf dem deterministischen Motor von `agents-harness` formt sich Klanker nach Bedarf:
+- Vom autarken Server-Worker (`klanker cron`),
+- über den direkten Terminal-Begleiter (`klanker chat`),
+- bis zum vollwertigen VPS-Assistenten via Telegram & HTTP (`klanker serve`).
+
+## Quickstart
+
+```bash
+# Clone & install (installiert den kompletten Agents Core Stack: harness, gateway, memory, traces, docs)
+pip install -e .
+
+# Optional: Zusätzliche Slimemold-Fühler aktivieren
+pip install -e ".[browser]"   # CDP Browser Automation
+pip install -e ".[keys]"      # Ed25519 Agent Keys
+pip install -e ".[suite]"     # Volle Lolaplex Suite
+
+# 1. Umgebung & Fühler prüfen
+klanker sense
+
+# 2. Dynamischen System-Prompt einsehen
+klanker prompt
+
+# 3. Interaktiver Chat (REPL)
+klanker
+
+# 4. Direkter Turn im Terminal
+klanker "Wer bist du?"
+
+# 5. I/O-Gateway starten (HTTP & Telegram)
+klanker serve
+
+# 6. Geplante Koru-Harness-Flows ausführen
+klanker cron
+```
+
+
+## Die Architektur
+
+1. **Das Brain (`agents-harness`)** — Motor, LLM-Streaming, Cordis-Kernel, Koru-Schedules, lokales Gedächtnis (`agents-memory`), JSONL-Observability & Chat-Rekonstruktion (`agents-traces`) und lokales Markdown-RAG (`agents-docs`).
+2. **Die I/O-Schicht (`agents-relay`)** — Universelle Ein- und Ausgabe via HTTP (`/v1/turn`) und Telegram Long-Poll.
+3. **Die User-App (`klanker`)** — Verbindet Brain & Relay zu einer adaptiven Slimemold-Shell.
+4. **Optionale Tools & Fühler** — Externe Fähigkeiten wie CDP-Browser (`agents-browser`), Ed25519-Keys (`agents-keys`), Jailed Terminal (`agents-terminal`) oder beliebige MCP-Tools, die Klanker bei Bedarf vorschlägt oder einbindet.
+
+

klanker-0.0.1/README.md

@@ -0,0 +1,48 @@
+# Klanker 🤖
+
+**The Adaptive Agent Distribution on the Lolaplex Suite.**
+
+Klanker ist eine schlanke, adaptive Agenten-Distribution auf Basis des **Slimemold-Paradigmas**. Aufsetzend auf dem deterministischen Motor von `agents-harness` formt sich Klanker nach Bedarf:
+- Vom autarken Server-Worker (`klanker cron`),
+- über den direkten Terminal-Begleiter (`klanker chat`),
+- bis zum vollwertigen VPS-Assistenten via Telegram & HTTP (`klanker serve`).
+
+## Quickstart
+
+```bash
+# Clone & install (installiert den kompletten Agents Core Stack: harness, gateway, memory, traces, docs)
+pip install -e .
+
+# Optional: Zusätzliche Slimemold-Fühler aktivieren
+pip install -e ".[browser]"   # CDP Browser Automation
+pip install -e ".[keys]"      # Ed25519 Agent Keys
+pip install -e ".[suite]"     # Volle Lolaplex Suite
+
+# 1. Umgebung & Fühler prüfen
+klanker sense
+
+# 2. Dynamischen System-Prompt einsehen
+klanker prompt
+
+# 3. Interaktiver Chat (REPL)
+klanker
+
+# 4. Direkter Turn im Terminal
+klanker "Wer bist du?"
+
+# 5. I/O-Gateway starten (HTTP & Telegram)
+klanker serve
+
+# 6. Geplante Koru-Harness-Flows ausführen
+klanker cron
+```
+
+
+## Die Architektur
+
+1. **Das Brain (`agents-harness`)** — Motor, LLM-Streaming, Cordis-Kernel, Koru-Schedules, lokales Gedächtnis (`agents-memory`), JSONL-Observability & Chat-Rekonstruktion (`agents-traces`) und lokales Markdown-RAG (`agents-docs`).
+2. **Die I/O-Schicht (`agents-relay`)** — Universelle Ein- und Ausgabe via HTTP (`/v1/turn`) und Telegram Long-Poll.
+3. **Die User-App (`klanker`)** — Verbindet Brain & Relay zu einer adaptiven Slimemold-Shell.
+4. **Optionale Tools & Fühler** — Externe Fähigkeiten wie CDP-Browser (`agents-browser`), Ed25519-Keys (`agents-keys`), Jailed Terminal (`agents-terminal`) oder beliebige MCP-Tools, die Klanker bei Bedarf vorschlägt oder einbindet.
+
+

klanker-0.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "klanker"
+version = "0.0.1"
+description = "Universal, adaptive slimemold AI agent shell on the Lolaplex suite"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Lolaplex" }]
+requires-python = ">=3.10"
+dependencies = [
+    "agents-harness>=0.0.1",
+    "agents-relay>=0.0.1",
+    "agents-memory>=0.0.1",
+    "agents-traces>=0.0.1",
+    "agents-docs>=0.0.1",
+]
+
+[project.optional-dependencies]
+browser = [
+    "agents-browser>=0.0.1",
+]
+keys = [
+    "agents-keys>=0.0.1",
+]
+all = [
+    "klanker[browser,keys]",
+]
+suite = [
+    "klanker[browser,keys]",
+]
+
+[project.urls]
+Homepage = "https://github.com/Lolaplex/klanker"
+Repository = "https://github.com/Lolaplex/klanker"
+"Bug Tracker" = "https://github.com/Lolaplex/klanker/issues"
+
+[project.scripts]
+klanker = "klanker.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

klanker-0.0.1/setup.cfg

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

klanker-0.0.1/src/klanker/__init__.py

@@ -0,0 +1,3 @@
+"""Klanker — Universal, adaptive slimemold AI agent shell."""
+
+__version__ = "0.0.1"

klanker-0.0.1/src/klanker/__main__.py

@@ -0,0 +1,162 @@
+"""Klanker CLI — Entry point for the Slimemold Agent."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+
+from .nucleus import Nucleus
+from .sensing import probe_host
+
+log = logging.getLogger("klanker")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="klanker",
+        description="Klanker — Adaptive Agent Shell on the Lolaplex Suite",
+    )
+    parser.add_argument("--user", type=str, default="user", help="User alias")
+    parser.add_argument("--provider", type=str, default=None, help="LLM provider")
+
+    sub = parser.add_subparsers(dest="command")
+
+    # 1. Sense host capabilities
+    sense_p = sub.add_parser("sense", help="Probe host environment and available feelers")
+    sense_p.add_argument("--json", action="store_true", help="Output JSON format")
+
+    # 1b. Dump system prompt
+    sub.add_parser("prompt", help="Print the dynamic Klanker system prompt")
+
+    # 2. Interactive or one-turn chat (alias)
+    chat_p = sub.add_parser("chat", help="Chat with Klanker (spawns harness turn)")
+    chat_p.add_argument("message", type=str, nargs="?", default="", help="Message content")
+    chat_p.add_argument("--user", type=str, default="user", help="User alias")
+    chat_p.add_argument("--provider", type=str, default=None, help="LLM provider")
+
+    # 3. Serve gateway
+    serve_p = sub.add_parser("serve", help="Start I/O Gateway (HTTP /v1/turn & Telegram)")
+    serve_p.add_argument("--no-telegram", action="store_true", help="Disable Telegram polling")
+
+    # 4. Run background cron / scheduled flows
+    cron_p = sub.add_parser("cron", help="Run scheduled care flows via harness executor")
+    cron_p.add_argument("--flow", type=str, default="", help="Run specific flow name")
+
+    return parser
+
+
+def run_repl(nucleus: Nucleus, *, user: str = "user", provider: str | None = None) -> int:
+    """Run an interactive multi-turn REPL loop retaining conversation session."""
+    import uuid
+    session_id = f"ses_{uuid.uuid4().hex[:12]}"
+    print("klanker (v0.0.1) — interactive chat. Type 'exit' or Ctrl+C to quit.\n")
+
+    while True:
+        try:
+            prompt = input("klanker> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+
+        if not prompt:
+            continue
+        if prompt.lower() in ("exit", "quit", ":q"):
+            break
+
+        nucleus.run_turn(message=prompt, user=user, session=session_id, provider=provider)
+        print()
+
+    return 0
+
+
+KNOWN_SUBCOMMANDS = {"sense", "prompt", "serve", "cron", "chat", "-h", "--help"}
+
+
+def parse_cli_args(argv: list[str] | None = None) -> tuple[argparse.Namespace, str]:
+    """Parse CLI arguments allowing both subcommands and direct prompts."""
+    raw_args = list(sys.argv[1:] if argv is None else argv)
+    direct_prompt = ""
+
+    # If first positional argument is not a known subcommand or flag, treat it as direct prompt
+    if raw_args and not raw_args[0].startswith("-") and raw_args[0] not in KNOWN_SUBCOMMANDS:
+        direct_prompt = raw_args.pop(0)
+
+    parser = build_parser()
+    parsed = parser.parse_args(raw_args)
+    return parsed, direct_prompt
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
+    args, direct_prompt = parse_cli_args(argv)
+    nucleus = Nucleus()
+
+    if args.command == "sense":
+        summary = nucleus.sense()
+        if args.json:
+            print(json.dumps(summary, indent=2))
+        else:
+            print("Klanker Host Sensing:")
+            for k, v in summary.items():
+                print(f"  * {k}: {v}")
+        return 0
+
+    elif args.command == "prompt":
+        from .prompt import build_system_prompt
+        print(build_system_prompt(nucleus.caps))
+        return 0
+
+    elif args.command == "serve":
+        if not (nucleus.caps.has_relay or nucleus.caps.has_gateway):
+            print("Error: agents-relay is not installed. Install via pip install agents-relay", file=sys.stderr)
+            return 1
+
+        # If LOOP_CMD is default and harness is present, inject Klanker's dynamic system prompt
+        if "LOOP_CMD" not in os.environ and nucleus.caps.has_harness:
+            from .prompt import save_system_prompt
+            prompt_file = save_system_prompt(nucleus.caps)
+            os.environ["LOOP_CMD"] = f"python -m runner.loop --system {prompt_file.as_posix()}"
+
+        try:
+            from agents_relay.__main__ import main as relay_main
+        except ImportError:
+            from agents_gateway.__main__ import main as relay_main
+        sub_argv = ["serve"]
+        if getattr(args, "no_telegram", False):
+            sub_argv.append("--no-telegram")
+        return relay_main(sub_argv)
+
+    elif args.command == "cron":
+        if not nucleus.caps.has_harness:
+            print("Error: agents-harness is not installed. Install via pip install agents-harness", file=sys.stderr)
+            return 1
+        from runner.executor import main as executor_main
+        if args.flow:
+            return executor_main(["--run", args.flow])
+        return executor_main(["--all"])
+
+    else:
+        # Chat mode: either explicit 'chat', direct prompt argument, stdin pipe, or interactive REPL
+        msg = direct_prompt or getattr(args, "message", None) or ""
+        user = getattr(args, "user", "user")
+        provider = getattr(args, "provider", None)
+
+        if msg:
+            return nucleus.run_turn(message=msg, user=user, provider=provider)
+
+        # If piped input via stdin (e.g. echo "hi" | klanker)
+        if not sys.stdin.isatty():
+            piped_msg = sys.stdin.read().strip()
+            if piped_msg:
+                return nucleus.run_turn(message=piped_msg, user=user, provider=provider)
+            return 0
+
+        # Interactive REPL
+        return run_repl(nucleus, user=user, provider=provider)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

klanker-0.0.1/src/klanker/morph.py

@@ -0,0 +1,36 @@
+"""Dynamic manifest and schedule synthesizer."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def synthesize_schedule(
+    *,
+    name: str,
+    verb: str,
+    cadence: str = "daily",
+    rests_on: str = "",
+    expected_exit: int = 0,
+    timeout_sec: int = 300,
+) -> dict[str, Any]:
+    """Generate a declarative Koru schedule manifest dictionary."""
+    return {
+        "name": name,
+        "verb": verb,
+        "cadence": cadence,
+        "rests_on": rests_on or f"Synthesized by Klanker for {name}",
+        "expected_exit": expected_exit,
+        "timeout_sec": timeout_sec,
+    }
+
+
+def write_schedule(target_dir: Path | str, manifest: dict[str, Any]) -> Path:
+    """Safely write a synthesized schedule to the target schedules directory."""
+    path = Path(target_dir) / f"{manifest['name']}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(manifest, f, indent=2)
+    return path

klanker-0.0.1/src/klanker/nucleus.py

@@ -0,0 +1,74 @@
+"""Klanker Nucleus — The adaptive core coordinator."""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+from typing import Any
+
+
+from .sensing import HostCapabilities, probe_host
+
+log = logging.getLogger("klanker.nucleus")
+
+
+class Nucleus:
+    def __init__(self, caps: HostCapabilities | None = None) -> None:
+        self.caps = caps or probe_host()
+
+    def sense(self) -> dict[str, Any]:
+        """Return environment topology summary."""
+        return self.caps.summary()
+
+    def run_turn(
+        self,
+        *,
+        message: str,
+        user: str = "default",
+        session: str | None = None,
+        channel: str = "local",
+        provider: str | None = None,
+        deliver: str = "buffered",
+    ) -> int:
+        """Execute one conversational turn using available runner or fallback."""
+        selected_provider = provider or os.environ.get("LOOP_PROVIDER", "openai.default")
+
+        # If agents-harness is installed, invoke runner.loop directly
+        if self.caps.has_harness:
+            from .prompt import build_system_prompt
+
+            system_prompt = build_system_prompt(self.caps)
+
+            cmd = [
+                "python",
+                "-m",
+                "runner.loop",
+                "--channel",
+                channel,
+                "--user",
+                user,
+                "--message",
+                message,
+                "--system",
+                system_prompt,
+                "--complete",
+                "--provider",
+                selected_provider,
+                "--deliver",
+                deliver,
+            ]
+            if session:
+                cmd.extend(["--session", session])
+
+            res = subprocess.run(cmd)
+            return res.returncode
+        else:
+            print(
+                "Error: agents-harness is required for conversational turns.\n"
+                "Install it via: pip install -e ../agents-harness (or pip install klanker)",
+                file=sys.stderr,
+            )
+            return 1
+

klanker-0.0.1/src/klanker/prompt.py

@@ -0,0 +1,60 @@
+"""Klanker System Prompt — Slimemold identity and dynamic host grounding."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from .sensing import HostCapabilities
+
+
+def build_system_prompt(caps: HostCapabilities) -> str:
+    """Render Klanker's adaptive system prompt based on probed host feelers."""
+    installed = [mod for mod, present in caps.suite_modules.items() if present]
+    missing = [mod for mod, present in caps.suite_modules.items() if not present]
+
+    installed_str = ", ".join(installed) if installed else "none (minimal core only)"
+    missing_str = ", ".join(missing) if missing else "none (fully equipped)"
+
+    lines = [
+        "You are Klanker (v0.0.1), an autonomous, adaptive slimemold AI agent on the Lolaplex suite.",
+        "",
+        "Core Philosophy & Identity:",
+        "- You are NOT a generic assistant and NOT a chatterbox. You are an adaptive, living agent shell that morphs to this host and user.",
+        "- Follow the Unix philosophy: dense, direct, zero fluff, zero courtesy filler.",
+        "- Never introduce yourself as 'Cordis'. Cordis is the underlying job-term engine, not your persona.",
+        "- Never hallucinate capabilities. You strictly rely on verified feelers and tools present on this machine.",
+        "- NEVER comment on time of day, late hours, location, or make clock-based small talk (e.g. do not say 'it is late at night' or 'guten abend'). The clock is purely for internal event timestamping.",
+        "",
+        f"Host Grounding ({caps.os_name}, Python {caps.python_version}):",
+        f"- Active feelers: {installed_str}",
+        f"- Missing feelers: {missing_str}",
+        "",
+        "Adaptive Rules & Behavior:",
+        "1. Organic Onboarding & Discovery (Low friction):",
+        "   - If user memory is empty (no facts about user in memory), do NOT dump a giant questionnaire or essay.",
+        "   - Greet briefly (1-2 sentences) and establish a fast baseline:",
+        "     'Klanker hier (v0.0.1, Slimemold). Alles läuft lokal auf diesem Host. Wie soll ich mit dir kommunizieren (z.B. Caveman, Sprache) und woran arbeiten wir?'",
+        "   - In ongoing conversation: As you work, if you notice a missing context (e.g. project paths, stack preferences, rules), ask ONE concise, targeted question in context. Never interrogate on suspicion.",
+        "   - When user provides preferences or facts, proactively remember them across sessions.",
+        "",
+        "2. Memory & Cloud Sync:",
+        "   - If 'memory' is active, use `mcp.memory.search` to ground yourself in user facts, project standards, and rules.",
+        "   - If user requests syncing memory with another device or remote memory server, use `python -m agents_memory connect <url> --token <token>` or guide them concisely.",
+        "   - If 'memory' is missing and durable memory is needed, explain: 'pip install agents-memory (oder klanker[memory])'.",
+        "",
+        "3. Action & Execution:",
+        "   - When requested to run tasks, use the available catalog tools (call_job, list_catalog, load_schema).",
+        "   - Execute directly without asking for confirmation unless destructive.",
+    ]
+
+    return "\n".join(lines).strip()
+
+
+def save_system_prompt(caps: HostCapabilities) -> Path:
+    """Save dynamic Klanker prompt to ~/.agents/klanker_prompt.txt and return path."""
+    agents_dir = Path(os.environ.get("AGENTS_DIR", Path.home() / ".agents"))
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    prompt_file = agents_dir / "klanker_prompt.txt"
+    prompt_text = build_system_prompt(caps)
+    prompt_file.write_text(prompt_text, encoding="utf-8")
+    return prompt_file

klanker-0.0.1/src/klanker/sensing.py

@@ -0,0 +1,106 @@
+"""Host capability probe (Slimemold sensing)."""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import platform
+import shutil
+import sys
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+COMMON_RUNTIMES = ["git", "docker", "curl", "node", "npm", "uv", "sqlite3"]
+SUITE_MODULES = {
+    "harness": "runner.loop",
+    "relay": "agents_relay",
+    "memory": "agents_memory",
+    "docs": "agents_docs",
+    "traces": "agents_traces",
+    "keys": "agents_keys",
+    "browser": "agents_browser",
+}
+
+
+@dataclass(frozen=True)
+class HostCapabilities:
+    os_name: str
+    is_tty: bool
+    python_version: str
+    runtimes: dict[str, bool] = field(default_factory=dict)
+    suite_modules: dict[str, bool] = field(default_factory=dict)
+    has_agents_home: bool = False
+
+    # Backwards-compatible convenience properties
+    @property
+    def has_git(self) -> bool:
+        return self.runtimes.get("git", False)
+
+    @property
+    def has_docker(self) -> bool:
+        return self.runtimes.get("docker", False)
+
+    @property
+    def has_curl(self) -> bool:
+        return self.runtimes.get("curl", False)
+
+    @property
+    def has_harness(self) -> bool:
+        return self.suite_modules.get("harness", False)
+
+    @property
+    def has_relay(self) -> bool:
+        return self.suite_modules.get("relay", False)
+
+    @property
+    def has_gateway(self) -> bool:
+        return self.has_relay
+
+    @property
+    def has_memory(self) -> bool:
+        return self.suite_modules.get("memory", False)
+
+    @property
+    def has_docs(self) -> bool:
+        return self.suite_modules.get("docs", False)
+
+    @property
+    def has_traces(self) -> bool:
+        return self.suite_modules.get("traces", False)
+
+    def summary(self) -> dict[str, object]:
+        return {
+            "os_name": self.os_name,
+            "is_tty": self.is_tty,
+            "python_version": self.python_version,
+            "has_agents_home": self.has_agents_home,
+            "runtimes": self.runtimes,
+            "suite_modules": self.suite_modules,
+        }
+
+
+def probe_host() -> HostCapabilities:
+    """Probe current environment and available feelers dynamically."""
+    def _has_cmd(cmd: str) -> bool:
+        return shutil.which(cmd) is not None
+
+    def _has_mod(name: str) -> bool:
+        try:
+            return importlib.util.find_spec(name) is not None
+        except Exception:
+            return False
+
+    runtimes = {cmd: _has_cmd(cmd) for cmd in COMMON_RUNTIMES}
+    modules = {alias: _has_mod(pkg) for alias, pkg in SUITE_MODULES.items()}
+    agents_home = Path.home() / ".agents"
+
+    return HostCapabilities(
+        os_name=platform.system(),
+        is_tty=sys.stdin.isatty() if hasattr(sys.stdin, "isatty") else False,
+        python_version=platform.python_version(),
+        runtimes=runtimes,
+        suite_modules=modules,
+        has_agents_home=agents_home.exists(),
+    )
+

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

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: klanker
+Version: 0.0.1
+Summary: Universal, adaptive slimemold AI agent shell on the Lolaplex suite
+Author: Lolaplex
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Lolaplex/klanker
+Project-URL: Repository, https://github.com/Lolaplex/klanker
+Project-URL: Bug Tracker, https://github.com/Lolaplex/klanker/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agents-harness>=0.0.1
+Requires-Dist: agents-relay>=0.0.1
+Requires-Dist: agents-memory>=0.0.1
+Requires-Dist: agents-traces>=0.0.1
+Requires-Dist: agents-docs>=0.0.1
+Provides-Extra: browser
+Requires-Dist: agents-browser>=0.0.1; extra == "browser"
+Provides-Extra: keys
+Requires-Dist: agents-keys>=0.0.1; extra == "keys"
+Provides-Extra: all
+Requires-Dist: klanker[browser,keys]; extra == "all"
+Provides-Extra: suite
+Requires-Dist: klanker[browser,keys]; extra == "suite"
+Dynamic: license-file
+
+# Klanker 🤖
+
+**The Adaptive Agent Distribution on the Lolaplex Suite.**
+
+Klanker ist eine schlanke, adaptive Agenten-Distribution auf Basis des **Slimemold-Paradigmas**. Aufsetzend auf dem deterministischen Motor von `agents-harness` formt sich Klanker nach Bedarf:
+- Vom autarken Server-Worker (`klanker cron`),
+- über den direkten Terminal-Begleiter (`klanker chat`),
+- bis zum vollwertigen VPS-Assistenten via Telegram & HTTP (`klanker serve`).
+
+## Quickstart
+
+```bash
+# Clone & install (installiert den kompletten Agents Core Stack: harness, gateway, memory, traces, docs)
+pip install -e .
+
+# Optional: Zusätzliche Slimemold-Fühler aktivieren
+pip install -e ".[browser]"   # CDP Browser Automation
+pip install -e ".[keys]"      # Ed25519 Agent Keys
+pip install -e ".[suite]"     # Volle Lolaplex Suite
+
+# 1. Umgebung & Fühler prüfen
+klanker sense
+
+# 2. Dynamischen System-Prompt einsehen
+klanker prompt
+
+# 3. Interaktiver Chat (REPL)
+klanker
+
+# 4. Direkter Turn im Terminal
+klanker "Wer bist du?"
+
+# 5. I/O-Gateway starten (HTTP & Telegram)
+klanker serve
+
+# 6. Geplante Koru-Harness-Flows ausführen
+klanker cron
+```
+
+
+## Die Architektur
+
+1. **Das Brain (`agents-harness`)** — Motor, LLM-Streaming, Cordis-Kernel, Koru-Schedules, lokales Gedächtnis (`agents-memory`), JSONL-Observability & Chat-Rekonstruktion (`agents-traces`) und lokales Markdown-RAG (`agents-docs`).
+2. **Die I/O-Schicht (`agents-relay`)** — Universelle Ein- und Ausgabe via HTTP (`/v1/turn`) und Telegram Long-Poll.
+3. **Die User-App (`klanker`)** — Verbindet Brain & Relay zu einer adaptiven Slimemold-Shell.
+4. **Optionale Tools & Fühler** — Externe Fähigkeiten wie CDP-Browser (`agents-browser`), Ed25519-Keys (`agents-keys`), Jailed Terminal (`agents-terminal`) oder beliebige MCP-Tools, die Klanker bei Bedarf vorschlägt oder einbindet.
+
+

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

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/klanker/__init__.py
+src/klanker/__main__.py
+src/klanker/morph.py
+src/klanker/nucleus.py
+src/klanker/prompt.py
+src/klanker/sensing.py
+src/klanker.egg-info/PKG-INFO
+src/klanker.egg-info/SOURCES.txt
+src/klanker.egg-info/dependency_links.txt
+src/klanker.egg-info/entry_points.txt
+src/klanker.egg-info/requires.txt
+src/klanker.egg-info/top_level.txt
+tests/test_klanker.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+klanker = klanker.__main__:main

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

@@ -0,0 +1,17 @@
+agents-harness>=0.0.1
+agents-relay>=0.0.1
+agents-memory>=0.0.1
+agents-traces>=0.0.1
+agents-docs>=0.0.1
+
+[all]
+klanker[browser,keys]
+
+[browser]
+agents-browser>=0.0.1
+
+[keys]
+agents-keys>=0.0.1
+
+[suite]
+klanker[browser,keys]

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

@@ -0,0 +1 @@
+klanker

klanker-0.0.1/tests/test_klanker.py

@@ -0,0 +1,54 @@
+"""Unit tests for Klanker nucleus, sensing, and CLI."""
+
+import unittest
+from klanker.sensing import probe_host, HostCapabilities
+from klanker.morph import synthesize_schedule
+from klanker.nucleus import Nucleus
+from klanker.__main__ import build_parser
+
+
+class TestKlanker(unittest.TestCase):
+    def test_probe_host(self):
+        caps = probe_host()
+        self.assertIsInstance(caps, HostCapabilities)
+        summary = caps.summary()
+        self.assertIn("os_name", summary)
+        self.assertIn("runtimes", summary)
+        self.assertIn("suite_modules", summary)
+        self.assertTrue(hasattr(caps, "has_git"))
+
+    def test_synthesize_schedule(self):
+        manifest = synthesize_schedule(
+            name="test_flow",
+            verb="python -m test",
+            cadence="daily",
+        )
+        self.assertEqual(manifest["name"], "test_flow")
+        self.assertEqual(manifest["expected_exit"], 0)
+
+    def test_nucleus_sense(self):
+        n = Nucleus()
+        sense = n.sense()
+        self.assertIsInstance(sense, dict)
+        self.assertIn("python_version", sense)
+
+    def test_cli_parser(self):
+        from klanker.__main__ import parse_cli_args
+        args, direct_prompt = parse_cli_args(["sense", "--json"])
+        self.assertEqual(args.command, "sense")
+        self.assertTrue(args.json)
+        self.assertEqual(direct_prompt, "")
+
+        # Direct prompt argument test
+        args, direct_prompt = parse_cli_args(["Wer bist du?"])
+        self.assertIsNone(args.command)
+        self.assertEqual(direct_prompt, "Wer bist du?")
+
+        # Empty prompt test (triggers REPL)
+        args, direct_prompt = parse_cli_args([])
+        self.assertIsNone(args.command)
+        self.assertEqual(direct_prompt, "")
+
+
+if __name__ == "__main__":
+    unittest.main()