krnl-code 1.0.4__py3-none-any.whl

krnl_agent/sandbox.py

@@ -0,0 +1,69 @@
+"""Per-tool command sandbox + network egress policy.
+
+A deny-by-default safety layer for `run_command`, evaluated *before* a command
+runs (and before the approval prompt). Configured under `sandbox:` in config.yaml:
+
+    sandbox:
+      block_network: true              # block curl/wget/ssh/etc. and URLs
+      deny_commands: ["rm -rf /", "git push"]   # regex, always denied
+      allow_commands: ["pytest", "npm (run )?test"]  # if set, ONLY these allowed
+
+This keeps autonomous / dangerous-mode runs contained: even with every approval
+auto-granted, a denied command never executes.
+"""
+from __future__ import annotations
+
+import re
+
+# Commands/binaries that perform network egress.
+_NET = re.compile(
+    r"(?i)(?:^|[\s;|&])(curl|wget|nc|ncat|netcat|telnet|ssh|scp|sftp|ftp|rsync|"
+    r"http|https)\b|https?://|ftp://")
+
+# Always-dangerous shapes blocked when block_network or any policy is active is
+# NOT assumed; these are only used by the built-in 'strict' helper below.
+_DESTRUCTIVE = [
+    r"rm\s+-rf\s+/(?:\s|$)",
+    r":\(\)\s*\{.*\};:",          # fork bomb
+    r"mkfs\b", r"dd\s+if=.*of=/dev/",
+    r">\s*/dev/sd[a-z]",
+]
+
+
+def check_command(sandbox: dict, command: str) -> tuple[bool, str]:
+    """Return (allowed, reason). Empty/whitespace commands are allowed (no-op)."""
+    if not sandbox:
+        return True, ""
+    cmd = (command or "").strip()
+    if not cmd:
+        return True, ""
+
+    for pat in sandbox.get("deny_commands", []) or []:
+        try:
+            if re.search(pat, cmd):
+                return False, f"blocked by sandbox.deny_commands rule: /{pat}/"
+        except re.error:
+            if pat in cmd:
+                return False, f"blocked by sandbox.deny_commands rule: {pat!r}"
+
+    if sandbox.get("block_network") and _NET.search(cmd):
+        return False, "network egress blocked by sandbox.block_network"
+
+    allow = sandbox.get("allow_commands") or []
+    if allow:
+        for pat in allow:
+            try:
+                if re.search(pat, cmd):
+                    return True, ""
+            except re.error:
+                if pat in cmd:
+                    return True, ""
+        return False, "not in sandbox.allow_commands allowlist (deny-by-default)"
+
+    return True, ""
+
+
+def is_destructive(command: str) -> bool:
+    """True for catastrophic shapes (used by `doctor`/strict presets)."""
+    cmd = command or ""
+    return any(re.search(p, cmd) for p in _DESTRUCTIVE)

krnl_agent/scaffold.py

