@agentunion/kite 1.4.0 → 1.6.0

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

package/kite_cli/utils/progress.py

@@ -0,0 +1,207 @@
+"""进度显示工具"""
+import sys
+from typing import Optional, Callable
+from kite_cli.utils.colors import Colors, supports_color
+
+
+class ProgressBar:
+    """进度条"""
+
+    def __init__(self, total: int = 100, desc: str = "", unit: str = "it", disable: bool = False):
+        """
+        初始化进度条
+
+        Args:
+            total: 总数
+            desc: 描述文本
+            unit: 单位
+            disable: 是否禁用（非 TTY 环境自动禁用）
+        """
+        self.total = total
+        self.desc = desc
+        self.unit = unit
+        self.current = 0
+        self.disable = disable or not self._is_tty()
+        self.use_color = supports_color()
+
+        # 尝试使用 tqdm
+        self.tqdm_bar = None
+        if not self.disable:
+            try:
+                from tqdm import tqdm
+                self.tqdm_bar = tqdm(
+                    total=total,
+                    desc=desc,
+                    unit=unit,
+                    ncols=80,
+                    bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]'
+                )
+            except ImportError:
+                # tqdm 不可用，使用简单实现
+                pass
+
+    def update(self, n: int = 1):
+        """更新进度"""
+        if self.disable:
+            return
+
+        self.current += n
+
+        if self.tqdm_bar:
+            self.tqdm_bar.update(n)
+        else:
+            # 简单实现
+            self._print_simple()
+
+    def set_description(self, desc: str):
+        """设置描述"""
+        self.desc = desc
+        if self.tqdm_bar:
+            self.tqdm_bar.set_description(desc)
+
+    def close(self):
+        """关闭进度条"""
+        if self.tqdm_bar:
+            self.tqdm_bar.close()
+        elif not self.disable:
+            # 简单实现：换行
+            print()
+
+    def _print_simple(self):
+        """简单进度显示"""
+        percent = int(self.current / self.total * 100) if self.total > 0 else 0
+        bar_length = 30
+        filled = int(bar_length * self.current / self.total) if self.total > 0 else 0
+        bar = '█' * filled + '░' * (bar_length - filled)
+
+        if self.use_color:
+            bar = Colors.GREEN + '█' * filled + Colors.RESET + Colors.BRIGHT_BLACK + '░' * (bar_length - filled) + Colors.RESET
+
+        sys.stdout.write(f'\r{self.desc}: {bar} {percent}% ({self.current}/{self.total})')
+        sys.stdout.flush()
+
+    def _is_tty(self) -> bool:
+        """检查是否为 TTY 环境"""
+        return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class DownloadProgress:
+    """下载进度显示"""
+
+    def __init__(self, desc: str = "下载中", disable: bool = False):
+        self.desc = desc
+        self.disable = disable or not self._is_tty()
+        self.use_color = supports_color()
+        self.tqdm_bar = None
+
+        if not self.disable:
+            try:
+                from tqdm import tqdm
+                self.tqdm_bar = tqdm(
+                    total=0,
+                    desc=desc,
+                    unit='B',
+                    unit_scale=True,
+                    unit_divisor=1024,
+                    ncols=80
+                )
+            except ImportError:
+                pass
+
+    def set_total(self, total: int):
+        """设置总大小"""
+        if self.tqdm_bar:
+            self.tqdm_bar.total = total
+
+    def update(self, n: int):
+        """更新已下载大小"""
+        if self.tqdm_bar:
+            self.tqdm_bar.update(n)
+
+    def close(self):
+        """关闭进度条"""
+        if self.tqdm_bar:
+            self.tqdm_bar.close()
+
+    def _is_tty(self) -> bool:
+        return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class StepProgress:
+    """多步骤进度显示"""
+
+    def __init__(self, steps: list, disable: bool = False):
+        """
+        初始化多步骤进度
+
+        Args:
+            steps: 步骤列表 ['步骤1', '步骤2', ...]
+            disable: 是否禁用
+        """
+        self.steps = steps
+        self.total = len(steps)
+        self.current_step = 0
+        self.disable = disable or not self._is_tty()
+        self.use_color = supports_color()
+
+    def next_step(self, status: str = "✓"):
+        """进入下一步"""
+        if self.disable:
+            return
+
+        if self.current_step < self.total:
+            step_name = self.steps[self.current_step]
+            if self.use_color:
+                status_colored = Colors.GREEN + status + Colors.RESET
+                print(f"{status_colored} [{self.current_step + 1}/{self.total}] {step_name}")
+            else:
+                print(f"{status} [{self.current_step + 1}/{self.total}] {step_name}")
+
+            self.current_step += 1
+
+    def fail_step(self, error: str = ""):
+        """当前步骤失败"""
+        if self.disable:
+            return
+
+        if self.current_step < self.total:
+            step_name = self.steps[self.current_step]
+            if self.use_color:
+                status = Colors.RED + "✗" + Colors.RESET
+                error_text = Colors.RED + error + Colors.RESET if error else ""
+            else:
+                status = "✗"
+                error_text = error
+
+            print(f"{status} [{self.current_step + 1}/{self.total}] {step_name} {error_text}")
+
+    def _is_tty(self) -> bool:
+        return hasattr(sys.stdout, 'isatty') and sys.stdout.isatty()
+
+
+def create_progress_callback(progress_bar: Optional[ProgressBar]) -> Optional[Callable]:
+    """创建进度回调函数"""
+    if not progress_bar:
+        return None
+
+    def callback(current: int, total: int):
+        if progress_bar.total != total:
+            progress_bar.total = total
+        progress_bar.current = current
+        if progress_bar.tqdm_bar:
+            progress_bar.tqdm_bar.n = current
+            progress_bar.tqdm_bar.refresh()
+
+    return callback

