@agentunion/kite 1.5.0 → 1.6.0

package/kite_cli/core/downloader.py

@@ -33,10 +33,25 @@ class Downloader:
         # 构建包名(带版本)
         package_spec = f"{name}=={version}" if version else name
 
+        # 读取镜像源配置
+        try:
+            from kite_cli.core.config_manager import ConfigManager
+            mgr = ConfigManager()
+            pypi_mirror = mgr.get("pypi_mirror")
+        except Exception:
+            pypi_mirror = None
+
         try:
             dest.mkdir(parents=True, exist_ok=True)
+
+            cmd = ["pip", "download", package_spec, "--dest", str(dest), "--no-deps"]
+
+            # 如果配置了镜像源，添加 --index-url
+            if pypi_mirror:
+                cmd.extend(["--index-url", pypi_mirror])
+
             result = subprocess.run(
-                ["pip", "download", package_spec, "--dest", str(dest), "--no-deps"],
+                cmd,
                 capture_output=True,
                 text=True,
                 timeout=60
@@ -97,10 +112,25 @@ class Downloader:
         # 构建包名(带版本)
         package_spec = f"{name}@{version}" if version else name
 
+        # 读取 npm 镜像源配置
+        try:
+            from kite_cli.core.config_manager import ConfigManager
+            mgr = ConfigManager()
+            npm_registry = mgr.get("npm_registry")
+        except Exception:
+            npm_registry = None
+
         try:
             dest.mkdir(parents=True, exist_ok=True)
+
+            cmd = ["npm", "pack", package_spec, "--pack-destination", str(dest)]
+
+            # 如果配置了镜像源，添加 --registry
+            if npm_registry:
+                cmd.extend(["--registry", npm_registry])
+
             result = subprocess.run(
-                ["npm", "pack", package_spec, "--pack-destination", str(dest)],
+                cmd,
                 capture_output=True,
                 text=True,
                 timeout=60

package/kite_cli/main.py

@@ -6,7 +6,21 @@ from kite_cli import __version__
 from kite_cli.utils.i18n import t
 
 
-KNOWN_COMMANDS = ["install", "uninstall", "update", "list", "search", "info", "log", "rollback", "clean", "doctor", "history", "prepare", "env-check", "venv-setup", "deps-install"]
+KNOWN_COMMANDS = ["install", "uninstall", "update", "list", "search", "info", "log", "rollback", "clean", "doctor", "history", "prepare", "env-check", "venv-setup", "deps-install", "outdated", "enable", "disable", "export", "import", "config", "deps", "why", "check", "build", "install-skill"]
+
+# 命令别名映射
+COMMAND_ALIASES = {
+    "i": "install",
+    "add": "install",
+    "rm": "uninstall",
+    "remove": "uninstall",
+    "up": "update",
+    "upgrade": "update",
+    "ls": "list",
+    "show": "list",
+    "b": "build",
+    "compile": "build",
+}
 
 
 class SilentArgumentParser(argparse.ArgumentParser):
@@ -35,12 +49,13 @@ Kite CLI v{__version__} — 模块安装管理工具
   kite <命令> [参数] [选项]
 
 命令:
-  install   <source>    安装模块
-  uninstall <name>      卸载模块
-  update    <name>      更新模块（使用安装时记录的来源）
-  list                  列出已安装的模块
+  install   <source>    安装模块 (别名: i, add)
+  uninstall <name>      卸载模块 (别名: rm, remove)
+  update    <name>      更新模块（使用安装时记录的来源）(别名: up, upgrade)
+  list                  列出已安装的模块 (别名: ls, show)
   search    <keyword>   搜索可用模块
   info      <name>      显示模块详细信息
+  build     [name]      编译模块 (别名: b, compile)
   log                   查看操作日志
   history               查看最近安装的模块
   rollback              回滚最后一次操作
@@ -50,6 +65,16 @@ Kite CLI v{__version__} — 模块安装管理工具
   env-check             环境检查（虚拟环境和依赖库）
   venv-setup            创建虚拟环境
   deps-install          安装依赖库
+  outdated              列出可更新的模块
+  enable    <name>      启用模块
+  disable   <name>      禁用模块
+  export                导出已安装模块列表
+  import    <file>      从文件批量安装模块
+  config    <子命令>    配置管理 (list/get/set/unset/reset)
+  deps      <name>      显示模块依赖树
+  why       <name>      显示为什么安装了某个模块
+  check                 检查依赖完整性
+  install-skill         安装 Kite skill 到 Claude Code
 
 全局选项:
   -h, -H, --help        显示此帮助信息
@@ -150,6 +175,10 @@ def main():
         print(f"kite-cli {__version__}")
         return 0
 
+    # 处理命令别名（在 argparse 解析之前）
+    if len(sys.argv) > 1 and sys.argv[1] in COMMAND_ALIASES:
+        sys.argv[1] = COMMAND_ALIASES[sys.argv[1]]
+
     parser = SilentArgumentParser(
         prog="kite",
         description="Kite 模块安装管理工具",
@@ -181,6 +210,9 @@ def main():
     list_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="筛选位置")
     list_parser.add_argument("--all", action="store_true", help="所有位置")
     list_parser.add_argument("-v", "--verbose", action="store_true", help="详细信息")
+    list_parser.add_argument("--outdated", action="store_true", help="只显示可更新的模块")
+    list_parser.add_argument("--disabled", action="store_true", help="只显示禁用的模块")
+    list_parser.add_argument("--enabled", action="store_true", help="只显示启用的模块")
 
     # search 命令
     search_parser = subparsers.add_parser("search", help="搜索可用模块", add_help=True)
@@ -234,8 +266,89 @@ def main():
     # deps-install 命令
     deps_install_parser = subparsers.add_parser("deps-install", help="安装依赖库", add_help=True)
 
+    # outdated 命令
+    outdated_parser = subparsers.add_parser("outdated", help="列出可更新的模块", add_help=True)
+    outdated_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="只检查指定位置")
+
+    # enable 命令
+    enable_parser = subparsers.add_parser("enable", help="启用模块", add_help=True)
+    enable_parser.add_argument("name", help="模块名")
+    enable_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+    enable_parser.add_argument("-y", "--yes", action="store_true", help="跳过确认")
+
+    # disable 命令
+    disable_parser = subparsers.add_parser("disable", help="禁用模块", add_help=True)
+    disable_parser.add_argument("name", help="模块名")
+    disable_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+    disable_parser.add_argument("-y", "--yes", action="store_true", help="跳过确认")
+
+    # export 命令
+    export_parser = subparsers.add_parser("export", help="导出已安装模块列表", add_help=True)
+    export_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="只导出指定位置")
+    export_parser.add_argument("--format", choices=["text", "json"], default="text", help="输出格式")
+
+    # import 命令
+    import_parser = subparsers.add_parser("import", help="从文件批量安装模块", add_help=True)
+    import_parser.add_argument("file", help="模块列表文件（使用 - 表示从 stdin 读取）")
+    import_parser.add_argument("-y", "--yes", action="store_true", help="跳过确认")
+
+    # deps 命令
+    deps_parser = subparsers.add_parser("deps", help="显示模块依赖树", add_help=True)
+    deps_parser.add_argument("name", help="模块名")
+    deps_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+    deps_parser.add_argument("--depth", type=int, default=-1, help="最大深度（-1 表示无限制）")
+
+    # why 命令
+    why_parser = subparsers.add_parser("why", help="显示为什么安装了某个模块", add_help=True)
+    why_parser.add_argument("name", help="模块名")
+    why_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+
+    # check 命令
+    check_parser = subparsers.add_parser("check", help="检查依赖完整性", add_help=True)
+    check_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+    check_parser.add_argument("--fix", action="store_true", help="尝试修复问题")
+
+    # build 命令
+    build_parser = subparsers.add_parser("build", help="编译模块", add_help=True)
+    build_parser.add_argument("name", nargs="?", help="模块名（省略则编译当前目录）")
+    build_parser.add_argument("-l", "--location", choices=["dev", "local", "global"], help="指定位置")
+    build_parser.add_argument("-t", "--type", help="强制指定构建类型")
+    build_parser.add_argument("--clean", action="store_true", help="清理后编译")
+    build_parser.add_argument("--dry-run", action="store_true", help="显示命令但不执行")
+    build_parser.add_argument("--env", default="default", help="指定环境（dev/prod）")
+    build_parser.add_argument("-v", "--verbose", action="store_true", help="详细输出")
+    build_parser.add_argument("-y", "--yes", action="store_true", help="跳过确认")
+
+    # install-skill 命令
+    install_skill_parser = subparsers.add_parser("install-skill", help="安装 Kite skill 到 Claude Code", add_help=True)
+    install_skill_parser.add_argument("--user", action="store_true", help="安装到用户级 (~/.claude/skills/kite/)")
+    install_skill_parser.add_argument("--project", action="store_true", help="安装到项目级 (./.claude/skills/kite/)")
+
+    # config 命令
+    config_parser = subparsers.add_parser("config", help="配置管理", add_help=True)
+    config_subs = config_parser.add_subparsers(dest="subcmd")
+
+    config_subs.add_parser("list", help="列出所有配置")
+
+    config_get = config_subs.add_parser("get", help="获取配置值")
+    config_get.add_argument("key", help="配置项名称")
+
+    config_set = config_subs.add_parser("set", help="设置配置值")
+    config_set.add_argument("key", help="配置项名称")
+    config_set.add_argument("value", help="配置值")
+
+    config_unset = config_subs.add_parser("unset", help="删除配置（恢复默认）")
+    config_unset.add_argument("key", help="配置项名称")
+
+    config_reset = config_subs.add_parser("reset", help="重置所有配置为默认值")
+    config_reset.add_argument("-y", "--yes", action="store_true", help="跳过确认")
+
     args, unknown = parser.parse_known_args()
 
