deepdoc 3.0.0__tar.gz → 3.3.0__tar.gz

{deepdoc-3.0.0 → deepdoc-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdoc
-Version: 3.0.0
+Version: 3.3.0
 Summary: Auto-generate beautiful docs from any codebase
 Author: Pranav Kumar
 License: MIT
@@ -35,6 +35,11 @@ Requires-Dist: fastapi>=0.115; extra == "chatbot"
 Requires-Dist: uvicorn>=0.30; extra == "chatbot"
 Requires-Dist: httpx>=0.27; extra == "chatbot"
 Requires-Dist: fastembed>=0.3.0; extra == "chatbot"
+Provides-Extra: site
+Requires-Dist: mkdocs>=1.6; extra == "site"
+Requires-Dist: mkdocs-material>=9.5; extra == "site"
+Requires-Dist: pymdown-extensions>=10.0; extra == "site"
+Requires-Dist: mkdocs-swagger-ui-tag>=0.6; extra == "site"
 Dynamic: license-file
 
 # DeepDoc
@@ -129,14 +134,13 @@ pip install click litellm gitpython rich pyyaml jinja2
 pip install -e . --no-deps
 ```
 
-To preview or deploy the generated site you also need **MkDocs Material** (pure Python — no Node.js):
+To preview or deploy the generated site you also need **MkDocs Material** (pure Python — no Node.js). Install the `site` extra:
 
 ```bash
-pip install mkdocs-material
-pip install mkdocs-swagger-ui-tag   # only when your repo has an OpenAPI/Swagger spec
+pip install 'deepdoc[site]'   # mkdocs-material + pymdown-extensions + mkdocs-swagger-ui-tag
 ```
 
-`deepdoc serve` / `deepdoc deploy` will tell you the exact `pip install` command if MkDocs is missing.
+`deepdoc serve` / `deepdoc deploy` will tell you to run `pip install 'deepdoc[site]'` if MkDocs is missing.
 
 ### Verify installation
 

{deepdoc-3.0.0 → deepdoc-3.3.0}/README.md

@@ -90,14 +90,13 @@ pip install click litellm gitpython rich pyyaml jinja2
 pip install -e . --no-deps
 ```
 
-To preview or deploy the generated site you also need **MkDocs Material** (pure Python — no Node.js):
+To preview or deploy the generated site you also need **MkDocs Material** (pure Python — no Node.js). Install the `site` extra:
 
 ```bash
-pip install mkdocs-material
-pip install mkdocs-swagger-ui-tag   # only when your repo has an OpenAPI/Swagger spec
+pip install 'deepdoc[site]'   # mkdocs-material + pymdown-extensions + mkdocs-swagger-ui-tag
 ```
 
-`deepdoc serve` / `deepdoc deploy` will tell you the exact `pip install` command if MkDocs is missing.
+`deepdoc serve` / `deepdoc deploy` will tell you to run `pip install 'deepdoc[site]'` if MkDocs is missing.
 
 ### Verify installation
 

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/__init__.py

@@ -1,3 +1,3 @@
 """DeepDoc — Auto-generate beautiful docs from any codebase."""
 
-__version__ = "3.0.0"
+__version__ = "3.3.0"

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/answer_mixin.py

@@ -668,15 +668,15 @@ class AnswerMixin:
                     reason=str(row.get("reason", "") or ""),
                 )
             )
-        if mode == "code_deep" and not evidence:
-            diagnostics.warnings.append("No source/config evidence was available for Code Deep.")
+        if mode == "deep" and not evidence:
+            diagnostics.warnings.append("No source/config evidence was available for deep mode.")
         return evidence, diagnostics
 
     def _evidence_role(self, row: dict[str, Any], *, source_kind: str, mode: str) -> str:
         reason = str(row.get("reason", "") or "")
         if source_kind == "config" or row.get("artifact_type"):
             return "config"
-        if reason in {"investigation_step", "research_step"} or mode == "code_deep":
+        if reason in {"investigation_step", "research_step"} or mode == "deep":
             return "implementation"
         if reason == "mentioned_source":
             return "supporting"

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/deep_research.py

@@ -426,7 +426,7 @@ class DeepResearcher:
         step: int,
     ) -> ResearchStep:
         """Run a Tool-Using ReAct loop for a single sub-question."""
