vibego 0.2.52__py3-none-any.whl → 1.0.0__py3-none-any.whl

project_repository.py

@@ -1,9 +1,11 @@
-"""项目配置仓库，负责在 SQLite 与 JSON 间同步。
-
-该模块承担以下职责：
-1. 初始化 SQLite 数据库并在首次运行时从 JSON 导入数据，同时保留原始 JSON 备份；
-2. 提供项目增删改查接口，所有写操作都会回写最新 JSON 以兼容旧逻辑；
-3. 提供 ProjectConfig 所需的数据结构，供 master 与其他脚本复用。
+"""Project configuration repository syncing SQLite and JSON storage.
+
+Responsibilities:
+1. Initialise the SQLite database and import data from JSON on first run while
+   keeping a backup of the original JSON file.
+2. Provide CRUD helpers that always write the latest JSON for legacy
+   compatibility.
+3. Expose data structures consumed by the master process and related scripts.
 """
 from __future__ import annotations
 
@@ -23,7 +25,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass(frozen=True)
 class ProjectRecord:
-    """描述单个项目的配置数据。"""
+    """Represent the configuration data for a single project."""
 
     bot_name: str
     bot_token: str
@@ -34,7 +36,7 @@ class ProjectRecord:
     legacy_name: Optional[str]
 
     def to_dict(self) -> dict:
-        """转换为 JSON 序列化所需的字典。"""
+        """Return a dictionary representation ready for JSON serialisation."""
         return {
             "bot_name": self.bot_name,
             "bot_token": self.bot_token,
@@ -47,21 +49,21 @@ class ProjectRecord:
 
 
 class ProjectRepository:
-    """项目配置仓库，封装所有读写逻辑。"""
+    """Repository wrapper that encapsulates project configuration I/O."""
 
     def __init__(self, db_path: Path, json_path: Path):
-        """初始化仓库并自动创建所需的文件与目录。"""
+        """Initialise the repository and ensure required files exist."""
 
-        # 保存路径，确保目录存在
+        # Store paths and create parent directories.
         self.db_path = db_path
         self.json_path = json_path
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
         self.json_path.parent.mkdir(parents=True, exist_ok=True)
-        # 初始化数据库文件
+        # Prepare the database file.
         self._initialize()
 
     def _initialize(self) -> None:
-        """初始化数据库，如果首次创建则执行 JSON 导入。"""
+        """Initialise the database and import JSON data on first launch."""
         first_create = not self.db_path.exists()
         with self._connect() as conn:
             conn.execute("PRAGMA foreign_keys = ON;")
@@ -83,27 +85,27 @@ class ProjectRepository:
             )
         if first_create:
             self._import_from_json()
-        # 每次启动都执行数据修复，保证旧数据被规范化
+        # Repair legacy records on every startup to keep data normalised.
         self._repair_records()
-        # 启动时始终导出一次，确保 JSON 与数据库一致
+        # Export once on startup so JSON mirrors the database.
         self._export_to_json(self.list_projects())
 
     def _connect(self) -> sqlite3.Connection:
-        """创建数据库连接，统一启用行字典模式。"""
+        """Create a database connection with row dictionaries enabled."""
         conn = sqlite3.connect(str(self.db_path))
         conn.row_factory = sqlite3.Row
         return conn
 
     def _import_from_json(self) -> None:
-        """首次初始化时从 JSON 迁移数据，并保留备份文件。"""
+        """Import data from JSON during the first initialisation and keep a backup."""
         if not self.json_path.exists():
             return
         try:
             raw = json.loads(self.json_path.read_text(encoding="utf-8"))
         except json.JSONDecodeError as exc:
-            raise RuntimeError(f"解析 {self.json_path} 时失败: {exc}") from exc
+            raise RuntimeError(f"Failed to parse {self.json_path}: {exc}") from exc
         if not isinstance(raw, list):
-            raise RuntimeError(f"{self.json_path} 内容必须是数组")
+            raise RuntimeError(f"The content of {self.json_path} must be an array.")
         records: List[ProjectRecord] = []
         for item in raw:
             if not isinstance(item, dict):
@@ -125,12 +127,12 @@ class ProjectRepository:
         shutil.copy2(self.json_path, backup_path)
 
     def _build_backup_path(self) -> Path:
-        """构造 JSON 备份路径，带有时间戳避免覆盖。"""
+        """Build a timestamped JSON backup path to avoid overwriting files."""
         timestamp = time.strftime("%Y%m%d-%H%M%S")
         return self.json_path.with_suffix(self.json_path.suffix + f".{timestamp}.bak")
 
     def list_projects(self) -> List[ProjectRecord]:
-        """读取全部项目配置。"""
+        """Return all project configurations."""
         with self._connect() as conn:
             cursor = conn.execute(
                 """
