codenaut 0.1.0__py3-none-any.whl

client/llm_client.py

@@ -0,0 +1,266 @@
+import asyncio
+from typing import Any, AsyncGenerator
+import httpx
+from openai import APIConnectionError, APIError, AsyncOpenAI, RateLimitError
+
+from client.response import (
+    StreamEventType,
+    StreamEvent,
+    TextDelta,
+    TokenUsage,
+    ToolCall,
+    ToolCallDelta,
+    parse_tool_call_arguments,
+)
+from config.config import Config
+from langsmith import trace
+
+class LLMClient:
+    def __init__(self, config: Config) -> None:
+        self._client: AsyncOpenAI | None = None
+        self._max_retries: int = 3
+        self.config = config
+
+    def get_client(self) -> AsyncOpenAI:
+        if self._client is None:
+            self._client = AsyncOpenAI(
+                api_key=self.config.api_key,
+                base_url=self.config.base_url,
+                # Fail fast on a stalled endpoint instead of hanging on the SDK
+                # default (~10 min). `read` bounds silence between streamed chunks
+                # (and time-to-first-token); `connect` bounds the initial connect.
+                timeout=httpx.Timeout(90.0, connect=15.0),
+                # We run our own retry loop below; leaving the SDK's default (2)
+                # would multiply every attempt and compound stalls.
+                max_retries=0,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        if self._client:
+            await self._client.close()
+            self._client = None
+
+    def _build_tools(self, tools: list[dict[str, Any]]):
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool["name"],
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get(
+                        "parameters",
+                        {
+                            "type": "object",
+                            "properties": {},
+                        },
+                    ),
+                },
+            }
+            for tool in tools
+        ]
+
+    def _get_cached_tokens(self, usage: Any) -> int:
+        prompt_details = getattr(usage, "prompt_tokens_details", None)
+        if prompt_details is None:
+            return 0
+
+        cached_tokens = getattr(prompt_details, "cached_tokens", None)
+        return cached_tokens or 0
+
+    async def chat_completion(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> AsyncGenerator[StreamEvent, None]:
+
+        with trace(
+            name="llm.chat_completion",
+            run_type="llm",
+            inputs={
+                "messages": messages,
+                "model": self.config.model_name,
+                "tools_count": len(tools) if tools else 0,
+            },
+            metadata={"model": self.config.model_name},
+        ) as run:
+            client = self.get_client()
+
+            kwargs = {
+                "model": self.config.model_name,
+                "messages": messages,
+                "stream": stream,
+            }
+
+            if tools:
+                kwargs["tools"] = self._build_tools(tools)
+                kwargs["tool_choice"] = "auto"
+
+            for attempt in range(self._max_retries + 1):
+                try:
+                    if stream:
+                        async for event in self._stream_response(client, kwargs):
+                            yield event
+                    else:
+                        event = await self._non_stream_response(client, kwargs)
+                        yield event
+                    return
+                except RateLimitError as e:
+                    if attempt < self._max_retries:
+                        wait_time = 2**attempt
+                        await asyncio.sleep(wait_time)
+                    else:
+                        yield StreamEvent(
+                            type=StreamEventType.ERROR,
+                            error=f"Rate limit exceeded: {e}",
+                        )
+                        return
+                except APIConnectionError as e:
+                    if attempt < self._max_retries:
+                        wait_time = 2**attempt
+                        await asyncio.sleep(wait_time)
+                    else:
+                        yield StreamEvent(
+                            type=StreamEventType.ERROR,
+                            error=f"Connection error: {e}",
+                        )
+                        return
+                except APIError as e:
+                    yield StreamEvent(
+                        type=StreamEventType.ERROR,
+                        error=f"API error: {e}",
+                    )
+                    return
+
+    async def _stream_response(
+        self,
+        client: AsyncOpenAI,
+        kwargs: dict[str, Any],
+    ) -> AsyncGenerator[StreamEvent, None]:
+        response = await client.chat.completions.create(**kwargs)
+
+        finish_reason: str | None = None
+        usage: TokenUsage | None = None
+        tool_calls: dict[int, dict[str, Any]] = {}
+
+        async for chunk in response:
+            if hasattr(chunk, "usage") and chunk.usage:
+                usage = TokenUsage(
+                    prompt_tokens=chunk.usage.prompt_tokens,
+                    completion_tokens=chunk.usage.completion_tokens,
+                    total_tokens=chunk.usage.total_tokens,
+                    cached_tokens=self._get_cached_tokens(chunk.usage),
+                )
+
+            if not chunk.choices:
+                continue
+
+            choice = chunk.choices[0]
+            delta = choice.delta
+
+            if choice.finish_reason:
+                finish_reason = choice.finish_reason
+
+            if delta.content:
+                yield StreamEvent(
+                    type=StreamEventType.TEXT_DELTA,
+                    text_delta=TextDelta(delta.content),
+                )
+
+            if delta.tool_calls:
+                for tool_call_delta in delta.tool_calls:
+                    idx = tool_call_delta.index
+
+                    if idx not in tool_calls:
+                        tool_calls[idx] = {
+                            "id": "",
+                            "name": "",
+                            "arguments": "",
+                            "started": False,
+                        }
+
+                    tool_call = tool_calls[idx]
+                    if tool_call_delta.id:
+                        tool_call["id"] = tool_call_delta.id
+
+                    function = tool_call_delta.function
+                    if function and function.name:
+                        tool_call["name"] = function.name
+
+                    if tool_call["name"] and not tool_call["started"]:
+                        tool_call["started"] = True
+                        yield StreamEvent(
+                            type=StreamEventType.TOOL_CALL_START,
+                            tool_call_delta=ToolCallDelta(
+                                call_id=tool_call["id"],
+                                name=tool_call["name"],
+                            ),
+                        )
+
+                    if function and function.arguments:
+                        tool_call["arguments"] += function.arguments
+                        yield StreamEvent(
+                            type=StreamEventType.TOOL_CALL_DELTA,
+                            tool_call_delta=ToolCallDelta(
+                                call_id=tool_call["id"],
+                                name=tool_call["name"],
+                                arguments_delta=function.arguments,
+                            ),
+                        )
+
+        for idx, tc in tool_calls.items():
+            yield StreamEvent(
+                type=StreamEventType.TOOL_CALL_COMPLETE,
+                tool_call=ToolCall(
+                    call_id=tc["id"],
+                    name=tc["name"],
+                    arguments=parse_tool_call_arguments(tc["arguments"]),
+                ),
+            )
+
+        yield StreamEvent(
+            type=StreamEventType.MESSAGE_COMPLETE,
+            finish_reason=finish_reason,
+            usage=usage,
+        )
+
+    async def _non_stream_response(
+        self,
+        client: AsyncOpenAI,
+        kwargs: dict[str, Any],
+    ) -> StreamEvent:
+        response = await client.chat.completions.create(**kwargs)
+        choice = response.choices[0]
+        message = choice.message
+
+        text_delta = None
+        if message.content:
+            text_delta = TextDelta(content=message.content)
+
+        tool_calls: list[ToolCall] = []
+        if message.tool_calls:
+            for tc in message.tool_calls:
+                tool_calls.append(
+                    ToolCall(
+                        call_id=tc.id,
+                        name=tc.function.name,
+                        arguments=parse_tool_call_arguments(tc.function.arguments),
+                    )
+                )
+
+        usage = None
+        if response.usage:
+            usage = TokenUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+                cached_tokens=self._get_cached_tokens(response.usage),
+            )
+
+        return StreamEvent(
+            type=StreamEventType.MESSAGE_COMPLETE,
+            text_delta=text_delta,
+            finish_reason=choice.finish_reason,
+            usage=usage,
+        )

