@agentunion/kite 1.3.2 → 1.4.0

package/kite_cli/utils/interactive.py

@@ -0,0 +1,63 @@
+"""交互式问答工具"""
+
+
+def select_source(candidates: list) -> dict:
+    """让用户选择来源"""
+    print("\n找到多个来源:")
+    for i, candidate in enumerate(candidates, 1):
+        platform = candidate["platform"]
+        name = candidate.get("name", "")
+        version = candidate.get("latest", candidate.get("version", ""))
+        desc = candidate.get("description", "")
+
+        if platform == "pypi":
+            print(f"  [{i}] PyPI: {name} v{version}")
+        elif platform == "npm":
+            print(f"  [{i}] npm: {name} v{version}")
+        elif platform == "git":
+            full_name = candidate.get("full_name", name)
+            print(f"  [{i}] Git: {full_name}")
+            if desc:
+                print(f"      {desc}")
+        elif platform == "local":
+            print(f"  [{i}] 本地: {candidate.get('path', '')}")
+
+    while True:
+        try:
+            choice = input("\n? 选择来源 [1]: ").strip() or "1"
+            index = int(choice) - 1
+            if 0 <= index < len(candidates):
+                return candidates[index]
+            print("无效选择，请重试")
+        except (ValueError, KeyboardInterrupt):
+            return None
+
+
+def select_location() -> str:
+    """让用户选择安装位置"""
+    print("\n? 选择安装位置:")
+    print("  [1] 开发环境 (Kite/extensions/) — 用于模块开发")
+    print("  [2] 本地实例 (~/.kite/workspace/Kite/extensions/) — 当前实例专用")
+    print("  [3] 全局共享 (~/.kite/modules/) — 所有实例共享")
+
+    while True:
+        try:
+            choice = input("\n选择 [3]: ").strip() or "3"
+            if choice == "1":
+                return "dev"
+            elif choice == "2":
+                return "local"
+            elif choice == "3":
+                return "global"
+            print("无效选择，请重试")
+        except KeyboardInterrupt:
+            return None
+
+
+def confirm_action(message: str) -> bool:
+    """确认操作"""
+    try:
+        answer = input(f"{message} [y/N]: ").strip().lower()
+        return answer in ("y", "yes")
+    except KeyboardInterrupt:
+        return False

package/kite_cli/utils/operation_log.py

