@kuandotdev/indicator 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @kuandotdev/indicator
+
+Node wrapper CLI for Indicator.
+
+This package is a production-shaped bootstrapper: it does not replace the Python
+runtime. It wraps the existing repo commands for install, uninstall, diagnostics,
+MCP/agent import, market data, and model forecast checks.
+
+When no local Indicator repo is found, `install` clones
+`https://github.com/cr2s367067/indicator.git` into `~/.indicator` before running
+the installer. Override with `TV_INDICATOR_INSTALL_DIR` or
+`TV_INDICATOR_REPO_URL`.
+
+## Local Development
+
+Use the repo Makefile for local development installs and reinstalls:
+
+```bash
+make install
+make uninstall
+make install FORCE_INSTALL=1
+make agent-import PLATFORM=auto
+make check-skills
+```
+
+Use the wrapper directly only when testing the package itself:
+
+```bash
+node src/cli.js --help
+node src/cli.js doctor
+```
+
+## Production Install
+
+Publish the package and expose:
+
+```bash
+npx @kuandotdev/indicator install
+npx @kuandotdev/indicator install --force
+npx @kuandotdev/indicator uninstall --platform auto
+```
+
+For IP protection, keep proprietary prompts/model orchestration server-side and
+ship this package as a thin local installer/client.

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@kuandotdev/indicator",
+  "version": "0.1.0",
+  "description": "Indicator CLI wrapper for install, uninstall, diagnostics, market data, and model forecast commands.",
+  "license": "UNLICENSED",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "indicator": "src/cli.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js",
+    "check": "node --check src/cli.js",
+    "test-install-wrapper": "node src/cli.js install --skip-wizard",
+    "test-uninstall-wrapper": "node src/cli.js uninstall --dry-run",
+    "doctor": "node src/cli.js doctor"
+  },
+  "keywords": [
+    "tradingview",
+    "indicator",
+    "mcp",
+    "agent",
+    "cli",
+    "installer"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "package.json"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { 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";
+const DEFAULT_REPO_URL = "https://github.com/cr2s367067/indicator.git";
+
+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 embedded 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/clone directory when no local repo is found
+  TV_INDICATOR_REPO_URL     Git repo URL used for first-time bootstrap
+  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(), dirname(fileURLToPath(import.meta.url)), installDir];
+  for (const start of starts) {
+    let current = resolve(start);
+    while (current !== dirname(current)) {
+      if (isProjectRoot(current)) {
+        if (bootstrap && current === installDir) {
+          await updateProjectRoot(current);
+        }
+        return current;
+      }
+      current = dirname(current);
+    }
+  }
+
+  if (bootstrap) {
+    return await bootstrapProjectRoot(installDir);
+  }
+
+  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 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}`,
+      );
+    }
+    await updateProjectRoot(targetDir);
+    return targetDir;
+  }
+
+  const repoUrl = process.env.TV_INDICATOR_REPO_URL || DEFAULT_REPO_URL;
+  mkdirSync(dirname(targetDir), { recursive: true });
+  console.log(`Indicator repo not found; cloning ${repoUrl} into ${targetDir}`);
+  const cloneCode = await run({ command: ["git", "clone", repoUrl, targetDir] }, process.cwd());
+  if (cloneCode !== 0) {
+    throw new Error(`Failed to clone Indicator repo into ${targetDir}`);
+  }
+  return targetDir;
+}
+
+async function updateProjectRoot(root) {
+  if (!existsSync(resolve(root, ".git"))) return;
+  console.log(`Updating Indicator repo in ${root}`);
+  const code = await run({ command: ["git", "-C", root, "pull", "--ff-only"] }, process.cwd());
+  if (code !== 0) {
+    console.warn("Could not fast-forward update the Indicator repo; continuing with the existing checkout.");
+  }
+}
+
+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();