# qibook-company-profile

Adopt this skill: https://proskills.md/skills/other/chinadaas-department-qibook-skills-qibook-company-profile

Page: https://proskills.md/skills/other/chinadaas-department-qibook-skills-qibook-company-profile
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: qibook-company-profile/SKILL.md
size: 4825
sha: d89f9d75dbe1283ff649d32137d4b1d3844dedba
upstream: https://github.com/chinadaas-department/qibook-skills/blob/master/qibook-company-profile/SKILL.md

````text
---
name: qibook-company-profile
version: 1.0.0
description: >
  企业工商信息与人员关联查询（查企业查老板）。
  Use when: 用户需要查企业、查公司、查老板、查股东、查高管、查法人、查对外投资、查人员任职、工商信息、主体识别等。
argument-hint: [企业名称/人员姓名/省份]
user-invocable: true
disable-model-invocation: false
allowed-tools:
  - Read
  - Bash
credentials:
  - name: QIBOOK_ACCESS_KEY
    description: 企百科 API 访问密钥
    how_to_get: "https://skill.qibook.com"
  - name: QIBOOK_BASE_URL
    description: 企百科 API 基础地址
    how_to_get: "https://skill.qibook.com"
requirements:
  python: 3.7+
  packages:
    - name: requests
  environment_variables:
    - name: QIBOOK_ACCESS_KEY
      required: true
      sensitive: true
    - name: QIBOOK_BASE_URL
      required: true
      sensitive: false
  network_access: true
---

# 查企业查老板

基于企百科 API，快速查询企业工商信息和人员关联信息，将结果转为中文 Markdown 后回答用户。

先理解用户想查什么（企业还是人、要哪些信息），再选择正确的查询路径，不要随意升级查询范围。

**不适合深度企业分析（企业画像、信用评估、竞争力分析），这类需求应引导使用 qibook-company-wiki-deepresearch skill。**

***

## When to use

用户不说"工商"、"照面"这些术语也要触发。以下口语都属于本 skill 范围：

- 帮我查一下华为 / 美团的全称是什么 / XX 是哪家公司
- XX 的法人是谁 / 注册资本多少 / 什么时候成立的
- XX 的股东有哪些 / 高管是谁 / 对外投资 / 谁是大股东
- XX 是谁开的 / 这家公司老板是谁
- 查一下张三 / 张三名下有几家公司 / 张三在 XX 公司担任什么
- 查张三在北京的情况

**口语理解优先**：
- "查一下 XX 公司" → 主体识别，返回全称 + 信用代码
- "XX 的老板" / "谁开的" → 查法人代表
- "XX 名下有几家公司" → 查人员关联企业统计
- "XX 的股东" → 查股东及出资信息

***

## Environment check

调用前先校验 `QIBOOK_ACCESS_KEY` 和 `QIBOOK_BASE_URL` 环境变量是否存在。缺失则提示：

```bash
export QIBOOK_ACCESS_KEY=your_key
export QIBOOK_BASE_URL=your_url
```

不要等到跑失败才暴露环境问题。

***

## 功能路由

**重要：根据用户意图选择正确的功能，不要随意升级查询范围。**

### 1. 主体识别

**触发：** 用户给了企业简称/别名想知道全称，或只提到公司名没要求具体信息。

```bash
python3 -m scripts.combined_query --entmark "华为"
```

**只返回企业全称 + 统一社会信用代码，不要额外展开。**

### 2. 查企业详细信息

**触发：** 用户明确要查照面/股东/高管/对外投资等具体信息。

```bash
python3 -m scripts.combined_query --entmark "天津测试有限公司"
```

**用户没指定模块 → 默认只返回照面，提示"还可以进一步查看股东、高管、对外投资"。**

### 3. 查人

**仅人名** → 人员统计汇总：

```bash
python3 -m scripts.combined_query --name "张三"
```

**人名+省份** → 该省份下的统计：

```bash
python3 -m scripts.combined_query --name "张三" --province "天津"
```

**人名+企业** → 担任法人、高管、投资详情：

```bash
python3 -m scripts.combined_query --entmark "天津测试有限公司" --name "张三"
```

### 路由判断

```
用户提问
  ├── 只提到公司名/简称，没要求具体信息 → 功能1（主体识别）
  ├── 明确要查照面/股东/高管/对外投资   → 功能2（查企业）
  ├── 提到人名，没提公司               → 功能3（查人汇总）
  ├── 提到人名+省份                    → 功能3（查人+省份）
  └── 提到人名+公司                    → 功能3（查人+企业详情）
```

***

## 回答规范