package/kite_cli/utils/table.py

@@ -0,0 +1,101 @@
+"""表格格式化工具"""
+from typing import List, Dict, Any, Optional
+from kite_cli.utils.colors import Colors, supports_color
+
+
+def format_table(
+    headers: List[str],
+    rows: List[List[Any]],
+    alignments: Optional[List[str]] = None,
+    min_widths: Optional[List[int]] = None
+) -> str:
+    """
+    格式化表格
+
+    Args:
+        headers: 表头列表
+        rows: 数据行列表，每行是一个列表
+        alignments: 对齐方式列表 ('left', 'right', 'center')，默认全部左对齐
+        min_widths: 最小列宽列表，默认自动计算
+
+    Returns:
+        格式化后的表格字符串
+    """
+    if not rows:
+        return ""
+
+    num_cols = len(headers)
+    if alignments is None:
+        alignments = ['left'] * num_cols
+    if min_widths is None:
+        min_widths = [0] * num_cols
+
+    # 计算每列的实际宽度（考虑 ANSI 转义码）
+    col_widths = [max(min_widths[i], _display_width(headers[i])) for i in range(num_cols)]
+
+    for row in rows:
+        for i, cell in enumerate(row):
+            if i < num_cols:
+                col_widths[i] = max(col_widths[i], _display_width(str(cell)))
+
+    # 构建表格
+    lines = []
+    use_color = supports_color()
+
+    # 表头
+    header_line = _format_row(headers, col_widths, alignments)
+    if use_color:
+        header_line = Colors.BOLD + header_line + Colors.RESET
+    lines.append(header_line)
+
+    # 分隔线
+    separator = _make_separator(col_widths)
+    lines.append(separator)
+
+    # 数据行
+    for row in rows:
+        lines.append(_format_row(row, col_widths, alignments))
+
+    return '\n'.join(lines)
+
+
+def _format_row(cells: List[Any], widths: List[int], alignments: List[str]) -> str:
+    """格式化单行"""
+    formatted_cells = []
+
+    for i, cell in enumerate(cells):
+        cell_str = str(cell)
+        width = widths[i]
+        align = alignments[i] if i < len(alignments) else 'left'
+
+        # 计算实际显示宽度（去除 ANSI 转义码）
+        display_width = _display_width(cell_str)
+        padding = width - display_width
+
+        if align == 'right':
+            formatted = ' ' * padding + cell_str
+        elif align == 'center':
+            left_pad = padding // 2
+            right_pad = padding - left_pad
+            formatted = ' ' * left_pad + cell_str + ' ' * right_pad
+        else:  # left
+            formatted = cell_str + ' ' * padding
+
+        formatted_cells.append(formatted)
+
+    return '  '.join(formatted_cells)
+
+
+def _make_separator(widths: List[int]) -> str:
+    """生成分隔线"""
+    parts = ['-' * w for w in widths]
+    return '  '.join(parts)
+
+
+def _display_width(text: str) -> int:
+    """计算文本的实际显示宽度（去除 ANSI 转义码）"""
+    import re
+    # 移除 ANSI 转义码
+    ansi_escape = re.compile(r'\x1b\[[0-9;]*m')
+    clean_text = ansi_escape.sub('', str(text))
+    return len(clean_text)