nonoka-cli 0.1.0__tar.gz

nonoka_cli-0.1.0/.gitignore

@@ -0,0 +1,49 @@
+# IDE / Editor
+self-files/
+.claude/
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Environment
+.env
+.venv/
+venv/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log

nonoka_cli-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,46 @@
+# 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/config.yaml.example

@@ -0,0 +1,40 @@
+# nonoka-cli configuration example — Deepseek API
+# Copy to ~/.config/nonoka/config.yaml to use
+
+model: "deepseek-chat"
+
+system_prompt: |
+  You are nonoka, a helpful AI assistant running in a terminal.
+  Be concise but thorough in your responses.
+
+# TODO: MCP server configuration (enabled in Phase 5)
+# mcp_servers:
+#   filesystem:
+#     transport: stdio
+#     command: npx
+#     args:
+#       - "-y"
+#       - "@modelcontextprotocol/server-filesystem"
+#       - "~"
+
+# TODO: Local tool scan paths (enabled in Phase 6)
+# tool_paths:
+#   - ~/.config/nonoka/tools/
+
+# TODO: Enabled skills (enabled in Phase 6)
+# skills:
+#   - code-review
+
+cli:
+  theme: dark
+  auto_approve: false
+  editor: "${EDITOR:-nano}"
+  max_history: 1000
+
+hitl:
+  policy: interactive
+  dangerous_tools:
+    - write_file
+    - edit_file
+    - delete_file
+    - execute_command

nonoka_cli-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "nonoka-cli"
+version = "0.1.0"
+description = "Terminal frontend for the Nonoka Agent framework"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+  "nonoka>=1.1.7",
+  "rich>=13.0.0",
+  "structlog>=24.0.0",
+]
+
+[project.scripts]
+nonoka-cli = "nonoka_cli.cli:main"
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0.0",
+  "pytest-asyncio>=0.23.0",
+  "pytest-cov>=5.0.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/nonoka_cli"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+addopts = "-v --tb=short"
+
+[tool.coverage.run]
+source = ["src/nonoka_cli"]
+
+[tool.ruff]
+line-length = 100
+select = ["E", "F", "W", "I"]

nonoka_cli-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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