noah-code 0.1.0__py3-none-any.whl

noah_code/config.py

@@ -0,0 +1,279 @@
+"""Layered configuration for Noah Code."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+PermissionAction = Literal["allow", "ask", "deny"]
+
+
+class PermissionRule(BaseModel):
+    """Ordered permission rule; last match wins."""
+
+    category: str = "*"
+    pattern: str = "*"
+    action: PermissionAction = "ask"
+    reason: str = ""
+
+
+class TracingConfig(BaseModel):
+    enabled: bool = True
+    jsonl_dir: str | None = None
+    viewer: bool = True
+
+
+class SummarizationPolicy(BaseModel):
+    policy: Literal["token_budget", "none"] = "token_budget"
+    max_tokens: int | None = None
+    preserve_recent: int = 10
+    target_chars: int = 4000
+
+
+class UIConfig(BaseModel):
+    show_reasoning: bool = False
+    markdown: bool = True
+    stream_shell: bool = True
+    frontend: Literal["tui", "console"] = "tui"
+
+
+class UpdateConfig(BaseModel):
+    auto_install: bool = True
+    interval_hours: int = Field(default=24, ge=1, le=24 * 30)
+    check_timeout_seconds: float = Field(default=3.0, gt=0, le=30)
+
+
+class NoahCodeConfig(BaseModel):
+    """Resolved configuration for a noah-code run."""
+
+    model: str = "gpt-4o-mini"
+    lightweight_model: str | None = None
+    max_iterations: int = 40
+    cell_timeout: float = 120.0
+    command_timeout: float = 60.0
+    summarization: SummarizationPolicy = Field(default_factory=SummarizationPolicy)
+    tracing: TracingConfig = Field(default_factory=TracingConfig)
+    session_dir: Path = Field(
+        default_factory=lambda: Path.home() / ".local" / "share" / "noah-code" / "sessions"
+    )
+    permission_rules: list[PermissionRule] = Field(default_factory=list)
+    auto_approve: bool = False
+    enabled_skills: list[str] = Field(default_factory=list)
+    mcp: dict[str, Any] = Field(default_factory=dict)
+    ui: UIConfig = Field(default_factory=UIConfig)
+    updates: UpdateConfig = Field(default_factory=UpdateConfig)
+    mode: Literal["build", "plan"] = "build"
+    max_file_bytes: int = 512_000
+    max_output_chars: int = 80_000
+    undo_blob_limit: int = 2_000_000
+    unsafe_inprocess_code_execution: bool = False
+
+    @field_validator("session_dir", mode="before")
+    @classmethod
+    def _coerce_path(cls, value: Any) -> Path:
+        return (
+            Path(value).expanduser()
+            if value is not None
+            else Path.home() / ".local/share/noah-code/sessions"
+        )
+
+
+DEFAULT_PERMISSION_RULES: list[PermissionRule] = [
+    PermissionRule(category="read", pattern="*", action="allow", reason="reads allowed"),
+    PermissionRule(
+        category="read",
+        pattern="**/.env",
+        action="deny",
+        reason="secret env files denied",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/.env.*",
+        action="deny",
+        reason="secret env files denied",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/.env.example",
+        action="allow",
+        reason="example env files are safe",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/*.pem",
+        action="deny",
+        reason="private keys denied",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/*id_rsa*",
+        action="deny",
+        reason="private keys denied",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/.git/**",
+        action="deny",
+        reason=".git internals denied",
+    ),
+    PermissionRule(
+        category="read",
+        pattern="**/noah-code/**/*.db",
+        action="deny",
+        reason="session databases denied",
+    ),
+    PermissionRule(category="edit", pattern="*", action="ask", reason="edits require approval"),
+    PermissionRule(category="bash", pattern="*", action="ask", reason="shell requires approval"),
+    PermissionRule(
+        category="bash",
+        pattern="git push*",
+        action="deny",
+        reason="push denied by default",
+    ),
+    PermissionRule(
+        category="bash",
+        pattern="git clean*",
+        action="deny",
+        reason="destructive git clean denied",
+    ),
+    PermissionRule(
+        category="bash",
+        pattern="git reset --hard*",
+        action="deny",
+        reason="destructive git reset denied",
+    ),
+    PermissionRule(
+        category="external_directory",
+        pattern="*",
+        action="ask",
+        reason="external paths require approval",
+    ),
+    PermissionRule(category="task", pattern="*", action="ask", reason="subagents require approval"),
+    PermissionRule(category="skill", pattern="*", action="ask", reason="skills require approval"),
+    PermissionRule(category="mcp", pattern="*", action="ask", reason="MCP requires approval"),
+    PermissionRule(category="lsp", pattern="*", action="allow", reason="LSP read-only by default"),
+]
+
+
+def _user_config_path() -> Path:
+    return Path.home() / ".config" / "noah-code" / "config.toml"
+
+
+def _project_config_path(workspace: Path) -> Path:
+    return workspace / ".noah-code" / "config.toml"
+
+
+# Repository-controlled configuration must not be able to weaken the host's
+# trust boundary. These settings are accepted only from user config, the
+# environment, or explicit CLI overrides.
+_USER_ONLY_CONFIG_KEYS = frozenset(
+    {
+        "auto_approve",
+        "enabled_skills",
+        "mcp",
+        "permission_rules",
+        "session_dir",
+        "tracing",
+        "unsafe_inprocess_code_execution",
+        "updates",
+    }
+)
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if not path.is_file():
+        return {}
+    with path.open("rb") as fh:
+        data = tomllib.load(fh)
+    return data if isinstance(data, dict) else {}
+
+
+def _load_project_toml(path: Path) -> dict[str, Any]:
+    data = _load_toml(path)
+    return {key: value for key, value in data.items() if key not in _USER_ONLY_CONFIG_KEYS}
+
+
+def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    out = dict(base)
+    for key, value in override.items():
+        if key in out and isinstance(out[key], dict) and isinstance(value, dict):
+            out[key] = _deep_merge(out[key], value)
+        else:
+            out[key] = value
+    return out
+
+
+def _env_overrides() -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    if model := os.environ.get("NOAH_CODE_MODEL"):
+        out["model"] = model
+    if light := os.environ.get("NOAH_CODE_LIGHTWEIGHT_MODEL"):
+        out["lightweight_model"] = light
+    if auto := os.environ.get("NOAH_CODE_AUTO"):
+        out["auto_approve"] = auto.lower() in {"1", "true", "yes", "on"}
+    if session_dir := os.environ.get("NOAH_CODE_SESSION_DIR"):
+        out["session_dir"] = session_dir
+    if mode := os.environ.get("NOAH_CODE_MODE"):
+        out["mode"] = mode
+    if unsafe := os.environ.get("NOAH_CODE_UNSAFE_INPROCESS"):
+        out["unsafe_inprocess_code_execution"] = unsafe.lower() in {"1", "true", "yes", "on"}
+    if auto_update := os.environ.get("NOAH_CODE_AUTO_UPDATE"):
+        out["updates"] = {
+            "auto_install": auto_update.lower() in {"1", "true", "yes", "on"}
+        }
+    return out
+
+
+def _normalize_raw(raw: dict[str, Any]) -> dict[str, Any]:
+    data = dict(raw)
+    if "permission_rules" in data and isinstance(data["permission_rules"], list):
+        data["permission_rules"] = [
+            rule if isinstance(rule, PermissionRule) else PermissionRule.model_validate(rule)
+            for rule in data["permission_rules"]
+        ]
+    if "summarization" in data and isinstance(data["summarization"], dict):
+        data["summarization"] = SummarizationPolicy.model_validate(data["summarization"])
+    if "tracing" in data and isinstance(data["tracing"], dict):
+        data["tracing"] = TracingConfig.model_validate(data["tracing"])
+    if "ui" in data and isinstance(data["ui"], dict):
+        data["ui"] = UIConfig.model_validate(data["ui"])
+    if "updates" in data and isinstance(data["updates"], dict):
+        data["updates"] = UpdateConfig.model_validate(data["updates"])
+    return data
+
+
+def load_config(
+    workspace: Path,
+    *,
+    cli_overrides: dict[str, Any] | None = None,
+) -> NoahCodeConfig:
+    """Load config with precedence: defaults < user < project < env < CLI."""
+    merged: dict[str, Any] = {
+        "permission_rules": [r.model_dump() for r in DEFAULT_PERMISSION_RULES],
+    }
+    merged = _deep_merge(merged, _load_toml(_user_config_path()))
+    merged = _deep_merge(merged, _load_project_toml(_project_config_path(workspace)))
+    merged = _deep_merge(merged, _env_overrides())
+    if cli_overrides:
+        cleaned = {k: v for k, v in cli_overrides.items() if v is not None}
+        merged = _deep_merge(merged, cleaned)
+    return NoahCodeConfig.model_validate(_normalize_raw(merged))
+
+
+def config_sources(workspace: Path) -> dict[str, Path | None]:
+    """Return config file locations for diagnostics."""
+    user = _user_config_path()
+    project = _project_config_path(workspace)
+    return {
+        "user": user if user.is_file() else None,
+        "project": project if project.is_file() else None,
+    }

noah_code/custom_commands.py

@@ -0,0 +1,103 @@
+"""User and project markdown slash commands."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+_FRONTMATTER = re.compile(r"\A---\s*\n(.*?)\n---\s*\n(.*)\Z", re.DOTALL)
+
+
+@dataclass(frozen=True)
+class CustomCommand:
+    name: str
+    description: str
+    body: str
+    mode: str | None = None
+    model: str | None = None
+    source: str = ""
+
+    def render(self, arguments: str) -> str:
+        """Expand $ARGUMENTS and $1..$9 positional placeholders."""
+        parts = _split_args(arguments)
+        text = self.body
+        text = text.replace("$ARGUMENTS", arguments.strip())
+        for i, part in enumerate(parts, start=1):
+            text = text.replace(f"${i}", part)
+        # Clear unused numbered placeholders.
+        text = re.sub(r"\$[1-9]\b", "", text)
+        return text.strip()
+
+
+def _split_args(arguments: str) -> list[str]:
+    import shlex
+
+    try:
+        return shlex.split(arguments)
+    except ValueError:
+        return arguments.split()
+
+
+def _parse_frontmatter(raw: str) -> tuple[dict[str, Any], str]:
+    match = _FRONTMATTER.match(raw)
+    if not match:
+        return {}, raw
+    meta_raw, body = match.group(1), match.group(2)
+    meta: dict[str, Any] = {}
+    # Prefer YAML-like simple key: value lines; fall back to TOML table.
+    for line in meta_raw.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if ":" in line:
+            key, _, val = line.partition(":")
+            meta[key.strip()] = val.strip().strip("\"'")
+    if not meta:
+        try:
+            parsed = tomllib.loads(meta_raw)
+            if isinstance(parsed, dict):
+                meta = parsed
+        except Exception:  # noqa: BLE001
+            meta = {}
+    return meta, body
+
+
+def load_commands_from_dir(directory: Path, *, source: str) -> dict[str, CustomCommand]:
+    out: dict[str, CustomCommand] = {}
+    if not directory.is_dir():
+        return out
+    for path in sorted(directory.glob("*.md")):
+        name = path.stem.strip().lower().lstrip("/")
+        if not name or name.startswith("."):
+            continue
+        try:
+            raw = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        meta, body = _parse_frontmatter(raw)
+        out[name] = CustomCommand(
+            name=name,
+            description=str(meta.get("description") or name),
+            body=body,
+            mode=(str(meta["mode"]).lower() if meta.get("mode") else None),
+            model=str(meta["model"]) if meta.get("model") else None,
+            source=f"{source}:{path.name}",
+        )
+    return out
+
+
+def discover_custom_commands(workspace: Path) -> dict[str, CustomCommand]:
+    """Project commands override user commands with the same name."""
+    user_dir = Path.home() / ".config" / "noah-code" / "commands"
+    project_dir = workspace / ".noah-code" / "commands"
+    commands = load_commands_from_dir(user_dir, source="user")
+    commands.update(load_commands_from_dir(project_dir, source="project"))
+    return commands

