claude-p 0.1.0__tar.gz

claude_p-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,21 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - run: uvx twine check dist/*
+      - uses: pypa/gh-action-pypi-publish@release/v1
+

claude_p-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+dist/
+build/
+*.egg-info/
+.DS_Store
+

claude_p-0.1.0/LICENSE

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

claude_p-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: claude-p
+Version: 0.1.0
+Summary: Claude -p compatible wrapper backed by interactive Claude Code subscription sessions
+Project-URL: Homepage, https://github.com/Equality-Machine/claude-p
+Project-URL: Repository, https://github.com/Equality-Machine/claude-p
+Project-URL: Issues, https://github.com/Equality-Machine/claude-p/issues
+Author: Equality Machine
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent,claude,claude-code,cli,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# claude-p
+
+`claude-p` is a `claude -p` compatible Python CLI and SDK backed by the
+interactive Claude Code TUI.
+
+Use it when `claude -p` is unavailable in an environment, but interactive
+`claude` works with the local Claude Code subscription login state.
+
+## Install
+
+```bash
+pip install claude-p
+```
+
+## CLI
+
+Default output matches `claude -p`: plain text.
+
+```bash
+claude-p.py "Respond exactly: hello"
+```
+
+Structured outputs:
+
+```bash
+claude-p.py "Respond exactly: hello" --output-format json
+claude-p.py "Respond exactly: hello" --output-format stream-json --include-partial-messages
+```
+
+The CLI accepts a broad subset of `claude -p` flags, including:
+
+- `-p`, `--print`
+- `--model`
+- `--tools`
+- `--permission-mode`
+- `--output-format text|json|stream-json`
+- `--include-partial-messages`
+- `--session-id`
+- `--cwd`
+- common Claude Code context/config flags such as `--system-prompt`,
+  `--append-system-prompt`, `--mcp-config`, `--settings`, `--plugin-dir`,
+  `--allowedTools`, `--disallowedTools`, `--resume`, and `--continue`
+
+Known limits:
+
+- Token usage, cost, and exact rate-limit fields are best-effort placeholders.
+- Hook lifecycle events from `claude -p --include-hook-events` are not replayed yet.
+- `--input-format stream-json` is accepted but not implemented.
+- `--bare` conflicts with the subscription-login goal because Claude bare mode
+  bypasses OAuth/keychain auth.
+
+## Python SDK
+
+The API is intentionally shaped like the official Claude Agent SDK:
+
+```python
+import asyncio
+from claude_p import ClaudePOptions, query
+
+
+async def main():
+    options = ClaudePOptions(
+        model="sonnet",
+        tools="default",
+        permission_mode="default",
+    )
+
+    async for message in query("这个目录里有多少个文件", options=options):
+        print(message)
+
+
+asyncio.run(main())
+```
+
+For a single final result:
+
+```python
+import asyncio
+from claude_p import ClaudePClient, ClaudePOptions
+
+
+async def main():
+    async with ClaudePClient(ClaudePOptions(model="sonnet")) as client:
+        result = await client.run("Respond exactly: SDK_OK")
+        print(result.result)
+
+
+asyncio.run(main())
+```
+
+## How it works
+
+The wrapper does not call `claude -p`.
+
+It:
+
+1. starts interactive `claude` in a pseudo-TTY;
+2. passes a deterministic `--session-id`;
+3. waits for the TUI response to complete;
+4. reads Claude Code's canonical session JSONL from
+   `~/.claude/projects/**/<session-id>.jsonl`;
+5. emits text/json/stream-json output compatible with `claude -p`.
+
+The session JSONL is required because terminal rendering is lossy and can drop
+characters during redraws.
+

claude_p-0.1.0/README.md

@@ -0,0 +1,106 @@
+# claude-p
+
+`claude-p` is a `claude -p` compatible Python CLI and SDK backed by the
+interactive Claude Code TUI.
+
+Use it when `claude -p` is unavailable in an environment, but interactive
+`claude` works with the local Claude Code subscription login state.
+
+## Install
+
+```bash
+pip install claude-p
+```
+
+## CLI
+
+Default output matches `claude -p`: plain text.
+
+```bash
+claude-p.py "Respond exactly: hello"
+```
+
+Structured outputs:
+
+```bash
+claude-p.py "Respond exactly: hello" --output-format json
+claude-p.py "Respond exactly: hello" --output-format stream-json --include-partial-messages
+```
+
+The CLI accepts a broad subset of `claude -p` flags, including:
+
+- `-p`, `--print`
+- `--model`
+- `--tools`
+- `--permission-mode`
+- `--output-format text|json|stream-json`
+- `--include-partial-messages`
+- `--session-id`
+- `--cwd`
+- common Claude Code context/config flags such as `--system-prompt`,
+  `--append-system-prompt`, `--mcp-config`, `--settings`, `--plugin-dir`,
+  `--allowedTools`, `--disallowedTools`, `--resume`, and `--continue`
+
+Known limits:
+
+- Token usage, cost, and exact rate-limit fields are best-effort placeholders.
+- Hook lifecycle events from `claude -p --include-hook-events` are not replayed yet.
+- `--input-format stream-json` is accepted but not implemented.
+- `--bare` conflicts with the subscription-login goal because Claude bare mode
+  bypasses OAuth/keychain auth.
+
+## Python SDK
+
+The API is intentionally shaped like the official Claude Agent SDK:
+
+```python
+import asyncio
+from claude_p import ClaudePOptions, query
+
+
+async def main():
+    options = ClaudePOptions(
+        model="sonnet",
+        tools="default",
+        permission_mode="default",
+    )
+
+    async for message in query("这个目录里有多少个文件", options=options):
+        print(message)
+
+
+asyncio.run(main())
+```
+
+For a single final result:
+
+```python
+import asyncio
+from claude_p import ClaudePClient, ClaudePOptions
+
+
+async def main():
+    async with ClaudePClient(ClaudePOptions(model="sonnet")) as client:
+        result = await client.run("Respond exactly: SDK_OK")
+        print(result.result)
+
+
+asyncio.run(main())
+```
+
+## How it works
+
+The wrapper does not call `claude -p`.
+
+It:
+
+1. starts interactive `claude` in a pseudo-TTY;
+2. passes a deterministic `--session-id`;
+3. waits for the TUI response to complete;
+4. reads Claude Code's canonical session JSONL from
+   `~/.claude/projects/**/<session-id>.jsonl`;
+5. emits text/json/stream-json output compatible with `claude -p`.
+
+The session JSONL is required because terminal rendering is lossy and can drop
+characters during redraws.
+

claude_p-0.1.0/claude-p.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+"""Repository-local entrypoint for development checkouts."""
+
+from claude_p.cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

claude_p-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "claude-p"
+version = "0.1.0"
+description = "Claude -p compatible wrapper backed by interactive Claude Code subscription sessions"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+  { name = "Equality Machine" }
+]
+keywords = ["claude", "claude-code", "agent", "sdk", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/Equality-Machine/claude-p"
+Repository = "https://github.com/Equality-Machine/claude-p"
+Issues = "https://github.com/Equality-Machine/claude-p/issues"
+
+[project.scripts]
+claude-p = "claude_p.cli:main"
+"claude-p.py" = "claude_p.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/claude_p"]
+

claude_p-0.1.0/src/claude_p/__init__.py

@@ -0,0 +1,16 @@
+"""Python SDK for the interactive Claude Code `claude -p` fallback."""
+
+from .sdk import ClaudePClient, ClaudePOptions, query
+from .types import AssistantMessage, ResultMessage, SDKMessage, StreamEventMessage, SystemMessage
+
+__all__ = [
+    "AssistantMessage",
+    "ClaudePClient",
+    "ClaudePOptions",
+    "ResultMessage",
+    "SDKMessage",
+    "StreamEventMessage",
+    "SystemMessage",
+    "query",
+]
+

claude_p-0.1.0/src/claude_p/__main__.py

@@ -0,0 +1,6 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

claude_p-0.1.0/src/claude_p/cli.py

@@ -0,0 +1,702 @@
+#!/usr/bin/env python3
+"""Claude Code interactive-TUI backend with `claude -p` compatible output.
+
+This script does not invoke `claude -p`. It starts interactive `claude` under a
+pseudo-TTY, captures the rendered terminal, extracts the assistant answer, and
+emits text/json/stream-json output shaped like `claude -p`.
+
+Compatibility target:
+- Same line-oriented JSON transport.
+- Same core event families: system init, stream_event message_start,
+  content_block_start/delta/stop, assistant, message_delta, message_stop, result.
+- Usage/cost/tool events are best-effort placeholders because the interactive
+  TUI does not expose a machine-readable protocol.
+"""
+
+from __future__ import annotations
+
+import argparse
+import glob
+import json
+import os
+from pathlib import Path
+import pty
+import re
+import select
+import signal
+import subprocess
+import sys
+import time
+import uuid
+
+
+ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+OSC_RE = re.compile(r"\x1b\][^\x07]*(?:\x07|\x1b\\)")
+SPINNER_RE = re.compile(r"\n?[✳✶✻✽✢·].*$", re.DOTALL)
+
+
+def warn(message: str) -> None:
+    print(f"claude_tui_agent.py: warning: {message}", file=sys.stderr)
+
+
+def append_flag(cmd: list[str], enabled: bool, flag: str) -> None:
+    if enabled:
+        cmd.append(flag)
+
+
+def append_value(cmd: list[str], flag: str, value: str | None) -> None:
+    if value is not None:
+        cmd.extend([flag, value])
+
+
+def append_optional_value(cmd: list[str], flag: str, value: str | None) -> None:
+    if value is None:
+        return
+    cmd.append(flag)
+    if value:
+        cmd.append(value)
+
+
+def append_repeated_values(cmd: list[str], flag: str, values: list[str] | None) -> None:
+    if not values:
+        return
+    for value in values:
+        cmd.extend([flag, value])
+
+
+def now_ms(start: float) -> int:
+    return int((time.time() - start) * 1000)
+
+
+def emit(obj: dict, enabled: bool = True) -> None:
+    if enabled:
+        print(json.dumps(obj, ensure_ascii=False, separators=(",", ":")), flush=True)
+
+
+def clean_terminal(text: str) -> str:
+    text = OSC_RE.sub("", text)
+    text = ANSI_RE.sub("", text)
+    return text.replace("\r", "").replace("\u00a0", " ")
+
+
+def normalize_answer(text: str) -> str:
+    text = clean_terminal(text)
+    text = SPINNER_RE.sub("", text)
+    # Drop common TUI chrome if it leaked into the block.
+    text = re.split(r"\n?────────────────", text, maxsplit=1)[0]
+    return text.strip()
+
+
+def extract_assistant_snapshot(transcript: str) -> str:
+    clean = clean_terminal(transcript)
+    marker = clean.rfind("⏺")
+    if marker < 0:
+        return ""
+    after = clean[marker + len("⏺") :]
+    return normalize_answer(after)
+
+
+def classify_failure(transcript: str, assistant_text: str, timed_out: bool) -> str | None:
+    if assistant_text:
+        return None
+    low = transcript.lower()
+    if "do you trust" in low or "workspace trust" in low:
+        return "workspace_trust_blocked"
+    if "permission" in low and ("allow" in low or "deny" in low):
+        return "tool_approval_blocked"
+    if timed_out:
+        return "assistant_output_timeout"
+    return "assistant_output_not_found"
+
+
+def build_usage(output_text: str) -> dict:
+    # The TUI does not expose reliable token/cost data. Keep shape-compatible
+    # fields with null/zero values and mark the source in result metadata.
+    approx_output_tokens = max(1, len(output_text.split()))
+    return {
+        "input_tokens": None,
+        "cache_creation_input_tokens": None,
+        "cache_read_input_tokens": None,
+        "output_tokens": approx_output_tokens,
+        "server_tool_use": {"web_search_requests": 0, "web_fetch_requests": 0},
+        "service_tier": None,
+        "cache_creation": {"ephemeral_1h_input_tokens": None, "ephemeral_5m_input_tokens": None},
+        "iterations": [
+            {
+                "input_tokens": None,
+                "output_tokens": approx_output_tokens,
+                "cache_read_input_tokens": None,
+                "cache_creation_input_tokens": None,
+                "cache_creation": {
+                    "ephemeral_5m_input_tokens": None,
+                    "ephemeral_1h_input_tokens": None,
+                },
+                "type": "message",
+            }
+        ],
+        "speed": None,
+    }
+
+
+def extract_text_from_content(content: object) -> str:
+    if isinstance(content, str):
+        return content
+    if not isinstance(content, list):
+        return ""
+    parts: list[str] = []
+    for block in content:
+        if isinstance(block, dict) and block.get("type") == "text":
+            text = block.get("text")
+            if isinstance(text, str):
+                parts.append(text)
+    return "".join(parts).strip()
+
+
+def canonical_json_if_equivalent(left: str, right: str) -> str | None:
+    try:
+        left_obj = json.loads(left)
+        right_obj = json.loads(right)
+    except json.JSONDecodeError:
+        return None
+    if left_obj != right_obj:
+        return None
+    return json.dumps(right_obj, ensure_ascii=False, separators=(",", ":"))
+
+
+def read_persisted_assistant(session_id: str) -> dict | None:
+    """Read Claude Code's persisted JSONL for exact final assistant text.
+
+    The interactive terminal is a lossy rendering surface: wide glyphs, cursor
+    redraws, and spinner updates can drop or smear characters in the captured
+    TTY transcript. Claude Code still writes the canonical session JSONL for
+    interactive sessions. When available, use it as the source of truth for the
+    final assistant message while keeping the TUI transcript as provenance.
+    """
+    pattern = str(Path.home() / ".claude" / "projects" / "**" / f"{session_id}.jsonl")
+    paths = [Path(p) for p in glob.glob(pattern, recursive=True)]
+    if not paths:
+        return None
+    path = max(paths, key=lambda p: p.stat().st_mtime)
+    latest: dict | None = None
+    try:
+        with path.open() as f:
+            for line in f:
+                try:
+                    event = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if event.get("type") != "assistant":
+                    continue
+                message = event.get("message")
+                if not isinstance(message, dict):
+                    continue
+                text = extract_text_from_content(message.get("content"))
+                if not text:
+                    continue
+                latest = {
+                    "path": str(path),
+                    "text": text,
+                    "message": message,
+                    "model": message.get("model"),
+                    "message_id": message.get("id"),
+                    "usage": message.get("usage"),
+                    "stop_reason": message.get("stop_reason"),
+                }
+    except OSError:
+        return None
+    return latest
+
+
+def run_tui(args: argparse.Namespace, stream_json: bool) -> tuple[str, str, int | None, bool, float]:
+    cmd = ["claude", "--session-id", args.session_id]
+
+    # Pass through options that the interactive `claude` entrypoint itself
+    # understands. Print-only options are handled by this wrapper and are not
+    # forwarded.
+    append_repeated_values(cmd, "--add-dir", args.add_dir)
+    append_value(cmd, "--agent", args.agent)
+    append_value(cmd, "--agents", args.agents)
+    append_flag(cmd, args.allow_dangerously_skip_permissions, "--allow-dangerously-skip-permissions")
+    append_repeated_values(cmd, "--allowedTools", args.allowed_tools)
+    append_value(cmd, "--append-system-prompt", args.append_system_prompt)
+    append_repeated_values(cmd, "--betas", args.betas)
+    append_flag(cmd, args.brief, "--brief")
+    append_flag(cmd, args.chrome, "--chrome")
+    append_flag(cmd, args.no_chrome, "--no-chrome")
+    append_flag(cmd, args.continue_session, "--continue")
+    append_flag(cmd, args.dangerously_skip_permissions, "--dangerously-skip-permissions")
+    append_optional_value(cmd, "--debug", args.debug)
+    append_value(cmd, "--debug-file", args.debug_file)
+    append_flag(cmd, args.disable_slash_commands, "--disable-slash-commands")
+    append_repeated_values(cmd, "--disallowedTools", args.disallowed_tools)
+    append_value(cmd, "--effort", args.effort)
+    append_flag(cmd, args.exclude_dynamic_system_prompt_sections, "--exclude-dynamic-system-prompt-sections")
+    append_repeated_values(cmd, "--file", args.files)
+    append_flag(cmd, args.fork_session, "--fork-session")
+    append_optional_value(cmd, "--from-pr", args.from_pr)
+    append_flag(cmd, args.ide, "--ide")
+    append_value(cmd, "--json-schema", args.json_schema)
+    append_repeated_values(cmd, "--mcp-config", args.mcp_config)
+    append_flag(cmd, args.mcp_debug, "--mcp-debug")
+    append_value(cmd, "--tools", args.tools)
+    append_value(cmd, "--model", args.model)
+    append_value(cmd, "--name", args.name)
+    append_value(cmd, "--permission-mode", args.permission_mode)
+    append_repeated_values(cmd, "--plugin-dir", args.plugin_dir)
+    append_value(cmd, "--remote-control-session-name-prefix", args.remote_control_session_name_prefix)
+    append_optional_value(cmd, "--resume", args.resume)
+    append_value(cmd, "--setting-sources", args.setting_sources)
+    append_value(cmd, "--settings", args.settings)
+    append_flag(cmd, args.strict_mcp_config, "--strict-mcp-config")
+    append_value(cmd, "--system-prompt", args.system_prompt)
+    append_optional_value(cmd, "--tmux", args.tmux)
+    append_optional_value(cmd, "--worktree", args.worktree)
+
+    cmd.append(args.prompt)
+    master, slave = pty.openpty()
+    env = {**os.environ, "NO_COLOR": "1", "TERM": args.term}
+    start = time.time()
+    proc = subprocess.Popen(
+        cmd,
+        stdin=slave,
+        stdout=slave,
+        stderr=slave,
+        cwd=args.cwd,
+        env=env,
+    )
+    os.close(slave)
+
+    raw = bytearray()
+    last_output = time.time()
+    last_snapshot = ""
+    timed_out = True
+
+    try:
+        while time.time() - start < args.timeout_sec:
+            ready, _, _ = select.select([master], [], [], 0.2)
+            if ready:
+                try:
+                    data = os.read(master, 65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                raw.extend(data)
+                last_output = time.time()
+
+                if args.emit_terminal_delta:
+                    emit(
+                        {
+                            "type": "tui_terminal_delta",
+                            "text": clean_terminal(data.decode("utf-8", "replace")),
+                            "uuid": str(uuid.uuid4()),
+                            "session_id": args.session_id,
+                        },
+                        enabled=stream_json,
+                    )
+
+                snapshot = extract_assistant_snapshot(raw.decode("utf-8", "replace"))
+                if snapshot and snapshot != last_snapshot:
+                    if args.live_tui_deltas:
+                        delta = snapshot[len(last_snapshot) :] if snapshot.startswith(last_snapshot) else snapshot
+                        if delta.strip():
+                            emit(
+                                {
+                                    "type": "stream_event",
+                                    "event": {
+                                        "type": "content_block_delta",
+                                        "index": 0,
+                                        "delta": {"type": "text_delta", "text": delta},
+                                    },
+                                    "session_id": args.session_id,
+                                    "parent_tool_use_id": None,
+                                    "uuid": str(uuid.uuid4()),
+                                },
+                                enabled=stream_json,
+                            )
+                    last_snapshot = snapshot
+
+            transcript = raw.decode("utf-8", "replace")
+            if last_snapshot and time.time() - last_output >= args.quiet_after_sec:
+                timed_out = False
+                break
+            if proc.poll() is not None:
+                timed_out = False
+                break
+    finally:
+        if proc.poll() is None:
+            proc.send_signal(signal.SIGTERM)
+            try:
+                proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+        os.close(master)
+
+    transcript = clean_terminal(raw.decode("utf-8", "replace"))
+    answer = extract_assistant_snapshot(transcript)
+    return transcript, answer, proc.returncode, timed_out, start
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("prompt", nargs="?")
+    parser.add_argument("--cwd", default=os.getcwd())
+
+    # Common Claude Code options. The goal is CLI compatibility with the print
+    # path while still using the interactive TUI backend internally.
+    parser.add_argument("-p", "--print", dest="print_mode", action="store_true", help="Accepted for claude -p compatibility.")
+    parser.add_argument("--add-dir", action="append", default=[])
+    parser.add_argument("--agent")
+    parser.add_argument("--agents")
+    parser.add_argument("--allow-dangerously-skip-permissions", action="store_true")
+    parser.add_argument("--allowedTools", "--allowed-tools", dest="allowed_tools", action="append", default=[])
+    parser.add_argument("--append-system-prompt")
+    parser.add_argument("--bare", action="store_true")
+    parser.add_argument("--betas", action="append", default=[])
+    parser.add_argument("--brief", action="store_true")
+    parser.add_argument("--chrome", action="store_true")
+    parser.add_argument("--no-chrome", action="store_true")
+    parser.add_argument("-c", "--continue", dest="continue_session", action="store_true")
+    parser.add_argument("--dangerously-skip-permissions", action="store_true")
+    parser.add_argument("-d", "--debug", nargs="?", const="")
+    parser.add_argument("--debug-file")
+    parser.add_argument("--disable-slash-commands", action="store_true")
+    parser.add_argument("--disallowedTools", "--disallowed-tools", dest="disallowed_tools", action="append", default=[])
+    parser.add_argument("--effort")
+    parser.add_argument("--exclude-dynamic-system-prompt-sections", action="store_true")
+    parser.add_argument("--fallback-model")
+    parser.add_argument("--file", dest="files", action="append", default=[])
+    parser.add_argument("--fork-session", action="store_true")
+    parser.add_argument("--from-pr", nargs="?", const="")
+    parser.add_argument("--ide", action="store_true")
+    parser.add_argument("--model", default="sonnet")
+    parser.add_argument("--tools", default="default")
+    parser.add_argument("--permission-mode", default="default")
+    parser.add_argument(
+        "--output-format",
+        choices=["text", "json", "stream-json"],
+        default="text",
+        help="Output format, matching claude -p. Default: text.",
+    )
+    parser.add_argument("--verbose", action="store_true", help="Accepted for claude -p CLI compatibility.")
+    parser.add_argument("--include-hook-events", action="store_true")
+    parser.add_argument(
+        "--include-partial-messages",
+        action="store_true",
+        help="Accepted for claude -p CLI compatibility. With the TUI backend, stream-json emits one final text delta by default.",
+    )
+    parser.add_argument("--input-format", choices=["text", "stream-json"], default="text")
+    parser.add_argument("--json-schema")
+    parser.add_argument("--max-budget-usd")
+    parser.add_argument("--mcp-config", action="append", default=[])
+    parser.add_argument("--mcp-debug", action="store_true")
+    parser.add_argument("-n", "--name")
+    parser.add_argument("--no-session-persistence", action="store_true")
+    parser.add_argument("--plugin-dir", action="append", default=[])
+    parser.add_argument("--remote-control-session-name-prefix")
+    parser.add_argument("--replay-user-messages", action="store_true")
+    parser.add_argument("-r", "--resume", nargs="?", const="")
+    parser.add_argument("--setting-sources")
+    parser.add_argument("--settings")
+    parser.add_argument("--strict-mcp-config", action="store_true")
+    parser.add_argument("--system-prompt")
+    parser.add_argument("--tmux", nargs="?", const="")
+    parser.add_argument("-v", "--version", action="store_true")
+    parser.add_argument("-w", "--worktree", nargs="?", const="")
+
+    # Wrapper-only controls.
+    parser.add_argument("--timeout-sec", type=float, default=90)
+    parser.add_argument("--quiet-after-sec", type=float, default=3)
+    parser.add_argument("--session-id", default=str(uuid.uuid4()))
+    parser.add_argument("--term", default="xterm-256color")
+    parser.add_argument("--raw-log")
+    parser.add_argument("--emit-terminal-delta", action="store_true")
+    parser.add_argument(
+        "--live-tui-deltas",
+        action="store_true",
+        help="Emit live text deltas from the lossy TUI surface. Default buffers until persisted JSONL final text is available.",
+    )
+    args = parser.parse_args()
+
+    if args.version:
+        subprocess.run(["claude", "--version"], check=False)
+        return 0
+
+    if args.prompt is None:
+        if sys.stdin.isatty():
+            parser.error("prompt is required unless stdin provides input")
+        args.prompt = sys.stdin.read()
+
+    unsupported: list[str] = []
+    if args.input_format != "text":
+        unsupported.append("--input-format stream-json")
+    if args.replay_user_messages:
+        unsupported.append("--replay-user-messages")
+    if args.no_session_persistence:
+        unsupported.append("--no-session-persistence")
+    if args.bare:
+        unsupported.append("--bare")
+    if args.max_budget_usd:
+        unsupported.append("--max-budget-usd")
+    if args.fallback_model:
+        unsupported.append("--fallback-model")
+    if unsupported:
+        for flag in unsupported:
+            warn(f"{flag} is not supported by the interactive subscription backend; continuing without exact claude -p semantics")
+
+    stream_json = args.output_format == "stream-json"
+    message_id = f"msg_tui_{uuid.uuid4().hex[:24]}"
+    start = time.time()
+
+    emit(
+        {
+            "type": "system",
+            "subtype": "init",
+            "cwd": args.cwd,
+            "session_id": args.session_id,
+            "tools": [],
+            "mcp_servers": [],
+            "model": args.model,
+            "permissionMode": args.permission_mode,
+            "apiKeySource": "interactive_tui_subscription",
+            "claude_code_version": None,
+            "output_style": "default",
+            "uuid": str(uuid.uuid4()),
+            "fast_mode_state": "off",
+        },
+        enabled=stream_json,
+    )
+    emit(
+        {
+            "type": "system",
+            "subtype": "status",
+            "status": "requesting",
+            "uuid": str(uuid.uuid4()),
+            "session_id": args.session_id,
+        },
+        enabled=stream_json,
+    )
+    emit(
+        {
+            "type": "stream_event",
+            "event": {
+                "type": "message_start",
+                "message": {
+                    "model": args.model,
+                    "id": message_id,
+                    "type": "message",
+                    "role": "assistant",
+                    "content": [],
+                    "stop_reason": None,
+                    "stop_sequence": None,
+                    "stop_details": None,
+                    "usage": {
+                        "input_tokens": None,
+                        "cache_creation_input_tokens": None,
+                        "cache_read_input_tokens": None,
+                        "output_tokens": None,
+                        "service_tier": None,
+                    },
+                },
+            },
+            "session_id": args.session_id,
+            "parent_tool_use_id": None,
+            "uuid": str(uuid.uuid4()),
+            "ttft_ms": None,
+        },
+        enabled=stream_json,
+    )
+    emit(
+        {
+            "type": "stream_event",
+            "event": {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}},
+            "session_id": args.session_id,
+            "parent_tool_use_id": None,
+            "uuid": str(uuid.uuid4()),
+        },
+        enabled=stream_json,
+    )
+
+    transcript, tui_answer, exit_code, timed_out, run_start = run_tui(args, stream_json)
+    if args.raw_log:
+        path = Path(args.raw_log)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(transcript)
+
+    persisted = read_persisted_assistant(args.session_id)
+    answer = persisted["text"] if persisted else tui_answer
+    final_answer_source = "session_jsonl" if persisted else "tui_transcript"
+    if persisted and tui_answer and tui_answer != persisted["text"]:
+        canonical = canonical_json_if_equivalent(tui_answer, persisted["text"])
+        if canonical is not None:
+            answer = canonical
+            final_answer_source = "json_canonicalized_from_matching_tui_and_session_jsonl"
+    final_model = persisted.get("model") if persisted else args.model
+    message_id = persisted.get("message_id") if persisted and persisted.get("message_id") else message_id
+
+    if answer and not args.live_tui_deltas:
+        emit(
+            {
+                "type": "stream_event",
+                "event": {
+                    "type": "content_block_delta",
+                    "index": 0,
+                    "delta": {"type": "text_delta", "text": answer},
+                },
+                "session_id": args.session_id,
+                "parent_tool_use_id": None,
+                "uuid": str(uuid.uuid4()),
+            },
+            enabled=stream_json,
+        )
+
+    failure = classify_failure(transcript, answer, timed_out)
+    is_error = failure is not None
+    usage = build_usage(answer)
+    duration_ms = now_ms(start)
+
+    if args.output_format == "text":
+        if answer:
+            print(answer)
+        return 0 if not is_error else 2
+
+    if args.output_format == "json":
+        print(
+            json.dumps(
+                {
+                    "type": "result",
+                    "subtype": "success" if not is_error else "error",
+                    "is_error": is_error,
+                    "duration_ms": duration_ms,
+                    "duration_api_ms": None,
+                    "num_turns": 1,
+                    "result": answer,
+                    "session_id": args.session_id,
+                    "total_cost_usd": None,
+                    "usage": usage,
+                    "terminal_reason": "completed" if not is_error else failure,
+                    "interactive_tui_backend": {
+                        "raw_log": args.raw_log,
+                        "session_jsonl": persisted.get("path") if persisted else None,
+                        "tui_answer": tui_answer,
+                        "final_answer_source": final_answer_source,
+                        "timed_out": timed_out,
+                        "exit_code": exit_code,
+                        "extraction_confidence": "high" if persisted else ("medium" if answer else "none"),
+                    },
+                },
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+        )
+        return 0 if not is_error else 2
+
+    emit(
+        {
+            "type": "assistant",
+            "message": {
+                "model": final_model,
+                "id": message_id,
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "text", "text": answer}] if answer else [],
+                "stop_reason": "end_turn" if not is_error else None,
+                "stop_sequence": None,
+                "stop_details": None,
+                "usage": {
+                    "input_tokens": None,
+                    "cache_creation_input_tokens": None,
+                    "cache_read_input_tokens": None,
+                    "output_tokens": usage["output_tokens"],
+                    "service_tier": None,
+                },
+                "context_management": None,
+            },
+            "parent_tool_use_id": None,
+            "session_id": args.session_id,
+            "uuid": str(uuid.uuid4()),
+        }
+    )
+    emit(
+        {
+            "type": "stream_event",
+            "event": {"type": "content_block_stop", "index": 0},
+            "session_id": args.session_id,
+            "parent_tool_use_id": None,
+            "uuid": str(uuid.uuid4()),
+        }
+    )
+    emit(
+        {
+            "type": "stream_event",
+            "event": {
+                "type": "message_delta",
+                "delta": {"stop_reason": "end_turn" if not is_error else "error", "stop_sequence": None, "stop_details": None},
+                "usage": {
+                    "input_tokens": None,
+                    "cache_creation_input_tokens": None,
+                    "cache_read_input_tokens": None,
+                    "output_tokens": usage["output_tokens"],
+                    "iterations": usage["iterations"],
+                },
+                "context_management": {"applied_edits": []},
+            },
+            "session_id": args.session_id,
+            "parent_tool_use_id": None,
+            "uuid": str(uuid.uuid4()),
+        }
+    )
+    emit(
+        {
+            "type": "stream_event",
+            "event": {"type": "message_stop"},
+            "session_id": args.session_id,
+            "parent_tool_use_id": None,
+            "uuid": str(uuid.uuid4()),
+        }
+    )
+    emit(
+        {
+            "type": "rate_limit_event",
+            "rate_limit_info": {"status": "unknown"},
+            "session_id": args.session_id,
+            "uuid": str(uuid.uuid4()),
+        }
+    )
+    emit(
+        {
+            "type": "result",
+            "subtype": "success" if not is_error else "error",
+            "is_error": is_error,
+            "api_error_status": None,
+            "duration_ms": duration_ms,
+            "duration_api_ms": None,
+            "num_turns": 1,
+            "result": answer,
+            "stop_reason": "end_turn" if not is_error else None,
+            "session_id": args.session_id,
+            "total_cost_usd": None,
+            "usage": usage,
+            "modelUsage": {},
+            "permission_denials": [],
+            "terminal_reason": "completed" if not is_error else failure,
+            "fast_mode_state": "off",
+            "uuid": str(uuid.uuid4()),
+            "interactive_tui_backend": {
+                "raw_log": args.raw_log,
+                "session_jsonl": persisted.get("path") if persisted else None,
+                "tui_answer": tui_answer,
+                "final_answer_source": final_answer_source,
+                "timed_out": timed_out,
+                "exit_code": exit_code,
+                "extraction_confidence": "high" if persisted else ("medium" if answer else "none"),
+                "compatibility_note": "Shape-compatible with claude -p stream-json core events; usage/cost/tool events are best-effort because TUI has no machine protocol.",
+            },
+        }
+    )
+
+    return 0 if not is_error else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

claude_p-0.1.0/src/claude_p/sdk.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+import json
+import os
+import sys
+from typing import Any, AsyncIterator, Iterable
+
+from .types import AssistantMessage, ResultMessage, SDKMessage, StreamEventMessage, SystemMessage
+
+
+@dataclass
+class ClaudePOptions:
+    """Options for the interactive Claude Code `claude -p` fallback.
+
+    The names mirror the official Claude Agent SDK's options style while
+    preserving CLI compatibility with `claude -p`.
+    """
+
+    cwd: str | None = None
+    model: str = "sonnet"
+    tools: str | Iterable[str] = "default"
+    permission_mode: str = "default"
+    output_format: str = "stream-json"
+    system_prompt: str | None = None
+    append_system_prompt: str | None = None
+    allowed_tools: list[str] = field(default_factory=list)
+    disallowed_tools: list[str] = field(default_factory=list)
+    mcp_config: list[str] = field(default_factory=list)
+    settings: str | None = None
+    session_id: str | None = None
+    timeout_sec: float = 90
+    quiet_after_sec: float = 3
+    raw_log: str | None = None
+    include_partial_messages: bool = True
+    executable: str | None = None
+    extra_args: list[str] = field(default_factory=list)
+
+    def command(self, prompt: str) -> list[str]:
+        if self.executable:
+            cmd = [self.executable, prompt]
+        else:
+            cmd = [sys.executable, "-m", "claude_p.cli", prompt]
+        cmd.extend(["--model", self.model])
+        if isinstance(self.tools, str):
+            cmd.extend(["--tools", self.tools])
+        else:
+            cmd.extend(["--tools", ",".join(self.tools)])
+        cmd.extend(["--permission-mode", self.permission_mode])
+        cmd.extend(["--output-format", self.output_format])
+        cmd.extend(["--timeout-sec", str(self.timeout_sec)])
+        cmd.extend(["--quiet-after-sec", str(self.quiet_after_sec)])
+        if self.cwd:
+            cmd.extend(["--cwd", self.cwd])
+        if self.system_prompt:
+            cmd.extend(["--system-prompt", self.system_prompt])
+        if self.append_system_prompt:
+            cmd.extend(["--append-system-prompt", self.append_system_prompt])
+        for tool in self.allowed_tools:
+            cmd.extend(["--allowedTools", tool])
+        for tool in self.disallowed_tools:
+            cmd.extend(["--disallowedTools", tool])
+        for config in self.mcp_config:
+            cmd.extend(["--mcp-config", config])
+        if self.settings:
+            cmd.extend(["--settings", self.settings])
+        if self.session_id:
+            cmd.extend(["--session-id", self.session_id])
+        if self.raw_log:
+            cmd.extend(["--raw-log", self.raw_log])
+        if self.include_partial_messages:
+            cmd.append("--include-partial-messages")
+        cmd.extend(self.extra_args)
+        return cmd
+
+
+def _message_from_raw(raw: dict[str, Any]) -> SDKMessage:
+    typ = raw.get("type")
+    if typ == "system":
+        return SystemMessage(type="system", raw=raw, subtype=raw.get("subtype"))
+    if typ == "stream_event":
+        return StreamEventMessage(type="stream_event", raw=raw, event=raw.get("event"))
+    if typ == "assistant":
+        content = raw.get("message", {}).get("content", [])
+        text_parts = [
+            block.get("text", "")
+            for block in content
+            if isinstance(block, dict) and block.get("type") == "text"
+        ]
+        return AssistantMessage(type="assistant", raw=raw, text="".join(text_parts))
+    if typ == "result":
+        return ResultMessage(
+            type="result",
+            raw=raw,
+            result=raw.get("result", ""),
+            is_error=bool(raw.get("is_error")),
+            session_id=raw.get("session_id"),
+            terminal_reason=raw.get("terminal_reason"),
+        )
+    return SDKMessage(type=str(typ or "raw"), raw=raw)
+
+
+async def query(prompt: str, *, options: ClaudePOptions | None = None) -> AsyncIterator[SDKMessage]:
+    """Run a prompt and yield stream-json messages.
+
+    This mirrors the official Claude Agent SDK's `query(...)` shape, but the
+    backend is interactive Claude Code instead of `claude -p`.
+    """
+
+    options = options or ClaudePOptions()
+    options.output_format = "stream-json"
+    proc = await asyncio.create_subprocess_exec(
+        *options.command(prompt),
+        cwd=options.cwd or os.getcwd(),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    assert proc.stdout is not None
+    async for raw_line in proc.stdout:
+        line = raw_line.decode("utf-8", "replace").strip()
+        if not line:
+            continue
+        yield _message_from_raw(json.loads(line))
+    stderr = await proc.stderr.read() if proc.stderr else b""
+    code = await proc.wait()
+    if code != 0:
+        raise RuntimeError(stderr.decode("utf-8", "replace") or f"claude-p exited with {code}")
+
+
+class ClaudePClient:
+    """Small client wrapper inspired by ClaudeSDKClient."""
+
+    def __init__(self, options: ClaudePOptions | None = None):
+        self.options = options or ClaudePOptions()
+
+    async def __aenter__(self) -> "ClaudePClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        return None
+
+    async def query(self, prompt: str) -> AsyncIterator[SDKMessage]:
+        async for message in query(prompt, options=self.options):
+            yield message
+
+    async def run(self, prompt: str) -> ResultMessage:
+        result: ResultMessage | None = None
+        async for message in self.query(prompt):
+            if isinstance(message, ResultMessage):
+                result = message
+        if result is None:
+            raise RuntimeError("claude-p did not emit a result message")
+        return result

claude_p-0.1.0/src/claude_p/types.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+
+@dataclass(frozen=True)
+class SDKMessage:
+    """Base message wrapper returned by the Python SDK."""
+
+    type: str
+    raw: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class SystemMessage(SDKMessage):
+    subtype: str | None = None
+
+
+@dataclass(frozen=True)
+class StreamEventMessage(SDKMessage):
+    event: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class AssistantMessage(SDKMessage):
+    text: str
+
+
+@dataclass(frozen=True)
+class ResultMessage(SDKMessage):
+    result: str
+    is_error: bool
+    session_id: str | None = None
+    terminal_reason: str | None = None
+
+
+MessageKind = Literal["system", "stream_event", "assistant", "result", "raw"]
+

claude_p-0.1.0/tests/test_sdk.py

@@ -0,0 +1,10 @@
+from claude_p import ClaudePOptions
+
+
+def test_options_command_includes_stream_json():
+    cmd = ClaudePOptions(model="sonnet", tools="").command("hello")
+    assert "--output-format" in cmd
+    assert "stream-json" in cmd
+    assert "--tools" in cmd
+    assert "" in cmd
+

claude_p-0.1.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 2
+requires-python = ">=3.10"
+
+[[package]]
+name = "claude-p"
+version = "0.1.0"
+source = { editable = "." }