kryth 1.0.0__tar.gz

kryth-1.0.0/LICENSE

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

kryth-1.0.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: kryth
+Version: 1.0.0
+Summary: KRYTH CLI: Autonomous Coding Intelligence — terminal AI coding agent with tools, sessions, and OpenAI-compatible model support
+Author: Navadeep
+License-Expression: MIT
+Keywords: ai,coding-agent,ai-coder,cli,openai-compatible,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Terminals
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: prompt_toolkit>=3.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: bridge
+Requires-Dist: fastapi>=0.110.0; extra == "bridge"
+Requires-Dist: uvicorn>=0.29.0; extra == "bridge"
+Requires-Dist: websockets>=12.0; extra == "bridge"
+Requires-Dist: playwright>=1.44.0; extra == "bridge"
+Dynamic: license-file

kryth-1.0.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kryth"
+version = "1.0.0"
+description = "KRYTH CLI: Autonomous Coding Intelligence — terminal AI coding agent with tools, sessions, and OpenAI-compatible model support"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+  { name = "Navadeep" }
+]
+keywords = ["ai", "coding-agent", "ai-coder", "cli", "openai-compatible", "developer-tools"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development",
+  "Topic :: Terminals",
+]
+
+dependencies = [
+  "openai>=1.0.0",
+  "prompt_toolkit>=3.0.0",
+  "rich>=13.0.0",
+  "python-dotenv>=1.0.0",
+]
+
+[project.optional-dependencies]
+bridge = [
+  "fastapi>=0.110.0",
+  "uvicorn>=0.29.0",
+  "websockets>=12.0",
+  "playwright>=1.44.0",
+]
+
+[project.scripts]
+
+kryth = "kryth.main:main"
+kryth-cli = "kryth.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

kryth-1.0.0/setup.cfg

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

kryth-1.0.0/src/agent/__init__.py

