devmate 1.0.0__py3-none-any.whl

devmate_notekeeper/__init__.py

@@ -0,0 +1,280 @@
+"""
+notekeeper — 笔记知识库
+
+基于 SQLite 的轻量笔记系统，支持 FTS5 全文搜索、标签管理、Markdown 导入导出。
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import create_engine, text
+
+from devmate.bus.command import CommandResult
+
+# ── 数据库初始化 ────────────────────────────────────
+
+DB_PATH = Path.home() / ".devmate" / "notes.db"
+engine = create_engine(f"sqlite:///{DB_PATH}", pool_pre_ping=True)
+
+
+def _init_db():
+    """初始化数据库表"""
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with engine.connect() as conn:
+        conn.execute(text("""
+            CREATE TABLE IF NOT EXISTS notes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL DEFAULT '',
+                tags TEXT NOT NULL DEFAULT '',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            )
+        """))
+        conn.execute(text("""
+            CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+                title, content, content=notes, content_rowid=id
+            )
+        """))
+        conn.commit()
+
+
+# ── 笔记 CRUD ──────────────────────────────────────
+
+@dataclass
+class Note:
+    """笔记数据"""
+    id: int
+    title: str
+    content: str
+    tags: list[str] = field(default_factory=list)
+    created_at: str = ""
+    updated_at: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id, "title": self.title,
+            "content": self.content[:200] if len(self.content) > 200 else self.content,
+            "tags": self.tags, "created_at": self.created_at,
+            "updated_at": self.updated_at,
+        }
+
+
+def _row_to_note(row) -> Note:
+    tags = []
+    if row.tags:
+        tags = json.loads(row.tags)
+    return Note(id=row.id, title=row.title, content=row.content,
+                tags=tags, created_at=row.created_at, updated_at=row.updated_at)
+
+
+def _now() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+_init_db()
+
+
+def new(title: str, content: str = "", tags: str = "") -> CommandResult:
+    """创建笔记"""
+    now = _now()
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
+    with engine.connect() as conn:
+        result = conn.execute(
+            text("INSERT INTO notes (title, content, tags, created_at, updated_at) "
+                 "VALUES (:title, :content, :tags, :ca, :ua)"),
+            {"title": title, "content": content, "tags": json.dumps(tag_list),
+             "ca": now, "ua": now},
+        )
+        note_id = result.lastrowid
+        # 同步 FTS
+        conn.execute(text("INSERT INTO notes_fts(rowid, title, content) VALUES (:id, :t, :c)"),
+                     {"id": note_id, "t": title, "c": content})
+        conn.commit()
+
+    return CommandResult(success=True, data={"id": note_id, "message": f"✅ 笔记已创建: {title}"})
+
+
+def list_notes(limit: int = 20, offset: int = 0) -> CommandResult:
+    """列出笔记"""
+    with engine.connect() as conn:
+        rows = conn.execute(
+            text("SELECT id, title, content, tags, created_at, updated_at "
+                 "FROM notes ORDER BY updated_at DESC LIMIT :lim OFFSET :off"),
+            {"lim": limit, "off": offset},
+        ).fetchall()
+
+        count = conn.execute(text("SELECT COUNT(*) FROM notes")).scalar()
+
+    notes = [_row_to_note(r) for r in rows]
+    return CommandResult(success=True, data={
+        "notes": [n.to_dict() for n in notes],
+        "total": count,
+    })
+
+
+def show(note_id: int) -> CommandResult:
+    """查看单条笔记"""
+    with engine.connect() as conn:
+        row = conn.execute(
+            text("SELECT * FROM notes WHERE id = :id"), {"id": note_id}
+        ).fetchone()
+
+    if row is None:
+        return CommandResult(success=False, error=f"笔记不存在: {note_id}")
+
+    note = _row_to_note(row)
+    return CommandResult(success=True, data=note.to_dict())
+
+
+def edit(note_id: int, title: str = "", content: str = "",
+         tags: str = "") -> CommandResult:
+    """编辑笔记"""
+    updates: list[str] = []
+    params: dict[str, Any] = {"id": note_id}
+
+    if title:
+        updates.append("title = :title")
+        params["title"] = title
+    if content:
+        updates.append("content = :content")
+        params["content"] = content
+    if tags:
+        tag_list = [t.strip() for t in tags.split(",") if t.strip()]
+        params["tags"] = json.dumps(tag_list)
+        updates.append("tags = :tags")
+
+    if not updates:
+        return CommandResult(success=False, error="没有要更新的内容")
+
+    updates.append("updated_at = :ua")
+    params["ua"] = _now()
+
+    with engine.connect() as conn:
+        conn.execute(
+            text(f"UPDATE notes SET {', '.join(updates)} WHERE id = :id"),
+            params,
+        )
+        # 同步 FTS
+        if title or content:
+            row = conn.execute(
+                text("SELECT title, content FROM notes WHERE id = :id"), {"id": note_id}
+            ).fetchone()
+            if row:
+                conn.execute(text(
+                    "DELETE FROM notes_fts WHERE rowid = :id"
+                ), {"id": note_id})
+                conn.execute(text(
+                    "INSERT INTO notes_fts(rowid, title, content) VALUES (:id, :t, :c)"
+                ), {"id": note_id, "t": row[0], "c": row[1]})
+        conn.commit()
+
+    return CommandResult(success=True, data={"message": "✅ 笔记已更新"})
+
+
+
+def remove(note_id: int) -> CommandResult:
+    """删除笔记"""
+    with engine.connect() as conn:
+        conn.execute(text("DELETE FROM notes WHERE id = :id"), {"id": note_id})
+        conn.execute(text("DELETE FROM notes_fts WHERE rowid = :id"), {"id": note_id})
+        conn.commit()
+
+    return CommandResult(success=True, data={"message": "✅ 笔记已删除"})
+
+
+# ── FTS5 全文搜索 ──────────────────────────────────
+
+def search(query: str, limit: int = 20) -> CommandResult:
+    """全文搜索笔记"""
+    with engine.connect() as conn:
+        rows = conn.execute(
+            text("SELECT n.id, n.title, n.content, n.tags, n.created_at, n.updated_at "
+                 "FROM notes_fts f JOIN notes n ON f.rowid = n.id "
+                 "WHERE notes_fts MATCH :q ORDER BY rank LIMIT :lim"),
+            {"q": query, "lim": limit},
+        ).fetchall()
+
+    notes = [_row_to_note(r) for r in rows]
+    return CommandResult(success=True, data={
+        "notes": [n.to_dict() for n in notes],
+        "total": len(notes),
+        "query": query,
+    })
+
+
+# ── 标签管理 ───────────────────────────────────────
+
+def tag_list() -> CommandResult:
+    """列出所有标签"""
+    with engine.connect() as conn:
+        rows = conn.execute(text("SELECT tags FROM notes")).fetchall()
+
+    tag_count: dict[str, int] = {}
+    for row in rows:
+        if row.tags:
+            for t in json.loads(row.tags):
+                tag_count[t] = tag_count.get(t, 0) + 1
+
+    tags = [{"name": k, "count": v} for k, v in sorted(tag_count.items())]
+    return CommandResult(success=True, data={"tags": tags})
+
+
+# ── Markdown 导入导出 ──────────────────────────────
+
+def export_note(note_id: int, output: str = "") -> CommandResult:
+    """导出笔记为 Markdown"""
+    result = show(note_id)
+    if not result.success:
+        return result
+
+    note = result.data
+    tags_str = ", ".join(note.get("tags", []))
+    md = f"""---
+title: "{note['title']}"
+created: {note.get('created_at', '')}
+updated: {note.get('updated_at', '')}
+tags: [{tags_str}]
+---
+
+{note.get('content', '')}
+"""
+
+    if output:
+        out_path = Path(output).expanduser()
+        out_path.write_text(md, encoding="utf-8")
+        return CommandResult(success=True, data={"message": f"已导出: {out_path}", "path": str(out_path)})  # noqa: E501
+
+    return CommandResult(success=True, data={"markdown": md})
+
+
+def import_markdown(path: str) -> CommandResult:
+    """从 Markdown 文件导入笔记"""
+    file_path = Path(path).expanduser()
+    if not file_path.exists():
+        return CommandResult(success=False, error=f"文件不存在: {path}")
+
+    content = file_path.read_text(encoding="utf-8")
+
+    # 解析 frontmatter
+    title = file_path.stem
+    tags = ""
+    body = content
+
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            front = parts[1]
+            body = parts[2].strip()
+            for line in front.split("\n"):
+                line = line.strip()
+                if line.startswith("title:"):
+                    title = line.split(":", 1)[1].strip().strip('"\'')
+                elif line.startswith("tags:"):
+                    tag_str = line.split(":", 1)[1].strip()
+                    tags = tag_str.strip("[]").replace(",", ",")
+
+    return new(title, body, tags)

devmate_regexlab/__init__.py

@@ -0,0 +1,212 @@
+"""
+regexlab — 正则表达式实验室
+
+包含正则测试、文件搜索、常用正则库等实用功能。
+"""
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from devmate.bus.command import CommandResult
+
+# ── 内置正则库 ──────────────────────────────────────
+
+BUILTIN_PATTERNS: dict[str, dict[str, str]] = {
+    "邮箱": {
+        "pattern": r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$",
+        "desc": "匹配常见邮箱地址",
+        "example": "user@example.com",
+    },
+    "手机号": {
+        "pattern": r"^1[3-9]\d{9}$",
+        "desc": "匹配中国大陆手机号",
+        "example": "13800138000",
+    },
+    "URL": {
+        "pattern": r"https?://[^\s/$.?#].[^\s]*",
+        "desc": "匹配 HTTP/HTTPS URL",
+        "example": "https://example.com/path?q=1",
+    },
+    "IPv4": {
+        "pattern": r"\b(?:\d{1,3}\.){3}\d{1,3}\b",
+        "desc": "匹配 IPv4 地址",
+        "example": "192.168.1.1",
+    },
+    "身份证号": {
+        "pattern": r"^[1-9]\d{5}(?:19|20)\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])\d{3}[\dXx]$",
+        "desc": "匹配 18 位身份证号",
+        "example": "110101199001011234",
+    },
+    "日期 (YYYY-MM-DD)": {
+        "pattern": r"\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])",
+        "desc": "匹配 YYYY-MM-DD 格式日期",
+        "example": "2026-07-24",
+    },
+    "中文字符": {
+        "pattern": r"[\u4e00-\u9fff]+",
+        "desc": "匹配连续的中文字符",
+        "example": "你好世界",
+    },
+}
+
+CUSTOM_LIB_FILE = Path.home() / ".devmate" / "regex_lib.json"
+
+
+# ── 正则测试 ────────────────────────────────────────
+
+def match(pattern: str, text: str, flags: str = "") -> CommandResult:
+    """测试正则匹配"""
+    try:
+        flag_val = _parse_flags(flags)
+        compiled = re.compile(pattern, flag_val)
+    except re.error as e:
+        return CommandResult(success=False, error=f"正则语法错误: {e}",
+                             suggestion="检查正则表达式中的特殊字符是否转义正确")
+
+    results: list[dict[str, Any]] = []
+    for m in compiled.finditer(text):
+        start, end = m.span()
+        results.append({
+            "matched": m.group(),
+            "start": start,
+            "end": end,
+            "groups": [g for g in m.groups() if g is not None],
+        })
+
+    return CommandResult(success=True, data={
+        "pattern": pattern,
+        "text_length": len(text),
+        "matches": results,
+        "total": len(results),
+        "flags": flags,
+    })
+
+
+def _parse_flags(flags: str) -> int:
+    """解析标志字符串为 re 标志位"""
+    flag_val = 0
+    flag_map = {
+        "i": re.IGNORECASE,
+        "m": re.MULTILINE,
+        "s": re.DOTALL,
+        "x": re.VERBOSE,
+        "u": re.UNICODE,
+    }
+    for f in flags.lower():
+        if f in flag_map:
+            flag_val |= flag_map[f]
+    return flag_val
+
+
+# ── 文件搜索 ────────────────────────────────────────
+
+def search(pattern: str, path: str, flags: str = "",
+           max_results: int = 50) -> CommandResult:
+    """在文件中搜索正则"""
+    target = Path(path).expanduser().resolve()
+    if not target.exists():
+        return CommandResult(success=False, error=f"路径不存在: {path}")
+
+    try:
+        flag_val = _parse_flags(flags)
+        compiled = re.compile(pattern, flag_val)
+    except re.error as e:
+        return CommandResult(success=False, error=f"正则语法错误: {e}")
+
+    files_checked = 0
+    matches_found = 0
+    file_matches: list[dict[str, Any]] = []
+
+    if target.is_file():
+        files = [target]
+    else:
+        files = list(target.rglob("*"))[:200]  # 最多检查 200 个文件
+
+    for file_path in files:
+        if file_path.is_dir() or file_path.is_symlink():
+            continue
+        try:
+            # 只检查文本文件
+            if file_path.suffix in (".pyc", ".pyo", ".so", ".dll", ".dylib", ".bin"):
+                continue
+            content = file_path.read_text(errors="ignore")
+            files_checked += 1
+            if matches_found >= max_results:
+                break
+            for i, line in enumerate(content.split("\n"), 1):
+                if compiled.search(line):
+                    if matches_found >= max_results:
+                        break
+                    file_rel = (
+                        file_path.relative_to(target)
+                        if target.is_dir() else file_path.name
+                    )
+                    file_matches.append({
+                        "file": str(file_rel),
+                        "line": i,
+                        "content": line.strip()[:100],
+                    })
+                    matches_found += 1
+        except (OSError, UnicodeDecodeError):
+            continue
+
+    return CommandResult(success=True, data={
+        "pattern": pattern,
+        "target": str(target),
+        "files_checked": files_checked,
+        "matches": file_matches,
+        "total": matches_found,
+    })
+
+
+# ── 正则库 ──────────────────────────────────────────
+
+def lib_list() -> CommandResult:
+    """列出内置和自定义正则"""
+    custom = []
+    if CUSTOM_LIB_FILE.exists():
+        custom = json.loads(CUSTOM_LIB_FILE.read_text())
+
+    builtin_list = [{"name": k, **v} for k, v in BUILTIN_PATTERNS.items()]
+
+    return CommandResult(success=True, data={
+        "builtin": builtin_list,
+        "custom": custom,
+    })
+
+
+def lib_add(name: str, pattern: str, desc: str = "", example: str = "") -> CommandResult:
+    """添加自定义正则"""
+    CUSTOM_LIB_FILE.parent.mkdir(parents=True, exist_ok=True)
+    lib = []
+    if CUSTOM_LIB_FILE.exists():
+        lib = json.loads(CUSTOM_LIB_FILE.read_text())
+
+    # 验证正则
+    try:
+        re.compile(pattern)
+    except re.error as e:
+        return CommandResult(success=False, error=f"正则语法错误: {e}")
+
+    # 更新或添加
+    lib = [item for item in lib if item.get("name") != name]
+    lib.append({"name": name, "pattern": pattern, "desc": desc, "example": example})
+    CUSTOM_LIB_FILE.write_text(json.dumps(lib, indent=2, ensure_ascii=False))
+    return CommandResult(success=True, data={"message": f"已添加正则: {name}"})
+
+
+def lib_remove(name: str) -> CommandResult:
+    """删除自定义正则"""
+    if not CUSTOM_LIB_FILE.exists():
+        return CommandResult(success=False, error="自定义正则库为空")
+
+    lib = json.loads(CUSTOM_LIB_FILE.read_text())
+    before = len(lib)
+    lib = [item for item in lib if item.get("name") != name]
+    if len(lib) == before:
+        return CommandResult(success=False, error=f"未找到正则: {name}")
+
+    CUSTOM_LIB_FILE.write_text(json.dumps(lib, indent=2, ensure_ascii=False))
+    return CommandResult(success=True, data={"message": f"已删除正则: {name}"})

devmate_reporter/__init__.py

@@ -0,0 +1,170 @@
+"""
+reporter — 报告自动生成
+
+基于 git log + 笔记的日报/周报，支持多模板和 Markdown/HTML 导出。
+"""
+
+import subprocess
+import time
+from pathlib import Path
+
+from devmate.bus.command import CommandResult
+
+REPORTS_DIR = Path.home() / ".devmate" / "reports"
+
+
+TEMPLATES: dict[str, dict[str, str]] = {
+    "minimal": {
+        "name": "简洁",
+        "desc": "只包含核心要点",
+        "header": "# {title}\n\n**周期*  # noqa: E501*: {period}\n\n",
+        "section_commits": "## 提交\n\n{commits}\n",
+        "section_notes": "## 笔记\n\n{notes}\n",
+    },
+    "standup": {
+        "name": "站会",
+        "desc": "昨日/今日/阻塞",
+        "header": "# 站会报告 - {period}\n\n",
+        "section_commits": "## 昨日完成\n\n{commits}\n",
+        "section_notes": "## 今日计划\n\n{notes}\n",
+        "section_blockers": "## 阻塞项\n\n{none}",
+    },
+    "detailed": {
+        "name": "详细",
+        "desc": "包含统计 + 变更明细",
+        "header": "# {title}\n\n**周期*  # noqa: E501*: {period}\n\n## 统计\n\n- 提交数: {commit_count}\n- 变更文件: {file_count}\n\n",  # noqa: E501
+        "section_commits": "## 提交明细\n\n| 时间 | 提交 | 说明 |\n|------|------|------|\n{commits}\n",  # noqa: E501
+        "section_notes": "## 笔记\n\n{notes}\n",
+    },
+}
+
+
+def _git_log(since: str, path: str = ".") -> tuple[list[dict], int]:
+    """获取 git 日志"""
+    try:
+        result = subprocess.run(
+            ["git", "log", "--oneline", "--since", since,
+             "--format=%h|||%s|||%an|||%ai"],
+            capture_output=True, text=True, cwd=path, timeout=10,
+        )
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if not line.strip():
+                continue
+            parts = line.split("|||", 3)
+            if len(parts) == 4:
+                commits.append({
+                    "hash": parts[0], "subject": parts[1],
+                    "author": parts[2], "date": parts[3][:10],
+                })
+
+        # 变更文件数
+        stat_result = subprocess.run(
+            ["git", "diff", "--stat", f"@{'{since}'}", "HEAD"],
+            capture_output=True, text=True, cwd=path, timeout=5,
+        )
+        file_count = len(stat_result.stdout.strip().split("\n")) if stat_result.stdout else 0
+
+        return commits, file_count
+    except Exception:
+        return [], 0
+
+
+def _get_notes(since: str) -> list[dict]:
+    """获取指定时间后的笔记"""
+    try:
+        from devmate_notekeeper import list_notes
+        result = list_notes(limit=50)
+        if result.success:
+            notes = []
+            for n in result.data["notes"]:
+                if n.get("updated_at", "").startswith(since[:10]):
+                    notes.append(n)
+            return notes
+    except Exception:
+        pass
+    return []
+
+
+def generate(period: str = "daily", template: str = "standup",
+             path: str = ".", title: str = "") -> CommandResult:
+    """生成报告"""
+    if template not in TEMPLATES:
+        types = ", ".join(TEMPLATES.keys())
+        return CommandResult(success=False, error=f"不支持的模板: {template}。可选: {types}")
+
+    if period == "daily":
+        since = "24 hours ago"
+        period_label = "日报"
+    elif period == "weekly":
+        since = "7 days ago"
+        period_label = "周报"
+    else:
+        since = period
+        period_label = period
+
+    commits, file_count = _git_log(since, path)
+    notes = _get_notes(since)
+
+    tmpl = TEMPLATES[template]
+    period_str = time.strftime("%Y-%m-%d")
+
+    # 渲染提交
+    commit_lines = []
+    for c in commits[:30]:
+        commit_lines.append(f"- {c['subject']} ({c['hash']})")
+    commits_str = "\n".join(commit_lines) if commit_lines else "(无提交)"
+
+    # 渲染笔记
+    note_lines = []
+    for n in notes:
+        note_lines.append(f"- {n['title']}")
+    notes_str = "\n".join(note_lines) if note_lines else "(无笔记)"
+
+    title = title or f"{period_label} - {period_str}"
+
+    # 填充模板
+    report = tmpl["header"].format(title=title, period=period_str)
+    report += tmpl["section_commits"].format(commits=commits_str)
+    report += tmpl["section_notes"].format(notes=notes_str)
+    if "section_blockers" in tmpl:
+        report += tmpl["section_blockers"].format(none="(无)")
+
+    # 保存
+    now = time.strftime("%Y%m%d_%H%M%S")
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    report_file = REPORTS_DIR / f"report_{now}.md"
+    report_file.write_text(report, encoding="utf-8")
+
+    return CommandResult(success=True, data={
+        "markdown": report,
+        "path": str(report_file),
+        "commit_count": len(commit_lines),
+        "period": period_label,
+        "template": template,
+    })
+
+
+def export_html(markdown_path: str) -> CommandResult:
+    """导出报告为 HTML"""
+    md_file = Path(markdown_path).expanduser()
+    if not md_file.exists():
+        return CommandResult(success=False, error=f"文件不存在: {markdown_path}")
+
+    content = md_file.read_text(encoding="utf-8")
+    html = f"""<!DOCTYPE html>
+<html><head><meta charset="utf-8">
+<title>DevMate 报告</title>
+<style>
+body {{ max-width: 800px; margin: auto; padding: 2em;
+       font-family: -apple-system, sans-serif; line-height: 1.6; }}
+h1 {{ color: #333; border-bottom: 2px solid #eee; }}
+h2 {{ color: #555; }}
+pre {{ background: #f5f5f5; padding: 1em; border-radius: 4px; }}
+</style></head><body>
+<pre>{content}</pre>
+</body></html>"""
+
+    html_file = md_file.with_suffix(".html")
+    html_file.write_text(html, encoding="utf-8")
+    return CommandResult(success=True, data={"path": str(html_file)})