1. 使用脚本返回的中文 Markdown 作为数据来源，不要暴露英文字段
2. 数组数据（股东、高管等）用表格展示
3. 空值字段脚本已自动过滤，无需额外处理
4. 某模块数据为空 → 告知"暂无该项信息"
5. 金额字段保留两位小数
6. 查询为空时区分原因（名称不对 / 权限不足 / 网络异常），不要统一说"查询失败"

***

## 脚本说明

| 脚本 | 功能 |
|------|------|
| `scripts/base.py` | API 认证、调用、字段映射(英→中)、空值过滤、Markdown 格式化 |
| `scripts/combined_query.py` | 三个功能的 fetch 函数，根据入参自动判断场景，返回 Markdown 字符串 |
| `scripts/__init__.py` | 统一入口，导出 fetch / fetch_entity_id / fetch_enterprise / fetch_person_summary / fetch_person_detail |
````

## File: qibook-company-profile/scripts/__init__.py
size: 655
sha: d79bb2af5aa0daac88df48b72a0dfdd77ee6fc97
upstream: https://github.com/chinadaas-department/qibook-skills/blob/master/qibook-company-profile/scripts/__init__.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
QiBook 查企业查老板 - 统一入口
"""

def __getattr__(name):
    """延迟导入，避免 python -m scripts.combined_query 时的 RuntimeWarning"""
    _exports = {
        'fetch', 'fetch_entity_id', 'fetch_enterprise',
        'fetch_person_summary', 'fetch_person_detail',
    }
    if name in _exports:
        from . import combined_query
        return getattr(combined_query, name)
    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

__all__ = [
    'fetch',
    'fetch_entity_id',
    'fetch_enterprise',
    'fetch_person_summary',
    'fetch_person_detail',
]
```

## File: qibook-company-profile/scripts/base.py
size: 6740
sha: 18e8a93edcca23508e781487e1a9f4d350c6bed3
upstream: https://github.com/chinadaas-department/qibook-skills/blob/master/qibook-company-profile/scripts/base.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
共享模块：API 认证、调用、字段映射、空值过滤
"""

import requests
import urllib3
import os
from typing import Any

# 禁止 verify=False 时的 InsecureRequestWarning
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# API 配置 - 从环境变量获取
ACCESS_KEY = os.environ.get('QIBOOK_ACCESS_KEY')
BASE_URL = os.environ.get('QIBOOK_BASE_URL')

# ============ API 调用 ============

ALLOWED_PARAMS = {'entmark', 'name', 'province'}

def call_api(params: dict) -> dict:
    """
    调用组合查询接口

    Args:
        params: 请求参数，仅支持 entmark、name、province 三个字段

    Returns:
        API 返回的 JSON dict
    """
    # 只保留接口支持的三个入参
    if not ACCESS_KEY or not BASE_URL:
        return {'code': -1, 'msg': '缺少 API 配置，请设置环境变量 QIBOOK_ACCESS_KEY 和 QIBOOK_BASE_URL'}
    filtered = {k: v for k, v in params.items() if k in ALLOWED_PARAMS and v}
    if not filtered:
        return {'code': -1, 'msg': '缺少有效参数（支持 entmark/name/province）'}
    url = f"{BASE_URL}/skill/entData/combinedQuery"
    headers = {'access_key': ACCESS_KEY}
    try:
        response = requests.get(url, headers=headers, params=filtered, verify=False, timeout=30)
        return response.json()
    except requests.exceptions.Timeout:
        return {'code': -1, 'msg': '请求超时'}
    except requests.exceptions.RequestException as e:
        return {'code': -1, 'msg': f'请求异常: {e}'}
    except ValueError:
        return {'code': -1, 'msg': f'响应解析失败（HTTP {response.status_code}）'}

# ============ 字段映射 ============

MODULE_NAME_MAP = {
    "ENT_INFO":          "企业信息",
    "PERSON_INFO":       "人员信息",
    "MANAGER_INFO":      "人员统计信息",
    "BASIC":             "企业基本信息",
    "SHAREHOLDER":       "股东及出资信息",
    "PERSON":            "主要管理人员",
    "ENTINV":            "企业对外投资信息",
    "LISTEDSHAREHOLDER": "十大股东名单",
    "RYPOSFR":           "担任法人信息",
    "RYPOSPER":          "担任高管信息",
    "RYPOSSHA":          "投资企业信息",
    "MANAGERLIST":       "高管列表",
    "ENTLIST":           "关联企业",
}

FIELD_NAME_MAP = {
    "ENTNAME":        "企业名称",
    "SHORTNAME":      "企业简称",
    "ORGCODES":       "组织机构代码",
    "CREDITCODE":     "统一社会信用代码",
    "REGNO":          "注册号",
    "FRNAME":         "法定代表人",
    "REGCAP":         "注册资本(万元)",
    "REGCAPCUR":      "注册资本币种",
    "ESDATE":         "成立日期",
    "OPFROM":         "经营期限自",
    "OPTO":           "经营期限至",
    "ENTSTATUS":      "经营状态",
    "REGORG":         "登记机关",
    "ANCHEYEAR":      "最后年检年度",
    "DOM":            "住所",
    "OPSCOPE":        "经营范围",
    "REGORGPROVINCE": "所在省份",
    "REGORGCITY":     "所在城市",
    "REGORGDISTRICT": "所在区县",
    "COMPINTRO":      "公司简介",
    "COMPURL":        "公司网址",
    "SHANAME":        "股东名称",
    "SUBCONAM":       "认缴出资额(万元)",
    "CONDATE":        "出资日期",
    "FUNDEDRATIO":    "出资比例",
    "PERNAME":        "高管姓名",
    "POSITION":       "职务",
    "ENTJGNAME":      "企业(机构)名称",
    "SHHOLDERNAME":   "股东名称",
    "HOLDERRTO":      "持股比例",
    "HOLDERAMT":      "持股数量",
    "RYNAME":         "查询人姓名",
    "NAME":           "高管名称",
    "ENT_COUNT":      "关联企业个数",
    "LEGAL_COUNT":    "担任法人企业数量",
    "MANAGER_COUNT":  "担任高管企业数量",
    "INV_COUNT":      "投资企业数量",
    "PROVINCENAME":   "省份",
    "AREAENT_COUNT":  "地区企业数量",
}

# 同一字段在不同模块下含义不同
MODULE_FIELD_MAP = {
    "ENTINV": {
        "REGCAP":      "注册资本(万元)",
        "REGCAPCUR":   "注册资本币种",
        "ENTSTATUS":   "企业状态",
        "REGORG":      "登记机关",
        "FUNDEDRATIO": "投资比例",
        "CONDATE":     "投资日期",
    },
    "SHAREHOLDER": {
        "REGCAPCUR": "认缴出资币种",
    },
}

def translate_field(field: str, module: str = None) -> str:
    """字段名英文转中文，优先模块级覆盖"""
    if module and module in MODULE_FIELD_MAP:
        cn = MODULE_FIELD_MAP[module].get(field)
        if cn:
            return cn
    return FIELD_NAME_MAP.get(field, field)

def convert_to_chinese(data: Any, parent_module: str = None) -> Any:
    """递归将英文 key 转为中文，同时过滤空值"""
    if isinstance(data, dict):
        result = {}
        for k, v in data.items():
            # 跳过空值
            if v is None or v == '' or v == [] or v == {}:
                continue
            if k in MODULE_NAME_MAP:
                cn_key = MODULE_NAME_MAP[k]
                result[cn_key] = convert_to_chinese(v, parent_module=k)
            else:
                cn_key = translate_field(k, parent_module)
                result[cn_key] = convert_to_chinese(v, parent_module)
        return result
    elif isinstance(data, list):
        items = [convert_to_chinese(item, parent_module) for item in data]
        return [item for item in items if item]  # 过滤空 dict/list
    else:
        return data

# ============ Markdown 格式化 ============

def dict_to_markdown(data: dict, title: str = "", level: int = 2) -> str:
    """将 dict 转为 Markdown，对象用 key: value，数组用表格"""
    lines = []
    if title:
        lines.append(f"{'#' * level} {title}")
        lines.append("")

    for key, value in data.items():
        if isinstance(value, dict):
            lines.append(dict_to_markdown(value, title=key, level=level + 1))
        elif isinstance(value, list) and value:
            lines.append(f"{'#' * (level + 1)} {key}")
            lines.append("")
            if isinstance(value[0], dict):
                # 表格
                headers = list(value[0].keys())
                lines.append("| " + " | ".join(headers) + " |")
                lines.append("| " + " | ".join(["---"] * len(headers)) + " |")
                for item in value:
                    row = [str(item.get(h, "")) for h in headers]
                    lines.append("| " + " | ".join(row) + " |")
            else:
                for item in value:
                    lines.append(f"- {item}")
            lines.append("")
        else:
            lines.append(f"- **{key}**：{value}")

    return "\n".join(lines)