-        max_iterations = 3
+        max_iterations = 5
         chunks = self._retrieve_for_question(
             question,
             history,
@@ -468,8 +468,9 @@ class DeepResearcher:
             "You have access to the following initial evidence chunks from the codebase.\n\n"
             "If the evidence is sufficient, provide your final answer in plain text.\n"
             "If you need to explore the codebase further, you can use the following tools by outputting a JSON object and NOTHING else:\n"
-            '1. read_file: `{"action": "read_file", "path": "file/path.py", "start": 10, "end": 50}`\n'
-            '2. grep: `{"action": "grep", "pattern": "def main"}`\n\n'
+            '1. search: `{"action": "search", "query": "what you want to find"}`  — semantic search over the code index\n'
+            '2. read_file: `{"action": "read_file", "path": "file/path.py", "start": 10, "end": 50}`\n'
+            '3. grep: `{"action": "grep", "pattern": "def main"}`\n\n'
             "Answer ONLY based on evidence. Prefer a detailed, implementation-level walkthrough.\n\n"
             "## STRICT GROUNDING RULES\n"
             "- Do NOT invent, fabricate, or hallucinate any code, function names, class names, "
@@ -632,6 +633,35 @@ class DeepResearcher:
                 results.append("... [truncated due to length]")
             return "\n".join(results)
 
+        elif action == "search":
+            query = str(tool_call.get("query", "")).strip()
+            if not query or len(query) < 3:
+                return "Error: search requires a non-empty 'query' (min 3 characters)."
+            try:
+                retrieve_context = getattr(self.service, "retrieve_context", None)
+                if not callable(retrieve_context):
+                    return "Error: search tool unavailable."
+                context = retrieve_context(query, [], mode="fast")
+                code_hits = context.get("code_hits", [])[:8]
+                if not code_hits:
+                    return f"No code matches found for '{query}'."
+                parts = []
+                for i, hit in enumerate(code_hits, 1):
+                    record = getattr(hit, "record", hit)
+                    source = (
+                        getattr(record, "file_path", None)
+                        or getattr(record, "doc_path", None)
+                        or "unknown"
+                    )
+                    text = getattr(record, "text", "")[:1600]
+                    score = round(float(getattr(hit, "score", 0.0)), 3)
+                    parts.append(f"[{i}] {source} (score={score}):\n{text}")
+                    if source not in sources_used:
+                        sources_used.append(source)
+                return "\n\n".join(parts)
+            except Exception as e:
+                return f"Error: Search failed - {e}"
+
         return f"Error: Unknown action '{action}'"
 
     def _synthesise(

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/retrieval_mixin.py

@@ -780,8 +780,10 @@ class RetrievalMixin:
         source_kind = record.source_kind or ""
         if source_kind == "product":
             priority += 0.8 if supporting_requested else 2.5
-        elif source_kind in {"config", "docs", "ops", "tooling"}:
+        elif source_kind in {"config", "ops", "tooling"}:
             priority += 1.2
+        elif source_kind == "docs":
+            priority += 0.2
         elif source_kind in {"test", "fixture", "example", "generated"}:
             priority += 4.5 if supporting_requested else -1.0
 

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/routes.py

@@ -27,14 +27,8 @@ class QueryRequest(BaseModel):
         return v
 
 
-class DeepResearchRequest(QueryRequest):
-    """Incoming deep-research payload."""
-
-    max_rounds: int = Field(default=3, ge=1, le=6)
-
-
-class CodeDeepRequest(QueryRequest):
-    """Incoming code-deep payload."""
+class DeepRequest(QueryRequest):
+    """Incoming deep mode payload."""
 
     max_rounds: int = Field(default=4, ge=1, le=8)
 
@@ -73,10 +67,10 @@ def create_fastapi_app(repo_root: Path, cfg: dict[str, Any]):
                 },
             )
 
-    @app.post("/deep-research")
-    def deep_research(request: DeepResearchRequest = Body(...)) -> dict[str, Any]:
+    @app.post("/deep")
+    def deep(request: DeepRequest = Body(...)) -> dict[str, Any]:
         try:
-            return service.deep_research(
+            return service.deep(
                 request.question,
                 request.history,
                 max_rounds=request.max_rounds,
@@ -85,7 +79,7 @@ def create_fastapi_app(repo_root: Path, cfg: dict[str, Any]):
             return JSONResponse(
                 status_code=500,
                 content={
-                    "error": "chatbot_deep_research_failed",
+                    "error": "chatbot_deep_failed",
                     "detail": str(exc),
                 },
             )
@@ -138,96 +132,29 @@ def create_fastapi_app(repo_root: Path, cfg: dict[str, Any]):
             },
         )
 
-    @app.post("/deep-research/stream")
-    def deep_research_stream(request: DeepResearchRequest = Body(...)):
-        tokens: queue.Queue[tuple[str, dict[str, Any]] | None] = queue.Queue()
+    @app.post("/deep/stream")
+    def deep_stream(request: DeepRequest = Body(...)):
+        events: queue.Queue[tuple[str, dict[str, Any]] | None] = queue.Queue()
 
         def on_token(text: str) -> None:
-            tokens.put(("token", {"text": text}))
-
-        def run() -> None:
-            try:
-                result = service.deep_research(
-                    request.question,
-                    request.history,
-                    max_rounds=request.max_rounds,
-                    token_callback=on_token,
-                )
-                tokens.put(("result", result))
-            except Exception as exc:
-                tokens.put(("error", {"error": "chatbot_deep_research_failed", "detail": str(exc)}))
-            finally:
-                tokens.put(("done", {"status": "done"}))
-                tokens.put(None)
-
-        thread = threading.Thread(target=run, daemon=True)
-        thread.start()
-
-        def event_stream():
-            while True:
-                try:
-                    item = tokens.get(timeout=30)
-                except queue.Empty:
-                    yield "event: ping\ndata: {}\n\n"
-                    continue
-                if item is None:
-                    break
-                event_name, payload = item
-                yield f"event: {event_name}\n"
-                yield f"data: {json.dumps(payload)}\n\n"
-
-        return StreamingResponse(
-            event_stream(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-    @app.post("/code-deep")
-    def code_deep(request: CodeDeepRequest = Body(...)) -> dict[str, Any]:
-        try:
-            return service.code_deep(
-                request.question,
-                request.history,
-                max_rounds=request.max_rounds,
-            )
-        except Exception as exc:
-            return JSONResponse(
-                status_code=500,
-                content={
-                    "error": "chatbot_code_deep_failed",
-                    "detail": str(exc),
-                },
-            )
-
-    @app.post("/code-deep/stream")
-    def code_deep_stream(request: CodeDeepRequest = Body(...)):
-        events: queue.Queue[tuple[str, dict[str, Any]] | None] = queue.Queue()
+            events.put(("token", {"text": text}))
 
         def emit(event: dict[str, Any]) -> None:
             events.put(("trace", event))
 
         def run() -> None:
             try:
-                result = service.code_deep(
+                result = service.deep(
                     request.question,
                     request.history,
                     max_rounds=request.max_rounds,
                     trace_callback=emit,
+                    token_callback=on_token,
                 )
                 events.put(("result", result))
             except Exception as exc:
                 events.put(
-                    (
-                        "error",
-                        {
-                            "error": "chatbot_code_deep_failed",
-                            "detail": str(exc),
-                        },
-                    )
+                    ("error", {"error": "chatbot_deep_failed", "detail": str(exc)})
                 )
             finally:
                 events.put(("done", {"status": "done"}))

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/scaffold.py

@@ -63,16 +63,12 @@ def _app_py() -> str:
             def _query():
                 return JSONResponse(status_code=503, content={"error": "startup_failed", "detail": _detail})
 
-            @app.post("/deep-research")
-            def _deep_research():
+            @app.post("/deep")
+            def _deep():
                 return JSONResponse(status_code=503, content={"error": "startup_failed", "detail": _detail})
 
-            @app.post("/code-deep")
-            def _code_deep():
-                return JSONResponse(status_code=503, content={"error": "startup_failed", "detail": _detail})
-
-            @app.post("/code-deep/stream")
-            def _code_deep_stream():
+            @app.post("/deep/stream")
+            def _deep_stream():
                 return JSONResponse(status_code=503, content={"error": "startup_failed", "detail": _detail})
         """
     )

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/service.py

@@ -49,7 +49,7 @@ from .constants import (
 )
 from .live_fallback_mixin import LiveFallbackMixin
 from .retrieval_mixin import RetrievalMixin
-from .routes import create_fastapi_app, QueryRequest, DeepResearchRequest, CodeDeepRequest
+from .routes import create_fastapi_app, QueryRequest, DeepRequest
 
 
 class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
@@ -106,7 +106,7 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
         ):
             logger.warning(
                 "Source archive empty or unreadable at %s while indexed corpora "
-                "exist. Live-fallback, evidence verification, and code-deep file "
+                "exist. Live-fallback, evidence verification, and deep mode file "
                 "inventory will be degraded. Run `deepdoc update` to rebuild.",
                 self.index_dir / "source_archive.json.gz",
             )
@@ -446,46 +446,24 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
             **self._workspace_defaults(),
         }
 
-    def deep_research(
+    def deep(
         self,
         question: str,
         history: list[dict[str, str]] | None = None,
-        max_rounds: int = 3,
+        max_rounds: int = 4,
         *,
+        trace_callback: Callable[[dict[str, Any]], None] | None = None,
         token_callback: "Callable[[str], None] | None" = None,
     ) -> dict[str, Any]:
-        """Run a DeepResearch session: decompose → retrieve → synthesise.
-
-        Returns a ResearchResult with a comprehensive answer and source citations.
-        Requires an LLM client to be configured (llm= at construction time or via settings).
-
-        Args:
-            question: The research question to answer.
-            max_rounds: Maximum number of sub-questions to explore.
+        """Run an agentic deep research session over the codebase.
 
-        Returns:
-            ResearchResult with fields: original_question, steps, final_answer, all_sources, confidence.
+        Decomposes the question into sub-questions, retrieves code-heavy evidence,
+        runs a tool-using ReAct loop (search / read_file / grep) for each, then
+        synthesises a comprehensive answer with source citations and a file inventory.
         """
-        retrieval_cfg = self.chat_cfg["retrieval"]
-        _, response = self._run_research_mode(
-            question,
-            history,
-            mode="deep",
-            max_rounds=max_rounds,
-            top_k=max(8, retrieval_cfg.get("deep_research_top_k", 10)),
-            token_callback=token_callback,
-        )
-        return response
+        from .deep_research import DeepResearcher
 
-    def code_deep(
-        self,
-        question: str,
-        history: list[dict[str, str]] | None = None,
-        max_rounds: int = 4,
-        *,
-        trace_callback: Callable[[dict[str, Any]], None] | None = None,
-    ) -> dict[str, Any]:
-        retrieval_cfg = self._retrieval_profile("code_deep")
+        retrieval_cfg = self._retrieval_profile("deep")
         trace: list[dict[str, Any]] = []
 
         def emit(event: dict[str, Any]) -> None:
@@ -496,56 +474,19 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
             if callable(callback):
                 callback(payload)
 
-        result, response = self._run_research_mode(
-            question,
-            history,
-            mode="code_deep",
-            max_rounds=max_rounds,
-            top_k=max(
-                10,
-                int(retrieval_cfg.get("code_deep_top_k", retrieval_cfg["top_k_code"])),
-            ),
-            trace_callback=emit,
-        )
-        response["trace"] = trace
-        response["response_mode"] = "code_deep"
-        response["research_mode"] = "code_deep"
-        response = self._finalize_answer_response(question, response, mode="code_deep")
-        response["trace"] = trace
-        response["file_inventory"] = self._collect_file_inventory(
-            question,
-            response,
-            result.all_sources,
-            retrieval_cfg,
-            trace,
-        )
-        return response
-
-    def _run_research_mode(
-        self,
-        question: str,
-        history: list[dict[str, str]] | None,
-        *,
-        mode: str,
-        max_rounds: int,
-        top_k: int,
-        trace_callback: Callable[[dict[str, Any]], None] | None = None,
-        token_callback: "Callable[[str], None] | None" = None,
-    ) -> tuple[Any, dict[str, Any]]:
-        from .deep_research import DeepResearcher
-
+        top_k = max(10, int(retrieval_cfg.get("deep_top_k_code", retrieval_cfg["top_k_code"])))
         researcher = DeepResearcher(
             service=self,
             llm=self._llm,
             top_k=top_k,
             max_rounds=max_rounds,
-            mode=mode,
-            trace_callback=trace_callback,
+            mode="deep",
+            trace_callback=emit,
         )
         researcher.synthesis_token_callback = token_callback
         result = researcher.research(question, history=history or [])
-        query_mode = "deep" if mode == "deep" else "code_deep"
-        response = self.query(question, history, mode=query_mode)
+
+        response = self.query(question, history, mode="deep")
         response.update(
             {
                 "answer": result.final_answer,
@@ -554,13 +495,17 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
                     sum(step.chunks_used for step in result.steps),
                 ),
                 "confidence": result.confidence,
-                "research_mode": mode,
+                "research_mode": "deep",
                 "research_sources": result.all_sources,
-                "response_mode": mode,
+                "response_mode": "deep",
             }
         )
-        response = self._finalize_answer_response(question, response, mode=mode)
-        return result, response
+        response = self._finalize_answer_response(question, response, mode="deep")
+        response["trace"] = trace
+        response["file_inventory"] = self._collect_file_inventory(
+            question, response, result.all_sources, retrieval_cfg, trace,
+        )
+        return response
 
     def _collect_file_inventory(
         self,
@@ -570,7 +515,7 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
         retrieval_cfg: dict[str, Any],
         trace: list[dict[str, Any]],
     ) -> list[dict[str, Any]]:
-        limit = max(8, int(retrieval_cfg.get("code_deep_file_inventory_limit", 18)))
+        limit = max(8, int(retrieval_cfg.get("deep_file_inventory_limit", 18)))
         inventory: dict[str, dict[str, Any]] = {}
 
         def add_entry(
@@ -696,21 +641,17 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
 
     def _retrieval_profile(self, mode: str) -> dict[str, Any]:
         base = deepcopy(self.chat_cfg["retrieval"])
-        mode_name = mode.strip().lower() if isinstance(mode, str) else "default"
+        mode_name = mode.strip().lower() if isinstance(mode, str) else "fast"
+
         if mode_name == "default":
             return base
-        if mode_name == "deep":
-            deep_prompt_chars = base.get("deep_mode_max_prompt_chars")
-            if isinstance(deep_prompt_chars, int) and deep_prompt_chars > 0:
-                base["max_prompt_chars"] = deep_prompt_chars
-            return base
 
-        if mode_name == "code_deep":
-            code_prompt_chars = base.get("code_deep_mode_max_prompt_chars")
-            if isinstance(code_prompt_chars, int) and code_prompt_chars > 0:
-                base["max_prompt_chars"] = code_prompt_chars
+        if mode_name == "deep":
+            prompt_chars = base.get("deep_mode_max_prompt_chars")
+            if isinstance(prompt_chars, int) and prompt_chars > 0:
+                base["max_prompt_chars"] = prompt_chars
 
-            code_top_k = base.get("code_deep_top_k")
+            code_top_k = base.get("deep_top_k_code")
             if isinstance(code_top_k, int) and code_top_k > 0:
                 base["top_k_code"] = max(base.get("top_k_code", code_top_k), code_top_k)
                 base["candidate_top_k_code"] = max(
@@ -718,18 +659,17 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
                     code_top_k * 2,
                 )
 
-            relationship_top_k = base.get("code_deep_top_k_relationship")
-            if isinstance(relationship_top_k, int) and relationship_top_k > 0:
+            rel_top_k = base.get("deep_top_k_relationship")
+            if isinstance(rel_top_k, int) and rel_top_k > 0:
                 base["top_k_relationship"] = max(
-                    base.get("top_k_relationship", relationship_top_k),
-                    relationship_top_k,
+                    base.get("top_k_relationship", rel_top_k), rel_top_k,
                 )
                 base["candidate_top_k_relationship"] = max(
-                    base.get("candidate_top_k_relationship", relationship_top_k * 2),
-                    relationship_top_k * 2,
+                    base.get("candidate_top_k_relationship", rel_top_k * 2),
+                    rel_top_k * 2,
                 )
 
-            docs_cap = base.get("code_deep_top_k_docs")
+            docs_cap = base.get("deep_top_k_docs")
             if isinstance(docs_cap, int) and docs_cap > 0:
                 base["top_k_docs"] = min(base.get("top_k_docs", docs_cap), docs_cap)
 
@@ -739,6 +679,7 @@ class ChatbotQueryService(RetrievalMixin, AnswerMixin, LiveFallbackMixin):
             base["rerank"] = True
             return base
 
+        # fast mode (default for any unrecognised mode string)
         fast_prompt_chars = base.get("fast_mode_max_prompt_chars")
         if isinstance(fast_prompt_chars, int) and fast_prompt_chars > 0:
             base["max_prompt_chars"] = fast_prompt_chars

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/chatbot/settings.py

@@ -72,12 +72,11 @@ DEFAULT_CHATBOT_CONFIG: dict[str, Any] = {
         "fast_mode_use_llm_retrieval_steps": False,
         "fast_mode_iterative_retrieval": False,
         "fast_mode_max_prompt_chars": 90000,
-        "deep_mode_max_prompt_chars": 140000,
-        "code_deep_mode_max_prompt_chars": 180000,
-        "code_deep_top_k": 16,
-        "code_deep_top_k_relationship": 12,
-        "code_deep_top_k_docs": 4,
-        "code_deep_file_inventory_limit": 18,
+        "deep_mode_max_prompt_chars": 180000,
+        "deep_top_k_code": 16,
+        "deep_top_k_relationship": 12,
+        "deep_top_k_docs": 4,
+        "deep_file_inventory_limit": 18,
         "lexical_retrieval": True,
         "lexical_candidate_limit": 24,
         "query_expansion": True,

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/cli.py

@@ -974,7 +974,7 @@ def serve(port):
 
     \b
     Run `deepdoc generate` first so the generated MkDocs site and docs exist.
-    Requires MkDocs Material: pip install mkdocs-material
+    Requires the site extra: pip install 'deepdoc[site]'
     """
     _load_or_exit()
     cfg = _load_or_exit()
@@ -1026,7 +1026,7 @@ def serve(port):
         pass
     except FileNotFoundError:
         console.print(
-            "[red]mkdocs not found. Install it: [bold]pip install mkdocs-material[/bold][/red]"
+            "[red]mkdocs not found. Install it: [bold]pip install 'deepdoc[site]'[/bold][/red]"
         )
         sys.exit(1)
     finally:
@@ -1107,7 +1107,7 @@ def _deploy():
             console.print("[red]Build failed.[/red]")
     except FileNotFoundError:
         console.print(
-            "[red]mkdocs not found. Install it: [bold]pip install mkdocs-material[/bold][/red]"
+            "[red]mkdocs not found. Install it: [bold]pip install 'deepdoc[site]'[/bold][/red]"
         )
         sys.exit(1)
 
@@ -1132,9 +1132,9 @@ def _ensure_mkdocs_installed(cfg: dict) -> None:
             missing.append("mkdocs-swagger-ui-tag")
 
     if missing:
-        pkgs = " ".join(dict.fromkeys(missing))
         raise click.ClickException(
-            f"MkDocs is not installed. Install it with:\n    pip install {pkgs}"
+            "MkDocs is not installed. Install the site extra with:\n"
+            "    pip install 'deepdoc[site]'"
         )
 
 

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/config.py

@@ -227,12 +227,11 @@ DEFAULT_CONFIG: dict[str, Any] = {
             "fast_mode_use_llm_retrieval_steps": False,
             "fast_mode_iterative_retrieval": False,
             "fast_mode_max_prompt_chars": 90000,
-            "deep_mode_max_prompt_chars": 140000,
-            "code_deep_mode_max_prompt_chars": 180000,
-            "code_deep_top_k": 16,
-            "code_deep_top_k_relationship": 12,
-            "code_deep_top_k_docs": 4,
-            "code_deep_file_inventory_limit": 18,
+            "deep_mode_max_prompt_chars": 180000,
+            "deep_top_k_code": 16,
+            "deep_top_k_relationship": 12,
+            "deep_top_k_docs": 4,
+            "deep_file_inventory_limit": 18,
             "lexical_retrieval": True,
             "lexical_candidate_limit": 24,
             "query_expansion": True,

{deepdoc-3.0.0 → deepdoc-3.3.0}/deepdoc/generator/__init__.py

@@ -13,11 +13,9 @@ from .post_processors import (
     build_internal_doc_link_maps,
     fix_file_references,
     fix_mermaid_diagrams,
-    normalize_code_fence_languages,
     normalize_explanatory_lines_outside_fences,
     normalize_html_code_blocks,
     repair_internal_doc_links,
-    repair_split_object_code_fences,
     repair_dangling_plain_fences,
     repair_unbalanced_code_fences,
 )