CodeFile.txt

ROOT_NAME code-edith
CREATED_UTC 2026-03-22T10:34:41Z
TOTAL_SOURCE_MB 0.04
FILE_COUNT 40

START_STRUCTURE
code-edith/
|-- .assets/
|   |-- edith-asi-art.txt
|   \-- edith-asi-unicode.txt
|-- .github/
|   \-- workflows/
|       \-- python-publish.yml
|-- src/
|   |-- config/
|   |   |-- system.txt
|   |   |-- tools.json
|   |   \-- version.txt
|   |-- engine/
|   |   |-- tools/
|   |   |   |-- __init__.py
|   |   |   |-- read_file.py
|   |   |   |-- shell_command.py
|   |   |   |-- web_search.py
|   |   |   \-- write_file.py
|   |   |-- __init__.py
|   |   |-- chat.py
|   |   |-- client.py
|   |   \-- tool_handler.py
|   |-- helper/
|   |   |-- __init__.py
|   |   |-- animation.py
|   |   |-- banner.py
|   |   |-- input.py
|   |   \-- print_md.py
|   |-- utils/
|   |   |-- commands/
|   |   |   |-- helper/
|   |   |   |   |-- __init__.py
|   |   |   |   \-- clipboard.py
|   |   |   |-- __init__.py
|   |   |   |-- clear.py
|   |   |   |-- copy.py
|   |   |   |-- exit.py
|   |   |   |-- help.py
|   |   |   \-- reset.py
|   |   |-- __init__.py
|   |   |-- command_handler.py
|   |   |-- console.py
|   |   |-- env.py
|   |   |-- history.py
|   |   |-- signals.py
|   |   \-- trust_folder.py
|   \-- index.py
|-- .gitignore
|-- LICENSE
|-- README.md
\-- pyproject.toml
END_STRUCTURE

FILE_START .gitignore 62d09d126b32
# Python
__pycache__/
*.py[cod]
*.pyo

# Distribution / packaging
*.egg-info/
*.egg
dist/
build/
wheels/
sdist/
.eggs/

# Virtual environments
.venv/
venv/
env/
ENV/

# Environment & secrets
.env
.env.*
!.env.example

# Test artifacts
src/test.json

# Editor & OS
.vscode/
.idea/
*.swp
*.swo
.DS_Store
Thumbs.db

FILE_END .gitignore 62d09d126b32

FILE_START LICENSE f91b147d31bd
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2026 Sapirrior

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

FILE_END LICENSE f91b147d31bd

FILE_START README.md d978424b90c4
# Code Edith

A lightweight, terminal-based AI coding agent. Connects to any OpenAI-compatible API endpoint — hosted providers or self-hosted models both work.

