cli-dolibarr 3.1.2__tar.gz → 3.2.0__tar.gz

{cli_dolibarr-3.1.2 → cli_dolibarr-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-dolibarr
-Version: 3.1.2
+Version: 3.2.0
 Summary: CLI tool for Dolibarr ERP/CRM REST API management
 Author: CLI Anything
 License-Expression: MIT

{cli_dolibarr-3.1.2 → cli_dolibarr-3.2.0}/README.md

@@ -128,7 +128,7 @@ dolibarr> exit
 
 | 命令 | 说明 |
 |------|------|
-| `schema refresh --admin-api-key KEY` | 一键刷新：sync → extrafields → enrich |
+| `schema refresh --admin-api-key KEY` | 一键刷新：sync → extrafields → enrich → auto-infer |
 | `schema sync` | 从 Dolibarr swagger 端点拉取最新 API 定义 |
 | `schema extrafields --admin-api-key KEY` | 拉取自定义字段定义并注入 schema（需管理员 key） |
 | `schema enrich` | 用 models_supplement.json 补全 model 字段定义（sync 后必须执行） |
@@ -233,6 +233,10 @@ python -m vllm.entrypoints.openai.api_server \
 | `DOLIBARR_URL` | API 完整地址，例如 `https://your-dolibarr.example.com/api/index.php` |
 | `DOLIBARR_API_KEY` | Dolibarr 用户设置中的 API Key |
 | `DOLIBARR_VERIFY_SSL` | 设为 `1` 或 `true` 启用 SSL 证书验证 |
+| `DOLIBARR_ADMIN_API_KEY` | 管理员 API Key，用于拉取自定义字段定义 |
+| `OPENAI_API_KEY` | OpenAI 兼容 API Key，用于 auto-infer 生成精确中文描述（可选） |
+| `OPENAI_BASE_URL` | OpenAI 兼容 API 地址（默认 `https://api.openai.com/v1`，可选） |
+| `OPENAI_MODEL` | 使用的模型名称（默认 `gpt-4o-mini`，可选） |
 
 配置文件路径：`~/.config/cli-dolibarr/config.json`
 

cli_dolibarr-3.2.0/cli_dolibarr/dolibarr/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.2.0"

{cli_dolibarr-3.1.2 → cli_dolibarr-3.2.0}/cli_dolibarr/dolibarr/commands/schema.py

@@ -348,12 +348,13 @@ def extrafields(ctx, admin_api_key):
               help='Admin API key. Falls back to DOLIBARR_ADMIN_API_KEY env var.')
 @click.pass_context
 def refresh(ctx, admin_api_key):
-    """Full schema refresh: sync + extrafields + enrich.
+    """Full schema refresh: sync + extrafields + enrich + auto-infer.
 
     One-command pipeline that:
     1. Syncs API schema from Dolibarr swagger
     2. Fetches extrafield definitions (admin key via --admin-api-key or DOLIBARR_ADMIN_API_KEY)
     3. Enriches models with supplement definitions
+    4. Auto-infers remaining bad models
     """
     client = _get_client(ctx)
     resolved_key = _resolve_admin_key(ctx, admin_api_key)
@@ -363,7 +364,7 @@ def refresh(ctx, admin_api_key):
         manager = SchemaManager()
         click.echo("Refreshing schema...")
 
-        click.echo("  [1/3] Syncing from Dolibarr swagger...")
+        click.echo("  [1/4] Syncing from Dolibarr swagger...")
         swagger = manager.fetch_swagger(client)
         schema = manager.normalize(swagger)
         manager.save(schema)
@@ -371,7 +372,7 @@ def refresh(ctx, admin_api_key):
         models_count = len(schema['models'])
         click.echo(f"         {endpoints} endpoints, {models_count} models")
 
-        click.echo("  [2/3] Fetching extrafields...")
+        click.echo("  [2/4] Fetching extrafields...")
         ef_stats = {'injected_models': 0, 'injected_fields': 0, 'elementtypes': 0}
         try:
             ef_data = manager.fetch_extrafields(client)
@@ -381,11 +382,24 @@ def refresh(ctx, admin_api_key):
         except RuntimeError:
             click.echo("         Skipped (requires admin API key)")
 
-        click.echo("  [3/3] Enriching models...")
+        click.echo("  [3/4] Enriching models...")
         enrich_stats = manager.enrich()
         click.echo(f"         {enrich_stats['enriched']} enriched, "
                     f"{enrich_stats['skipped_good']} already good")
 
+        click.echo("  [4/4] Auto-inferring remaining models...")
+        infer_stats = {'inferred': 0, 'skipped_action': 0, 'skipped_no_data': 0, 'skipped_no_endpoint': 0}
+        try:
+            infer_stats = manager.auto_infer(client)
+            if infer_stats['inferred'] > 0:
+                click.echo(f"         {infer_stats['inferred']} models auto-inferred")
+            else:
+                click.echo("         No models to infer")
+            if infer_stats.get('skipped_no_endpoint', 0) > 0:
+                click.echo(f"         {infer_stats['skipped_no_endpoint']} skipped (no GET endpoint)")
+        except Exception:
+            click.echo("         Skipped (unexpected error)")
+
         click.echo("\nRefresh complete.")
     except DolibarrAPIError as e:
         click.echo(f"Error: {e.message}", err=True)

{cli_dolibarr-3.1.2 → cli_dolibarr-3.2.0}/cli_dolibarr/dolibarr/core/schema_manager.py

@@ -11,9 +11,12 @@ Schema file location: cli_dolibarr/dolibarr/schema.json
 import csv
 import io
 import json
+import os
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
+
+import requests
 
 COMMANDS_DIR = Path(__file__).parent.parent / 'commands'
 
@@ -61,6 +64,24 @@ class SchemaManager:
         'separate': 'string',
     }
 
+    _READONLY_FIELDS = frozenset({
+        'id', 'rowid', 'entity', 'ref', 'ref_ext',
+        'date_creation', 'date_modification', 'tms',
+        'fk_user_creat', 'fk_user_modif', 'user_creation', 'user_modification',
+        'total_ht', 'total_tva', 'total_ttc', 'total_localtax1', 'total_localtax2',
+        'paye', 'close_code', 'close_note',
+        'linkedObjects', 'linkedObjectsIds', 'extraparams',
+        'rang', 'import_key', 'model_pdf', 'last_main_doc',
+        'fk_statut', 'statut',
+    })
+
+    _ACTION_MODEL_SUFFIXES = frozenset({
+        'ValidateModel', 'CloseModel', 'SettopaidModel', 'SettodraftModel',
+        'SettounpaidModel', 'ReopenModel', 'SetinvoicedModel',
+        'MakeorderModel', 'ReceiveOrderModel', 'ApproveModel',
+        'MarkAsCreditAvailableModel', 'ProduceandconsumeModel', 'ProduceandconsumeallModel',
+    })
+
     def __init__(self):
         self.data: Optional[Dict[str, Any]] = None
 
@@ -100,7 +121,9 @@ class SchemaManager:
 
         for model_name, model_def in models.items():
             props = model_def.get('properties', {})
-            is_bad = len(props) == 1 and 'request_data' in props
+            prop_names = set(props.keys())
+            substantive = prop_names - {'request_data', 'dummy', 'array_options'}
+            is_bad = not substantive
 
             if model_name in supplement:
                 if is_bad:
@@ -201,6 +224,242 @@ class SchemaManager:
             'elementtypes': elementtypes,
         }
 
+    # ── Auto-infer (T7) ─────────────────────────────────────────────
+
+    @staticmethod
+    def _infer_model_to_get_path(model_name: str, schema: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Find a GET endpoint that returns data matching the given model.
+
+        Returns dict with 'path' template, 'is_line' flag, and 'group',
+        or None if no suitable endpoint found.
+        """
+        for suffix in SchemaManager._ACTION_MODEL_SUFFIXES:
+            if model_name.endswith(suffix):
+                return None
+
+        endpoints = schema.get('endpoints', [])
+        matched_groups: List[Tuple[str, bool]] = []
+        for ep in endpoints:
+            if ep.get('method') != 'POST':
+                continue
+            if ep.get('request_body') != model_name:
+                continue
+            path = ep.get('path', '')
+            group = SchemaManager._extract_group(path)
+            is_line = '/lines' in path
+            matched_groups.append((group, is_line))
+
+        if not matched_groups:
+            return None
+
+        group, is_line = matched_groups[0]
+
+        if is_line:
+            return {
+                'path': f'/{group}/{{id}}/lines',
+                'is_line': True,
+                'group': group,
+            }
+
+        for ep in endpoints:
+            if ep.get('method') != 'GET':
+                continue
+            ep_group = SchemaManager._extract_group(ep.get('path', ''))
+            if ep_group != group:
+                continue
+            path = ep.get('path', '')
+            if '{id}' not in path.split('/')[-1]:
+                return {
+                    'path': f'/{group}',
+                    'is_line': False,
+                    'group': group,
+                }
+
+        return None
+
+    @staticmethod
+    def _filter_writable_fields(data: Dict[str, Any]) -> Dict[str, Any]:
+        """Remove readonly fields from a GET response dict."""
+        filtered = {}
+        for key, value in data.items():
+            if key in SchemaManager._READONLY_FIELDS:
+                continue
+            if value is None and (key.startswith('date_') or key.startswith('fk_user_')):
+                continue
+            filtered[key] = value
+        return filtered
+
+    @staticmethod
+    def _infer_field_type(value: Any) -> str:
+        """Infer JSON schema type from a Python value."""
+        if isinstance(value, bool):
+            return 'integer'  # Dolibarr uses 0/1 booleans
+        if isinstance(value, int):
+            return 'integer'
+        if isinstance(value, float):
+            return 'number'
+        if isinstance(value, str):
+            return 'string'
+        if isinstance(value, list):
+            return 'array'
+        if isinstance(value, dict):
+            return 'object'
+        return 'string'
+
+    @staticmethod
+    def _call_ai_for_descriptions(model_name: str, fields_with_types: Dict[str, str],
+                                  sample_data: Dict[str, Any]) -> Optional[Dict[str, str]]:
+        """Call OpenAI-compatible API to generate Chinese descriptions for fields."""
+        api_key = os.environ.get('OPENAI_API_KEY')
+        if not api_key:
+            return None
+
+        base_url = os.environ.get('OPENAI_BASE_URL', 'https://api.openai.com/v1')
+        model = os.environ.get('OPENAI_MODEL', 'gpt-4o-mini')
+
+        field_list = ', '.join(fields_with_types.keys())
+        prompt = (
+            f"Given the Dolibarr ERP model '{model_name}' with these fields: [{field_list}], "
+            f"and this sample API response data: {json.dumps(sample_data, default=str, ensure_ascii=False)[:2000]}, "
+            f"provide a short Chinese description for each field. "
+            f"Return ONLY a JSON object mapping field_name to description string. "
+            f"Example: {{\"socid\": \"客户 ID\"}}"
+        )
+
+        try:
+            resp = requests.post(
+                f"{base_url}/chat/completions",
+                headers={
+                    'Authorization': f'Bearer {api_key}',
+                    'Content-Type': 'application/json',
+                },
+                json={
+                    'model': model,
+                    'messages': [{'role': 'user', 'content': prompt}],
+                    'temperature': 0.1,
+                },
+                timeout=30,
+            )
+            resp.raise_for_status()
+            content = resp.json()['choices'][0]['message']['content']
+            if '```' in content:
+                content = content.split('```')[1]
+                if content.startswith('json'):
+                    content = content[4:]
+            return json.loads(content.strip())
+        except Exception:
+            return None
+
+    def auto_infer(self, client) -> Dict[str, int]:
+        """Auto-infer field definitions for bad models by sampling GET endpoints.
+
+        Returns stats: {'inferred': N, 'skipped_action': N, 'skipped_no_data': N, 'skipped_no_endpoint': N}
+        """
+        schema = self.load()
+        if schema is None:
+            return {'inferred': 0, 'skipped_action': 0, 'skipped_no_data': 0, 'skipped_no_endpoint': 0}
+
+        models = schema.get('models', {})
+        supplement = self._load_supplement()
+
+        bad_models: List[str] = []
+        for model_name, model_def in models.items():
+            props = model_def.get('properties', {})
+            prop_names = set(props.keys())
+            substantive = prop_names - {'request_data', 'dummy', 'array_options'}
+            if not substantive:
+                bad_models.append(model_name)
+
+        stats = {'inferred': 0, 'skipped_action': 0, 'skipped_no_data': 0, 'skipped_no_endpoint': 0}
+
+        base = client.base_url.rstrip('/')
+
+        for model_name in bad_models:
+            if model_name in supplement:
+                continue
+
+            is_action = any(model_name.endswith(s) for s in self._ACTION_MODEL_SUFFIXES)
+            if is_action:
+                stats['skipped_action'] += 1
+                continue
+
+            path_info = self._infer_model_to_get_path(model_name, schema)
+            if path_info is None:
+                stats['skipped_no_endpoint'] += 1
+                continue
+
+            sample_data: Optional[Dict[str, Any]] = None
+
+            if path_info['is_line']:
+                group = path_info['group']
+                list_url = f"{base}/{group}"
+                try:
+                    list_resp = client.session.get(list_url, params={'limit': 1})
+                    if list_resp.status_code == 200:
+                        list_data = list_resp.json()
+                        if isinstance(list_data, list) and len(list_data) > 0:
+                            parent_id = list_data[0].get('id') or list_data[0].get('rowid')
+                            if parent_id:
+                                detail_url = f"{base}/{group}/{parent_id}/lines"
+                                detail_resp = client.session.get(detail_url, params={'limit': 1})
+                                if detail_resp.status_code == 200:
+                                    detail_data = detail_resp.json()
+                                    if isinstance(detail_data, list) and len(detail_data) > 0:
+                                        sample_data = detail_data[0]
+                                    elif isinstance(detail_data, dict):
+                                        sample_data = detail_data
+                except Exception:
+                    pass
+            else:
+                list_url = f"{base}{path_info['path']}"
+                try:
+                    list_resp = client.session.get(list_url, params={'limit': 1})
+                    if list_resp.status_code == 200:
+                        list_data = list_resp.json()
+                        if isinstance(list_data, list) and len(list_data) > 0:
+                            sample_data = list_data[0]
+                except Exception:
+                    pass
+
+            if sample_data is None:
+                stats['skipped_no_data'] += 1
+                continue
+
+            writable = self._filter_writable_fields(sample_data)
+            if not writable:
+                stats['skipped_no_data'] += 1
+                continue
+
+            fields_with_types: Dict[str, str] = {}
+            for key, value in writable.items():
+                fields_with_types[key] = self._infer_field_type(value)
+
+            ai_desc = self._call_ai_for_descriptions(model_name, fields_with_types, sample_data)
+
+            properties: Dict[str, Any] = {}
+            for key, type_name in fields_with_types.items():
+                prop: Dict[str, Any] = {'type': type_name}
+                if ai_desc and key in ai_desc:
+                    prop['description'] = ai_desc[key]
+                else:
+                    prop['description'] = key
+                properties[key] = prop
+
+            new_def: Dict[str, Any] = {
+                'properties': properties,
+                'auto_inferred': True,
+            }
+
+            supplement[model_name] = new_def
+            stats['inferred'] += 1
+
+        if stats['inferred'] > 0:
+            self.SUPPLEMENT_PATH.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.SUPPLEMENT_PATH, 'w', encoding='utf-8') as f:
+                json.dump(supplement, f, indent=2, ensure_ascii=False)
+
+        return stats
+
     def refresh(self, client) -> Dict[str, Any]:
         """Full schema refresh: sync + extrafields + enrich.
 
@@ -208,13 +467,12 @@ class SchemaManager:
         1. Syncs API schema from Dolibarr swagger
         2. Fetches extrafield definitions (best-effort, skips if no admin key)
         3. Enriches models with supplement definitions
+        4. Auto-infers remaining bad models (best-effort)
         """
-        # Step 1: sync
         swagger = self.fetch_swagger(client)
         schema = self.normalize(swagger)
         self.save(schema)
 
-        # Step 2: extrafields (best-effort)
         ef_stats = {'injected_models': 0, 'injected_fields': 0, 'elementtypes': 0}
         try:
             ef_data = self.fetch_extrafields(client)
@@ -222,14 +480,22 @@ class SchemaManager:
         except RuntimeError:
             pass
 
-        # Step 3: enrich
         enrich_stats = self.enrich()
 
+        infer_stats = {'inferred': 0, 'skipped_action': 0, 'skipped_no_data': 0, 'skipped_no_endpoint': 0}
+        try:
+            infer_stats = self.auto_infer(client)
+            if infer_stats['inferred'] > 0:
+                self.enrich()
+        except Exception:
+            pass
+
         return {
             'endpoints': len(schema['endpoints']),
             'models': len(schema['models']),
             'extrafields': ef_stats,
             'enrich': enrich_stats,
+            'auto_infer': infer_stats,
         }
 
     def fetch_swagger(self, client) -> Dict[str, Any]: