[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-parcadei--llm-tldr":3,"tool-parcadei--llm-tldr":64},[4,17,27,35,43,56],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":16},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,3,"2026-04-05T11:01:52",[13,14,15],"开发框架","图像","Agent","ready",{"id":18,"name":19,"github_repo":20,"description_zh":21,"stars":22,"difficulty_score":23,"last_commit_at":24,"category_tags":25,"status":16},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",138956,2,"2026-04-05T11:33:21",[13,15,26],"语言模型",{"id":28,"name":29,"github_repo":30,"description_zh":31,"stars":32,"difficulty_score":23,"last_commit_at":33,"category_tags":34,"status":16},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",107662,"2026-04-03T11:11:01",[13,14,15],{"id":36,"name":37,"github_repo":38,"description_zh":39,"stars":40,"difficulty_score":23,"last_commit_at":41,"category_tags":42,"status":16},3704,"NextChat","ChatGPTNextWeb\u002FNextChat","NextChat 是一款轻量且极速的 AI 助手，旨在为用户提供流畅、跨平台的大模型交互体验。它完美解决了用户在多设备间切换时难以保持对话连续性，以及面对众多 AI 模型不知如何统一管理的痛点。无论是日常办公、学习辅助还是创意激发，NextChat 都能让用户随时随地通过网页、iOS、Android、Windows、MacOS 或 Linux 端无缝接入智能服务。\n\n这款工具非常适合普通用户、学生、职场人士以及需要私有化部署的企业团队使用。对于开发者而言，它也提供了便捷的自托管方案，支持一键部署到 Vercel 或 Zeabur 等平台。\n\nNextChat 的核心亮点在于其广泛的模型兼容性，原生支持 Claude、DeepSeek、GPT-4 及 Gemini Pro 等主流大模型，让用户在一个界面即可自由切换不同 AI 能力。此外，它还率先支持 MCP（Model Context Protocol）协议，增强了上下文处理能力。针对企业用户，NextChat 提供专业版解决方案，具备品牌定制、细粒度权限控制、内部知识库整合及安全审计等功能，满足公司对数据隐私和个性化管理的高标准要求。",87618,"2026-04-05T07:20:52",[13,26],{"id":44,"name":45,"github_repo":46,"description_zh":47,"stars":48,"difficulty_score":23,"last_commit_at":49,"category_tags":50,"status":16},2268,"ML-For-Beginners","microsoft\u002FML-For-Beginners","ML-For-Beginners 是由微软推出的一套系统化机器学习入门课程，旨在帮助零基础用户轻松掌握经典机器学习知识。这套课程将学习路径规划为 12 周，包含 26 节精炼课程和 52 道配套测验，内容涵盖从基础概念到实际应用的完整流程，有效解决了初学者面对庞大知识体系时无从下手、缺乏结构化指导的痛点。\n\n无论是希望转型的开发者、需要补充算法背景的研究人员，还是对人工智能充满好奇的普通爱好者，都能从中受益。课程不仅提供了清晰的理论讲解，还强调动手实践，让用户在循序渐进中建立扎实的技能基础。其独特的亮点在于强大的多语言支持，通过自动化机制提供了包括简体中文在内的 50 多种语言版本，极大地降低了全球不同背景用户的学习门槛。此外，项目采用开源协作模式，社区活跃且内容持续更新，确保学习者能获取前沿且准确的技术资讯。如果你正寻找一条清晰、友好且专业的机器学习入门之路，ML-For-Beginners 将是理想的起点。",84991,"2026-04-05T10:45:23",[14,51,52,53,15,54,26,13,55],"数据工具","视频","插件","其他","音频",{"id":57,"name":58,"github_repo":59,"description_zh":60,"stars":61,"difficulty_score":10,"last_commit_at":62,"category_tags":63,"status":16},3128,"ragflow","infiniflow\u002Fragflow","RAGFlow 是一款领先的开源检索增强生成（RAG）引擎，旨在为大语言模型构建更精准、可靠的上下文层。它巧妙地将前沿的 RAG 技术与智能体（Agent）能力相结合，不仅支持从各类文档中高效提取知识，还能让模型基于这些知识进行逻辑推理和任务执行。\n\n在大模型应用中，幻觉问题和知识滞后是常见痛点。RAGFlow 通过深度解析复杂文档结构（如表格、图表及混合排版），显著提升了信息检索的准确度，从而有效减少模型“胡编乱造”的现象，确保回答既有据可依又具备时效性。其内置的智能体机制更进一步，使系统不仅能回答问题，还能自主规划步骤解决复杂问题。\n\n这款工具特别适合开发者、企业技术团队以及 AI 研究人员使用。无论是希望快速搭建私有知识库问答系统，还是致力于探索大模型在垂直领域落地的创新者，都能从中受益。RAGFlow 提供了可视化的工作流编排界面和灵活的 API 接口，既降低了非算法背景用户的上手门槛，也满足了专业开发者对系统深度定制的需求。作为基于 Apache 2.0 协议开源的项目，它正成为连接通用大模型与行业专有知识之间的重要桥梁。",77062,"2026-04-04T04:44:48",[15,14,13,26,54],{"id":65,"github_repo":66,"name":67,"description_en":68,"description_zh":69,"ai_summary_zh":69,"readme_en":70,"readme_zh":71,"quickstart_zh":72,"use_case_zh":73,"hero_image_url":74,"owner_login":75,"owner_name":75,"owner_avatar_url":76,"owner_bio":77,"owner_company":77,"owner_location":77,"owner_email":77,"owner_twitter":77,"owner_website":77,"owner_url":78,"languages":79,"stars":84,"forks":85,"last_commit_at":86,"license":87,"difficulty_score":88,"env_os":89,"env_gpu":90,"env_ram":91,"env_deps":92,"category_tags":100,"github_topics":77,"view_count":23,"oss_zip_url":77,"oss_zip_packed_at":77,"status":16,"created_at":101,"updated_at":102,"faqs":103,"releases":134},2182,"parcadei\u002Fllm-tldr","llm-tldr","95% token savings. 155x faster queries. 16 languages.  LLMs can't read your entire codebase. TLDR extracts structure, traces dependencies, and gives them exactly what they need.","llm-tldr 是一款专为 AI 智能体设计的代码分析工具，旨在让大语言模型（LLM）在理解大型代码库时，只获取最核心的信息。面对动辄数万行的项目代码，直接输入给 LLM 不仅容易超出上下文限制，还会因充斥大量无关细节导致模型“迷失”。llm-tldr 通过提取代码结构而非堆砌原始文本，能减少 95% 的 Token 消耗，并将查询速度提升 155 倍，同时支持 16 种编程语言。\n\n该工具特别适合需要利用 AI 辅助编程、重构或调试的开发者及研究人员。其核心技术亮点在于构建了五层深度分析架构：从基础的抽象语法树（AST）到调用图、控制流、数据流，直至程序依赖图。这种分层设计让用户可以根据任务需求（如浏览结构或追踪变量来源）灵活获取不同深度的信息。此外，llm-tldr 引入了语义搜索层，利用嵌入向量将代码的功能行为转化为可检索的索引。这意味着用户可以用自然语言描述功能（例如“验证 JWT 令牌”），即使代码中没有完全匹配的关键词，也能精准定位到相关函数。配合常驻内存的守护进程，它能实现毫秒级的快速响应，真正做到了“按需供给”，让 AI 高效读懂你的代码。","# TLDR: Code Analysis for AI Agents\n\n[![PyPI](https:\u002F\u002Fimg.shields.io\u002Fpypi\u002Fv\u002Fllm-tldr)](https:\u002F\u002Fpypi.org\u002Fproject\u002Fllm-tldr\u002F)\n[![Python](https:\u002F\u002Fimg.shields.io\u002Fpypi\u002Fpyversions\u002Fllm-tldr)](https:\u002F\u002Fpypi.org\u002Fproject\u002Fllm-tldr\u002F)\n[![License](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Flicense-AGPL--3.0-blue)](LICENSE)\n\n**Give LLMs exactly the code they need. Nothing more.**\n\n```bash\n# One-liner: Install, index, search\npip install llm-tldr && tldr warm . && tldr semantic \"what you're looking for\" .\n```\n\nYour codebase is 100K lines. Claude's context window is 200K tokens. Raw code won't fit—and even if it did, the LLM would drown in irrelevant details.\n\nTLDR extracts *structure* instead of dumping *text*. The result: **95% fewer tokens** while preserving everything needed to understand and edit code correctly.\n\n```bash\npip install llm-tldr\ntldr warm .                    # Index your project\ntldr context main --project .  # Get LLM-ready summary\n```\n\n---\n\n## How It Works\n\nTLDR builds 5 analysis layers, each answering different questions:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ Layer 5: Program Dependence  → \"What affects line 42?\"      │\n│ Layer 4: Data Flow           → \"Where does this value go?\"  │\n│ Layer 3: Control Flow        → \"How complex is this?\"       │\n│ Layer 2: Call Graph          → \"Who calls this function?\"   │\n│ Layer 1: AST                 → \"What functions exist?\"      │\n└─────────────────────────────────────────────────────────────┘\n```\n\n**Why layers?** Different tasks need different depth:\n- Browsing code? Layer 1 (structure) is enough\n- Refactoring? Layer 2 (call graph) shows what breaks\n- Debugging null? Layer 5 (slice) shows only relevant lines\n\nThe daemon keeps indexes in memory for **100ms queries** instead of 30-second CLI spawns.\n\n### Architecture\n\n```\n┌──────────────────────────────────────────────────────────────────┐\n│                         YOUR CODE                                │\n│  src\u002F*.py, lib\u002F*.ts, pkg\u002F*.go                                    │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │ tree-sitter\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                     5-LAYER ANALYSIS                             │\n│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐     │\n│  │   AST   │→│  Calls  │→│   CFG   │→│   DFG   │→│   PDG   │     │\n│  │   L1    │ │   L2    │ │   L3    │ │   L4    │ │   L5    │     │\n│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘     │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │ bge-large-en-v1.5\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                    SEMANTIC INDEX                                │\n│  1024-dim embeddings in FAISS  →  \"find JWT validation\"          │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                       DAEMON                                     │\n│  In-memory indexes  •  100ms queries  •  Auto-lifecycle          │\n└──────────────────────────────────────────────────────────────────┘\n```\n\n### The Semantic Layer: Search by Behavior\n\nThe real power comes from combining all 5 layers into **searchable embeddings**.\n\nEvery function gets indexed with:\n- Signature + docstring (L1)\n- What it calls + who calls it (L2)\n- Complexity metrics (L3)\n- Data flow patterns (L4)\n- Dependencies (L5)\n- First ~10 lines of actual code\n\nThis gets encoded into **1024-dimensional vectors** using `bge-large-en-v1.5`. The result: search by *what code does*, not just what it says.\n\n```bash\n# \"validate JWT\" finds verify_access_token() even without that exact text\ntldr semantic \"validate JWT tokens and check expiration\" .\n```\n\n**Why this works:** Traditional search finds `authentication` in variable names and comments. Semantic search understands that `verify_access_token()` *performs* JWT validation because the call graph and data flow reveal its purpose.\n\n### Setting Up Semantic Search\n\n```bash\n# Build the semantic index (one-time, ~2 min for typical project)\ntldr warm \u002Fpath\u002Fto\u002Fproject\n\n# Search by behavior\ntldr semantic \"database connection pooling\" .\n```\n\nEmbedding dependencies (`sentence-transformers`, `faiss-cpu`) are included with `pip install llm-tldr`. The index is cached in `.tldr\u002Fcache\u002Fsemantic.faiss`.\n\n### Keeping the Index Fresh\n\nThe daemon tracks dirty files and auto-rebuilds after 20 changes, but you need to notify it when files change:\n\n```bash\n# Notify daemon of a changed file\ntldr daemon notify src\u002Fauth.py --project .\n```\n\n**Integration options:**\n\n1. **Git hook** (post-commit):\n   ```bash\n   git diff --name-only HEAD~1 | xargs -I{} tldr daemon notify {} --project .\n   ```\n\n2. **Editor hook** (on save):\n   ```bash\n   tldr daemon notify \"$FILE\" --project .\n   ```\n\n3. **Manual rebuild** (when needed):\n   ```bash\n   tldr warm .  # Full rebuild\n   ```\n\nThe daemon auto-rebuilds semantic embeddings in the background once the dirty threshold (default: 20 files) is reached.\n\n---\n\n## The Workflow\n\n### Before Reading Code\n```bash\ntldr tree src\u002F                      # See file structure\ntldr structure src\u002F --lang python   # See functions\u002Fclasses\n```\n\n### Before Editing\n```bash\ntldr extract src\u002Fauth.py            # Full file analysis\ntldr context login --project .      # LLM-ready summary (95% savings)\n```\n\n### Before Refactoring\n```bash\ntldr impact login .                 # Who calls this? (reverse call graph)\ntldr change-impact                  # Which tests need to run?\n```\n\n### Debugging\n```bash\ntldr slice src\u002Fauth.py login 42     # What affects line 42?\ntldr dfg src\u002Fauth.py login          # Trace data flow\n```\n\n### Finding Code by Behavior\n```bash\ntldr semantic \"validate JWT tokens\" .   # Natural language search\n```\n\n---\n\n## Quick Setup\n\n### 1. Install\n\n```bash\npip install llm-tldr\n```\n\n### 2. Index Your Project\n\n```bash\ntldr warm \u002Fpath\u002Fto\u002Fproject\n```\n\nThis builds all analysis layers and starts the daemon. Takes 30-60 seconds for a typical project, then queries are instant.\n\n### 3. Start Using\n\n```bash\ntldr context main --project .   # Get context for a function\ntldr impact helper_func .       # See who calls it\ntldr semantic \"error handling\"  # Find by behavior\n```\n\n---\n\n## Real Example: Why This Matters\n\n**Scenario:** Debug why `user` is null on line 42.\n\n**Without TLDR:**\n1. Read the 150-line function\n2. Trace every variable manually\n3. Miss the bug because it's hidden in control flow\n\n**With TLDR:**\n```bash\ntldr slice src\u002Fauth.py login 42\n```\n\n**Output:** Only 6 lines that affect line 42:\n```python\n3:   user = db.get_user(username)\n7:   if user is None:\n12:      raise NotFound\n28:  token = create_token(user)  # ← BUG: skipped null check\n35:  session.token = token\n42:  return session\n```\n\nThe bug is obvious. Line 28 uses `user` without going through the null check path.\n\n---\n\n## Command Reference\n\n### Exploration\n| Command | What It Does |\n|---------|--------------|\n| `tldr tree [path]` | File tree |\n| `tldr structure [path] --lang \u003Clang>` | Functions, classes, methods |\n| `tldr search \u003Cpattern> [path]` | Text pattern search |\n| `tldr extract \u003Cfile>` | Full file analysis |\n\n### Analysis\n| Command | What It Does |\n|---------|--------------|\n| `tldr context \u003Cfunc> --project \u003Cpath>` | LLM-ready summary (95% savings) |\n| `tldr cfg \u003Cfile> \u003Cfunction>` | Control flow graph |\n| `tldr dfg \u003Cfile> \u003Cfunction>` | Data flow graph |\n| `tldr slice \u003Cfile> \u003Cfunc> \u003Cline>` | Program slice |\n\n### Cross-File\n| Command | What It Does |\n|---------|--------------|\n| `tldr calls [path]` | Build call graph |\n| `tldr impact \u003Cfunc> [path]` | Find all callers (reverse call graph) |\n| `tldr dead [path]` | Find unreachable code |\n| `tldr arch [path]` | Detect architecture layers |\n| `tldr imports \u003Cfile>` | Parse imports |\n| `tldr importers \u003Cmodule> [path]` | Find files that import a module |\n\n### Semantic\n| Command | What It Does |\n|---------|--------------|\n| `tldr warm \u003Cpath>` | Build all indexes (including embeddings) |\n| `tldr semantic \u003Cquery> [path]` | Natural language code search |\n\n### Diagnostics\n| Command | What It Does |\n|---------|--------------|\n| `tldr diagnostics \u003Cfile>` | Type check + lint |\n| `tldr change-impact [files]` | Find tests affected by changes |\n| `tldr doctor` | Check\u002Finstall diagnostic tools |\n\n### Daemon\n| Command | What It Does |\n|---------|--------------|\n| `tldr daemon start` | Start background daemon |\n| `tldr daemon stop` | Stop daemon |\n| `tldr daemon status` | Check status |\n\n---\n\n## Supported Languages\n\nPython, TypeScript, JavaScript, Go, Rust, Java, C, C++, Ruby, PHP, C#, Kotlin, Scala, Swift, Lua, Elixir\n\nLanguage is auto-detected or specify with `--lang`.\n\n---\n\n## MCP Integration\n\nFor AI tools (Claude Desktop, Claude Code):\n\n**Claude Desktop** - Add to `~\u002FLibrary\u002FApplication Support\u002FClaude\u002Fclaude_desktop_config.json`:\n```json\n{\n  \"mcpServers\": {\n    \"tldr\": {\n      \"command\": \"tldr-mcp\",\n      \"args\": [\"--project\", \"\u002Fpath\u002Fto\u002Fyour\u002Fproject\"]\n    }\n  }\n}\n```\n\n**Claude Code** - Add to `.claude\u002Fsettings.json`:\n```json\n{\n  \"mcpServers\": {\n    \"tldr\": {\n      \"command\": \"tldr-mcp\",\n      \"args\": [\"--project\", \".\"]\n    }\n  }\n}\n```\n\n---\n\n## Configuration\n\n### `.tldrignore` - Exclude Files\n\nTLDR respects `.tldrignore` (gitignore syntax) for all commands including `tree`, `structure`, `search`, `calls`, and semantic indexing:\n\n```bash\n# Auto-create with sensible defaults\ntldr warm .  # Creates .tldrignore if missing\n```\n\n**Default exclusions:**\n- `node_modules\u002F`, `.venv\u002F`, `__pycache__\u002F`\n- `dist\u002F`, `build\u002F`, `*.egg-info\u002F`\n- Binary files (`*.so`, `*.dll`, `*.whl`)\n- Security files (`.env`, `*.pem`, `*.key`)\n\n**Customize** by editing `.tldrignore`:\n```gitignore\n# Add your patterns\nlarge_test_fixtures\u002F\nvendor\u002F\ndata\u002F*.csv\n```\n\n**CLI Flags:**\n```bash\n# Add patterns from command line (can be repeated)\ntldr --ignore \"packages\u002Fold\u002F\" --ignore \"*.generated.ts\" tree .\n\n# Bypass all ignore patterns\ntldr --no-ignore tree .\n```\n\n### Settings - Daemon Behavior\n\nCreate `.tldr\u002Fconfig.json` for daemon settings:\n\n```json\n{\n  \"semantic\": {\n    \"enabled\": true,\n    \"auto_reindex_threshold\": 20\n  }\n}\n```\n\n| Setting | Default | Description |\n|---------|---------|-------------|\n| `enabled` | `true` | Enable semantic search |\n| `auto_reindex_threshold` | `20` | Files changed before auto-rebuild |\n\n### Monorepo Support\n\nFor monorepos, create `.claude\u002Fworkspace.json` to scope indexing:\n\n```json\n{\n  \"active_packages\": [\"packages\u002Fcore\", \"packages\u002Fapi\"],\n  \"exclude_patterns\": [\"**\u002Ffixtures\u002F**\"]\n}\n```\n\n---\n\n## Performance\n\n| Metric | Raw Code | TLDR | Improvement |\n|--------|----------|------|-------------|\n| Tokens for function context | 21,000 | 175 | **99% savings** |\n| Tokens for codebase overview | 104,000 | 12,000 | **89% savings** |\n| Query latency (daemon) | 30s | 100ms | **300x faster** |\n\n---\n\n## Deep Dive\n\nFor the full architecture explanation, benchmarks, and advanced workflows:\n\n**[Full Documentation](.\u002Fdocs\u002FTLDR.md)**\n\n---\n\n## License\n\nAGPL-3.0 - See LICENSE file.\n","# TLDR：面向 AI 代理的代码分析\n\n[![PyPI](https:\u002F\u002Fimg.shields.io\u002Fpypi\u002Fv\u002Fllm-tldr)](https:\u002F\u002Fpypi.org\u002Fproject\u002Fllm-tldr\u002F)\n[![Python](https:\u002F\u002Fimg.shields.io\u002Fpypi\u002Fpyversions\u002Fllm-tldr)](https:\u002F\u002Fpypi.org\u002Fproject\u002Fllm-tldr\u002F)\n[![License](https:\u002F\u002Fimg.shields.io\u002Fbadge\u002Flicense-AGPL--3.0-blue)](LICENSE)\n\n**为大语言模型提供它们真正需要的代码，不多也不少。**\n\n```bash\n# 一行命令：安装、索引、搜索\npip install llm-tldr && tldr warm . && tldr semantic \"你想要查找的内容\" .\n```\n\n你的代码库有 10 万行。Claude 的上下文窗口是 20 万 token。原始代码根本放不下——即使放得下，大语言模型也会被无关细节淹没。\n\nTLDR 不会直接输出文本，而是提取代码的**结构**。结果是：在保留理解与正确编辑代码所需信息的同时，token 数量减少了 **95%**。\n\n```bash\npip install llm-tldr\ntldr warm .                    # 索引你的项目\ntldr context main --project .  # 获取适合大语言模型的摘要\n```\n\n---\n\n## 工作原理\n\nTLDR 构建了 5 层分析，每一层回答不同的问题：\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│ 第 5 层：程序依赖关系 → “第 42 行受哪些内容影响？”      │\n│ 第 4 层：数据流           → “这个值会流向哪里？”          │\n│ 第 3 层：控制流        → “这段代码有多复杂？”             │\n│ 第 2 层：调用图          → “哪些地方会调用这个函数？”     │\n│ 第 1 层：抽象语法树     → “有哪些函数存在？”              │\n└─────────────────────────────────────────────────────────────┘\n```\n\n**为什么采用多层设计？** 不同的任务需要不同深度的信息：\n- 浏览代码？只需第 1 层（结构）。\n- 重构？第 2 层（调用图）能显示哪些部分会受到影响。\n- 调试空指针问题？第 5 层（切片）只展示相关代码行。\n\n守护进程将索引常驻内存，实现**100 毫秒级查询**，而无需每次通过 CLI 启动耗时 30 秒的进程。\n\n### 架构\n\n```\n┌──────────────────────────────────────────────────────────────────┐\n│                         你的代码                                │\n│  src\u002F*.py, lib\u002F*.ts, pkg\u002F*.go                                    │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │ tree-sitter\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                     5 层分析                             │\n│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐     │\n│  │   AST   │→│  Calls  │→│   CFG   │→│   DFG   │→│   PDG   │     │\n│  │   L1    │ │   L2    │ │   L3    │ │   L4    │ │   L5    │     │\n│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘     │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │ bge-large-en-v1.5\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                    语义索引                                │\n│  1024 维嵌入存储于 FAISS 中 → “查找 JWT 验证”                  │\n└───────────────────────────┬──────────────────────────────────────┘\n                            │\n                            ▼\n┌──────────────────────────────────────────────────────────────────┐\n│                       守护进程                                     │\n│  内存中索引  •  100 毫秒查询  •  自动生命周期管理          │\n└──────────────────────────────────────────────────────────────────┘\n```\n\n### 语义层：按行为搜索\n\n真正的强大之处在于将所有 5 层结合成可搜索的嵌入。\n\n每个函数都会被索引以下内容：\n- 函数签名 + 文档字符串（L1）\n- 它调用了什么以及谁调用了它（L2）\n- 复杂度指标（L3）\n- 数据流模式（L4）\n- 依赖关系（L5）\n- 实际代码的前 10 行左右\n\n这些信息会被使用 `bge-large-en-v1.5` 编码为 **1024 维向量**。结果是：可以根据代码的**行为**进行搜索，而不仅仅是它的文字描述。\n\n```bash\n# “验证 JWT” 会找到 verify_access_token()，即使代码中没有完全匹配的文字\ntldr semantic \"验证 JWT 令牌并检查过期时间\" .\n```\n\n**为何有效？** 传统搜索只会根据变量名和注释找到“authentication”。而语义搜索则能理解 `verify_access_token()` *确实* 执行了 JWT 验证，因为调用图和数据流揭示了它的实际用途。\n\n### 设置语义搜索\n\n```bash\n# 构建语义索引（一次性操作，典型项目约需 2 分钟）\ntldr warm \u002Fpath\u002Fto\u002Fproject\n\n# 按行为搜索\ntldr semantic \"数据库连接池\" .\n```\n\n嵌入所需的依赖项（`sentence-transformers`、`faiss-cpu`）已包含在 `pip install llm-tldr` 中。索引会缓存在 `.tldr\u002Fcache\u002Fsemantic.faiss` 文件中。\n\n### 保持索引最新\n\n守护进程会跟踪脏文件，并在发生 20 次更改后自动重建索引，但你需要在文件变更时通知它：\n\n```bash\n# 通知守护进程文件已更改\ntldr daemon notify src\u002Fauth.py --project .\n```\n\n**集成方式：**\n\n1. **Git 钩子**（提交后）：\n   ```bash\n   git diff --name-only HEAD~1 | xargs -I{} tldr daemon notify {} --project .\n   ```\n\n2. **编辑器钩子**（保存时）：\n   ```bash\n   tldr daemon notify \"$FILE\" --project .\n   ```\n\n3. **手动重建**（必要时）：\n   ```bash\n   tldr warm .  # 完整重建\n   ```\n\n守护进程会在脏文件数量达到默认阈值（20 个）后，在后台自动重建语义嵌入。\n\n---\n\n## 工作流程\n\n### 阅读代码之前\n```bash\ntldr tree src\u002F                      # 查看文件结构\ntldr structure src\u002F --lang python   # 查看函数和类\n```\n\n### 编辑代码之前\n```bash\ntldr extract src\u002Fauth.py            # 完整文件分析\ntldr context login --project .      # 适合大语言模型的摘要（节省 95% token）\n```\n\n### 重构之前\n```bash\ntldr impact login .                 # 哪些地方会调用此函数？（反向调用图）\ntldr change-impact                  # 需要运行哪些测试？\n```\n\n### 调试\n```bash\ntldr slice src\u002Fauth.py login 42     # 第 42 行受哪些内容影响？\ntldr dfg src\u002Fauth.py login          # 追踪数据流\n```\n\n### 按行为查找代码\n```bash\ntldr semantic \"验证 JWT 令牌\" .   # 自然语言搜索\n```\n\n---\n\n## 快速设置\n\n### 1. 安装\n\n```bash\npip install llm-tldr\n```\n\n### 2. 索引你的项目\n\n```bash\ntldr warm \u002Fpath\u002Fto\u002Fproject\n```\n\n这会构建所有分析层并启动守护进程。对于典型项目，耗时 30–60 秒，之后查询即可立即响应。\n\n### 3. 开始使用\n\n```bash\ntldr context main --project .   # 获取某个函数的上下文\ntldr impact helper_func .       # 查看谁调用了它\ntldr semantic \"错误处理\"  # 按行为查找\n```\n\n---\n\n## 真实案例：为什么这很重要\n\n**场景：** 调试为什么第42行的`user`是空值。\n\n**不使用TLDR：**\n1. 阅读这个150行的函数\n2. 手动跟踪每个变量\n3. 因为bug隐藏在控制流中而错过它\n\n**使用TLDR：**\n```bash\ntldr slice src\u002Fauth.py login 42\n```\n\n**输出：** 只有6行代码影响到第42行：\n```python\n3:   user = db.get_user(username)\n7:   if user is None:\n12:      raise NotFound\n28:  token = create_token(user)  # ← BUG：跳过了空值检查\n35:  session.token = token\n42:  return session\n```\n\nbug很明显。第28行直接使用了`user`，却没有经过空值检查的逻辑分支。\n\n---\n\n## 命令参考\n\n### 探索\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr tree [path]` | 文件树 |\n| `tldr structure [path] --lang \u003Clang>` | 函数、类、方法 |\n| `tldr search \u003Cpattern> [path]` | 文本模式搜索 |\n| `tldr extract \u003Cfile>` | 整个文件分析 |\n\n### 分析\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr context \u003Cfunc> --project \u003Cpath>` | LLM友好的摘要（节省95%） |\n| `tldr cfg \u003Cfile> \u003Cfunction>` | 控制流图 |\n| `tldr dfg \u003Cfile> \u003Cfunction>` | 数据流图 |\n| `tldr slice \u003Cfile> \u003Cfunc> \u003Cline>` | 程序切片 |\n\n### 跨文件\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr calls [path]` | 构建调用图 |\n| `tldr impact \u003Cfunc> [path]` | 查找所有调用者（反向调用图） |\n| `tldr dead [path]` | 查找不可达代码 |\n| `tldr arch [path]` | 检测架构层 |\n| `tldr imports \u003Cfile>` | 解析导入 |\n| `tldr importers \u003Cmodule> [path]` | 查找导入某个模块的文件 |\n\n### 语义\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr warm \u003Cpath>` | 构建所有索引（包括嵌入） |\n| `tldr semantic \u003Cquery> [path]` | 自然语言代码搜索 |\n\n### 诊断\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr diagnostics \u003Cfile>` | 类型检查 + 静态分析 |\n| `tldr change-impact [files]` | 查找受更改影响的测试 |\n| `tldr doctor` | 检查\u002F安装诊断工具 |\n\n### 守护进程\n| 命令 | 功能 |\n|---------|--------------|\n| `tldr daemon start` | 启动后台守护进程 |\n| `tldr daemon stop` | 停止守护进程 |\n| `tldr daemon status` | 检查状态 |\n\n---\n\n## 支持的语言\n\nPython、TypeScript、JavaScript、Go、Rust、Java、C、C++、Ruby、PHP、C#、Kotlin、Scala、Swift、Lua、Elixir\n\n语言会自动检测，也可以通过`--lang`指定。\n\n---\n\n## MCP集成\n\n适用于AI工具（Claude Desktop、Claude Code）：\n\n**Claude Desktop** - 添加到`~\u002FLibrary\u002FApplication Support\u002FClaude\u002Fclaude_desktop_config.json`：\n```json\n{\n  \"mcpServers\": {\n    \"tldr\": {\n      \"command\": \"tldr-mcp\",\n      \"args\": [\"--project\", \"\u002Fpath\u002Fto\u002Fyour\u002Fproject\"]\n    }\n  }\n}\n```\n\n**Claude Code** - 添加到`.claude\u002Fsettings.json`：\n```json\n{\n  \"mcpServers\": {\n    \"tldr\": {\n      \"command\": \"tldr-mcp\",\n      \"args\": [\"--project\", \".\"]\n    }\n  }\n}\n```\n\n---\n\n## 配置\n\n### `.tldrignore` - 排除文件\n\nTLDR会尊重`.tldrignore`（gitignore语法），用于所有命令，包括`tree`、`structure`、`search`、`calls`以及语义索引：\n\n```bash\n# 自动创建并带有合理默认值\ntldr warm .  # 如果不存在，则创建.tldrignore\n```\n\n**默认排除：**\n- `node_modules\u002F`、`.venv\u002F`、`__pycache__\u002F`\n- `dist\u002F`、`build\u002F`、`*.egg-info\u002F`\n- 二进制文件（`*.so`、`*.dll`、`*.whl`）\n- 安全文件（`.env`、`*.pem`、`*.key`）\n\n**自定义**可通过编辑`.tldrignore`实现：\n```gitignore\n# 添加你的模式\nlarge_test_fixtures\u002F\nvendor\u002F\ndata\u002F*.csv\n```\n\n**CLI标志：**\n```bash\n# 从命令行添加模式（可重复）\ntldr --ignore \"packages\u002Fold\u002F\" --ignore \"*.generated.ts\" tree .\n\n# 忽略所有忽略规则\ntldr --no-ignore tree .\n```\n\n### 设置 - 守护进程行为\n\n创建`.tldr\u002Fconfig.json`以配置守护进程设置：\n\n```json\n{\n  \"semantic\": {\n    \"enabled\": true,\n    \"auto_reindex_threshold\": 20\n  }\n}\n```\n\n| 设置 | 默认值 | 描述 |\n|---------|---------|-------------|\n| `enabled` | `true` | 启用语义搜索 |\n| `auto_reindex_threshold` | `20` | 更改文件数达到阈值后自动重建索引 |\n\n### 单体仓库支持\n\n对于单体仓库，创建`.claude\u002Fworkspace.json`以限定索引范围：\n\n```json\n{\n  \"active_packages\": [\"packages\u002Fcore\", \"packages\u002Fapi\"],\n  \"exclude_patterns\": [\"**\u002Ffixtures\u002F**\"]\n}\n```\n\n---\n\n## 性能\n\n| 指标 | 原始代码 | TLDR | 提升 |\n|--------|----------|------|-------------|\n| 函数上下文的token数 | 21,000 | 175 | **99%节省** |\n| 代码库概览的token数 | 104,000 | 12,000 | **89%节省** |\n| 查询延迟（守护进程） | 30秒 | 100毫秒 | **快300倍** |\n\n---\n\n## 深度解析\n\n如需完整的架构说明、基准测试及高级工作流程：\n\n**[完整文档](.\u002Fdocs\u002FTLDR.md)**\n\n---\n\n## 许可证\n\nAGPL-3.0 - 详见LICENSE文件。","# llm-tldr 快速上手指南\n\n**llm-tldr** 是一款专为 AI Agent 设计的代码分析工具。它能提取代码的深层结构（如调用图、数据流），而非简单堆砌文本，从而在保留关键上下文的同时，将 Token 消耗降低 95%，让大模型更精准地理解你的代码库。\n\n## 环境准备\n\n*   **操作系统**：Linux, macOS, Windows\n*   **Python 版本**：3.8 及以上\n*   **前置依赖**：无需额外安装系统级依赖，工具会自动处理 `tree-sitter` 解析器及语义嵌入模型（`sentence-transformers`, `faiss-cpu`）。\n\n> **国内加速建议**：\n> 建议配置国内 PyPI 镜像源以提升安装速度：\n> ```bash\n> pip install -i https:\u002F\u002Fpypi.tuna.tsinghua.edu.cn\u002Fsimple llm-tldr\n> ```\n\n## 安装步骤\n\n使用 pip 一键安装：\n\n```bash\npip install llm-tldr\n```\n\n## 基本使用\n\n### 1. 初始化索引 (Warm Up)\n首次使用前，需对项目建立索引。这会构建 5 层分析结构并启动后台守护进程（Daemon），实现毫秒级查询。\n\n```bash\n# 对当前目录项目进行索引（典型项目耗时约 30-60 秒）\ntldr warm .\n```\n\n### 2. 获取 LLM 友好的代码摘要\n不再需要粘贴整个文件。使用 `context` 命令获取经过压缩的结构化摘要，直接喂给大模型。\n\n```bash\n# 获取 main 函数的精简上下文（节省约 95% Token）\ntldr context main --project .\n```\n\n### 3. 语义搜索 (按行为查找代码)\n通过自然语言描述代码功能进行搜索，即使函数名或注释中不包含关键词也能找到。\n\n```bash\n# 查找“验证 JWT 令牌”相关的代码逻辑\ntldr semantic \"validate JWT tokens\" .\n```\n\n### 4. 其他常用场景\n\n*   **查看项目结构**：\n    ```bash\n    tldr tree src\u002F\n    ```\n*   **分析函数调用影响**（重构前必用）：\n    ```bash\n    # 查看谁调用了 login 函数\n    tldr impact login .\n    ```\n*   **调试定位**（程序切片）：\n    ```bash\n    # 找出影响 src\u002Fauth.py 中 login 函数第 42 行的所有相关代码行\n    tldr slice src\u002Fauth.py login 42\n    ```\n\n### 5. 保持索引更新\n当文件发生修改时，通知后台守护进程更新索引（也可配置 Git Hook 自动执行）：\n\n```bash\ntldr daemon notify src\u002Fauth.py --project .\n```","某后端工程师需要在拥有 10 万行代码的遗留微服务项目中，快速定位并修复一个涉及 JWT 令牌验证逻辑的安全漏洞。\n\n### 没有 llm-tldr 时\n- **上下文溢出**：试图将整个模块代码喂给大模型时，远超 Token 限制，导致关键逻辑被截断或被迫手动删减代码。\n- **大海捞针**：传统文本搜索只能匹配关键字，无法找到名为 `verify_access_token` 但注释未提及\"JWT\"的核心函数，遗漏关键调用链。\n- **盲目修改风险**：不清楚该函数被哪些上游服务调用，重构时极易引发未知的连锁崩溃，需人工逐层追踪依赖。\n- **响应迟缓**：每次询问代码结构都需重新解析文件，大模型在无关的样板代码中“迷路”，生成建议耗时且不准确。\n\n### 使用 llm-tldr 后\n- **精准投喂**：llm-tldr 自动提取代码结构而非全文，节省 95% 的 Token，让大模型在有限的上下文窗口内完整掌握核心逻辑。\n- **语义直达**：通过语义搜索\"validate JWT tokens\"，直接定位到 `verify_access_token` 函数，即使代码中无完全匹配的文本也能精准命中。\n- **依赖可视**：利用第 5 层程序依赖分析，瞬间生成影响范围图谱，明确展示谁调用了该函数，确保修复方案安全无副作用。\n- **毫秒响应**：后台守护进程将索引驻留内存，查询速度从数十秒缩短至 100 毫秒，让开发者能像对话一样实时探索代码库。\n\nllm-tldr 通过将庞大的代码库转化为结构化、可语义搜索的精简摘要，让大模型真正具备了理解复杂工程全貌的能力。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fparcadei_llm-tldr_348ccf48.png","parcadei","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fparcadei_6f2ca57f.png",null,"https:\u002F\u002Fgithub.com\u002Fparcadei",[80],{"name":81,"color":82,"percentage":83},"Python","#3572A5",100,1084,108,"2026-04-04T20:47:40","AGPL-3.0",1,"未说明 (基于 Python 和 pip 安装，通常支持 Linux, macOS, Windows)","非必需。语义搜索功能使用 CPU 版本的 FAISS (faiss-cpu) 和 sentence-transformers，README 中未提及需要 GPU 或 CUDA。","未说明 (守护进程将索引保留在内存中以实现快速查询，具体需求取决于项目代码库的大小)",{"notes":93,"python":94,"dependencies":95},"该工具通过构建 5 层代码分析（AST、调用图、控制流、数据流、程序依赖）来压缩代码上下文。首次运行 'tldr warm' 命令会为项目建立索引并启动后台守护进程，典型项目耗时 30-60 秒。语义搜索功能会使用 bge-large-en-v1.5 模型生成嵌入向量，相关依赖在安装时自动包含。支持多种编程语言（Python, TS, Go, Rust 等），并通过 .tldrignore 文件排除无关目录。","3.8+ (根据 PyPI 徽章推断，具体版本需参考 pypi.org\u002Fproject\u002Fllm-tldr\u002F)",[96,97,98,99],"tree-sitter","sentence-transformers","faiss-cpu","bge-large-en-v1.5 (模型)",[26,13,15,53],"2026-03-27T02:49:30.150509","2026-04-06T07:13:58.945655",[104,109,114,119,124,129],{"id":105,"question_zh":106,"answer_zh":107,"source_url":108},10061,"为什么 TypeScript 文件的 cfg\u002Fdfg\u002Fslice 命令返回空结果？","根本原因是依赖项中缺少 `tree-sitter-javascript`。在 `cfg_extractor.py` 中，导入块同时导入了 `tree_sitter_typescript` 和 `tree_sitter_javascript`，如果其中任何一个导入失败，`TREE_SITTER_AVAILABLE` 将保持为 `False`，导致所有 TypeScript CFG 分析返回空值。\n\n解决方案：确保安装了 `tree-sitter-javascript>=0.23.0`。该问题已在 v1.2.7 版本（commit 884bfaf）中通过将其添加到 `pyproject.toml` 依赖项中修复。请尝试升级工具版本或手动安装缺失的依赖。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F23",{"id":110,"question_zh":111,"answer_zh":112,"source_url":113},10062,"如何添加对 Lua 或 Luau (Roblox) 文件的支持？","Lua 和 Luau 支持现已加入。用户只需在 cc-v3 中运行更新脚本即可启用这些语言支持。\n\n命令示例：运行项目提供的更新脚本（update script）。\n如果使用后遇到任何问题，可以提交新的 Issue 反馈。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F16",{"id":115,"question_zh":116,"answer_zh":117,"source_url":118},10063,"使用 pip 安装 llm-tldr 时出现断言错误（assertion error）怎么办？","这通常是因为 pip、setuptools 或 wheel 版本过旧导致的。解决方法是升级这些构建工具。\n\n请执行以下命令：\n```bash\npython3 -m pip install --upgrade pip setuptools wheel\n```\n升级完成后（例如 pip 升级到 25.3+），再次尝试运行 `pip install llm-tldr` 即可成功安装。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F29",{"id":120,"question_zh":121,"answer_zh":122,"source_url":123},10064,"运行 `tldr warm` 命令后为什么没有自动生成 .tldrignore 文件？","这是一个已知问题，根本原因是 `warm` 命令的处理程序中没有调用 `ensure_tldrignore()` 函数（该函数原本仅用于 `semantic index`）。\n\n该问题已在 v1.2.7 版本（commit 171ada1）中修复。修复后，运行 `tldr warm .` 将会自动创建包含合理默认值（如忽略 node_modules\u002F, .venv\u002F 等）的 `.tldrignore` 文件。请升级至最新版本以解决此问题。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F22",{"id":125,"question_zh":126,"answer_zh":127,"source_url":128},10065,"项目的许可证到底是 AGPL-3.0 还是 Apache-2.0？","项目实际采用的许可证是 **AGPL-3.0**。此前 README 文档中错误地提及了 Apache 2.0，造成了不一致。维护者已根据 GitHub 仓库设置和 LICENSE 文件，将 README 中的许可证说明更新为 AGPL-3.0，请以仓库根目录下的 LICENSE 文件为准。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F34",{"id":130,"question_zh":131,"answer_zh":132,"source_url":133},10066,"`tldr semantic index` 是否支持 PHP 语言参数？","早期版本可能存在不支持 `--lang=php` 参数或忽略 `.tldrignore` 文件的问题。该问题已通过社区提交的 PR (#11) 合并修复。\n\n现在您可以正常使用 `tldr semantic index . --lang=php` 来构建索引，且工具会正确尊重 `.tldrignore` 配置（例如跳过 \u002Fvendor 目录）。请确保您使用的是修复后的最新版本。","https:\u002F\u002Fgithub.com\u002Fparcadei\u002Fllm-tldr\u002Fissues\u002F10",[]]