@kuandotdev/indicator 0.1.2 → 0.1.4

package/project/packages/indicator/src/cli.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const TOOL_NAME = "indicator";
+const DEFAULT_PLATFORM = "auto";
+
+function printHelp() {
+  console.log(`Indicator CLI
+
+Usage:
+  ${TOOL_NAME} <command> [options]
+
+Commands:
+  install                 Run Indicator installer
+  uninstall               Remove agent integrations or the full local install
+  doctor                  Run make doctor
+  status                  Show Indicator status
+  version                 Show Indicator version
+  check-skills            Verify generated agent skills/prompts
+  session-check           Verify TradingView browser session
+  search QUERY            Search TradingView symbols
+  model-status            Show server-side stock/ETF/index model status
+  model-forecast SYMBOL   Read/refresh a model forecast row
+  ohlcv SYMBOL            Fetch TradingView OHLCV data
+  rating SYMBOL           Fetch raw TradingView technical rating
+  agent-import            Import MCP/skills for agent platforms
+  agent-uninstall         Remove MCP registrations for agent platforms
+  cli ...args             Run the underlying training-view CLI through conda
+
+Install options:
+  --force                 Set FORCE_INSTALL=1
+  --skip-wizard           Set TV_INDICATOR_SETUP=0
+  --platform <name>       auto | all | pi | claude-code | codex | gemini | cursor
+  --language <code>       en | zhtw | zhcn | ...
+  --prompt-env            Enable optional .env prompts during install
+  --plain-menu            Use plain install menu
+
+Uninstall options:
+  --dry-run               Show what would be removed
+  --platform <name>       Agent platform(s) for agent uninstall
+  --full                  Run make uninstall-all
+  --keep-env              Preserve .env with --full
+
+Examples:
+  ${TOOL_NAME} install --platform all --plain-menu
+  ${TOOL_NAME} uninstall --dry-run --platform all
+  ${TOOL_NAME} search 6584 --limit 5
+  ${TOOL_NAME} model-forecast NASDAQ:TSLA --json
+  ${TOOL_NAME} model-forecast BINANCE:BTCUSDT --refresh --json
+  ${TOOL_NAME} ohlcv BINANCE:BTCUSDT --interval 1D --bars 3
+  ${TOOL_NAME} cli data ohlcv TPEX:6584 --interval 1W --bars 40
+
+Environment:
+  TV_INDICATOR_INSTALL_DIR  Install directory for the npm-bundled project copy
+  TV_INDICATOR_PROJECT_ROOT Existing repo path to use instead of auto-detecting
+`);
+}
+
+function parseOption(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return undefined;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${name} requires a value`);
+  }
+  return value;
+}
+
+function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+function removeOptions(args, optionsWithValues, flags) {
+  const out = [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (flags.includes(arg)) continue;
+    if (optionsWithValues.includes(arg)) {
+      i += 1;
+      continue;
+    }
+    out.push(arg);
+  }
+  return out;
+}
+
+async function findProjectRoot({ bootstrap = false } = {}) {
+  const explicit = process.env.TV_INDICATOR_PROJECT_ROOT;
+  if (explicit) {
+    if (isProjectRoot(explicit)) {
+      return resolve(explicit);
+    }
+    throw new Error(`TV_INDICATOR_PROJECT_ROOT is not an Indicator project root: ${explicit}`);
+  }
+
+  const installDir = defaultInstallDir();
+  const starts = [process.cwd(), installDir];
+  for (const start of starts) {
+    let current = resolve(start);
+    while (current !== dirname(current)) {
+      if (isProjectRoot(current)) {
+        return current;
+      }
+      current = dirname(current);
+    }
+  }
+
+  if (bootstrap) {
+    return await bootstrapProjectRoot(installDir);
+  }
+
+  const packaged = packagedProjectRoot();
+  if (isProjectRoot(packaged)) {
+    return packaged;
+  }
+
+  throw new Error(
+    `Could not find Indicator project root. Run '${TOOL_NAME} install' first or set TV_INDICATOR_PROJECT_ROOT.`,
+  );
+}
+
+function defaultInstallDir() {
+  return resolve(process.env.TV_INDICATOR_INSTALL_DIR || resolve(homedir(), ".indicator"));
+}
+
+function packagedProjectRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..", "project");
+}
+
+function isProjectRoot(path) {
+  return (
+    existsSync(resolve(path, "Makefile")) &&
+    existsSync(resolve(path, "pyproject.toml")) &&
+    existsSync(resolve(path, "tools", "interactive_install.sh"))
+  );
+}
+
+async function bootstrapProjectRoot(targetDir) {
+  if (existsSync(targetDir)) {
+    if (!isProjectRoot(targetDir)) {
+      throw new Error(
+        `Install directory exists but is not an Indicator project root: ${targetDir}`,
+      );
+    }
+    return targetDir;
+  }
+
+  const sourceDir = packagedProjectRoot();
+  if (!isProjectRoot(sourceDir)) {
+    throw new Error(
+      "Packaged Indicator project files are missing. Reinstall @kuandotdev/indicator or set TV_INDICATOR_PROJECT_ROOT.",
+    );
+  }
+
+  mkdirSync(dirname(targetDir), { recursive: true });
+  console.log(`Indicator project not found; copying npm-bundled project into ${targetDir}`);
+  cpSync(sourceDir, targetDir, { recursive: true });
+  return targetDir;
+}
+
+async function run(spec, cwd) {
+  const env = { ...process.env, ...(spec.env ?? {}) };
+  console.log(`$ ${spec.command.join(" ")}`);
+  return await new Promise((resolveCode) => {
+    const proc = spawn(spec.command[0], spec.command.slice(1), {
+      cwd,
+      env,
+      stdio: "inherit",
+    });
+    proc.on("error", (error) => {
+      console.error(error.message);
+      resolveCode(1);
+    });
+    proc.on("close", (code) => {
+      resolveCode(code ?? 1);
+    });
+  });
+}
+
+function makeEnv(args) {
+  const env = {};
+  const platform = parseOption(args, "--platform");
+  const language = parseOption(args, "--language");
+  if (platform) env.PLATFORM = platform;
+  if (language) env.TV_AGENT_LANGUAGE = language;
+  if (hasFlag(args, "--force")) env.FORCE_INSTALL = "1";
+  if (hasFlag(args, "--skip-wizard")) env.TV_INDICATOR_SETUP = "0";
+  if (hasFlag(args, "--prompt-env")) env.TV_INSTALL_PROMPT_ENV = "1";
+  if (hasFlag(args, "--plain-menu")) env.TV_INSTALL_MENU = "plain";
+  return env;
+}
+
+function installCommand(args) {
+  return {
+    command: ["make", "install"],
+    env: makeEnv(args),
+  };
+}
+
+function uninstallCommand(args) {
+  const platform = parseOption(args, "--platform") ?? DEFAULT_PLATFORM;
+  if (hasFlag(args, "--full")) {
+    const env = {};
+    if (hasFlag(args, "--keep-env")) env.KEEP_ENV = "1";
+    return {
+      command: ["make", "uninstall-all"],
+      env,
+    };
+  }
+
+  return {
+    command: [
+      "./tools/uninstall_agent_tools.sh",
+      "--platform",
+      platform,
+      ...(hasFlag(args, "--dry-run") ? ["--dry-run"] : []),
+    ],
+  };
+}
+
+function makeTarget(target, extraEnv = {}) {
+  return {
+    command: ["make", target],
+    env: extraEnv,
+  };
+}
+
+function cliPassthroughCommand(args) {
+  if (args.length === 0) throw new Error("cli requires arguments for training-view");
+  const condaEnv = parseOption(args, "--conda-env") ?? "tv-indicator";
+  const cleaned = removeOptions(args, ["--conda-env"], []);
+  return {
+    command: [
+      "conda",
+      "run",
+      "-n",
+      condaEnv,
+      "--live-stream",
+      "--no-capture-output",
+      "python",
+      "-m",
+      "tv_indicator.cli.main",
+      ...cleaned,
+    ],
+  };
+}
+
+function agentImportCommand(args) {
+  return {
+    command: ["make", "agent-import"],
+    env: { PLATFORM: parseOption(args, "--platform") ?? DEFAULT_PLATFORM },
+  };
+}
+
+function agentUninstallCommand(args) {
+  return {
+    command: ["make", "agent-uninstall"],
+    env: { PLATFORM: parseOption(args, "--platform") ?? DEFAULT_PLATFORM },
+  };
+}
+
+function modelForecastCommand(args) {
+  const cleaned = removeOptions(args, ["--period"], ["--refresh", "--json"]);
+  const symbol = cleaned[0];
+  if (!symbol) throw new Error("model-forecast requires SYMBOL");
+  const env = { SYMBOL: symbol };
+  if (hasFlag(args, "--refresh")) env.REFRESH = "1";
+  if (hasFlag(args, "--json")) env.MODEL_JSON = "1";
+  const period = parseOption(args, "--period");
+  if (period) env.MODEL_PERIOD = period;
+  return makeTarget("model-forecast", env);
+}
+
+function searchCommand(args) {
+  const cleaned = removeOptions(args, ["--limit"], []);
+  const query = cleaned[0];
+  if (!query) throw new Error("search requires QUERY");
+  const env = { Q: query };
+  const limit = parseOption(args, "--limit");
+  if (limit) env.LIMIT = limit;
+  return makeTarget("search", env);
+}
+
+function ohlcvCommand(args) {
+  const cleaned = removeOptions(args, ["--interval", "--bars"], []);
+  const symbol = cleaned[0];
+  if (!symbol) throw new Error("ohlcv requires SYMBOL");
+  const env = { SYMBOL: symbol };
+  const interval = parseOption(args, "--interval");
+  const bars = parseOption(args, "--bars");
+  if (interval) env.INTERVAL = interval;
+  if (bars) env.BARS = bars;
+  return makeTarget("ohlcv", env);
+}
+
+function ratingCommand(args) {
+  const cleaned = removeOptions(args, ["--interval"], []);
+  const symbol = cleaned[0];
+  if (!symbol) throw new Error("rating requires SYMBOL");
+  const env = { SYMBOL: symbol };
+  const interval = parseOption(args, "--interval");
+  if (interval) env.INTERVAL = interval;
+  return makeTarget("rating", env);
+}
+
+function commandFor(args) {
+  const [command, ...rest] = args;
+  switch (command) {
+    case undefined:
+    case "-h":
+    case "--help":
+    case "help":
+      printHelp();
+      return null;
+    case "install":
+      return installCommand(rest);
+    case "uninstall":
+      return uninstallCommand(rest);
+    case "doctor":
+      return makeTarget("doctor");
+    case "status":
+      return makeTarget("status");
+    case "version":
+      return makeTarget("version");
+    case "check-skills":
+      return makeTarget("check-skills");
+    case "session-check":
+      return makeTarget("session-check");
+    case "search":
+      return searchCommand(rest);
+    case "model-status":
+      return makeTarget("model-status");
+    case "model-forecast":
+      return modelForecastCommand(rest);
+    case "ohlcv":
+      return ohlcvCommand(rest);
+    case "rating":
+      return ratingCommand(rest);
+    case "agent-import":
+      return agentImportCommand(rest);
+    case "agent-uninstall":
+      return agentUninstallCommand(rest);
+    case "cli":
+      return cliPassthroughCommand(rest);
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    const spec = commandFor(args);
+    if (!spec) return;
+    const root = await findProjectRoot({ bootstrap: args[0] === "install" });
+    const code = await run(spec, root);
+    process.exit(code);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+await main();

package/project/packages/tradingview-stock-data-skill/README.md

@@ -0,0 +1,112 @@
+# tradingview-stock-data-skill
+
+Generic Agent Skill for fetching current stock prices, OHLCV candles, price history, and CSV exports from TradingView-compatible tooling.
+
+For agent-driven installation/setup, see [`docs/agent-install.md`](../../docs/agent-install.md).
+
+The package also includes protected Pi startup integration. It does not ship a
+bundled copy of the project prompt.
+
+The skill is agent-agnostic and can be used by Claude Code, Pi, Codex-style agents, Gemini CLI, Cursor, and any agent that follows the Agent Skills `SKILL.md` convention or can read repository instruction files.
+
+## Install / wire into agents
+
+### Pi package install
+
+From this repo:
+
+```bash
+pi install ./packages/tradingview-stock-data-skill
+```
+
+Project-local Pi install:
+
+```bash
+pi install -l ./packages/tradingview-stock-data-skill
+```
+
+If this repository already wires `tradingview-stock-data` through `.pi/skills`, avoid duplicate skill warnings by loading only the package extension:
+
+```json
+{
+  "packages": [
+    {
+      "source": "../packages/tradingview-stock-data-skill",
+      "skills": []
+    }
+  ]
+}
+```
+
+After publishing to npm:
+
+```bash
+pi install npm:tradingview-stock-data-skill
+```
+
+### Claude Code
+
+Copy or symlink the skill directory into Claude skills:
+
+```bash
+mkdir -p .claude/skills
+ln -s ../../skills/tradingview-stock-data .claude/skills/tradingview-stock-data
+```
+
+Or globally:
+
+```bash
+mkdir -p ~/.claude/skills
+ln -s /absolute/path/to/skills/tradingview-stock-data ~/.claude/skills/tradingview-stock-data
+```
+
+### Codex / Gemini / Cursor
+
+Use the repository wiring script from this project:
+
+```bash
+make update-skills
+```
+
+That creates/refreshes:
+
+```text
+.claude/skills/tradingview-stock-data
+.pi/agent/skills/tradingview-stock-data
+.cursor/rules/tradingview-stock-data.mdc
+AGENTS.md
+GEMINI.md
+```
+
+## Invoke
+
+Ask naturally:
+
+```text
+Get current price for 6584.tw
+Get price history for TPEX:6584
+Export 2330.tw daily history to CSV
+```
+
+Or explicitly in Pi:
+
+```text
+/skill:tradingview-stock-data get 6584.tw daily history
+```
+
+## Automatic setup
+
+The package performs best-effort agent setup during installation and Pi startup
+when it is installed from this project. The exact startup wiring, prompt marker,
+sentinel files, and protected prompt contents are implementation details and are
+not part of the public package contract.
+
+## Requirements
+
+One of the following data access paths:
+
+- A Indicator MCP server with an OHLCV tool
+- A Makefile target like `make ohlcv SYMBOL=... INTERVAL=... BARS=...`
+- A CLI like `training-view data ohlcv ...`
+
+For Taiwan stocks, use TradingView symbols like `TWSE:2330` or `TPEX:6584`.

package/project/packages/tradingview-stock-data-skill/extensions/stock-prompt-injector.ts

@@ -0,0 +1,121 @@
+/**
+ * Stock Prompt Injector Extension
+ *
+ * When this Pi package is loaded, append the active stock-analysis startup prompt
+ * to the system prompt only if it is not already present from .pi/APPEND_SYSTEM.md,
+ * AGENTS.md/CLAUDE.md/GEMINI.md, or another injector.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+const INJECTION_MARKER = "TV_INDICATOR_STOCK_PROMPT_AUTO_INJECTED";
+const AUTO_IMPORT_SENTINEL = ".pi/.tv-indicator-auto-imported";
+const PROMPT_SIGNATURES = [
+	"# Market Analysis Agent",
+	"# Stock Analysis Agent",
+	"## Workflow (run in order, every time)",
+	"Default to the **Short Report**",
+];
+
+function hasStockPrompt(systemPrompt: string): boolean {
+	if (!systemPrompt) return false;
+	if (systemPrompt.includes(INJECTION_MARKER)) return true;
+	return PROMPT_SIGNATURES.every((signature) => systemPrompt.includes(signature));
+}
+
+function readableNonEmpty(file: string): boolean {
+	try {
+		return existsSync(file) && statSync(file).isFile() && statSync(file).size > 0;
+	} catch {
+		return false;
+	}
+}
+
+function findProjectRootWithImportScript(cwd: string): { root: string; script: string } | null {
+	let current = cwd;
+	for (let i = 0; i < 8; i++) {
+		const script = join(current, "tools", "import_agent_tools.sh");
+		if (existsSync(script)) return { root: current, script };
+
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+
+function findProjectPrompt(cwd: string): { path: string; source: string } | null {
+	let current = cwd;
+	for (let i = 0; i < 8; i++) {
+		const promptDir = join(current, "skills", "system-prompt-injection");
+		const custom = join(promptDir, "CUSTOM_SYSTEM_PROMPT.md");
+		const fallback = join(promptDir, "DEFAULT_SYSTEM_PROMPT.md");
+		if (readableNonEmpty(custom)) return { path: custom, source: "project-custom" };
+		if (readableNonEmpty(fallback)) return { path: fallback, source: "project-default" };
+
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+
+function getActivePrompt(cwd: string): { content: string; path: string; source: string } | null {
+	const found = findProjectPrompt(cwd);
+	if (!found) return null;
+	const content = readFileSync(found.path, "utf8").trim();
+	if (!content) return null;
+	return { ...found, content };
+}
+
+function autoImportProjectTools(cwd: string): void {
+	if (process.env.TV_INDICATOR_DISABLE_AUTO_IMPORT === "1") return;
+
+	const project = findProjectRootWithImportScript(cwd);
+	if (!project) return;
+
+	const sentinel = join(project.root, AUTO_IMPORT_SENTINEL);
+	if (existsSync(sentinel)) return;
+
+	spawnSync("bash", [project.script, "--platform", "pi"], {
+		cwd: project.root,
+		env: {
+			...process.env,
+			TV_INDICATOR_AUTO_IMPORT: "1",
+		},
+		stdio: "ignore",
+		timeout: 60_000,
+	});
+}
+
+export default function stockPromptInjector(pi: ExtensionAPI) {
+	pi.on("session_start", async (event) => {
+		if (event.reason !== "startup" && event.reason !== "reload") return;
+		autoImportProjectTools(process.cwd());
+	});
+
+	pi.on("before_agent_start", async (event) => {
+		const currentSystemPrompt = event.systemPrompt ?? "";
+		if (hasStockPrompt(currentSystemPrompt)) {
+			return {};
+		}
+
+		const cwd = String(event.systemPromptOptions?.cwd ?? process.cwd());
+		const activePrompt = getActivePrompt(cwd);
+		if (!activePrompt) {
+			return {};
+		}
+
+		return {
+			systemPrompt: `${currentSystemPrompt}
+
+<!-- ${INJECTION_MARKER} source=${activePrompt.source} -->
+
+${activePrompt.content}
+`,
+		};
+	});
+}

package/project/packages/tradingview-stock-data-skill/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "tradingview-stock-data-skill",
+  "version": "0.1.0",
+  "description": "Generic Agent Skill for fetching TradingView stock price and OHLCV history via CLI, Makefile, or MCP tools.",
+  "keywords": [
+    "agent-skill",
+    "pi-package",
+    "claude-code",
+    "codex",
+    "gemini",
+    "tradingview",
+    "stock-price",
+    "ohlcv",
+    "taiwan-stocks"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "postinstall": "bash ./scripts/postinstall.sh"
+  },
+  "files": [
+    "extensions",
+    "skills",
+    "scripts",
+    "README.md",
+    "package.json"
+  ],
+  "pi": {
+    "skills": ["./skills"],
+    "extensions": ["./extensions"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/project/packages/tradingview-stock-data-skill/scripts/postinstall.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Best-effort package install hook.
+# If this package is installed from inside a tv-indicator project, automatically
+# run the project import script so the correct agent context, package filters,
+# and MCP tool config are prepared.
+
+set -euo pipefail
+
+if [[ "${TV_INDICATOR_SKIP_POSTINSTALL:-0}" == "1" ]]; then
+  echo "tv-indicator: postinstall auto-import skipped by TV_INDICATOR_SKIP_POSTINSTALL=1"
+  exit 0
+fi
+
+PACKAGE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+# Package lifecycle hooks are usually run by Pi/package managers, so default to
+# Pi-only to avoid unexpectedly modifying Claude Desktop/global configs. Set
+# TV_INDICATOR_AGENT_PLATFORM=all (or another platform) to override.
+PLATFORM="${TV_INDICATOR_AGENT_PLATFORM:-pi}"
+
+find_import_script_from() {
+  local start="$1"
+  [[ -n "$start" ]] || return 1
+  [[ -d "$start" ]] || start="$(dirname "$start")"
+  local current
+  current="$(cd "$start" 2>/dev/null && pwd || true)"
+  while [[ -n "$current" && "$current" != "/" ]]; do
+    if [[ -x "$current/tools/import_agent_tools.sh" ]]; then
+      printf '%s\n' "$current/tools/import_agent_tools.sh"
+      return 0
+    fi
+    current="$(dirname "$current")"
+  done
+  return 1
+}
+
+IMPORT_SCRIPT=""
+for candidate in \
+  "${TV_INDICATOR_PROJECT_ROOT:-}" \
+  "${INIT_CWD:-}" \
+  "$PWD" \
+  "$PACKAGE_DIR"
+do
+  if IMPORT_SCRIPT="$(find_import_script_from "$candidate" 2>/dev/null)"; then
+    break
+  fi
+  IMPORT_SCRIPT=""
+done
+
+if [[ -z "$IMPORT_SCRIPT" ]]; then
+  echo "tv-indicator: no project tools/import_agent_tools.sh found; skipping install-time import."
+  echo "tv-indicator: runtime Pi extension will still inject the stock prompt if loaded."
+  exit 0
+fi
+
+PROJECT_ROOT="$(cd "$(dirname "$IMPORT_SCRIPT")/.." && pwd)"
+SENTINEL="$PROJECT_ROOT/.pi/.tv-indicator-auto-imported"
+
+if [[ "$PLATFORM" == "pi" && -f "$SENTINEL" && "${TV_INDICATOR_FORCE_IMPORT:-0}" != "1" ]]; then
+  echo "tv-indicator: Pi agent tools already imported; skipping."
+  echo "tv-indicator: set TV_INDICATOR_FORCE_IMPORT=1 to force re-import."
+  exit 0
+fi
+
+echo "tv-indicator: running agent tool import for platform '$PLATFORM' in $PROJECT_ROOT"
+
+if bash "$IMPORT_SCRIPT" --platform "$PLATFORM"; then
+  echo "tv-indicator: agent tool import complete."
+else
+  echo "tv-indicator: agent tool import failed; continuing package install." >&2
+  echo "tv-indicator: run manually later: $IMPORT_SCRIPT --platform $PLATFORM" >&2
+fi
+
+exit 0