polyglav 0.37.0__tar.gz

polyglav-0.37.0/LICENSE

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

polyglav-0.37.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: polyglav
+Version: 0.37.0
+Summary: A lightweight agentic tooling core with API, CLI and REPL interfaces
+Author: Evgenij Myasnikov
+License-Expression: MIT
+Project-URL: Repository, https://github.com/polyglav/polyglav
+Project-URL: Issues, https://github.com/polyglav/polyglav/issues
+Project-URL: Changelog, https://github.com/polyglav/polyglav/blob/main/CHANGELOG.md
+Keywords: ai,ai-agents,api,assistant,cli,cloud,local,python,repl
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Polyglav
+
+<p align="center"><img src="polyglav.svg" alt="Polyglav terminal session"></p>
+
+**One agent, many heads**
+
+<p>
+  <a href="https://pypi.org/project/polyglav/"><img src="https://img.shields.io/pypi/v/polyglav" alt="PyPI version"></a>
+  <a href="https://polyglav.github.io/polyglav/"><img src="https://img.shields.io/badge/docs-site-blue" alt="Site"></a>
+  <img src="https://img.shields.io/badge/python-%3E%3D3.10-blue" alt="Python >=3.10">
+  <img src="https://img.shields.io/github/actions/workflow/status/polyglav/polyglav/ci.yml?branch=main" alt="CI">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero dependencies">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License">
+</p>
+
+Polyglav is an AI agent that lives in your terminal. You describe an outcome once, it breaks the job into steps, brings in specialist agents for each one, and lets them work through it in order, handing results from one to the next as they finish. You stay at a single prompt the whole time. The name says it: poly means many, glav means heads.
+
+## Why Polyglav
+
+- **One prompt, many heads** - ask for an outcome, and Polyglav splits it across specialists that run one after another in the same process. As soon as one delivers, the next continues. No windows to switch and no babysitting.
+- **It actually gets work done** - it reads and writes files, searches the web, runs commands, edits code, and commits, all behind permissions you control.
+- **Grows with you** - reusable roles and skills, scheduled jobs that run unattended, and a supervisor for many agents at once.
+- **Your machine, your keys** - config and complete session logs stay on your disk. Bring your own provider key, or run fully local.
+- **Safe by default** - every tool is permission controlled. Anything outside your project asks first, and every action is on the record.
+- **Zero dependencies** - pure Python standard library. Nothing to audit, no supply chain, no lockfile churn.
+- **At home in the terminal** - a fast streaming REPL with dimmed thinking, markdown rendering, command completion, and history. No browser and no account.
+- **Many providers, any model** - Ollama, OpenAI, Groq, Anthropic, OpenCode Zen/Go, or any OpenAI-compatible endpoint, picked automatically from the address.
+
+## What you can do with it
+
+- **Ship a change end to end** - ask for a feature and let a planner, a programmer, and a reviewer work through it in order.
+- **Keep a project tidy** - schedule a job that refreshes docs, updates a changelog, or summarizes logs on a cron.
+- **Research and write** - point it at a folder of notes or papers and ask for a summary with sources.
+- **Run many agents** - give each folder its own agent and watch them all from one place.
+- **Automate with the API** - drive the same loop from scripts, CI, or another program.
+
+## How it works
+
+1. **Ask** - describe an outcome to the assistant in one sentence.
+2. **Compose** - for bigger work it designs a small team: the specialists and the order they run in.
+3. **Run** - stages run one after another, each with its own tools and permissions.
+4. **Hand off** - as the work moves, each agent passes what it did to the next.
+5. **Report** - watch progress, jump into any agent, or come back to a summary.
+
+## Install
+
+```bash
+pipx install polyglav
+polyglav
+```
+
+For source installs, the REPL, the headless CLI, the HTTP API, Docker, plugins, and the full command reference, see [INSTALL.md](INSTALL.md).
+
+## Learn more
+
+- [AGENTS.md](AGENTS.md) - architecture and conventions
+- [CONTRIBUTING.md](CONTRIBUTING.md) - the contribution workflow
+- [INSTALL.md](INSTALL.md) - install, run, and command reference
+- [VISION.md](VISION.md) - what Polyglav is and where it is going
+- [docs/index.md](docs/index.md) - full documentation
+
+## License
+
+[MIT](LICENSE)