@@ -0,0 +1,141 @@
+"""Tool registry for the agent loop.
+
+Public surface:
+
+- ``TOOLS``         — name → callable. Used by the dispatcher.
+- ``TOOL_SPECS``    — JSON-schema list passed to the LLM via ``tools=``.
+- ``READ_ONLY_TOOLS`` — names safe in plan mode.
+- ``RUN_COMMAND_ERROR_MARKER`` — sentinel used to flag non-zero exits.
+
+Implementations live in private submodules (``_file_ops``, ``_search``,
+``_shell``, ``_todos``, ``_plan``, ``_subagent``). ``_specs`` carries
+the LLM-facing schemas. The registry is assembled here so callers can
+keep doing ``from agent.tools import TOOLS, TOOL_SPECS``.
+"""
+
+from __future__ import annotations
+
+from agent.tools._common import RUN_COMMAND_ERROR_MARKER
+from agent.tools._file_ops import (
+    read_file,
+    write_file,
+    edit_file,
+    multi_edit,
+    delete_file,
+    list_files,
+    rollback_file,
+)
+from agent.tools._memory import add_memory
+from agent.tools._search import (
+    search_code,
+    grep,
+    glob_files,
+    semantic_search,
+    lookup_symbol,
+    lookup_imports,
+    lookup_dependents,
+)
+from agent.tools._shell import run_command, task_output
+from agent.tools._todos import todo_write, todo_read
+from agent.tools._plan import exit_plan_mode
+from agent.tools._subagent import spawn_agent, spawn_agents_parallel
+from agent.tools._critique import self_critique
+from agent.tools._git import git_op
+from agent.tools._verify import verify_files
+from agent.tools._debug import diagnose_error
+from agent.tools._project_runner import run_tests, run_install
+from agent.tools._checkpoint import checkpoint
+from agent.tools._task_graph import run_task_graph
+from agent.tools._specs import TOOL_SPECS
+
+
+TOOLS = {
+    "read_file": read_file,
+    "write_file": write_file,
+    "edit_file": edit_file,
+    "multi_edit": multi_edit,
+    "delete_file": delete_file,
+    "list_files": list_files,
+    "rollback_file": rollback_file,
+    "run_command": run_command,
+    "task_output": task_output,
+    "search_code": search_code,
+    "grep": grep,
+    "glob": glob_files,
+    "semantic_search": semantic_search,
+    "lookup_symbol": lookup_symbol,
+    "lookup_imports": lookup_imports,
+    "lookup_dependents": lookup_dependents,
+    "todo_write": todo_write,
+    "todo_read": todo_read,
+    "exit_plan_mode": exit_plan_mode,
+    "spawn_agent": spawn_agent,
+    "spawn_agents_parallel": spawn_agents_parallel,
+    "self_critique": self_critique,
+    "git_op": git_op,
+    "verify_files": verify_files,
+    "diagnose_error": diagnose_error,
+    "run_tests": run_tests,
+    "run_install": run_install,
+    "checkpoint": checkpoint,
+    "run_task_graph": run_task_graph,
+    "add_memory": add_memory,
+}
+
+
+READ_ONLY_TOOLS = {
+    "read_file",
+    "list_files",
+    "search_code",
+    "grep",
+    "glob",
+    "semantic_search",
+    "lookup_symbol",
+    "lookup_imports",
+    "lookup_dependents",
+    "todo_read",
+    "todo_write",
+    "task_output",
+    "exit_plan_mode",
+    "self_critique",
+    "verify_files",
+    "diagnose_error",
+}
+
+
+# Tools that emit their own visual representation (panel, diff, todo
+# list) and don't need the generic "⎿ first-line preview" tee under
+# their tool header. The agent loop reads this set when deciding
+# whether to emit ``tool_result``.
+SELF_RENDERED_TOOLS = {
+    "write_file",
+    "edit_file",
+    "multi_edit",
+    "run_command",
+    "todo_write",
+    "exit_plan_mode",
+}
+
+
+# Sanity check at import: the spec list and the registry must agree.
+# Drift here would silently advertise non-existent tools to the model
+# (or hide real ones), so we fail fast instead.
+_spec_names = {t["function"]["name"] for t in TOOL_SPECS}
+_registry_names = set(TOOLS.keys())
+if _spec_names != _registry_names:
+    missing_specs = _registry_names - _spec_names
+    missing_tools = _spec_names - _registry_names
+    raise RuntimeError(
+        "tools registry / specs mismatch — "
+        f"in TOOLS but not TOOL_SPECS: {sorted(missing_specs)}; "
+        f"in TOOL_SPECS but not TOOLS: {sorted(missing_tools)}"
+    )
+
+
+__all__ = [
+    "TOOLS",
+    "TOOL_SPECS",
+    "READ_ONLY_TOOLS",
+    "SELF_RENDERED_TOOLS",
+    "RUN_COMMAND_ERROR_MARKER",
+]

kryth-1.0.0/src/agent/_checkpoint.py

@@ -0,0 +1,43 @@
+"""Milestone-checkpoint tool.
+
+Lets the agent record "I just finished phase X" markers into the
+persisted session transcript. Useful for long-horizon tasks: the
+operator can scan checkpoints on ``/resume`` and see structured
+milestones instead of scrolling through raw tool calls.
+"""
+
+from __future__ import annotations
+
+from agent.tools._results import err
+
+
+def checkpoint(label, summary: str = "", modified_files=None):
+    """Write a milestone marker into the session transcript.
+
+    ``label``           — short title (kebab-case recommended, max 120 chars).
+    ``summary``         — one paragraph describing what was just completed
+                          and any decisions worth remembering on resume.
+    ``modified_files``  — optional list of paths touched by this milestone.
+    """
+    if not isinstance(label, str) or not label.strip():
+        return err("BAD_ARGS", "checkpoint: label must be a non-empty string")
+
+    if modified_files is not None and not isinstance(modified_files, list):
+        return err("BAD_ARGS", "checkpoint: modified_files must be a list of strings")
+
+    from agent.persistence import session_store
+    store = session_store()
+    cp = store.append_checkpoint(
+        label=label.strip(),
+        summary=str(summary or ""),
+        modified_files=[p for p in (modified_files or []) if isinstance(p, str)],
+    )
+    if cp is None:
+        return "(checkpoint not persisted — session store unavailable)"
+    return (
+        f"checkpoint recorded: {cp['label']!s} at turn {cp['turn_index']}"
+        + (f" ({len(cp['modified_files'])} files)" if cp.get("modified_files") else "")
+    )
+
+
+__all__ = ["checkpoint"]

kryth-1.0.0/src/agent/_common.py

@@ -0,0 +1,44 @@
+"""Shared helpers used across tool implementations."""
+
+from __future__ import annotations
+
+from agent.tools._results import TOOL_ERROR_PREFIX, err
+
+
+# Legacy alias. New code should call ``err("NON_ZERO_EXIT", ...)`` from
+# ``_results``; this name remains so the rest of the codebase (and any
+# saved transcripts) can still detect "a tool error happened" by
+# substring match. Both the new ``[ERROR ...]`` prefix and historical
+# ``[NON_ZERO_EXIT]`` results match it.
+RUN_COMMAND_ERROR_MARKER = TOOL_ERROR_PREFIX
+
+# Max chars stored for a single tool result. Head + tail are preserved
+# so both setup context and error tails (stack traces, last-test-failure
+# line) survive trimming. read_file is exempt — it has its own
+# offset/limit pagination.
+TOOL_OUTPUT_BUDGET = 3000
+
+
+def trim_head_tail(text: str, budget: int = TOOL_OUTPUT_BUDGET) -> str:
+    """Trim long output to head + tail with an elision marker.
+
+    Returns ``text`` unchanged when under budget. Otherwise keeps the
+    first ``budget // 2`` chars and the last ``budget // 2`` chars,
+    joined by a single-line marker showing how much was dropped.
+    """
+    if len(text) <= budget:
+        return text
+    half = budget // 2
+    dropped = len(text) - 2 * half
+    head = text[:half]
+    tail = text[-half:]
+    return f"{head}\n...[truncated {dropped} chars]...\n{tail}"
+
+
+__all__ = [
+    "RUN_COMMAND_ERROR_MARKER",
+    "TOOL_ERROR_PREFIX",
+    "TOOL_OUTPUT_BUDGET",
+    "err",
+    "trim_head_tail",
+]

kryth-1.0.0/src/agent/_critique.py

@@ -0,0 +1,114 @@
+"""Self-critique tool.
+
+Lets the agent pause after a non-trivial edit batch and ask a cheap
+reviewer model to grade its own work. The reviewer reads a unified diff
+between the most recent snapshot and the current file (or the diff for
+a list of files) and returns ``[BUG]`` / ``[RISK]`` / ``[SUSPECT]``
+findings — or ``LGTM`` if nothing stands out.
+
+Why this is its own tool rather than a hook on every write:
+- Critique costs a model call. Auto-running on every micro-edit would
+  burn quota.
+- The agent chooses when it has reached a meaningful checkpoint
+  (feature done, refactor finished). That's the right granularity.
+"""
+
+from __future__ import annotations
+
+import difflib
+import os
+from pathlib import Path
+
+from agent import snapshots
+from agent.tools._results import err
+
+
+def _read_text(path: str) -> str | None:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            return f.read()
+    except (OSError, UnicodeDecodeError):
+        return None
+
+
+def _diff_against_snapshot(path: str) -> tuple[str, str]:
+    """Return ``(diff_text, status)`` for ``path``.
+
+    ``status`` describes what kind of comparison happened: ``ok``,
+    ``no-snapshot``, ``unreadable``. The diff is empty whenever the file
+    contents match the latest snapshot (no change to review).
+    """
+    backups = snapshots.list_snapshots(path)
+    current = _read_text(path)
+    if current is None:
+        return "", "unreadable"
+    if not backups:
+        return "", "no-snapshot"
+
+    backup_path = backups[0]["backup_path"]
+    try:
+        with open(backup_path, "r", encoding="utf-8") as f:
+            previous = f.read()
+    except (OSError, UnicodeDecodeError):
+        return "", "unreadable"
+
+    if previous == current:
+        return "", "unchanged"
+
+    diff = "\n".join(difflib.unified_diff(
+        previous.splitlines(),
+        current.splitlines(),
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+        lineterm="",
+    ))
+    return diff, "ok"
+
+
+def self_critique(paths, intent: str = ""):
+    """Ask the reviewer model to grade recent edits to ``paths``.
+
+    ``paths`` may be a single path or a list. Each file is diffed against
+    its most recent snapshot; the combined diff is sent to the critic.
+
+    ``intent`` is a one-line description of the goal the edits were
+    meant to achieve — gives the reviewer the success criterion to
+    measure against.
+    """
+    from agent.llm import critique
+
+    if isinstance(paths, str):
+        path_list = [paths]
+    elif isinstance(paths, list):
+        path_list = [p for p in paths if isinstance(p, str) and p.strip()]
+    else:
+        return err(
+            "BAD_ARGS",
+            "self_critique: paths must be a string or list of strings",
+        )
+
+    if not path_list:
+        return err("BAD_ARGS", "self_critique: paths is empty")
+
+    diffs: list[str] = []
+    statuses: dict[str, str] = {}
+    for p in path_list:
+        d, status = _diff_against_snapshot(p)
+        statuses[p] = status
+        if d:
+            diffs.append(d)
+
+    if not diffs:
+        nothing = ", ".join(f"{p}={statuses[p]}" for p in path_list)
+        return f"(no diff to review — {nothing})"
+
+    combined = "\n".join(diffs)
+    findings = critique(combined, intent=intent)
+    if not findings:
+        return "(critique unavailable — proceeding without review)"
+
+    header = f"critic reviewed {len(diffs)} file(s) vs latest snapshot:"
+    return header + "\n" + findings
+
+
+__all__ = ["self_critique"]

kryth-1.0.0/src/agent/_debug.py

@@ -0,0 +1,55 @@
+"""Autonomous-debug helper tool.
+
+Lets the agent ask a cheap reviewer model to triage a failed command —
+"what's broken and what should I try next" — without burning the main
+model's context on long error traces. The agent stays in the driver's
+seat: this tool gives a diagnosis, the agent decides what to do.
+"""
+
+from __future__ import annotations
+
+from agent.tools._results import err
+
+
+def diagnose_error(
+    command,
+    stdout: str = "",
+    stderr: str = "",
+    exit_code: int = 1,
+    context_hint: str = "",
+):
+    """Diagnose a failed command. Returns the model's CAUSE/FIX/CONFIDENCE
+    block, or a structured error if inputs are unusable.
+
+    ``command``         — the literal command that ran (string).
+    ``stdout/stderr``   — captured output; tails are kept, head dropped.
+    ``exit_code``       — the non-zero exit code.
+    ``context_hint``    — optional one-liner: what the agent was trying
+                          to accomplish, so the diagnosis isn't context-free.
+    """
+    if not isinstance(command, str) or not command.strip():
+        return err("BAD_ARGS", "diagnose_error: command must be a non-empty string")
+
+    try:
+        ec = int(exit_code)
+    except (TypeError, ValueError):
+        return err("BAD_ARGS", "diagnose_error: exit_code must be an integer")
+
+    if ec == 0 and not (stderr or "").strip():
+        return "(command appears to have succeeded — nothing to diagnose)"
+
+    from agent.llm import diagnose_error as _ask
+
+    findings = _ask(
+        command=command.strip(),
+        stdout=str(stdout or ""),
+        stderr=str(stderr or ""),
+        exit_code=ec,
+        context_hint=str(context_hint or ""),
+    )
+    if not findings:
+        return "(diagnosis unavailable — proceed manually)"
+    return findings
+
+
+__all__ = ["diagnose_error"]