@thinkingai/ae-cli 1.0.1

package/README.md

@@ -0,0 +1,229 @@
+# ae-cli
+
+CLI tool for ThinkingAI AgenticEngine (AE) platform. Designed for both AI Agent and human use.
+
+## Installation
+
+**Step 1: Install ae-cli**
+
+```bash
+npm install -g @thinkingai/ae-cli
+```
+
+**Step 2: Install AI Agent Skills**
+
+```bash
+npx skills add ThinkingAIAgenticEngine/ae-cli -g -y
+```
+
+This installs 8 skill packages into your AI coding agent (Claude Code, Trae, Cursor, etc.), enabling the agent to understand and call ae-cli commands.
+
+To update:
+
+```bash
+npm cache clean --force && npm install -g @thinkingai/ae-cli
+npx skills add ThinkingAIAgenticEngine/ae-cli -g -y
+```
+
+## Quick Start
+
+```bash
+# First run — interactive host setup + auto-login
+ae-cli config
+```
+
+The `config` command opens an interactive terminal UI:
+- First run: prompts you to add a TE host URL and label, then auto-authenticates
+- Subsequent runs: shows all configured hosts, lets you switch, edit, delete, or add new ones
+
+```
+TE Host Manager  (↑↓ select · Enter switch · e edit label · d delete · a add · q quit)
+
+❯ ● Production  https://ta.thinkingdata.cn  ✓
+  ○ Staging     https://ta-staging.example.com:8080  ✗
+  + Add new host...
+```
+
+After selecting a host, ae-cli automatically checks if the token is valid. If not, it triggers `auth login` for you.
+
+## Usage
+
+```bash
+# TE meta domain (metadata and governance)
+ae-cli te_meta +list_events --project_id 1
+
+# Table output
+ae-cli te_meta +list_events --project_id 1 --format table
+```
+
+## Authentication
+
+Authentication is handled per-host. Each TE host URL maintains its own token.
+
+```bash
+# Auto-login for active host (macOS, extracts token from Chrome)
+ae-cli auth login
+
+# Manually set token
+ae-cli auth set-token <your-token>
+
+# Check status
+ae-cli auth status
+
+# Logout
+ae-cli auth logout
+```
+
+## Commands
+
+### Domains
+
+| Domain | Commands | Description |
+|--------|----------|-------------|
+| `te_analysis` | 31 | Analysis workflows: alerts, reports, dashboards, ad-hoc/drilldown, clusters/tags, metadata/metrics, project tools, entity details, analysis schema |
+| `te_audience` | 14 | Audience operations: clusters, tags, and cluster/tag definition schema |
+| `te_meta` | 20 | Metadata governance: events/properties, metrics, virtual metadata, project config, tracking plan, mark times, resource links |
+| `te_engage` | 40+ | Hermes Engage MCP: channels, tasks, configs, flows, strategies |
+| `te_dataops` | 50+ | Data warehouse management: repos, datatables, flows, IDE queries, integration, operations |
+| `te_community` | 30+ | Community analysis: posts search, sentiment analysis, topic trends, livestream data |
+| `te_common` | 2 | Cross-module common constraints: resource link completion, project ID gate |
+| `operation` | 11 | Tasks, flows, channels, space navigation |
+
+### Global Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--host <url>` | Override active TE host URL | from config |
+| `--format <json\|table>` | Output format | json |
+| `--jq <expr>` | Filter expression | - |
+| `--dry-run` | Preview request | false |
+| `--yes` | Skip confirmation | false |
+
+## Skills
+
+8 AI Agent skill packages are included in the `skills/` directory:
+
+| Skill | Description |
+|-------|-------------|
+| `te-shared` | Authentication, configuration, global options |
+| `te-analysis` | Alerts, reports, dashboards, ad-hoc/drilldown, entity details, analysis schema |
+| `te-audience` | Cluster and tag lifecycle management |
+| `te-meta` | Metadata governance, project config, tracking plan, and resource link operations |
+| `te-engage` | Hermes Engage MCP: channels, tasks, configs, flows, strategies |
+| `te-dataops` | Data warehouse management, task flows, IDE queries, integration, operations |
+| `te-community` | Community analysis: posts, comments, topics, livestreams |
+| `te-common` | Cross-module constraints: project ID gate, resource link completion |
+
+Install them with:
+
+```bash
+npx skills add ThinkingAIAgenticEngine/ae-cli -g -y
+```
+
+## Skill Details
+
+### te-analysis (31 tools)
+
+Analysis query and visualization capabilities:
+- **Alerts**: view, create, update alert definitions
+- **Reports & Dashboards**: create, query, update reports and dashboards
+- **Model Analysis**: event analysis, retention analysis, funnel analysis, SQL analysis, user property analysis, distribution analysis, interval analysis, path analysis, attribution analysis
+- **Entity/Event Details**: query details, generate analysis SQL
+- **Schema Helpers**: analysis query schema, filter schema, groupby schema
+
+### te-audience (14 tools)
+
+Audience operations and targeting:
+- **Clusters**: create, update, query, member inspection, recomputation
+- **Tags**: create, update, query, member inspection, recomputation
+- **Schema Definitions**: cluster/tag definition schemas
+
+### te-meta (20 tools)
+
+Metadata and tracking-plan governance:
+- **Metadata Governance**: events/properties, metrics, virtual metadata
+- **Project Configuration**: project config, project users
+- **Tracking Plans**: track program management
+- **Mark Times**: date markers management
+- **Entity Catalog**: entity listing
+
+### te-engage (40+ tools)
+
+Hermes Engage MCP capabilities:
+- **Channels**: channel management, config channels, approval management
+- **Tasks**: task list, task details, task data/metrics overview, experiment reports
+- **Configs**: config items, strategies, strategy comparison, trigger/analysis reports
+- **Flows**: flow creation, node config, flow reports, flow validation
+
+### te-dataops (50+ tools)
+
+Data warehouse management:
+- **Repo Management**: spaces, catalogs, schemas, members
+- **Data Tables**: table creation, views, batch operations, data dictionary
+- **Task Flows**: flow creation, task nodes, scheduling, execution, monitoring
+- **IDE Queries**: metadata browsing, SQL execution, query management
+- **Integration**: datasource management, sync solutions, data synchronization
+- **Operations**: flow instances, task instances, backfill jobs
+
+### te-community (30+ tools)
+
+Community social media analysis:
+- **Posts**: search, detail, corpus tags
+- **Comments**: sentiment analysis, tag analysis, summary
+- **Topics**: hot topics, trends, daily summaries
+- **Livestreams**: rooms, sessions, analysis, metrics
+- **Advanced Analysis**: activity analysis, character analysis, weekly reports, release analysis
+
+### te-common (2 tools)
+
+Cross-module common constraints:
+- **Project ID Gate**: mandatory project verification before execution
+- **Resource Link Completion**: post-write link generation for dashboards, reports, metrics, alerts, clusters, tags
+
+## Development
+
+```bash
+git clone https://github.com/ThinkingAIAgenticEngine/ae-cli.git
+cd ae-cli
+npm install
+npx tsx src/index.ts --help
+```
+
+## Architecture
+
+ae-cli is built with:
+- **TypeScript** (~8000 lines of code)
+- **Commander.js** for CLI framework
+- **WebSocket** for MCP server integration
+- **Node.js** runtime (v18+)
+
+The project structure:
+```
+src/
+├── core/          # Core modules: auth, config, client, mcp
+├── framework/     # Framework: types, register, runner, output
+├── api/           # Raw API access
+└── commands/      # Domain-specific commands
+    ├── auth.ts
+    ├── config.ts
+    ├── te-analysis/
+    ├── te-audience/
+    ├── te-meta/
+    ├── te-engage/
+    ├── te-dataops/
+    ├── community/
+    └── te-common/
+```
+
+## Verification Scripts
+
+```bash
+npm run verify:te-analysis-tools
+npm run verify:te-audience-tools
+npm run verify:te-meta-tools
+npm run verify:te-common-tools
+```
+
+## License
+
+MIT

