devmate 1.0.0__py3-none-any.whl

devmate_dbadmin/__init__.py

@@ -0,0 +1,263 @@
+"""
+dbadmin — 数据库管理
+
+支持 SQLite 和 PostgreSQL 的：
+  - 连接管理
+  - 表列表/表结构查看
+  - SQL 查询执行
+  - 保存的查询
+"""
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.engine import Engine
+
+from devmate.bus.command import CommandResult
+
+# ── 数据库连接管理 ──────────────────────────────────
+
+@dataclass
+class ConnectionInfo:
+    """已保存的数据库连接"""
+    name: str
+    dsn: str
+    engine: str = "sqlite"  # sqlite / postgresql
+    created_at: str = ""
+
+
+_connections: dict[str, Engine] = {}
+_CONNECTIONS_FILE = Path.home() / ".devmate" / "db_connections.json"
+
+
+def connect(dsn: str, name: str = "default") -> CommandResult:
+    """连接数据库"""
+    try:
+        engine = create_engine(dsn, pool_pre_ping=True)
+        # 测试连接
+        with engine.connect() as conn:
+            conn.execute(text("SELECT 1"))
+        _connections[name] = engine
+
+        # 保存连接信息
+        _save_connection(name, dsn)
+
+        return CommandResult(success=True, data={
+            "message": f"✅ 已连接到 {dsn}",
+            "engine": engine.name,
+            "dsn": dsn,
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=f"连接失败: {e}")
+
+
+def _save_connection(name: str, dsn: str):
+    """持久化连接信息"""
+    _CONNECTIONS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    connections = {}
+    if _CONNECTIONS_FILE.exists():
+        connections = json.loads(_CONNECTIONS_FILE.read_text())
+    connections[name] = {"dsn": dsn, "engine": _detect_engine(dsn)}
+    _CONNECTIONS_FILE.write_text(json.dumps(connections, indent=2))
+
+
+def _detect_engine(dsn: str) -> str:
+    if dsn.startswith("postgresql"):
+        return "postgresql"
+    return "sqlite"
+
+
+def get_engine(name: str = "default") -> Engine:
+    """获取已连接的 engine"""
+    engine = _connections.get(name)
+    if engine is None:
+        # 尝试从文件恢复
+        if _CONNECTIONS_FILE.exists():
+            cons = json.loads(_CONNECTIONS_FILE.read_text())
+            if name in cons:
+                engine = create_engine(cons[name]["dsn"], pool_pre_ping=True)
+                _connections[name] = engine
+    return engine
+
+
+# ── 表操作 ───────────────────────────────────────────
+
+def list_tables(name: str = "default") -> CommandResult:
+    """列出数据库中所有表"""
+    engine = get_engine(name)
+    if engine is None:
+        return CommandResult(success=False, error="未连接数据库。先用 devmate db connect <dsn>")
+
+    try:
+        inspector = inspect(engine)
+        tables = inspector.get_table_names()
+
+        result_data = []
+        for table_name in tables:
+            with engine.connect() as conn:
+                count = conn.execute(text(f"SELECT COUNT(*) FROM \"{table_name}\"")).scalar()
+            result_data.append({"name": table_name, "row_count": count})
+
+        return CommandResult(success=True, data={
+            "tables": result_data,
+            "total": len(result_data),
+            "engine": engine.name,
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))
+
+
+def show_table(table_name: str, name: str = "default") -> CommandResult:
+    """查看表结构"""
+    engine = get_engine(name)
+    if engine is None:
+        return CommandResult(success=False, error="未连接数据库")
+
+    try:
+        inspector = inspect(engine)
+        columns = inspector.get_columns(table_name)
+
+        col_info = []
+        for col in columns:
+            col_info.append({
+                "name": col["name"],
+                "type": str(col["type"]),
+                "nullable": col.get("nullable", True),
+                "primary_key": col.get("primary_key", False),
+                "default": str(col.get("default", "")) if col.get("default") else "",
+            })
+
+        # 前 10 行数据预览
+        preview_rows: list[list[Any]] = []
+        preview_columns: list[str] = [c["name"] for c in columns]
+        with engine.connect() as conn:
+            quoted = _quote_table(table_name, engine)
+            result = conn.execute(text(f"SELECT * FROM {quoted} LIMIT 10"))
+            preview_rows = [list(row) for row in result]
+
+        return CommandResult(success=True, data={
+            "table": table_name,
+            "columns": col_info,
+            "preview": {
+                "columns": preview_columns,
+                "rows": preview_rows,
+            },
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))
+
+
+# ── SQL 查询执行 ─────────────────────────────────────
+
+def query(sql: str, name: str = "default", timeout: int = 5) -> CommandResult:
+    """执行 SQL 查询"""
+    engine = get_engine(name)
+    if engine is None:
+        return CommandResult(success=False, error="未连接数据库。先用 devmate db connect <dsn>")
+
+    start = time.time()
+    try:
+        with engine.connect() as conn:
+            conn.execute(text("SELECT 1"))  # ping
+
+            _query_keywords = ("SELECT", "WITH", "EXPLAIN", "SHOW", "DESCRIBE", "PRAGMA")
+            if sql.strip().upper().startswith(_query_keywords):
+                result = conn.execute(text(sql))
+                columns = list(result.keys())
+                rows = [list(row) for row in result.fetchmany(100)]
+                elapsed = round((time.time() - start) * 1000, 1)
+
+                return CommandResult(success=True, data={
+                    "type": "query",
+                    "columns": columns,
+                    "rows": rows,
+                    "row_count": len(rows),
+                    "elapsed_ms": elapsed,
+                })
+            else:
+                conn.execute(text(sql))
+                conn.commit()
+                elapsed = round((time.time() - start) * 1000, 1)
+
+                # 获取影响行数
+                return CommandResult(success=True, data={
+                    "type": "execute",
+                    "message": "查询执行成功",
+                    "elapsed_ms": elapsed,
+                })
+
+    except Exception as e:
+        elapsed = round((time.time() - start) * 1000, 1)
+        hint = _generate_error_hint(str(e))
+        return CommandResult(success=False, error=str(e), suggestion=hint)
+
+
+def _generate_error_hint(error_msg: str) -> str:
+    """根据错误信息生成中文提示"""
+    error_lower = error_msg.lower()
+
+    if "no such table" in error_lower:
+        return "表不存在。运行 devmate db list-tables 查看所有表"
+    if "no such column" in error_lower or "unknown column" in error_lower:
+        return "列不存在。运行 devmate db show <表名> 查看表结构"
+    if "syntax error" in error_lower:
+        return "SQL 语法错误。检查关键字拼写和标点符号"
+    if "permission denied" in error_lower:
+        return "权限不足。检查数据库用户权限"
+    if "timeout" in error_lower:
+        return "查询超时。尝试添加 LIMIT 限制或优化查询"
+    if "duplicate column" in error_lower:
+        return "列名重复。检查 SELECT 中是否选择了多次同名列"
+
+    return "检查 SQL 语句是否正确，或运行 devmate db show <表名> 查看表结构"
+
+
+def _quote_table(table_name: str, engine: Engine) -> str:
+    """安全地引用表名"""
+    if engine.name == "postgresql":
+        return f'"{table_name}"'
+    return f'"{table_name}"'
+
+
+# ── 保存的查询 ──────────────────────────────────────
+
+_SAVED_FILE = Path.home() / ".devmate" / "saved_queries.json"
+
+
+def save_query(name: str, sql: str) -> CommandResult:
+    """保存查询"""
+    _SAVED_FILE.parent.mkdir(parents=True, exist_ok=True)
+    queries = {}
+    if _SAVED_FILE.exists():
+        queries = json.loads(_SAVED_FILE.read_text())
+
+    queries[name] = {"sql": sql, "created": time.strftime("%Y-%m-%d %H:%M")}
+    _SAVED_FILE.write_text(json.dumps(queries, indent=2, ensure_ascii=False))
+    return CommandResult(success=True, data={"message": f"查询已保存: {name}"})
+
+
+def list_saved_queries() -> CommandResult:
+    """列出保存的查询"""
+    if not _SAVED_FILE.exists():
+        return CommandResult(success=True, data={"queries": []})
+
+    queries = json.loads(_SAVED_FILE.read_text())
+    data = [{"name": k, "sql": v["sql"], "created": v.get("created", "")}
+            for k, v in queries.items()]
+    return CommandResult(success=True, data={"queries": data})
+
+
+def run_saved_query(name: str, conn_name: str = "default") -> CommandResult:
+    """运行保存的查询"""
+    if not _SAVED_FILE.exists():
+        return CommandResult(success=False, error="没有保存的查询")
+
+    queries = json.loads(_SAVED_FILE.read_text())
+    if name not in queries:
+        return CommandResult(success=False, error=f"查询不存在: {name}")
+
+    return query(queries[name]["sql"], name=conn_name)

devmate_gitflow/__init__.py

@@ -0,0 +1,247 @@
+"""
+gitflow — Git 工作流增强
+
+包含 Conventional Commit 校验、CHANGELOG 自动生成、.gitignore 生成器、仓库统计。
+"""
+
+import re
+import subprocess
+from pathlib import Path
+
+from devmate.bus.command import CommandResult
+
+# ── Conventional Commit 规范 ─────────────────────────
+
+CONVENTIONAL_TYPES = {
+    "feat": "新功能",
+    "fix": "Bug 修复",
+    "docs": "文档更新",
+    "style": "代码格式（不影响功能）",
+    "refactor": "重构",
+    "perf": "性能优化",
+    "test": "测试相关",
+    "build": "构建系统",
+    "ci": "CI 配置",
+    "chore": "杂项",
+    "revert": "回退",
+}
+
+COMMIT_PATTERN = re.compile(
+    r"^(?P<type>\w+)(?:\((?P<scope>[\w.-]+)\))?"
+    r"(?P<breaking>!)?:\s*(?P<description>.+)"
+    r"(?:\n\n(?P<body>.+))?"
+    r"(?:\n\n(?P<footer>.+))?$",
+    re.DOTALL,
+)
+
+
+def commit_check(message: str) -> CommandResult:
+    """校验 Git commit message 是否符合 Conventional Commit 规范"""
+    result = {
+        "valid": False,
+        "type": "",
+        "scope": "",
+        "description": "",
+        "breaking": False,
+        "errors": [],
+        "warnings": [],
+    }
+
+    if not message or not message.strip():
+        result["errors"].append("Commit message 不能为空")
+        return CommandResult(success=False, data=result, error="Commit message 为空")
+
+    m = COMMIT_PATTERN.match(message.strip())
+    if not m:
+        result["errors"].append(
+            "格式错误。正确格式: <type>(<scope>): <description>\n"
+            "示例: feat(cli): 添加 --json 选项"
+        )
+        suggestion = result["errors"][0]
+        return CommandResult(success=False, data=result, error="格式错误", suggestion=suggestion)
+
+    result["valid"] = True
+    result["type"] = m.group("type")
+    result["scope"] = m.group("scope") or ""
+    result["description"] = m.group("description")
+    result["breaking"] = bool(m.group("breaking"))
+
+    # 校验 type
+    if result["type"] not in CONVENTIONAL_TYPES:
+        types_str = ", ".join(CONVENTIONAL_TYPES.keys())
+        result["warnings"].append(
+            f"未知类型 '{result['type']}'。标准类型: {types_str}"
+        )
+
+    # 校验 description 长度
+    if len(result["description"]) > 100:
+        result["warnings"].append(f"描述过长 ({len(result['description'])} 字符)，建议 ≤ 72 字符")
+    elif len(result["description"]) < 5:
+        result["warnings"].append(f"描述过短 ({len(result['description'])} 字符)，建议 5-72 字符")
+
+    return CommandResult(success=True, data=result)
+
+
+# ── CHANGELOG 生成 ──────────────────────────────────
+
+CHANGELOG_HEADER = """# CHANGELOG
+
+> 自动生成，基于 Conventional Commit
+
+"""
+
+
+def changelog(path: str = ".", since: str = "") -> CommandResult:
+    """从 git log 自动生成 CHANGELOG"""
+    repo = Path(path).expanduser().resolve()
+    git_dir = repo / ".git"
+    if not git_dir.exists():
+        return CommandResult(success=False, error=f"不是 Git 仓库: {path}")
+
+    try:
+        since_arg = f"--since={since}" if since else "--max-count=100"
+        result = subprocess.run(
+            ["git", "log", "--format=%s|||%b|||%H|||%an|||%ai", since_arg],
+            capture_output=True, text=True, cwd=str(repo),
+        )
+        if result.returncode != 0:
+            return CommandResult(success=False, error=f"git log 失败: {result.stderr.strip()}")
+    except FileNotFoundError:
+        return CommandResult(success=False, error="git 未安装")
+
+    lines = [ln for ln in result.stdout.strip().split("\n") if ln.strip()]
+    if not lines:
+        return CommandResult(success=True, data={"message": "没有提交记录"})
+
+    grouped: dict[str, list[dict]] = {}
+    for line in lines:
+        parts = line.split("|||")
+        if len(parts) < 5:
+            continue
+        subject, body, commit_hash, author, date = parts[:5]
+
+        m = COMMIT_PATTERN.match(subject)
+        if not m:
+            commit_type = "other"
+        else:
+            commit_type = m.group("type") or "other"
+
+        grouped.setdefault(commit_type, []).append({
+            "subject": subject,
+            "hash": commit_hash[:8],
+            "author": author,
+            "date": date[:10],
+        })
+
+    # 渲染 Markdown
+    md = CHANGELOG_HEADER
+    md += f"## {since or '最新提交'}\n\n"
+
+    type_order = ["feat", "fix", "refactor", "perf", "docs", "style", "test", "chore", "other"]
+    for t in type_order:
+        if t not in grouped:
+            continue
+        label = CONVENTIONAL_TYPES.get(t, t.capitalize())
+        md += f"### {label}\n\n"
+        for commit in grouped[t]:
+            md += f"- {commit['subject']} ({commit['hash']})\n"
+        md += "\n"
+
+    return CommandResult(success=True, data={
+        "markdown": md,
+        "commit_count": len(lines),
+    })
+
+
+# ── .gitignore 生成 ─────────────────────────────────
+
+GITIGNORE_TEMPLATES: dict[str, list[str]] = {
+    "python": [
+        "# Python", "__pycache__/", "*.py[cod]", "*$py.class", "*.so",
+        ".Python", "build/", "develop-eggs/", "dist/", "downloads/",
+        "*.egg-info/", ".eggs/", "*.egg", ".venv/", "venv/", "env/",
+        ".pytest_cache/", ".ruff_cache/", ".mypy_cache/", "*.cover",
+    ],
+    "node": [
+        "# Node", "node_modules/", "npm-debug.log*", "yarn-debug.log*",
+        "yarn-error.log*", ".pnp.*", ".yarn/", "dist/", "build/",
+        ".next/", "coverage/", ".env.local", ".env.production",
+    ],
+    "macos": [
+        "# macOS", ".DS_Store", ".AppleDouble", ".LSOverride",
+        "Icon\\x0d", "._*", ".Spotlight-V100", ".Trashes",
+    ],
+    "ide": [
+        "# IDE", ".vscode/", ".idea/", "*.swp", "*.swo", "*~",
+        ".project", ".classpath", ".settings/",
+    ],
+}
+
+
+def gitignore(types: list[str]) -> CommandResult:
+    """生成 .gitignore 内容"""
+    lines = []
+    for t in types:
+        if t in GITIGNORE_TEMPLATES:
+            lines.extend(GITIGNORE_TEMPLATES[t])
+
+    if not lines:
+        types_list = ", ".join(GITIGNORE_TEMPLATES.keys())
+        return CommandResult(success=False, error=f"不支持的类型。支持: {types_list}")
+
+    content = "\n".join(lines) + "\n"
+    return CommandResult(success=True, data={"content": content, "types": types})
+
+
+# ── 仓库统计 ────────────────────────────────────────
+
+def stats(path: str = ".") -> CommandResult:
+    """统计 Git 仓库信息"""
+    repo = Path(path).expanduser().resolve()
+    git_dir = repo / ".git"
+    if not git_dir.exists():
+        return CommandResult(success=False, error=f"不是 Git 仓库: {path}")
+
+    try:
+        # 总提交数
+        r1 = subprocess.run(["git", "rev-list", "--count", "HEAD"],
+                            capture_output=True, text=True, cwd=str(repo))
+        total_commits = r1.stdout.strip()
+
+        # 贡献者列表
+        r2 = subprocess.run(
+            ["git", "shortlog", "-sn", "HEAD"],
+            capture_output=True, text=True, cwd=str(repo),
+        )
+        contributors = []
+        for line in r2.stdout.strip().split("\n"):
+            if line.strip():
+                parts = line.strip().split("\t", 1)
+                if len(parts) == 2:
+                    commits = int(parts[0].strip())
+                    name = parts[1].strip()
+                    contributors.append({"commits": commits, "name": name})
+
+        # 分支数
+        r3 = subprocess.run(["git", "branch", "--list"],
+                            capture_output=True, text=True, cwd=str(repo))
+        branch_count = len([b for b in r3.stdout.split("\n") if b.strip()])
+
+        # 代码行数
+        subprocess.run(
+            ["git", "diff", "--shortstat", "HEAD~1..HEAD", "--"],
+            capture_output=True, text=True, cwd=str(repo),
+            # 如果 HEAD~1 不存在（第一次提交），忽略
+        )
+
+        return CommandResult(success=True, data={
+            "total_commits": total_commits,
+            "contributors": contributors,
+            "contributor_count": len(contributors),
+            "branch_count": branch_count,
+            "path": str(repo),
+        })
+    except FileNotFoundError:
+        return CommandResult(success=False, error="git 未安装")
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))

