code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/namespace_skill_search/search_tool.py

@@ -0,0 +1,158 @@
+"""browse_skill_namespace — the on-demand discovery tool.
+
+This is the model-agnostic analog of OpenAI's `tool_search` (and
+Anthropic's Tool Search Tool): the model calls it when it needs a
+capability instead of scanning a flat list baked into the system prompt.
+Three modes, one tool, matching the three things a model actually needs
+to do at this scale:
+
+    browse_skill_namespace()                    -> list namespaces (directory)
+    browse_skill_namespace(namespace="Finance")  -> list skills in one namespace
+    browse_skill_namespace(query="variance")     -> keyword search, all namespaces
+
+No model-provider-specific `defer_loading` flag required — the reduction
+in upfront context comes from the `load_prompt` summary block (see
+namespaces.py) being a few lines per namespace instead of one line per
+skill. This tool is just the drill-down mechanism underneath it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import List, Optional
+
+from pydantic import BaseModel
+from pydantic_ai import RunContext
+
+from .namespaces import build_namespaces
+
+
+class NamespaceBrowseOutput(BaseModel):
+    """Uniform output for all three browse_skill_namespace modes."""
+
+    mode: str  # "directory" | "namespace" | "search"
+    namespaces: List[str] = []  # populated in "directory" mode
+    skills: List[dict] = []  # populated in "namespace"/"search" modes
+    total_skills: int = 0
+    error: Optional[str] = None
+
+
+def _skill_matches(skill_haystack: str, terms: List[str]) -> bool:
+    return any(term in skill_haystack for term in terms)
+
+
+def _query_terms(query: Optional[str]) -> List[str]:
+    """Split a query into lowercase terms.
+
+    A blank or whitespace-only query means "no filter", not "filter to
+    nothing" -- ``any(term in haystack for term in [])`` is ``False`` for
+    every skill, which would otherwise make ``query=""`` or
+    ``query="   "`` silently return zero results instead of the
+    unfiltered set the caller almost certainly intended.
+    """
+    if not query or not query.strip():
+        return []
+    return query.lower().split()
+
+
+def register_browse_skill_namespace(agent):
+    """Register the browse_skill_namespace tool on an agent."""
+
+    @agent.tool
+    async def browse_skill_namespace(
+        context: RunContext,
+        namespace: Optional[str] = None,
+        query: Optional[str] = None,
+    ) -> NamespaceBrowseOutput:
+        """Discover skills without loading all of them into context at once.
+
+        Call with no arguments first to see the namespace directory (a
+        short list of domains + counts). Then either drill into one
+        namespace by name, or keyword-search across every namespace at
+        once. Call activate_skill(name) on whatever you find.
+
+        Args:
+            namespace: Exact namespace name to list skills within.
+            query: Keyword(s) to search across name/description/tags.
+        """
+        # build_namespaces() performs blocking filesystem/frontmatter I/O; explicitly
+        # offload it because async pydantic-ai tools aren't auto-threaded.
+        try:
+            namespaces = await asyncio.to_thread(build_namespaces)
+        except Exception as exc:  # noqa: BLE001 - surface to the model, don't crash the turn
+            return NamespaceBrowseOutput(
+                mode="directory",
+                error=f"Failed to read skill catalog: {exc}",
+            )
+        total = sum(len(v) for v in namespaces.values())
+
+        if not namespaces:
+            return NamespaceBrowseOutput(
+                mode="directory",
+                error="No skills available (skills disabled or none installed).",
+            )
+
+        # Mode 1: directory listing (no args)
+        if namespace is None and query is None:
+            return NamespaceBrowseOutput(
+                mode="directory",
+                namespaces=sorted(namespaces.keys(), key=lambda n: -len(namespaces[n])),
+                total_skills=total,
+            )
+
+        # Mode 2: drill into a specific namespace
+        if namespace is not None:
+            matched_ns = next(
+                (n for n in namespaces if n.lower() == namespace.lower()), None
+            )
+            if matched_ns is None:
+                return NamespaceBrowseOutput(
+                    mode="namespace",
+                    error=(
+                        f"Namespace '{namespace}' not found. Call "
+                        "browse_skill_namespace() with no arguments to see "
+                        "valid namespace names."
+                    ),
+                )
+            skills = namespaces[matched_ns]
+            terms = _query_terms(query)
+            if terms:
+                skills = [
+                    s
+                    for s in skills
+                    if _skill_matches(
+                        f"{s.name} {s.description} {' '.join(s.tags)}".lower(),
+                        terms,
+                    )
+                ]
+            return NamespaceBrowseOutput(
+                mode="namespace",
+                skills=[
+                    {"name": s.name, "description": s.description, "tags": s.tags}
+                    for s in skills
+                ],
+                total_skills=len(skills),
+            )
+
+        # Mode 3 searches all namespaces; explicit blank query means "no filter",
+        # unlike omitted args, which select mode 1's directory listing.
+        terms = _query_terms(query)
+        results = [
+            {
+                "name": s.name,
+                "description": s.description,
+                "tags": s.tags,
+                "namespace": ns,
+            }
+            for ns, skills in namespaces.items()
+            for s in skills
+            if not terms
+            or _skill_matches(
+                f"{s.name} {s.description} {' '.join(s.tags)}".lower(), terms
+            )
+        ]
+        return NamespaceBrowseOutput(
+            mode="search", skills=results, total_skills=len(results)
+        )
+
+    return browse_skill_namespace

code_puppy_core_plugins/no_tools/register_callbacks.py

@@ -0,0 +1,42 @@
+"""``--no-tools`` CLI flag (issue #182).
+
+Lets wrappers run Code Puppy as a plain text-in/text-out subprocess:
+no tools registered on any agent, no MCP toolsets attached, and no tool
+schemas eating tokens in the request.
+
+Implementation is deliberately tiny: the flag just sets the
+``CODE_PUPPY_NO_TOOLS`` env var, and the core tool registry
+(``code_puppy.tools.tools_disabled``) honors it. Wrappers that can't pass
+CLI flags can set the env var directly — same effect, zero magic.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from code_puppy.callbacks import register_callback
+
+
+def _register_cli_args(parser: Any) -> None:
+    parser.add_argument(
+        "--no-tools",
+        action="store_true",
+        help=(
+            "Disable all agent tools and MCP servers for this run "
+            "(pure text-in/text-out; equivalent to CODE_PUPPY_NO_TOOLS=1)"
+        ),
+    )
+
+
+def _handle_cli_args(args: Any) -> Optional[dict]:
+    if getattr(args, "no_tools", False):
+        from code_puppy.tools import NO_TOOLS_ENV_VAR
+
+        os.environ[NO_TOOLS_ENV_VAR] = "1"
+    # Never short-circuit startup — this flag only flips the kill-switch.
+    return None
+
+
+register_callback("register_cli_args", _register_cli_args)
+register_callback("handle_cli_args", _handle_cli_args)

code_puppy_core_plugins/oauth_pasteback.py

@@ -0,0 +1,110 @@
+"""Helpers for OAuth flows that support terminal paste-back."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+
+
+@dataclass(frozen=True)
+class ParsedOAuthCallback:
+    """Parsed authorization result from a pasted callback URL or code."""
+
+    code: Optional[str] = None
+    state: Optional[str] = None
+    error: Optional[str] = None
+    error_description: Optional[str] = None
+
+    @property
+    def error_message(self) -> Optional[str]:
+        if not self.error:
+            return None
+        if self.error_description:
+            return f"{self.error}: {self.error_description}"
+        return self.error
+
+
+def _first(params: dict[str, list[str]], name: str) -> Optional[str]:
+    values = params.get(name)
+    if not values:
+        return None
+    value = values[0].strip()
+    return value or None
+
+
+def _looks_like_query(value: str) -> bool:
+    if value.startswith("?"):
+        return True
+    return "=" in value and (
+        "&" in value or value.startswith(("code=", "state=", "error="))
+    )
+
+
+def parse_oauth_callback_input(raw_input: str) -> ParsedOAuthCallback:
+    """Parse pasted OAuth input into code/state/error fields.
+
+    Supported inputs include full callback URLs, raw query strings, Claude's
+    ``code#state`` and ``code state`` console formats, and bare codes.
+    """
+    value = raw_input.strip()
+    if not value:
+        raise ValueError("Authorization code cannot be empty")
+
+    parsed_url = urlparse(value)
+    query = parsed_url.query
+    if query or _looks_like_query(value):
+        params = parse_qs(query or value.lstrip("?"), keep_blank_values=False)
+        result = ParsedOAuthCallback(
+            code=_first(params, "code"),
+            state=_first(params, "state"),
+            error=_first(params, "error"),
+            error_description=_first(params, "error_description"),
+        )
+        if result.code or result.error:
+            return result
+        raise ValueError("No authorization code found in pasted OAuth input")
+
+    if "#" in value:
+        code, state = value.split("#", 1)
+        code = code.strip()
+        state = state.strip() or None
+        if not code:
+            raise ValueError("Authorization code cannot be empty")
+        return ParsedOAuthCallback(code=code, state=state)
+
+    parts = value.split()
+    if len(parts) == 2:
+        return ParsedOAuthCallback(code=parts[0].strip(), state=parts[1].strip())
+    if len(parts) > 2:
+        raise ValueError("Pasted OAuth input has too many whitespace-separated parts")
+
+    return ParsedOAuthCallback(code=value)
+
+
+def read_available_stdin_line() -> Optional[str]:
+    """Return one stdin line when available without blocking.
+
+    The OAuth callback server can complete in parallel, so the auth flow must
+    not block indefinitely on input. This helper is intentionally POSIX-only;
+    Windows callers still retain browser callback behavior and explicit timeout.
+    """
+    if os.name == "nt":
+        return None
+
+    try:
+        import select
+
+        readable, _, _ = select.select([sys.stdin], [], [], 0)
+    except (OSError, ValueError):
+        return None
+
+    if not readable:
+        return None
+
+    line = sys.stdin.readline()
+    if line == "":
+        return None
+    return line.rstrip("\r\n")

code_puppy_core_plugins/oauth_puppy_html.py

@@ -0,0 +1,194 @@
+"""Small, self-contained HTML pages for browser-based OAuth callbacks."""
+
+from __future__ import annotations
+
+from html import escape
+from typing import Optional
+
+_PAGE_STYLES = """
+:root {
+  color-scheme: light dark;
+  --bg: #f5f3ef;
+  --card: rgba(255, 255, 255, 0.92);
+  --border: rgba(28, 25, 23, 0.10);
+  --text: #1c1917;
+  --muted: #6b645f;
+  --success: #16845b;
+  --success-soft: #e7f6ef;
+  --failure: #c2413a;
+  --failure-soft: #fcebea;
+  --shadow: 0 24px 70px rgba(41, 37, 36, 0.12);
+}
+* { box-sizing: border-box; }
+body {
+  min-height: 100vh;
+  margin: 0;
+  display: grid;
+  place-items: center;
+  padding: 24px;
+  background:
+    radial-gradient(circle at 20% 10%, rgba(249, 115, 22, 0.08), transparent 30%),
+    var(--bg);
+  color: var(--text);
+  font-family: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+.card {
+  width: min(100%, 480px);
+  padding: 40px;
+  border: 1px solid var(--border);
+  border-radius: 24px;
+  background: var(--card);
+  box-shadow: var(--shadow);
+  text-align: center;
+}
+.mark {
+  width: 64px;
+  height: 64px;
+  margin: 0 auto 24px;
+  display: grid;
+  place-items: center;
+  border-radius: 18px;
+  background: #1c1917;
+  color: #fff;
+  font-size: 30px;
+  box-shadow: 0 10px 24px rgba(28, 25, 23, 0.16);
+}
+.eyebrow {
+  margin: 0 0 10px;
+  color: var(--muted);
+  font-size: 13px;
+  font-weight: 700;
+  letter-spacing: 0.11em;
+  text-transform: uppercase;
+}
+h1 {
+  margin: 0;
+  font-size: clamp(28px, 6vw, 38px);
+  line-height: 1.12;
+  letter-spacing: -0.035em;
+}
+.message {
+  max-width: 370px;
+  margin: 16px auto 0;
+  color: var(--muted);
+  font-size: 16px;
+  line-height: 1.6;
+}
+.status {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 28px;
+  padding: 9px 13px;
+  border-radius: 999px;
+  font-size: 13px;
+  font-weight: 700;
+}
+.status::before {
+  content: "";
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: currentColor;
+}
+.success .status { color: var(--success); background: var(--success-soft); }
+.failure .status { color: var(--failure); background: var(--failure-soft); }
+.hint {
+  margin: 24px 0 0;
+  color: var(--muted);
+  font-size: 13px;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #121110;
+    --card: rgba(29, 27, 25, 0.94);
+    --border: rgba(255, 255, 255, 0.09);
+    --text: #f7f5f2;
+    --muted: #aaa39d;
+    --success: #73d5ad;
+    --success-soft: rgba(22, 132, 91, 0.18);
+    --failure: #f19a94;
+    --failure-soft: rgba(194, 65, 58, 0.18);
+    --shadow: 0 24px 70px rgba(0, 0, 0, 0.34);
+  }
+  .mark { background: #f7f5f2; color: #1c1917; }
+}
+@media (max-width: 520px) {
+  .card { padding: 32px 24px; border-radius: 20px; }
+}
+"""
+
+
+def oauth_success_html(service_name: str, extra_message: Optional[str] = None) -> str:
+    """Return a restrained success page for an OAuth callback."""
+    service = _clean(service_name, "OAuth")
+    message = _clean(
+        extra_message,
+        "Authentication is complete. You can return to Code Puppy.",
+    )
+    return _render_page(
+        service=service,
+        state="success",
+        title="You're connected",
+        message=message,
+        status="Authentication complete",
+        hint="This window can be closed safely.",
+        auto_close=True,
+    )
+
+
+def oauth_failure_html(service_name: str, reason: str) -> str:
+    """Return a clear, low-drama failure page for an OAuth callback."""
+    service = _clean(service_name, "OAuth")
+    message = _clean(reason, "Authentication could not be completed.")
+    return _render_page(
+        service=service,
+        state="failure",
+        title="Couldn't connect",
+        message=message,
+        status="Authentication incomplete",
+        hint="Return to Code Puppy and try signing in again.",
+    )
+
+
+def _clean(value: Optional[str], fallback: str) -> str:
+    """Normalize and HTML-escape dynamic page content."""
+    normalized = value.strip() if value else fallback
+    return escape(normalized or fallback)
+
+
+def _render_page(
+    *,
+    service: str,
+    state: str,
+    title: str,
+    message: str,
+    status: str,
+    hint: str,
+    auto_close: bool = False,
+) -> str:
+    """Build a complete OAuth result page without remote assets."""
+    close_script = (
+        "<script>setTimeout(() => window.close(), 3500);</script>" if auto_close else ""
+    )
+    return f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="robots" content="noindex, nofollow">
+  <title>{service} authentication</title>
+  <style>{_PAGE_STYLES}</style>
+</head>
+<body>
+  <main class="card {state}">
+    <div class="mark" aria-hidden="true">CP</div>
+    <p class="eyebrow">Code Puppy · {service}</p>
+    <h1>{title}</h1>
+    <p class="message">{message}</p>
+    <div class="status" role="status">{status}</div>
+    <p class="hint">{hint}</p>
+  </main>
+  {close_script}
+</body>
+</html>"""

code_puppy_core_plugins/obsidian_agent/README.md

@@ -0,0 +1,52 @@
+# Obsidian Agent
+
+The Obsidian Agent adds a specialized Code Puppy agent for working with Obsidian vaults through the official `obsidian` CLI.
+
+## What it does
+
+- Discovers vaults, notes, folders, links, tags, tasks, templates, and related Obsidian state.
+- Uses the Obsidian CLI for vault-aware operations instead of blindly editing files.
+- Follows a read-before-write workflow for note changes.
+- Requires explicit confirmation for destructive, broad, or hard-to-reverse operations.
+- Helps troubleshoot common CLI setup issues.
+
+## Requirements
+
+- Obsidian desktop 1.12.7 or newer.
+- Obsidian's command line interface enabled in Settings → General.
+- The Obsidian desktop app running, or available to be launched by the CLI.
+- The `obsidian` command available on `PATH`.
+
+Useful checks:
+
+```bash
+which obsidian
+obsidian version
+obsidian help
+obsidian vaults total verbose
+```
+
+## Usage
+
+Switch to the agent from Code Puppy and ask for an Obsidian task. Include a vault name or vault-relative path when relevant.
+
+Examples:
+
+- "Find notes about release planning in my work vault."
+- "Create a meeting note from my weekly meeting template."
+- "Append this task to today's daily note."
+- "Show unresolved links and propose a cleanup plan."
+
+For broad updates, the agent should present a plan and ask for confirmation before making changes. Tiny bureaucracy, but the useful kind.
+
+## Safety notes
+
+The agent intentionally avoids personal defaults. It does not include any user-specific vault names, local paths, or private note structure.
+
+It treats these as confirmation-required operations:
+
+- Permanent deletes, moves, and renames.
+- History or sync restores.
+- Publish changes.
+- Plugin, theme, snippet, sync, reload, restart, and developer/debug commands.
+- Arbitrary JavaScript evaluation.

code_puppy_core_plugins/obsidian_agent/__init__.py

@@ -0,0 +1,8 @@
+"""Obsidian Agent plugin.
+
+Registers a specialized agent for safe Obsidian CLI workflows.
+"""
+
+from .agent_obsidian import ObsidianAgent
+
+__all__ = ["ObsidianAgent"]