@agentunion/kite 1.5.0 → 1.6.0

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)

package/launcher/count_lines.py

@@ -2,6 +2,7 @@
 """
 代码行数统计工具
 统计 Kite 项目的代码行数并记录到 JSONL 文件
+支持文件级缓存，只统计修改过的文件
 """
 import json
 import sys
@@ -18,6 +19,65 @@ if sys.platform == "win32":
         pass
 
 
+# 排除的目录（防御性措施）
+EXCLUDE_DIRS = {
+    # Python 相关
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".tox",
+    ".eggs",
+    "*.egg-info",
+    # JavaScript 相关
+    "node_modules",
+    # 构建产物
+    "dist",
+    "build",
+    # 版本控制
+    ".git",
+    ".svn",
+    ".hg",
+    # IDE 配置
+    ".idea",
+    ".vscode",
+    # 项目特定
+    ".dev",          # 开发相关（变更日志、发布备份）
+    ".claude",       # Claude 工作目录
+}
+
+
+def load_cache(cache_file: Path) -> dict:
+    """加载文件缓存
+
+    缓存格式: {
+        "file_path": {
+            "mtime": 1234567890.123,
+            "lines": 100
+        }
+    }
+    """
+    if not cache_file.exists():
+        return {}
+
+    try:
+        with open(cache_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_cache(cache: dict, cache_file: Path):
+    """保存文件缓存"""
+    try:
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(cache_file, "w", encoding="utf-8") as f:
+            json.dump(cache, f, ensure_ascii=False, indent=2)
+    except OSError:
+        pass
+
+
 def count_lines_in_file(file_path: Path) -> int:
     """统计单个文件的行数"""
     try:
@@ -27,61 +87,138 @@ def count_lines_in_file(file_path: Path) -> int:
         return 0
 
 
-def count_lines(root_dir: Path, pattern: str, exclude_dirs: set[str]) -> int:
-    """统计指定模式的文件行数"""
+def count_lines_cached(root_dir: Path, pattern: str, exclude_dirs: set[str], cache: dict) -> tuple[int, dict]:
+    """统计指定模式的文件行数（使用缓存）
+
+    Returns:
+        (total_lines, updated_cache)
+    """
     total = 0
+    updated_cache = {}
+    cache_hits = 0
+    cache_misses = 0
+
     for file_path in root_dir.rglob(pattern):
         # 检查是否在排除目录中
         if any(excluded in file_path.parts for excluded in exclude_dirs):
             continue
-        total += count_lines_in_file(file_path)
-    return total
 
+        # 获取文件修改时间
+        try:
+            mtime = file_path.stat().st_mtime
+        except OSError:
+            continue
 
-def count_all(root_dir: Path) -> dict:
-    """统计所有类型的代码行数"""
-    stats = {}
+        # 转换为相对路径作为缓存键
+        rel_path = str(file_path.relative_to(root_dir))
 
-    # 排除的目录
-    exclude_dirs = {
-        "__pycache__",
-        "node_modules",
-        ".git",
-        ".venv",
-        "venv",
-        ".idea",
-        ".vscode",
-        ".dev",          # 开发相关（变更日志、发布备份）
-        ".claude",       # Claude 工作目录
-    }
+        # 检查缓存
+        cached = cache.get(rel_path)
+        if cached and cached.get("mtime") == mtime:
+            # 缓存命中
+            lines = cached["lines"]
+            cache_hits += 1
+        else:
+            # 缓存未命中，重新统计
+            lines = count_lines_in_file(file_path)
+            cache_misses += 1
 
-    # Python 代码
-    stats["python"] = count_lines(root_dir, "*.py", exclude_dirs)
+        total += lines
+        updated_cache[rel_path] = {"mtime": mtime, "lines": lines}
 
-    # JavaScript 代码
-    stats["javascript"] = count_lines(root_dir, "*.js", exclude_dirs)
+    return total, updated_cache
 
-    # Markdown 文档
-    stats["markdown"] = count_lines(root_dir, "*.md", exclude_dirs)
 
-    # YAML 配置
-    stats["yaml"] = count_lines(root_dir, "*.yaml", exclude_dirs) + \
-                    count_lines(root_dir, "*.yml", exclude_dirs)
+def count_all(root_dir: Path, cache_file: Path) -> tuple[dict, dict]:
+    """统计所有类型的代码行数（使用缓存）
 
-    # JSON 配置（排除 package-lock.json）
-    json_total = 0
-    for file_path in root_dir.rglob("*.json"):
-        if any(excluded in file_path.parts for excluded in exclude_dirs):
-            continue
-        if file_path.name == "package-lock.json":
-            continue
-        json_total += count_lines_in_file(file_path)
-    stats["json"] = json_total
+    Returns:
+        (stats, cache_info)
+    """
+    import time
 
-    # 总计
+    # 加载缓存
+    t0 = time.time()
+    cache = load_cache(cache_file)
+    print(f"DEBUG: 加载缓存耗时 {time.time()-t0:.3f}秒")
+
+    # 一次性遍历所有文件，按扩展名分类（用 os.scandir 跳过排除目录）
+    import os
+    t0 = time.time()
+    target_exts = {'.py', '.js', '.md', '.yaml', '.yml', '.json'}
+    files_by_ext = {ext: [] for ext in target_exts}
+
+    def _scan(dir_path):
+        try:
+            entries = os.scandir(dir_path)
+        except PermissionError:
+            return
+        with entries:
+            for entry in entries:
+                if entry.is_dir(follow_symlinks=False):
+                    if entry.name not in EXCLUDE_DIRS:
+                        _scan(entry.path)
+                elif entry.is_file(follow_symlinks=False):
+                    ext = os.path.splitext(entry.name)[1].lower()
+                    if ext in target_exts:
+                        files_by_ext[ext].append(Path(entry.path))
+
+    _scan(str(root_dir))
+    print(f"DEBUG: 目录遍历耗时 {time.time()-t0:.3f}秒")
+
+    stats = {}
+    new_cache = {}
+
+    # 统计各类型文件
+    def count_files(files, label):
+        t = time.time()
+        total = 0
+        for file_path in files:
+            if file_path.name == "package-lock.json":
+                continue
+
+            try:
+                mtime = file_path.stat().st_mtime
+            except OSError:
+                continue
+
+            rel_path = str(file_path.relative_to(root_dir))
+            cached = cache.get(rel_path)
+
+            if cached and cached.get("mtime") == mtime:
+                lines = cached["lines"]
+            else:
+                lines = count_lines_in_file(file_path)
+
+            total += lines
+            new_cache[rel_path] = {"mtime": mtime, "lines": lines}
+
+        print(f"DEBUG: {label}统计耗时 {time.time()-t:.3f}秒 ({len(files)}个文件)")
+        return total
+
+    stats["python"] = count_files(files_by_ext['.py'], "Python")
+    stats["javascript"] = count_files(files_by_ext['.js'], "JavaScript")
+    stats["markdown"] = count_files(files_by_ext['.md'], "Markdown")
+    stats["yaml"] = count_files(files_by_ext['.yaml'], "YAML") + count_files(files_by_ext['.yml'], "YML")
+    stats["json"] = count_files(files_by_ext['.json'], "JSON")
     stats["total"] = sum(stats.values())
 
-    return stats
+    # 计算缓存命中率
+    total_files = len(new_cache)
+    cached_files = sum(1 for k in new_cache if k in cache and cache[k].get("mtime") == new_cache[k]["mtime"])
+    cache_info = {
+        "total_files": total_files,
+        "cache_hits": cached_files,
+        "cache_misses": total_files - cached_files,
+        "hit_rate": f"{cached_files / total_files * 100:.1f}%" if total_files > 0 else "0%"
+    }
+
+    # 保存新缓存
+    t0 = time.time()
+    save_cache(new_cache, cache_file)
+    print(f"DEBUG: 保存缓存耗时 {time.time()-t0:.3f}秒")
+
+    return stats, cache_info
 
 
 def save_record(stats: dict, record_file: Path):
@@ -113,10 +250,11 @@ def save_record(stats: dict, record_file: Path):
         f.write(json.dumps(record, ensure_ascii=False) + "\n")
 
 
-def print_stats(stats: dict):
+def print_stats(stats: dict, cache_info: dict = None):
     """打印统计结果"""
     # ANSI 颜色代码
     BOLD = "\033[1m"
+    DIM = "\033[2m"
     RESET = "\033[0m"
 
     print("\n" + "=" * 50)
@@ -129,6 +267,8 @@ def print_stats(stats: dict):
     print(f"JSON 配置:        {BOLD}{stats['json']:>8,} 行{RESET}")
     print("-" * 50)
     print(f"总计:             {BOLD}{stats['total']:>8,} 行{RESET}")
+    if cache_info:
+        print(f"{DIM}缓存命中率:       {cache_info['hit_rate']} ({cache_info['cache_hits']}/{cache_info['total_files']}){RESET}")
     print("=" * 50 + "\n")
 
 
@@ -222,18 +362,25 @@ def show_history(record_file: Path, limit: int = 10):
 
 def run_stats():
     """Run code stats from main.py entry point (simplified output)."""
+    import time
+    start_time = time.time()
+
     script_dir = Path(__file__).parent
     root_dir = script_dir.parent
     record_file = root_dir / "data" / "stats" / "lines.jsonl"
+    cache_file = root_dir / "data" / "stats" / "cache.json"
 
     print("[launcher] 正在统计代码行数...")
     try:
-        stats = count_all(root_dir)
+        stats, cache_info = count_all(root_dir, cache_file)
+        elapsed = time.time() - start_time
+        print(f"[launcher] 统计耗时: {elapsed:.2f}秒")
         save_record(stats, record_file)
 
         # Print stats
         BRIGHT_GREEN = "\033[92m"
         BOLD = "\033[1m"
+        DIM = "\033[2m"
         RESET = "\033[0m"
 
         print("")
@@ -247,6 +394,7 @@ def run_stats():
         print(f"JSON 配置:        {BRIGHT_GREEN}{stats['json']:>8,}{RESET} 行")
         print("-" * 50)
         print(f"总计:             {BOLD}{BRIGHT_GREEN}{stats['total']:>8,}{RESET} 行")
+        print(f"{DIM}缓存命中率:       {cache_info['hit_rate']} ({cache_info['cache_hits']}/{cache_info['total_files']}){RESET}")
         print("=" * 50)
         print("")
 
@@ -263,6 +411,7 @@ def main():
 
     # 记录文件路径
     record_file = root_dir / "data" / "stats" / "lines.jsonl"
+    cache_file = root_dir / "data" / "stats" / "cache.json"
 
     # 解析命令行参数
     show_hist = "--history" in sys.argv or "-h" in sys.argv
@@ -276,14 +425,14 @@ def main():
     # 统计代码行数
     if not quiet:
         print("正在统计代码行数...")
-    stats = count_all(root_dir)
+    stats, cache_info = count_all(root_dir, cache_file)
 
     # 保存记录
     save_record(stats, record_file)
 
     # 打印结果
     if not quiet:
-        print_stats(stats)
+        print_stats(stats, cache_info)
         # 显示最近 8 次记录
         show_history(record_file, limit=8)