polyglav-0.37.0/README.md

@@ -0,0 +1,64 @@
+# Polyglav
+
+<p align="center"><img src="polyglav.svg" alt="Polyglav terminal session"></p>
+
+**One agent, many heads**
+
+<p>
+  <a href="https://pypi.org/project/polyglav/"><img src="https://img.shields.io/pypi/v/polyglav" alt="PyPI version"></a>
+  <a href="https://polyglav.github.io/polyglav/"><img src="https://img.shields.io/badge/docs-site-blue" alt="Site"></a>
+  <img src="https://img.shields.io/badge/python-%3E%3D3.10-blue" alt="Python >=3.10">
+  <img src="https://img.shields.io/github/actions/workflow/status/polyglav/polyglav/ci.yml?branch=main" alt="CI">
+  <img src="https://img.shields.io/badge/dependencies-0-brightgreen" alt="Zero dependencies">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License">
+</p>
+
+Polyglav is an AI agent that lives in your terminal. You describe an outcome once, it breaks the job into steps, brings in specialist agents for each one, and lets them work through it in order, handing results from one to the next as they finish. You stay at a single prompt the whole time. The name says it: poly means many, glav means heads.
+
+## Why Polyglav
+
+- **One prompt, many heads** - ask for an outcome, and Polyglav splits it across specialists that run one after another in the same process. As soon as one delivers, the next continues. No windows to switch and no babysitting.
+- **It actually gets work done** - it reads and writes files, searches the web, runs commands, edits code, and commits, all behind permissions you control.
+- **Grows with you** - reusable roles and skills, scheduled jobs that run unattended, and a supervisor for many agents at once.
+- **Your machine, your keys** - config and complete session logs stay on your disk. Bring your own provider key, or run fully local.
+- **Safe by default** - every tool is permission controlled. Anything outside your project asks first, and every action is on the record.
+- **Zero dependencies** - pure Python standard library. Nothing to audit, no supply chain, no lockfile churn.
+- **At home in the terminal** - a fast streaming REPL with dimmed thinking, markdown rendering, command completion, and history. No browser and no account.
+- **Many providers, any model** - Ollama, OpenAI, Groq, Anthropic, OpenCode Zen/Go, or any OpenAI-compatible endpoint, picked automatically from the address.
+
+## What you can do with it
+
+- **Ship a change end to end** - ask for a feature and let a planner, a programmer, and a reviewer work through it in order.
+- **Keep a project tidy** - schedule a job that refreshes docs, updates a changelog, or summarizes logs on a cron.
+- **Research and write** - point it at a folder of notes or papers and ask for a summary with sources.
+- **Run many agents** - give each folder its own agent and watch them all from one place.
+- **Automate with the API** - drive the same loop from scripts, CI, or another program.
+
+## How it works
+
+1. **Ask** - describe an outcome to the assistant in one sentence.
+2. **Compose** - for bigger work it designs a small team: the specialists and the order they run in.
+3. **Run** - stages run one after another, each with its own tools and permissions.
+4. **Hand off** - as the work moves, each agent passes what it did to the next.
+5. **Report** - watch progress, jump into any agent, or come back to a summary.
+
+## Install
+
+```bash
+pipx install polyglav
+polyglav
+```
+
+For source installs, the REPL, the headless CLI, the HTTP API, Docker, plugins, and the full command reference, see [INSTALL.md](INSTALL.md).
+
+## Learn more
+
+- [AGENTS.md](AGENTS.md) - architecture and conventions
+- [CONTRIBUTING.md](CONTRIBUTING.md) - the contribution workflow
+- [INSTALL.md](INSTALL.md) - install, run, and command reference
+- [VISION.md](VISION.md) - what Polyglav is and where it is going
+- [docs/index.md](docs/index.md) - full documentation
+
+## License
+
+[MIT](LICENSE)

polyglav-0.37.0/plugins/__init__.py