@@ -144,7 +146,7 @@ class ProjectRepository:
         return [self._normalize_record_fields(self._row_to_record(row, normalize=False)) for row in rows]
 
     def get_by_slug(self, slug: str) -> Optional[ProjectRecord]:
-        """根据 project_slug 查询项目（忽略大小写以兼容历史数据）。"""
+        """Look up a project by slug (case-insensitive for legacy data)."""
         slug = self._sanitize_slug(slug)
         with self._connect() as conn:
             cursor = conn.execute(
@@ -161,7 +163,7 @@ class ProjectRepository:
         return self._normalize_record_fields(self._row_to_record(row, normalize=False))
 
     def get_by_bot_name(self, bot_name: str) -> Optional[ProjectRecord]:
-        """根据 bot 名查询项目。"""
+        """Look up a project by bot name."""
         bot_name = self._sanitize_bot_name(bot_name)
         with self._connect() as conn:
             cursor = conn.execute(
@@ -178,7 +180,7 @@ class ProjectRepository:
         return self._normalize_record_fields(self._row_to_record(row, normalize=False))
 
     def insert_project(self, record: ProjectRecord) -> None:
-        """新增项目记录。"""
+        """Insert a new project record."""
         normalized = self._normalize_record_fields(record)
         with self._connect() as conn:
             conn.execute("BEGIN IMMEDIATE;")
@@ -203,7 +205,7 @@ class ProjectRepository:
         self._export_to_json(self.list_projects())
 
     def update_project(self, slug: str, record: ProjectRecord) -> None:
-        """更新项目记录，slug 作为定位字段（匹配时忽略大小写）。"""
+        """Update a project using its slug (case-insensitive) as the identifier."""
         normalized_slug = self._sanitize_slug(slug)
         normalized = self._normalize_record_fields(record)
         with self._connect() as conn:
@@ -228,12 +230,12 @@ class ProjectRepository:
             )
             if cursor.rowcount == 0:
                 conn.rollback()
-                raise ValueError(f"未找到项目 {slug}")
+                raise ValueError(f"Project {slug} not found")
             conn.commit()
         self._export_to_json(self.list_projects())
 
     def delete_project(self, slug: str) -> None:
-        """删除指定项目（匹配时忽略大小写）。"""
+        """Delete a project by slug (case-insensitive)."""
         normalized_slug = self._sanitize_slug(slug)
         with self._connect() as conn:
             conn.execute("BEGIN IMMEDIATE;")
@@ -243,12 +245,12 @@ class ProjectRepository:
             )
             if cursor.rowcount == 0:
                 conn.rollback()
-                raise ValueError(f"未找到项目 {slug}")
+                raise ValueError(f"Project {slug} not found")
             conn.commit()
         self._export_to_json(self.list_projects())
 
     def _bulk_upsert(self, records: Iterable[ProjectRecord]) -> None:
-        """批量写入项目数据，用于初始化导入。"""
+        """Insert or update multiple project records, used for bootstrap imports."""
         with self._connect() as conn:
             conn.execute("BEGIN IMMEDIATE;")
             for record in records:
@@ -281,7 +283,7 @@ class ProjectRepository:
             conn.commit()
 
     def _normalize_int(self, value: Optional[object]) -> Optional[int]:
