errlens-cli 0.1.0__py3-none-any.whl

errlens/runner.py

@@ -0,0 +1,241 @@
+"""Binary forwarding with independent readers and bounded process cleanup."""
+
+import os
+import errno
+import queue
+import select
+import signal
+import subprocess
+import sys
+import threading
+import time
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from typing import BinaryIO, Literal
+from types import FrameType
+
+from errlens.capture import Capture
+from errlens.models import ExecutionContext, ExecutionResult
+
+CHUNK_SIZE = 64 * 1024
+
+
+class RunnerError(Exception):
+    """ErrLens infrastructure failure, distinct from a child's nonzero status."""
+
+    def __init__(self, kind: str, detail: str, exit_code: int = 125) -> None:
+        super().__init__(detail)
+        self.kind = kind
+        self.exit_code = exit_code
+
+
+def _broken_pipe(error: OSError | ValueError, destination: BinaryIO) -> bool:
+    if isinstance(error, BrokenPipeError):
+        return True
+    # Windows CRT can surface a closed redirected pipe as EINVAL, not EPIPE.
+    # Restrict the mapping to actual pipe handles; EINVAL on files stays an error.
+    if sys.platform == "win32" and isinstance(error, OSError) and error.errno == errno.EINVAL:
+        import ctypes
+        import msvcrt
+        from ctypes import wintypes
+
+        try:
+            kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+            get_type = kernel.GetFileType
+            get_type.argtypes = [wintypes.HANDLE]
+            get_type.restype = wintypes.DWORD
+            return bool(get_type(msvcrt.get_osfhandle(destination.fileno())) == 3)
+        except (OSError, ValueError):
+            return False
+    return False
+
+
+def _available(stream: BinaryIO) -> int:
+    """Poll pipes without an uncancellable blocking read (also on Python 3.11)."""
+    if sys.platform != "win32":
+        return CHUNK_SIZE if select.select([stream], [], [], 0.02)[0] else 0
+    import ctypes
+    import msvcrt
+    from ctypes import wintypes
+
+    kernel = ctypes.WinDLL("kernel32", use_last_error=True)
+    peek = kernel.PeekNamedPipe
+    peek.argtypes = [wintypes.HANDLE, wintypes.LPVOID, wintypes.DWORD,
+                     wintypes.LPVOID, ctypes.POINTER(wintypes.DWORD), wintypes.LPVOID]
+    peek.restype = wintypes.BOOL
+    available = wintypes.DWORD()
+    if not peek(msvcrt.get_osfhandle(stream.fileno()), None, 0, None,
+                ctypes.byref(available), None):
+        error = ctypes.get_last_error()
+        if error in (109, 233):  # broken pipe / no process on other end
+            return -1
+        raise ctypes.WinError(error)
+    return min(available.value, CHUNK_SIZE)
+
+
+def _pump(
+    source: BinaryIO, destination: BinaryIO, name: Literal["stdout", "stderr"],
+    capture: Capture, stop: threading.Event, errors: queue.SimpleQueue[RunnerError],
+) -> None:
+    try:
+        while not stop.is_set():
+            try:
+                available = _available(source)
+                if available < 0:
+                    return
+                if available == 0:
+                    stop.wait(0.01)
+                    continue
+                chunk = os.read(source.fileno(), available)
+            except (OSError, ValueError) as exc:
+                errors.put(RunnerError("read", f"{name}: {exc}"))
+                return
+            if not chunk:
+                return
+            capture.append(name, chunk)
+            try:
+                offset = 0
+                while offset < len(chunk):
+                    written = destination.write(chunk[offset:])
+                    if written is None or written <= 0:
+                        raise OSError("Output stream made no progress")
+                    offset += written
+                destination.flush()
+            except (OSError, ValueError) as exc:
+                broken = _broken_pipe(exc, destination)
+                errors.put(RunnerError("broken_pipe" if broken else "write", f"{name}: {exc}",
+                                       141 if broken else 125))
+                return
+    except Exception as exc:
+        errors.put(RunnerError("reader", f"{name}: {type(exc).__name__}: {exc}"))
+    finally:
+        try:
+            source.close()
+        except OSError as exc:
+            errors.put(RunnerError("read", f"{name}: {exc}"))
+
+
+@contextmanager
+def _interrupts(cancel: threading.Event) -> Iterator[None]:
+    """Handlers record cancellation; no asynchronous exceptions during cleanup."""
+    previous: dict[signal.Signals, Callable[[int, FrameType | None], object] | int | None] = {}
+    if threading.current_thread() is threading.main_thread():
+        signals = [signal.SIGINT]
+        if sys.platform == "win32":
+            signals.append(signal.SIGBREAK)
+        for number in signals:
+            previous[number] = signal.getsignal(number)
+            if previous[number] != signal.SIG_IGN:
+                signal.signal(number, lambda signum, frame: cancel.set())
+    try:
+        yield
+    finally:
+        for number, handler in previous.items():
+            signal.signal(number, handler)
+
+
+def _signal_group(process: subprocess.Popen[bytes], *, force: bool = False) -> None:
+    try:
+        if sys.platform != "win32":
+            os.killpg(process.pid, signal.SIGKILL if force else signal.SIGINT)
+        elif process.poll() is None:
+            if force:
+                process.kill()
+            else:
+                process.send_signal(signal.CTRL_BREAK_EVENT)
+    except ProcessLookupError:
+        pass
+    except OSError:
+        if process.poll() is None:
+            process.kill()
+
+
+def run(
+    context: ExecutionContext, capture: Capture, stdout: BinaryIO, stderr: BinaryIO,
+    *, cancel: threading.Event | None = None, interrupt_timeout: float = 1.0,
+    drain_timeout: float = 1.0,
+) -> ExecutionResult:
+    """Run an argv sequence, inheriting stdin and environment (metadata is inert).
+
+    Single-use capture is supplied by the caller. Main-thread use handles Ctrl+C;
+    callers in other threads must supply a cancellation Event. Exit signals remain
+    negative in the result. No analyzers, rendering or translations are invoked.
+    """
+    if interrupt_timeout <= 0 or drain_timeout <= 0:
+        raise ValueError("Timeouts must be positive")
+    cancellation = cancel if cancel is not None else threading.Event()
+    errors: queue.SimpleQueue[RunnerError] = queue.SimpleQueue()
+    stop = threading.Event()
+    readers: list[threading.Thread] = []
+    process: subprocess.Popen[bytes] | None = None
+    with _interrupts(cancellation):
+        try:
+            try:
+                creation_flags = 0
+                if sys.platform == "win32":
+                    creation_flags = subprocess.CREATE_NEW_PROCESS_GROUP
+                process = subprocess.Popen(
+                    context.command, cwd=context.cwd, stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE, bufsize=0, shell=False,
+                    start_new_session=os.name == "posix",
+                    creationflags=creation_flags,
+                )
+            except FileNotFoundError as exc:
+                raise RunnerError("not_found", str(exc), 127) from exc
+            except PermissionError as exc:
+                raise RunnerError("permission", str(exc), 126) from exc
+            except (OSError, ValueError) as exc:
+                raise RunnerError("launch", str(exc)) from exc
+            assert process.stdout is not None and process.stderr is not None
+            for name, source, target in (
+                ("stdout", process.stdout, stdout), ("stderr", process.stderr, stderr),
+            ):
+                reader = threading.Thread(
+                    target=_pump, args=(source, target, name, capture, stop, errors),
+                    name=f"errlens-{name}", daemon=True,
+                )
+                reader.start()
+                readers.append(reader)
+            interrupted = False
+            interrupt_deadline: float | None = None
+            drain_deadline: float | None = None
+            while True:
+                if not errors.empty():
+                    raise errors.get()
+                now = time.monotonic()
+                if cancellation.is_set() and not interrupted:
+                    interrupted = True
+                    _signal_group(process)
+                    interrupt_deadline = now + interrupt_timeout
+                if interrupt_deadline is not None and now >= interrupt_deadline:
+                    _signal_group(process, force=True)
+                    interrupt_deadline = None
+                status = process.poll()
+                if status is not None:
+                    if not any(reader.is_alive() for reader in readers):
+                        break
+                    if drain_deadline is None:
+                        drain_deadline = now + drain_timeout
+                    if now >= drain_deadline:
+                        raise RunnerError("drain", "Output pipes did not close after process exit")
+                time.sleep(0.01)
+            if not errors.empty():
+                raise errors.get()
+            return ExecutionResult(status, interrupted, not capture.truncated)
+        finally:
+            stop.set()
+            if process is not None:
+                if process.poll() is None or cancellation.is_set() or any(r.is_alive() for r in readers):
+                    _signal_group(process, force=True)
+                try:
+                    process.wait(timeout=2)
+                except subprocess.TimeoutExpired as exc:
+                    raise RunnerError("cleanup", "Process did not exit after kill") from exc
+                for reader in readers:
+                    reader.join(timeout=0.5)
+                # Readers own their source handles; never close/reuse an fd while
+                # a reader is active. Normally polling makes both joins immediate.
+                if not any(reader.is_alive() for reader in readers):
+                    for pipe in (process.stdout, process.stderr):
+                        if pipe is not None and not pipe.closed:
+                            pipe.close()

errlens/service.py

@@ -0,0 +1,58 @@
+"""Post-execution analysis/explanation coordination, without process or terminal I/O."""
+
+from errlens.analyzers.base import AnalyzerRegistry
+from errlens.analyzers.python import PythonAnalyzer
+from errlens.capture import Capture, TerminalCapture
+from errlens.models import Diagnostic, ExecutionContext, ExecutionResult, ExplanationReport
+from errlens.rules.python import explain
+
+
+def analyze_capture(
+    context: ExecutionContext, result: ExecutionResult, capture: Capture | TerminalCapture,
+    *, registry: AnalyzerRegistry | None = None, encoding: str = "utf-8",
+) -> list[Diagnostic]:
+    """Analyze bounded tails once the runner has finished. Inputs are not modified.
+
+    Callers can inspect structured results without reparsing the original bytes.
+    """
+    if registry is None:
+        registry = AnalyzerRegistry()
+        registry.register(PythonAnalyzer())
+    data = capture.decoded(encoding)
+    diagnostics: list[Diagnostic] = []
+    for analyzer in registry.all():
+        diagnostics.extend(analyzer.analyze(context, result, data))
+    return diagnostics
+
+
+def explain_capture(
+    context: ExecutionContext, result: ExecutionResult, capture: Capture | TerminalCapture,
+    *, registry: AnalyzerRegistry | None = None, encoding: str = "utf-8",
+) -> ExplanationReport | None:
+    """One report after a failed, non-interrupted execution; no output on success.
+
+    Prefer stderr, then combined, then stdout. Follow explicit chain links only;
+    independent diagnostics are counted, never labelled as causes.
+    """
+    if result.exit_code in (0, None) or result.interrupted:
+        return None
+    diagnostics = analyze_capture(context, result, capture, registry=registry, encoding=encoding)
+    if not diagnostics:
+        return None
+    primary = next((items[-1] for source in ("stderr", "combined", "stdout")
+                    if (items := [item for item in diagnostics if item.source == source])),
+                   diagnostics[-1])
+    indexed = {item.diagnostic_id: item for item in diagnostics}
+    related: list[Diagnostic] = []
+    seen = {primary.diagnostic_id}
+    current = primary
+    while current.related_diagnostic_id and current.related_diagnostic_id not in seen:
+        predecessor = indexed.get(current.related_diagnostic_id)
+        if predecessor is None:
+            break
+        related.append(predecessor)
+        seen.add(predecessor.diagnostic_id)
+        current = predecessor
+    related.reverse()
+    return ExplanationReport(primary, explain(primary, context), related,
+                             max(0, len(diagnostics) - len(related) - 1))

errlens_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: errlens-cli
+Version: 0.1.0
+Summary: Local Python error explanations with opt-in terminal and shell integration.
+Author: ErrLens contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ErrLens/errlens-cli
+Project-URL: Source, https://github.com/ErrLens/errlens-cli
+Project-URL: Documentation, https://github.com/ErrLens/errlens-cli/blob/main/README.md
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer<1,>=0.16
+Requires-Dist: rich<15,>=14
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: mypy<2,>=1.15; extra == "dev"
+Dynamic: license-file
+
+# ErrLens
+
+ErrLens is a local, open-source CLI that adds readable Russian or English explanations to recognized Python errors. It helps developers understand tracebacks without copying them to an external service. Explanations are rule-based and work offline after installation; no API key or AI model is required.
+
+ErrLens runs a command through `errlens run`. Its default pipe mode forwards the original stdout and stderr, then appends an explanation to stderr when an error is recognized. Optional shell wrappers intercept only `python`; explicit terminal mode uses merged terminal output.
+
+## Requirements and installation
+
+Python 3.11 or newer is required. On Windows, Linux or macOS, install from a local checkout:
+
+```console
+python -m pip install .
+```
+
+For development, use a virtual environment and install `python -m pip install -e ".[dev]"`. Installing dependencies requires an available package index or local wheels.
+
+The PyPI distribution name is **errlens-cli**; the Python import and executable
+are both **errlens**. This candidate has not been uploaded. After publication,
+install with `python -m pip install errlens-cli==0.1.0`, then run `errlens --version`.
+Until then use this checkout or a verified supplied wheel:
+`python -m pip install /path/to/errlens_cli-0.1.0-py3-none-any.whl`.
+The existing PyPI package named `errlens` is not the distribution selected for
+this repository. See [release preparation](https://github.com/ErrLens/errlens-cli/blob/main/docs/releasing.md).
+CI covers CPython 3.11–3.13; newer Python versions are not yet qualified.
+
+## Usage
+
+```console
+errlens --help
+errlens --version
+errlens run python main.py
+errlens run --lang en -- python main.py
+errlens run --no-explain -- python main.py
+errlens run python -c "print(undefined_variable)"
+```
+
+Russian is the default; `--lang en` selects English. Place ErrLens options before the executable; arguments after the executable belong to the child process. `--no-explain` skips analysis. The optional `--` makes the boundary explicit.
+
+The original traceback remains visible. For example, a `NameError` can be followed by an explanation that the name is unavailable in the current scope and suggestions to check its spelling and definition. Causes are described as possibilities, not established facts. Successful commands and nonzero exits without recognized diagnostics do not produce an explanation.
+
+## Supported diagnostics
+
+Rules cover `ModuleNotFoundError`, `ImportError`, `SyntaxError`, `IndentationError`, `TabError`, `NameError`, `TypeError`, `AttributeError`, `KeyError`, `FileNotFoundError` and `PermissionError`. Other structured exceptions receive a neutral notice. Incomplete diagnostics are marked as such; `ExceptionGroup` is summarized at its outer level. For a chain of exceptions, the final diagnostic is explained and linked predecessors are noted.
+
+Suggested commands are never executed. A pip command is shown only for the exact `requests` import and an explicitly specified absolute Python executable path, with a condition to confirm that the distribution is actually needed in that environment. Import names do not generally identify package names, and a missing module may be local.
+
+## Behavior and limitations
+
+- ErrLens launches argument sequences without `shell=True`. Shell pipelines and builtins are interpreted by the invoking shell, not by ErrLens. On Windows, the operating system may invoke a command interpreter for `.bat` or `.cmd` files even with `shell=False`.
+- Separate bounded buffers retain up to 1 MiB per stream for analysis. Original bytes are forwarded as they arrive; the diagnostic copy may be truncated. No output logs are saved to disk.
+- Pipes change `isatty()` and may affect child buffering and colors. Interactive programs, job control and full-screen applications are not guaranteed to work. The relative ordering of stdout and stderr cannot be reconstructed.
+- The child exit code is preserved for normal exits. On POSIX, signal termination becomes `128 + signal`; user interruption returns 130. Runner failures have their own codes: 125 for internal failures, 126 for permission errors, 127 for missing executables and 141 for broken pipes. Child programs can also use these codes; ErrLens identifies its own failures in stderr when possible.
+- In pipe mode, Ctrl+C handling uses a separate process group. Windows pipe cleanup does not guarantee termination of an arbitrary descendant tree. After the child exits, pipes held open by descendants are subject to a one-second drain timeout. ConPTY uses the Job Object cleanup described below.
+- Recognition targets standard CPython traceback formatting; IPython/Jupyter and logger-prefixed tracebacks are not supported. A traceback-like log can be ambiguous. Stdout diagnostics require a failed Python command. Unknown or incomplete data is not presented as a certain cause.
+- Rich markup and terminal control characters from diagnostic data are rendered literally or escaped in the ErrLens block. Redirected explanations are plain text without ANSI. Original child output is not sanitized.
+- Explanation fields are capped at 2,048 characters; linked exception messages at 256 characters. The forwarded traceback is not shortened by this limit.
+- ErrLens does not fix code, install packages, collect telemetry or contact a service. Shell wrappers and terminal mode are explicit opt-ins; VS Code extension support remains future work.
+
+## Opt-in PowerShell 7 integration (Windows)
+
+```powershell
+errlens shell install powershell
+errlens shell status powershell
+errlens shell uninstall powershell
+```
+
+Installation explicitly edits the current user's **all-hosts PowerShell 7 profile**
+(shared with VS Code), discovered using `pwsh -NoProfile`. Restart PowerShell after
+installation/removal. ExecutionPolicy is never changed; your policy must allow
+loading the profile and the integration script. No administrator access is needed.
+For an isolated trial or a custom host profile use `--profile 'path/to/profile.ps1'`
+on each management command, then dot-source that profile manually.
+
+An owned script is placed in an `ErrLens` subdirectory next to the selected profile.
+Only one guarded dot-source line is appended. Existing profile bytes are preserved;
+each modification of an existing profile creates a uniquely named backup alongside
+it. Backups are retained on removal. Edited connection lines and unowned integration
+files are refused rather than overwritten. A newly created profile is left empty
+after removal. Existing `python` aliases/functions are preserved with a warning.
+
+After loading, plain `python main.py`, `python -c "print(undefined_variable)"` and
+`python --version` delegate to `errlens run`. Only the command name `python` is
+wrapped. Absolute executable paths, `py`, pip and other commands bypass it.
+The native Python application is resolved from PATH on every invocation, so venv
+activation is respected. The ErrLens runtime is bound to the absolute Python path
+used during installation; `errlens` need not be in PATH. Keep that environment
+installed. To migrate it, uninstall the integration and reinstall from the new runtime.
+
+Temporarily bypass analysis with `$env:ERRLENS_DISABLE='1'`; restore it with
+`Remove-Item Env:ERRLENS_DISABLE`. To remove the wrapper from the current session,
+use `Remove-Item Function:python`. Persistent removal takes effect in new sessions.
+
+This is a PowerShell function calling a native program, not transparent terminal
+capture. `$LASTEXITCODE` is explicitly propagated. `$?` may report function success
+even when Python fails; inspect `$LASTEXITCODE`. PowerShell 7.3+ uses Standard
+native argument passing locally inside the wrapper; 7.0–7.2 retain their legacy
+quoting/empty-argument limitations. Global preferences are not changed.
+Pipeline output and `>` pass through PowerShell's object/text conversion and do
+not guarantee byte identity (including PowerShell 7.4 native redirection behavior).
+Pipeline input is not forwarded by this wrapper. Avoid binary pipelines, REPLs,
+interactive and full-screen applications; use an absolute Python executable when
+native semantics are needed. ExecutionPolicy, host-specific profile loading and
+VS Code itself require manual verification on the target machine.
+
+## Opt-in Bash and Zsh integration
+
+On Linux/macOS, explicitly install with `errlens shell install bash` or
+`errlens shell install zsh`; use `status` or `uninstall` in place of `install`.
+Bash uses `~/.bashrc`; Zsh uses `${ZDOTDIR:-$HOME}/.zshrc`. Bash login shells
+do not necessarily load `.bashrc`: configure your login profile to source it
+yourself if needed. These are interactive startup files; noninteractive shells
+do not automatically load them. `--profile PATH` selects an isolated/custom file.
+
+An owned script in `.errlens` beside the profile is sourced by one guarded line.
+Existing profile bytes are retained, changes receive unique backups, repeated
+installation is idempotent, and removal removes only the exact owned line and script.
+Edited lines and unowned scripts are refused. Backups remain after removal.
+Existing `python` functions and aliases take precedence and are preserved.
+
+The `python` function resolves the external interpreter and `errlens` on each
+invocation, forwards `"$@"`, working directory and exit status, and respects an
+activated virtual environment. `ERRLENS_DISABLE=1 python ...` bypasses analysis;
+if ErrLens is absent from PATH, the native Python is run directly. Use `unset -f
+python` to disable the wrapper in the current shell. `command python`, an absolute
+path, `python3`, pip and other commands bypass it. Restart or source the profile
+after installation; restart or unset the function after uninstallation.
+
+When starting Zsh from Bash with an active virtual environment, the Bash
+activation script may have modified and exported prompt variables. Bash prompt
+escapes are not Zsh prompt syntax and may appear literally. Start a clean Zsh,
+then run `source /path/to/venv/bin/activate` within Zsh. The ErrLens integration
+does not change `PS1` or `PROMPT`; your Zsh configuration can define its own prompt.
+Manual reports of Windows 11/PowerShell and Ubuntu 24.04/WSL Bash and Zsh are
+distinct from the automated CI checks; consult CI results for verified runs.
+
+Redirection and pipelines follow the shell and `errlens run` pipe semantics.
+Input is inherited, but interactive/terminal-dependent programs and exact stdout/
+stderr interleaving are not guaranteed. Ctrl+C follows Runner process-group handling;
+PTY and job-control equivalence are not guaranteed. Paths with spaces and Unicode
+are quoted without `eval`. No system profiles or shell settings are modified.
+
+## Explicit terminal mode
+
+Use `errlens run --terminal-mode pty -- python script.py` when terminal stdin
+and stdout are available. Linux/macOS use POSIX PTY; Windows 10 1809+ and Windows
+11 use native ConPTY. Pipe remains the default, including all shell wrappers.
+A transport error never triggers an automatic second run. Windows requires
+actual console handles and a native executable (.exe or .com), with no batch
+file or legacy winpty fallback. No extra runtime dependency or compiler is needed.
+
+Terminal mode supplies a terminal, input, window-size propagation and terminal
+Ctrl+C handling. stdout and stderr merge onto ErrLens stdout; echo and LF-to-CRLF
+conversion are normal terminal behavior. Binary identity and original stream
+separation are not guaranteed. Redirected host stdin/stdout are rejected; use
+pipe mode for pipelines. The combined diagnostic tail is limited to 1 MiB.
+Recognized failed Python commands receive one explanation on stderr after terminal
+restoration. Interactive REPL exceptions followed by a successful exit do not
+produce cards. ANSI forwarding is supported, but screen reconstruction, job-control
+transparency, suspended children and arbitrary full-screen applications are not
+guaranteed. A permanently blocked output sink can still block forwarding.
+
+The host terminal modes and signal handlers are saved and restored on ordinary
+exit, cancellation and transport errors. SIGKILL or a host crash cannot provide
+that guarantee. POSIX processes that deliberately detach from the session may
+outlive cleanup. ConPTY clients belong to a kill-on-close Windows Job Object:
+remaining descendants are terminated when the main client ends or transport fails.
+Windows uses a separate, short-lived owner process to bound ConPTY shutdown on
+older Windows builds. Input/output are UTF-8/VT text, so invalid bytes, NUL, cursor
+movement, wrapping and screen redraws need not survive as original log bytes.
+The analyzer strips ANSI but does not reconstruct a screen; complex redraws can
+produce incomplete or unrecognized diagnostics.
+
+Automated tests use isolated real ConPTY sessions and nested console handles on
+Windows, and nested POSIX PTYs on Linux and in the manual macOS workflow. User-reported manual checks
+cover Windows Terminal and VS Code ConPTY plus selected WSL Bash/Zsh sessions;
+the [acceptance record](https://github.com/ErrLens/errlens-cli/blob/main/docs/manual-acceptance.md) preserves untested combinations.
+Legacy console hosts, detailed REPL editing, Windows 10 lifecycle behavior and
+physical macOS hosts are not fully manually qualified. See
+[Windows ConPTY notes](https://github.com/ErrLens/errlens-cli/blob/main/docs/windows-conpty.md) for lifecycle details.
+
+## Development and checks
+
+```console
+python -m pytest
+python -m mypy
+python -m pip check
+python -m build
+```
+
+The build creates a wheel and source distribution in `dist/`. GitHub Actions #6
+passed all 11 jobs for `84dbb9c927b1b0eaf3ac6efc50863b9f0ef72836`, covering
+Windows, Ubuntu and macOS on Python 3.11–3.13 plus Windows/Ubuntu wheel installation.
+Hosted macOS runners were unavailable in [CI #8](https://github.com/ErrLens/errlens-cli/actions/runs/43235376928).
+The required Tests workflow temporarily runs Linux and Windows on Python 3.11–3.13
+and both packaging jobs. macOS tests remain available through a separate manual
+workflow. Earlier macOS passes apply to their tested commits. The release candidate
+has yet to be tested on macOS. The [release guide](https://github.com/ErrLens/errlens-cli/blob/main/docs/releasing.md)
+records when to restore macOS to the required matrix. The manual publishing workflow
+can retain candidate artifacts for review.
+
+See [CONTRIBUTING.md](https://github.com/ErrLens/errlens-cli/blob/main/CONTRIBUTING.md) for contribution guidance. ErrLens is distributed under the [MIT License](https://github.com/ErrLens/errlens-cli/blob/main/LICENSE).
+
+## Roadmap
+
+The current CLI focuses on local Python diagnostics, localized explanations,
+opt-in shell wrappers and explicit terminal sessions. Future stages may improve
+terminal compatibility and add VS Code integration, additional analyzers and
+optional AI providers. Those future features are not part of the current CLI.

errlens_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+errlens/__init__.py,sha256=AkRndmVGIVs_sUxxABG7XRcPS3OPBa_r-ErjfPWqmj8,186
+errlens/__main__.py,sha256=I_fRhsEjjNCRvt75dfF4Bik486DYs49IWxi-_S2D7u4,118
+errlens/_conpty.py,sha256=zLMY7uoKLGtNrbixeRcei-bs6TQaF30-FVuA2IDcuY8,9983
+errlens/_conpty_worker.py,sha256=IOhUg9ycO3drOqLH97hk_vjn1f63iD30njycCtScwKM,6020
+errlens/_pty_child.py,sha256=S_4Sl7bAZuo0Chj0RTE0exj2LSYLJdzLw1h0u3Qop08,719
+errlens/capture.py,sha256=xZZlP_LhXqUDmkV_YAUFZKHDvHUEXzYu_x8pVIUZMfA,2994
+errlens/cli.py,sha256=y4P2Vka0h9i_43kxt-jogRRSGwZET9vZVjKGev05ZoM,6954
+errlens/conpty_runner.py,sha256=ABp8xGH-4UGVBSDuGTKz30A30fqIALpJKcq2LkEq1XQ,12408
+errlens/i18n.py,sha256=reY8VjIdUL5kC-S-GdiIa997wrVafmTS7LnoOao4ffM,2390
+errlens/models.py,sha256=Enjn-C4FwJ1BzFIrki5wFOOMAXFo-NJO_YR6UFtn_Cw,4060
+errlens/posix_shell.py,sha256=3i4AV3SjaDoM8TIVS9_YOS9WX9ub_-wtVn_qGW78iq8,3074
+errlens/powershell.py,sha256=nPlGZDWJ_EREGMmBj85LqwzqKkWHvxTJT6t5CMBDR5s,3698
+errlens/pty_runner.py,sha256=33oskB5IlpB3PXAGAVk32m270VPccYvRNRIKFqASnW0,7084
+errlens/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+errlens/render.py,sha256=1PX78Vtau3BkxEzoaR_tRVx6XUfxdPEaS-oa-YMmeHo,4696
+errlens/runner.py,sha256=tZ1zGFf9-ipOP2TnRa4YbKvI_OKYmD0837HCk4mBn9A,10020
+errlens/service.py,sha256=WpKo9R9OiTlI4ggFID2_nBfirRdSkgi9apw_2ETkpTA,2602
+errlens/analyzers/__init__.py,sha256=Lf3L5CqPi18geW4Fe7gdsvDeQHDHz--j1cdLFDhLaSA,78
+errlens/analyzers/base.py,sha256=04kj74wNdB-0tZ0pjky--o2kN8Q6cD25TqamrW4_URE,1424
+errlens/analyzers/python.py,sha256=HYcfe9h1wqrNcUHbK7f-BHJJeKCxfyhTF9-Cj3drdDA,16244
+errlens/locales/en.json,sha256=AsFTM4rThOqyqPipZtlIq-qnZhrSTT1VQLnMUn5ZPTc,9107
+errlens/locales/ru.json,sha256=XFJW_d_8nzJrTJsG65xqq-s7j8W5tXr2MSAkDAgyEHI,14288
+errlens/rules/__init__.py,sha256=imlafOfMafltS594ewopLR1cd_0O348cJFpkaQ4LoyM,74
+errlens/rules/python.py,sha256=fmxGawpIoPYOT3JVCf9p_j8AeqKZkkmsKrX6tBnnNpo,3681
+errlens_cli-0.1.0.dist-info/licenses/LICENSE,sha256=w-U6mi6O-gzqwvlP9IB3m6Zr81MW1wNkqa3I_VBEPfs,1077
+errlens_cli-0.1.0.dist-info/METADATA,sha256=VGQgNhOuH3Go0y6vJ_r2lbdHK7ulPEAoAB-LHnBZ_1Q,15870
+errlens_cli-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+errlens_cli-0.1.0.dist-info/entry_points.txt,sha256=huj9rHpK07NvEqo5_Mluz5IvcEL3aENtZCr2e-gHj8k,51
+errlens_cli-0.1.0.dist-info/top_level.txt,sha256=MlJH5FSVsEJQu1-spNcKDl9aXfrLT2B1ANsP6xBgxzI,8
+errlens_cli-0.1.0.dist-info/RECORD,,

errlens_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

errlens_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+errlens = errlens.cli:main_entry

errlens_cli-0.1.0.dist-info/licenses/LICENSE

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

errlens_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+errlens