```

## File: qibook-company-profile/scripts/combined_query.py
size: 7638
sha: 77528fe62cab4493843836a8f7f60027390a9937
upstream: https://github.com/chinadaas-department/qibook-skills/blob/master/qibook-company-profile/scripts/combined_query.py

```text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
组合查询一体化脚本
支持三种场景：主体识别、查企业、查人
统一接口：fetch(entmark, name, province) -> str (Markdown)
"""

import sys
import os

if __package__:
    from .base import call_api, convert_to_chinese, dict_to_markdown
else:
    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
    from base import call_api, convert_to_chinese, dict_to_markdown

def _fetch_raw(entmark: str = "", name: str = "", province: str = "") -> dict:
    """调接口拿原始数据"""
    params = {}
    if entmark:
        params["entmark"] = entmark
    if name:
        params["name"] = name
    if province:
        params["province"] = province

    if not params:
        return {}

    resp = call_api(params)
    if resp.get("code") != 200:
        return {}
    return resp.get("data", {})

# ============ 功能一：主体识别 ============

def fetch_entity_id(entmark: str) -> str:
    """
    主体识别：输入企业标识，返回企业名称 + 统一社会信用代码

    Args:
        entmark: 企业名称/简称/信用代码/注册号等

    Returns:
        Markdown 格式的主体识别结果
    """
    raw = _fetch_raw(entmark=entmark)
    if not raw:
        return "未查询到相关企业信息"

    basic = raw.get("ENT_INFO", {}).get("BASIC", {})
    if not basic:
        return "未查询到相关企业信息"

    ent_name = basic.get("ENTNAME", "")
    credit_code = basic.get("CREDITCODE", "")

    lines = [
        "## 主体识别结果",
        "",
        f"- **企业名称**：{ent_name}",
        f"- **统一社会信用代码**：{credit_code}",
    ]
    return "\n".join(lines)

# ============ 功能二：查企业 ============

def fetch_enterprise(entmark: str) -> str:
    """
    查企业：输入企业标识，返回照面、股东、高管、对外投资

    Args:
        entmark: 企业名称/简称/信用代码/注册号等

    Returns:
        Markdown 格式的企业信息
    """
    raw = _fetch_raw(entmark=entmark)
    if not raw:
        return "未查询到相关企业信息"

    ent_info = raw.get("ENT_INFO", {})
    if not ent_info:
        return "未查询到相关企业信息"

    cn_data = convert_to_chinese(ent_info)
    return dict_to_markdown(cn_data, title="企业信息查询结果")

# ============ 功能三：查人 ============

def fetch_person_summary(name: str, province: str = "") -> str:
    """
    查人（仅人名 / 人名+省份）：返回人员统计汇总

    Args:
        name: 人员姓名
        province: 省份（可选，预留）

    Returns:
        Markdown 格式的人员统计
    """
    raw = _fetch_raw(name=name, province=province)
    if not raw:
        return "未查询到相关人员信息"

    person_info = raw.get("MANAGER_INFO", raw.get("PERSON_INFO", {}))
    if not person_info:
        return "未查询到相关人员信息"

    # MANAGER_INFO 返回的是 list，需要特殊处理
    if isinstance(person_info, list):
        cn_data = [convert_to_chinese(item) if isinstance(item, dict) else item for item in person_info]
        lines = [f"## 人员查询结果：{name}", ""]
        for item in cn_data:
            if isinstance(item, dict):
                person_name = item.get("高管名称", item.get("姓名", item.get("NAME", name)))
                ent_count = item.get("关联企业个数", item.get("ENT_COUNT", ""))
                legal_count = item.get("担任法人企业数量", item.get("LEGAL_COUNT", ""))
                manager_count = item.get("担任高管企业数量", item.get("MANAGER_COUNT", ""))
                inv_count = item.get("投资企业数量", item.get("INV_COUNT", ""))
                lines.append(f"**{person_name}**")
                lines.append(f"- 关联企业：{ent_count} 家")
                lines.append(f"- 担任法人：{legal_count} 家")
                lines.append(f"- 担任高管：{manager_count} 家")
                lines.append(f"- 投资企业：{inv_count} 家")
                # 企业分布
                ent_list = item.get("关联企业", item.get("ENTLIST", []))
                if ent_list:
                    lines.append("")
                    lines.append("| 省份 | 企业名称 | 该省企业数 |")
                    lines.append("| --- | --- | --- |")
                    for ent in ent_list:
                        if isinstance(ent, dict):
                            prov = ent.get("省份", ent.get("PROVINCENAME", ""))
                            ename = ent.get("企业名称", ent.get("ENTNAME", ""))
                            area_count = ent.get("地区企业数量", ent.get("AREAENT_COUNT", ""))
                            lines.append(f"| {prov} | {ename} | {area_count} |")
                lines.append("")
        return "\n".join(lines)
    else:
        cn_data = convert_to_chinese(person_info)
        return dict_to_markdown(cn_data, title=f"人员查询结果：{name}")

def fetch_person_detail(name: str, entmark: str) -> str:
    """
    查人（人名+企业）：返回企业信息 + 投资任职情况

    Args:
        name: 人员姓名
        entmark: 企业标识

    Returns:
        Markdown 格式的企业信息 + 人员投资任职详情
    """
    raw = _fetch_raw(entmark=entmark, name=name)
    if not raw:
        return "未查询到相关信息"

    parts = []

    # 企业信息（ENT_INFO）
    ent_info = raw.get("ENT_INFO", {})
    if ent_info:
        cn_ent = convert_to_chinese(ent_info)
        parts.append(dict_to_markdown(cn_ent, title="企业信息"))

    # 投资任职情况（PERSON_INFO）
    person_info = raw.get("PERSON_INFO", raw.get("MANAGER_INFO", {}))
    if person_info:
        if isinstance(person_info, list):
            cn_list = [convert_to_chinese(item) if isinstance(item, dict) else item for item in person_info]
            lines = [f"## {name} 在 {entmark} 的投资任职情况", ""]
            for item in cn_list:
                if isinstance(item, dict):
                    lines.append(dict_to_markdown(item, level=3))
            parts.append("\n".join(lines))
        elif isinstance(person_info, dict):
            cn_person = convert_to_chinese(person_info)
            parts.append(dict_to_markdown(cn_person, title=f"{name} 在 {entmark} 的投资任职情况"))

    if not parts:
        return "未查询到相关信息"

    return "\n\n".join(parts)

# ============ 统一入口 ============

def fetch(entmark: str = "", name: str = "", province: str = "") -> str:
    """
    统一入口，根据参数组合自动判断场景

    Args:
        entmark: 企业标识（可选）
        name: 人员姓名（可选）
        province: 省份（可选，预留）

    Returns:
        Markdown 格式的查询结果
    """
    if entmark and name:
        return fetch_person_detail(name, entmark)
    elif entmark:
        return fetch_enterprise(entmark)
    elif name:
        return fetch_person_summary(name, province)
    else:
        return "请提供企业标识(entmark)或人员姓名(name)"

if __name__ == '__main__':
    import argparse
    parser = argparse.ArgumentParser(description="企业/人员组合查询")
    parser.add_argument("--entmark", type=str, default="", help="企业标识")
    parser.add_argument("--name", type=str, default="", help="人员姓名")
    parser.add_argument("--province", type=str, default="", help="省份（预留）")
    args = parser.parse_args()

    print(fetch(entmark=args.entmark, name=args.name, province=args.province))
```

## File: README.md
upstream: https://github.com/chinadaas-department/qibook-skills/blob/master/README.md

````text
# QiBook Skills

[企百科](https://skill.qibook.com) 官方提供的 AI Skill 工具包，支持企业工商查询与企业深度研究。

## Skills

| Skill | 说明 |
|-------|------|
| **qibook-company-profile** | 企业征信 — 快速查询企业工商信息（照面、股东、高管、对外投资）和人员关联 |
| **qibook-company-wiki-deepresearch** | 企业简介 — 基于 20+ 维度数据，自动识别主体类型，生成专业企业洞察报告 |

## 安装

### 1. 安装依赖

```bash
pip install requests
```

### 2. 安装 Skill

通过 skills 命令安装：

```bash
# 企业征信
npx skills add https://github.com/ChinaDaaS-Department/qibook-skills.git --skill qibook-company-profile

# 企业简介
npx skills add https://github.com/ChinaDaaS-Department/qibook-skills.git --skill qibook-company-wiki-deepresearch
```

或将对应目录复制到本地 skills 目录。

### 3. 配置凭证

到 [企百科](https://skill.qibook.com) 获取 API 凭证：

```bash
export QIBOOK_ACCESS_KEY="your_access_key"
export QIBOOK_BASE_URL="your_base_url"
```

## 使用

安装并配置后，在智能体中用自然语言直接交流。支持 Claude Code、OpenClaw、Trae 等通用智能体。

### 企业征信

```
帮我查一下XX公司的股东信息
XX公司的股东有哪些
查一下张三名下有几家公司
```

### 企业简介

```
帮我了解一下XX公司
帮我研究一下XX公司
给我做个XX公司的企业报告
```

## 许可

本项目仅供学习和研究使用。使用时请遵守企百科的使用条款。
````