-        """将输入转换为整数或 None，兼容字符串类型。"""
+        """Convert the input to an int or None, handling string representations."""
         if value is None:
             return None
         if isinstance(value, int):
@@ -291,28 +293,28 @@ class ProjectRepository:
         return None
 
     def _sanitize_bot_name(self, bot_name: str) -> str:
-        """去除多余空白与前导 @，统一 bot 名格式。"""
+        """Trim whitespace and leading @ symbols to normalise bot names."""
         cleaned = (bot_name or "").strip()
         if cleaned.startswith("@"):
             cleaned = cleaned[1:]
         return cleaned.strip()
 
     def _sanitize_slug(self, slug: str) -> str:
-        """复用 master 侧逻辑，将 slug 归一化为小写并替换非法字符。"""
+        """Normalise slugs to lowercase and replace illegal characters."""
         text = (slug or "").strip().lower()
         text = text.replace(" ", "-").replace("/", "-").replace("\\", "-")
         text = text.strip("-")
         return text or "project"
 
     def _sanitize_optional_text(self, value: Optional[str]) -> Optional[str]:
-        """通用字符串清洗，空字符串回落为 None。"""
+        """Clean optional text values and return None for empty strings."""
         if value is None:
             return None
         cleaned = value.strip()
         return cleaned or None
 
     def _normalize_record_fields(self, record: ProjectRecord) -> ProjectRecord:
-        """返回字段已归一化的新记录，避免数据库遗留非法值。"""
+        """Return a normalised record to avoid persisting invalid values."""
         allowed_chat_id = self._normalize_int(record.allowed_chat_id)
         clean_bot = self._sanitize_bot_name(record.bot_name)
         slug_source = record.project_slug.strip() or clean_bot
@@ -331,7 +333,7 @@ class ProjectRepository:
         )
 
     def _row_to_record(self, row: sqlite3.Row, *, normalize: bool = True) -> ProjectRecord:
-        """将数据库行转换为 ProjectRecord，可选是否立即归一化。"""
+        """Convert a database row into ProjectRecord, optionally normalising it."""
         record = ProjectRecord(
             bot_name=row["bot_name"],
             bot_token=row["bot_token"],
@@ -344,7 +346,7 @@ class ProjectRepository:
         return self._normalize_record_fields(record) if normalize else record
 
     def _repair_records(self) -> None:
-        """启动时统一修复遗留数据，确保 slug/bot name 无不合法字符。"""
+        """Repair legacy data on startup to ensure slugs and bot names are valid."""
         with self._connect() as conn:
             conn.row_factory = sqlite3.Row
             cursor = conn.execute(
@@ -367,13 +369,13 @@ class ProjectRepository:
             existing_slug_id = slug_owner.get(normalized.project_slug)
             if existing_slug_id is not None and existing_slug_id != current_id:
                 raise RuntimeError(
-                    f"项目 slug 归一化冲突: {normalized.project_slug} 已被记录 {existing_slug_id} 占用"
+                    f"Slug normalisation conflict: {normalized.project_slug} is already used by record {existing_slug_id}"
                 )
             slug_owner[normalized.project_slug] = current_id
             existing_bot_id = bot_owner.get(normalized.bot_name)
             if existing_bot_id is not None and existing_bot_id != current_id:
                 raise RuntimeError(
-                    f"bot 名归一化冲突: {normalized.bot_name} 已被记录 {existing_bot_id} 占用"
+                    f"Bot name normalisation conflict: {normalized.bot_name} is already used by record {existing_bot_id}"
                 )
             bot_owner[normalized.bot_name] = current_id
             if normalized != record:
@@ -402,10 +404,10 @@ class ProjectRepository:
                     ),
                 )
             conn.commit()
-        logger.info("已修复 %s 条项目配置，统一 slug/bot 名格式", len(updates))
+        logger.info("Repaired %s project records and normalised slug/bot formats", len(updates))
 
     def _export_to_json(self, records: Iterable[ProjectRecord]) -> None:
