byte-ai-cli 0.1.8__py3-none-any.whl

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/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/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/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/core/__init__.py

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

byte/core/array_store.py

@@ -0,0 +1,82 @@
+from typing import Any, Optional
+
+from byte.core.mixins.conditionable import Conditionable
+from byte.core.utils import value
+
+
+class ArrayStore(Conditionable):
+	"""Dictionary-based store with fluent interface and conditional execution.
+
+	Provides a chainable API for managing key-value data with support for
+	conditional operations, merging, and store manipulation. Extends Conditionable
+	for when/unless conditional execution patterns.
+	Usage: `store = ArrayStore({"key": "value"}).add("new", 42).when(True, ...)`
+	"""
+
+	def __init__(self, data: Optional[dict[str, Any]] = None):
+		"""Initialize the array store with optional initial data.
+
+		Usage: `store = ArrayStore({"initial": "data"})`
+		"""
+		self._data: dict[str, Any] = data if data is not None else {}
+
+	def add(self, key: str, val: Any) -> "ArrayStore":
+		"""Add an item to the store, evaluating callable values.
+
+		Usage: `store.add("key", "value")` or `store.add("key", lambda: compute())`
+		"""
+		self._data[key] = value(val)
+		return self
+
+	def get(self, key: str, default: Any = None) -> Any:
+		"""Retrieve a single item from the store with optional default.
+
+		Usage: `val = store.get("key", "default_value")`
+		"""
+		return self._data.get(key, default)
+
+	def all(self) -> dict[str, Any]:
+		"""Retrieve all items in the store.
+
+		Usage: `data = store.all()`
+		"""
+		return self._data
+
+	def is_not_empty(self) -> bool:
+		"""Determine if the store contains any items.
+
+		Usage: `if store.is_not_empty(): ...`
+		"""
+		return not self.is_empty()
+
+	def is_empty(self) -> bool:
+		"""Determine if the store is empty.
+
+		Usage: `if store.is_empty(): ...`
+		"""
+		return len(self._data) == 0
+
+	def merge(self, *arrays: dict[str, Any]) -> "ArrayStore":
+		"""Merge one or more dictionaries into the store.
+
+		Usage: `store.merge({"key1": "val1"}, {"key2": "val2"})`
+		"""
+		for array in arrays:
+			self._data.update(array)
+		return self
+
+	def remove(self, key: str) -> "ArrayStore":
+		"""Remove an item from the store by key.
+
+		Usage: `store.remove("unwanted_key")`
+		"""
+		self._data.pop(key, None)
+		return self
+
+	def set(self, data: dict[str, Any]) -> "ArrayStore":
+		"""Overwrite the entire store with new data.
+
+		Usage: `store.set({"new": "data"})`
+		"""
+		self._data = data
+		return self

byte/core/cli.py

@@ -0,0 +1,22 @@
+import click
+
+from byte.core.config.config import ByteConfg
+from byte.core.initializer import FirstBootInitializer
+
+
+@click.command()
+def cli():
+	"""Byte CLI Assistant"""
+	from byte.main import run
+
+	# Check for first boot before bootstrapping
+	initializer = FirstBootInitializer()
+	if initializer.is_first_boot():
+		initializer.run_if_needed()
+
+	config = ByteConfg()
+	run(config)
+
+
+if __name__ == "__main__":
+	cli()

byte/core/config/config.py

@@ -0,0 +1,81 @@
+from pathlib import Path
+from typing import List
+
+import git
+from dotenv import load_dotenv
+from pydantic import Field
+from pydantic_settings import (
+	BaseSettings,
+	PydanticBaseSettingsSource,
+	SettingsConfigDict,
+	YamlConfigSettingsSource,
+)
+
+from byte.domain.cli.config import CLIConfig
+from byte.domain.edit_format.config import EditFormatConfig
+from byte.domain.files.config import FilesConfig
+from byte.domain.lint.config import LintConfig
+from byte.domain.llm.config import LLMConfig
+from byte.domain.mcp.config import MCPServer
+from byte.domain.web.config import WebConfig
+
+
+def _find_project_root() -> Path:
+	"""Find git repository root directory.
+
+	Raises InvalidGitRepositoryError if not in a git repository.
+	"""
+	try:
+		# Use git library to find repository root
+		repo = git.Repo(search_parent_directories=True)
+		return Path(repo.working_dir)
+	except git.InvalidGitRepositoryError:
+		raise git.InvalidGitRepositoryError(
+			"Byte requires a git repository. Please run 'git init' or navigate to a git repository."
+		)
+
+
+PROJECT_ROOT = _find_project_root()
+BYTE_DIR: Path = PROJECT_ROOT / ".byte"
+BYTE_DIR.mkdir(exist_ok=True)
+
+BYTE_CACHE_DIR: Path = BYTE_DIR / "cache"
+BYTE_CACHE_DIR.mkdir(exist_ok=True)
+
+BYTE_CONFIG_FILE = BYTE_DIR / "config.yaml"
+
+# Load our dotenv
+DOTENV_PATH = PROJECT_ROOT / ".env"
+load_dotenv(DOTENV_PATH)
+
+
+class ByteConfg(BaseSettings):
+	model_config = SettingsConfigDict(
+		env_nested_delimiter="_",
+		env_nested_max_split=1,
+		env_prefix="BYTE_",
+		yaml_file=BYTE_CONFIG_FILE,
+	)
+
+	project_root: Path = Field(default=PROJECT_ROOT, exclude=True)
+	byte_dir: Path = Field(default=BYTE_DIR, exclude=True)
+	byte_cache_dir: Path = Field(default=BYTE_CACHE_DIR, exclude=True)
+
+	cli: CLIConfig = CLIConfig()
+	llm: LLMConfig = LLMConfig()
+	lint: LintConfig = LintConfig()
+	files: FilesConfig = FilesConfig()
+	edit_format: EditFormatConfig = EditFormatConfig()
+	web: WebConfig = WebConfig()
+	mcp: List[MCPServer] = []
+
+	@classmethod
+	def settings_customise_sources(
+		cls,
+		settings_cls: type[BaseSettings],
+		init_settings: PydanticBaseSettingsSource,
+		env_settings: PydanticBaseSettingsSource,
+		dotenv_settings: PydanticBaseSettingsSource,
+		file_secret_settings: PydanticBaseSettingsSource,
+	) -> tuple[PydanticBaseSettingsSource, ...]:
+		return (YamlConfigSettingsSource(settings_cls),)