client/response.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+import json
+
+
+@dataclass
+class TextDelta:
+    content: str
+
+    def __str__(self):
+        return self.content
+
+
+class StreamEventType(str, Enum):
+    TEXT_DELTA = "text_delta"
+    MESSAGE_COMPLETE = "message_complete"
+    ERROR = "error"
+
+    TOOL_CALL_START = "tool_call_start"
+    TOOL_CALL_DELTA = "tool_call_delta"
+    TOOL_CALL_COMPLETE = "tool_call_complete"
+
+
+@dataclass
+class TokenUsage:
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+    cached_tokens: int = 0
+
+    def __add__(self, other: TokenUsage):
+        return TokenUsage(
+            prompt_tokens=self.prompt_tokens + other.prompt_tokens,
+            completion_tokens=self.completion_tokens + other.completion_tokens,
+            total_tokens=self.total_tokens + other.total_tokens,
+            cached_tokens=self.cached_tokens + other.cached_tokens,
+        )
+
+
+@dataclass
+class ToolCallDelta:
+    call_id: str
+    name: str | None = None
+    arguments_delta: str = ""
+
+
+@dataclass
+class ToolCall:
+    call_id: str
+    name: str | None = None
+    arguments: str = ""
+
+
+@dataclass
+class StreamEvent:
+    type: StreamEventType
+    text_delta: TextDelta | None = None
+    error: str | None = None
+    finish_reason: str | None = None
+    tool_call_delta: ToolCallDelta | None = None
+    tool_call: ToolCall | None = None
+    usage: TokenUsage | None = None
+
+
+@dataclass
+class ToolResultMessage:
+    tool_call_id: str
+    content: str
+    is_error: bool = False
+
+    def to_openai_message(self) -> dict[str, Any]:
+        return {
+            "role": "tool",
+            "tool_call_id": self.tool_call_id,
+            "content": self.content,
+        }
+
+
+def parse_tool_call_arguments(arguments_str: str) -> dict[str, Any]:
+    if not arguments_str:
+        return {}
+
+    try:
+        return json.loads(arguments_str)
+    except json.JSONDecodeError:
+        return {"raw_arguments": arguments_str}

codenaut-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,63 @@
+main.py,sha256=LFHn2Ov49-zNQqu3AX24UrH2PGXbNPwcnUs1qtgd7PM,17759
+agent/__init__.py,sha256=nZIx5ApwFdMjKOQPtS-4qR5I8UA6LRlu4rqFAErAgcA,34
+agent/agent.py,sha256=3BpqyIVlZwn5fUjk4eUpKGYAnh8VHWmp6YtvJj9oJfU,8782
+agent/events.py,sha256=WYJ5vcaZ3ItVOjyXla1TWrKb45KN8zpIK965VZUsxks,3974
+agent/persistence.py,sha256=8JK1fCzEHVLJC10DPkb1Amlg_Hn9ASGwjdeMoN96zhU,4165
+agent/session.py,sha256=3Pq0muVZY85pr6a6PLohyc42BhfD6yZt2PFfCNJXRZE,3411
+client/__init__.py,sha256=M4ahv6R9Kj3qD4JBpyUPgpjHnGy1riJM_iTn79Jw6Ig,31
+client/llm_client.py,sha256=eT2zlCWfQd7ea56IM61nhxSVH8oIOyn-IpypVmZvySY,9693
+client/response.py,sha256=K6tSQalNHxnr3KrpawYd93Clsr9yd8LOdLkE4W3lHDQ,2107
+codenaut-0.1.0.dist-info/licenses/LICENSE,sha256=1LZfjHOqkRejkZyYAe7R1xGMZprN0ExOIaM-df7gYY4,1067
+config/__init__.py,sha256=FXE68WpVrO9ePz1Hnd9ASfk4wXYD2dF6vzbeKvmm0bI,40
+config/config.py,sha256=Yi1vpfOfEzv4dQ9qcQ807cZr3poBvJ7UhShRd1FIxUA,4928
+config/loader.py,sha256=cS2uFa5XL90w59nKkfYgNLrAH4JP0yMKQfMpfAL4fug,5123
+context/__init__.py,sha256=g7OlaNtUW3JOROZ8rYPjVZum6oVlr5icfNO07N6xJUg,39
+context/compaction.py,sha256=vBS2qcMqKFcpEmCKj4cvwbmF1XxQw3EeF-44RoEytTs,3437
+context/loop_detector.py,sha256=dTyxIIZEijjrs1chScexUu7Dlb2TAmEkOwc_D2Ac_lk,1613
+context/manager.py,sha256=L-6Vs_5vV09PkzWrpnTwvaYNgzmK5fWRqm0xO1EeWPA,7934
+hooks/__init__.py,sha256=2qnpTS65dGZvePaSWNu-J0azm4YNSYdbw3WCEKpmikY,30
+hooks/hook_system.py,sha256=gb1QVUFiCEpSVdQIH7zsOEKbZt1w-TovY4P_2O200Xw,4394
+prompts/__init__.py,sha256=oHvySSUnV3dY00xMgRyLocCXhQrTcm0lXMGONiKONh4,37
+prompts/system.py,sha256=u5dy-e1iFwZLwyKdk7Ped9oOcHXsVI67sqjVKXNc4UU,20413
+safety/__init__.py,sha256=OY1s9BJe2zBTV0P5Rr5TsIoFPLza_tvzl7ERl6taZ64,36
+safety/approval.py,sha256=t00EzL5AoGz1C8wow5ELvPMRYQDANd6eY52x4yM_0Gs,4613
+skills/__init__.py,sha256=t_e173VDOEU9SLxy20dYG3-mVgPuyGZdPvs3o_90wGs,223
+skills/discovery.py,sha256=AgxBMNRgjGV1riHFCOs0WyVD6JK6vACjUs3uXdnPFWM,3313
+skills/models.py,sha256=IfsqiZh8cEkii6sF_tS7C6f4juNOZVG-4snYP3hPlBc,318
+skills/registry.py,sha256=SEbphwtXp8ER20x66gPu0W2iKgYDjmz9NPN5ijSrpWA,1819
+tools/__init__.py,sha256=-l-DUD3QxdEYoGwI37vjwsKulVxt8m9NsLr3UJKCrzs,44
+tools/base.py,sha256=76YetOiyB_2m4HG4rVhVrtGlcoAS4WiaHBf1EwKTcWE,5506
+tools/discovery.py,sha256=xBI3StV_JuWy6FJQ0RhfVxj2fANCnJ6cGWXxga0j5dc,2174
+tools/registry.py,sha256=-GzxUcWZaYJ5JIlRKBAWKDowSzN9vyhwJoOxbj2Ue6U,5302
+tools/subagents.py,sha256=sG3K6zSmC09bHLHivJwJxObkVn_RHjCp034b0CMZsdg,5051
+tools/builtin/__init__.py,sha256=JsemuTRhOaHnOSTebFKBQ_xjg6hBEpc5YImnqxCRrpo,1576
+tools/builtin/apply_patch.py,sha256=VxhX8hYeJAF3xYxMzIKaEgrK68dGyG4M0UHunoVhQ0w,12272
+tools/builtin/edit_file.py,sha256=tBQDO_q3Hbr9PZ7Q2361D9eQLSrqXfwaxoNB14_WgSA,7229
+tools/builtin/glob.py,sha256=ed_fVL2bB6A8DmbqbXkmoCqhfYOQNz-3DY9dNeH74yI,2425
+tools/builtin/grep.py,sha256=jClE2-uICi7onANmAyxvgfUbEhppHNnc0ioHYi1ltDw,3690
+tools/builtin/list_dir.py,sha256=xxJ6smvuVE8qeOR5CRPgiu2aM-oN-w5ifUn8NEumKkI,1818
+tools/builtin/memory.py,sha256=PvSayh_zikx47Dny05ZVGWswpgTpt-vYrmwprcnmX-o,4247
+tools/builtin/read_file.py,sha256=X3OBTNNDFRCX-3n6LX79WykENy67rht7VDTVUs372nE,4341
+tools/builtin/shell.py,sha256=BGKWHkzEaf6GSRTu8K1o9yw8v2_MFp7OD5ZMIqcnNVk,4822
+tools/builtin/tasks.py,sha256=IChW-WpDYy-JyyvvgE4LzQFwOwTp4h7Ci4hfaV6RqeY,12526
+tools/builtin/web_fetch.py,sha256=ooPzI8fBruEWeT6n7No4A5HGC6WYPXx0eSUn_PaAXpo,1824
+tools/builtin/web_search.py,sha256=PD5upTRAN2xZJ_dnRX8ZO28sOwSwd-yrCIey0Fda1VY,1821
+tools/builtin/write_file.py,sha256=07QtMR9LqVXN-G5Rtfus2WPPkMlQbnKhyY4QTJS26YE,3495
+tools/mcp/__init__.py,sha256=hruMBtSTRDIsC5MA83-BLdaQzjy_LJKKq1OlGzxrmU8,39
+tools/mcp/client.py,sha256=TwjIZr_55qnmy1r_aWNVgM-4Ng-B-9WSoE0w9jmWVkQ,3855
+tools/mcp/mcp_manager.py,sha256=5FbntJ-C0BXNHmRA3q_C53Us7GT_yuXWUOjmrM0D-co,2399
+tools/mcp/mcp_tool.py,sha256=yuWNeJ2L6fWy0afi7Kszzv9v4GNQWNVLqp5eOCvMfzM,1498
+ui/__init__.py,sha256=iHQwkfGYAYTxR3tVv6TK-k6V-KZ-LufnUx0TspOlgcw,252
+ui/completer.py,sha256=K9ElFxbmDgYZTTTGCXIn8VYjjZz82z3dnnE73Dh_85U,5246
+ui/prompt.py,sha256=KrUQaQUFX-1cUfBy1SFKQrLcJWEihBRpf0D0hpkA83Y,2172
+ui/tui.py,sha256=Lwn9ZpXXC0i2-NNBq5QfFM1-8oGdC0kUmL_X5ETlUzw,21836
+utils/__init__.py,sha256=ZzhtEkM5EYuz8Oi6eOevMF4Lhyaz30f4Bh7exMBuByo,30
+utils/errors.py,sha256=TGafz7_2XvFqJJKhU9d8gUVHLGkbFCZ9sNKDZpwLPOA,1429
+utils/file_tags.py,sha256=vp5HRagPNNRxt1p3ZgDLcck3nI70gtJXoc8iXTY23QM,2876
+utils/paths.py,sha256=UWhZu9pgrl--ganIBM3UVCZ1xRsKoxKbmWfSKaMCnrw,834
+utils/text.py,sha256=Ja4ROXd9wPeyjxssSkVddHHGnwXyFJxCVrDPFtftvTQ,2077
+codenaut-0.1.0.dist-info/METADATA,sha256=iiaWDohrNywMHQPBrqq-XbExp3X2qGZn338ONlvDx_w,5644
+codenaut-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+codenaut-0.1.0.dist-info/entry_points.txt,sha256=wrn5K1tYT1aVSP-KckqtwtobA9oISGRWfK5axMwOkKI,59
+codenaut-0.1.0.dist-info/top_level.txt,sha256=rCQsbocwJaqy1bpr0B0YuJNWQd31KXCmv1OjIquEWus,76
+codenaut-0.1.0.dist-info/RECORD,,

codenaut-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
+

codenaut-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+code-it = main:main
+codenaut = main:main

codenaut-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1,12 @@
+agent
+client
+config
+context
+hooks
+main
+prompts
+safety
+skills
+tools
+ui
+utils

config/__init__.py

@@ -0,0 +1 @@
+"""Configuration models and loaders."""