devmate_monitor/__init__.py

@@ -0,0 +1,112 @@
+"""
+monitor — 系统资源监控
+
+提供 CPU/内存/磁盘监控、进程列表、实时日志追踪。
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from devmate.bus.command import CommandResult
+
+
+def _run(cmd: list[str], timeout: int = 5) -> str:
+    """运行 shell 命令并返回输出"""
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def dashboard() -> CommandResult:
+    """系统资源概览"""
+    data: dict[str, Any] = {}
+
+    # CPU
+    cpu_info = _run(["python3", "-c", "import os; print(os.cpu_count() or 'N/A')"])
+    load = _run(["sysctl", "-n", "vm.loadavg"])[:50] if Path("/usr/bin/sysctl").exists() else ""
+
+    # 内存
+    try:
+        import psutil
+        mem = psutil.virtual_memory()
+        data["memory"] = {
+            "total": f"{mem.total / 1024**3:.1f}GB",
+            "used": f"{mem.used / 1024**3:.1f}GB",
+            "percent": mem.percent,
+            "available": f"{mem.available / 1024**3:.1f}GB",
+        }
+    except ImportError:
+        data["memory"] = {"total": "?", "used": "?", "percent": 0}
+
+    # 磁盘
+    disk = _run(["df", "-h", "/"])
+    data["disk"] = {"info": disk[:200]}
+
+    # 进程数
+    proc_count = _run(["ps", "-e", "--no-headers", "|", "wc", "-l"])
+    data["processes"] = proc_count
+
+    # 系统信息
+    hostname = _run(["hostname"])
+    uptime = _run(["uptime"])[:100]
+    data["system"] = {
+        "hostname": hostname,
+        "cpu_count": cpu_info,
+        "load": load,
+        "uptime": uptime,
+    }
+
+    return CommandResult(success=True, data=data)
+
+
+def process_list(sort_by: str = "cpu", limit: int = 20) -> CommandResult:
+    """进程列表"""
+    try:
+        import psutil
+        processes = []
+        for proc in psutil.process_iter(["pid", "name", "cpu_percent", "memory_percent", "status"]):
+            try:
+                info = proc.info
+                processes.append({
+                    "pid": info["pid"],
+                    "name": info["name"] or "",
+                    "cpu": info["cpu_percent"] or 0.0,
+                    "memory": info["memory_percent"] or 0.0,
+                    "status": info["status"] or "",
+                })
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+
+        if sort_by == "cpu":
+            processes.sort(key=lambda p: p["cpu"], reverse=True)
+        elif sort_by == "memory":
+            processes.sort(key=lambda p: p["memory"], reverse=True)
+
+        return CommandResult(success=True, data={
+            "processes": processes[:limit],
+            "total": len(processes),
+        })
+    except ImportError:
+        return CommandResult(success=False, error="需要安装 psutil: pip install psutil")
+
+
+def log_tail(path: str, lines: int = 50) -> CommandResult:
+    """实时日志追踪"""
+    log_file = Path(path).expanduser()
+    if not log_file.exists():
+        return CommandResult(success=False, error=f"日志文件不存在: {path}")
+
+    try:
+        content = log_file.read_text(encoding="utf-8", errors="replace")
+        last_lines = "\n".join(content.split("\n")[-lines:])
+        return CommandResult(success=True, data={
+            "path": str(log_file),
+            "lines": lines,
+            "content": last_lines,
+            "size": log_file.stat().st_size,
+        })
+    except Exception as e:
+        return CommandResult(success=False, error=str(e))