akitallm 0.1.0__tar.gz → 0.1.1__tar.gz

akitallm-0.1.1/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 0.1.1
+Summary: AkitaLLM: An open-source local-first AI system for programming.
+Author: KerubinDev
+License: MIT
+Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
+Keywords: ai,cli,programming,local-first,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: litellm
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: pytest-mock
+Requires-Dist: gitpython
+Requires-Dist: tomli-w
+Requires-Dist: tomli
+Dynamic: license-file
+
+```text
+     _      _   _ _        _     _     __  __ 
+    / \    | | _(_) |_ __ _| |   | |   |  \/  |
+   / _ \   | |/ / | __/ _` | |   | |   | |\/| |
+  / ___ \  |   <| | || (_| | |___| |___| |  | |
+ /_/   \_\ |_|\_\_|\__\__,_|_____|_____|_|  |_|
+                                               
+```
+
+# AkitaLLM
+### A deterministic, local-first AI orchestrator for software engineers.
+
+---
+
+## What is AkitaLLM?
+
+AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
+
+Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
+
+---
+
+## Why AkitaLLM exists
+
+Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
+- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
+- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
+- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
+
+AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
+
+---
+
+## The Engineering Difference
+
+| Feature | Generic AI Tools | AkitaLLM |
+| :--- | :--- | :--- |
+| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
+| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
+| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
+| **Validation** | Post-facto manual review | Automated local test execution |
+| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
+
+---
+
+## Core Principles
+
+1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
+2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
+3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
+4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
+
+---
+
+## Key Features
+
+- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
+- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
+- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
+- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
+- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
+
+---
+
+## Installation
+
+AkitaLLM is available on PyPI. You can install it directly using pip:
+
+```bash
+pip install akitallm
+```
+
+---
+
+## Usage
+
+### 1. Project Initialization
+Run any command to trigger the initial configuration and onboarding.
+```bash
+akita review .
+```
+
+### 2. Strategic Code Review
+Analyze a directory for potential architectural risks and bugs.
+```bash
+akita review src/
+```
+
+### 3. Implementation Planning
+Generate a technical plan for a specific goal.
+```bash
+akita plan "Implement JWT authentication with Redis-based session storage"
+```
+
+### 4. Code Problem Solving
+Generate a diff to solve a precise issue or refactor a module.
+```bash
+akita solve "Improve error handling in the reasoning engine to prevent silent failures"
+```
+
+---
+
+## Contributing
+
+We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
+
+Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
+
+---
+
+*“Understanding the internals is the first step to excellence.”*

akitallm-0.1.1/README.md

@@ -0,0 +1,111 @@
+```text
+     _      _   _ _        _     _     __  __ 
+    / \    | | _(_) |_ __ _| |   | |   |  \/  |
+   / _ \   | |/ / | __/ _` | |   | |   | |\/| |
+  / ___ \  |   <| | || (_| | |___| |___| |  | |
+ /_/   \_\ |_|\_\_|\__\__,_|_____|_____|_|  |_|
+                                               
+```
+
+# AkitaLLM
+### A deterministic, local-first AI orchestrator for software engineers.
+
+---
+
+## What is AkitaLLM?
+
+AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
+
+Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
+
+---
+
+## Why AkitaLLM exists
+
+Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
+- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
+- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
+- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
+
+AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
+
+---
+
+## The Engineering Difference
+
+| Feature | Generic AI Tools | AkitaLLM |
+| :--- | :--- | :--- |
+| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
+| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
+| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
+| **Validation** | Post-facto manual review | Automated local test execution |
+| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
+
+---
+
+## Core Principles
+
+1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
+2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
+3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
+4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
+
+---
+
+## Key Features
+
+- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
+- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
+- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
+- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
+- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
+
+---
+
+## Installation
+
+AkitaLLM is available on PyPI. You can install it directly using pip:
+
+```bash
+pip install akitallm
+```
+
+---
+
+## Usage
+
+### 1. Project Initialization
+Run any command to trigger the initial configuration and onboarding.
+```bash
+akita review .
+```
+
+### 2. Strategic Code Review
+Analyze a directory for potential architectural risks and bugs.
+```bash
+akita review src/
+```
+
+### 3. Implementation Planning
+Generate a technical plan for a specific goal.
+```bash
+akita plan "Implement JWT authentication with Redis-based session storage"
+```
+
+### 4. Code Problem Solving
+Generate a diff to solve a precise issue or refactor a module.
+```bash
+akita solve "Improve error handling in the reasoning engine to prevent silent failures"
+```
+
+---
+
+## Contributing
+
+We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
+
+Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
+
+---
+
+*“Understanding the internals is the first step to excellence.”*

akitallm-0.1.1/akita/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

akitallm-0.1.1/akitallm.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: akitallm
+Version: 0.1.1
+Summary: AkitaLLM: An open-source local-first AI system for programming.
+Author: KerubinDev
+License: MIT
+Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
+Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
+Keywords: ai,cli,programming,local-first,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]
+Requires-Dist: litellm
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: python-dotenv
+Requires-Dist: pytest
+Requires-Dist: pytest-mock
+Requires-Dist: gitpython
+Requires-Dist: tomli-w
+Requires-Dist: tomli
+Dynamic: license-file
+
+```text
+     _      _   _ _        _     _     __  __ 
+    / \    | | _(_) |_ __ _| |   | |   |  \/  |
+   / _ \   | |/ / | __/ _` | |   | |   | |\/| |
+  / ___ \  |   <| | || (_| | |___| |___| |  | |
+ /_/   \_\ |_|\_\_|\__\__,_|_____|_____|_|  |_|
+                                               
+```
+
+# AkitaLLM
+### A deterministic, local-first AI orchestrator for software engineers.
+
+---
+
+## What is AkitaLLM?
+
+AkitaLLM is not another "AI wrapper." It is a command-line utility designed for developers who value engineering rigor over generative "magic." It treats Large Language Models as non-deterministic execution engines that must be constrained within a strict, auditable pipeline: **Analyze → Plan → Execute → Validate**.
+
+Built as a local-first tool, it provides you with an AI-augmented workflow that respects your project's context, follows security best practices, and prioritizes structured output over conversational noise.
+
+---
+
+## Why AkitaLLM exists
+
+Most current AI tools (ChatGPT, Copilot, Cursor) operate in a "black-box" conversational mode. They are excellent at text generation but often fail at **software engineering**, which requires:
+- **Project-Level Context**: Understanding how a change in `utils.py` affects `main.py`.
+- **Previsibilty**: Knowing exactly what the AI intends to do before it modifies a single byte.
+- **Verification**: Automatically ensuring that proposed changes don't break existing logic.
+
+AkitaLLM was built to bridge this gap, treating AI as a component of a larger, human-controlled engineering process.
+
+---
+
+## The Engineering Difference
+
+| Feature | Generic AI Tools | AkitaLLM |
+| :--- | :--- | :--- |
+| **Logic** | Conversational / Guesswork | Analyze → Plan → Execute → Validate |
+| **Control** | Autocomplete / Chat | Explicit technical plans & reviewable Diffs |
+| **Security** | Cloud-heavy | Local-first, respects `.gitignore` and `.env` |
+| **Validation** | Post-facto manual review | Automated local test execution |
+| **Philosophy** | "It just works" (Hype) | "Understand the internals" (Engineering) |
+
+---
+
+## Core Principles
+
+1. **Local-First**: Your code remains on your machine. AkitaLLM orchestrates local models (via Ollama) or remote APIs (via LiteLLM) through encrypted, controlled channels.
+2. **Contextual Awareness**: It uses recursive file scanning and structure analysis to build a high-fidelity map of your project before making suggestions.
+3. **No Magic**: No hidden prompts, no mysterious "thinking" phases. All actions are logged, auditable, and based on standard engineering patterns.
+4. **Tool-Driven**: AI is a user of tools (linters, test runners, AST parsers), not a replacement for them.
+
+---
+
+## Key Features
+
+- **Structural Code Review**: Detailed analysis of bugs, style, performance, and security risks with prioritized severity levels.
+- **Technical Planning**: Generation of step-by-step implementation plans in Markdown for complex feature requests.
+- **Actionable Diffs**: Proposed changes are generated as standard Unified Diffs for human review before application.
+- **Environment Isolation**: Supports `.env` and local configuration storage (`~/.akita/`) to keep secrets safe.
+- **Model Agnostic**: Seamlessly switch between GPT-4o, Claude 3.5, Llama 3, and more.
+
+---
+
+## Installation
+
+AkitaLLM is available on PyPI. You can install it directly using pip:
+
+```bash
+pip install akitallm
+```
+
+---
+
+## Usage
+
+### 1. Project Initialization
+Run any command to trigger the initial configuration and onboarding.
+```bash
+akita review .
+```
+
+### 2. Strategic Code Review
+Analyze a directory for potential architectural risks and bugs.
+```bash
+akita review src/
+```
+
+### 3. Implementation Planning
+Generate a technical plan for a specific goal.
+```bash
+akita plan "Implement JWT authentication with Redis-based session storage"
+```
+
+### 4. Code Problem Solving
+Generate a diff to solve a precise issue or refactor a module.
+```bash
+akita solve "Improve error handling in the reasoning engine to prevent silent failures"
+```
+
+---
+
+## Contributing
+
+We are looking for engineers, not just coders. If you value robust abstractions, clean code, and predictable systems, your contribution is welcome.
+
+Review our [CONTRIBUTING.md](CONTRIBUTING.md) to understand our engineering standards and PR workflow. High-quality PRs with test coverage are prioritized.
+
+---
+
+*“Understanding the internals is the first step to excellence.”*

{akitallm-0.1.0 → akitallm-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "akitallm"
-version = "0.1.0"
+version = "0.1.1"
 description = "AkitaLLM: An open-source local-first AI system for programming."
 authors = [{ name = "KerubinDev" }]
 readme = "README.md"

akitallm-0.1.0/PKG-INFO

@@ -1,111 +0,0 @@
-Metadata-Version: 2.4
-Name: akitallm
-Version: 0.1.0
-Summary: AkitaLLM: An open-source local-first AI system for programming.
-Author: KerubinDev
-License: MIT
-Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
-Keywords: ai,cli,programming,local-first,llm
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typer[all]
-Requires-Dist: litellm
-Requires-Dist: pydantic
-Requires-Dist: rich
-Requires-Dist: python-dotenv
-Requires-Dist: pytest
-Requires-Dist: pytest-mock
-Requires-Dist: gitpython
-Requires-Dist: tomli-w
-Requires-Dist: tomli
-Dynamic: license-file
-
-# AkitaLLM
-
-**AkitaLLM** is an open-source, local-first AI system designed for professional programming. It orchestrates existing LLMs (Ollama, OpenAI, Anthropic, etc.) through a strict **Plan-Execute-Validate** pipeline to ensure code quality and reliability.
-
-## What is AkitaLLM?
-
-AkitaLLM is a command-line interface (CLI) that helps you manage codebases with AI. Unlike simple chat interfaces, AkitaLLM:
-- **Analyzes** your project structure and file content before proposing changes.
-- **Plans** technical steps using a structured reasoning engine.
-- **Solves** problems by generating Unified Diffs that you can review.
-- **Validates** changes using local testing frameworks like `pytest`.
-
-## Key Features
-
-- **Local-First**: Developed with privacy and security in mind.
-- **Model Agnostic**: Use any model supported by LiteLLM (GPT-4o, Claude, Llama 3 via Ollama).
-- **Structured Output**: Code reviews and plans are presented in professional terminal tables and Markdown.
-- **Security by Default**: Diffs are only applied with your explicit confirmation.
-- **Support for .env**: Manage your API keys safely.
-
-## Installation
-
-```bash
-# Clone the repository
-git clone https://github.com/Your-Name/AkitaLLM.git
-cd AkitaLLM
-
-# Install in editable mode
-pip install -e .
-```
-
-## Usage
-
-### 1. Initial Setup
-The first time you run a command, AkitaLLM will guide you through choosing a model.
-```bash
-akita review .
-```
-
-### 2. Code Review
-Analyze files or directories for bugs, style, and security risks.
-```bash
-akita review src/
-```
-
-### 3. Solution Planning
-Generate a technical plan for a complex task.
-```bash
-akita plan "Refactor the authentication module to support JWT"
-```
-
-### 4. Problem Solving
-Generate a diff to solve a specific issue.
-```bash
-akita solve "Add error handling to the ReasoningEngine class"
-```
-
-## Configuration
-
-AkitaLLM stores its configuration in `~/.akita/config.toml`. You can manage it via:
-```bash
-# View and change model settings
-akita config model
-
-# Reset all settings
-akita config model --reset
-```
-
-## Contributing
-
-We welcome contributions! Please check [CONTRIBUTING.md](CONTRIBUTING.md) to understand our workflow and standards.
-
-## License
-
-This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details.
-
----
-
-*“Understanding the internals is the first step to excellence.”*

akitallm-0.1.0/README.md

@@ -1,79 +0,0 @@
-# AkitaLLM
-
-**AkitaLLM** is an open-source, local-first AI system designed for professional programming. It orchestrates existing LLMs (Ollama, OpenAI, Anthropic, etc.) through a strict **Plan-Execute-Validate** pipeline to ensure code quality and reliability.
-
-## What is AkitaLLM?
-
-AkitaLLM is a command-line interface (CLI) that helps you manage codebases with AI. Unlike simple chat interfaces, AkitaLLM:
-- **Analyzes** your project structure and file content before proposing changes.
-- **Plans** technical steps using a structured reasoning engine.
-- **Solves** problems by generating Unified Diffs that you can review.
-- **Validates** changes using local testing frameworks like `pytest`.
-
-## Key Features
-
-- **Local-First**: Developed with privacy and security in mind.
-- **Model Agnostic**: Use any model supported by LiteLLM (GPT-4o, Claude, Llama 3 via Ollama).
-- **Structured Output**: Code reviews and plans are presented in professional terminal tables and Markdown.
-- **Security by Default**: Diffs are only applied with your explicit confirmation.
-- **Support for .env**: Manage your API keys safely.
-
-## Installation
-
-```bash
-# Clone the repository
-git clone https://github.com/Your-Name/AkitaLLM.git
-cd AkitaLLM
-
-# Install in editable mode
-pip install -e .
-```
-
-## Usage
-
-### 1. Initial Setup
-The first time you run a command, AkitaLLM will guide you through choosing a model.
-```bash
-akita review .
-```
-
-### 2. Code Review
-Analyze files or directories for bugs, style, and security risks.
-```bash
-akita review src/
-```
-
-### 3. Solution Planning
-Generate a technical plan for a complex task.
-```bash
-akita plan "Refactor the authentication module to support JWT"
-```
-
-### 4. Problem Solving
-Generate a diff to solve a specific issue.
-```bash
-akita solve "Add error handling to the ReasoningEngine class"
-```
-
-## Configuration
-
-AkitaLLM stores its configuration in `~/.akita/config.toml`. You can manage it via:
-```bash
-# View and change model settings
-akita config model
-
-# Reset all settings
-akita config model --reset
-```
-
-## Contributing
-
-We welcome contributions! Please check [CONTRIBUTING.md](CONTRIBUTING.md) to understand our workflow and standards.
-
-## License
-
-This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details.
-
----
-
-*“Understanding the internals is the first step to excellence.”*

akitallm-0.1.0/akita/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

akitallm-0.1.0/akitallm.egg-info/PKG-INFO

@@ -1,111 +0,0 @@
-Metadata-Version: 2.4
-Name: akitallm
-Version: 0.1.0
-Summary: AkitaLLM: An open-source local-first AI system for programming.
-Author: KerubinDev
-License: MIT
-Project-URL: Homepage, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Repository, https://github.com/KerubinDev/AkitaLLM
-Project-URL: Issues, https://github.com/KerubinDev/AkitaLLM/issues
-Keywords: ai,cli,programming,local-first,llm
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: typer[all]
-Requires-Dist: litellm
-Requires-Dist: pydantic
-Requires-Dist: rich
-Requires-Dist: python-dotenv
-Requires-Dist: pytest
-Requires-Dist: pytest-mock
-Requires-Dist: gitpython
-Requires-Dist: tomli-w
-Requires-Dist: tomli
-Dynamic: license-file
-
-# AkitaLLM
-
-**AkitaLLM** is an open-source, local-first AI system designed for professional programming. It orchestrates existing LLMs (Ollama, OpenAI, Anthropic, etc.) through a strict **Plan-Execute-Validate** pipeline to ensure code quality and reliability.
-
-## What is AkitaLLM?
-
-AkitaLLM is a command-line interface (CLI) that helps you manage codebases with AI. Unlike simple chat interfaces, AkitaLLM:
-- **Analyzes** your project structure and file content before proposing changes.
-- **Plans** technical steps using a structured reasoning engine.
-- **Solves** problems by generating Unified Diffs that you can review.
-- **Validates** changes using local testing frameworks like `pytest`.
-
-## Key Features
-
-- **Local-First**: Developed with privacy and security in mind.
-- **Model Agnostic**: Use any model supported by LiteLLM (GPT-4o, Claude, Llama 3 via Ollama).
-- **Structured Output**: Code reviews and plans are presented in professional terminal tables and Markdown.
-- **Security by Default**: Diffs are only applied with your explicit confirmation.
-- **Support for .env**: Manage your API keys safely.
-
-## Installation
-
-```bash
-# Clone the repository
-git clone https://github.com/Your-Name/AkitaLLM.git
-cd AkitaLLM
-
-# Install in editable mode
-pip install -e .
-```
-
-## Usage
-
-### 1. Initial Setup
-The first time you run a command, AkitaLLM will guide you through choosing a model.
-```bash
-akita review .
-```
-
-### 2. Code Review
-Analyze files or directories for bugs, style, and security risks.
-```bash
-akita review src/
-```
-
-### 3. Solution Planning
-Generate a technical plan for a complex task.
-```bash
-akita plan "Refactor the authentication module to support JWT"
-```
-
-### 4. Problem Solving
-Generate a diff to solve a specific issue.
-```bash
-akita solve "Add error handling to the ReasoningEngine class"
-```
-
-## Configuration
-
-AkitaLLM stores its configuration in `~/.akita/config.toml`. You can manage it via:
-```bash
-# View and change model settings
-akita config model
-
-# Reset all settings
-akita config model --reset
-```
-
-## Contributing
-
-We welcome contributions! Please check [CONTRIBUTING.md](CONTRIBUTING.md) to understand our workflow and standards.
-
-## License
-
-This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details.
-
----
-
-*“Understanding the internals is the first step to excellence.”*