![License](https://img.shields.io/badge/license-Apache--2.0-orange) ![Python](https://img.shields.io/badge/python-3.10%2B-grey)

---

## Requirements

- Python 3.10 or higher
- An OpenAI-compatible API endpoint (e.g. OpenAI, Anthropic via proxy, Ollama, LM Studio)
- A `.env` file in your home directory (`~/.env`) — see [Configuration](#configuration)

---

## Installation

**From PyPI** (stable):

```bash
pip install code-edith
```

**From GitHub** (latest):

```bash
pip install git+https://github.com/sapirrior/code-edith
```

---

## Configuration

Create a `.env` file in your **home directory** (`~/.env`) with the following variables:

```env
EDITH_API_KEY=your_api_key
EDITH_BASE_URL=https://api.openai.com/v1
EDITH_MODEL_NAME=gpt-4o
```

| Variable | Description |
|---|---|
| `EDITH_API_KEY` | API key from your provider |
| `EDITH_BASE_URL` | Base URL of the OpenAI-compatible endpoint |
| `EDITH_MODEL_NAME` | Model identifier (e.g. `gpt-4o`, `claude-3-5-sonnet`, `llama3`) |

The config is read from `~/.env` at startup. Edith does not touch your project files during configuration.

---

## Usage

Navigate to the folder you want to work in, then launch Edith:

```bash
cd your-project
edith
```

**Trust prompt.** The first time you run Edith in a folder, it will ask whether you trust it. Answering `y` creates a `.edith/TRUST` marker file in the current directory. Subsequent launches in the same folder skip this step. If you answer `n`, Edith exits immediately without doing anything.

Once running, type your request at the `>> ` prompt and press Enter.

---

## Tools

Edith has four built-in tools it can invoke autonomously to complete tasks:

| Tool | What it does | Requires confirmation |
|---|---|---|
| `WebSearch` | Searches the web using DuckDuckGo | No |
| `ReadFile` | Reads a local file and returns its contents | No |
| `WriteFile` | Creates or overwrites a file with new content | **Yes** |
| `ShellCommand` | Runs a bash command in the current directory | **Yes** |

For `WriteFile` and `ShellCommand`, Edith will always pause and show you exactly what it is about to do before asking `Allow? (y/n)`. Typing anything other than `y` or `yes` cancels the action. The model is instructed not to retry a denied action.

---

## Commands

Type these at the prompt at any time:

| Command | Description |
|---|---|
| `/clear` | Clear the terminal and redraw the banner |
| `/copy` | Copy the last response to the clipboard |
| `/reset` | Wipe the conversation history (model forgets the session) |
| `/exit` | Exit Edith cleanly |
| `/help` | Show the command list |

---

## Reporting Issues

Open an issue on the [GitHub repository](https://github.com/sapirrior/code-edith/issues).

---

## License

Apache-2.0. See [LICENSE](LICENSE) for details.

FILE_END README.md d978424b90c4

FILE_START pyproject.toml 991da217a834
[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"

[project]
name = "code-edith"
dynamic = ["version"]
description = "AI Coding Assistant CLI"
readme = "README.md"
requires-python = ">=3.10"
license = { file = "LICENSE" }
authors = [
    { name = "Nolan Stark" }
]
keywords = ["cli", "ai", "assistant", "coding", "llm"]
dependencies = [
    "rich",
    "python-dotenv",
    "openai",
    "halo",
    "prompt_toolkit",
    "ddgs"
]

[project.scripts]
edith = "index:main"

[tool.setuptools]
package-dir = {"" = "src"}
py-modules = ["index"]

[tool.setuptools.dynamic]
version = { file = "src/config/version.txt" }

[tool.setuptools.packages.find]
where = ["src"]

[tool.setuptools.package-data]
"*" = ["*.txt", "*.json"]

FILE_END pyproject.toml 991da217a834

FILE_START .assets/edith-asi-art.txt 02ddfd464968
 ▛███▜
▛█████▜
 ▘▘ ▝▝
FILE_END .assets/edith-asi-art.txt 02ddfd464968

FILE_START .assets/edith-asi-unicode.txt dd1759322a25
\u0020\u259B\u2588\u2588\u2588\u259C
\u259B\u2588\u2588\u2588\u2588\u2588\u259C
\u0020\u2598\u2598\u0020\u259D\u259D
FILE_END .assets/edith-asi-unicode.txt dd1759322a25

FILE_START .github/workflows/python-publish.yml 88d3deb6ad29
# This workflow will upload a Python Package to PyPI when a release is created
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries

# This workflow uses actions that are not certified by GitHub.
# They are provided by a third-party and are governed by
# separate terms of service, privacy policy, and support
# documentation.

name: Upload Python Package

on:
  release:
    types: [published]

permissions:
  contents: read

jobs:
  release-build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.x"

      - name: Build release distributions
        run: |
          # NOTE: put your own distribution build steps here.
          python -m pip install build
          python -m build

      - name: Upload distributions
        uses: actions/upload-artifact@v4
        with:
          name: release-dists
          path: dist/

  pypi-publish:
    runs-on: ubuntu-latest
    needs:
      - release-build
    permissions:
      # IMPORTANT: this permission is mandatory for trusted publishing
      id-token: write

    # Dedicated environments with protections for publishing are strongly recommended.
    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
    environment:
      name: pypi
      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
      # url: https://pypi.org/p/YOURPROJECT
      #
      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
      # ALTERNATIVE: exactly, uncomment the following line instead:
      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}

    steps:
      - name: Retrieve release distributions
        uses: actions/download-artifact@v4
        with:
          name: release-dists
          path: dist/

      - name: Publish release distributions to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          packages-dir: dist/

FILE_END .github/workflows/python-publish.yml 88d3deb6ad29

FILE_START src/index.py 1477663d7182
import os
import time
import utils.signals
from utils.trust_folder import trust_folder
from utils.command_handler import handle_command
from utils.history import add_history, get_history, clear_history
from engine.chat import make_request
from engine.client import load_client
from helper.print_md import print_md
from helper.input import get_input
from helper.animation import animation
from utils.console import console
from helper.banner import show_banner
from utils.env import load_home_env, load_env

def load_all_envs_one_by_one():
    api_key = load_env("EDITH_API_KEY")
    base_url = load_env("EDITH_BASE_URL")
    model_name = load_env("EDITH_MODEL_NAME") or "gpt-4o"
    return api_key, base_url, model_name

def main():
    try:
        trust_folder()
        show_banner()
        api_key, base_url, model_name = load_all_envs_one_by_one()
        
        animation(True, "Connecting...")
        client = load_client(api_key, base_url)
        animation(False)

        while True:
            query = get_input().strip()
            if not query: continue
            if query.startswith("/"): handle_command(query); continue

            add_history({"role": "user", "content": query})
            animation(True, "Thinking...")

            response = make_request(client, get_history(), model_name)
            animation(False)

            print_md(response)
            add_history({"role": "assistant", "content": response})
            console.print("\n")

    except EOFError:
        pass
    except KeyboardInterrupt:
        pass
    except Exception as e:
        animation(False)
        console.print(f"\n[orangex]Engine Error:[/orangex] [greyx]{str(e)}[/greyx]")
    finally:
        animation(False)
        console.print("[greyx]Goodbye![/greyx]")
        exit(0)
FILE_END src/index.py 1477663d7182

FILE_START src/config/system.txt 98ee6d2c87d0
<identity>
The current year is 2026, You are Edith ("code-edith"), a CLI coding agent built by Nolan Stark.
</identity>

<personality>
Concise. Direct. No fluff.
- Use short responses for non-code tasks.
- Be polite and helpful.
- Reply with code or commands by default — skip explanations unless asked.
- No greetings, no filler, no unsolicited suggestions.
- If a task is ambiguous, ask short clarifying questions before execution.
</personality>

<tool_usage>
- You are equipped with 4 core tools: WebSearch, ReadFile, WriteFile, and ShellCommand.
- File System: Use `ShellCommand` for ALL directory and file management (e.g., `mkdir`, `rm`, `mv`, `cp`, `ls`, `find`).
- Execution: Use `ShellCommand` to run scripts, compile code, or install packages (e.g., `python main.py`, `npm install`).
- Code Generation: Use `WriteFile` to create or modify the actual contents of scripts and text files.
- Never use `ShellCommand` to echo large amounts of code into a file; always use `WriteFile` for that.
- If the user denies a tool execution, stop immediately and output a short acknowledgment. Do not attempt workarounds.
</tool_usage>

<safety>
Refuse tasks that are destructive, illegal, or malicious — this includes but is not limited to: network attacks, credential theft, removing system packages, bypassing auth, or harming data outside the current project workspace.
One-line refusal, no elaboration.
</safety>

<format>
- Always provide complete, valid codes unless asked for a snippet.
- Always specify the language in code blocks for syntax highlighting.
- Code blocks for all code/commands.
- No markdown prose unless the user asks for an explanation.
- Prefer minimal, readable output.
</format>

FILE_END src/config/system.txt 98ee6d2c87d0

FILE_START src/config/tools.json e70ab465023f
[
  {
    "type": "function",
    "function": {
      "name": "WebSearch",
      "description": "Executes an internet search to retrieve real-time data or external technical documentation.",
      "parameters": {
        "type": "object",
        "properties": {
          "query": { "type": "string", "description": "The search keywords." }
        },
        "required": ["query"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "ReadFile",
      "description": "Reads and returns the exact text content of a specified local file.",
      "parameters": {
        "type": "object",
        "properties": {
          "path": { "type": "string", "description": "The path to the file." }
        },
        "required": ["path"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "WriteFile",
      "description": "Writes or overwrites text content to a specified local file.",
      "parameters": {
        "type": "object",
        "properties": {
          "path": { "type": "string", "description": "The path to the file." },
          "content": { "type": "string", "description": "The exact text or code to write." }
        },
        "required": ["path", "content"]
      }
    }
  },
  {
    "type": "function",
    "function": {
      "name": "ShellCommand",
      "description": "Executes a bash shell command in the local terminal. Use this for file manipulation (mkdir, rm, cp, mv), running scripts (python main.py), or installing packages. DO NOT use for destructive system-wide commands.",
      "parameters": {
        "type": "object",
        "properties": {
          "command": { "type": "string", "description": "The exact bash command to execute." }
        },
        "required": ["command"]
      }
    }
  }
]

FILE_END src/config/tools.json e70ab465023f

FILE_START src/config/version.txt 1af52911593c
26.0.7
FILE_END src/config/version.txt 1af52911593c

FILE_START src/engine/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/engine/__init__.py empty000000

FILE_START src/engine/chat.py dc0c17698ba0
import json
from pathlib import Path
from engine.tool_handler import handle_tool_call
from utils.history import add_history
from helper.animation import animation
from helper.print_md import print_md

def make_request(client, msgs, model):
    src_dir = Path(__file__).resolve().parent.parent
    system_content = (src_dir / "config" / "system.txt").read_text().strip()

    with open(src_dir / "config" / "tools.json", 'r') as f:
        tools_schema = json.load(f)

    messages = [{"role": "system", "content": system_content}] + msgs

    max_iter = 10
    for _ in range(max_iter):
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            tools=tools_schema,
            tool_choice="auto"
        )

        msg = response.choices[0].message

        if not msg.tool_calls:
            return msg.content or ""

        if msg.content:
            animation(False)
            print_md(msg.content)

        assistant_msg = msg.model_dump()
        assistant_msg["content"] = assistant_msg.get("content") or ""

        messages.append(assistant_msg)
        add_history(assistant_msg)

        tool_results = []
        for tool_call in msg.tool_calls:
            name = tool_call.function.name
            try:
                args = json.loads(tool_call.function.arguments)
            except (json.JSONDecodeError, TypeError):
                args = {}

            result = handle_tool_call(name, args)

            tool_msg = {
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": name,
                "content": str(result)
            }
            tool_results.append(tool_msg)
            add_history(tool_msg)

        messages.extend(tool_results)
        animation(True, "Reasoning...")

    return ""
FILE_END src/engine/chat.py dc0c17698ba0

FILE_START src/engine/client.py b91fdf4a9b95
from openai import OpenAI
from utils.console import console

def load_client(key, url):
	try:
		client = OpenAI(api_key=key,base_url=url)
		client.models.list() # do a tiny test without losing tokens
		return client
	except Exception as e:
		console.print("[Error] connecting with server.")
		exit(1)
FILE_END src/engine/client.py b91fdf4a9b95

FILE_START src/engine/tool_handler.py b6795d4afdb2
import shutil
import sys
from rich.markup import escape
from rich.panel import Panel
from rich.syntax import Syntax
from rich.text import Text
from engine.tools import web_search, read_file, write_file, shell_command
from helper.animation import animation
from utils.console import console

_ORANGE = "\033[38;2;217;119;87m"
_GREY   = "\033[38;2;153;153;153m"
_RESET  = "\033[0m"

TOOL_MAP = {
    "WebSearch":    web_search.execute,
    "ReadFile":     read_file.execute,
    "WriteFile":    write_file.execute,
    "ShellCommand": shell_command.execute,
}

DESTRUCTIVE_TOOLS = {"WriteFile", "ShellCommand"}

TOOL_LABELS = {
    "WebSearch":    "Search",
    "ReadFile":     "Read",
    "WriteFile":    "Write",
    "ShellCommand": "Shell",
}


def _term_width() -> int:
    return shutil.get_terminal_size().columns - 2


def _get_ext(target: str) -> str:
    if "." in target:
        ext = target.rsplit(".", 1)[-1].lower()
        if len(ext) <= 6 and "/" not in ext and "\\" not in ext:
            return ext
    return "text"


TITLED_TOOLS = {"ReadFile", "WriteFile"}

def _make_title(name: str, target: str) -> str:
    label = TOOL_LABELS.get(name, name)
    if name in TITLED_TOOLS:
        safe_target = escape(target)
        return f"[orangex]{label}[/orangex] [greyx]·[/greyx] [greyx]{safe_target}[/greyx]"
    return f"[orangex]{label}[/orangex]"


def _print_panel(name: str, target: str, content: str | None) -> None:
    if content:
        ext  = _get_ext(target)
        body = Syntax(content, ext, theme="monokai", word_wrap=True, background_color="default")
    else:
        body = Text(target, style="greyx")

    console.print(
        Panel(
            body,
            title=_make_title(name, target),
            title_align="left",
            border_style="greyx",
            padding=(0, 2),
            expand=False,
            width=_term_width(),
        )
    )


def _confirm_prompt() -> str:
    sys.stdout.write(f"   {_GREY}Allow?{_RESET} {_ORANGE}(y/n):{_RESET} ")
    sys.stdout.flush()
    return input()


def handle_tool_call(name: str, args: dict) -> str:
    if not isinstance(args, dict):
        return "Error: Tool received invalid arguments."

    func = TOOL_MAP.get(name)
    if not func:
        return f"Error: Tool '{name}' not found."

    target  = args.get("command") or args.get("path") or args.get("query") or "..."
    content = args.get("content")

    animation(False)
    console.print()
    _print_panel(name, target, content)

    if name in DESTRUCTIVE_TOOLS:
        try:
            raw = _confirm_prompt()
            console.print()

            if raw.strip().lower() not in ("y", "yes"):
                console.print(f"   [greyx]Denied.[/greyx]\n")
                animation(True, "Thinking...")
                return "Tool execution denied by user. Do not retry this action."

        except (KeyboardInterrupt, EOFError):
            console.print()
            console.print(f"   [greyx]Aborted.[/greyx]\n")
            animation(True, "Thinking...")
            return "Tool execution aborted by user. Do not retry this action."

    try:
        animation(True, f"Running {name}...")
        return str(func(**args))
    except Exception as e:
        return f"Error executing {name}: {str(e)}"
    finally:
        animation(True, "Thinking...")
FILE_END src/engine/tool_handler.py b6795d4afdb2

FILE_START src/engine/tools/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/engine/tools/__init__.py empty000000

FILE_START src/engine/tools/read_file.py e8bdca656734
from pathlib import Path

def execute(path: str) -> str:
    p = Path(path).expanduser().resolve()
    if not p.exists(): return f"Error: File not found: {path}"
    if not p.is_file(): return f"Error: Not a file: {path}"
    try:
        return p.read_text(errors="replace")
    except Exception as e:
        return f"Error reading file: {e}"

FILE_END src/engine/tools/read_file.py e8bdca656734

FILE_START src/engine/tools/shell_command.py b20ccc5a929a
import subprocess

def execute(command: str) -> str:
    try:
        result = subprocess.run(
            command,
            shell=True,
            capture_output=True,
            text=True,
            timeout=60
        )
        stdout = result.stdout.strip()
        stderr = result.stderr.strip()
        
        output = []
        if stdout:
            output.append(stdout)
        if stderr:
            output.append(f"Error/Warning: {stderr}")
        
        if not output:
            return f"Command '{command}' executed successfully with no output."
        return "\n".join(output)
    except Exception as e:
        return f"Execution Error: {str(e)}"

FILE_END src/engine/tools/shell_command.py b20ccc5a929a

FILE_START src/engine/tools/web_search.py 38d5265cb269
from ddgs import DDGS

def execute(query: str) -> str:
    try:
        results = []
        with DDGS() as ddgs:
            for r in ddgs.text(query, max_results=5):
                results.append(f"Title: {r.get('title')}\nURL: {r.get('href')}\nSnippet: {r.get('body')}")
        return "\n---\n".join(results) if results else "No results found."
    except Exception as e:
        return f"Search error: {e}"

FILE_END src/engine/tools/web_search.py 38d5265cb269

FILE_START src/engine/tools/write_file.py c705452a2d69
from pathlib import Path

def execute(path: str, content: str) -> str:
    p = Path(path).expanduser().resolve()
    try:
        p.parent.mkdir(parents=True, exist_ok=True)
        p.write_text(content)
        return f"Successfully wrote {len(content)} characters to {path}"
    except Exception as e:
        return f"Error writing file: {e}"

FILE_END src/engine/tools/write_file.py c705452a2d69

FILE_START src/helper/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/helper/__init__.py empty000000

FILE_START src/helper/animation.py ba8d5a06dffa
import sys
from halo import Halo

# Brand Colors
ORANGEX = "\033[38;2;217;119;87m"
GREYX = "\033[38;2;153;153;153m"
RESET = "\033[0m"

# Global instance initialization
_sp = Halo(
    spinner={
        "interval": 200,
        "frames": [f"{ORANGEX}{c}{RESET}" for c in "✲✱❖"]
    }
)

def animation(run: bool, text="Reasoning..."):
    """
    run: True to start/update, False to stop.
    text: The message to display in Greyx.
    """
    if run:
        # Update text dynamically (works even if already spinning)
        _sp.text = f"{GREYX}{text}{RESET}"
        _sp.start()
    else:
        # Stop the Halo spinner
        _sp.stop()
        
        # The Fix: Move cursor to start (\r) and erase the entire line (\033[K)
        # This gives print_md a completely blank canvas.
        sys.stdout.write("\r\033[K")
        sys.stdout.flush()
FILE_END src/helper/animation.py ba8d5a06dffa

FILE_START src/helper/banner.py 2799d61f7a6a
import os
from rich.panel import Panel
from rich.align import Align
from utils.console import console

folder_name = os.path.basename(os.getcwd()) # Reads current folder name
content = f"""
[resetx]Welcome to Code Edith![/resetx]
[orangex] ▛███▜[/orangex]
[orangex]▛█████▜[/orangex]
[orangex] ▘▘ ▝▝[/orangex]
[greyx]Folder: {folder_name}[/greyx]
[greyx]Tip: /help for information[/greyx]
"""

def show_banner():
	try: # try/except block
		console.clear()
		banner_panel = Panel( # Initializes the panel
			Align.left(content.strip()),
			border_style = "orangex",
			width = console.size.width - 2, # terminal-size - 2
			title_align = "left",
			title = "[bold orangex]Code Edith[/bold orangex]",
			padding = (1, 1) # adds padding
			)
		console.print(banner_panel)
	except Exception as e: # Error handle
		console.print("[Error] Loading banner.") # Error message
		exit(1)
FILE_END src/helper/banner.py 2799d61f7a6a

FILE_START src/helper/input.py 67a53d58d6e7
from prompt_toolkit import prompt
from prompt_toolkit.styles import Style

# Minimalist Style: Just Orangex for the symbol
style = Style.from_dict({
    'symbol': '#d97757',
    '': '#a0a0a0'
})

def get_input():
    # The symbol is 3 characters: ">", ">", " "
    message = [('class:symbol', '>> ')]

    # Continuation creates the indent for wrapped lines (3 spaces)
    def continuation(width, line_number, is_soft_wrap):
        return [('class:symbol', '   ')]

    return prompt(
        message,
        style=style,
        prompt_continuation=continuation,
        wrap_lines=True
    ).strip()
FILE_END src/helper/input.py 67a53d58d6e7

FILE_START src/helper/print_md.py 6997f5225ee4
from utils.console import console
from rich.markdown import Markdown
from rich.padding import Padding

# Brand Colors
ORANGEX = "\033[38;2;217;119;87m"
GREYX = "\033[38;2;153;153;153m"
RESET = "\033[0m"

def print_md(text):
	try:
		txt_md = Markdown(text.strip())
		padded_md = Padding(txt_md, (0, 2, 0, 3))
		console.print(padded_md)
	except Exception as e:
		console.print("[Error] prompt request.")
		exit(1)
FILE_END src/helper/print_md.py 6997f5225ee4

FILE_START src/utils/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/utils/__init__.py empty000000

FILE_START src/utils/command_handler.py a563988c2b5d
from utils.console import console
from utils.commands.clear import cmd_clear
from utils.commands.copy import cmd_copy
from utils.commands.reset import cmd_reset
from utils.commands.exit import cmd_exit
from utils.commands.help import cmd_help

def handle_command(query):
	parts = query[1:].lower().split()
	cmd = parts[0] if parts else ""
	
	if cmd == "clear":
		cmd_clear()
	elif cmd == "copy":
		cmd_copy()
	elif cmd == "reset":
		cmd_reset()
	elif cmd == "exit":
		cmd_exit()
	elif cmd == "help":
		cmd_help()
	else:
		console.print(f"[orangex]Unknown command:[/orangex][greyx]/{cmd}[/greyx]\n")
FILE_END src/utils/command_handler.py a563988c2b5d

FILE_START src/utils/console.py 0b5b2b8b9710
import shutil
from rich.console import Console
from rich.theme import Theme
from rich.markdown import Markdown

theme_custom = Theme({ # Adds custom themes
    "orangex": "rgb(217,119,87)", # orange color
    "greyx": "rgb(128,128,128)", # grey color
    "resetx": "default" # white color
})

try:
	console = Console(theme=theme_custom) # installs console with custom themes
	console.width = shutil.get_terminal_size().columns - 2 # sets width
except Exception as e:
	console.print("[Error] Starting the console.")
	exit(1) # exits if error occurs
FILE_END src/utils/console.py 0b5b2b8b9710

FILE_START src/utils/env.py f1903712faa5
import os
from pathlib import Path
from dotenv import load_dotenv
from utils.console import console

def load_home_env():
	try:
		home_path = Path.home() / ".env"
		
		if home_path.exists():
			load_dotenv(dotenv_path=home_path)
	except Exception as e:
		console.print("[Error] Loading environmental variables.")
		exit(1)

load_home_env()

def load_env(var):
		val = os.environ.get(var)
		if val is None:
			console.print(f"[Error] Loading {var} environmental variable.")
			exit(1)
		else:
			return val
FILE_END src/utils/env.py f1903712faa5

FILE_START src/utils/history.py 6991cdeada74
class ChatHistory:
    """Manages the conversation history for the AI model."""
    def __init__(self, max_length=None):
        self._history = []
        self.max_length = max_length

    def add(self, message):
        if not isinstance(message, dict):
            raise ValueError("Message must be a dictionary.")
        self._history.append(message)
        
        if self.max_length and len(self._history) > self.max_length:
            self._history.pop(0)

    def get(self):
        return list(self._history)

    def clear(self):
        self._history.clear()

    def __len__(self):
        return len(self._history)


_manager = ChatHistory()

def add_history(message):
    _manager.add(message)

def get_history():
    return _manager.get()

def clear_history():
    _manager.clear()

FILE_END src/utils/history.py 6991cdeada74

FILE_START src/utils/signals.py ebf63381cdbb
import signal

_UNCATCHABLE = {signal.SIGKILL, signal.SIGSTOP}

for sig in signal.valid_signals() - _UNCATCHABLE:
    try:
        signal.signal(sig, signal.SIG_IGN)
    except (ValueError, OSError, RuntimeError):
        continue
FILE_END src/utils/signals.py ebf63381cdbb

FILE_START src/utils/trust_folder.py fd431b12e3b7
from pathlib import Path
from utils.console import console

def trust_folder():
	
	trust_dir = Path(".edith")
	trust_file = trust_dir / "TRUST"
	
	if trust_file.exists():
		return True
	else:
		console.clear()
		console.print(f"[orangex]Folder:[/orangex] [greyx]{Path.cwd().name}.[/greyx]")
		console.print("[orangex]This folder is not trusted.[/orangex]")
		
		choice = console.input("Do you trust this folder (y/n): ").strip().lower()
		
		if choice != 'y':
			exit(0)
		else:
			try:
				trust_dir.mkdir(parents=True, exist_ok=True)
				trust_file.touch()
				console.print("[orangex]Starting...[/orangex]")
				return True
			except Exception as e:
				console.print("[Error] Checking Trust Folder.")
				exit(1)
FILE_END src/utils/trust_folder.py fd431b12e3b7

FILE_START src/utils/commands/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/utils/commands/__init__.py empty000000

FILE_START src/utils/commands/clear.py 86fb1d090fe8
import shutil
from utils.console import console
from helper.banner import show_banner

def cmd_clear():
	console.width = shutil.get_terminal_size().columns - 2
	show_banner()
FILE_END src/utils/commands/clear.py 86fb1d090fe8

FILE_START src/utils/commands/copy.py 577b2c58088a
from utils.history import get_history
from utils.console import console
from utils.commands.helper.clipboard import copy

def cmd_copy():
    history = get_history()
    
    # FIX: Use without a "content" key
    assistant_msgs = [m.get("content", "") for m in history if m.get("role") == "assistant"]
    
    if assistant_msgs and assistant_msgs[-1]:
        if copy(str(assistant_msgs[-1])):
            console.print("[orangex]Latest response copied to clipboard![/orangex]\n")
        else:
            console.print("[orangex]No clipboard tool found\n[/orangex]")
    else:
        console.print("[orangex]Nothing to copy yet.[/orangex]\n")

FILE_END src/utils/commands/copy.py 577b2c58088a

FILE_START src/utils/commands/exit.py 3007cd6d1d85
import sys

def cmd_exit():
	sys.exit(0)
FILE_END src/utils/commands/exit.py 3007cd6d1d85

FILE_START src/utils/commands/help.py b02f5a2c1618
from utils.console import console

def cmd_help():
	console.print("[orangex]Edith Commands:[/orangex]")
	console.print("[greyx]/clear[/greyx] - Clear the terminal screen")
	console.print("[greyx]/copy [/greyx] - Copy last response to clipboard")
	console.print("[greyx]/reset[/greyx] - Wipe conversation history")
	console.print("[greyx]/exit [/greyx] - Stop Edith safely")
	console.print("[greyx]/help [/greyx] - Show this menu\n")
FILE_END src/utils/commands/help.py b02f5a2c1618

FILE_START src/utils/commands/reset.py e6492a397a7a
from utils.console import console
from utils.history import clear_history

def cmd_reset():
	clear_history()
	console.print("[orangex]History reset. Memory wiped.[/orangex]\n")
FILE_END src/utils/commands/reset.py e6492a397a7a

FILE_START src/utils/commands/helper/__init__.py empty000000
EMPTY_CONTENT
FILE_END src/utils/commands/helper/__init__.py empty000000

FILE_START src/utils/commands/helper/clipboard.py 7cd4909298a8
import subprocess
import sys

def copy(text):
    """Copy text to clipboard. Returns True on success, False otherwise."""
    if not text:
        return False
    
    # Platform-specific and fallback clipboard tools
    cmds = {
        'darwin': [['pbcopy']],
        'win32': [['clip']],
    }.get(sys.platform, [['xclip', '-selection', 'clipboard'], ['wl-copy'], ['termux-clipboard-set']])
    
    content = str(text).encode('utf-8')
    
    for cmd in cmds:
        try:
            subprocess.run(cmd, input=content, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL, check=True, timeout=5)
            return True
        except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
            continue
    
    return False

FILE_END src/utils/commands/helper/clipboard.py 7cd4909298a8