codenaut 0.1.0__tar.gz

codenaut-0.1.0/LICENSE

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

codenaut-0.1.0/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: codenaut
+Version: 0.1.0
+Summary: A terminal-based OpenAI-compatible coding agent with tools, approvals, MCP, and session persistence.
+Author: nick211908
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/nick211908/coding-agent
+Project-URL: Issues, https://github.com/nick211908/coding-agent/issues
+Project-URL: Repository, https://github.com/nick211908/coding-agent
+Keywords: agent,cli,coding,openai,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.4.2
+Requires-Dist: ddgs>=9.14.4
+Requires-Dist: fastmcp>=3.4.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: langsmith>=0.13.0
+Requires-Dist: openai>=2.44.0
+Requires-Dist: platformdirs>=4.10.0
+Requires-Dist: prompt-toolkit>=3.0.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: rich>=14.2.0
+Requires-Dist: tiktoken>=0.13.0
+Requires-Dist: tomli>=2.4.1; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pylint>=4.0.6; extra == "dev"
+Dynamic: license-file
+
+# code-it
+
+A terminal-based, OpenAI-compatible coding agent that reads, edits, and runs code in your project through a ReAct-style tool-calling loop with approvals, hooks, MCP, and session persistence.
+
+## Install
+
+Prerequisites: Python 3.13+ and `uv`.
+
+Install dependencies into the project-managed environment:
+
+```bash
+uv sync
+```
+
+Build distributable artifacts:
+
+```bash
+uv build
+```
+
+This creates:
+
+- `dist/code_it-<version>-py3-none-any.whl`
+- `dist/code_it-<version>.tar.gz`
+
+## First Run
+
+After syncing the project environment, configure credentials:
+
+```bash
+uv run code-it --configure
+```
+
+This prompts for:
+
+- your API key
+- an optional base URL for any OpenAI-compatible provider
+
+The values are saved in your user config file at:
+
+- Windows: `%APPDATA%\code-it\config.toml`
+- macOS: `~/Library/Application Support/code-it/config.toml`
+- Linux: `~/.config/code-it/config.toml`
+
+You can still use a project-local `.env` file or `API_KEY` and `BASE_URL` environment variables, but they are no longer required for packaged installs.
+
+## Usage
+
+Run interactively:
+
+```bash
+uv run code-it
+```
+
+Run a single prompt:
+
+```bash
+uv run code-it "Summarize what this repo does"
+```
+
+Target a specific working directory:
+
+```bash
+uv run code-it --cwd /path/to/project "Find and fix the failing test"
+```
+
+Update saved credentials later:
+
+```bash
+uv run code-it --configure
+```
+
+Inside an interactive session:
+
+```text
+[user]> /setup                  # update saved API credentials
+[user]> /tools                  # list available tools
+[user]> /mcp                    # list connected MCP servers
+[user]> /approval auto-edit     # change the approval policy
+[user]> /save                   # save the current session
+[user]> /sessions               # list saved sessions
+[user]> /resume <session_id>    # resume a saved session
+[user]> /checkpoint             # snapshot the current session
+[user]> /stats                  # show token/turn usage stats
+[user]> /exit                   # quit
+```
+
+## Project Config
+
+Project-level overrides still live in `.ai-agent/config.toml`.
+
+You can also add:
+
+- `AGENT.MD` for project-specific developer instructions
+- `.ai-agent/skills/<skill-name>/SKILL.md` for reusable skills
+- `.ai-agent/tools/*.py` for custom tools
+
+## Publish Checklist
+
+1. Bump `version` in `pyproject.toml`.
+2. Run tests.
+3. Build the wheel and sdist with `uv build --no-sources`.
+4. Test the CLI with `uv run code-it --configure`.
+5. Upload to TestPyPI.
+6. Verify both `uv run code-it --configure` and `uv run code-it` work.
+7. Publish to PyPI.
+
+## Publish With uv
+
+Recommended local release flow:
+
+```bash
+uv sync --frozen
+uv run python -m unittest tests.test_config_loader tests.test_skills
+uv build --no-sources
+uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+```
+
+TestPyPI publish:
+
+```bash
+$env:UV_PUBLISH_TOKEN="pypi-***"
+uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+PyPI publish:
+
+```bash
+$env:UV_PUBLISH_TOKEN="pypi-***"
+uv publish
+```
+
+For the first release, verify the package name on PyPI before publishing. If `code-it` is already taken, rename `project.name` in `pyproject.toml` before uploading.
+
+## Trusted Publishing
+
+A GitHub Actions release workflow is included at `.github/workflows/publish.yml`.
+
+To use it:
+
+1. Create the project on PyPI.
+2. In the PyPI project settings, add a Trusted Publisher for this GitHub repository.
+3. In GitHub, create an environment named `pypi`.
+4. Push a version tag like `v0.1.0`.
+
+That workflow will:
+
+- sync with `uv`
+- run the unit tests
+- build the wheel and source distribution
+- smoke-test both artifacts
+- publish with `uv publish`
+
+## Why `uv` Instead of `pip install -e .`
+
+This repository already carries a `uv.lock`, so `uv sync` is the safer default for development. It avoids polluting a shared Python installation and reduces resolver conflicts with unrelated packages already installed on your machine.
+
+## License
+
+Distributed under the [MIT License](LICENSE).

codenaut-0.1.0/README.md

@@ -0,0 +1,161 @@
+# code-it
+
+A terminal-based, OpenAI-compatible coding agent that reads, edits, and runs code in your project through a ReAct-style tool-calling loop with approvals, hooks, MCP, and session persistence.
+
+## Install
+
+Prerequisites: Python 3.13+ and `uv`.
+
+Install dependencies into the project-managed environment:
+
+```bash
+uv sync
+```
+
+Build distributable artifacts:
+
+```bash
+uv build
+```
+
+This creates:
+
+- `dist/code_it-<version>-py3-none-any.whl`
+- `dist/code_it-<version>.tar.gz`
+
+## First Run
+
+After syncing the project environment, configure credentials:
+
+```bash
+uv run code-it --configure
+```
+
+This prompts for:
+
+- your API key
+- an optional base URL for any OpenAI-compatible provider
+
+The values are saved in your user config file at:
+
+- Windows: `%APPDATA%\code-it\config.toml`
+- macOS: `~/Library/Application Support/code-it/config.toml`
+- Linux: `~/.config/code-it/config.toml`
+
+You can still use a project-local `.env` file or `API_KEY` and `BASE_URL` environment variables, but they are no longer required for packaged installs.
+
+## Usage
+
+Run interactively:
+
+```bash
+uv run code-it
+```
+
+Run a single prompt:
+
+```bash
+uv run code-it "Summarize what this repo does"
+```
+
+Target a specific working directory:
+
+```bash
+uv run code-it --cwd /path/to/project "Find and fix the failing test"
+```
+
+Update saved credentials later:
+
+```bash
+uv run code-it --configure
+```
+
+Inside an interactive session:
+
+```text
+[user]> /setup                  # update saved API credentials
+[user]> /tools                  # list available tools
+[user]> /mcp                    # list connected MCP servers
+[user]> /approval auto-edit     # change the approval policy
+[user]> /save                   # save the current session
+[user]> /sessions               # list saved sessions
+[user]> /resume <session_id>    # resume a saved session
+[user]> /checkpoint             # snapshot the current session
+[user]> /stats                  # show token/turn usage stats
+[user]> /exit                   # quit
+```
+
+## Project Config
+
+Project-level overrides still live in `.ai-agent/config.toml`.
+
+You can also add:
+
+- `AGENT.MD` for project-specific developer instructions
+- `.ai-agent/skills/<skill-name>/SKILL.md` for reusable skills
+- `.ai-agent/tools/*.py` for custom tools
+
+## Publish Checklist
+
+1. Bump `version` in `pyproject.toml`.
+2. Run tests.
+3. Build the wheel and sdist with `uv build --no-sources`.
+4. Test the CLI with `uv run code-it --configure`.
+5. Upload to TestPyPI.
+6. Verify both `uv run code-it --configure` and `uv run code-it` work.
+7. Publish to PyPI.
+
+## Publish With uv
+
+Recommended local release flow:
+
+```bash
+uv sync --frozen
+uv run python -m unittest tests.test_config_loader tests.test_skills
+uv build --no-sources
+uv run --isolated --no-project --with dist/*.whl tests/smoke_test.py
+uv run --isolated --no-project --with dist/*.tar.gz tests/smoke_test.py
+```
+
+TestPyPI publish:
+
+```bash
+$env:UV_PUBLISH_TOKEN="pypi-***"
+uv publish --publish-url https://test.pypi.org/legacy/
+```
+
+PyPI publish:
+
+```bash
+$env:UV_PUBLISH_TOKEN="pypi-***"
+uv publish
+```
+
+For the first release, verify the package name on PyPI before publishing. If `code-it` is already taken, rename `project.name` in `pyproject.toml` before uploading.
+
+## Trusted Publishing
+
+A GitHub Actions release workflow is included at `.github/workflows/publish.yml`.
+
+To use it:
+
+1. Create the project on PyPI.
+2. In the PyPI project settings, add a Trusted Publisher for this GitHub repository.
+3. In GitHub, create an environment named `pypi`.
+4. Push a version tag like `v0.1.0`.
+
+That workflow will:
+
+- sync with `uv`
+- run the unit tests
+- build the wheel and source distribution
+- smoke-test both artifacts
+- publish with `uv publish`
+
+## Why `uv` Instead of `pip install -e .`
+
+This repository already carries a `uv.lock`, so `uv sync` is the safer default for development. It avoids polluting a shared Python installation and reduces resolver conflicts with unrelated packages already installed on your machine.
+
+## License
+
+Distributed under the [MIT License](LICENSE).

codenaut-0.1.0/agent/__init__.py

@@ -0,0 +1 @@
+"""Core agent runtime package."""

codenaut-0.1.0/agent/agent.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+import json
+from typing import AsyncGenerator, Awaitable, Callable
+from agent.events import AgentEvent, AgentEventType
+from agent.session import Session
+from client.response import StreamEventType, TokenUsage, ToolCall, ToolResultMessage
+from config.config import Config
+from prompts.system import create_loop_breaker_prompt
+from tools.base import ToolConfirmation
+from langsmith import trace
+
+class Agent:
+    def __init__(
+        self,
+        config: Config,
+        confirmation_callback: Callable[[ToolConfirmation], bool] | None = None,
+    ):
+        self.config = config
+        self.session: Session | None = Session(self.config)
+        self.session.approval_manager.confirmation_callback = confirmation_callback
+
+    async def run(self, message: str):
+        with trace(
+            name="agent.run",
+            run_type="chain",
+            inputs={"message": message},
+            metadata={"model": self.config.model_name},
+        ) as run:
+            await self.session.hook_system.trigger_before_agent(message)
+            yield AgentEvent.agent_start(message)
+            self.session.context_manager.add_user_message(message)
+
+            final_response: str | None = None
+
+            async for event in self._agentic_loop(message):
+                yield event
+
+                if event.type == AgentEventType.TEXT_COMPLETE:
+                    final_response = event.data.get("content")
+
+            # Patch the output onto the run before the span closes
+            run.end(outputs={"response": final_response})
+
+            await self.session.hook_system.trigger_after_agent(message, final_response)
+            yield AgentEvent.agent_end(final_response)
+
+    def _should_enable_tools(self, message: str) -> bool:
+        normalized = " ".join(message.lower().strip().split())
+        if not normalized:
+            return False
+
+        simple_messages = {
+            "hi",
+            "hii",
+            "hiii",
+            "hello",
+            "hey",
+            "hlo",
+            "yo",
+            "sup",
+            "thanks",
+            "thank you",
+            "ok",
+            "okay",
+        }
+
+        return normalized not in simple_messages
+
+    async def _agentic_loop(self, latest_user_message: str) -> AsyncGenerator[AgentEvent, None]:
+        max_turns = self.config.max_turns
+        enable_tools = self._should_enable_tools(latest_user_message)
+
+        for turn_num in range(max_turns):
+            self.session.increment_turn()
+            response_text = ""
+
+            # check for context overflow
+            if self.session.context_manager.needs_compression():
+                yield AgentEvent.compaction_start(
+                    self.session.context_manager.message_count
+                )
+                summary, usage = await self.session.chat_compactor.compress(
+                    self.session.context_manager
+                )
+
+                if summary:
+                    self.session.context_manager.replace_with_summary(summary)
+                    self.session.context_manager.set_latest_usage(usage)
+                    self.session.context_manager.add_usage(usage)
+                    yield AgentEvent.compaction_complete(
+                        self.session.context_manager.message_count,
+                        usage,
+                    )
+                else:
+                    yield AgentEvent.compaction_error(
+                        self.session.chat_compactor.last_error
+                        or "Compaction failed."
+                    )
+
+            tool_schemas = self.session.tool_registry.get_schemas() if enable_tools else []
+
+            tool_calls: list[ToolCall] = []
+            usage: TokenUsage | None = None
+
+            async for event in self.session.client.chat_completion(
+                self.session.context_manager.get_messages(),
+                tools=tool_schemas if tool_schemas else None,
+            ):
+                if event.type == StreamEventType.TEXT_DELTA:
+                    if event.text_delta:
+                        content = event.text_delta.content
+                        response_text += content
+                        yield AgentEvent.text_delta(content)
+                elif event.type == StreamEventType.TOOL_CALL_COMPLETE:
+                    if event.tool_call:
+                        tool_calls.append(event.tool_call)
+                elif event.type == StreamEventType.ERROR:
+                    yield AgentEvent.agent_error(
+                        event.error or "Unknown error occurred.",
+                    )
+                elif event.type == StreamEventType.MESSAGE_COMPLETE:
+                    usage = event.usage
+
+            self.session.context_manager.add_assistant_message(
+                response_text or None,
+                (
+                    [
+                        {
+                            "id": tc.call_id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.name,
+                                "arguments": json.dumps(tc.arguments),
+                            },
+                        }
+                        for tc in tool_calls
+                    ]
+                    if tool_calls
+                    else None
+                ),
+            )
+            if response_text:
+                yield AgentEvent.text_complete(response_text)
+                self.session.loop_detector.record_action(
+                    "response",
+                    text=response_text,
+                )
+
+            if not tool_calls:
+                if usage:
+                    self.session.context_manager.set_latest_usage(usage)
+                    self.session.context_manager.add_usage(usage)
+
+                self.session.context_manager.prune_tool_outputs()
+                return
+
+            enable_tools = True
+
+            tool_call_results: list[ToolResultMessage] = []
+
+            for tool_call in tool_calls:
+                with trace(
+                    name=f"tool.{tool_call.name}",
+                    run_type="tool",
+                    inputs={
+                        "tool_name": tool_call.name,
+                        "arguments": tool_call.arguments,
+                    },
+                ) as tool_run:
+                    yield AgentEvent.tool_call_start(
+                        tool_call.call_id,
+                        tool_call.name,
+                        tool_call.arguments,
+                    )
+
+                    self.session.loop_detector.record_action(
+                        "tool_call",
+                        tool_name=tool_call.name,
+                        args=tool_call.arguments,
+                    )
+
+                    result = await self.session.tool_registry.invoke(
+                        tool_call.name,
+                        tool_call.arguments,
+                        self.config.cwd,
+                        self.session.hook_system,
+                        self.session.approval_manager,
+                    )
+
+                    yield AgentEvent.tool_call_complete(
+                        tool_call.call_id,
+                        tool_call.name,
+                        result,
+                    )
+
+                    tool_call_results.append(
+                        ToolResultMessage(
+                            tool_call_id=tool_call.call_id,
+                            content=result.to_model_output(),
+                            is_error=not result.success,
+                        )
+                    )
+
+            for tool_result in tool_call_results:
+                self.session.context_manager.add_tool_result(
+                    tool_result.tool_call_id,
+                    tool_result.content,
+                )
+
+            loop_detection_error = self.session.loop_detector.check_for_loop()
+            if loop_detection_error:
+                loop_prompt = create_loop_breaker_prompt(loop_detection_error)
+                self.session.context_manager.add_user_message(loop_prompt)
+
+            if usage:
+                self.session.context_manager.set_latest_usage(usage)
+                self.session.context_manager.add_usage(usage)
+
+            self.session.context_manager.prune_tool_outputs()
+
+        yield AgentEvent.agent_error(f"Maximum turns ({max_turns}) reached")
+
+    async def __aenter__(self) -> Agent:
+        await self.session.initialize()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type,
+        exc_val,
+        exc_tb,
+    ) -> None:
+        if self.session and self.session.client and self.session.mcp_manager:
+            await self.session.client.close()
+            await self.session.mcp_manager.shutdown()
+            self.session = None