daxiapi-cli 2.6.0 → 2.7.0

package/README.md

@@ -91,10 +91,34 @@ daxiapi sector gn
 
 # 热门概念板块（东方财富数据源）
 daxiapi sector gn --type dfcf
+
+# 行业板块详情（通过板块ID查询）
+daxiapi sector bk_info --code BK0428
+
+# 行业板块详情（通过板块名称查询，支持模糊匹配）
+daxiapi sector bk_info --name 工程建筑
+
+# 行业板块详情（指定数据源）
+daxiapi sector bk_info --type ths --name 工程建筑
+
+# 概念板块详情（通过板块ID查询）
+daxiapi sector gn_info --code GN123
+
+# 概念板块详情（通过板块名称查询，支持模糊匹配）
+daxiapi sector gn_info --name 人工智能
+
+# 概念板块详情（指定数据源）
+daxiapi sector gn_info --type ths --name 人工智能
 ```
 
 **sector stocks 排序字段**：`cs`（CS强度）、`zdf`（涨跌幅）、`sm`（市值）、`cg`（成交额）、`cr`（换手率）、`sctr`（SCTR排名）
 
+**bk_info/gn_info 说明**：
+- `bk_info`：查询行业板块详情，返回CS强度、多日涨跌幅、市场宽度、主力资金净流入等数据
+- `gn_info`：查询概念板块详情，返回CS强度、多日涨跌幅、涨幅7%以上股票数、突破箱体股票数等数据
+- 支持通过 `--code`（板块ID）或 `--name`（板块名称，模糊匹配）查询
+- `--type` 可选数据源：`dfcf`（东方财富）或 `ths`（同花顺）
+
 ---
 
 ### 个股数据
@@ -164,6 +188,55 @@ daxiapi stock capital-flow 600031 --days 10
 
 ---
 
+### SQL筛选
+
+```bash
+# 基础查询（查询指定日期的股票）
+daxiapi sql "date='2026-06-17' LIMIT 10"
+
+# 强势股筛选（RPS>70）
+daxiapi sql "date='2026-06-17' AND rps_score>70 ORDER BY rps_score DESC LIMIT 20"
+
+# 多条件组合（RPS>70、SCTR>60、CS>0）
+daxiapi sql "date='2026-06-17' AND rps_score>70 AND sctr>60 AND cs>0 ORDER BY rps_score DESC LIMIT 15"
+
+# 技术形态筛选（VCP形态）
+daxiapi sql "date='2026-06-17' AND isVCP=1 ORDER BY rps_score DESC LIMIT 20"
+
+# 区间范围查询（CS在0-15之间）
+daxiapi sql "date='2026-06-17' AND cs in [0, 15] ORDER BY cs DESC LIMIT 20"
+
+# 板块筛选（银行板块）
+daxiapi sql "date='2026-06-17' AND bkName='银行' AND rps_score>70 ORDER BY rps_score DESC LIMIT 20"
+```
+
+**SQL语法说明**：
+
+- **必须包含 `date` 条件**：所有查询必须指定日期，格式为 `date='YYYY-MM-DD'`
+- **日期限制**：只支持查询最近10天内的数据
+- **支持的运算符**：`=`, `!=`, `<>`, `>`, `<`, `>=`, `<=`, `in [...]`, `in (...)`
+- **逻辑运算符**：`AND`, `OR`，支持括号嵌套
+- **排序**：`ORDER BY field ASC/DESC`，支持多字段排序
+- **数量限制**：`LIMIT N`，限制返回数量
+
+**支持的查询字段**：
+
+| 字段类别 | 字段名 | 说明 |
+|---------|--------|------|
+| 日期 | `date` | 查询日期（必填） |
+| 基本信息 | `stockId`, `name` | 股票代码、名称 |
+| 涨跌幅 | `zdf`, `zdf_5d`, `zdf_10d`, `zdf_20d` | 当日、5日、10日、20日涨跌幅 |
+| 强度指标 | `cs`, `rps_score`, `sctr`, `sm`, `ml` | CS强度、RPS、SCTR、SM、ML |
+| 技术形态 | `isVCP`, `isSOS`, `isSpring`, `isNewHigh` | VCP、SOS、Spring、新高形态 |
+| 价格 | `close`, `open`, `high`, `low` | 收盘价、开盘价、最高价、最低价 |
+| 成交量 | `vol`, `amount` | 成交量、成交额 |
+| 市值 | `shizhi` | 总市值（亿元） |
+| 板块 | `bkName`, `bkCode` | 板块名称、板块代码 |
+
+**更多示例**：参考 [xiapi-stock-sql-screener Skill](../skills/xiapi-stock-sql-screener/SKILL.md)
+
+---
+
 ### 涨跌停
 
 ```bash