@@ -0,0 +1,4 @@
+"""Bundled plugins shipped with polyglav. Each subdirectory here is a plugin
+directory (manifest.json + entry module), discovered by
+polyglav.plugins.manager.PluginManager.bundled_dir.
+"""

polyglav-0.37.0/plugins/polyglav-core-anthropic/manifest.json

@@ -0,0 +1,13 @@
+{
+  "name": "polyglav-core-anthropic",
+  "version": "0.1.0",
+  "description": "Anthropic provider - bundled with polyglav",
+  "polyglav_version": ">=0.28.0,<1.0",
+  "python": ">=3.10",
+  "entry": "src/plugin.py",
+  "provides": {
+    "tools": [],
+    "providers": ["anthropic"],
+    "commands": []
+  }
+}

polyglav-0.37.0/plugins/polyglav-core-anthropic/src/plugin.py

@@ -0,0 +1,24 @@
+from polyglav.providers.base import OpenAICompatibleProvider
+
+
+class AnthropicProvider(OpenAICompatibleProvider):
+    DEFAULT_BASE_URL = 'https://api.anthropic.com/v1'
+    DEFAULT_MODEL = 'claude-sonnet-4-20250514'
+    HOST_PATTERNS = ('anthropic.com',)
+
+    _BUDGET = {'low': 1024, 'medium': 2048, 'high': 4096}
+
+    def _reasoning_payload(self, payload: dict) -> dict:
+        if self._reasoning_off(self.reasoning):
+            payload['thinking'] = {'type': 'disabled'}
+            return payload
+        effort = self.reasoning
+        if effort is True or effort in ('on', 'auto'):
+            effort = 'medium'
+        budget = self._BUDGET.get(effort, 2048)
+        payload['thinking'] = {'type': 'enabled', 'budget_tokens': budget}
+        return payload
+
+
+def register_providers(providers):
+    providers['anthropic'] = AnthropicProvider

polyglav-0.37.0/plugins/polyglav-core-anthropic/tests/test_anthropic_provider.py

@@ -0,0 +1,53 @@
+import importlib.util
+import sys
+import unittest
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parents[1] / 'src'
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
+
+
+def _load_plugin():
+    name = 'polyglav_anthropic_provider_plugin'
+    spec = importlib.util.spec_from_file_location(name, str(SRC / 'plugin.py'))
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+AnthropicProvider = _load_plugin().AnthropicProvider
+
+
+class TestAnthropicProvider(unittest.TestCase):
+
+    def test_defaults(self):
+        p = AnthropicProvider()
+        self.assertEqual(p.base_url, 'https://api.anthropic.com/v1')
+        self.assertEqual(p.model, 'claude-sonnet-4-20250514')
+        self.assertEqual(p._endpoint(), 'https://api.anthropic.com/v1/chat/completions')
+
+    def test_host_patterns(self):
+        self.assertIn('anthropic.com', AnthropicProvider.HOST_PATTERNS)
+
+    def test_reasoning_off(self):
+        p = AnthropicProvider(reasoning=False)
+        payload = p._payload([{'role': 'user', 'content': 'hi'}])
+        self.assertEqual(payload['thinking'], {'type': 'disabled'})
+
+    def test_reasoning_auto_maps_to_medium(self):
+        p = AnthropicProvider(reasoning='auto')
+        payload = p._payload([{'role': 'user', 'content': 'hi'}])
+        self.assertEqual(payload['thinking'],
+                         {'type': 'enabled', 'budget_tokens': 2048})
+
+    def test_reasoning_high_budget(self):
+        p = AnthropicProvider(reasoning='high')
+        payload = p._payload([{'role': 'user', 'content': 'hi'}])
+        self.assertEqual(payload['thinking'],
+                         {'type': 'enabled', 'budget_tokens': 4096})
+
+
+if __name__ == '__main__':
+    unittest.main()

polyglav-0.37.0/plugins/polyglav-core-dev/manifest.json