@@ -0,0 +1,167 @@
+"""Auto-onboarding: scaffold a `.krnl/` wrapper the first time the agent works in
+a project, so memory, a skill, and a project doc exist by default - no setup.
+
+Creates (only what's missing):
+    .krnl/AGENTS.md                      - project memory / rules (auto-loaded)
+    .krnl/PROJECT.md                     - a project overview doc (the agent's own MD)
+    .krnl/skills/explore-codebase/SKILL.md  - a starter skill for understanding the repo
+
+Everything is detected from the repo (stack, build/test/lint commands), so the
+files are useful immediately and key-free.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def detect_project(workspace: str) -> dict:
+    root = Path(workspace)
+    info: dict = {"name": root.name, "stack": [], "build": [], "test": [],
+                  "lint": [], "run": [], "git": (root / ".git").exists()}
+
+    def add(cat: str, cmd: str):
+        if cmd not in info[cat]:
+            info[cat].append(cmd)
+
+    if (root / "pyproject.toml").exists() or (root / "setup.py").exists() or (root / "requirements.txt").exists():
+        info["stack"].append("Python")
+        if (root / "requirements.txt").exists():
+            add("build", "pip install -r requirements.txt")
+        if (root / "pyproject.toml").exists():
+            add("build", "pip install -e .")
+        add("test", "pytest")
+    pkg = root / "package.json"
+    if pkg.exists():
+        info["stack"].append("Node.js")
+        try:
+            scripts = json.loads(pkg.read_text(encoding="utf-8")).get("scripts", {})
+            cat = {"build": "build", "test": "test", "lint": "lint", "dev": "run", "start": "run"}
+            for k, c in cat.items():
+                if k in scripts:
+                    add(c, f"npm run {k}")
+        except Exception:
+            pass
+    if (root / "go.mod").exists():
+        info["stack"].append("Go"); add("build", "go build ./..."); add("test", "go test ./...")
+    if (root / "Cargo.toml").exists():
+        info["stack"].append("Rust"); add("build", "cargo build"); add("test", "cargo test")
+    if (root / "pom.xml").exists():
+        info["stack"].append("Java/Maven"); add("build", "mvn compile"); add("test", "mvn test")
+    if (root / "build.gradle").exists() or (root / "build.gradle.kts").exists():
+        info["stack"].append("Gradle"); add("build", "gradle build"); add("test", "gradle test")
+    if (root / "Gemfile").exists():
+        info["stack"].append("Ruby")
+    if (root / "composer.json").exists():
+        info["stack"].append("PHP")
+    # top-level layout (a few entries)
+    try:
+        entries = sorted(p.name for p in root.iterdir()
+                         if not p.name.startswith(".") and p.name not in ("node_modules", "venv"))
+        info["layout"] = entries[:20]
+    except Exception:
+        info["layout"] = []
+    return info
+
+
+def needs_scaffold(workspace: str) -> bool:
+    return not (Path(workspace) / ".krnl").exists()
+
+
+def _list(items: list, fallback: str = "(detect / fill in)") -> str:
+    return "\n".join(f"- `{x}`" for x in items) if items else f"- {fallback}"
+
+
+def _agents_md(info: dict) -> str:
+    stack = ", ".join(info["stack"]) or "(unknown)"
+    return f"""# Project memory - {info['name']}
+
+Auto-loaded into the agent's context. Edit freely; this is the source of truth
+for how to work in this repo.
+
+## Stack
+{stack}
+
+## Commands
+**Build/install**
+{_list(info['build'])}
+**Test**
+{_list(info['test'])}
+**Lint**
+{_list(info['lint'])}
+**Run/dev**
+{_list(info['run'])}
+
+## Conventions
+- (e.g. code style, branch naming, files to never touch)
+
+## Notes
+- (anything the agent should always know about this project)
+"""
+
+
+def _project_md(info: dict) -> str:
+    layout = "\n".join(f"- {x}" for x in info.get("layout", [])) or "- (run `list_files`)"
+    return f"""# {info['name']} - project overview
+
+> Auto-generated by Krnl Agent onboarding. Enrich it by asking the agent to
+> "study this codebase and update .krnl/PROJECT.md".
+
+**Stack:** {', '.join(info['stack']) or 'unknown'}
+**Git:** {'yes' if info['git'] else 'no'}
+
+## Top-level layout
+{layout}
+
+## How to build & test
+{_list(info['build'] + info['test'])}
+
+## Architecture notes
+- (the agent fills these in as it learns the codebase)
+"""
+
+
+def _skill_md(info: dict) -> str:
+    return f"""---
+description: How to explore and safely work in the {info['name']} codebase.
+---
+
+# Explore the {info['name']} codebase
+
+When asked to understand, change, or debug this project:
+
+1. Read `.krnl/PROJECT.md` and `.krnl/AGENTS.md` first for stack and commands.
+2. Map the structure with `list_files` and `glob`; read entry points and configs.
+3. Use `search_text` to locate symbols before editing; prefer `edit_file`.
+4. After changes, run the test command from memory and fix failures.
+5. Keep changes minimal and match existing style.
+
+Stack: {', '.join(info['stack']) or 'unknown'}
+"""
+
+
+def scaffold(workspace: str) -> list[str]:
+    """Create the .krnl scaffold (only files that don't already exist)."""
+    root = Path(workspace)
+    info = detect_project(workspace)
+    krnl = root / ".krnl"
+    (krnl / "skills" / "explore-codebase").mkdir(parents=True, exist_ok=True)
+    created: list[str] = []
+
+    mem = krnl / "AGENTS.md"
+    has_memory = any((root / n).exists() for n in ("AGENTS.md", "KRNL.md", "CLAUDE.md"))
+    if not mem.exists() and not has_memory:
+        mem.write_text(_agents_md(info), encoding="utf-8")
+        created.append(".krnl/AGENTS.md")
+
+    proj = krnl / "PROJECT.md"
+    if not proj.exists():
+        proj.write_text(_project_md(info), encoding="utf-8")
+        created.append(".krnl/PROJECT.md")
+
+    skill = krnl / "skills" / "explore-codebase" / "SKILL.md"
+    if not skill.exists():
+        skill.write_text(_skill_md(info), encoding="utf-8")
+        created.append(".krnl/skills/explore-codebase/SKILL.md")
+
+    return created

krnl_agent/schedules.py

@@ -0,0 +1,137 @@
+"""Scheduled agents — run tasks on cron schedules, independent of any terminal.
+
+    krnl-agent schedule create "PR summary" --cron "0 9 * * MON-FRI" \
+        --prompt "List all open PRs and their review status" --workspace /repo
+    krnl-agent schedule list
+    krnl-agent schedule run <id>
+    krnl-agent schedule daemon          # foreground loop that fires due schedules
+
+Schedules persist in ~/.krnl-agent/schedules.json across restarts. Includes a
+small dependency-free cron matcher (5 fields, supports *, lists, ranges, steps,
+and day/month names).
+"""
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime
+
+from .settings import SETTINGS_DIR
+
+SCHEDULES_FILE = SETTINGS_DIR / "schedules.json"
+
+_DOW = {"SUN": 0, "MON": 1, "TUE": 2, "WED": 3, "THU": 4, "FRI": 5, "SAT": 6}
+_MON = {m: i + 1 for i, m in enumerate(
+    ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"])}
+
+
+# --------------------------------------------------------------------------- #
+# Cron matching
+# --------------------------------------------------------------------------- #
+def _match_field(expr: str, value: int, names: dict | None = None) -> bool:
+    expr = expr.upper()
+    if names:
+        for n, v in names.items():
+            expr = expr.replace(n, str(v))
+    for part in expr.split(","):
+        step = 1
+        if "/" in part:
+            part, step_s = part.split("/", 1)
+            step = int(step_s)
+        if part in ("*", ""):
+            lo, hi = None, None
+        elif "-" in part:
+            a, b = part.split("-", 1)
+            lo, hi = int(a), int(b)
+        else:
+            lo = hi = int(part)
+        if lo is None:  # wildcard
+            if value % step == 0:
+                return True
+        elif lo <= value <= hi and (value - lo) % step == 0:
+            return True
+    return False
+
+
+def cron_match(expr: str, dt: datetime) -> bool:
+    fields = expr.split()
+    if len(fields) != 5:
+        return False
+    minute, hour, dom, month, dow = fields
+    cron_dow = (dt.weekday() + 1) % 7  # Python Mon=0..Sun=6 -> cron Sun=0..Sat=6
+    dom_r = dom not in ("*", "?")
+    dow_r = dow not in ("*", "?")
+    base = (
+        _match_field(minute, dt.minute)
+        and _match_field(hour, dt.hour)
+        and _match_field(month, dt.month, _MON)
+    )
+    if not base:
+        return False
+    dom_ok = _match_field(dom, dt.day)
+    dow_ok = _match_field(dow, cron_dow, _DOW)
+    # standard cron: when both day-fields are restricted, it's OR
+    if dom_r and dow_r:
+        return dom_ok or dow_ok
+    return dom_ok and dow_ok
+
+
+# --------------------------------------------------------------------------- #
+# Storage
+# --------------------------------------------------------------------------- #
+def _load() -> list[dict]:
+    try:
+        return json.loads(SCHEDULES_FILE.read_text(encoding="utf-8")).get("schedules", [])
+    except Exception:
+        return []
+
+
+def _save(rows: list[dict]) -> None:
+    SETTINGS_DIR.mkdir(parents=True, exist_ok=True)
+    SCHEDULES_FILE.write_text(json.dumps({"schedules": rows}, indent=2), encoding="utf-8")
+
+
+def create(name: str, cron: str, prompt: str, workspace: str,
+           provider: str | None = None, model: str | None = None) -> dict:
+    rows = _load()
+    sched = {
+        "id": uuid.uuid4().hex[:8],
+        "name": name,
+        "cron": cron,
+        "prompt": prompt,
+        "workspace": workspace,
+        "provider": provider,
+        "model": model,
+        "last_run": None,
+    }
+    rows.append(sched)
+    _save(rows)
+    return sched
+
+
+def list_schedules() -> list[dict]:
+    return _load()
+
+
+def remove(schedule_id: str) -> bool:
+    rows = _load()
+    new = [r for r in rows if r["id"] != schedule_id]
+    _save(new)
+    return len(new) != len(rows)
+
+
+def get(schedule_id: str) -> dict | None:
+    return next((r for r in _load() if r["id"] == schedule_id), None)
+
+
+def mark_run(schedule_id: str, stamp: str) -> None:
+    rows = _load()
+    for r in rows:
+        if r["id"] == schedule_id:
+            r["last_run"] = stamp
+    _save(rows)
+
+
+def due(now: datetime) -> list[dict]:
+    stamp = now.strftime("%Y-%m-%d %H:%M")
+    return [r for r in _load() if r.get("last_run") != stamp and cron_match(r["cron"], now)]

krnl_agent/secrets.py

@@ -0,0 +1,100 @@
+"""Secret scanner — find hard-coded credentials before they ship.
+
+A regex sweep over the workspace for the highest-signal secret shapes (API keys,
+private keys, tokens, connection strings). It is intentionally conservative to
+keep false positives low, reports `path:line` with the match masked, and never
+prints the full secret back into the model's context.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+# (label, compiled pattern). Patterns target distinctive secret shapes.
+_RULES: list[tuple[str, re.Pattern]] = [
+    ("AWS access key id", re.compile(r"\bAKIA[0-9A-Z]{16}\b")),
+    ("AWS secret access key", re.compile(r"(?i)aws.{0,20}secret.{0,20}['\"][0-9a-zA-Z/+]{40}['\"]")),
+    ("GitHub token", re.compile(r"\bgh[pousr]_[0-9A-Za-z]{36,}\b")),
+    ("GitHub fine-grained token", re.compile(r"\bgithub_pat_[0-9A-Za-z_]{60,}\b")),
+    ("Slack token", re.compile(r"\bxox[baprs]-[0-9A-Za-z-]{10,}\b")),
+    ("Google API key", re.compile(r"\bAIza[0-9A-Za-z\-_]{35}\b")),
+    ("OpenAI / sk- key", re.compile(r"\bsk-[A-Za-z0-9]{20,}\b")),
+    ("Anthropic key", re.compile(r"\bsk-ant-[A-Za-z0-9\-_]{20,}\b")),
+    ("PyPI token", re.compile(r"\bpypi-[A-Za-z0-9\-_]{40,}\b")),
+    ("Stripe key", re.compile(r"\b[sr]k_live_[0-9A-Za-z]{20,}\b")),
+    ("JWT", re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\b")),
+    ("Private key block", re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----")),
+    ("Generic secret assignment", re.compile(
+        r"(?i)(?:password|passwd|secret|api[_-]?key|access[_-]?token|auth[_-]?token)"
+        r"\s*[:=]\s*['\"][^'\"\s]{8,}['\"]")),
+    ("Connection string w/ password", re.compile(
+        r"(?i)(?:postgres|mysql|mongodb|redis|amqp)(?:\+\w+)?://[^:\s]+:[^@\s]+@")),
+]
+
+# Don't flag obvious placeholders.
+_PLACEHOLDER = re.compile(
+    r"(?i)(your[_-]?|example|placeholder|changeme|xxx+|\.\.\.|<[^>]+>|dummy|sample|test[_-]?key)")
+
+_MAX_HITS = 200
+
+
+def _mask(s: str) -> str:
+    s = s.strip().strip("'\"")
+    if len(s) <= 12:
+        return s[:2] + "…"
+    return f"{s[:4]}…{s[-4:]} (len {len(s)})"
+
+
+def scan(ctx, path: str = ".") -> tuple[int, str]:
+    """Scan the workspace for likely secrets. Returns (hit_count, report)."""
+    base = ctx.resolve(path)
+    hits: list[str] = []
+    scanned = 0
+    if base.is_file():
+        files = [base]
+    else:
+        files = []
+        for root, dirs, names in os.walk(base):
+            rroot = ctx.rel(Path(root))
+            dirs[:] = [d for d in sorted(dirs)
+                       if not ctx.is_ignored(f"{rroot}/{d}".lstrip("./"))]
+            for n in sorted(names):
+                fp = Path(root) / n
+                if not ctx.is_ignored(ctx.rel(fp)):
+                    files.append(fp)
+
+    for fp in files:
+        try:
+            if fp.stat().st_size > 400_000:
+                continue
+            with open(fp, "rb") as fb:
+                if b"\x00" in fb.read(2048):
+                    continue
+        except Exception:
+            continue
+        try:
+            with open(fp, encoding="utf-8", errors="ignore") as fh:
+                for i, line in enumerate(fh, 1):
+                    if len(line) > 1000:
+                        continue
+                    for label, rx in _RULES:
+                        m = rx.search(line)
+                        if m and not _PLACEHOLDER.search(m.group(0)):
+                            hits.append(f"{ctx.rel(fp)}:{i}: [{label}] {_mask(m.group(0))}")
+                            break
+                    if len(hits) >= _MAX_HITS:
+                        break
+        except Exception:
+            continue
+        scanned += 1
+        if len(hits) >= _MAX_HITS:
+            hits.append("… (more; truncated)")
+            break
+
+    if not hits:
+        return 0, f"No likely secrets found ({scanned} files scanned)."
+    report = (f"Found {len(hits)} potential secret(s) across {scanned} files. "
+              "Review each; rotate anything real and move it to env/secret storage:\n\n"
+              + "\n".join(hits))
+    return len(hits), report

krnl_agent/selfheal.py

@@ -0,0 +1,87 @@
+"""Self-healing — keep a deployment alive.
+
+Two cooperating loops (policy: rollback is autonomous, code fixes are PRs):
+
+  * FAST loop (deterministic, autonomous): after a deploy, poll the app's health
+    endpoint; if it's unhealthy, automatically roll back to the last known-good
+    release. This only ever reverts to a previous good state, so it is always safe
+    to run without asking.
+  * SLOW loop (generative, gated): pull current production errors (see monitor.py),
+    have the model write a patch + regression test, and open a PR for a human to
+    merge. That part is driven by the `heal` command's prompt, not this module — here
+    we provide the safe, deterministic primitives it builds on.
+"""
+from __future__ import annotations
+
+import time
+import urllib.error
+import urllib.request
+
+from . import deploy
+
+
+def http_health(url: str, timeout: float = 10.0) -> tuple[bool, str]:
+    """Single GET. Healthy = HTTP 2xx/3xx. Never raises."""
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "krnl-agent-health"})
+        with urllib.request.urlopen(req, timeout=timeout) as r:  # noqa: S310
+            code = getattr(r, "status", 200)
+            return (200 <= code < 400), f"HTTP {code}"
+    except urllib.error.HTTPError as e:
+        return (200 <= e.code < 400), f"HTTP {e.code}"
+    except Exception as e:  # noqa: BLE001
+        return False, f"unreachable: {type(e).__name__}: {e}"
+
+
+def check_health(url: str, path: str = "/health", attempts: int = 1,
+                 delay: float = 0.0, _sleep=time.sleep) -> tuple[bool, str]:
+    """Poll `url`+`path` up to `attempts` times. Returns (healthy, detail)."""
+    full = url.rstrip("/") + (path if path.startswith("/") else "/" + path)
+    last = ""
+    for i in range(max(1, attempts)):
+        ok, detail = http_health(full)
+        last = detail
+        if ok:
+            return True, f"healthy ({detail}) at {full}"
+        if i < attempts - 1 and delay:
+            _sleep(delay)
+    return False, f"unhealthy ({last}) at {full}"
+
+
+def rollback(ctx, target_name: str, params: dict | None = None) -> tuple[bool, str]:
+    """Build and RUN the rollback command for a target (autonomous, safe).
+
+    Returns (ok, output). Rolling back only restores a prior good release.
+    """
+    ok, cmd = deploy.rollback_command(target_name, params)
+    if not ok:
+        return False, cmd
+    from .tools import run_command  # lazy to avoid import cycle
+
+    outcome = run_command(ctx, cmd)
+    return outcome.ok, outcome.output
+
+
+def heal_once(ctx, url: str, target_name: str, params: dict | None = None,
+              path: str = "/health", attempts: int = 3, delay: float = 5.0) -> dict:
+    """Fast-loop self-heal: check health; if unhealthy, auto-rollback. Returns a
+    report dict (no exceptions). The generative error→PR step is handled by the
+    `heal` command prompt, not here."""
+    healthy, detail = check_health(url, path, attempts=attempts, delay=delay)
+    report = {"url": url, "target": target_name, "healthy": healthy, "detail": detail,
+              "action": "none", "rollback_ok": None, "rollback_output": ""}
+    if healthy:
+        return report
+    t = deploy.target(target_name)
+    if not t or not t.rollback_cmd:
+        report["action"] = "no-rollback-available"
+        return report
+    report["action"] = "rollback"
+    rb_ok, rb_out = rollback(ctx, target_name, params)
+    report["rollback_ok"] = rb_ok
+    report["rollback_output"] = rb_out[:500]
+    # Re-check after rollback.
+    healthy2, detail2 = check_health(url, path, attempts=attempts, delay=delay)
+    report["healthy_after_rollback"] = healthy2
+    report["detail_after_rollback"] = detail2
+    return report