+    # 处理命令别名
+    if args.command and args.command in COMMAND_ALIASES:
+        args.command = COMMAND_ALIASES[args.command]
+
     # 处理全局 --help / --version
     if args.help:
         print_help()
@@ -308,6 +421,39 @@ def main():
     elif args.command == "deps-install":
         from kite_cli.commands.deps_install import run_deps_install
         return run_deps_install(args)
+    elif args.command == "outdated":
+        from kite_cli.commands.outdated import run_outdated
+        return run_outdated(args)
+    elif args.command == "enable":
+        from kite_cli.commands.enable import run_enable
+        return run_enable(args)
+    elif args.command == "disable":
+        from kite_cli.commands.disable import run_disable
+        return run_disable(args)
+    elif args.command == "export":
+        from kite_cli.commands.export import run_export
+        return run_export(args)
+    elif args.command == "import":
+        from kite_cli.commands.import_cmd import run_import
+        return run_import(args)
+    elif args.command == "deps":
+        from kite_cli.commands.deps import run_deps
+        return run_deps(args)
+    elif args.command == "why":
+        from kite_cli.commands.why import run_why
+        return run_why(args)
+    elif args.command == "check":
+        from kite_cli.commands.check import run_check
+        return run_check(args)
+    elif args.command == "build":
+        from kite_cli.commands.build import run_build
+        return run_build(args)
+    elif args.command == "install-skill":
+        from kite_cli.commands.install_skill import main
+        return main()
+    elif args.command == "config":
+        from kite_cli.commands.config import run_config
+        return run_config(args)
     else:
         print(f"未知命令: {args.command}")
         return 1