@@ -0,0 +1,77 @@
+"""操作日志记录"""
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+
+def get_log_file() -> Path:
+    """获取日志文件路径"""
+    # 使用 KITE_DATA 环境变量，如果没有则使用 ~/.kite/data
+    kite_data = os.environ.get("KITE_DATA")
+    if kite_data:
+        log_dir = Path(kite_data) / "cli_logs"
+    else:
+        home = Path.home()
+        log_dir = home / ".kite" / "data" / "cli_logs"
+
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir / "operations.jsonl"
+
+
+def log_operation(operation: str, details: dict, success: bool = True, error: str = None):
+    """记录操作日志"""
+    log_entry = {
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "operation": operation,
+        "details": details,
+        "success": success,
+        "error": error
+    }
+
+    try:
+        log_file = get_log_file()
+        with open(log_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
+    except Exception as e:
+        # 日志记录失败不应该影响主流程
+        print(f"[Warning] 记录操作日志失败: {e}")
+
+
+def read_operations(limit: int = 50) -> list:
+    """读取最近的操作日志"""
+    log_file = get_log_file()
+    if not log_file.exists():
+        return []
+
+    try:
+        with open(log_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        # 返回最后 N 条
+        operations = []
+        for line in lines[-limit:]:
+            try:
+                operations.append(json.loads(line.strip()))
+            except json.JSONDecodeError:
+                continue
+
+        return operations
+    except Exception as e:
+        print(f"[Error] 读取操作日志失败: {e}")
+        return []
+
+
+def get_last_operation(operation_type: str = None) -> dict:
+    """获取最后一次操作"""
+    operations = read_operations(limit=100)
+
+    if operation_type:
+        # 查找指定类型的最后一次操作
+        for op in reversed(operations):
+            if op.get("operation") == operation_type:
+                return op
+        return None
+    else:
+        # 返回最后一次操作
+        return operations[-1] if operations else None

package/kite_cli/utils/paths.py

@@ -0,0 +1,34 @@
+"""路径处理工具"""
+import os
+from pathlib import Path
+
+
+def get_install_path(location: str, module_name: str) -> Path:
+    """获取安装路径"""
+    if location == "dev":
+        # 开发环境: {KITE_PROJECT}/extensions/
+        kite_project = os.environ.get("KITE_PROJECT")
+        if not kite_project:
+            # 如果没有环境变量，使用当前目录
+            kite_project = Path.cwd()
+        return Path(kite_project) / "extensions" / module_name
+
+    elif location == "local":
+        # 本地实例: {KITE_INSTANCE_DIR}/extensions/
+        kite_instance = os.environ.get("KITE_INSTANCE_DIR")
+        if not kite_instance:
+            # 默认路径
+            home = Path.home()
+            kite_instance = home / ".kite" / "workspace" / "Kite"
+        return Path(kite_instance) / "extensions" / module_name
+
+    elif location == "global":
+        # 全局共享: {KITE_MODULES}
+        kite_modules = os.environ.get("KITE_MODULES")
+        if not kite_modules:
+            # 默认路径
+            home = Path.home()
+            kite_modules = home / ".kite" / "modules"
+        return Path(kite_modules) / module_name
+
+    raise ValueError(f"未知的安装位置: {location}")

package/kite_cli/utils/version.py

@@ -0,0 +1,308 @@
+"""版本号解析和比较工具
+
+支持 semver 版本号解析、比较和匹配。
+"""
+import re
+from typing import Tuple, Optional, List
+
+
+class Version:
+    """版本号类"""
+
+    def __init__(self, version_string: str):
+        """解析版本号字符串"""
+        self.original = version_string
+        self.major = 0
+        self.minor = 0
+        self.patch = 0
+        self.prerelease = None
+        self.build = None
+
+        self._parse(version_string)
+
+    def _parse(self, version_string: str):
+        """解析版本号"""
+        # 移除 'v' 前缀
+        version_string = version_string.lstrip('v')
+
+        # 分离 prerelease 和 build
+        if '+' in version_string:
+            version_string, self.build = version_string.split('+', 1)
+
+        if '-' in version_string:
+            version_string, self.prerelease = version_string.split('-', 1)
+
+        # 解析主版本号
+        parts = version_string.split('.')
+        if len(parts) >= 1:
+            self.major = int(parts[0]) if parts[0].isdigit() else 0
+        if len(parts) >= 2:
+            self.minor = int(parts[1]) if parts[1].isdigit() else 0
+        if len(parts) >= 3:
+            self.patch = int(parts[2]) if parts[2].isdigit() else 0
+
+    def __str__(self):
+        """转为字符串"""
+        version = f"{self.major}.{self.minor}.{self.patch}"
+        if self.prerelease:
+            version += f"-{self.prerelease}"
+        if self.build:
+            version += f"+{self.build}"
+        return version
+
+    def __repr__(self):
+        return f"Version('{self}')"
+
+    def __eq__(self, other):
+        """相等比较"""
+        if not isinstance(other, Version):
+            other = Version(str(other))
+        return (self.major, self.minor, self.patch, self.prerelease) == \
+               (other.major, other.minor, other.patch, other.prerelease)
+
+    def __lt__(self, other):
+        """小于比较"""
+        if not isinstance(other, Version):
+            other = Version(str(other))
+
+        # 比较主版本号
+        if self.major != other.major:
+            return self.major < other.major
+        if self.minor != other.minor:
+            return self.minor < other.minor
+        if self.patch != other.patch:
+            return self.patch < other.patch
+
+        # 比较 prerelease
+        if self.prerelease is None and other.prerelease is None:
+            return False
+        if self.prerelease is None:
+            return False  # 正式版 > 预发布版
+        if other.prerelease is None:
+            return True
+        return self.prerelease < other.prerelease
+
+    def __le__(self, other):
+        return self == other or self < other
+
+    def __gt__(self, other):
+        return not self <= other
+
+    def __ge__(self, other):
+        return not self < other
+
+
+class VersionSpec:
+    """版本规范类"""
+
+    def __init__(self, spec: str):
+        """解析版本规范"""
+        self.original = spec
+        self.operator = None
+        self.version = None
+        self.range_start = None
+        self.range_end = None
+
+        self._parse(spec)
+
+    def _parse(self, spec: str):
+        """解析版本规范"""
+        spec = spec.strip()
+
+        # latest
+        if spec == "latest":
+            self.operator = "latest"
+            return
+
+        # 范围: 1.0.0 - 2.0.0
+        if ' - ' in spec:
+            parts = spec.split(' - ')
+            if len(parts) == 2:
+                self.operator = "range"
+                self.range_start = Version(parts[0].strip())
+                self.range_end = Version(parts[1].strip())
+                return
+
+        # ^1.2.3 (兼容版本)
+        if spec.startswith('^'):
+            self.operator = "^"
+            self.version = Version(spec[1:])
+            return
+
+        # ~1.2.3 (近似版本)
+        if spec.startswith('~'):
+            self.operator = "~"
+            self.version = Version(spec[1:])
+            return
+
+        # >=1.2.3
+        if spec.startswith('>='):
+            self.operator = ">="
+            self.version = Version(spec[2:])
+            return
+
+        # <=1.2.3
+        if spec.startswith('<='):
+            self.operator = "<="
+            self.version = Version(spec[2:])
+            return
+
+        # >1.2.3
+        if spec.startswith('>'):
+            self.operator = ">"
+            self.version = Version(spec[1:])
+            return
+
+        # <1.2.3
+        if spec.startswith('<'):
+            self.operator = "<"
+            self.version = Version(spec[1:])
+            return
+
+        # =1.2.3 或 1.2.3 (精确版本)
+        if spec.startswith('='):
+            spec = spec[1:]
+        self.operator = "="
+        self.version = Version(spec)
+
+    def match(self, version: Version) -> bool:
+        """检查版本是否匹配规范"""
+        if not isinstance(version, Version):
+            version = Version(str(version))
+
+        if self.operator == "latest":
+            return True  # latest 匹配任何版本,由调用者选择最新
+
+        if self.operator == "=":
+            return version == self.version
+
+        if self.operator == ">":
+            return version > self.version
+
+        if self.operator == ">=":
+            return version >= self.version
+
+        if self.operator == "<":
+            return version < self.version
+
+        if self.operator == "<=":
+            return version <= self.version
+
+        if self.operator == "^":
+            # ^1.2.3 匹配 >=1.2.3 且 <2.0.0
+            if self.version.major == 0:
+                # ^0.x.y 匹配 >=0.x.y 且 <0.(x+1).0
+                return version >= self.version and \
+                       version.major == 0 and \
+                       version.minor == self.version.minor
+            else:
+                return version >= self.version and \
+                       version.major == self.version.major
+
+        if self.operator == "~":
+            # ~1.2.3 匹配 >=1.2.3 且 <1.3.0
+            return version >= self.version and \
+                   version.major == self.version.major and \
+                   version.minor == self.version.minor
+
+        if self.operator == "range":
+            return self.range_start <= version <= self.range_end
+
+        return False
+
+
+def parse_version_spec(spec: str) -> Tuple[Optional[str], Optional[str]]:
+    """解析版本规范字符串
+
+    Args:
+        spec: 版本规范,如 "pkg@1.2.0", "pkg@^1.0.0", "pkg@latest", "pkg"
+
+    Returns:
+        (package_name, version_spec) 元组
+    """
+    if '@' not in spec:
+        return spec, None
+
+    parts = spec.rsplit('@', 1)
+    if len(parts) == 2:
+        return parts[0], parts[1]
+
+    return spec, None
+
+
+def compare_versions(v1: str, v2: str) -> int:
+    """比较两个版本号
+
+    Args:
+        v1: 版本号 1
+        v2: 版本号 2
+
+    Returns:
+        -1 if v1 < v2
+         0 if v1 == v2
+         1 if v1 > v2
+    """
+    version1 = Version(v1)
+    version2 = Version(v2)
+
+    if version1 < version2:
+        return -1
+    elif version1 > version2:
+        return 1
+    else:
+        return 0
+
+
+def match_version(version: str, spec: str) -> bool:
+    """检查版本是否匹配规范
+
+    Args:
+        version: 版本号,如 "1.2.3"
+        spec: 版本规范,如 "^1.0.0", ">=1.2.0", "1.2.3"
+
+    Returns:
+        是否匹配
+    """
+    v = Version(version)
+    s = VersionSpec(spec)
+    return s.match(v)
+
+
+def get_latest_version(versions: List[str]) -> Optional[str]:
+    """从版本列表中获取最新版本
+
+    Args:
+        versions: 版本号列表
+
+    Returns:
+        最新版本号,如果列表为空则返回 None
+    """
+    if not versions:
+        return None
+
+    version_objects = [Version(v) for v in versions]
+    latest = max(version_objects)
+    return str(latest)
+
+
+def filter_versions(versions: List[str], spec: str) -> List[str]:
+    """根据版本规范过滤版本列表
+
+    Args:
+        versions: 版本号列表
+        spec: 版本规范
+
+    Returns:
+        匹配的版本列表,按版本号降序排列
+    """
+    version_spec = VersionSpec(spec)
+    matched = []
+
+    for v in versions:
+        version = Version(v)
+        if version_spec.match(version):
+            matched.append(v)
+
+    # 按版本号降序排列
+    matched.sort(key=lambda x: Version(x), reverse=True)
+    return matched