byte/core/event_bus.py

@@ -0,0 +1,92 @@
+import asyncio
+import time
+from enum import Enum
+from typing import Any, Callable, Dict, List, TypeVar
+
+from pydantic.dataclasses import dataclass as pydantic_dataclass
+
+T = TypeVar("T")
+
+
+class EventType(Enum):
+	PRE_PROMPT_TOOLKIT = "pre_prompt_toolkit"
+	POST_PROMPT_TOOLKIT = "post_prompt_toolkit"
+
+	GENERATE_FILE_CONTEXT = "generate_file_context"
+
+	FILE_ADDED = "file_added"
+
+	PRE_AGENT_EXECUTION = "pre_agent_execution"
+	POST_AGENT_EXECUTION = "post_agent_execution"
+
+	END_NODE = "end_node"
+
+	PRE_ASSISTANT_NODE = "pre_assistant_node"
+	POST_ASSISTANT_NODE = "post_assistant_node"
+
+
+@pydantic_dataclass
+class Payload:
+	"""Generic event payload that can carry any data."""
+
+	event_type: EventType
+	data: Dict[str, Any]
+	timestamp: float = 0.0
+
+	def __post_init__(self):
+		if self.timestamp == 0.0:
+			self.timestamp = time.time()
+
+	def get(self, key: str, default: Any = None) -> Any:
+		"""Get data value with optional default."""
+		return self.data.get(key, default)
+
+	def set(self, key: str, value: Any) -> "Payload":
+		"""Return new Payload with updated data."""
+		new_data = self.data.copy()
+		new_data[key] = value
+		return Payload(event_type=self.event_type, data=new_data, timestamp=self.timestamp)
+
+	def update(self, updates: Dict[str, Any]) -> "Payload":
+		"""Return new Payload with multiple updates."""
+		new_data = self.data.copy()
+		new_data.update(updates)
+		return Payload(event_type=self.event_type, data=new_data, timestamp=self.timestamp)
+
+
+class EventBus:
+	"""Simple event system with typed Pydantic payloads."""
+
+	def __init__(self, container=None, **kwargs):
+		self.container = container
+		self._listeners: Dict[str, List[Callable]] = {}
+
+	def on(self, event_name: str, callback: Callable):
+		"""Register a listener for an event."""
+		if event_name not in self._listeners:
+			self._listeners[event_name] = []
+		self._listeners[event_name].append(callback)
+
+	async def emit(self, payload: Payload) -> Payload:
+		"""Emit an event using the payload's event_type."""
+		event_name = payload.event_type.value
+
+		if event_name not in self._listeners:
+			return payload
+
+		current_payload = payload
+
+		for listener in self._listeners[event_name]:
+			try:
+				if asyncio.iscoroutinefunction(listener):
+					result = await listener(current_payload)
+				else:
+					result = listener(current_payload)
+
+				if result is not None:
+					current_payload = result
+
+			except Exception as e:
+				print(f"Error in event listener for '{event_name}': {e}")
+
+		return current_payload

byte/core/exceptions.py

@@ -0,0 +1,19 @@
+class ByteException(Exception):
+	"""Base exception for all Byte operations.
+
+	All custom exceptions in the Byte project should inherit from this class.
+	This provides a common base for catching any Byte-specific errors.
+	Usage: `except ByteException as e: ...`
+	"""
+
+	pass
+
+
+class ByteConfigException(ByteException):
+	"""Base exception for configuration-related errors.
+
+	Raised when configuration validation fails or required settings are missing.
+	Usage: `except ByteConfigException as e: ...`
+	"""
+
+	pass