package/kite_cli/utils/colors.py

@@ -0,0 +1,153 @@
+"""彩色输出工具"""
+import sys
+import os
+
+
+# ANSI 颜色代码
+class Colors:
+    """ANSI 颜色代码"""
+    # 基础颜色
+    BLACK = '\033[30m'
+    RED = '\033[31m'
+    GREEN = '\033[32m'
+    YELLOW = '\033[33m'
+    BLUE = '\033[34m'
+    MAGENTA = '\033[35m'
+    CYAN = '\033[36m'
+    WHITE = '\033[37m'
+
+    # 亮色
+    BRIGHT_BLACK = '\033[90m'
+    BRIGHT_RED = '\033[91m'
+    BRIGHT_GREEN = '\033[92m'
+    BRIGHT_YELLOW = '\033[93m'
+    BRIGHT_BLUE = '\033[94m'
+    BRIGHT_MAGENTA = '\033[95m'
+    BRIGHT_CYAN = '\033[96m'
+    BRIGHT_WHITE = '\033[97m'
+
+    # 样式
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    ITALIC = '\033[3m'
+    UNDERLINE = '\033[4m'
+
+    # 重置
+    RESET = '\033[0m'
+
+
+def supports_color():
+    """检查终端是否支持彩色输出"""
+    # Windows 10+ 支持 ANSI 颜色
+    if sys.platform == 'win32':
+        # 尝试启用 Windows 10 的 ANSI 支持
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+            return True
+        except Exception:
+            return False
+
+    # Unix/Linux/Mac 检查 TERM 环境变量
+    if not hasattr(sys.stdout, 'isatty'):
+        return False
+    if not sys.stdout.isatty():
+        return False
+
+    term = os.environ.get('TERM', '')
+    if term == 'dumb':
+        return False
+
+    return True
+
+
+# 全局标志
+_COLOR_ENABLED = supports_color()
+
+
+def enable_color(enabled=True):
+    """启用或禁用彩色输出"""
+    global _COLOR_ENABLED
+    _COLOR_ENABLED = enabled
+
+
+def is_color_enabled():
+    """检查彩色输出是否启用"""
+    return _COLOR_ENABLED
+
+
+def colorize(text, color, bold=False):
+    """给文本添加颜色"""
+    if not _COLOR_ENABLED:
+        return text
+
+    prefix = color
+    if bold:
+        prefix = Colors.BOLD + color
+
+    return f"{prefix}{text}{Colors.RESET}"
+
+
+# 便捷函数
+def success(text, bold=False):
+    """成功消息（绿色）"""
+    return colorize(text, Colors.GREEN, bold)
+
+
+def error(text, bold=False):
+    """错误消息（红色）"""
+    return colorize(text, Colors.RED, bold)
+
+
+def warning(text, bold=False):
+    """警告消息（黄色）"""
+    return colorize(text, Colors.YELLOW, bold)
+
+
+def info(text, bold=False):
+    """信息消息（蓝色）"""
+    return colorize(text, Colors.BLUE, bold)
+
+
+def dim(text):
+    """暗淡文本（灰色）"""
+    return colorize(text, Colors.BRIGHT_BLACK, False)
+
+
+def highlight(text):
+    """高亮文本（青色加粗）"""
+    return colorize(text, Colors.CYAN, True)
+
+
+def bold(text):
+    """加粗文本"""
+    if not _COLOR_ENABLED:
+        return text
+    return f"{Colors.BOLD}{text}{Colors.RESET}"
+
+
+# 带标签的输出函数
+def print_success(message):
+    """打印成功消息"""
+    print(f"{success('[Success]', True)} {message}")
+
+
+def print_error(message):
+    """打印错误消息"""
+    print(f"{error('[Error]', True)} {message}")
+
+
+def print_warning(message):
+    """打印警告消息"""
+    print(f"{warning('[Warning]', True)} {message}")
+
+
+def print_info(message):
+    """打印信息消息"""
+    print(f"{info('[Info]', True)} {message}")
+
+
+def print_cancelled(message="已取消"):
+    """打印取消消息"""
+    print(f"{dim('[Cancelled]')} {message}")