-        """将数据库内容导出为 JSON，兼容旧逻辑并保留易读格式。"""
+        """Export the database content to JSON, keeping it readable for legacy flows."""
         payload = [record.to_dict() for record in records]
         tmp_path = self.json_path.with_suffix(self.json_path.suffix + ".tmp")
         tmp_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")

scripts/__init__.py

@@ -1,2 +1 @@
-"""脚本模块标记，便于打包工具识别此目录。"""
-
+"""Marker module so packaging tools treat this directory as a package."""

scripts/bump_version.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
-# 版本管理便捷脚本
-# 使用方式：
+# Convenient script for version management
+# How to use:
 #   ./scripts/bump_version.sh patch
 #   ./scripts/bump_version.sh minor
 #   ./scripts/bump_version.sh major
@@ -9,81 +9,83 @@
 
 set -e
 
-# 项目根目录
+# Project root directory
 PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$PROJECT_ROOT"
 
-# bump-my-version 路径
-BUMP_CMD="/Users/david/.config/vibego/runtime/.venv/bin/bump-my-version"
+# bump-my-version path
+MASTER_CONFIG_ROOT="${MASTER_CONFIG_ROOT:-$HOME/.config/vibego}"
+RUNTIME_DIR="${VIBEGO_RUNTIME_ROOT:-$MASTER_CONFIG_ROOT/runtime}"
+BUMP_CMD="$RUNTIME_DIR/.venv/bin/bump-my-version"
 
-# 检查 bump-my-version 是否存在
+# Check if bump-my-version exists
 if [ ! -f "$BUMP_CMD" ]; then
-    echo "错误：找不到 bump-my-version"
-    echo "请先安装：pip install bump-my-version"
+    echo "Error: bump-my-version not found"
+    echo "Please install first: pip install bump-my-version"
     exit 1
 fi
 
-# 如果没有参数，显示帮助
+# If there are no parameters, display help
 if [ $# -eq 0 ]; then
-    echo "用法："
-    echo "  $0 patch         递增补丁版本 (0.2.11 → 0.2.12)"
-    echo "                   自动提交：fix: bugfixes"
-    echo "  $0 minor         递增次版本 (0.2.11 → 0.3.0)"
-    echo "                   自动提交：feat: 添加新功能"
-    echo "  $0 major         递增主版本 (0.2.11 → 1.0.0)"
-    echo "                   自动提交：feat!: 重大变更"
-    echo "  $0 show          显示当前版本"
-    echo "  $0 --dry-run     预览变更（添加在 patch/minor/major 后）"
+    echo "usage:"
+    echo "  $0 patch         Increment patch version (0.2.11 → 0.2.12)"
+    echo "                   Autocommit: fix: bugfixes"
+    echo "  $0 minor         Increment minor version (0.2.11 → 0.3.0)"
+    echo "                   Automatic submission: feat: Add new features"
+    echo "  $0 major         Increment major version (0.2.11 → 1.0.0)"
+    echo "                   Automatic submission: feat!: Major changes"
+    echo "  $0 show          Show current version"
+    echo "  $0 --dry-run     Preview changes (added in patch/minor/major back)"
     echo ""
-    echo "说明："
-    echo "  脚本会自动提交当前未提交的修改，然后递增版本号。"
-    echo "  如果不想自动提交，请在参数中添加 --no-auto-commit"
+    echo "illustrate:"
+    echo "  The script automatically commits the currently uncommitted changes and then increments the version number."
+    echo "  If you don't want to commit automatically, add --no-auto-commit to the parameters"
     echo ""
-    echo "示例："
-    echo "  $0 patch                    # 自动提交修改并递增补丁版本"
-    echo "  $0 patch --dry-run         # 预览补丁版本递增（不会提交）"
-    echo "  $0 minor --no-auto-commit  # 仅递增版本，不自动提交当前修改"
+    echo "Example:"
+    echo "  $0 patch                    # Automatically commit changes andIncrement patch version"
+    echo "  $0 patch --dry-run         # The preview patch version is incremented (will not be submitted)"
+    echo "  $0 minor --no-auto-commit  # Only increments version, does not automatically commit current modifications"
     exit 0
 fi
 
-# 处理 show 命令
+# Handling show commands
 if [ "$1" = "show" ]; then
     "$BUMP_CMD" show current_version
     exit 0
 fi
 
-# 处理 --help
+# Processing --help
 if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
     "$BUMP_CMD" --help
     exit 0
 fi
 
-# 检查是否禁用自动提交
+# Check if autocommit is disabled
 AUTO_COMMIT=true
 if [[ "$*" =~ "--no-auto-commit" ]]; then
     AUTO_COMMIT=false
 fi
 
-# 检查是否是 dry-run
+# Check if it is dry-run
 DRY_RUN=false
 if [[ "$*" =~ "--dry-run" ]]; then
     DRY_RUN=true
 fi
 
-# 获取版本类型
+# Get version type
 VERSION_TYPE="$1"
 
-# 获取对应版本类型的 commit 消息
+# Get the commit message of the corresponding version type
 get_commit_message() {
     case "$1" in
         patch)
             echo "fix: bugfixes"
             ;;
         minor)
