byte-ai-cli 0.1.8__tar.gz

byte_ai_cli-0.1.8/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.3
+Name: byte-ai-cli
+Version: 0.1.8
+Summary: A human-in-the-loop AI coding agent that keeps you in control.
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Requires-Dist: pyperclip>=1.9.0
+Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: beautifulsoup4>=4.14.2
+Requires-Dist: click>=8.2.1
+Requires-Dist: gitpython>=3.1.45
+Requires-Dist: langchain-mcp-adapters>=0.1.10
+Requires-Dist: langchain[anthropic,google-genai,openai]>=0.3.27
+Requires-Dist: langgraph>=0.6.7
+Requires-Dist: langgraph-checkpoint-sqlite>=2.0.11
+Requires-Dist: markdownify>=1.2.0
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pydoll-python>=2.8.2
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=14.1.0
+Requires-Dist: watchfiles>=1.1.0
+Requires-Dist: loguru>=0.7.3
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/UseTheFork/byte
+Description-Content-Type: text/markdown
+
+# Byte
+
+<p align="center"><img alt="Byte Logo" src="docs/images/logo.svg" /></p>
+
+A human-in-the-loop AI coding agent that keeps you in control. Byte helps you build through natural conversation while maintaining full visibility and approval over every change.
+
+---
+
+## What is Byte?
+
+Byte is a CLI coding agent designed for developers who want AI assistance without sacrificing control. Unlike autonomous agents that make multiple decisions and tool calls independently, Byte requires your approval for every decision.
+
+**Key Features:**
+
+- Review and confirm every change before it's applied
+- See exactly what the agent modifies in your code
+- Manage precisely what information the AI receives
+- Slots into your existing development environment
+- Structured prompts that adapt and evolve with each interaction
+- Automatic linting, formatting, and testing without extra commands
+
+---
+
+## Design Philosophy
+
+**Transparency First** - You see the complete prompt, not just your input. All interactions are logged for reference and debugging.
+
+**Explicit Over Implicit** - Changes require approval. Context additions need confirmation. No surprises.
+
+**Complementary, Not Replacement** - Byte enhances your workflow without replacing your tools or editor.
+
+**Quality Over Quantity** - Better prompts produce better results. Byte prioritizes well-structured instructions over large context windows.
+
+---
+
+## Quick Start
+
+Get started with Byte in three steps:
+
+```bash
+# Install with uv
+$ uv tool install byte
+
+# Navigate to your project
+$ cd /path/to/your/project
+
+# Run Byte
+$ byte
+```
+
+See the [Installation Guide](<[getting-started/installation.md](https://usethefork.github.io/byte/getting-started/installation/)>) for other installation methods including pip and Nix.
+
+---
+
+## Why This Approach?
+
+### Human-in-the-Loop Design
+
+Every decision and code change requires your confirmation. If you prefer agents that work autonomously, Byte isn't for you. If you value control and transparency, you'll appreciate the deliberate confirmation flow.
+
+### Built for Experienced Developers
+
+Designed for experienced developers who understand good design principles. This isn't a tool where you provide a specification and it builds the entire feature. Instead, Byte excels at small, incremental changes that keep you in control. Understanding when to refactor, how to structure code, and what constitutes good design remains your responsibility.
+
+### Search/Replace Over Tools
+
+Instead of giving the AI arbitrary tools, explicit Search/Replace blocks show you the exact changes before they happen, making it easy to cancel or modify the proposed work.
+
+### Workflow Preservation
+
+Your editor stays central to development. Whether you use Vim, VS Code, or Jetbrains, Byte complements your existing workflow as something you invoke when needed.
+
+### Context Management
+
+You control exactly what context the LLM receives:
+
+- Add or remove files from the active context
+- Monitor token usage and memory consumption
+- Prevent context overflow with targeted information
+
+### Intelligent Prompting
+
+Structured prompts adapt with each turn:
+
+- Previous Search/Replace blocks get removed to maintain focus
+- Instructions follow clear markdown formatting
+- Reduces "tunnel vision" where agents fixate on minor issues
+- Full prompt visibility through logging for debugging
+
+### Integrated Tooling
+
+Linting, formatting, and testing run automatically after code changes are applied. Configure your tools once and they work seamlessly in the background without requiring agent interaction.
+
+### Controlled MCP Integration
+
+Model Context Protocol (MCP) tools are available but tightly controlled. Manually run tools or restrict which agents can access specific capabilities.
+
+---
+
+## Built With
+
+Byte leverages modern Python tooling and AI frameworks:
+
+- **uv** - Fast Python package management
+- **LangChain** - AI framework for language models
+- **LangGraph** - Graph-based agent workflows
+- **Rich** - Beautiful terminal output
+- **Prompt Toolkit** - Interactive command-line interfaces
+- **Catppuccin** - Soothing pastel theme
+
+---
+
+## Inspiration
+
+Byte draws inspiration from excellent projects in the coding agent space:
+
+- [Aider](http://aider.chat/) - The pioneering CLI coding agent that proved the concept
+- [Charm's Crush](https://github.com/charmbracelet/crush) - Elegant terminal agent
+
+---
+
+## License
+
+[License information to be added]
+
+## Contributing
+
+[Contribution guidelines to be added]

byte_ai_cli-0.1.8/README.md

@@ -0,0 +1,128 @@
+# Byte
+
+<p align="center"><img alt="Byte Logo" src="docs/images/logo.svg" /></p>
+
+A human-in-the-loop AI coding agent that keeps you in control. Byte helps you build through natural conversation while maintaining full visibility and approval over every change.
+
+---
+
+## What is Byte?
+
+Byte is a CLI coding agent designed for developers who want AI assistance without sacrificing control. Unlike autonomous agents that make multiple decisions and tool calls independently, Byte requires your approval for every decision.
+
+**Key Features:**
+
+- Review and confirm every change before it's applied
+- See exactly what the agent modifies in your code
+- Manage precisely what information the AI receives
+- Slots into your existing development environment
+- Structured prompts that adapt and evolve with each interaction
+- Automatic linting, formatting, and testing without extra commands
+
+---
+
+## Design Philosophy
+
+**Transparency First** - You see the complete prompt, not just your input. All interactions are logged for reference and debugging.
+
+**Explicit Over Implicit** - Changes require approval. Context additions need confirmation. No surprises.
+
+**Complementary, Not Replacement** - Byte enhances your workflow without replacing your tools or editor.
+
+**Quality Over Quantity** - Better prompts produce better results. Byte prioritizes well-structured instructions over large context windows.
+
+---
+
+## Quick Start
+
+Get started with Byte in three steps:
+
+```bash
+# Install with uv
+$ uv tool install byte
+
+# Navigate to your project
+$ cd /path/to/your/project
+
+# Run Byte
+$ byte
+```
+
+See the [Installation Guide](<[getting-started/installation.md](https://usethefork.github.io/byte/getting-started/installation/)>) for other installation methods including pip and Nix.
+
+---
+
+## Why This Approach?
+
+### Human-in-the-Loop Design
+
+Every decision and code change requires your confirmation. If you prefer agents that work autonomously, Byte isn't for you. If you value control and transparency, you'll appreciate the deliberate confirmation flow.
+
+### Built for Experienced Developers
+
+Designed for experienced developers who understand good design principles. This isn't a tool where you provide a specification and it builds the entire feature. Instead, Byte excels at small, incremental changes that keep you in control. Understanding when to refactor, how to structure code, and what constitutes good design remains your responsibility.
+
+### Search/Replace Over Tools
+
+Instead of giving the AI arbitrary tools, explicit Search/Replace blocks show you the exact changes before they happen, making it easy to cancel or modify the proposed work.
+
+### Workflow Preservation
+
+Your editor stays central to development. Whether you use Vim, VS Code, or Jetbrains, Byte complements your existing workflow as something you invoke when needed.
+
+### Context Management
+
+You control exactly what context the LLM receives:
+
+- Add or remove files from the active context
+- Monitor token usage and memory consumption
+- Prevent context overflow with targeted information
+
+### Intelligent Prompting
+
+Structured prompts adapt with each turn:
+
+- Previous Search/Replace blocks get removed to maintain focus
+- Instructions follow clear markdown formatting
+- Reduces "tunnel vision" where agents fixate on minor issues
+- Full prompt visibility through logging for debugging
+
+### Integrated Tooling
+
+Linting, formatting, and testing run automatically after code changes are applied. Configure your tools once and they work seamlessly in the background without requiring agent interaction.
+
+### Controlled MCP Integration
+
+Model Context Protocol (MCP) tools are available but tightly controlled. Manually run tools or restrict which agents can access specific capabilities.
+
+---
+
+## Built With
+
+Byte leverages modern Python tooling and AI frameworks:
+
+- **uv** - Fast Python package management
+- **LangChain** - AI framework for language models
+- **LangGraph** - Graph-based agent workflows
+- **Rich** - Beautiful terminal output
+- **Prompt Toolkit** - Interactive command-line interfaces
+- **Catppuccin** - Soothing pastel theme
+
+---
+
+## Inspiration
+
+Byte draws inspiration from excellent projects in the coding agent space:
+
+- [Aider](http://aider.chat/) - The pioneering CLI coding agent that proved the concept
+- [Charm's Crush](https://github.com/charmbracelet/crush) - Elegant terminal agent
+
+---
+
+## License
+
+[License information to be added]
+
+## Contributing
+
+[Contribution guidelines to be added]

byte_ai_cli-0.1.8/pyproject.toml

@@ -0,0 +1,136 @@
+[project]
+name = "byte-ai-cli"
+version = "0.1.8"
+description = "A human-in-the-loop AI coding agent that keeps you in control."
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "pyperclip>=1.9.0",
+    "aiosqlite>=0.21.0",
+    "beautifulsoup4>=4.14.2",
+    "click>=8.2.1",
+    "gitpython>=3.1.45",
+    "langchain-mcp-adapters>=0.1.10",
+    "langchain[anthropic,google-genai,openai]>=0.3.27",
+    "langgraph>=0.6.7",
+    "langgraph-checkpoint-sqlite>=2.0.11",
+    "markdownify>=1.2.0",
+    "pathspec>=0.12.1",
+    "prompt-toolkit>=3.0.52",
+    "pydantic>=2.11.7",
+    "pydantic-settings>=2.10.1",
+    "pydoll-python>=2.8.2",
+    "pyperclip>=1.11.0",
+    "python-dotenv>=1.1.1",
+    "pyyaml>=6.0.2",
+    "rich>=14.1.0",
+    "watchfiles>=1.1.0",
+    "loguru>=0.7.3",
+]
+
+[project.urls]
+Homepage = "https://github.com/UseTheFork/byte"
+
+[project.scripts]
+byte = "byte.core.cli:cli"
+
+[tool.uv.build-backend]
+module-name = "byte"
+
+[dependency-groups]
+dev = [
+    "dill>=0.4.0",
+    "grandalf>=0.8",
+    "pytest>=8.4.2",
+    "pytest-asyncio>=1.2.0",
+    "ruff>=0.12.12",
+    "tomli>=2.2.1",
+]
+
+mkdocs = ["mkdocs>=1.6.1", "mkdocs-material>=9.6.21", "mkdocstrings>=0.30.1"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+
+[tool.ruff.lint]
+select = [
+    # keep-sorted start
+    "E",
+    "F",
+    "FURB",
+    "G",
+    "I",
+    "ICN",
+    "ISC",
+    "LOG",
+    "PIE",
+    "PT",
+    "Q",
+    "RSE",
+    "RUF",
+    "T10",
+    "UP",
+    # keep-sorted end
+]
+ignore = [
+    # keep-sorted start
+    "E111",
+    "E114",
+    "E117",
+    "E501",
+    "E712",
+    "ISC001",
+    "PIE790",
+    "Q001",
+    "Q002",
+    "Q003",
+    "RUF005",
+    "RUF006",
+    "RUF012",
+    "UP006",
+    "UP007",
+    "UP035",
+    "UP045",
+    "W191",
+    # keep-sorted end
+]
+
+[tool.ruff.format]
+indent-style = "tab"
+line-ending = "lf"
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+[tool.basedpyright]
+include = ["src"]
+exclude = ["**/node_modules", "**/__pycache__"]
+pythonPlatform = "All"
+pythonVersion = "3.12"
+reportIgnoreCommentWithoutRule = true
+reportRedeclaration = false
+reportUnnecessaryTypeIgnoreComment = "warning"
+typeCheckingMode = "basic"
+
+executionEnvironments = [
+    { root = "src/tests", reportPrivateUsage = false, extraPaths = [
+        "src/tests/e2e",
+    ] },
+    { root = "src" },
+]
+
+[build-system]
+requires = ["uv_build>=0.8.10,<0.9.0"]
+build-backend = "uv_build"

byte_ai_cli-0.1.8/src/byte/__init__.py

@@ -0,0 +1,4 @@
+from byte.core.logging import log
+from byte.core.utils import dd, dump
+
+__all__ = ["dd", "dump", "log"]

byte_ai_cli-0.1.8/src/byte/bootstrap.py

@@ -0,0 +1,91 @@
+from byte.container import app
+from byte.core.config.config import ByteConfg
+from byte.core.event_bus import EventBus
+from byte.core.task_manager import TaskManager
+from byte.domain.agent.service_provider import AgentServiceProvider
+from byte.domain.analytics.service_provider import AnalyticsProvider
+from byte.domain.cli.service.command_registry import CommandRegistry
+from byte.domain.cli.service.console_service import ConsoleService
+from byte.domain.cli.service_provider import CLIServiceProvider
+from byte.domain.development.service_provider import DevelopmentProvider
+from byte.domain.edit_format.service_provider import EditFormatProvider
+from byte.domain.files.service_provider import FileServiceProvider
+from byte.domain.git.service_provider import GitServiceProvider
+from byte.domain.knowledge.service_provider import KnowledgeServiceProvider
+from byte.domain.lint.service_provider import LintServiceProvider
+from byte.domain.llm.service_provider import LLMServiceProvider
+from byte.domain.mcp.service_provider import MCPServiceProvider
+from byte.domain.memory.service_provider import MemoryServiceProvider
+from byte.domain.system.service_provider import SystemServiceProvider
+from byte.domain.tools.service_provider import ToolsServiceProvider
+from byte.domain.web.service_provider import WebServiceProvider
+
+
+async def bootstrap(config: ByteConfg):
+	"""Initialize and configure the application's dependency injection container.
+
+	Follows a two-phase initialization pattern: register all services first,
+	then boot them. This ensures all dependencies are available during the
+	boot phase when services may need to reference each other.
+
+	Returns the fully configured container ready for use.
+	"""
+
+	app.singleton(EventBus)
+	app.singleton(TaskManager)
+
+	# Make the global command registry available through dependency injection
+	app.singleton(CommandRegistry)
+
+	# Boot config as early as possible
+	app.singleton(ByteConfg, lambda: config)
+
+	# Setup console early
+	app.singleton(ConsoleService)
+
+	# Order matters: ConfigServiceProvider must be early since other services
+	# may need configuration access during their boot phase
+
+	service_providers = [
+		CLIServiceProvider(),  # Console and prompt services
+		MemoryServiceProvider(),  # Short-term conversation memory
+		KnowledgeServiceProvider(),
+		FileServiceProvider(),  # File context management
+		ToolsServiceProvider(),  # File context management
+		LLMServiceProvider(),  # Language model integration
+		GitServiceProvider(),  # Git repository operations
+		LintServiceProvider(),  # Code linting functionality
+		AgentServiceProvider(),  # Agent routing and management
+		MCPServiceProvider(),
+		AnalyticsProvider(),
+		EditFormatProvider(),
+		WebServiceProvider(),
+		SystemServiceProvider(),  # Core system commands
+		DevelopmentProvider(),  # Core system commands
+	]
+
+	# Phase 1: Register all service bindings in the container
+	# This makes services available for dependency resolution
+	for provider in service_providers:
+		await provider.register_services(app)
+		await provider.register_commands(app)
+		await provider.register(app)
+
+	# Phase 2: Boot services after all are registered
+	# This allows services to safely reference dependencies during initialization
+	for provider in service_providers:
+		await provider.boot_commands(app)
+		await provider.boot(app)
+
+	# Store service providers for shutdown
+	app._service_providers = service_providers
+
+	return app
+
+
+async def shutdown(container):
+	"""Shutdown all service providers in reverse order."""
+	if hasattr(container, "_service_providers"):
+		# Shutdown in reverse order (opposite of boot)
+		for provider in reversed(container._service_providers):
+			await provider.shutdown(container)

byte_ai_cli-0.1.8/src/byte/container.py

@@ -0,0 +1,90 @@
+import asyncio
+from typing import Any, Callable, Dict, Optional, Type, TypeVar
+
+from byte.core.mixins.bootable import Bootable
+
+T = TypeVar("T")
+
+
+class Container:
+	"""Simple dependency injection container for managing service bindings.
+
+	Implements the Service Locator pattern with support for both transient
+	and singleton lifetimes. Services are resolved lazily on first access.
+	"""
+
+	def __init__(self):
+		self._singletons: Dict[Type, Callable[[], Any]] = {}
+		self._transients: Dict[Type, Callable[[], Any]] = {}
+		self._instances: Dict[Type, Any] = {}
+		self._service_providers = []
+
+	def bind(self, service_class: Type[T], concrete: Optional[Callable[[], T]] = None) -> None:
+		"""Register a transient service binding.
+
+		Usage:
+		container.bind(FileService, lambda: FileService(container))
+		container.bind(FileService)  # Auto-creates with container
+		"""
+		if concrete is None:
+
+			def concrete():
+				return service_class(self)  # pyright: ignore[reportCallIssue]
+
+		self._transients[service_class] = concrete
+
+	def singleton(self, service_class: Type[T], concrete: Optional[Callable[[], T]] = None) -> None:
+		"""Register a singleton service binding.
+
+		Usage:
+		container.singleton(FileService, lambda: FileService(container))
+		container.singleton(FileService)  # Auto-creates with container
+		"""
+		if concrete is None:
+			# Auto-create factory for class
+			def concrete():
+				return service_class(self)  # pyright: ignore[reportCallIssue]
+
+		self._singletons[service_class] = concrete
+
+	async def make(self, service_class: Type[T], **kwargs) -> T:
+		"""Resolve a service from the container.
+
+		Usage:
+		file_service = await container.make(FileService)
+		"""
+		# Return cached singleton instance if available
+		if service_class in self._instances:
+			return self._instances[service_class]
+
+		# Try to create from singleton bindings
+		if service_class in self._singletons:
+			factory = self._singletons[service_class]
+			instance = await self._create_instance(factory, **kwargs)
+			self._instances[service_class] = instance  # Cache it
+			return instance
+
+		# Try to create from transient bindings
+		if service_class in self._transients:
+			factory = self._transients[service_class]
+			return await self._create_instance(factory, **kwargs)  # Don't cache
+
+		raise ValueError(f"No binding found for {service_class.__name__}")
+
+	async def _create_instance(self, factory: Callable, **kwargs) -> Any:
+		"""Helper to create and boot instances."""
+		if asyncio.iscoroutinefunction(factory):
+			instance = await factory()
+		else:
+			instance = factory()
+
+		if isinstance(instance, Bootable):
+			await instance.ensure_booted(**kwargs)
+
+		return instance
+
+
+# Global application container instance
+# Using a global container simplifies service access across the application
+# while maintaining the benefits of dependency injection
+app = Container()

byte_ai_cli-0.1.8/src/byte/context.py

@@ -0,0 +1,22 @@
+from contextvars import ContextVar
+from typing import Optional, Type, TypeVar
+
+from byte.container import Container
+
+T = TypeVar("T")
+
+container_context: ContextVar[Optional["Container"]] = ContextVar("container", default=None)
+
+
+def get_container() -> "Container":
+	"""Get the current container from context."""
+	container = container_context.get()
+	if container is None:
+		raise RuntimeError("No container available in current context")
+	return container
+
+
+async def make[T](service_class: Type[T]) -> T:
+	"""Convenience method to get a service from the current container context."""
+	container = get_container()
+	return await container.make(service_class)

byte_ai_cli-0.1.8/src/byte/core/__init__.py

@@ -0,0 +1,4 @@
+from byte.core.logging import log
+from byte.core.utils import dd, dump
+
+__all__ = ["dd", "dump", "log"]