package/bin/index.js

@@ -12,6 +12,7 @@ program
 require('../commands/config')(program);
 require('../commands/market')(program);
 require('../commands/sector')(program);
+require('../commands/sql')(program);
 require('../commands/stock')(program);
 require('../commands/kline')(program);
 require('../commands/zdt')(program);

package/commands/sql.js

@@ -0,0 +1,66 @@
+const config = require('../lib/config');
+const api = require('../lib/api');
+const {handleError, createParameterError} = require('../lib/error');
+const {output} = require('../lib/output');
+const {parseSql} = require('../lib/sql-parser');
+
+module.exports = function (program) {
+    const sqlCmd = program
+        .command('sql')
+        .description(
+            '使用 SQL 条件筛选股票，支持自定义条件组合、排序和数量限制。' +
+                '支持等于、大于、小于、区间范围、IN枚举、字段间比较等多种条件写法，支持 AND/OR 逻辑组合和括号嵌套。' +
+                '返回股票代码、名称、涨跌幅、CS强度、RPS相对强度、SCTR技术排名、所属板块、概念等详细数据。' +
+                '可用于量化筛选、技术形态选股和自定义策略分析。'
+        );
+
+    sqlCmd
+        .argument('<condition>', 'SQL WHERE 条件（支持 ORDER BY 和 LIMIT）')
+        .action(async condition => {
+            try {
+                const token = config.getToken();
+                if (!token) {
+                    const error = new Error('未配置 API Token');
+                    error.response = {status: 401};
+                    throw error;
+                }
+
+                if (!condition) {
+                    throw createParameterError(
+                        '参数无效',
+                        ["参数 'condition' 不能为空"],
+                        [
+                            'daxiapi sql "date=\'2026-06-17\' AND isVCP=1"',
+                            'daxiapi sql "date=\'2026-06-17\' AND rps_score>70 ORDER BY rps_score DESC LIMIT 20"'
+                        ]
+                    );
+                }
+
+                // 解析 SQL 条件
+                const parsed = parseSql(condition);
+                if (parsed.error) {
+                    throw createParameterError(
+                        'SQL 解析失败',
+                        [parsed.error],
+                        [
+                            'daxiapi sql "date=\'2026-06-17\' AND isVCP=1"',
+                            'daxiapi sql "date=\'2026-06-17\' AND cs in [0, 15] AND rps_score>70 ORDER BY rps_score DESC LIMIT 10"'
+                        ]
+                    );
+                }
+
+                // 调用服务端接口
+                const data = await api.querySqlStocks(
+                    token,
+                    parsed.conditions,
+                    parsed.orderBy,
+                    parsed.limit
+                );
+
+                output(data);
+            } catch (error) {
+                handleError(error);
+                process.exit(1);
+            }
+        });
+};

package/lib/api.js

@@ -124,6 +124,11 @@ async function queryStockData(token, q, type = 'stock') {
     return post(client, '/query_stock_data', {q, type});
 }
 
+async function querySqlStocks(token, conditions, orderBy, limit) {
+    const client = createClient(token);
+    return post(client, '/sql_query', { conditions, orderBy, limit });
+}
+
 
 
 async function getCapitalFlow(code, days =10) {
@@ -509,6 +514,7 @@ module.exports = {
     getZdtPool,
     getSecId,
     queryStockData,
+    querySqlStocks,
     getPatternStocks,
     getDividendScore,
     getStockRank,

package/lib/sql-parser.js

@@ -0,0 +1,348 @@
+class Tokenizer {
+    constructor(text) {
+        this.text = text;
+        this.pos = 0;
+        this.tokens = [];
+    }
+
+    tokenize() {
+        while (this.pos < this.text.length) {
+            this.skipWhitespace();
+            if (this.pos >= this.text.length) break;
+
+            const char = this.text[this.pos];
+
+            if (char === '(') {
+                this.tokens.push({type: 'LPAREN', value: '('});
+                this.pos++;
+            } else if (char === ')') {
+                this.tokens.push({type: 'RPAREN', value: ')'});
+                this.pos++;
+            } else if (char === '[') {
+                this.tokens.push({type: 'LBRACKET', value: '['});
+                this.pos++;
+            } else if (char === ']') {
+                this.tokens.push({type: 'RBRACKET', value: ']'});
+                this.pos++;
+            } else if (char === ',') {
+                this.tokens.push({type: 'COMMA', value: ','});
+                this.pos++;
+            } else if ('=!<>'.includes(char)) {
+                this.readOperator();
+            } else if (char === "'" || char === '"') {
+                this.readString(char);
+            } else if (/\d/.test(char)) {
+                this.readNumber();
+            } else if (/[a-zA-Z_]/.test(char)) {
+                this.readWord();
+            } else {
+                throw new Error(`未知字符: ${char} at position ${this.pos}`);
+            }
+        }
+        return this.tokens;
+    }
+
+    skipWhitespace() {
+        while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) {
+            this.pos++;
+        }
+    }
+
+    readOperator() {
+        const start = this.pos;
+        const char = this.text[this.pos];
+
+        if (char === '!' && this.text[this.pos + 1] === '=') {
+            this.tokens.push({type: 'OP', value: '!='});
+            this.pos += 2;
+        } else if (char === '>' && this.text[this.pos + 1] === '=') {
+            this.tokens.push({type: 'OP', value: '>='});
+            this.pos += 2;
+        } else if (char === '<' && this.text[this.pos + 1] === '=') {
+            this.tokens.push({type: 'OP', value: '<='});
+            this.pos += 2;
+        } else if ('=!<>'.includes(char)) {
+            this.tokens.push({type: 'OP', value: char});
+            this.pos++;
+        } else {
+            throw new Error(`无效操作符 at position ${start}`);
+        }
+    }
+
+    readString(quote) {
+        this.pos++;
+        const start = this.pos;
+        while (this.pos < this.text.length && this.text[this.pos] !== quote) {
+            this.pos++;
+        }
+        if (this.pos >= this.text.length) {
+            throw new Error(`未闭合的字符串 at position ${start - 1}`);
+        }
+        const value = this.text.substring(start, this.pos);
+        this.tokens.push({type: 'STRING', value});
+        this.pos++;
+    }
+
+    readNumber() {
+        const start = this.pos;
+        while (this.pos < this.text.length && /[\d.]/.test(this.text[this.pos])) {
+            this.pos++;
+        }
+        const value = parseFloat(this.text.substring(start, this.pos));
+        this.tokens.push({type: 'NUMBER', value});
+    }
+
+    readWord() {
+        const start = this.pos;
+        while (this.pos < this.text.length && /[a-zA-Z0-9_]/.test(this.text[this.pos])) {
+            this.pos++;
+        }
+        const value = this.text.substring(start, this.pos);
+
+        const upper = value.toUpperCase();
+        if (upper === 'AND') {
+            this.tokens.push({type: 'AND', value: upper});
+        } else if (upper === 'OR') {
+            this.tokens.push({type: 'OR', value: upper});
+        } else if (upper === 'IN') {
+            this.tokens.push({type: 'IN', value: upper});
+        } else if (upper === 'BETWEEN') {
+            this.tokens.push({type: 'BETWEEN', value: upper});
+        } else {
+            this.tokens.push({type: 'IDENT', value});
+        }
+    }
+}
+
+class Parser {
+    constructor(tokens, fieldMap = {}) {
+        this.tokens = tokens;
+        this.pos = 0;
+        this.fieldMap = fieldMap;
+    }
+
+    parse() {
+        if (this.tokens.length === 0) {
+            return {error: '空条件'};
+        }
+        const result = this.parseExpression();
+        if (this.pos < this.tokens.length) {
+            return {error: `未解析的 token: ${JSON.stringify(this.tokens[this.pos])}`};
+        }
+        return result;
+    }
+
+    parseExpression() {
+        return this.parseOr();
+    }
+
+    parseOr() {
+        let left = this.parseAnd();
+
+        while (this.match('OR')) {
+            const right = this.parseAnd();
+            if (left.type === 'or') {
+                left.conditions.push(right);
+            } else {
+                left = {type: 'or', conditions: [left, right]};
+            }
+        }
+
+        return left;
+    }
+
+    parseAnd() {
+        let left = this.parseFactor();
+
+        while (this.match('AND')) {
+            const right = this.parseFactor();
+            if (left.type === 'and') {
+                left.conditions.push(right);
+            } else {
+                left = {type: 'and', conditions: [left, right]};
+            }
+        }
+
+        return left;
+    }
+
+    parseFactor() {
+        if (this.match('LPAREN')) {
+            const expr = this.parseExpression();
+            if (!this.match('RPAREN')) {
+                return {error: '缺少右括号 )'};
+            }
+            return expr;
+        }
+
+        return this.parseCondition();
+    }
+
+    parseCondition() {
+        const fieldToken = this.expect('IDENT');
+        if (fieldToken.error) return fieldToken;
+
+        const field = fieldToken.value;
+
+        if (this.match('IN')) {
+            if (this.match('LPAREN')) {
+                const values = [];
+                do {
+                    const valueToken = this.tokens[this.pos];
+                    if (valueToken.type === 'STRING' || valueToken.type === 'NUMBER') {
+                        values.push(valueToken.value);
+                        this.pos++;
+                    } else if (valueToken.type === 'IDENT') {
+                        values.push(valueToken.value);
+                        this.pos++;
+                    } else {
+                        return {error: 'IN 列表中无效的值'};
+                    }
+                } while (this.match('COMMA'));
+
+                if (!this.match('RPAREN')) {
+                    return {error: 'IN 列表缺少 )'};
+                }
+                return {type: 'condition', field, op: 'IN', value: values};
+            }
+
+            if (this.match('LBRACKET')) {
+                const minToken = this.tokens[this.pos];
+                if (minToken.type !== 'NUMBER' && minToken.type !== 'IDENT') {
+                    return {error: '区间下限无效'};
+                }
+                const min = minToken.value;
+                this.pos++;
+
+                if (!this.match('COMMA')) {
+                    return {error: '区间缺少逗号'};
+                }
+
+                const maxToken = this.tokens[this.pos];
+                if (maxToken.type !== 'NUMBER' && maxToken.type !== 'IDENT') {
+                    return {error: '区间上限无效'};
+                }
+                const max = maxToken.value;
+                this.pos++;
+
+                if (!this.match('RBRACKET')) {
+                    return {error: '区间缺少 ]'};
+                }
+                return {type: 'condition', field, op: 'BETWEEN', value: [min, max]};
+            }
+
+            return {error: 'IN 后缺少 ( 或 ['};
+        }
+
+        const opToken = this.expect('OP');
+        if (opToken.error) return opToken;
+
+        const op = opToken.value;
+        const valueToken = this.tokens[this.pos];
+
+        if (!valueToken) {
+            return {error: '缺少值'};
+        }
+
+        if (valueToken.type === 'STRING') {
+            this.pos++;
+            return {type: 'condition', field, op, value: valueToken.value};
+        }
+
+        if (valueToken.type === 'NUMBER') {
+            this.pos++;
+            return {type: 'condition', field, op, value: valueToken.value};
+        }
+
+        if (valueToken.type === 'IDENT') {
+            this.pos++;
+            if (this.fieldMap[valueToken.value]) {
+                return {type: 'condition', field, op: 'FIELD_CMP', cmpOp: op, value: valueToken.value};
+            }
+            return {type: 'condition', field, op, value: valueToken.value};
+        }
+
+        return {error: `无效的值: ${JSON.stringify(valueToken)}`};
+    }
+
+    match(type) {
+        if (this.pos < this.tokens.length && this.tokens[this.pos].type === type) {
+            this.pos++;
+            return true;
+        }
+        return false;
+    }
+
+    expect(type) {
+        if (this.pos < this.tokens.length && this.tokens[this.pos].type === type) {
+            const token = this.tokens[this.pos];
+            this.pos++;
+            return token;
+        }
+        return {error: `期望 ${type}，但得到 ${this.tokens[this.pos] ? this.tokens[this.pos].type : 'EOF'}`};
+    }
+}
+
+function parseSql(text, fieldMap = {}) {
+    text = text.trim();
+    if (!text) return {error: '请输入查询条件'};
+
+    text = text.replace(/^\s*SELECT\s+.*?\s+FROM\s+stocks\s*/i, '');
+    text = text.replace(/^\s*SELECT\s+\*\s+FROM\s+stocks\s*/i, '');
+    text = text.replace(/^\s*FROM\s+stocks\s*/i, '');
+
+    let whereText = '';
+    let orderByText = '';
+    let limitText = '';
+
+    const limitMatch = text.match(/\bLIMIT\s+(\d+)\s*$/i);
+    if (limitMatch) {
+        limitText = limitMatch[1];
+        text = text.substring(0, limitMatch.index).trim();
+    }
+
+    const orderMatch = text.match(/\bORDER\s+BY\s+(\w+)(?:\s+(ASC|DESC))?\s*$/i);
+    if (orderMatch) {
+        orderByText = orderMatch[0];
+        text = text.substring(0, orderMatch.index).trim();
+    }
+
+    const whereMatch = text.match(/^\s*WHERE\s+/i);
+    if (whereMatch) {
+        whereText = text.substring(whereMatch[0].length).trim();
+    } else {
+        whereText = text;
+    }
+
+    if (!whereText) return {error: '请输入 WHERE 条件'};
+
+    try {
+        const tokenizer = new Tokenizer(whereText);
+        const tokens = tokenizer.tokenize();
+        const parser = new Parser(tokens, fieldMap);
+        const parseResult = parser.parse();
+
+        if (parseResult.error) return parseResult;
+
+        const result = {conditions: parseResult};
+
+        if (orderMatch) {
+            result.orderBy = {
+                field: orderMatch[1],
+                dir: (orderMatch[2] || 'DESC').toUpperCase()
+            };
+        }
+
+        if (limitText) {
+            const n = parseInt(limitText, 10);
+            if (n < 1 || n > 100) return {error: 'LIMIT 必须在 1~100 之间'};
+            result.limit = n;
+        }
+
+        return result;
+    } catch (err) {
+        return {error: err.message};
+    }
+}
+
+module.exports = {Tokenizer, Parser, parseSql};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "daxiapi-cli",
-    "version": "2.6.0",
+    "version": "2.7.0",
     "description": "大虾皮金融数据API命令行工具",
     "bin": {
         "daxiapi": "./bin/index.js",