mt-signals 1.0.0

package/bin/mt-signals.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+"use strict";
+
+const { request, loadConfig, saveConfig, getBaseUrl, getApiKey } = require("../lib/client");
+const { fmt, catColor, scoreColor, bar, sparkline } = require("../lib/format");
+
+const args = process.argv.slice(2);
+const flags = {};
+const positional = [];
+for (const a of args) {
+  if (a.startsWith("--")) {
+    const [k, v] = a.slice(2).split("=");
+    flags[k] = v === undefined ? true : v;
+  } else {
+    positional.push(a);
+  }
+}
+const cmd = positional[0];
+const json = flags.json;
+
+function out(data) {
+  if (json) return console.log(JSON.stringify(data, null, 2));
+  return data;
+}
+
+function die(msg) {
+  console.error(fmt.red(`Error: ${msg}`));
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    switch (cmd) {
+      case "list":
+      case "signals":
+      case undefined: {
+        if (cmd === undefined && positional.length === 0 && !flags.category && !flags.sort && !flags.min && !flags.limit) {
+          // No args at all — show help
+          showHelp();
+          break;
+        }
+        const qs = [];
+        if (flags.category) qs.push(`category=${encodeURIComponent(flags.category)}`);
+        if (flags.min) qs.push(`min_score=${flags.min}`);
+        if (flags.limit) qs.push(`limit=${flags.limit}`);
+        if (flags.sort) qs.push(`sort=${flags.sort}`);
+        const query = qs.length > 0 ? `?${qs.join("&")}` : "";
+        const data = await request("GET", `/signals${query}`);
+        if (json) return out(data);
+
+        const sigs = data.signals || [];
+        if (sigs.length === 0) {
+          console.log(fmt.dim("\n  No signals found.\n"));
+          break;
+        }
+
+        console.log(fmt.bold(`\n  Research Signals (${data.total} total)\n`));
+        for (const s of sigs) {
+          const sc = scoreColor(s.score)(String((s.score || 0).toFixed(1)).padStart(4));
+          const cat = catColor(s.category).padEnd(22);
+          const topic = fmt.bold((s.topic || "").padEnd(35).slice(0, 35));
+          const src = fmt.dim((s.source || "").padEnd(8).slice(0, 8));
+          console.log(`  ${sc}  ${cat}  ${topic}  ${src}  U:${bar(s.urgency, 10, 5)} B:${bar(s.buyer_intent, 10, 5)} D:${bar(s.durability, 10, 5)}`);
+        }
+        console.log(fmt.dim(`\n  Last recalculated: ${data.last_recalculated || "never"}\n`));
+        break;
+      }
+
+      case "top": {
+        const limit = positional[1] || flags.limit || "10";
+        const data = await request("GET", `/signals?limit=${limit}`);
+        if (json) return out(data);
+
+        const sigs = data.signals || [];
+        console.log(fmt.bold(`\n  Top ${sigs.length} Signals\n`));
+        for (let i = 0; i < sigs.length; i++) {
+          const s = sigs[i];
+          const rank = fmt.dim(`#${String(i + 1).padStart(2)}`);
+          const sc = scoreColor(s.score)(String((s.score || 0).toFixed(1)));
+          const cat = catColor(s.category);
+          console.log(`  ${rank}  ${sc}  ${fmt.bold(s.topic || "")}  ${cat}`);
+          if (s.summary) console.log(`       ${fmt.dim(s.summary.slice(0, 90))}`);
+        }
+        console.log();
+        break;
+      }
+
+      case "trending":
+      case "hot": {
+        const data = await request("GET", "/signals/trending");
+        if (json) return out(data);
+
+        console.log(fmt.bold(`\n  Trending Signals\n`));
+
+        const breakouts = data.breakouts || [];
+        if (breakouts.length > 0) {
+          console.log(fmt.yellow(`  Breakouts (${breakouts.length})\n`));
+          for (const b of breakouts) {
+            console.log(`  ${fmt.yellow("\u26a1")} ${fmt.bold(b.topic)}  ${fmt.yellow(b.multiplier + "x")}  ${fmt.dim(b.previous_avg + " \u2192 " + b.current)}  ${catColor(b.category)}`);
+          }
+          console.log();
+        } else {
+          console.log(fmt.dim("  No breakout signals.\n"));
+        }
+
+        const hot = data.hot_signals || [];
+        if (hot.length > 0) {
+          console.log(fmt.green(`  Hot Signals (score 6+)\n`));
+          for (const s of hot) {
+            const sc = scoreColor(s.score)(String((s.score || 0).toFixed(1)));
+            console.log(`  ${sc}  ${fmt.bold(s.topic || "")}  ${catColor(s.category)}`);
+            if (s.summary) console.log(`       ${fmt.dim(s.summary.slice(0, 90))}`);
+          }
+        } else {
+          console.log(fmt.dim("  No hot signals.\n"));
+        }
+        console.log();
+        break;
+      }
+
+      case "lookup":
+      case "topic": {
+        const topic = positional.slice(1).join(" ") || flags.topic;
+        if (!topic) die("Usage: mt-signals lookup <topic>");
+        const encoded = encodeURIComponent(topic.replace(/\s+/g, "-"));
+        const data = await request("GET", `/signals/${encoded}`);
+        if (json) return out(data);
+
+        const s = data.signal;
+        if (!s) { console.log(fmt.dim("\n  Signal not found.\n")); break; }
+
+        console.log(fmt.bold(`\n  ${s.topic}\n`));
+        console.log(`  ${fmt.cyan("Score:")}        ${scoreColor(s.score)(String((s.score || 0).toFixed(1)))}`);
+        console.log(`  ${fmt.cyan("Category:")}     ${catColor(s.category)}`);
+        console.log(`  ${fmt.cyan("Source:")}       ${s.source || "—"} (${s.source_count || 1} sources)`);
+        console.log(`  ${fmt.cyan("Urgency:")}      ${bar(s.urgency, 10, 15)} ${(s.urgency || 0).toFixed(1)}`);
+        console.log(`  ${fmt.cyan("Buyer Intent:")} ${bar(s.buyer_intent, 10, 15)} ${(s.buyer_intent || 0).toFixed(1)}`);
+        console.log(`  ${fmt.cyan("Durability:")}   ${bar(s.durability, 10, 15)} ${(s.durability || 0).toFixed(1)}`);
+
+        if (s.summary) console.log(`\n  ${fmt.dim(s.summary)}`);
+
+        if (s.actionable_for && s.actionable_for.length > 0) {
+          console.log(`\n  ${fmt.cyan("Actionable for:")} ${s.actionable_for.join(", ")}`);
+        }
+
+        if (s.evidence && s.evidence.length > 0) {
+          console.log(fmt.bold("\n  Evidence\n"));
+          for (const e of s.evidence.slice(0, 10)) {
+            console.log(`  ${fmt.dim("\u2022")} ${e}`);
+          }
+        }
+
+        const hist = data.history || [];
+        if (hist.length > 2) {
+          const scores = hist.map(h => h.score);
+          console.log(`\n  ${fmt.cyan("Trend:")} ${sparkline(scores)}  ${fmt.dim("(" + hist.length + " data points)")}`);
+        }
+
+        console.log(fmt.dim(`\n  Updated: ${s.updated || s.created || "—"}\n`));
+        break;
+      }
+
+      case "category":
+      case "cat": {
+        const cat = positional[1] || flags.category;
+        if (!cat) die("Usage: mt-signals category <name>\n  Categories: ai, infrastructure, security, devtools, data, business, career, market");
+        const data = await request("GET", `/signals/category/${encodeURIComponent(cat)}`);
+        if (json) return out(data);
+
+        const sigs = data.signals || [];
+        console.log(fmt.bold(`\n  ${catColor(data.category)} (${data.total} signals)\n`));
+        for (const s of sigs) {
+          const sc = scoreColor(s.score)(String((s.score || 0).toFixed(1)).padStart(4));
+          console.log(`  ${sc}  ${fmt.bold((s.topic || "").padEnd(35).slice(0, 35))}  U:${(s.urgency || 0).toFixed(1)} B:${(s.buyer_intent || 0).toFixed(1)} D:${(s.durability || 0).toFixed(1)}`);
+        }
+        console.log();
+        break;
+      }
+
+      case "stats": {
+        const data = await request("GET", "/stats");
+        if (json) return out(data);
+
+        console.log(fmt.bold(`\n  Signal Stats\n`));
+        console.log(`  ${fmt.cyan("Total Signals:")}    ${fmt.bold(String(data.total_signals))}`);
+        console.log(`  ${fmt.cyan("History Entries:")}   ${fmt.bold(String(data.history_entries))}`);
+
+        const cats = Object.entries(data.categories || {});
+        if (cats.length > 0) {
+          console.log(fmt.bold("\n  Categories\n"));
+          for (const [name, info] of cats.sort((a, b) => b[1].count - a[1].count)) {
+            const avg = scoreColor(info.avg_score)(String(info.avg_score));
+            console.log(`  ${catColor(name).padEnd(22)}  ${String(info.count).padStart(3)} signals  avg ${avg}  ${fmt.dim("top: " + (info.top_topic || "—").slice(0, 30))}`);
+          }
+        }
+
+        const top = data.top_10 || [];
+        if (top.length > 0) {
+          console.log(fmt.bold("\n  Top 10\n"));
+          for (let i = 0; i < top.length; i++) {
+            const s = top[i];
+            console.log(`  ${fmt.dim("#" + (i + 1))}  ${scoreColor(s.score)(String((s.score || 0).toFixed(1)))}  ${fmt.bold(s.topic || "")}  ${catColor(s.category)}`);
+          }
+        }
+        console.log();
+        break;
+      }
+
+      case "recalculate":
+      case "recalc": {
+        const data = await request("POST", "/trigger", { action: "recalculate" });
+        if (json) return out(data);
+        console.log(fmt.green(`\n  Scores recalculated. ${data.total || 0} signals updated.\n`));
+        break;
+      }
+
+      case "config": {
+        const sub = positional[1];
+        if (sub === "set") {
+          const key = positional[2];
+          const val = positional[3];
+          if (!key || !val) die("Usage: mt-signals config set <key> <value>\n  Keys: url, apiKey");
+          const cfg = loadConfig();
+          cfg[key] = val;
+          saveConfig(cfg);
+          console.log(fmt.green(`\n  Set ${key} = ${val}\n`));
+        } else {
+          console.log(fmt.bold("\n  Configuration\n"));
+          console.log(`  ${fmt.cyan("URL:")}     ${getBaseUrl()}`);
+          console.log(`  ${fmt.cyan("API Key:")} ${getApiKey() ? fmt.dim(getApiKey().slice(0, 8) + "...") : fmt.dim("(not set)")}`);
+          console.log(`  ${fmt.cyan("Config:")}  ${require("path").join(require("os").homedir(), ".mt-signals", "config.json")}`);
+          console.log();
+        }
+        break;
+      }
+
+      case "help":
+      default: {
+        if (cmd && cmd !== "help") die(`Unknown command: ${cmd}\nRun 'mt-signals help' for usage.`);
+        showHelp();
+        break;
+      }
+    }
+  } catch (err) {
+    if (json) {
+      console.log(JSON.stringify({ error: err.message }));
+      process.exit(1);
+    }
+    die(err.message);
+  }
+}
+
+function showHelp() {
+  console.log(`
+${fmt.bold("mt-signals")} — Research Signal Intelligence
+
+${fmt.bold("USAGE")}
+  mt-signals <command> [options]
+
+${fmt.bold("COMMANDS")}
+  ${fmt.cyan("signals")}     [--category=X] [--sort=X]  List all scored signals
+  ${fmt.cyan("top")}         [N]                        Top N signals (default: 10)
+  ${fmt.cyan("trending")}                               Breakout signals + hot (score 6+)
+  ${fmt.cyan("lookup")}      <topic>                    Deep dive on a specific signal
+  ${fmt.cyan("category")}    <name>                     Signals by category
+  ${fmt.cyan("stats")}                                  Category breakdown + top 10
+  ${fmt.cyan("recalculate")}                            Force score recalculation
+  ${fmt.cyan("config")}      [set <key> <value>]        View/set configuration
+
+${fmt.bold("OPTIONS")}
+  --json              Output raw JSON
+  --category=X        Filter: ai, infrastructure, security, devtools, data, business, career, market
+  --sort=X            Sort: score, urgency, buyer_intent, durability
+  --min=N             Minimum score filter
+  --limit=N           Max results
+
+${fmt.bold("ENVIRONMENT")}
+  MT_SIGNALS_URL       API base URL (default: https://signals.metaltorque.dev)
+  MT_SIGNALS_API_KEY   Access key for the API
+
+${fmt.bold("EXAMPLES")}
+  mt-signals signals                       # All signals ranked by score
+  mt-signals top 5                         # Top 5 signals
+  mt-signals trending                      # Breakouts + hot signals
+  mt-signals signals --category=ai         # AI signals only
+  mt-signals signals --sort=buyer_intent   # Sort by buyer intent
+  mt-signals lookup "MCP server"           # Deep dive
+  mt-signals stats --json                  # Pipe stats to another tool
+`);
+}
+
+main();

