@kuandotdev/indicator 0.1.1 → 0.1.3

package/project/src/tv_indicator/mcp/agent_server.py

@@ -0,0 +1,398 @@
+"""MCP server: agent documentation + protected market-analysis prompt management.
+
+Tools:
+  list_skills                  — list project skills and descriptions
+  read_agent_docs              — read docs/agent-skill-directory.md
+  read_install_docs            — read docs/agent-install.md
+  get_prompt_status            — return active prompt metadata without prompt text
+  prompt write tools           — enabled only with TV_AGENT_ENABLE_PROMPT_WRITE=1
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from ..config import PROJECT_ROOT
+
+server = Server("training-view-agent")
+
+PROMPT_DIR = PROJECT_ROOT / "skills" / "system-prompt-injection"
+DEFAULT_PROMPT = PROMPT_DIR / "DEFAULT_SYSTEM_PROMPT.md"
+CUSTOM_PROMPT = PROMPT_DIR / "CUSTOM_SYSTEM_PROMPT.md"
+AGENT_DOCS = PROJECT_ROOT / "docs" / "agent-skill-directory.md"
+AGENT_INSTALL_DOCS = PROJECT_ROOT / "docs" / "agent-install.md"
+INSTALLER = PROJECT_ROOT / "tools" / "install_skills.sh"
+SKILLS_DIR = PROJECT_ROOT / "skills"
+PROMPT_WRITE_ENV = "TV_AGENT_ENABLE_PROMPT_WRITE"
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    tools = [
+        Tool(
+            name="list_skills",
+            description="List available project skill capabilities without internal file paths or prompt text.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="read_agent_docs",
+            description="Read the public agent capability directory. Internal design and prompt text are redacted.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="read_install_docs",
+            description="Read public installation guidance. Internal installer design is redacted.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="get_prompt_status",
+            description="Return protected active market prompt metadata. Does not return prompt contents.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+    ]
+
+    if _prompt_write_enabled():
+        tools.extend(
+            [
+                Tool(
+                    name="init_custom_stock_prompt",
+                    description="Create CUSTOM_SYSTEM_PROMPT.md from DEFAULT_SYSTEM_PROMPT.md if custom is missing or empty.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "apply": {"type": "boolean", "default": True},
+                        },
+                    },
+                ),
+                Tool(
+                    name="set_custom_stock_prompt",
+                    description="Replace CUSTOM_SYSTEM_PROMPT.md with provided text and optionally apply it to startup/context files.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "content": {"type": "string"},
+                            "apply": {"type": "boolean", "default": True},
+                        },
+                        "required": ["content"],
+                    },
+                ),
+                Tool(
+                    name="append_custom_stock_prompt",
+                    description="Append text to CUSTOM_SYSTEM_PROMPT.md and optionally apply it to startup/context files.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "content": {"type": "string"},
+                            "heading": {"type": "string", "description": "Optional markdown heading for the appended block"},
+                            "apply": {"type": "boolean", "default": True},
+                        },
+                        "required": ["content"],
+                    },
+                ),
+                Tool(
+                    name="reset_custom_stock_prompt",
+                    description="Remove CUSTOM_SYSTEM_PROMPT.md and apply the read-only default prompt.",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "apply": {"type": "boolean", "default": True},
+                        },
+                    },
+                ),
+                Tool(
+                    name="apply_stock_prompt",
+                    description="Regenerate Pi/Codex/Claude/Gemini/Cursor startup/context files from the active prompt.",
+                    inputSchema={"type": "object", "properties": {}},
+                ),
+            ]
+        )
+    return tools
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    try:
+        if name == "list_skills":
+            return _json(_list_skills())
+        if name == "read_agent_docs":
+            return _text(_public_agent_docs())
+        if name == "read_install_docs":
+            return _text(_public_install_docs())
+        if name == "get_prompt_status":
+            return _json(_prompt_status())
+        if name == "init_custom_stock_prompt":
+            _require_prompt_write_enabled()
+            payload = await asyncio.to_thread(_init_custom, arguments.get("apply", True))
+            return _json(payload)
+        if name == "set_custom_stock_prompt":
+            _require_prompt_write_enabled()
+            payload = await asyncio.to_thread(
+                _set_custom, arguments["content"], arguments.get("apply", True)
+            )
+            return _json(payload)
+        if name == "append_custom_stock_prompt":
+            _require_prompt_write_enabled()
+            payload = await asyncio.to_thread(
+                _append_custom,
+                arguments["content"],
+                arguments.get("heading"),
+                arguments.get("apply", True),
+            )
+            return _json(payload)
+        if name == "reset_custom_stock_prompt":
+            _require_prompt_write_enabled()
+            payload = await asyncio.to_thread(_reset_custom, arguments.get("apply", True))
+            return _json(payload)
+        if name == "apply_stock_prompt":
+            _require_prompt_write_enabled()
+            payload = await asyncio.to_thread(_apply)
+            return _json(payload)
+    except Exception as e:
+        return _json({"ok": False, "error": str(e)})
+    return _text(f"Unknown tool: {name}")
+
+
+def _json(payload: Any) -> list[TextContent]:
+    return [TextContent(type="text", text=json.dumps(payload, default=str, ensure_ascii=False))]
+
+
+def _text(text: str) -> list[TextContent]:
+    return [TextContent(type="text", text=text)]
+
+
+def _read_required(path: Path) -> str:
+    if not path.exists():
+        raise FileNotFoundError(path)
+    return path.read_text(encoding="utf-8")
+
+
+def _active_prompt_path() -> Path:
+    if CUSTOM_PROMPT.exists() and CUSTOM_PROMPT.stat().st_size > 0:
+        return CUSTOM_PROMPT
+    return DEFAULT_PROMPT
+
+
+def _prompt_write_enabled() -> bool:
+    value = os.environ.get(PROMPT_WRITE_ENV, "")
+    return value.lower() in {"1", "true", "yes", "on"}
+
+
+def _require_prompt_write_enabled() -> None:
+    if not _prompt_write_enabled():
+        raise PermissionError(
+            f"Prompt write tools are disabled. Set {PROMPT_WRITE_ENV}=1 in the MCP server environment for local development."
+        )
+
+
+def _prompt_status() -> dict[str, Any]:
+    source = _active_prompt_path()
+    content = _read_required(source)
+    digest = hashlib.sha256(content.encode("utf-8")).hexdigest()
+    return {
+        "ok": True,
+        "active": "custom" if source == CUSTOM_PROMPT else "default",
+        "configured": True,
+        "bytes": len(content.encode("utf-8")),
+        "sha256": digest,
+        "content_protected": True,
+        "prompt_write_enabled": _prompt_write_enabled(),
+        "message": "Prompt contents are protected and are not returned by MCP. Use high-level capability docs or enable prompt write tools explicitly for local development.",
+    }
+
+
+def _parse_frontmatter(text: str) -> dict[str, str]:
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---\n", 4)
+    if end < 0:
+        return {}
+    block = text[4:end]
+    data: dict[str, str] = {}
+    current_key: str | None = None
+    for line in block.splitlines():
+        if re.match(r"^[A-Za-z0-9_-]+:\s*", line):
+            key, value = line.split(":", 1)
+            current_key = key.strip()
+            data[current_key] = value.strip().strip('"')
+        elif current_key and line.startswith(" "):
+            data[current_key] += " " + line.strip().strip('"')
+    return data
+
+
+def _list_skills() -> dict[str, Any]:
+    skills = []
+    for skill_file in sorted(SKILLS_DIR.glob("*/SKILL.md")):
+        text = skill_file.read_text(encoding="utf-8")
+        fm = _parse_frontmatter(text)
+        skills.append(
+            {
+                "name": fm.get("name", skill_file.parent.name),
+                "description": fm.get("description", ""),
+            }
+        )
+    return {
+        "skills": skills,
+        "docs": "Use read_agent_docs for public capability guidance. Internal file paths are protected.",
+        "prompt": _prompt_status(),
+    }
+
+
+def _public_agent_docs() -> str:
+    return """# TradingView Toolkit Agent Capabilities
+
+This public MCP document lists what the agent can do, not how the toolkit is implemented.
+Protected content is not exposed here: system/developer prompts, generated startup context,
+skill source text, MCP source, package extension implementation details, installer internals,
+model source/architecture, browser session data, cookies, and API keys.
+
+## Capabilities
+
+- Resolve TradingView symbols for stocks, ETFs, listed funds, indexes, crypto, forex, futures, and other supported symbols.
+- Fetch current market state and OHLCV history.
+- Analyze PineScript-compatible technical indicators. MACD is the default unless the user asks for another indicator.
+- Run the server-side stock/ETF/index forecast workflow when applicable and available.
+- Skip the stock model for crypto, forex, futures, commodities, and perpetual pairs unless explicitly asked to test it.
+- Fetch recent online news when available and combine it with technicals, fundamentals, asset metrics, and model output when applicable.
+- Produce the configured market-analysis report format with an agent-evaluated Rating, Buy score, and Sell score.
+- Store user-provided optional API/session values safely when the credential-storage workflow is explicitly requested.
+
+## Public MCP Tools
+
+- training-view-data: market data, symbol search, screener, model forecast, and raw TradingView technical rating when explicitly requested.
+- training-view-browser: TradingView browser/session checks and PineScript push workflows.
+- training-view-agent: public capability docs, install guidance, and protected prompt status.
+
+## Prompt Protection
+
+Prompt status is available through get_prompt_status, but prompt text is intentionally not returned.
+Prompt write tools are disabled by default and require an explicit local-development environment flag.
+"""
+
+
+def _public_install_docs() -> str:
+    return """# TradingView Toolkit Installation
+
+Use the public install commands from the project root:
+
+```bash
+make install
+make agent-import PLATFORM=auto
+```
+
+Reinstall only when explicitly needed:
+
+```bash
+FORCE_INSTALL=1 make install
+make agent-import PLATFORM=auto
+```
+
+Optional API/session prompts are skipped by default. Prompt text, installer internals,
+generated startup context, and package-extension implementation details are protected
+and are not exposed through MCP.
+"""
+
+
+def _run_installer() -> dict[str, Any]:
+    if not INSTALLER.exists():
+        raise FileNotFoundError(INSTALLER)
+    proc = subprocess.run(
+        ["bash", str(INSTALLER)],
+        cwd=PROJECT_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    return {
+        "returncode": proc.returncode,
+        "stdout": proc.stdout,
+        "stderr": proc.stderr,
+    }
+
+
+def _apply() -> dict[str, Any]:
+    result = _run_installer()
+    return {
+        "ok": result["returncode"] == 0,
+        "prompt": _prompt_status(),
+        "installer": result,
+    }
+
+
+def _init_custom(apply: bool = True) -> dict[str, Any]:
+    _read_required(DEFAULT_PROMPT)
+    created = False
+    if not CUSTOM_PROMPT.exists() or CUSTOM_PROMPT.stat().st_size == 0:
+        CUSTOM_PROMPT.write_text(DEFAULT_PROMPT.read_text(encoding="utf-8"), encoding="utf-8")
+        created = True
+    payload: dict[str, Any] = {
+        "ok": True,
+        "created": created,
+        "custom_prompt": str(CUSTOM_PROMPT.relative_to(PROJECT_ROOT)),
+    }
+    if apply:
+        payload["apply"] = _apply()
+    return payload
+
+
+def _set_custom(content: str, apply: bool = True) -> dict[str, Any]:
+    CUSTOM_PROMPT.write_text(content.rstrip() + "\n", encoding="utf-8")
+    payload: dict[str, Any] = {
+        "ok": True,
+        "custom_prompt": str(CUSTOM_PROMPT.relative_to(PROJECT_ROOT)),
+        "bytes": CUSTOM_PROMPT.stat().st_size,
+    }
+    if apply:
+        payload["apply"] = _apply()
+    return payload
+
+
+def _append_custom(content: str, heading: str | None = None, apply: bool = True) -> dict[str, Any]:
+    _init_custom(apply=False)
+    block = "\n\n"
+    if heading:
+        block += f"## {heading.strip()}\n\n"
+    block += content.rstrip() + "\n"
+    with CUSTOM_PROMPT.open("a", encoding="utf-8") as f:
+        f.write(block)
+    payload: dict[str, Any] = {
+        "ok": True,
+        "custom_prompt": str(CUSTOM_PROMPT.relative_to(PROJECT_ROOT)),
+        "bytes": CUSTOM_PROMPT.stat().st_size,
+    }
+    if apply:
+        payload["apply"] = _apply()
+    return payload
+
+
+def _reset_custom(apply: bool = True) -> dict[str, Any]:
+    existed = CUSTOM_PROMPT.exists()
+    CUSTOM_PROMPT.unlink(missing_ok=True)
+    payload: dict[str, Any] = {"ok": True, "removed_custom": existed}
+    if apply:
+        payload["apply"] = _apply()
+    return payload
+
+
+async def _run() -> None:
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream, write_stream, server.create_initialization_options()
+        )
+
+
+def main() -> None:
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main()

package/project/src/tv_indicator/mcp/browser_server.py

@@ -0,0 +1,133 @@
+"""MCP server: TradingView browser automation.
+
+Tools:
+  session_check       — verify the saved profile / cookie is still logged in
+  push_script         — paste a .pine file into TV's Pine Editor, save, optionally apply + screenshot
+  screenshot_chart    — open a chart, optionally change symbol, save a screenshot
+
+Register in claude_desktop_config.json:
+    {
+      "mcpServers": {
+        "training-view-browser": {
+          "command": "training-view-mcp-browser",
+          "env": {
+            "TV_SESSIONID": "...",
+            "TV_BROWSER_HEADLESS": "true"
+          }
+        }
+      }
+    }
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+server = Server("training-view-browser")
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    return [
+        Tool(
+            name="session_check",
+            description="Verify that the saved Playwright profile / session cookie can log into TradingView.",
+            inputSchema={"type": "object", "properties": {}},
+        ),
+        Tool(
+            name="push_script",
+            description=(
+                "Open TradingView, paste a .pine script into the Pine Editor, save it, "
+                "optionally apply it to a symbol's chart, and optionally screenshot. "
+                "Requires the user to be already logged in (session cookie or `training-view browser login` once)."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "script_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the .pine file",
+                    },
+                    "apply_to": {
+                        "type": "string",
+                        "description": "Optional symbol (e.g. 'NASDAQ:AAPL') to switch the chart to",
+                    },
+                    "screenshot": {"type": "boolean", "default": False},
+                    "script_name": {
+                        "type": "string",
+                        "description": "Name to save the script under in TradingView (default: filename)",
+                    },
+                },
+                "required": ["script_path"],
+            },
+        ),
+        Tool(
+            name="screenshot_chart",
+            description="Open a chart on TradingView and save a screenshot.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "symbol": {"type": "string"},
+                    "layout_url": {
+                        "type": "string",
+                        "description": "Full URL of a saved TV layout (overrides default)",
+                    },
+                    "out_path": {"type": "string", "description": "Where to save the PNG"},
+                },
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    if name == "session_check":
+        from ..browser.automation import session_check_async
+
+        r = await session_check_async()
+        return [TextContent(type="text", text=json.dumps(r, default=str))]
+
+    if name == "push_script":
+        from ..browser.automation import push_script_async
+
+        r = await push_script_async(
+            Path(arguments["script_path"]),
+            apply_to=arguments.get("apply_to"),
+            screenshot=arguments.get("screenshot", False),
+            script_name=arguments.get("script_name"),
+        )
+        return [TextContent(type="text", text=json.dumps(r, default=str))]
+
+    if name == "screenshot_chart":
+        from ..browser.automation import screenshot_chart_async
+
+        out = arguments.get("out_path")
+        path = await screenshot_chart_async(
+            symbol=arguments.get("symbol"),
+            layout_url=arguments.get("layout_url"),
+            out_path=Path(out) if out else None,
+        )
+        return [TextContent(type="text", text=json.dumps({"screenshot": str(path)}))]
+
+    return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+
+async def _run() -> None:
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream, write_stream, server.create_initialization_options()
+        )
+
+
+def main() -> None:
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main()