-            echo "feat: 添加新功能"
+            echo "feat: Add new features"
             ;;
         major)
-            echo "feat!: 重大变更"
+            echo "feat!: Major changes"
             ;;
         *)
             echo ""
@@ -91,62 +93,62 @@ get_commit_message() {
     esac
 }
 
-# 检查版本类型是否有效
+# Check if the version type is valid
 COMMIT_MSG=$(get_commit_message "$VERSION_TYPE")
 if [ -z "$COMMIT_MSG" ]; then
-    # 如果不是有效的版本类型，直接传递给 bump-my-version
+    # If not a valid version type, pass it directly to bump-my-version
     "$BUMP_CMD" bump "$@"
     exit 0
 fi
 
-# 显示当前版本
-echo "📦 当前版本：$("$BUMP_CMD" show current_version)"
+# Show current version
+echo "📦 Current version:$("$BUMP_CMD" show current_version)"
 echo ""
 
-# 检查是否有未提交的修改
+# Check for uncommitted changes
 if [ "$AUTO_COMMIT" = true ] && [ "$DRY_RUN" = false ]; then
     if ! git diff-index --quiet HEAD -- 2>/dev/null; then
-        echo "📝 检测到未提交的修改，准备创建 commit..."
+        echo "📝 Uncommitted changes detected, prepare to create commit..."
         echo ""
 
-        echo "Commit 消息：$COMMIT_MSG"
+        echo "Commit information:$COMMIT_MSG"
         echo ""
 
-        # 显示将要提交的文件
-        echo "将要提交的文件："
+        # Show files to be submitted
+        echo "Documents to be submitted:"
         git status --short
         echo ""
 
-        # 提交所有修改
+        # Commit all changes
         git add .
         git commit -m "$COMMIT_MSG"
 
-        echo "✅ 代码修改已提交"
+        echo "OK: Code modification has been submitted"
         echo ""
     else
-        echo "ℹ️  没有未提交的修改，跳过自动 commit"
+        echo "ℹ️  No uncommitted changes, skip automatic commit"
         echo ""
     fi
 fi
 
-# 执行版本递增
-echo "🚀 开始递增版本..."
+# Execution version increment
+echo "🚀 Start incremental version..."
 echo ""
 
 "$BUMP_CMD" bump "$@"
 
 echo ""
-echo "✅ 版本管理完成！"
+echo "OK: Version management completed!"
 echo ""
-echo "📋 操作摘要："
+echo "📋 Operation summary:"
 if [ "$AUTO_COMMIT" = true ] && [ "$DRY_RUN" = false ]; then
-    echo "   1. 已提交代码修改（如有）"
-    echo "   2. 已递增版本号"
-    echo "   3. 已创建版本 commit 和 tag"
+    echo "   1. Submitted code modifications (if any)"
+    echo "   2. Version number incremented"
+    echo "   3. Version commit and tag created"
 else