package/kite_cli/utils/dependency_graph.py

@@ -0,0 +1,209 @@
+"""依赖图分析工具"""
+from pathlib import Path
+from typing import Dict, List, Set, Optional, Tuple
+from kite_cli.utils.paths import get_install_path
+
+
+class DependencyGraph:
+    """依赖图"""
+
+    def __init__(self):
+        self.nodes: Dict[str, Dict] = {}  # 模块名 -> 模块信息
+        self.edges: Dict[str, List[str]] = {}  # 模块名 -> 依赖列表
+        self.reverse_edges: Dict[str, List[str]] = {}  # 模块名 -> 被依赖列表
+
+    def add_module(self, name: str, location: str, module_data: Dict):
+        """添加模块"""
+        self.nodes[name] = {
+            'location': location,
+            'version': module_data.get('version', 'unknown'),
+            'data': module_data
+        }
+
+        # 解析依赖
+        deps = []
+        dependencies = module_data.get('dependencies', {})
+
+        # Python 依赖
+        if 'python' in dependencies:
+            python_deps = dependencies['python']
+            if isinstance(python_deps, list):
+                deps.extend(python_deps)
+
+        # npm 依赖
+        if 'npm' in dependencies:
+            npm_deps = dependencies['npm']
+            if isinstance(npm_deps, list):
+                deps.extend(npm_deps)
+
+        # Kite 模块依赖
+        if 'kite' in dependencies:
+            kite_deps = dependencies['kite']
+            if isinstance(kite_deps, list):
+                deps.extend(kite_deps)
+
+        self.edges[name] = deps
+
+        # 构建反向依赖
+        for dep in deps:
+            if dep not in self.reverse_edges:
+                self.reverse_edges[dep] = []
+            self.reverse_edges[dep].append(name)
+
+    def get_dependencies(self, name: str, max_depth: int = -1) -> List[Tuple[str, int]]:
+        """获取依赖树（深度优先）"""
+        result = []
+        visited = set()
+
+        def dfs(node: str, depth: int):
+            if max_depth >= 0 and depth > max_depth:
+                return
+            if node in visited:
+                return
+            visited.add(node)
+
+            deps = self.edges.get(node, [])
+            for dep in deps:
+                result.append((dep, depth))
+                dfs(dep, depth + 1)
+
+        dfs(name, 1)
+        return result
+
+    def get_reverse_dependencies(self, name: str) -> List[str]:
+        """获取反向依赖（谁依赖了这个模块）"""
+        return self.reverse_edges.get(name, [])
+
+    def find_path(self, from_name: str, to_name: str) -> Optional[List[str]]:
+        """查找依赖路径"""
+        if from_name not in self.edges:
+            return None
+
+        visited = set()
+        queue = [(from_name, [from_name])]
+
+        while queue:
+            current, path = queue.pop(0)
+
+            if current == to_name:
+                return path
+
+            if current in visited:
+                continue
+            visited.add(current)
+
+            for dep in self.edges.get(current, []):
+                if dep not in visited:
+                    queue.append((dep, path + [dep]))
+
+        return None
+
+    def detect_cycles(self) -> List[List[str]]:
+        """检测循环依赖"""
+        cycles = []
+        visited = set()
+        rec_stack = set()
+
+        def dfs(node: str, path: List[str]):
+            visited.add(node)
+            rec_stack.add(node)
+            path.append(node)
+
+            for dep in self.edges.get(node, []):
+                if dep not in visited:
+                    dfs(dep, path)
+                elif dep in rec_stack:
+                    # 找到循环
+                    cycle_start = path.index(dep)
+                    cycle = path[cycle_start:] + [dep]
+                    cycles.append(cycle)
+
+            path.pop()
+            rec_stack.remove(node)
+
+        for node in self.nodes:
+            if node not in visited:
+                dfs(node, [])
+
+        return cycles
+
+    def check_missing(self) -> Dict[str, List[str]]:
+        """检查缺失的依赖"""
+        missing = {}
+
+        for name, deps in self.edges.items():
+            missing_deps = []
+            for dep in deps:
+                if dep not in self.nodes:
+                    missing_deps.append(dep)
+
+            if missing_deps:
+                missing[name] = missing_deps
+
+        return missing
+
+
+def build_dependency_graph(locations: List[str] = None) -> DependencyGraph:
+    """构建依赖图"""
+    graph = DependencyGraph()
+
+    if locations is None:
+        locations = ['dev', 'local', 'global']
+
+    for loc in locations:
+        try:
+            if loc == 'dev':
+                import os
+                if 'KITE_PROJECT' not in os.environ:
+                    continue
+                base_path = Path(os.environ['KITE_PROJECT']) / 'extensions'
+            elif loc == 'local':
+                import os
+                if 'KITE_INSTANCE_DIR' in os.environ:
+                    base_path = Path(os.environ['KITE_INSTANCE_DIR']) / 'extensions'
+                else:
+                    base_path = Path.home() / '.kite' / 'workspace' / 'default' / 'extensions'
+            else:  # global
+                base_path = Path.home() / '.kite' / 'modules'
+
+            if not base_path.exists():
+                continue
+
+            for module_dir in base_path.iterdir():
+                if not module_dir.is_dir():
+                    continue
+
+                module_md = module_dir / 'module.md'
+                if not module_md.exists():
+                    continue
+
+                # 解析 module.md
+                module_data = parse_module_md(module_md)
+                if module_data and module_data.get('name'):
+                    graph.add_module(module_data['name'], loc, module_data)
+
+        except Exception:
+            continue
+
+    return graph
+
+
+def parse_module_md(module_md_path: Path) -> Optional[Dict]:
+    """解析 module.md"""
+    try:
+        with open(module_md_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        if not content.startswith('---'):
+            return None
+
+        parts = content.split('---', 2)
+        if len(parts) < 2:
+            return None
+
+        import yaml
+        frontmatter = yaml.safe_load(parts[1])
+        return frontmatter
+
+    except Exception:
+        return None

package/kite_cli/utils/process.py

@@ -0,0 +1,55 @@
+"""进程执行工具"""
+import subprocess
+import os
+from pathlib import Path
+from typing import List, Dict, Optional
+
+
+def run_command(
+    cmd: List[str],
+    cwd: Path,
+    env: Optional[Dict[str, str]] = None,
+    verbose: bool = False,
+    timeout: int = 600
+) -> bool:
+    """执行命令并实时输出"""
+
+    # 合并环境变量
+    full_env = os.environ.copy()
+    if env:
+        full_env.update(env)
+
+    try:
+        if verbose:
+            print(f"执行命令: {' '.join(cmd)}")
+            print(f"工作目录: {cwd}")
+
+        # 实时输出
+        process = subprocess.Popen(
+            cmd,
+            cwd=str(cwd),
+            env=full_env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+
+        # 逐行输出
+        for line in process.stdout:
+            print(line, end='')
+
+        # 等待完成
+        return_code = process.wait(timeout=timeout)
+        return return_code == 0
+
+    except subprocess.TimeoutExpired:
+        process.kill()
+        print(f"错误: 命令执行超时（{timeout}秒）")
+        return False
+    except FileNotFoundError:
+        print(f"错误: 命令未找到 '{cmd[0]}'")
+        return False
+    except Exception as e:
+        print(f"错误: 命令执行失败 - {e}")
+        return False