kcode-pi 0.1.5 → 0.1.7

package/vendor/kingdee-skills/ok-cosmic/scripts/script_utils.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: NOASSERTION
-"""Small CLI helpers shared by ok-cosmic scripts."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from typing import Callable, Optional
-
-
-class FriendlyArgumentParser(argparse.ArgumentParser):
-    """ArgumentParser that reports concise failures instead of dumping usage."""
-
-    def error(self, message: str) -> None:
-        self.exit(1, f"✖️ 参数错误: {message}\n提示: 使用 --help 查看参数。\n")
-
-
-def run_cli(main_func: Callable[[], Optional[int]]) -> int:
-    """Run a CLI entrypoint and convert uncaught exceptions to failure text."""
-
-    try:
-        result = main_func()
-        if isinstance(result, int):
-            return result
-        return 0
-    except SystemExit as e:
-        code = e.code
-        if code is None:
-            return 0
-        if isinstance(code, int):
-            return code
-        print(f"✖️ 执行失败: {code}", file=sys.stderr)
-        return 1
-    except KeyboardInterrupt:
-        print("✖️ 执行已取消", file=sys.stderr)
-        return 130
-    except Exception as e:
-        print(f"✖️ 执行失败: {e}", file=sys.stderr)
-        return 1

package/vendor/kingdee-skills/ok-cosmic/scripts/sqlite_cache.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: NOASSERTION
-"""Shared SQLite JSON cache helpers for ok-cosmic scripts."""
-
-import json
-import os
-import re
-import sqlite3
-import sys
-import time
-from typing import Any, Dict, Iterable, Optional, Sequence
-
-
-IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
-
-
-def resolve_graph_db_path(config: Dict[str, Any], missing_message: str) -> str:
-    """Resolve graph.dbPath relative to ok-cosmic.json's directory."""
-    graph_config = config.get("graph", {})
-    if not isinstance(graph_config, dict):
-        graph_config = {}
-
-    db_path = str(graph_config.get("dbPath", "")).strip()
-    if not db_path:
-        raise ValueError(missing_message)
-
-    raw_db_path = os.path.expanduser(db_path)
-    if os.path.isabs(raw_db_path):
-        return os.path.normpath(raw_db_path)
-
-    base_dir = str(config.get("__config_dir__", "")).strip() or os.getcwd()
-    return os.path.normpath(os.path.abspath(os.path.join(base_dir, raw_db_path)))
-
-
-def _validate_identifier(value: str, label: str) -> str:
-    if not IDENTIFIER_RE.match(value):
-        raise ValueError(f"{label} 不是安全的 SQLite 标识符: {value}")
-    return value
-
-
-class JsonSqliteCache:
-    """Small SQLite cache storing JSON payload + updated_at with TTL."""
-
-    def __init__(
-        self,
-        db_path: str,
-        *,
-        table_name: str,
-        key_column: str,
-        create_sql: str,
-        ttl: int = 600,
-        check_same_thread: bool = True,
-        init_error_message: str = "初始化缓存表失败",
-        write_error_message: str = "写入缓存失败",
-    ):
-        self.db_path = db_path
-        self.table_name = _validate_identifier(table_name, "table_name")
-        self.key_column = _validate_identifier(key_column, "key_column")
-        self.ttl = ttl
-        self.init_error_message = init_error_message
-        self.write_error_message = write_error_message
-        self._conn = sqlite3.connect(self.db_path, check_same_thread=check_same_thread)
-        self._conn.execute("PRAGMA journal_mode=WAL")
-        self._conn.execute("PRAGMA busy_timeout=5000")
-        self._conn.row_factory = sqlite3.Row
-        self._init_db(create_sql)
-
-    def _init_db(self, create_sql: str) -> None:
-        try:
-            self._conn.execute(create_sql)
-            self._conn.commit()
-        except Exception as e:
-            print(f" (DEBUG) {self.init_error_message}: {e}", file=sys.stderr)
-
-    def get(self, key: str) -> Optional[Dict[str, Any]]:
-        try:
-            row = self._conn.execute(
-                f"SELECT payload, updated_at FROM {self.table_name} WHERE {self.key_column} = ?",
-                (key,),
-            ).fetchone()
-            if not row or (time.time() - row["updated_at"] > self.ttl):
-                return None
-            return json.loads(row["payload"])
-        except Exception:
-            return None
-
-    def set_payload(
-        self,
-        key: str,
-        payload: Dict[str, Any],
-        *,
-        extra_columns: Optional[Sequence[str]] = None,
-        extra_values: Optional[Sequence[Any]] = None,
-    ) -> None:
-        extra_columns = tuple(extra_columns or ())
-        extra_values = tuple(extra_values or ())
-        if len(extra_columns) != len(extra_values):
-            raise ValueError("extra_columns 和 extra_values 数量不一致")
-        for column in extra_columns:
-            _validate_identifier(column, "extra_column")
-
-        columns = (self.key_column, *extra_columns, "payload", "updated_at")
-        placeholders = ", ".join("?" for _ in columns)
-        column_sql = ", ".join(columns)
-        values = (
-            key,
-            *extra_values,
-            json.dumps(payload, ensure_ascii=False),
-            int(time.time()),
-        )
-
-        try:
-            self._conn.execute(
-                f"""
-                INSERT OR REPLACE INTO {self.table_name}
-                ({column_sql})
-                VALUES ({placeholders})
-                """,
-                values,
-            )
-            self._conn.commit()
-        except Exception as e:
-            print(f" (DEBUG) {self.write_error_message}: {e}", file=sys.stderr)
-
-    def remove(self, key: str) -> None:
-        try:
-            self._conn.execute(
-                f"DELETE FROM {self.table_name} WHERE {self.key_column} = ?",
-                (key,),
-            )
-            self._conn.commit()
-        except Exception:
-            pass
-
-    def close(self) -> None:
-        try:
-            self._conn.close()
-        except Exception:
-            pass
-
-    def __del__(self):
-        self.close()

package/vendor/kingdee-skills/ok-cosmic/setup/setup-mac.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-# ok-cosmic-knowledge 离线 API 知识图谱构建工具
-# 用法: ./setup-mac.sh [参数]
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-JAR_FILE="$SCRIPT_DIR/setup.jar"
-
-if ! command -v java &> /dev/null; then
-    echo "错误: 未找到 java 命令，请安装 JDK 8+"
-    exit 1
-fi
-
-if [ ! -f "$JAR_FILE" ]; then
-    echo "请确认发布包完整，或重新获取包含 setup.jar 的安装包"
-    exit 1
-fi
-
-java -jar "$JAR_FILE" "$@"

package/vendor/kingdee-skills/ok-cosmic/setup/setup-windows.bat

@@ -1,53 +0,0 @@
-@echo off
-setlocal
-REM ok-cosmic-knowledge 离线 API 知识图谱构建工具
-REM 用法: setup-windows.bat [参数]
-
-chcp 65001 >nul 2>nul
-
-set "SCRIPT_DIR=%~dp0"
-set "JAR_FILE=%SCRIPT_DIR%setup.jar"
-set "EXIT_CODE=0"
-set "PAUSE_ON_EXIT="
-
-REM Explorer 双击通常通过 cmd.exe /c 启动，执行结束后窗口会立即关闭。
-echo %CMDCMDLINE% | findstr /I /C:" /c " >nul && set "PAUSE_ON_EXIT=1"
-
-if not exist "%JAR_FILE%" (
-    echo 错误: setup.jar 文件不存在: "%JAR_FILE%"
-    echo 请确认发布包完整，或重新获取包含 setup.jar 的安装包
-    set "EXIT_CODE=1"
-    goto end
-)
-
-where java >nul 2>nul
-if errorlevel 1 (
-    echo 错误: 未找到 java 命令，请先安装 JRE/JDK 并配置 PATH。
-    set "EXIT_CODE=1"
-    goto end
-)
-
-pushd "%SCRIPT_DIR%" >nul 2>nul
-if errorlevel 1 (
-    echo 错误: 无法进入脚本目录: "%SCRIPT_DIR%"
-    set "EXIT_CODE=1"
-    goto end
-)
-
-java -jar "%JAR_FILE%" %*
-set "EXIT_CODE=%ERRORLEVEL%"
-popd >nul
-
-:end
-if defined PAUSE_ON_EXIT (
-    echo.
-    if "%EXIT_CODE%"=="0" (
-        echo 执行完成，按任意键关闭窗口...
-    ) else (
-        echo 执行失败，退出码: %EXIT_CODE%
-        echo 按任意键关闭窗口...
-    )
-    pause >nul
-)
-
-exit /b %EXIT_CODE%

package/vendor/kingdee-skills/ok-ksql/scripts/ksql_lint.py

@@ -1,363 +0,0 @@
-#!/usr/bin/env python3
-"""Static checks for ok-ksql generated PostgreSQL data-fix SQL files.
-
-The linter is intentionally dependency-free and conservative: it catches the
-high-risk patterns required by the ok-ksql skill, but it is not a full SQL
-parser. Fix reported ERROR items before delivery. WARN items document style
-preferences that may be acceptable only with an explicit reason.
-"""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable, Iterator, Sequence
-
-
-TIMESTAMP_RE = re.compile(r"\b\d{12}\b")
-BACKUP_TABLE_RE = re.compile(r"\bbak_[a-zA-Z0-9_]+_(\d{12})\b", re.IGNORECASE)
-FILE_TS_RE = re.compile(r"ksql_[^/\\]*_(\d{12})\.txt$", re.IGNORECASE)
-HEADER_TS_RE = re.compile(r"备份表时间戳[：:]\s*(\d{12})")
-
-
-@dataclass(frozen=True)
-class Finding:
-    severity: str
-    line: int
-    message: str
-
-    def format(self, path: Path) -> str:
-        return f"{path}:{self.line}: {self.severity}: {self.message}"
-
-
-@dataclass(frozen=True)
-class Statement:
-    text: str
-    line: int
-
-
-def strip_comments_and_literals(sql: str) -> str:
-    """Return SQL with comments and quoted literals replaced by spaces.
-
-    This keeps line numbers stable while avoiding false positives from words
-    appearing inside comments or strings.
-    """
-
-    out: list[str] = []
-    i = 0
-    n = len(sql)
-    state = "normal"
-    dollar_tag = ""
-
-    while i < n:
-        ch = sql[i]
-        nxt = sql[i + 1] if i + 1 < n else ""
-
-        if state == "normal":
-            if ch == "-" and nxt == "-":
-                out.extend([" ", " "])
-                i += 2
-                state = "line_comment"
-                continue
-            if ch == "/" and nxt == "*":
-                out.extend([" ", " "])
-                i += 2
-                state = "block_comment"
-                continue
-            if ch == "'":
-                out.append(" ")
-                i += 1
-                state = "single_quote"
-                continue
-            if ch == '"':
-                out.append(" ")
-                i += 1
-                state = "double_quote"
-                continue
-            if ch == "$":
-                match = re.match(r"\$[A-Za-z_][A-Za-z0-9_]*\$|\$\$", sql[i:])
-                if match:
-                    dollar_tag = match.group(0)
-                    out.extend(" " * len(dollar_tag))
-                    i += len(dollar_tag)
-                    state = "dollar_quote"
-                    continue
-            out.append(ch)
-            i += 1
-            continue
-
-        if state == "line_comment":
-            out.append("\n" if ch == "\n" else " ")
-            i += 1
-            if ch == "\n":
-                state = "normal"
-            continue
-
-        if state == "block_comment":
-            if ch == "*" and nxt == "/":
-                out.extend([" ", " "])
-                i += 2
-                state = "normal"
-            else:
-                out.append("\n" if ch == "\n" else " ")
-                i += 1
-            continue
-
-        if state == "single_quote":
-            if ch == "'" and nxt == "'":
-                out.extend([" ", " "])
-                i += 2
-            else:
-                out.append("\n" if ch == "\n" else " ")
-                i += 1
-                if ch == "'":
-                    state = "normal"
-            continue
-
-        if state == "double_quote":
-            if ch == '"' and nxt == '"':
-                out.extend([" ", " "])
-                i += 2
-            else:
-                out.append("\n" if ch == "\n" else " ")
-                i += 1
-                if ch == '"':
-                    state = "normal"
-            continue
-
-        if state == "dollar_quote":
-            if sql.startswith(dollar_tag, i):
-                out.extend(" " * len(dollar_tag))
-                i += len(dollar_tag)
-                state = "normal"
-                dollar_tag = ""
-            else:
-                out.append("\n" if ch == "\n" else " ")
-                i += 1
-            continue
-
-    return "".join(out)
-
-
-def iter_statements(masked_sql: str) -> Iterator[Statement]:
-    start = 0
-    start_line = 1
-    line = 1
-
-    for idx, ch in enumerate(masked_sql):
-        if ch == ";":
-            text = masked_sql[start : idx + 1]
-            if text.strip():
-                yield Statement(text=text, line=start_line)
-            start = idx + 1
-            start_line = line
-        if ch == "\n":
-            line += 1
-            if not masked_sql[start:idx].strip():
-                start_line = line
-
-    tail = masked_sql[start:]
-    if tail.strip():
-        yield Statement(text=tail, line=start_line)
-
-
-def line_of_offset(text: str, base_line: int, offset: int) -> int:
-    return base_line + text[:offset].count("\n")
-
-
-def has_token(statement: str, token: str) -> bool:
-    return re.search(rf"\b{re.escape(token)}\b", statement, re.IGNORECASE) is not None
-
-
-def lint_statement(stmt: Statement) -> list[Finding]:
-    findings: list[Finding] = []
-    compact = " ".join(stmt.text.split())
-    if not compact:
-        return findings
-
-    first = re.match(r"^\s*(\w+)", compact)
-    first_word = first.group(1).upper() if first else ""
-
-    if first_word in {"UPDATE", "DELETE"} and not has_token(stmt.text, "WHERE"):
-        findings.append(
-            Finding(
-                "ERROR",
-                stmt.line,
-                f"{first_word} 语句缺少 WHERE，禁止生成无范围更新/删除。",
-            )
-        )
-
-    select_star_matches = list(re.finditer(r"\bSELECT\s+\*", stmt.text, re.IGNORECASE))
-    if select_star_matches:
-        is_backup = re.search(
-            r"\bSELECT\s+\*\s+INTO\s+bak_[a-zA-Z0-9_]+_\d{12}\s+FROM\b",
-            stmt.text,
-            re.IGNORECASE,
-        )
-        if is_backup:
-            if has_token(stmt.text, "WHERE"):
-                findings.append(
-                    Finding(
-                        "ERROR",
-                        stmt.line,
-                        "备份语句必须整表备份，SELECT * INTO bak_... 不允许带 WHERE。",
-                    )
-                )
-        else:
-            for match in select_star_matches:
-                findings.append(
-                    Finding(
-                        "ERROR",
-                        line_of_offset(stmt.text, stmt.line, match.start()),
-                        "查询/验证语句禁止 SELECT *；只有整表备份 SELECT * INTO bak_... 例外。",
-                    )
-                )
-
-    if re.search(r"\bSELECT\s+\*\s+INTO\b", stmt.text, re.IGNORECASE) and not re.search(
-        r"\bSELECT\s+\*\s+INTO\s+bak_[a-zA-Z0-9_]+_\d{12}\s+FROM\b",
-        stmt.text,
-        re.IGNORECASE,
-    ):
-        findings.append(
-            Finding(
-                "ERROR",
-                stmt.line,
-                "备份表名必须形如 bak_<原表或业务缩写>_<yyyyMMddHHmm>。",
-            )
-        )
-
-    for match in re.finditer(r"\bEXISTS\b", stmt.text, re.IGNORECASE):
-        findings.append(
-            Finding(
-                "WARN",
-                line_of_offset(stmt.text, stmt.line, match.start()),
-                "SQL 可读性偏好：成员关系/半连接默认使用 IN，只有 IN 改变语义时才保留 EXISTS 并说明原因。",
-            )
-        )
-
-    if re.search(r"\bUPDATE\b.+\bJOIN\b", compact, re.IGNORECASE):
-        findings.append(
-            Finding(
-                "WARN",
-                stmt.line,
-                "PostgreSQL 多表更新优先使用 UPDATE ... FROM ... WHERE ...，不要使用 MySQL 风格 UPDATE ... JOIN。",
-            )
-        )
-
-    if re.search(r"=\s*NULL\b|\bNULL\s*=", stmt.text, re.IGNORECASE):
-        findings.append(
-            Finding(
-                "ERROR",
-                stmt.line,
-                "NULL 判断必须使用 IS NULL / IS NOT NULL，不能使用 = NULL。",
-            )
-        )
-
-    if re.search(r"<>|!=", stmt.text) and has_token(stmt.text, "NULL"):
-        findings.append(
-            Finding(
-                "WARN",
-                stmt.line,
-                "涉及 NULL 的不等比较需确认语义；PostgreSQL 可优先使用 IS DISTINCT FROM。",
-            )
-        )
-
-    return findings
-
-
-def lint_timestamps(path: Path, raw_sql: str) -> list[Finding]:
-    findings: list[Finding] = []
-    backup_timestamps = set(BACKUP_TABLE_RE.findall(raw_sql))
-
-    if len(backup_timestamps) > 1:
-        findings.append(
-            Finding(
-                "ERROR",
-                1,
-                "同一 SQL 文件中出现多个备份表时间戳；桌面文件、备份表和文件头时间戳必须一致。",
-            )
-        )
-
-    file_match = FILE_TS_RE.search(path.name)
-    if file_match and backup_timestamps and file_match.group(1) not in backup_timestamps:
-        findings.append(
-            Finding(
-                "ERROR",
-                1,
-                f"文件名时间戳 {file_match.group(1)} 与备份表时间戳 {', '.join(sorted(backup_timestamps))} 不一致。",
-            )
-        )
-
-    header_matches = list(HEADER_TS_RE.finditer(raw_sql))
-    header_timestamps = {m.group(1) for m in header_matches}
-    if len(header_timestamps) > 1:
-        findings.append(Finding("ERROR", 1, "文件头出现多个不同的备份表时间戳。"))
-    if header_timestamps and backup_timestamps and header_timestamps != backup_timestamps:
-        findings.append(
-            Finding(
-                "ERROR",
-                1,
-                f"文件头时间戳 {', '.join(sorted(header_timestamps))} 与备份表时间戳 {', '.join(sorted(backup_timestamps))} 不一致。",
-            )
-        )
-
-    return findings
-
-
-def lint_file(path: Path) -> list[Finding]:
-    raw_sql = path.read_text(encoding="utf-8")
-    masked_sql = strip_comments_and_literals(raw_sql)
-
-    findings: list[Finding] = []
-    findings.extend(lint_timestamps(path, raw_sql))
-    for stmt in iter_statements(masked_sql):
-        findings.extend(lint_statement(stmt))
-    return sorted(findings, key=lambda f: (f.line, f.severity, f.message))
-
-
-def parse_args(argv: Sequence[str]) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Lint ok-ksql generated PostgreSQL data-fix SQL files."
-    )
-    parser.add_argument("paths", nargs="+", type=Path, help="SQL/.txt files to lint")
-    parser.add_argument(
-        "--strict",
-        action="store_true",
-        help="treat WARN findings as failures",
-    )
-    return parser.parse_args(argv)
-
-
-def main(argv: Sequence[str] | None = None) -> int:
-    args = parse_args(sys.argv[1:] if argv is None else argv)
-    all_findings: list[tuple[Path, Finding]] = []
-
-    for path in args.paths:
-        if not path.exists():
-            print(f"{path}:1: ERROR: 文件不存在。", file=sys.stderr)
-            return 2
-        if path.is_dir():
-            print(f"{path}:1: ERROR: 请输入 SQL/.txt 文件，不能是目录。", file=sys.stderr)
-            return 2
-        for finding in lint_file(path):
-            all_findings.append((path, finding))
-
-    for path, finding in all_findings:
-        print(finding.format(path))
-
-    error_count = sum(1 for _, f in all_findings if f.severity == "ERROR")
-    warn_count = sum(1 for _, f in all_findings if f.severity == "WARN")
-    print(f"SUMMARY: {error_count} error(s), {warn_count} warning(s)")
-
-    if error_count:
-        return 1
-    if args.strict and warn_count:
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())