package/bin/ae-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/auth-JXELJNDS.js

@@ -0,0 +1,19 @@
+import {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  loadToken,
+  resolveHost,
+  saveToken,
+  setTokenManual
+} from "./chunk-RJNLN3KQ.js";
+import "./chunk-OVQOK35G.js";
+export {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  loadToken,
+  resolveHost,
+  saveToken,
+  setTokenManual
+};

package/dist/auth-L3G3A74I.js

@@ -0,0 +1,67 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  clearToken,
+  getAuthStatus,
+  getToken,
+  resolveHost,
+  setTokenManual
+} from "./chunk-RJNLN3KQ.js";
+import "./chunk-OVQOK35G.js";
+
+// src/commands/auth.ts
+function registerAuth(program) {
+  const auth = program.command("auth").description("Authentication management");
+  auth.command("login").description("Login to TE (auto-extract token from Chrome on macOS)").action(async () => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    try {
+      const token = await getToken(host);
+      process.stderr.write(`[ae-cli] Authenticated to ${host}
+`);
+      printOutput({ authenticated: true, host, token: token.slice(0, 8) + "..." }, program.opts().format || "json");
+    } catch (err) {
+      printError("auth", err.message);
+      process.exit(1);
+    }
+  });
+  auth.command("set-token <token>").description("Manually set authentication token for active host").action((token) => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    setTokenManual(token, host);
+    process.stderr.write(`[ae-cli] Token saved for ${host}
+`);
+    printOutput({ saved: true, host }, program.opts().format || "json");
+  });
+  auth.command("status").description("Show current authentication status").action(() => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printOutput({ authenticated: false, host: "(none)", hint: "Run: ae-cli config set-host" }, program.opts().format || "json");
+      return;
+    }
+    const status = getAuthStatus(host);
+    printOutput(status, program.opts().format || "json");
+  });
+  auth.command("logout").description("Clear stored token for active host").action(() => {
+    const host = resolveHost(program.opts().host);
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    clearToken(host);
+    process.stderr.write(`[ae-cli] Token cleared for ${host}
+`);
+    printOutput({ cleared: true, host }, program.opts().format || "json");
+  });
+}
+export {
+  registerAuth
+};

package/dist/chunk-3GM5LJZR.js

@@ -0,0 +1,145 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-RJNLN3KQ.js";
+
+// src/core/client.ts
+import WebSocket from "ws";
+import { randomBytes } from "crypto";
+function genRequestId(prefix) {
+  const rand = randomBytes(4).toString("base64url").slice(0, 8);
+  return `${prefix}@@${rand}`;
+}
+function buildUrl(baseUrl, modulePath, params = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function buildWsUrl(baseUrl, token) {
+  const base = baseUrl.replace(/\/$/, "");
+  const wsBase = base.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  return `${wsBase}/v1/ta-websocket/query/${token}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  const url = buildUrl(resolvedHost, modulePath, params);
+  const headers = {
+    "Authorization": `bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const options = { method, headers };
+  if (body && method !== "GET") options.body = JSON.stringify(body);
+  const resp = await fetch(url, options);
+  if ((resp.status === 401 || resp.status === 403) && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  const data = await resp.json();
+  if (data.return_code === -1001 && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`TE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function httpGet(modulePath, params = {}, hostUrl) {
+  return request("GET", modulePath, params, null, true, hostUrl);
+}
+async function httpPost(modulePath, params = {}, body, hostUrl) {
+  return request("POST", modulePath, params, body ?? {}, true, hostUrl);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, hostUrl, timeoutMs = 3e4) {
+  const wsUrl = buildWsUrl(hostUrl, token);
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`WebSocket query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    ws.on("open", () => {
+      const payload = {
+        requestId,
+        projectId,
+        eventModel,
+        qp: typeof qp === "string" ? qp : JSON.stringify(qp),
+        searchSource: options.searchSource || "reportQuery",
+        querySource: options.querySource || "single_report",
+        contentTranslate: options.contentTranslate !== false,
+        ...options.extra || {}
+      };
+      ws.send(JSON.stringify(["data", payload, { channel: "ta" }]));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (Array.isArray(msg) && msg.length >= 2) {
+          const data = msg[1];
+          if (data.requestId === requestId && data.progress === 100) {
+            clearTimeout(timer);
+            ws.close();
+            resolve(data);
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+    });
+  });
+}
+async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  try {
+    return await wsQueryOnce(projectId, requestId, qp, eventModel, options, token, resolvedHost);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
+      clearToken(resolvedHost);
+      const newToken = await getToken(resolvedHost);
+      return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
+    }
+    throw err;
+  }
+}
+async function querySql(projectId, sql, hostUrl) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, hostUrl);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, hostUrl) {
+  const dashboardId = options.dashboardId || 0;
+  const requestId = genRequestId(`${projectId}_${dashboardId}_${reportId}`);
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: options.searchSource || "model_search",
+    querySource: options.querySource || "module",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/chunk-JD5DXMKL.js

@@ -0,0 +1,172 @@
+import {
+  getToken
+} from "./chunk-RJNLN3KQ.js";
+import {
+  getActiveHost,
+  getConfigDir
+} from "./chunk-OVQOK35G.js";
+
+// src/core/mcp.ts
+import fs from "fs";
+import path from "path";
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var JSONRPC_VERSION = "2.0";
+var serviceMappingMap = /* @__PURE__ */ new Map();
+registerMcpMapping("te_analysis", {
+  componentName: "analysis",
+  mappingPath: "analysis"
+});
+registerMcpMapping("te_analysis_extend", {
+  componentName: "analysis",
+  mappingPath: "analysis-extend"
+});
+function registerMcpMapping(serviceName, mapping) {
+  serviceMappingMap.set(serviceName, mapping);
+}
+function registerMcpMappings(mappings) {
+  for (const [serviceName, mapping] of Object.entries(mappings)) {
+    serviceMappingMap.set(serviceName, mapping);
+  }
+}
+function getMcpMapping(serviceName) {
+  const mapping = serviceMappingMap.get(serviceName);
+  if (!mapping) {
+    throw new Error(`MCP mapping not found for service: '${serviceName}'. Please register it using registerMcpMapping() first.`);
+  }
+  return mapping;
+}
+function buildMcpUrl(host, serviceName) {
+  const mapping = getMcpMapping(serviceName);
+  const base = host.replace(/\/+$/, "");
+  return `${base}/mcp/${mapping.componentName}/http/${mapping.mappingPath}`;
+}
+function resolveMcpUrl(mcpUrlOverride, host, serviceName) {
+  if (mcpUrlOverride) {
+    return mcpUrlOverride;
+  }
+  return buildMcpUrl(host, serviceName);
+}
+var requestIdCounter = 1;
+function genRequestId() {
+  return requestIdCounter++;
+}
+var MCP_TOKEN_FILE = path.join(getConfigDir(), "mcp-tokens.json");
+var MCP_TOKEN_GENERATE_PATH = "/v1/ta/mcp/token/generate";
+function loadMcpTokenStore() {
+  try {
+    if (fs.existsSync(MCP_TOKEN_FILE)) {
+      return JSON.parse(fs.readFileSync(MCP_TOKEN_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function saveMcpTokenStore(store) {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(MCP_TOKEN_FILE, JSON.stringify(store, null, 2));
+}
+async function generateMcpToken(hostUrl) {
+  const teToken = await getToken(hostUrl);
+  const base = hostUrl.replace(/\/+$/, "");
+  const url = `${base}${MCP_TOKEN_GENERATE_PATH}`;
+  const resp = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `bearer ${teToken}`
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`MCP token generate HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  if (data.return_code !== 0) {
+    throw new Error(`MCP token generate error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  const mcpToken = data.data?.userSecret;
+  if (!mcpToken) {
+    throw new Error("MCP token generate error: empty userSecret in response");
+  }
+  return mcpToken;
+}
+async function getMcpToken(hostOverride) {
+  const hostUrl = hostOverride || getActiveHost();
+  const store = loadMcpTokenStore();
+  if (store[hostUrl]) {
+    return store[hostUrl];
+  }
+  const mcpToken = await generateMcpToken(hostUrl);
+  const updatedStore = { ...store, [hostUrl]: mcpToken };
+  saveMcpTokenStore(updatedStore);
+  return mcpToken;
+}
+async function mcpRequest(url, method, params = {}, hostOverride) {
+  const token = await getMcpToken(hostOverride);
+  const requestId = genRequestId();
+  const paramsWithMeta = {
+    ...params,
+    _meta: { progressToken: requestId }
+  };
+  const body = {
+    jsonrpc: JSONRPC_VERSION,
+    id: requestId,
+    method,
+    params: paramsWithMeta
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+    "mcp-token": token
+  };
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    throw new Error(`MCP HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = await resp.json();
+  if (data.error) {
+    throw new Error(`MCP error: ${data.error.message || JSON.stringify(data.error)}`);
+  }
+  return data.result;
+}
+async function callMcpTool(url, toolName, args = {}, hostOverride) {
+  const params = {
+    name: toolName,
+    arguments: args
+  };
+  const result = await mcpRequest(url, "tools/call", params, hostOverride);
+  return {
+    content: result.content.map((item) => {
+      if (item.type === "text") {
+        return { type: "text", text: item.text };
+      } else if (item.type === "image") {
+        return { type: "image", data: item.data, mimeType: item.mimeType };
+      } else {
+        return { type: "resource", ...item };
+      }
+    }),
+    isError: result.isError
+  };
+}
+function parseMcpResult(result) {
+  if (result.content.length > 0 && result.content[0].type === "text") {
+    const text = result.content[0].text || "";
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return result;
+}
+
+export {
+  registerMcpMappings,
+  resolveMcpUrl,
+  callMcpTool,
+  parseMcpResult
+};