@@ -0,0 +1,17 @@
+{
+  "name": "polyglav-core-dev",
+  "version": "0.1.0",
+  "description": "Developer workflow wrappers: code_test, code_lint, code_format - bundled with polyglav",
+  "polyglav_version": ">=0.13.0,<1.0",
+  "python": ">=3.10",
+  "entry": "src/plugin.py",
+  "provides": {
+    "tools": [
+      "code_test",
+      "code_lint",
+      "code_format"
+    ],
+    "providers": [],
+    "commands": []
+  }
+}

polyglav-0.37.0/plugins/polyglav-core-dev/src/plugin.py

@@ -0,0 +1,234 @@
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+MAX_TIMEOUT = 600
+DEFAULT_TIMEOUT = 300
+
+DEFAULTS = {
+    'test': 'python -m unittest discover',
+    'lint': 'ruff check .',
+    'format': 'ruff format .',
+}
+
+
+def _resolve_interpreter(argv: list[str]) -> list[str]:
+    if argv and argv[0] in ('python', 'python3'):
+        return [sys.executable] + argv[1:]
+    return argv
+
+
+def _clamp_timeout(timeout) -> int:
+    try:
+        return max(1, min(int(timeout), MAX_TIMEOUT))
+    except (TypeError, ValueError):
+        return DEFAULT_TIMEOUT
+
+
+def _cap(config=None) -> int:
+    if config is None:
+        return 0
+    try:
+        return max(0, int(config.get('tool_max_result_chars', 0)))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _truncate(text: str, max_chars: int = 0) -> str:
+    if max_chars > 0 and len(text) > max_chars:
+        return text[:max_chars].rsplit('\n', 1)[0] + '\n... (truncated)'
+    return text
+
+
+def _is_failure(result: str) -> bool:
+    for line in result.splitlines():
+        if line.startswith('exit '):
+            try:
+                return int(line[5:].strip()) != 0
+            except ValueError:
+                return False
+    return False
+
+
+def _cmd(config, key: str, default: str) -> list[str]:
+    raw = ''
+    if config is not None:
+        raw = str(config.get(key) or '')
+    if not raw.strip():
+        raw = default
+    try:
+        argv = shlex.split(raw)
+    except ValueError:
+        argv = raw.split()
+    argv = argv or [default]
+    return _resolve_interpreter(argv)
+
+
+def _is_discover(argv: list[str]) -> bool:
+    return (len(argv) >= 4 and argv[1] == '-m' and argv[2] == 'unittest'
+            and argv[3] == 'discover')
+
+
+def _test_argv(config, target: str) -> list[str]:
+    argv = _cmd(config, 'dev.test_cmd', DEFAULTS['test'])
+    if not target:
+        return argv
+    if _is_discover(argv):
+        return [argv[0], '-m', 'unittest', target]
+    return argv + [target]
+
+
+def _run(argv: list[str], cwd: str | None, config,
+         timeout: int, target: str = '') -> str:
+    if cwd and not Path(cwd).is_dir():
+        return f'Error: cwd not found: {cwd}'
+    timeout = _clamp_timeout(timeout)
+    try:
+        proc = subprocess.run(
+            argv, capture_output=True, text=True, cwd=cwd, timeout=timeout,
+        )
+    except FileNotFoundError:
+        return f'Error: command not found: {argv[0]}'
+    except subprocess.TimeoutExpired as e:
+        out = e.stdout or ''
+        return f'Error: command timed out after {timeout}s' + (
+            f'\n{_truncate(out, _cap(config))}' if out else '')
+    except OSError as e:
+        return f'Error running command: {e}'
+    stdout = proc.stdout or ''
+    stderr = proc.stderr or ''
+    body = stdout if not stderr or stderr == stdout else f'{stdout}\n{stderr}'
+    lines = [f'$ {" ".join(argv)}']
+    if cwd:
+        lines.append(f'[cwd: {cwd}]')
+    lines.append(f'exit {proc.returncode}')
+    no_tests = ('NO TESTS RAN' in body or 'Ran 0 tests' in body
+                or proc.returncode == 5)
+    if target and no_tests:
+        lines.append(
+            f'Error: no tests matched "{target}" '
+            f'(unittest exit {proc.returncode})')
+    if body:
+        lines.append(_truncate(body, _cap(config)))
+    return '\n'.join(lines)
+
+
+def register_tools(registry):
+    @registry.register(
+        name='code_test',
+        description='Run the project test suite. Uses the dev.test_cmd config key (default "python -m unittest discover"); pass target to run a specific test module or path. Reports the exit code and output. Use to verify code changes.',
+        parameters={
+            'type': 'object',
+            'properties': {
+                'target': {
+                    'type': 'string',
+                    'description': 'Optional test module, class, or path to run instead of the whole suite',
+                },
+                'cwd': {
+                    'type': 'string',
+                    'description': 'Working directory for the command (defaults to the current one)',
+                },
+                'timeout': {
+                    'type': 'integer',
+                    'description': 'Timeout in seconds before the command is killed (capped at 600)',
+                },
+            },
+            'required': [],
+        },
+        category='exec',
+        permission='bash',
+        path_arg='cwd',
+        key_arg='target',
+        short='Run the project test suite',
+        echo=True,
+        glyph='$',
+        verb='Test',
+        error=_is_failure,
+        aliases=['run_tests', 'test_suite'],
+        param_aliases={'test': 'target', 'path': 'target', 'tests': 'target'},
+    )
+    def code_test(target: str = '', cwd: str | None = None,
+                  timeout: int = DEFAULT_TIMEOUT, _config=None) -> str:
+        argv = _test_argv(_config, target)
+        return _run(argv, cwd, _config, timeout, target=target)
+
+    @registry.register(
+        name='code_lint',
+        description='Run the project linter. Uses the dev.lint_cmd config key (default "ruff check ."); pass target to lint a specific path. Reports the exit code and findings. Use to check code style before finishing.',
+        parameters={
+            'type': 'object',
+            'properties': {
+                'target': {
+                    'type': 'string',
+                    'description': 'Optional path to lint instead of the whole project',
+                },
+                'cwd': {
+                    'type': 'string',
+                    'description': 'Working directory for the command (defaults to the current one)',
+                },
+                'timeout': {
+                    'type': 'integer',
+                    'description': 'Timeout in seconds before the command is killed (capped at 600)',
+                },
+            },
+            'required': [],
+        },
+        category='exec',
+        permission='bash',
+        path_arg='cwd',
+        key_arg='target',
+        short='Run the project linter',
+        echo=True,
+        glyph='$',
+        verb='Lint',
+        error=_is_failure,
+        aliases=['run_lint', 'lint_check'],
+        param_aliases={'path': 'target'},
+    )
+    def code_lint(target: str = '', cwd: str | None = None,
+                  timeout: int = DEFAULT_TIMEOUT, _config=None) -> str:
+        argv = _cmd(_config, 'dev.lint_cmd', DEFAULTS['lint'])
+        if target:
+            argv = argv + [target]
+        return _run(argv, cwd, _config, timeout)
+
+    @registry.register(
+        name='code_format',
+        description='Run the project formatter. Uses the dev.format_cmd config key (default "ruff format ."); pass target to format a specific path. Reports the exit code and output. Use to format code before finishing.',
+        parameters={
+            'type': 'object',
+            'properties': {
+                'target': {
+                    'type': 'string',
+                    'description': 'Optional path to format instead of the whole project',
+                },
+                'cwd': {
+                    'type': 'string',
+                    'description': 'Working directory for the command (defaults to the current one)',
+                },
+                'timeout': {
+                    'type': 'integer',
+                    'description': 'Timeout in seconds before the command is killed (capped at 600)',
+                },
+            },
+            'required': [],
+        },
+        category='exec',
+        permission='bash',
+        path_arg='cwd',
+        key_arg='target',
+        short='Run the project formatter',
+        echo=True,
+        glyph='$',
+        verb='Format',
+        error=_is_failure,
+        aliases=['run_format', 'format_code'],
+        param_aliases={'path': 'target'},
+    )
+    def code_format(target: str = '', cwd: str | None = None,
+                    timeout: int = DEFAULT_TIMEOUT, _config=None) -> str:
+        argv = _cmd(_config, 'dev.format_cmd', DEFAULTS['format'])
+        if target:
+            argv = argv + [target]
+        return _run(argv, cwd, _config, timeout)