nonoka-cli 0.1.0__py3-none-any.whl

nonoka_cli/__init__.py

@@ -0,0 +1,5 @@
+"""Nonoka CLI — Terminal frontend for the Nonoka Agent framework."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"

nonoka_cli/__main__.py

@@ -0,0 +1,7 @@
+"""Allow running nonoka-cli as a module: python -m nonoka_cli."""
+
+from nonoka_cli.cli import main
+
+if __name__ == "__main__":
+  import sys
+  sys.exit(main())

nonoka_cli/cli.py

@@ -0,0 +1,134 @@
+"""CLI entry point for nonoka-cli.
+
+Handles argument parsing, configuration loading, and REPL startup.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import signal
+import sys
+from pathlib import Path
+
+import structlog
+
+from nonoka_cli.core.orchestrator import Orchestrator
+from nonoka_cli.shell.repl import REPL
+from nonoka_cli.ui.renderer import Renderer
+from nonoka_cli.utils.logging import setup_logging
+
+logger = structlog.get_logger("nonoka_cli.cli")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+  """Build the argument parser."""
+  parser = argparse.ArgumentParser(
+    prog="nonoka-cli",
+    description="Terminal frontend for the Nonoka Agent framework",
+  )
+  parser.add_argument(
+    "--config",
+    type=Path,
+    default=None,
+    help="Path to configuration file (default: ~/.config/nonoka/config.yaml)",
+  )
+  parser.add_argument(
+    "--model",
+    type=str,
+    default=None,
+    help="Override the model specified in config",
+  )
+  parser.add_argument(
+    "--verbose", "-v",
+    action="store_true",
+    help="Output INFO level logs to console",
+  )
+  parser.add_argument(
+    "--debug",
+    action="store_true",
+    help="Output DEBUG level logs to console",
+  )
+  return parser
+
+
+async def _run_repl(args: argparse.Namespace) -> int:
+  """Initialize and run the REPL.
+
+  Args:
+    args: Parsed command-line arguments.
+
+  Returns:
+    Exit code (0 for success).
+  """
+  orchestrator = Orchestrator()
+  renderer = Renderer()
+  repl = REPL(orchestrator, renderer)
+
+  # Handle Ctrl+C by interrupting the current execution
+  loop = asyncio.get_event_loop()
+
+  def _sigint_handler():
+    asyncio.create_task(repl.interrupt())
+
+  if sys.platform != "win32":
+    loop.add_signal_handler(signal.SIGINT, _sigint_handler)
+
+  try:
+    await orchestrator.initialize(config_path=args.config)
+  except Exception as exc:
+    print(f"Failed to initialize: {exc}", file=sys.stderr)
+    logger.error("initialization_failed", error=str(exc))
+    return 1
+
+  # Apply model override if provided
+  if args.model:
+    orchestrator.config.model = args.model
+    orchestrator._agent_factory.rebuild()
+    logger.info("model_overridden", model=args.model)
+
+  print(f"nonoka-cli initialized. Model: {orchestrator.config.model}")
+  print("Type /help for commands, /exit to quit.")
+  print()
+
+  try:
+    await repl.run()
+  finally:
+    await orchestrator.shutdown()
+    if sys.platform != "win32":
+      loop.remove_signal_handler(signal.SIGINT)
+
+  return 0
+
+
+def main() -> int:
+  """Main entry point.
+
+  Returns:
+    Exit code (0 for success, 1 for error).
+  """
+  parser = _build_parser()
+  args = parser.parse_args()
+
+  # Setup logging
+  log_level = (
+    logging.DEBUG if args.debug
+    else logging.INFO if args.verbose
+    else logging.WARNING
+  )
+  setup_logging(level=log_level, console=args.verbose or args.debug)
+
+  try:
+    return asyncio.run(_run_repl(args))
+  except KeyboardInterrupt:
+    print("\nInterrupted.")
+    return 130
+  except Exception as exc:
+    logger.error("fatal_error", error=str(exc))
+    print(f"Fatal error: {exc}", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+  sys.exit(main())

nonoka_cli/config/__init__.py

@@ -0,0 +1,8 @@
+"""Configuration loading and validation for nonoka-cli."""
+
+from __future__ import annotations
+
+from nonoka_cli.config.models import CLIConfig
+from nonoka_cli.config.loader import ConfigLoader, load_config
+
+__all__ = ["CLIConfig", "ConfigLoader", "load_config"]

nonoka_cli/config/loader.py

@@ -0,0 +1,130 @@
+"""Configuration loading with env-var substitution."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import structlog
+
+from nonoka_cli.config.models import CLIConfig
+from nonoka_cli.utils.errors import ConfigError, ConfigNotFoundError
+
+logger = structlog.get_logger("nonoka_cli.config")
+
+_ENV_PATTERN = re.compile(r"\$\{(?P<name>[A-Za-z_][A-Za-z0-9_]*)(?::-?(?P<default>[^}]*))?\}")
+
+
+def _substitute_env_vars(value: Any) -> Any:
+  """Recursively substitute ``${VAR}`` and ``${VAR:-default}`` in strings."""
+  if isinstance(value, str):
+    def replacer(match: re.Match[str]) -> str:
+      var_name = match.group("name")
+      default = match.group("default")
+      result = os.getenv(var_name)
+      if result is None:
+        if default is not None:
+          return default
+        raise ConfigError(
+          f"Environment variable '{var_name}' is not set and no default provided"
+        )
+      return result
+    return _ENV_PATTERN.sub(replacer, value)
+  if isinstance(value, dict):
+    return {k: _substitute_env_vars(v) for k, v in value.items()}
+  if isinstance(value, list):
+    return [_substitute_env_vars(item) for item in value]
+  return value
+
+
+class ConfigLoader:
+  """Loads and validates CLI configuration from YAML files."""
+
+  DEFAULT_PATH = Path.home() / ".config" / "nonoka" / "config.yaml"
+  FALLBACK_PATH = Path.cwd() / "nonoka.yaml"
+
+  @classmethod
+  def find_config_file(
+    cls,
+    explicit_path: Path | str | None = None,
+  ) -> Path:
+    """Search for a configuration file in priority order.
+
+    Priority: explicit_path > ~/.config/nonoka/config.yaml > ./nonoka.yaml
+    """
+    if explicit_path is not None:
+      path = Path(explicit_path)
+      if path.exists():
+        return path
+      raise ConfigNotFoundError(f"Explicit config file not found: {path}")
+
+    if cls.DEFAULT_PATH.exists():
+      return cls.DEFAULT_PATH
+
+    if cls.FALLBACK_PATH.exists():
+      return cls.FALLBACK_PATH
+
+    raise ConfigNotFoundError(
+      f"No config file found. Searched: {cls.DEFAULT_PATH}, {cls.FALLBACK_PATH}"
+    )
+
+  @classmethod
+  def load(
+    cls,
+    path: Path | str | None = None,
+  ) -> CLIConfig:
+    """Load configuration from a YAML file.
+
+    Args:
+      path: Explicit config file path. If None, searches default locations.
+
+    Returns:
+      Validated CLIConfig instance.
+
+    Raises:
+      ConfigNotFoundError: If no config file is found.
+      ConfigError: If parsing or validation fails.
+    """
+    config_path = cls.find_config_file(path)
+    logger.info("loading_config", path=str(config_path))
+
+    try:
+      import yaml
+    except ImportError as exc:
+      raise ConfigError("PyYAML is required. Install: pip install pyyaml") from exc
+
+    try:
+      raw = config_path.read_text(encoding="utf-8")
+      data = yaml.safe_load(raw)
+    except Exception as exc:
+      raise ConfigError(f"Failed to parse YAML: {exc}") from exc
+
+    if data is None:
+      data = {}
+    if not isinstance(data, dict):
+      raise ConfigError(
+        f"Config file must contain a top-level object, got {type(data).__name__}"
+      )
+
+    # Substitute env vars before validation
+    try:
+      data = _substitute_env_vars(data)
+    except ConfigError:
+      raise
+    except Exception as exc:
+      raise ConfigError(f"Environment variable substitution failed: {exc}") from exc
+
+    try:
+      config = CLIConfig.model_validate(data)
+    except Exception as exc:
+      raise ConfigError(f"Config validation failed: {exc}") from exc
+
+    logger.info("config_loaded", model=config.model)
+    return config
+
+
+def load_config(path: Path | str | None = None) -> CLIConfig:
+  """Convenience function: load CLI configuration."""
+  return ConfigLoader.load(path)

nonoka_cli/config/models.py

@@ -0,0 +1,51 @@
+"""Pydantic models for CLI configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class CLIConfigModel(BaseModel):
+  """CLI behavior configuration."""
+  theme: str = "dark"
+  auto_approve: bool = False
+  editor: str = "${EDITOR:-nano}"
+  max_history: int = 1000
+  multi_line_trigger: str = '"""'
+
+
+class HITLConfigModel(BaseModel):
+  """HITL (Human-in-the-Loop) configuration."""
+  policy: str = "interactive"
+  dangerous_tools: list[str] = Field(default_factory=list)
+
+
+class MCPServerConfigModel(BaseModel):
+  """Single MCP server configuration."""
+  transport: str
+  command: str
+  args: list[str] = Field(default_factory=list)
+
+
+class CLIConfig(BaseModel):
+  """Top-level configuration for nonoka-cli.
+
+  Matches the expected structure of ~/.config/nonoka/config.yaml.
+  """
+  model: str = "gpt-4o"
+  system_prompt: str = "You are a helpful AI assistant."
+  mcp_servers: dict[str, MCPServerConfigModel] = Field(default_factory=dict)
+  tool_paths: list[Path] = Field(default_factory=list)
+  skills: list[str] = Field(default_factory=list)
+  cli: CLIConfigModel = Field(default_factory=CLIConfigModel)
+  hitl: HITLConfigModel = Field(default_factory=HITLConfigModel)
+
+  @field_validator("tool_paths", mode="before")
+  @classmethod
+  def _resolve_tool_paths(cls, v: Any) -> list[Path]:
+    if v is None:
+      return []
+    return [Path(p).expanduser() for p in v]

nonoka_cli/core/__init__.py

@@ -0,0 +1,9 @@
+"""Core orchestration layer for nonoka-cli."""
+
+from __future__ import annotations
+
+from nonoka_cli.core.context import CLIContext
+from nonoka_cli.core.agent_factory import AgentFactory
+from nonoka_cli.core.orchestrator import Orchestrator
+
+__all__ = ["CLIContext", "AgentFactory", "Orchestrator"]

nonoka_cli/core/agent_factory.py

@@ -0,0 +1,78 @@
+"""Agent factory — builds nonoka Agent from CLI configuration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+
+from nonoka import Agent, AgentBuilder
+from nonoka_cli.config.models import CLIConfig
+from nonoka_cli.utils.errors import AgentBuildError
+
+logger = structlog.get_logger("nonoka_cli.core")
+
+
+class AgentFactory:
+  """Builds nonoka Agent instances from CLI configuration.
+
+  TODO: Integrate MCP tools, local tools, and skills.
+  Currently supports model and system_prompt only.
+  """
+
+  def __init__(self, config: CLIConfig):
+    self._config = config
+    self._agent: Agent | None = None
+
+  @property
+  def config(self) -> CLIConfig:
+    """Current configuration."""
+    return self._config
+
+  def build(self) -> Agent:
+    """Build (or rebuild) an Agent from the current configuration.
+
+    Returns:
+      A nonoka Agent instance.
+
+    Raises:
+      AgentBuildError: If model is not configured.
+    """
+    if not self._config.model:
+      raise AgentBuildError("No model configured. Set 'model' in config.yaml.")
+
+    logger.info(
+      "building_agent",
+      model=self._config.model,
+      system_prompt_length=len(self._config.system_prompt),
+    )
+
+    self._agent = (
+      AgentBuilder()
+      .model(self._config.model)
+      .system_prompt(self._config.system_prompt)
+      .max_turns(20)
+      .build()
+    )
+    return self._agent
+
+  def rebuild(self, config_patch: dict[str, Any] | None = None) -> Agent:
+    """Rebuild Agent with an optional configuration patch.
+
+    Args:
+      config_patch: Dict of config overrides (e.g. {"model": "gpt-4o"}).
+
+    Returns:
+      The rebuilt Agent.
+    """
+    if config_patch:
+      # Apply patch by creating a new config
+      data = self._config.model_dump()
+      data.update(config_patch)
+      self._config = self._config.__class__.model_validate(data)
+
+    return self.build()
+
+  def get_agent(self) -> Agent | None:
+    """Return the currently built Agent, if any."""
+    return self._agent

nonoka_cli/core/context.py

@@ -0,0 +1,17 @@
+"""CLI runtime context passed to tools via RunContext.deps."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from nonoka_cli.config.models import CLIConfig
+
+
+@dataclass
+class CLIContext:
+  """CLI runtime context injected into tools."""
+  user: str
+  session_id: str
+  config: CLIConfig
+  working_dir: Path

nonoka_cli/core/orchestrator.py

@@ -0,0 +1,138 @@
+"""Orchestrator — coordinates config, agent, runner, and execution."""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import AsyncIterator
+from pathlib import Path
+
+import structlog
+from nonoka import Runner
+from nonoka.core.runner import StreamEvent
+
+from nonoka_cli.config.loader import ConfigLoader
+from nonoka_cli.config.models import CLIConfig
+from nonoka_cli.core.agent_factory import AgentFactory
+from nonoka_cli.core.context import CLIContext
+from nonoka_cli.utils.errors import ConfigError, OrchestratorError
+
+logger = structlog.get_logger("nonoka_cli.core")
+
+
+class Orchestrator:
+  """Orchestration layer — the bridge between Shell and nonoka kernel.
+
+  Responsibilities:
+  - Load configuration
+  - Build Agent and Runner
+  - Execute prompts via nonoka's streaming ReAct API
+  - Manage a single session_id
+
+  TODO: Add MCP, Skill, session management, HITL.
+  """
+
+  def __init__(self, config: CLIConfig | None = None):
+    """Initialize the orchestrator.
+
+    Args:
+      config: Pre-loaded configuration. If None, will be loaded on initialize().
+    """
+    self._config = config
+    self._agent_factory: AgentFactory | None = None
+    self._runner: Runner | None = None
+    self._session_id: str = str(uuid.uuid4())
+    self._initialized = False
+
+  @property
+  def config(self) -> CLIConfig:
+    """Current configuration."""
+    if self._config is None:
+      raise OrchestratorError("Orchestrator not initialized. Call initialize() first.")
+    return self._config
+
+  @property
+  def session_id(self) -> str:
+    """Current session identifier."""
+    return self._session_id
+
+  async def initialize(self, config_path: Path | str | None = None) -> None:
+    """Load config, build agent, and create runner.
+
+    Args:
+      config_path: Optional explicit path to config file.
+
+    Raises:
+      ConfigError: If configuration cannot be loaded.
+      OrchestratorError: If agent or runner cannot be built.
+    """
+    if self._config is None:
+      try:
+        self._config = ConfigLoader.load(config_path)
+      except ConfigError:
+        raise
+      except Exception as exc:
+        raise ConfigError(f"Failed to load configuration: {exc}") from exc
+
+    self._agent_factory = AgentFactory(self._config)
+    agent = self._agent_factory.build()
+
+    self._runner = Runner()
+
+    logger.info(
+      "orchestrator_initialized",
+      model=self._config.model,
+      session_id=self._session_id,
+    )
+    self._initialized = True
+
+  async def execute(self, prompt: str) -> AsyncIterator[StreamEvent]:
+    """Execute a user prompt and yield streaming events.
+
+    Args:
+      prompt: The user's input text.
+
+    Yields:
+      StreamEvent objects from nonoka's ReAct streaming API.
+
+    Raises:
+      OrchestratorError: If not initialized or execution fails.
+    """
+    if not self._initialized or self._agent_factory is None or self._runner is None:
+      raise OrchestratorError("Orchestrator not initialized. Call initialize() first.")
+
+    agent = self._agent_factory.get_agent()
+    if agent is None:
+      raise OrchestratorError("No Agent available. Build failed during initialization.")
+
+    logger.info("executing_prompt", prompt_length=len(prompt), session_id=self._session_id)
+
+    deps = CLIContext(
+      user="local",
+      session_id=self._session_id,
+      config=self._config,
+      working_dir=Path.cwd(),
+    )
+
+    try:
+      async for event in self._runner.run_react_stream(
+        agent, prompt, deps=deps, session_id=self._session_id
+      ):
+        yield event
+    except Exception as exc:
+      logger.error("execution_failed", error=str(exc))
+      raise OrchestratorError(f"Execution failed: {exc}") from exc
+
+  def new_session(self) -> str:
+    """Create a new session, discarding the old one.
+
+    Returns:
+      The new session_id.
+    """
+    self._session_id = str(uuid.uuid4())
+    logger.info("new_session_created", session_id=self._session_id)
+    return self._session_id
+
+  async def shutdown(self) -> None:
+    """Graceful shutdown — clean up resources."""
+    logger.info("orchestrator_shutdown")
+    self._initialized = False

nonoka_cli/shell/__init__.py

@@ -0,0 +1,5 @@
+"""Shell / REPL layer for nonoka-cli."""
+
+from nonoka_cli.shell.repl import REPL
+
+__all__ = ["REPL"]

nonoka_cli/shell/repl.py

@@ -0,0 +1,164 @@
+"""REPL — Read-Eval-Print Loop for nonoka-cli.
+
+Provides interactive terminal session with command parsing,
+interrupt handling, and prompt execution.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import structlog
+
+from nonoka_cli.core.orchestrator import Orchestrator
+from nonoka_cli.ui.renderer import Renderer
+from nonoka_cli.utils.errors import CLIError, OrchestratorError
+
+logger = structlog.get_logger("nonoka_cli.shell")
+
+PROMPT = "nonoka> "
+
+
+class REPL:
+  """Interactive REPL for nonoka-cli.
+
+  Features:
+  - Read user input line by line
+  - Route /-prefixed commands to handlers
+  - Pass plain text to orchestrator for Agent execution
+  - Handle Ctrl+C (interrupt) and Ctrl+D (exit)
+  """
+
+  def __init__(
+    self,
+    orchestrator: Orchestrator,
+    renderer: Renderer | None = None,
+  ):
+    self._orchestrator = orchestrator
+    self._renderer = renderer or Renderer()
+    self._running = False
+    self._current_task: asyncio.Task | None = None
+
+  async def run(self) -> None:
+    """Start the REPL main loop.
+
+    Reads from stdin, dispatches commands, and executes prompts
+    via the orchestrator until the user exits.
+    """
+    self._running = True
+    logger.info("repl_started")
+
+    while self._running:
+      try:
+        user_input = await self._read_input()
+      except EOFError:
+        self._running = False
+        print("\nGoodbye!")
+        break
+      except KeyboardInterrupt:
+        print("\n")
+        continue
+
+      if not user_input:
+        continue
+
+      if user_input.startswith("/"):
+        await self._handle_command(user_input)
+      else:
+        await self._handle_prompt(user_input)
+
+    logger.info("repl_stopped")
+
+  async def _read_input(self) -> str:
+    """Read a line of input from stdin asynchronously.
+
+    Returns:
+      Stripped user input string.
+
+    Raises:
+      EOFError: On Ctrl+D (empty read).
+    """
+    loop = asyncio.get_event_loop()
+    # Use loop.run_in_executor so input() does not block the event loop
+    raw = await loop.run_in_executor(None, input, PROMPT)
+    if raw is None:
+      raise EOFError()
+    return raw.strip()
+
+  async def _handle_command(self, raw: str) -> None:
+    """Handle a /-prefixed CLI command.
+
+    Args:
+      raw: The full command string (e.g. "/exit").
+    """
+    parts = raw[1:].split()
+    if not parts:
+      return
+
+    cmd = parts[0].lower()
+    args = parts[1:]
+
+    match cmd:
+      case "exit" | "quit":
+        self._running = False
+        print("Goodbye!")
+
+      case "new":
+        session_id = self._orchestrator.new_session()
+        print(f"New session: {session_id}")
+
+      case "help":
+        self._print_help()
+
+      case _:
+        print(f"Unknown command: /{cmd}. Type /help for available commands.")
+
+  async def _handle_prompt(self, prompt: str) -> None:
+    """Execute a plain-text prompt through the orchestrator.
+
+    Args:
+      prompt: User's natural language input.
+    """
+    try:
+      stream = self._orchestrator.execute(prompt)
+      self._current_task = asyncio.create_task(
+        self._renderer.render_stream(stream)
+      )
+      await self._current_task
+    except asyncio.CancelledError:
+      print("\n[Cancelled]")
+    except OrchestratorError as exc:
+      print(f"\n[Error] {exc}")
+    except CLIError as exc:
+      print(f"\n[Error] {exc}")
+    except Exception as exc:
+      logger.error("unexpected_error", error=str(exc))
+      print(f"\n[Unexpected Error] {exc}")
+    finally:
+      self._current_task = None
+
+  def _print_help(self) -> None:
+    """Print available commands."""
+    print("""
+Available commands:
+  /exit         Exit the CLI
+  /new          Start a new session
+  /help         Show this help message
+
+Any other text is sent to the AI assistant.
+""")
+
+  async def interrupt(self) -> None:
+    """Interrupt the current execution (called on Ctrl+C).
+
+    Cancels the running render task and clears output.
+    """
+    if self._current_task and not self._current_task.done():
+      self._current_task.cancel()
+      self._renderer.clear_current_output()
+      try:
+        await self._current_task
+      except asyncio.CancelledError:
+        pass
+      print("\n[Cancelled]")

nonoka_cli/ui/__init__.py

@@ -0,0 +1,5 @@
+"""UI / rendering layer for nonoka-cli."""
+
+from nonoka_cli.ui.renderer import Renderer
+
+__all__ = ["Renderer"]

nonoka_cli/ui/renderer.py

@@ -0,0 +1,78 @@
+"""Basic text renderer — streams nonoka StreamEvent to the terminal.
+
+TODO: Add Markdown rendering, code highlighting, tool cards, stats panel.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import AsyncIterator
+
+from nonoka.core.runner import StreamEvent
+
+
+class Renderer:
+  """Renders nonoka StreamEvent stream to the terminal.
+
+  Implements minimal text streaming:
+  - content_delta: print incremental text
+  - tool_call_start / tool_call_result: print simple indicators
+  - error: print error message
+  - final: newline after response
+  """
+
+  def __init__(self, file: object | None = None):
+    """Args:
+      file: Output stream (default: sys.stdout).
+    """
+    self._file = file or sys.stdout
+    self._in_tool_call = False
+
+  async def render_stream(self, stream: AsyncIterator[StreamEvent]) -> None:
+    """Consume a StreamEvent async iterator and render to terminal.
+
+    Args:
+      stream: AsyncIterator of StreamEvent from nonoka Runner.
+    """
+    async for event in stream:
+      self._render_event(event)
+
+  def _render_event(self, event: StreamEvent) -> None:
+    """Render a single StreamEvent."""
+    match event.type:
+      case "content_delta":
+        content = event.data.get("content", "")
+        if content:
+          self._file.write(content)
+          self._file.flush()
+
+      case "tool_call_start":
+        self._in_tool_call = True
+        tool_calls = event.data.get("tool_calls", [])
+        names = [tc.get("name", "unknown") for tc in tool_calls]
+        self._file.write(f"\n[Tool: {', '.join(names)}]\n")
+        self._file.flush()
+
+      case "tool_call_result":
+        self._in_tool_call = False
+        result = event.data.get("result")
+        if isinstance(result, dict) and "error" in result:
+          self._file.write(f"[Tool error: {result['error']}]\n")
+        else:
+          self._file.write("[Tool done]\n")
+        self._file.flush()
+
+      case "error":
+        error_msg = event.data.get("error", "Unknown error")
+        error_type = event.data.get("error_type", "error")
+        self._file.write(f"\n[{error_type.upper()}] {error_msg}\n")
+        self._file.flush()
+
+      case "final":
+        if not self._in_tool_call:
+          self._file.write("\n")
+          self._file.flush()
+
+  def clear_current_output(self) -> None:
+    """Clear current output area (no-op for basic renderer)."""
+    pass

nonoka_cli/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for nonoka-cli."""

nonoka_cli/utils/errors.py

@@ -0,0 +1,28 @@
+"""Custom exceptions for nonoka-cli."""
+
+from __future__ import annotations
+
+
+class CLIError(Exception):
+  """Base exception for all CLI errors."""
+  pass
+
+
+class ConfigError(CLIError):
+  """Configuration loading or validation failed."""
+  pass
+
+
+class ConfigNotFoundError(ConfigError):
+  """Configuration file not found."""
+  pass
+
+
+class AgentBuildError(CLIError):
+  """Failed to build Agent from configuration."""
+  pass
+
+
+class OrchestratorError(CLIError):
+  """Orchestrator execution error."""
+  pass

nonoka_cli/utils/logging.py

@@ -0,0 +1,75 @@
+"""Logging configuration for nonoka-cli using structlog."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+import structlog
+
+
+def setup_logging(
+  level: int = logging.INFO,
+  log_file: Path | None = None,
+  console: bool = False,
+) -> structlog.stdlib.BoundLogger:
+  """Configure structlog for nonoka-cli.
+
+  Args:
+    level: Logging level (default: INFO).
+    log_file: Path to log file. If None, defaults to
+      ~/.local/share/nonoka/logs/nonoka-cli.log.
+    console: Whether to also output logs to stderr.
+
+  Returns:
+    A configured structlog logger.
+  """
+  # Default log file path
+  if log_file is None:
+    log_file = Path.home() / ".local" / "share" / "nonoka" / "logs" / "nonoka-cli.log"
+
+  # Ensure log directory exists
+  log_file.parent.mkdir(parents=True, exist_ok=True)
+
+  shared_processors = [
+    structlog.stdlib.filter_by_level,
+    structlog.stdlib.add_logger_name,
+    structlog.stdlib.add_log_level,
+    structlog.processors.TimeStamper(fmt="iso"),
+    structlog.processors.StackInfoRenderer(),
+    structlog.processors.format_exc_info,
+  ]
+
+  handlers: list[logging.Handler] = [
+    logging.FileHandler(log_file, encoding="utf-8"),
+  ]
+
+  if console:
+    handlers.append(logging.StreamHandler(sys.stderr))
+
+  logging.basicConfig(
+    format="%(message)s",
+    level=level,
+    handlers=handlers,
+  )
+
+  structlog.configure(
+    processors=shared_processors + [
+      structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+    ],
+    context_class=dict,
+    logger_factory=structlog.stdlib.LoggerFactory(),
+    wrapper_class=structlog.stdlib.BoundLogger,
+    cache_logger_on_first_use=True,
+  )
+
+  # Configure formatter for stdlib handlers
+  formatter = structlog.stdlib.ProcessorFormatter(
+    processor=structlog.dev.ConsoleRenderer(colors=console),
+    foreign_pre_chain=shared_processors,
+  )
+  for handler in handlers:
+    handler.setFormatter(formatter)
+
+  return structlog.get_logger("nonoka_cli")

nonoka_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: nonoka-cli
+Version: 0.1.0
+Summary: Terminal frontend for the Nonoka Agent framework
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+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
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Requires-Dist: nonoka>=1.1.7
+Requires-Dist: rich>=13.0.0
+Requires-Dist: structlog>=24.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# nonoka-cli
+
+Terminal frontend for the [Nonoka](https://pypi.org/project/nonoka) Agent framework.
+
+## Quick Start
+
+```bash
+# Install
+pip install nonoka-cli
+
+# Start interactive REPL
+nonoka-cli
+
+# With custom config
+nonoka-cli --config ~/.config/nonoka/config.yaml
+
+# Override model
+nonoka-cli --model gpt-4o
+```
+
+## Configuration
+
+Create `~/.config/nonoka/config.yaml`:
+
+```yaml
+model: "gpt-4o"
+system_prompt: |
+  You are a helpful AI assistant.
+```
+
+## Commands
+
+- `/exit` — Quit the CLI
+- `/new` — Start a new session
+- `/help` — Show help
+
+## Development
+
+```bash
+# Setup
+uv venv
+uv pip install -e ".[dev]"
+
+# Run tests
+pytest
+```

nonoka_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+nonoka_cli/__init__.py,sha256=bWtxzZxy-h9XeGsGBQ4-CMXhbjiMwQkotjDpnaGnzyU,130
+nonoka_cli/__main__.py,sha256=Xa46NPUKiCdUSR0GUnJY9HtEt5RXXheOwam96pX3_N4,159
+nonoka_cli/cli.py,sha256=oxKAopJt9tzxUJ2qJ2l163OYrm9CyRBH2xB2FwXhPuw,3163
+nonoka_cli/config/__init__.py,sha256=CQ1ti5x1HKsIG00lyx7KedmAGiibbzirAL_YbSpOP3k,262
+nonoka_cli/config/loader.py,sha256=3OSW3OIOP5l7SbXYKFLarzrRNuhJcu32O3buMudZeHk,3747
+nonoka_cli/config/models.py,sha256=Q-tcG94zFgWIk0vJ5ikSVnEhcILMVS-pDa-AJa5NrpU,1472
+nonoka_cli/core/__init__.py,sha256=cHCJXJHqQ12GV2P3kVhSXvgIjcTbQ2pDsH-G1dsGy7M,298
+nonoka_cli/core/agent_factory.py,sha256=TjsnNEEySegVQ17eKzHgREaXqRzhetpjXdo1XNe_epI,1996
+nonoka_cli/core/context.py,sha256=Ti81oHE0FjaUp32X_3h7OX1Z8iM64Iy7fi4Gidz052Q,357
+nonoka_cli/core/orchestrator.py,sha256=CV7sppeuqR-f24v4CZlF-gjBXX5LJMsIZlwzJEW0FE4,4105
+nonoka_cli/shell/__init__.py,sha256=8ytQyy-XtRw6-45WFMVpCevjADUDBmXVmDkAn5Qn2BQ,101
+nonoka_cli/shell/repl.py,sha256=3CceBY2arH9J5i6SdINmJeOUVlQWBFq40o-fothv-L0,4173
+nonoka_cli/ui/__init__.py,sha256=fcxR0JTtkc0LBIMrN9kAchfw7UJ4zYaAfLTE_3gMYG8,112
+nonoka_cli/ui/renderer.py,sha256=5FEQaG75JjNtUSNVwkDx7ELxX2b_d3du8RmzMzRBooo,2389
+nonoka_cli/utils/__init__.py,sha256=mGxMnE0iPLieZWXRJAv1hJEoSOkA51lzv6M3tZtel6Q,38
+nonoka_cli/utils/errors.py,sha256=zuVmKqbyf5jVnOJ0map-AGUMfOX4fZWM8xzsVGC16L0,506
+nonoka_cli/utils/logging.py,sha256=dSSaOpnuWt3SMBeao69z6wMin6wGvFCC83CfuGD85_U,1972
+nonoka_cli-0.1.0.dist-info/METADATA,sha256=ch_1NxyysF109_K9R36Apontxmu4o73g_KH_xYKrjvY,1480
+nonoka_cli-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+nonoka_cli-0.1.0.dist-info/entry_points.txt,sha256=laiysCgrJzjJNv7s_-puse-hfAng0lD9skaT-YPG8Ag,51
+nonoka_cli-0.1.0.dist-info/RECORD,,

nonoka_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

nonoka_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nonoka-cli = nonoka_cli.cli:main