package/lib/client.js

@@ -0,0 +1,69 @@
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const CONFIG_DIR = path.join(os.homedir(), ".mt-signals");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+function loadConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8")); } catch { return {}; }
+}
+
+function saveConfig(cfg) {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+
+function getBaseUrl() {
+  return (process.env.MT_SIGNALS_URL || loadConfig().url || "https://signals.metaltorque.dev").replace(/\/$/, "");
+}
+
+function getApiKey() {
+  return process.env.MT_SIGNALS_API_KEY || loadConfig().apiKey || "";
+}
+
+function request(method, urlPath, body, timeout = 30000) {
+  return new Promise((resolve, reject) => {
+    const base = getBaseUrl();
+    const apiKey = getApiKey();
+    const sep = urlPath.includes("?") ? "&" : "?";
+    const fullUrl = apiKey ? `${base}${urlPath}${sep}key=${apiKey}` : `${base}${urlPath}`;
+    const mod = fullUrl.startsWith("https") ? https : http;
+    const parsed = new URL(fullUrl);
+
+    const headers = { "Content-Type": "application/json", "User-Agent": "mt-signals-cli/1.0.0" };
+
+    const opts = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method,
+      headers,
+      timeout,
+    };
+
+    const req = mod.request(opts, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode >= 400) return reject(new Error(json.error || `HTTP ${res.statusCode}`));
+          resolve(json);
+        } catch {
+          if (res.statusCode >= 400) return reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 300)}`));
+          resolve(data);
+        }
+      });
+    });
+
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("Request timed out")); });
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+module.exports = { request, loadConfig, saveConfig, getBaseUrl, getApiKey, CONFIG_DIR, CONFIG_FILE };

package/lib/format.js

@@ -0,0 +1,50 @@
+const NO_COLOR = process.env.NO_COLOR || process.env.TERM === "dumb";
+const c = (code, s) => NO_COLOR ? s : `\x1b[${code}m${s}\x1b[0m`;
+
+const fmt = {
+  bold: (s) => c("1", s),
+  dim: (s) => c("2", s),
+  green: (s) => c("32", s),
+  red: (s) => c("31", s),
+  yellow: (s) => c("33", s),
+  cyan: (s) => c("36", s),
+  magenta: (s) => c("35", s),
+  blue: (s) => c("34", s),
+  white: (s) => c("37", s),
+};
+
+const CAT_COLORS = {
+  ai: fmt.magenta,
+  infrastructure: fmt.green,
+  security: fmt.red,
+  devtools: fmt.yellow,
+  data: fmt.blue,
+  business: fmt.magenta,
+  career: fmt.cyan,
+  market: fmt.yellow,
+};
+
+function catColor(cat) {
+  return (CAT_COLORS[cat] || fmt.dim)(cat || "unknown");
+}
+
+function scoreColor(score) {
+  if (score >= 7) return fmt.green;
+  if (score >= 4) return fmt.yellow;
+  return fmt.dim;
+}
+
+function bar(value, max, width = 10) {
+  const filled = Math.round((value / (max || 10)) * width);
+  const empty = width - filled;
+  return fmt.cyan("\u2588".repeat(filled)) + fmt.dim("\u2591".repeat(empty));
+}
+
+function sparkline(values) {
+  const chars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  if (!values.length) return "";
+  const max = Math.max(...values, 1);
+  return values.map((v) => fmt.cyan(chars[Math.min(Math.floor((v / max) * 7), 7)])).join("");
+}
+
+module.exports = { fmt, catColor, scoreColor, bar, sparkline };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "mt-signals",
+  "version": "1.0.0",
+  "description": "CLI for MetalTorque Research Signals — scored trend intelligence from HN, Reddit, ArXiv, and GitHub.",
+  "bin": {
+    "mt-signals": "bin/mt-signals.js"
+  },
+  "keywords": ["research", "signals", "trends", "market-intelligence", "ai", "swarm", "cli"],
+  "license": "MIT",
+  "author": "MetalTorque",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joepangallo/research-signal-api"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ]
+}