noah_code/event_bridge.py

@@ -0,0 +1,132 @@
+"""Bridge NOOA EventManager events into HostEvent for UI streaming."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from noah_code.events import HostEvent, HostEventKind
+
+Unsubscribe = Callable[[], None]
+EmitFn = Callable[[HostEvent], None]
+
+
+def install_event_bridge(agent: Any, emit: EmitFn) -> list[Unsubscribe]:
+    """Subscribe to agent.event_manager and forward useful events to the UI.
+
+    Returns unsubscribe callables (call all on host close / session switch).
+    """
+    em = agent.event_manager
+    unsubs: list[Unsubscribe] = []
+
+    def on_tool_call(event: Any) -> None:
+        # Fresh ToolCallEvent has result=None; updates do not re-emit.
+        if getattr(event, "result", None) is not None:
+            return
+        name = getattr(event, "name", "tool")
+        args = getattr(event, "arguments", {}) or {}
+        preview = ""
+        if name == "execute_python":
+            code = str(args.get("code", ""))
+            preview = code.strip().splitlines()[0][:80] if code.strip() else ""
+            text = f"execute_python{(': ' + preview) if preview else ''}"
+        else:
+            text = f"{name}({_brief_args(args)})"
+        emit(HostEvent(HostEventKind.TOOL_START, text, meta={"tool": name}))
+
+    def on_python_output(event: Any) -> None:
+        status = str(getattr(event, "execution_status", "") or "")
+        err = (getattr(event, "error", "") or "").strip()
+        stdout = (getattr(event, "stdout", "") or "").strip()
+        stderr = (getattr(event, "stderr", "") or "").strip()
+        parts = [f"code cell {status}".strip()]
+        if err:
+            parts.append(err[:200])
+        elif stderr:
+            parts.append(stderr[:200])
+        elif stdout:
+            line = stdout.splitlines()[0][:80]
+            parts.append(line)
+        emit(
+            HostEvent(
+                HostEventKind.TOOL_FINISH,
+                " · ".join(p for p in parts if p),
+                meta={"kind": "python_output"},
+            )
+        )
+        # Stream truncated stdout/stderr as shell-like chunks when present.
+        if stdout and len(stdout) > 0:
+            emit(
+                HostEvent(
+                    HostEventKind.SHELL_CHUNK,
+                    _truncate(stdout, 4000),
+                    meta={"stream": "stdout", "source": "codeact"},
+                )
+            )
+        if stderr:
+            emit(
+                HostEvent(
+                    HostEventKind.SHELL_CHUNK,
+                    _truncate(stderr, 2000),
+                    meta={"stream": "stderr", "source": "codeact"},
+                )
+            )
+
+    def on_error(event: Any) -> None:
+        content = str(getattr(event, "content", event) or "")
+        if content:
+            emit(HostEvent(HostEventKind.ERROR, content))
+
+    def on_llm_start(event: Any) -> None:
+        method = getattr(event, "method_name", "")
+        turn = getattr(event, "turn_number", "")
+        emit(
+            HostEvent(
+                HostEventKind.STATUS,
+                f"llm · {method} turn {turn}",
+                meta={"kind": "llm_start"},
+            )
+        )
+
+    def on_llm_end(event: Any) -> None:
+        ok = getattr(event, "success", True)
+        emit(
+            HostEvent(
+                HostEventKind.STATUS,
+                f"llm · {'ok' if ok else 'failed'}",
+                meta={"kind": "llm_end"},
+            )
+        )
+
+    def on_summary(event: Any) -> None:
+        text = str(getattr(event, "content", "") or getattr(event, "summary", "") or "")
+        if text:
+            emit(HostEvent(HostEventKind.SUMMARY, _truncate(text, 2000)))
+
+    for etype, handler in (
+        ("ToolCallEvent", on_tool_call),
+        ("PythonOutput", on_python_output),
+        ("Error", on_error),
+        ("LLMCallStart", on_llm_start),
+        ("LLMCallEnd", on_llm_end),
+        ("Summary", on_summary),
+    ):
+        try:
+            unsubs.append(em.on(etype, handler))
+        except Exception:  # noqa: BLE001 - event type may be unregistered
+            continue
+
+    return unsubs
+
+
+def _brief_args(args: dict[str, Any]) -> str:
+    if not args:
+        return ""
+    keys = list(args.keys())[:3]
+    return ", ".join(f"{k}=…" for k in keys)
+
+
+def _truncate(text: str, limit: int) -> str:
+    if len(text) <= limit:
+        return text
+    return text[: limit // 2] + "\n…\n" + text[-(limit // 2) :]

noah_code/events.py

@@ -0,0 +1,27 @@
+"""Host-facing event types for UI rendering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class HostEventKind(StrEnum):
+    MESSAGE = "message"
+    REASONING = "reasoning"
+    TOOL_START = "tool_start"
+    TOOL_FINISH = "tool_finish"
+    SHELL_CHUNK = "shell_chunk"
+    ERROR = "error"
+    SUMMARY = "summary"
+    APPROVAL = "approval"
+    STATUS = "status"
+    STOP = "stop"
+
+
+@dataclass
+class HostEvent:
+    kind: HostEventKind
+    text: str = ""
+    meta: dict[str, Any] = field(default_factory=dict)