-    echo "   1. 已递增版本号"
-    echo "   2. 已创建版本 commit 和 tag"
+    echo "   1. Version number incremented"
+    echo "   2. Version commit and tag created"
 fi
 echo ""
-echo "💡 提示：如需推送到远程，请执行："
+echo "💡 Tip: To push to remote, please execute:"
 echo "   git push && git push --tags"

scripts/log_writer.py

@@ -1,14 +1,17 @@
 #!/usr/bin/env python3
-"""面向 tmux pipe-pane 的日志写入器。
-
-功能：
-- 将 stdin 写入指定日志文件，确保主文件大小不超过阈值（默认 20MB）。
-- 超过阈值时将现有文件按时间戳归档，并创建新的主文件。
-- 定期清理超过保留时间（默认 24 小时）的归档文件。
-
-通过环境变量控制：
-- MODEL_LOG_MAX_BYTES：主日志文件最大字节数，默认 20971520 (20MB)
-- MODEL_LOG_RETENTION_SECONDS：归档文件保留时长，默认 86400 秒 (24h)
+"""Log writer for tmux pipe-pane.
+
+Features:
+- Stream stdin to a target log file while keeping the primary file under a
+  configurable size (default 20 MB).
+- When the threshold is exceeded, archive the current file with a timestamp
+  suffix and create a fresh primary log.
+- Periodically delete archived logs that exceed the retention window
+  (default 24 hours).
+
+Environment variables:
+- MODEL_LOG_MAX_BYTES: maximum size of the primary log file, default 20971520 (20 MB).
+- MODEL_LOG_RETENTION_SECONDS: retention period for archived files, default 86400 seconds (24 h).
 """
 
 from __future__ import annotations
@@ -25,7 +28,7 @@ DEFAULT_RETENTION_SECONDS = 24 * 60 * 60
 
 
 def _env_int(name: str, default: int) -> int:
-    """读取整数型环境变量，解析失败时返回默认值。"""
+    """Read an integer environment variable with graceful fallback."""
 
     raw = os.environ.get(name)
     if raw is None:
@@ -41,7 +44,7 @@ def _env_int(name: str, default: int) -> int:
 
 
 def cleanup_archives(base_path: Path, retention_seconds: int) -> None:
-    """删除超过保留时间的归档日志。"""
+    """Remove archived logs that exceed the retention period."""
 
     cutoff = time.time() - retention_seconds
     pattern = f"{base_path.stem}-*.log"
@@ -58,7 +61,7 @@ def cleanup_archives(base_path: Path, retention_seconds: int) -> None:
 
 
 def rotate_log(base_path: Path) -> Path:
-    """将当前主日志按时间戳归档，并返回归档后的路径。"""
+    """Archive the current primary log and return the archive path."""
 
     timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
     archive_name = f"{base_path.stem}-{timestamp}.log"
@@ -72,13 +75,13 @@ def rotate_log(base_path: Path) -> Path:
     try:
         base_path.rename(archive_path)
     except FileNotFoundError:
-        # 文件可能已被外部删除，此时无需归档
+        # External processes may have removed the file; skip archival in that case.
         return archive_path
     return archive_path
 
 
 def main() -> int:
-    """执行日志写入循环，处理滚动与归档清理。"""
+    """Run the logging loop, handling rotation and archive cleanup."""
 
     if len(sys.argv) != 2:
         sys.stderr.write("Usage: log_writer.py <log_file>\n")
@@ -91,7 +94,7 @@ def main() -> int:
     retention_seconds = _env_int("MODEL_LOG_RETENTION_SECONDS", DEFAULT_RETENTION_SECONDS)
 
     def open_log_file() -> tuple[int, object]:
-        """打开日志文件并返回当前大小及文件句柄。"""
+        """Open the log file and return the current size together with the handle."""
 
         fp = log_path.open("ab", buffering=0)
         try: