pcli-agent 0.1.0__py3-none-any.whl

pcli/tools/toolbox/synthesize.py

@@ -0,0 +1,100 @@
+"""LLM-driven tool schema synthesis from raw --help text, for software
+without a curated plugin. Strictly schema-validated before being trusted;
+retries once with the validation error fed back if the first attempt
+doesn't parse/validate, then gives up rather than registering something
+malformed."""
+
+from __future__ import annotations
+
+import json
+
+import jsonschema
+
+from pcli.llm.client import GatewayClient
+from pcli.llm.models import ChatMessage
+
+SYNTHESIZED_TOOL_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "tools": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "pattern": "^[a-z][a-z0-9_]*$"},
+                    "description": {"type": "string"},
+                    "subcommand": {"type": "array", "items": {"type": "string"}},
+                    "parameters": {"type": "object"},
+                    "risk": {"type": "string", "enum": ["read", "mutate", "destructive"]},
+                },
+                "required": ["name", "description", "subcommand", "parameters", "risk"],
+            },
+        }
+    },
+    "required": ["tools"],
+}
+
+_SYSTEM_PROMPT = """You turn raw CLI --help output into a JSON list of tool definitions for \
+an AI agent to call. Rules:
+- Each tool maps to ONE specific subcommand invocation, given as an argv list in \
+"subcommand" (e.g. ["get", "pods"], or [] if the binary takes flags directly with no \
+subcommand).
+- "parameters" is a JSON Schema object (with "type": "object" and "properties") describing \
+the subcommand's *optional/value flags* as named properties (e.g. "namespace", "output"), \
+NOT positional words already baked into "subcommand". Use "type": "boolean" for flags that \
+take no value. Property names must be valid identifiers (letters, digits, underscore).
+- "risk" must be "read" for read-only/inspection commands, "mutate" for commands that change \
+state, "destructive" for commands that delete/terminate/irreversibly change state. When in \
+doubt, choose the more cautious (destructive over mutate, mutate over read).
+- Only include commands you are reasonably confident about from the help text. Fewer, \
+correct tools are better than many guessed ones.
+- Respond with ONLY a JSON object of the shape {"tools": [...]}, no prose, no code fences."""
+
+
+def _strip_code_fence(text: str) -> str:
+    if not text.startswith("```"):
+        return text
+    lines = text.splitlines()
+    if lines and lines[0].startswith("```"):
+        lines = lines[1:]
+    if lines and lines[-1].strip() == "```":
+        lines = lines[:-1]
+    return "\n".join(lines)
+
+
+async def synthesize_tools(
+    client: GatewayClient,
+    *,
+    software_name: str,
+    help_corpus: str,
+    model: str | None = None,
+) -> list[dict]:
+    messages = [
+        ChatMessage(role="system", content=_SYSTEM_PROMPT),
+        ChatMessage(
+            role="user",
+            content=f"Software: {software_name}\n\n--help output:\n\n{help_corpus[:12000]}",
+        ),
+    ]
+
+    last_error: Exception | None = None
+    for attempt in range(2):
+        message, _usage = await client.collect(messages, model=model)
+        raw = _strip_code_fence((message.content or "").strip())
+        try:
+            data = json.loads(raw)
+            jsonschema.validate(data, SYNTHESIZED_TOOL_SCHEMA)
+            return data["tools"]
+        except (json.JSONDecodeError, jsonschema.ValidationError) as exc:
+            last_error = exc
+            if attempt == 0:
+                messages.append(ChatMessage(role="assistant", content=raw))
+                messages.append(
+                    ChatMessage(
+                        role="user",
+                        content=f"That wasn't valid: {exc}. Respond again with ONLY the "
+                        "corrected JSON object.",
+                    )
+                )
+
+    raise ValueError(f"Could not synthesize a valid tool schema for '{software_name}': {last_error}")

pcli/tui/app.py

@@ -0,0 +1,37 @@
+"""Root Textual application."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App
+
+from pcli.config.settings import Settings, get_settings
+from pcli.session.models import Session
+from pcli.tui.screens.chat import ChatScreen
+from pcli.tui.themes import VIM_THEMES
+
+_STYLES_PATH = Path(__file__).parent / "styles" / "pcli.tcss"
+
+
+class PcliApp(App):
+    CSS_PATH = str(_STYLES_PATH)
+    TITLE = "pcli"
+
+    def __init__(self, settings: Settings | None = None, *, session: Session | None = None) -> None:
+        super().__init__()
+        self._settings = settings or get_settings()
+        self._initial_session = session
+
+    def on_mount(self) -> None:
+        for theme in VIM_THEMES:
+            self.register_theme(theme)
+        # settings.ui_theme is free-text (hand-edited config.toml, or a
+        # stale value from a pcli version whose theme set has since
+        # changed) - applying an unknown name would raise straight out of
+        # on_mount, so this is checked rather than trusted. Falls back to
+        # whatever App.theme already defaults to (textual-dark) rather than
+        # failing the whole app over one bad setting.
+        if self._settings.ui_theme in self.available_themes:
+            self.theme = self._settings.ui_theme
+        self.push_screen(ChatScreen(self._settings, session=self._initial_session))

pcli/tui/screens/ask_question_modal.py

@@ -0,0 +1,54 @@
+"""Modal that implements the ask_user_question tool's ask_question
+callback via Textual — lets the model pause a turn to ask the user
+something directly, optionally with a fixed set of suggested answers,
+mirroring opencode's "ask" tool. A free-text field is always available
+regardless of whether options are given, so a suggested answer never
+forecloses a different one."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import App, ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static
+
+from pcli.tui.widgets.paste_input import PasteInput
+
+
+class AskQuestionModal(ModalScreen[str]):
+    def __init__(self, question: str, options: list[str] | None = None) -> None:
+        super().__init__()
+        self._question = question
+        self._options = options or []
+
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="ask-question-modal"):
+            yield Static(self._question, id="ask-question-text")
+            if self._options:
+                with Vertical(id="ask-question-options"):
+                    for index, option in enumerate(self._options):
+                        yield Button(option, id=f"ask-question-option-{index}")
+            yield PasteInput(
+                placeholder="Or type your own answer and press Enter...",
+                id="ask-question-input",
+            )
+
+    def on_mount(self) -> None:
+        self.query_one(PasteInput).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        for index, option in enumerate(self._options):
+            if event.button.id == f"ask-question-option-{index}":
+                self.dismiss(option)
+                return
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        answer = event.value.strip()
+        if answer:
+            self.dismiss(answer)
+
+
+async def ask_question_via_modal(app: App[Any], question: str, options: list[str] | None) -> str:
+    return await app.push_screen_wait(AskQuestionModal(question, options))