From 66eb67569eae2d85afe5acd2ffb0478f32419fa2 Mon Sep 17 00:00:00 2001 From: "yue02.sun" Date: Thu, 28 May 2026 19:02:16 +0800 Subject: [PATCH] first commit --- build/lib/d_wiki/__init__.py | 3 + build/lib/d_wiki/__main__.py | 4 + build/lib/d_wiki/cli.py | 77 +++ build/lib/d_wiki/compile.py | 590 ++++++++++++++++++ build/lib/d_wiki/config.py | 59 ++ build/lib/d_wiki/dreams.py | 227 +++++++ build/lib/d_wiki/llm.py | 156 +++++ build/lib/d_wiki/metadata.py | 119 ++++ build/lib/d_wiki/search.py | 469 ++++++++++++++ build/lib/d_wiki/tokenize.py | 22 + build/lib/d_wiki/yaml_compat.py | 70 +++ d-wiki | 5 + d-wiki.yml | 11 + d_wiki.egg-info/PKG-INFO | 5 + d_wiki.egg-info/SOURCES.txt | 19 + d_wiki.egg-info/dependency_links.txt | 1 + d_wiki.egg-info/entry_points.txt | 2 + d_wiki.egg-info/top_level.txt | 1 + d_wiki/__init__.py | 3 + d_wiki/__main__.py | 4 + d_wiki/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 260 bytes d_wiki/__pycache__/__init__.cpython-312.pyc | Bin 0 -> 251 bytes d_wiki/__pycache__/__init__.cpython-314.pyc | Bin 0 -> 253 bytes d_wiki/__pycache__/__main__.cpython-312.pyc | Bin 0 -> 291 bytes d_wiki/__pycache__/__main__.cpython-314.pyc | Bin 0 -> 297 bytes d_wiki/__pycache__/cli.cpython-311.pyc | Bin 0 -> 5424 bytes d_wiki/__pycache__/cli.cpython-312.pyc | Bin 0 -> 4830 bytes d_wiki/__pycache__/cli.cpython-314.pyc | Bin 0 -> 5139 bytes d_wiki/__pycache__/compile.cpython-311.pyc | Bin 0 -> 34834 bytes d_wiki/__pycache__/compile.cpython-312.pyc | Bin 0 -> 29961 bytes d_wiki/__pycache__/compile.cpython-314.pyc | Bin 0 -> 35866 bytes d_wiki/__pycache__/config.cpython-311.pyc | Bin 0 -> 4270 bytes d_wiki/__pycache__/config.cpython-312.pyc | Bin 0 -> 3537 bytes d_wiki/__pycache__/config.cpython-314.pyc | Bin 0 -> 4165 bytes d_wiki/__pycache__/dreams.cpython-311.pyc | Bin 0 -> 14693 bytes d_wiki/__pycache__/dreams.cpython-312.pyc | Bin 0 -> 12422 bytes d_wiki/__pycache__/dreams.cpython-314.pyc | Bin 0 -> 15951 bytes d_wiki/__pycache__/llm.cpython-311.pyc | Bin 0 -> 11461 bytes d_wiki/__pycache__/llm.cpython-312.pyc | Bin 0 -> 9968 bytes d_wiki/__pycache__/llm.cpython-314.pyc | Bin 0 -> 12165 bytes d_wiki/__pycache__/metadata.cpython-311.pyc | Bin 0 -> 10041 bytes d_wiki/__pycache__/metadata.cpython-312.pyc | Bin 0 -> 8126 bytes d_wiki/__pycache__/metadata.cpython-314.pyc | Bin 0 -> 10504 bytes d_wiki/__pycache__/search.cpython-311.pyc | Bin 0 -> 30958 bytes d_wiki/__pycache__/search.cpython-312.pyc | Bin 0 -> 25989 bytes d_wiki/__pycache__/search.cpython-314.pyc | Bin 0 -> 32170 bytes d_wiki/__pycache__/tokenize.cpython-311.pyc | Bin 0 -> 2505 bytes d_wiki/__pycache__/tokenize.cpython-312.pyc | Bin 0 -> 2062 bytes d_wiki/__pycache__/tokenize.cpython-314.pyc | Bin 0 -> 2644 bytes .../__pycache__/yaml_compat.cpython-311.pyc | Bin 0 -> 4546 bytes .../__pycache__/yaml_compat.cpython-312.pyc | Bin 0 -> 3530 bytes .../__pycache__/yaml_compat.cpython-314.pyc | Bin 0 -> 4126 bytes d_wiki/cli.py | 77 +++ d_wiki/compile.py | 590 ++++++++++++++++++ d_wiki/config.py | 59 ++ d_wiki/dreams.py | 227 +++++++ d_wiki/llm.py | 156 +++++ d_wiki/metadata.py | 119 ++++ d_wiki/search.py | 469 ++++++++++++++ d_wiki/tokenize.py | 22 + d_wiki/yaml_compat.py | 70 +++ docs/language-decision.md | 56 ++ knowledge/robogo/aliases.yml | 25 + knowledge/robogo/queries/3d-generation.md | 25 + knowledge/robogo/queries/dev-machine.md | 7 + knowledge/robogo/queries/guagan.md | 7 + knowledge/robogo/queries/mirror.md | 8 + knowledge/robogo/queries/openclaw.md | 8 + knowledge/robogo/queries/rdk-agent.md | 8 + knowledge/x5/aliases.yml | 33 + knowledge/x5/queries/camera-bring-up.md | 19 + knowledge/x5/queries/compute.md | 14 + pyproject.toml | 17 + .../test_d_wiki.cpython-311-pytest-9.0.3.pyc | Bin 0 -> 25064 bytes tests/__pycache__/test_d_wiki.cpython-312.pyc | Bin 0 -> 20696 bytes tests/__pycache__/test_d_wiki.cpython-314.pyc | Bin 0 -> 8503 bytes tests/test_d_wiki.py | 509 +++++++++++++++ 77 files changed, 4372 insertions(+) create mode 100644 build/lib/d_wiki/__init__.py create mode 100644 build/lib/d_wiki/__main__.py create mode 100644 build/lib/d_wiki/cli.py create mode 100644 build/lib/d_wiki/compile.py create mode 100644 build/lib/d_wiki/config.py create mode 100644 build/lib/d_wiki/dreams.py create mode 100644 build/lib/d_wiki/llm.py create mode 100644 build/lib/d_wiki/metadata.py create mode 100644 build/lib/d_wiki/search.py create mode 100644 build/lib/d_wiki/tokenize.py create mode 100644 build/lib/d_wiki/yaml_compat.py create mode 100755 d-wiki create mode 100644 d-wiki.yml create mode 100644 d_wiki.egg-info/PKG-INFO create mode 100644 d_wiki.egg-info/SOURCES.txt create mode 100644 d_wiki.egg-info/dependency_links.txt create mode 100644 d_wiki.egg-info/entry_points.txt create mode 100644 d_wiki.egg-info/top_level.txt create mode 100644 d_wiki/__init__.py create mode 100644 d_wiki/__main__.py create mode 100644 d_wiki/__pycache__/__init__.cpython-311.pyc create mode 100644 d_wiki/__pycache__/__init__.cpython-312.pyc create mode 100644 d_wiki/__pycache__/__init__.cpython-314.pyc create mode 100644 d_wiki/__pycache__/__main__.cpython-312.pyc create mode 100644 d_wiki/__pycache__/__main__.cpython-314.pyc create mode 100644 d_wiki/__pycache__/cli.cpython-311.pyc create mode 100644 d_wiki/__pycache__/cli.cpython-312.pyc create mode 100644 d_wiki/__pycache__/cli.cpython-314.pyc create mode 100644 d_wiki/__pycache__/compile.cpython-311.pyc create mode 100644 d_wiki/__pycache__/compile.cpython-312.pyc create mode 100644 d_wiki/__pycache__/compile.cpython-314.pyc create mode 100644 d_wiki/__pycache__/config.cpython-311.pyc create mode 100644 d_wiki/__pycache__/config.cpython-312.pyc create mode 100644 d_wiki/__pycache__/config.cpython-314.pyc create mode 100644 d_wiki/__pycache__/dreams.cpython-311.pyc create mode 100644 d_wiki/__pycache__/dreams.cpython-312.pyc create mode 100644 d_wiki/__pycache__/dreams.cpython-314.pyc create mode 100644 d_wiki/__pycache__/llm.cpython-311.pyc create mode 100644 d_wiki/__pycache__/llm.cpython-312.pyc create mode 100644 d_wiki/__pycache__/llm.cpython-314.pyc create mode 100644 d_wiki/__pycache__/metadata.cpython-311.pyc create mode 100644 d_wiki/__pycache__/metadata.cpython-312.pyc create mode 100644 d_wiki/__pycache__/metadata.cpython-314.pyc create mode 100644 d_wiki/__pycache__/search.cpython-311.pyc create mode 100644 d_wiki/__pycache__/search.cpython-312.pyc create mode 100644 d_wiki/__pycache__/search.cpython-314.pyc create mode 100644 d_wiki/__pycache__/tokenize.cpython-311.pyc create mode 100644 d_wiki/__pycache__/tokenize.cpython-312.pyc create mode 100644 d_wiki/__pycache__/tokenize.cpython-314.pyc create mode 100644 d_wiki/__pycache__/yaml_compat.cpython-311.pyc create mode 100644 d_wiki/__pycache__/yaml_compat.cpython-312.pyc create mode 100644 d_wiki/__pycache__/yaml_compat.cpython-314.pyc create mode 100644 d_wiki/cli.py create mode 100644 d_wiki/compile.py create mode 100644 d_wiki/config.py create mode 100644 d_wiki/dreams.py create mode 100644 d_wiki/llm.py create mode 100644 d_wiki/metadata.py create mode 100644 d_wiki/search.py create mode 100644 d_wiki/tokenize.py create mode 100644 d_wiki/yaml_compat.py create mode 100644 docs/language-decision.md create mode 100644 knowledge/robogo/aliases.yml create mode 100644 knowledge/robogo/queries/3d-generation.md create mode 100644 knowledge/robogo/queries/dev-machine.md create mode 100644 knowledge/robogo/queries/guagan.md create mode 100644 knowledge/robogo/queries/mirror.md create mode 100644 knowledge/robogo/queries/openclaw.md create mode 100644 knowledge/robogo/queries/rdk-agent.md create mode 100644 knowledge/x5/aliases.yml create mode 100644 knowledge/x5/queries/camera-bring-up.md create mode 100644 knowledge/x5/queries/compute.md create mode 100644 pyproject.toml create mode 100644 tests/__pycache__/test_d_wiki.cpython-311-pytest-9.0.3.pyc create mode 100644 tests/__pycache__/test_d_wiki.cpython-312.pyc create mode 100644 tests/__pycache__/test_d_wiki.cpython-314.pyc create mode 100644 tests/test_d_wiki.py diff --git a/build/lib/d_wiki/__init__.py b/build/lib/d_wiki/__init__.py new file mode 100644 index 0000000..365f5d0 --- /dev/null +++ b/build/lib/d_wiki/__init__.py @@ -0,0 +1,3 @@ +"""d-wiki lightweight local knowledge retrieval.""" + +__version__ = "0.1.0" diff --git a/build/lib/d_wiki/__main__.py b/build/lib/d_wiki/__main__.py new file mode 100644 index 0000000..bfdcd0c --- /dev/null +++ b/build/lib/d_wiki/__main__.py @@ -0,0 +1,4 @@ +from .cli import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/build/lib/d_wiki/cli.py b/build/lib/d_wiki/cli.py new file mode 100644 index 0000000..92d81fc --- /dev/null +++ b/build/lib/d_wiki/cli.py @@ -0,0 +1,77 @@ +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path +from typing import Any + +from .config import DWikiConfig, load_config +from .compile import compile_kb +from .dreams import dream_kb +from .search import get_page, index_payload, search, status_payload + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(prog="d-wiki") + parser.add_argument("--config", type=Path, default=None) + subparsers = parser.add_subparsers(dest="command", required=True) + + status_parser = subparsers.add_parser("status") + status_parser.add_argument("--format", choices=["json"], default="json") + + index_parser = subparsers.add_parser("index") + index_parser.add_argument("--kb", required=True) + index_parser.add_argument("--format", choices=["json"], default="json") + + compile_parser = subparsers.add_parser("compile") + compile_parser.add_argument("--kb", required=True) + compile_parser.add_argument("--force", action="store_true") + compile_parser.add_argument("--llm", choices=["off", "auto", "require"], default="off") + compile_parser.add_argument("--llm-scope", choices=["queries", "all"], default="queries") + compile_parser.add_argument("--format", choices=["json"], default="json") + + dream_parser = subparsers.add_parser("dream") + dream_parser.add_argument("--kb", required=True) + dream_parser.add_argument("--force", action="store_true") + dream_parser.add_argument("--format", choices=["json"], default="json") + + search_parser = subparsers.add_parser("search") + search_parser.add_argument("--kb", required=True) + search_parser.add_argument("--query", required=True) + search_parser.add_argument("--max-results", type=int, default=5) + search_parser.add_argument("--format", choices=["json"], default="json") + + get_parser = subparsers.add_parser("get") + get_parser.add_argument("--kb", required=True) + get_parser.add_argument("--id", required=True) + get_parser.add_argument("--format", choices=["json"], default="json") + + args = parser.parse_args(argv) + try: + config = load_config(args.config) + payload = dispatch(args, config) + except Exception as exc: + print(json.dumps({"status": "error", "error": str(exc)}, ensure_ascii=False), file=sys.stderr) + return 2 + print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True)) + return 0 + + +def dispatch(args: argparse.Namespace, config: DWikiConfig) -> dict[str, Any]: + if args.command == "status": + return status_payload(config.path, config.knowledge_bases) + kb = config.knowledge_bases.get(args.kb) + if kb is None: + raise ValueError(f"D_WIKI_KB_NOT_FOUND: {args.kb}") + if args.command == "index": + return index_payload(kb) + if args.command == "compile": + return compile_kb(kb, force=args.force, llm_mode=args.llm, llm_scope=args.llm_scope) + if args.command == "dream": + return dream_kb(kb, force=args.force) + if args.command == "search": + return search(kb, args.query, args.max_results) + if args.command == "get": + return get_page(kb, args.id) + raise ValueError(f"D_WIKI_UNKNOWN_COMMAND: {args.command}") diff --git a/build/lib/d_wiki/compile.py b/build/lib/d_wiki/compile.py new file mode 100644 index 0000000..bd90cae --- /dev/null +++ b/build/lib/d_wiki/compile.py @@ -0,0 +1,590 @@ +from __future__ import annotations + +import re +import shutil +import json +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .llm import LlmPageSynthesis, LlmPageSynthesizer +from .metadata import load_alias_groups, load_query_entries +from .search import Chunk, compiled_wiki_root, load_source_chunks, trim_block +from .tokenize import tokenize + + +@dataclass(frozen=True) +class CompiledPage: + wikilink: str + title: str + path: Path + + +@dataclass(frozen=True) +class _EvidenceProfile: + tokens: frozenset[str] + phrases: tuple[str, ...] + + +def compile_kb( + kb: KnowledgeBaseConfig, + *, + force: bool = False, + llm_mode: str = "off", + llm_scope: str = "queries", +) -> dict[str, Any]: + chunks = load_source_chunks(kb) + if not chunks: + raise ValueError("D_WIKI_COMPILE_NO_SOURCE_CHUNKS") + synthesizer = LlmPageSynthesizer.from_environment() if llm_mode in {"auto", "require"} else None + if llm_mode == "require" and synthesizer is None: + raise ValueError("D_WIKI_LLM_CONFIG_REQUIRED") + wiki_root = compiled_wiki_root(kb) + concepts_dir = wiki_root / "concepts" + raw_dir = wiki_root / "raw" + if force: + shutil.rmtree(concepts_dir, ignore_errors=True) + concepts_dir.mkdir(parents=True, exist_ok=True) + raw_dir.mkdir(parents=True, exist_ok=True) + + pages: list[CompiledPage] = [] + grouped = _group_chunks(chunks) + query_entries = load_query_entries(kb.queries_dir) + alias_groups = load_alias_groups(kb.aliases_path) + query_by_source = { + source: entry + for entry in query_entries + for source in entry.primary_sources + } + aliases_by_source = { + related: group + for group in alias_groups + for related in group.related + } + + for wikilink, page_chunks in sorted(grouped.items()): + page = _compile_page( + kb, + wikilink, + page_chunks, + query_entry=query_by_source.get(wikilink), + alias_group=aliases_by_source.get(wikilink), + synthesizer=( + synthesizer + if llm_scope == "all" or query_by_source.get(wikilink) is not None + else None + ), + require_llm=llm_mode == "require", + ) + if force or not page.path.exists(): + page.path.write_text(page.content, encoding="utf-8") + pages.append(CompiledPage(wikilink=wikilink, title=page.title, path=page.path)) + + _write_schema(wiki_root, kb) + _write_index(wiki_root, pages) + _append_log(wiki_root, kb, len(chunks), len(pages)) + return { + "status": "compiled", + "kb": kb.name, + "source_root": str(kb.root), + "wiki_root": str(wiki_root), + "source_chunks": len(chunks), + "pages": len(pages), + "llm_mode": llm_mode, + "llm_scope": llm_scope, + "llm_enabled": synthesizer is not None, + "compiled_at": datetime.now(timezone.utc).isoformat(), + } + + +@dataclass(frozen=True) +class _PageDraft: + title: str + path: Path + content: str + + +def _compile_page( + kb: KnowledgeBaseConfig, + wikilink: str, + chunks: list[Chunk], + *, + query_entry: Any | None, + alias_group: Any | None, + synthesizer: LlmPageSynthesizer | None, + require_llm: bool, +) -> _PageDraft: + first = chunks[0] + title = _title_for(first, query_entry) + slug = _slug(wikilink) + path = compiled_wiki_root(kb) / "concepts" / f"{slug}.md" + evidence_profile = _evidence_profile(title, query_entry, alias_group) + tags = _tags(kb, first, alias_group) + aliases = _aliases(title, query_entry, alias_group) + source_ref = first.wikilink + source_path = str(first.source_path) + key_blocks = _key_blocks(chunks, evidence_profile) + intent = _intent(title, query_entry, alias_group) + summary = _summary(chunks, title, evidence_profile, intent=intent) + requirements = _answer_requirements(intent, query_entry) + synthesis = _llm_synthesis( + synthesizer, + title=title, + wikilink=wikilink, + query_entry=query_entry, + alias_group=alias_group, + key_blocks=key_blocks, + require_llm=require_llm, + ) + if synthesis is not None: + summary = synthesis.summary + retrieval_hints = _retrieval_hints(title, aliases, tags, requirements, alias_group) + blueprint = ( + list(synthesis.answer_blueprint) + if synthesis and synthesis.answer_blueprint + else _deterministic_answer_blueprint(intent, requirements, key_blocks) + ) + links = _related_links(query_entry, alias_group) + content = "\n".join( + [ + "---", + f"llmWikiVersion: \"1\"", + f"conceptId: {_yaml_scalar(slug)}", + f"title: {_yaml_scalar(title)}", + f"summary: {_yaml_scalar(summary)}", + f"sources: {_yaml_list([source_ref])}", + f"source_paths: {_yaml_list([source_path])}", + f"kind: concept", + f"tags: {_yaml_list(tags)}", + f"aliases: {_yaml_list(aliases)}", + f"intents: {_yaml_list([intent])}", + f"retrieval_hints: {_yaml_list(retrieval_hints)}", + f"answer_requirements: {_yaml_list(requirements)}", + f"confidence: {synthesis.confidence if synthesis else 'medium'}", + f"provenanceState: {'llm_compiled' if synthesis else 'compiled'}", + "---", + "", + f"# {title}", + "", + summary, + "", + "## Intent Model", + "", + f"- intent: {intent}", + f"- coverage: {'procedure' if intent == 'procedure' else 'fact'}", + f"- answer_requirements: {';'.join(requirements) if requirements else '直接基于证据回答'}", + "", + "## Retrieval Hints", + "", + *[f"- {hint}" for hint in retrieval_hints], + "", + "## Answer Blueprint", + "", + *[f"- {item}" for item in blueprint], + "", + "## Synthesized Evidence" if synthesis and synthesis.key_evidence else "", + "" if synthesis and synthesis.key_evidence else "", + *[f"- {item}" for item in (synthesis.key_evidence if synthesis else ())], + "" if synthesis and synthesis.key_evidence else "", + "## Evidence Graph", + "", + *_evidence_graph_lines(key_blocks), + "", + "## Key Evidence", + "", + *[f"- {trim_block(block.text, 420)} ^[{block.wikilink}#{block.index}]" for block in key_blocks], + "", + "## Source Map", + "", + f"- 原始来源:`{source_ref}`", + f"- 文件路径:`{source_path}`", + "", + "## Related", + "", + *[f"- [[{link}]]" for link in links], + "", + ] + ) + return _PageDraft(title=title, path=path, content=content) + + +def _llm_synthesis( + synthesizer: LlmPageSynthesizer | None, + *, + title: str, + wikilink: str, + query_entry: Any | None, + alias_group: Any | None, + key_blocks: list[Chunk], + require_llm: bool, +) -> LlmPageSynthesis | None: + if synthesizer is None: + return None + prompt = _llm_compile_prompt( + title=title, + wikilink=wikilink, + query_entry=query_entry, + alias_group=alias_group, + key_blocks=key_blocks, + ) + try: + return synthesizer.synthesize(prompt) + except Exception: + if require_llm: + raise + return None + + +def _llm_compile_prompt( + *, + title: str, + wikilink: str, + query_entry: Any | None, + alias_group: Any | None, + key_blocks: list[Chunk], +) -> str: + aliases = list(getattr(query_entry, "aliases", ()) if query_entry is not None else ()) + terms = list(getattr(alias_group, "terms", ()) if alias_group is not None else ()) + requirements = list(getattr(query_entry, "answer_requirements", ()) if query_entry is not None else ()) + intent = getattr(query_entry, "intent", None) if query_entry is not None else getattr(alias_group, "intent", None) + evidence = [ + { + "block_id": f"{block.wikilink}#{block.index}", + "heading": block.heading, + "text": trim_block(block.text, 700), + } + for block in key_blocks[:8] + ] + return "\n".join( + [ + "Compile a d-wiki concept page from the local evidence below.", + "Do not invent facts. Use only the evidence text. Prefer Chinese output when the title or aliases are Chinese.", + "For procedure intent, make answer_blueprint actionable and ordered. For fact intent, put the direct answer first.", + "Return only JSON with this shape:", + '{"summary": "...", "answer_blueprint": ["..."], "key_evidence": ["..."], "confidence": "low|medium|high"}', + "", + json_dumps( + { + "title": title, + "wikilink": wikilink, + "intent": intent, + "aliases": aliases, + "terms": terms, + "answer_requirements": requirements, + "evidence": evidence, + } + ), + ] + ) + + +def _answer_blueprint_lines(synthesis: LlmPageSynthesis | None) -> list[str]: + if synthesis is None or not synthesis.answer_blueprint: + return [] + return ["## Answer Blueprint", "", *[f"- {item}" for item in synthesis.answer_blueprint], ""] + + +def _intent(title: str, query_entry: Any | None, alias_group: Any | None) -> str: + if query_entry is not None and getattr(query_entry, "intent", ""): + return str(query_entry.intent) + if alias_group is not None and getattr(alias_group, "intent", ""): + return str(alias_group.intent) + lowered = title.lower() + if any(term in lowered for term in ("如何", "怎么", "指南", "debug", "调试", "配置", "bring up", "生成")): + return "procedure" + return "fact" + + +def _answer_requirements(intent: str, query_entry: Any | None) -> list[str]: + if query_entry is not None: + requirements = [str(item) for item in getattr(query_entry, "answer_requirements", ()) if str(item).strip()] + if requirements: + return _unique(requirements) + if intent == "procedure": + return ["按步骤回答", "说明关键前提", "说明验证方式", "引用证据来源"] + return ["直接给出结论", "保留关键数值和单位", "引用证据来源"] + + +def _retrieval_hints( + title: str, + aliases: list[str], + tags: list[str], + requirements: list[str], + alias_group: Any | None, +) -> list[str]: + values = [title, *aliases, *tags, *requirements] + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + hints: list[str] = [] + for value in values: + hints.append(value) + hints.extend(tokenize(value)) + return _unique(hints)[:32] + + +def _deterministic_answer_blueprint(intent: str, requirements: list[str], key_blocks: list[Chunk]) -> list[str]: + if requirements: + return requirements[:6] + if intent == "procedure": + headings = _unique([block.heading for block in key_blocks if block.heading]) + if headings: + return [f"围绕「{heading}」组织步骤和注意事项" for heading in headings[:5]] + return ["按前提、配置、执行、验证的顺序回答"] + return ["先给出直接结论", "补充关键参数、限制和来源"] + + +def _evidence_graph_lines(key_blocks: list[Chunk]) -> list[str]: + lines: list[str] = [] + for block in key_blocks[:8]: + claim = trim_block(block.text, 180) + if not claim: + continue + lines.append(f"- claim: {claim}") + lines.append(f" source: {block.wikilink}#{block.index}") + if block.heading: + lines.append(f" heading: {block.heading}") + return lines or ["- claim: 暂无可用证据", " source: unknown"] + + +def _group_chunks(chunks: list[Chunk]) -> dict[str, list[Chunk]]: + grouped: dict[str, list[Chunk]] = {} + for chunk in chunks: + grouped.setdefault(chunk.wikilink, []).append(chunk) + return grouped + + +def _title_for(chunk: Chunk, query_entry: Any | None) -> str: + if query_entry is not None and getattr(query_entry, "title", ""): + return str(query_entry.title) + return chunk.title + + +def _summary( + chunks: list[Chunk], + title: str, + evidence_profile: _EvidenceProfile | None = None, + *, + intent: str = "fact", +) -> str: + if intent == "procedure": + for chunk in chunks[:12]: + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text) and re.search(r"(概述|流程|过程|用于|帮助|点亮|调试)", text): + return f"{title}:{text}" + ranked = _rank_evidence(chunks, evidence_profile) + for score, chunk in ranked: + if score <= 0: + continue + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text): + return f"{title}:{text}" + for chunk in chunks: + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text) and len(text) >= 20: + return f"{title}:{text}" + return f"{title} 的编译知识页,来源于本地文档。" + + +def _key_blocks(chunks: list[Chunk], evidence_profile: _EvidenceProfile | None = None) -> list[Chunk]: + preferred = [ + chunk + for chunk in chunks + if _is_evidence_candidate(chunk.text) + ] + ranked = _rank_evidence(preferred, evidence_profile) + if not ranked or ranked[0][0] <= 0: + return (preferred or chunks)[:6] + selected: list[Chunk] = [] + seen: set[tuple[str, int]] = set() + for score, chunk in ranked: + if score <= 0: + continue + key = (chunk.wikilink, chunk.index) + if key in seen: + continue + selected.append(chunk) + seen.add(key) + if len(selected) >= 6: + return selected + for chunk in preferred: + key = (chunk.wikilink, chunk.index) + if key in seen: + continue + selected.append(chunk) + seen.add(key) + if len(selected) >= 6: + break + return selected + + +def _evidence_profile(title: str, query_entry: Any | None, alias_group: Any | None) -> _EvidenceProfile: + values = [title] + if query_entry is not None: + values.extend(str(item) for item in getattr(query_entry, "aliases", ())) + values.extend(str(item) for item in getattr(query_entry, "answer_requirements", ())) + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + phrases = tuple(_unique([_normalize_phrase(value) for value in values if value])) + tokens: set[str] = set() + for value in values: + tokens.update(tokenize(str(value))) + return _EvidenceProfile(tokens=frozenset(tokens), phrases=phrases) + + +def _rank_evidence( + chunks: list[Chunk], + evidence_profile: _EvidenceProfile | None, +) -> list[tuple[float, Chunk]]: + if evidence_profile is None or (not evidence_profile.tokens and not evidence_profile.phrases): + return [] + ranked = [(_evidence_score(chunk, evidence_profile), chunk) for chunk in chunks] + ranked.sort(key=lambda item: (-item[0], item[1].index)) + return ranked + + +def _evidence_score(chunk: Chunk, evidence_profile: _EvidenceProfile) -> float: + text = trim_block(chunk.text, 1000) + normalized = _normalize_phrase(text) + chunk_tokens = set(chunk.tokens) | set(tokenize(text)) + score = 0.0 + score += len(chunk_tokens & evidence_profile.tokens) * 2.0 + for phrase in evidence_profile.phrases: + if len(phrase) >= 2 and phrase in normalized: + score += 5.0 + if "tops" in evidence_profile.tokens and re.search(r"\b\d+(?:\.\d+)?\s*tops\b", normalized): + score += 8.0 + if "算力" in evidence_profile.tokens and "tops" in normalized: + score += 6.0 + if "bpu" in evidence_profile.tokens and "bpu" in normalized: + score += 4.0 + if re.search(r"\b\d+(?:\.\d+)?\s*(tops|ghz|gb|mb|fps|v|a|w)\b", normalized): + score += 2.0 + if _is_low_signal(text): + score -= 8.0 + return score + + +def _is_evidence_candidate(text: str) -> bool: + stripped = text.lstrip() + return not stripped.startswith("|") and not stripped.startswith(">") + + +def _is_low_signal(text: str) -> bool: + stripped = text.strip() + without_marks = re.sub(r"[*_`#\-\s]+", "", stripped) + if len(without_marks) < 8: + return True + if stripped.startswith("```") or "```" in stripped: + return True + if stripped.startswith("|"): + return True + if "![](" in stripped: + return True + if re.search(r"(^|\n)\s*[├│└─]{2,}", stripped): + return True + return False + + +def _tags(kb: KnowledgeBaseConfig, chunk: Chunk, alias_group: Any | None) -> list[str]: + tags = [kb.name] + if alias_group is not None: + tags.append(_slug(str(alias_group.name)).replace("--", "-")) + for token in re.findall(r"[a-zA-Z][a-zA-Z0-9_-]{2,}", chunk.title): + lowered = token.lower() + if lowered not in tags: + tags.append(lowered) + return tags[:8] + + +def _aliases(title: str, query_entry: Any | None, alias_group: Any | None) -> list[str]: + values = [title] + if query_entry is not None: + values.extend(str(item) for item in getattr(query_entry, "aliases", ())) + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + return _unique(values)[:12] + + +def _related_links(query_entry: Any | None, alias_group: Any | None) -> list[str]: + links: list[str] = [] + if query_entry is not None: + links.extend(str(item) for item in getattr(query_entry, "supporting_sources", ())) + if alias_group is not None: + links.extend(str(item) for item in getattr(alias_group, "related", ())) + return _unique(links)[:10] + + +def _unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + cleaned = value.strip() + if not cleaned or cleaned in seen: + continue + seen.add(cleaned) + output.append(cleaned) + return output + + +def _normalize_phrase(value: str) -> str: + return re.sub(r"\s+", " ", value.lower()).strip() + + +def _write_schema(wiki_root: Path, kb: KnowledgeBaseConfig) -> None: + (wiki_root / "SCHEMA.md").write_text( + "\n".join( + [ + "# Wiki Schema", + "", + "## Domain", + f"Compiled local knowledge for `{kb.name}`.", + "", + "## Conventions", + "- Pages live under `concepts/`.", + "- Every page has frontmatter with title, summary, sources, tags, aliases, confidence, and provenanceState.", + "- Claims in Key Evidence keep provenance markers pointing back to source block ids.", + "- Raw source files remain immutable; compiled pages are generated artifacts.", + "", + ] + ), + encoding="utf-8", + ) + + +def _write_index(wiki_root: Path, pages: list[CompiledPage]) -> None: + lines = ["# Index", "", "> Content catalog for compiled d-wiki pages.", "", "## Concepts", ""] + for page in sorted(pages, key=lambda item: item.title): + rel = page.path.relative_to(wiki_root).as_posix() + lines.append(f"- [[{rel[:-3]}]] — {page.title}") + lines.append("") + (wiki_root / "index.md").write_text("\n".join(lines), encoding="utf-8") + + +def _append_log(wiki_root: Path, kb: KnowledgeBaseConfig, chunks: int, pages: int) -> None: + line = f"- {datetime.now(timezone.utc).isoformat()} compiled `{kb.name}` from {chunks} chunks into {pages} pages.\n" + path = wiki_root / "log.md" + if not path.exists(): + path.write_text("# Log\n\n", encoding="utf-8") + with path.open("a", encoding="utf-8") as handle: + handle.write(line) + + +def _slug(value: str) -> str: + slug = re.sub(r"[^0-9A-Za-z\u4e00-\u9fff]+", "-", value).strip("-").lower() + return slug or "page" + + +def _yaml_scalar(value: str) -> str: + import json + + return json.dumps(value, ensure_ascii=False) + + +def _yaml_list(values: list[str]) -> str: + return "[" + ", ".join(_yaml_scalar(value) for value in values) + "]" + + +def json_dumps(value: Any) -> str: + return json.dumps(value, ensure_ascii=False, indent=2) diff --git a/build/lib/d_wiki/config.py b/build/lib/d_wiki/config.py new file mode 100644 index 0000000..b8bee1e --- /dev/null +++ b/build/lib/d_wiki/config.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import os +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .yaml_compat import safe_load + + +@dataclass(frozen=True) +class KnowledgeBaseConfig: + name: str + root: Path + source_type: str + aliases_path: Path | None + queries_dir: Path | None + + +@dataclass(frozen=True) +class DWikiConfig: + path: Path + knowledge_bases: dict[str, KnowledgeBaseConfig] + + +def default_config_path() -> Path: + return Path(os.environ.get("D_WIKI_CONFIG", Path.cwd() / "d-wiki.yml")).expanduser() + + +def load_config(path: Path | None = None) -> DWikiConfig: + config_path = (path or default_config_path()).expanduser().resolve() + data = safe_load(config_path.read_text(encoding="utf-8")) or {} + raw_kbs = data.get("knowledge_bases") + if not isinstance(raw_kbs, dict): + raise ValueError("D_WIKI_CONFIG_MISSING_KNOWLEDGE_BASES") + bases: dict[str, KnowledgeBaseConfig] = {} + for name, raw in raw_kbs.items(): + if not isinstance(raw, dict): + raise ValueError(f"D_WIKI_KB_INVALID: {name}") + root = Path(str(raw.get("root", ""))).expanduser() + if not root.is_absolute(): + root = (config_path.parent / root).resolve() + aliases_path = _optional_path(config_path.parent, raw.get("aliases")) + queries_dir = _optional_path(config_path.parent, raw.get("queries")) + bases[str(name)] = KnowledgeBaseConfig( + name=str(name), + root=root, + source_type=str(raw.get("source_type", "markdown")), + aliases_path=aliases_path, + queries_dir=queries_dir, + ) + return DWikiConfig(path=config_path, knowledge_bases=bases) + + +def _optional_path(base: Path, value: Any) -> Path | None: + if not value: + return None + path = Path(str(value)).expanduser() + return path if path.is_absolute() else (base / path).resolve() diff --git a/build/lib/d_wiki/dreams.py b/build/lib/d_wiki/dreams.py new file mode 100644 index 0000000..ffec505 --- /dev/null +++ b/build/lib/d_wiki/dreams.py @@ -0,0 +1,227 @@ +from __future__ import annotations + +import re +import shutil +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .metadata import frontmatter, load_query_entries + + +@dataclass(frozen=True) +class DreamedQuery: + slug: str + title: str + aliases: tuple[str, ...] + intent: str + primary_sources: tuple[str, ...] + supporting_sources: tuple[str, ...] + answer_requirements: tuple[str, ...] + + +def dream_kb(kb: KnowledgeBaseConfig, *, force: bool = False) -> dict[str, Any]: + wiki_root = kb.root / ".d_wiki" / "wiki" + if not wiki_root.is_dir(): + raise ValueError("D_WIKI_DREAM_REQUIRES_COMPILED_WIKI") + output_root = dream_root(kb) + queries_dir = output_root / "queries" + if force: + shutil.rmtree(output_root, ignore_errors=True) + queries_dir.mkdir(parents=True, exist_ok=True) + + pages = sorted((wiki_root / "concepts").glob("*.md")) + dreamed = [_dream_page(path, wiki_root) for path in pages] + dreamed = [item for item in dreamed if item is not None] + for item in dreamed: + (queries_dir / f"{item.slug}.md").write_text(_query_markdown(item), encoding="utf-8") + (output_root / "README.md").write_text(_readme(kb, len(pages), len(dreamed)), encoding="utf-8") + return { + "status": "dreamed", + "kb": kb.name, + "input_wiki": str(wiki_root), + "output_store": str(output_root), + "queries": len(dreamed), + "dreamed_at": datetime.now(timezone.utc).isoformat(), + } + + +def load_dream_query_entries(kb: KnowledgeBaseConfig) -> list[Any]: + return load_query_entries(dream_root(kb) / "queries") + + +def dream_root(kb: KnowledgeBaseConfig) -> Path: + return kb.root / ".d_wiki" / "dreams" / "latest" + + +def _dream_page(path: Path, wiki_root: Path) -> DreamedQuery | None: + meta, body = frontmatter(path.read_text(encoding="utf-8", errors="ignore")) + title = str(meta.get("title") or "").strip() + if not title: + return None + curation_body = _curation_body(body) + source = _first(meta.get("sources")) or _wikilink_for_compiled(path, wiki_root) + aliases = _unique([title, *_dream_aliases(title, curation_body)]) + intent = _first(meta.get("intents")) or _dream_intent(title, curation_body) + requirements = _as_list(meta.get("answer_requirements")) or _dream_requirements(title, curation_body, intent) + supporting = _related_sources(body, source) + return DreamedQuery( + slug=path.stem, + title=title, + aliases=tuple(aliases[:18]), + intent=intent, + primary_sources=(source,), + supporting_sources=tuple(supporting[:6]), + answer_requirements=tuple(requirements[:8]), + ) + + +def _dream_aliases(title: str, body: str) -> list[str]: + text = f"{title}\n{body}".lower() + aliases = [ + f"{title}怎么用", + f"如何使用{title}", + ] + if _looks_like_3d_generation(title, text): + aliases.extend( + [ + "3D资产生成怎么用", + "如何使用 3D 资产生成功能", + "我想知道如何使用3d资产生成功能", + "图生3D怎么用", + "如何生成3D模型", + "如何把图片生成3D资产", + ] + ) + if "camera" in text and any(term in text for term in ("点亮", "bring up", "sensor")): + aliases.extend(["如何在X5平台上点亮camera", "X5 camera 点亮", "X5 摄像头 bring up"]) + if any(term in text for term in ("算力", "tops", "bpu")): + aliases.extend(["x5的算力是多少", "X5 BPU 算力"]) + return aliases + + +def _dream_intent(title: str, body: str) -> str: + text = f"{title}\n{body}".lower() + if any(term in text for term in ("如何", "怎么", "步骤", "使用", "创建", "配置", "点亮", "生成", "调试", "bring up")): + return "procedure" + return "fact" + + +def _dream_requirements(title: str, body: str, intent: str) -> list[str]: + text = f"{title}\n{body}".lower() + if _looks_like_3d_generation(title, text): + return [ + "说明 3D 生成是图生 3D 工具,不是镜像资产", + "按准备参考图、生成、保存到 3D 资产的流程回答", + "说明输出默认 glb,生成结果可保存到 3D 资产", + "提醒暂不支持文生 3D,文字描述可先用图像生成产图", + ] + if intent == "procedure": + return ["按步骤回答", "说明关键前提和入口", "引用证据来源"] + return ["直接回答问题", "引用证据来源"] + + +def _looks_like_3d_generation(title: str, text: str) -> bool: + title_text = title.lower() + return ( + "3d 生成" in title_text + or "3d生成" in title_text + or "3d 资产生成" in title_text + or "3d资产生成" in title_text + or "embodygen" in text + or "ai 图生 3d 工具" in text + or "ai 图生3d 工具" in text + ) + + +def _curation_body(body: str) -> str: + lines: list[str] = [] + skip = False + for line in body.splitlines(): + if line.startswith("## "): + skip = line.strip() in {"## Retrieval Hints", "## Related"} + if skip: + continue + if not skip: + lines.append(line) + return "\n".join(lines) + + +def _related_sources(body: str, primary: str) -> list[str]: + links = re.findall(r"\[\[([^\]]+)\]\]", body) + refs = re.findall(r"\^\[([^#\]]+)(?:#[^\]]+)?\]", body) + return _unique([item for item in [*links, *refs] if item and item != primary]) + + +def _query_markdown(item: DreamedQuery) -> str: + lines = [ + "---", + f"title: {_yaml_scalar(item.title)}", + f"aliases: {_yaml_list(item.aliases)}", + f"intent: {item.intent}", + f"primary_sources: {_yaml_list(item.primary_sources)}", + f"supporting_sources: {_yaml_list(item.supporting_sources)}", + f"answer_requirements: {_yaml_list(item.answer_requirements)}", + "provenance: dreamed", + "---", + "", + f"Dreamed query memory for {item.title}.", + "", + ] + return "\n".join(lines) + + +def _readme(kb: KnowledgeBaseConfig, pages: int, queries: int) -> str: + return "\n".join( + [ + "# d-wiki dream output", + "", + "This store is generated from the compiled wiki. It does not modify source documents or compiled concept pages.", + "", + f"- kb: `{kb.name}`", + f"- input_pages: {pages}", + f"- dreamed_queries: {queries}", + "", + ] + ) + + +def _first(value: Any) -> str: + items = _as_list(value) + return items[0] if items else "" + + +def _as_list(value: Any) -> list[str]: + if isinstance(value, str): + return [value] + if isinstance(value, list): + return [str(item).strip() for item in value if str(item).strip()] + return [] + + +def _unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + cleaned = re.sub(r"\s+", " ", str(value)).strip() + if not cleaned or cleaned in seen: + continue + seen.add(cleaned) + output.append(cleaned) + return output + + +def _wikilink_for_compiled(path: Path, wiki_root: Path) -> str: + return path.relative_to(wiki_root).with_suffix("").as_posix() + + +def _yaml_scalar(value: str) -> str: + import json + + return json.dumps(value, ensure_ascii=False) + + +def _yaml_list(values: tuple[str, ...] | list[str]) -> str: + return "[" + ", ".join(_yaml_scalar(value) for value in values) + "]" diff --git a/build/lib/d_wiki/llm.py b/build/lib/d_wiki/llm.py new file mode 100644 index 0000000..959e902 --- /dev/null +++ b/build/lib/d_wiki/llm.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import json +import os +import urllib.error +import urllib.request +from dataclasses import dataclass +from typing import Any + + +@dataclass(frozen=True) +class LlmSettings: + base_url: str + model: str + api_key: str + api_style: str = "anthropic" + max_tokens: int = 900 + + +@dataclass(frozen=True) +class LlmPageSynthesis: + summary: str + answer_blueprint: tuple[str, ...] + key_evidence: tuple[str, ...] + confidence: str = "medium" + + +class LlmPageSynthesizer: + def __init__(self, settings: LlmSettings) -> None: + self.settings = settings + + @classmethod + def from_environment(cls) -> "LlmPageSynthesizer | None": + base_url = os.environ.get("D_WIKI_LLM_BASE_URL") or os.environ.get("ROBOGO_LLM_BASE_URL") + model = os.environ.get("D_WIKI_LLM_MODEL") or os.environ.get("ROBOGO_LLM_MODEL") + api_key = os.environ.get("D_WIKI_LLM_API_KEY") or os.environ.get("ROBOGO_LLM_API_KEY") + if not base_url or not model or not api_key: + return None + api_style = os.environ.get("D_WIKI_LLM_API_STYLE") or os.environ.get("ROBOGO_LLM_API_STYLE") or "anthropic" + max_tokens = int(os.environ.get("D_WIKI_LLM_MAX_TOKENS", "900")) + return cls(LlmSettings(base_url=base_url, model=model, api_key=api_key, api_style=api_style, max_tokens=max_tokens)) + + def synthesize(self, prompt: str) -> LlmPageSynthesis | None: + text = self._complete(prompt).strip() + payload = _extract_json(text) + if not isinstance(payload, dict): + return None + summary = str(payload.get("summary") or "").strip() + if not summary: + return None + answer_blueprint = _string_tuple(payload.get("answer_blueprint")) + key_evidence = _string_tuple(payload.get("key_evidence")) + confidence = str(payload.get("confidence") or "medium").strip().lower() + if confidence not in {"low", "medium", "high"}: + confidence = "medium" + return LlmPageSynthesis( + summary=summary, + answer_blueprint=answer_blueprint, + key_evidence=key_evidence, + confidence=confidence, + ) + + def _complete(self, prompt: str) -> str: + if self.settings.api_style == "openai": + return self._complete_openai(prompt) + return self._complete_anthropic(prompt) + + def _complete_anthropic(self, prompt: str) -> str: + payload = { + "model": self.settings.model, + "max_tokens": self.settings.max_tokens, + "temperature": 0, + "system": "You compile local documentation into concise, evidence-grounded wiki pages. Return only JSON.", + "messages": [{"role": "user", "content": prompt}], + } + data = self._post_json(_join_url(self.settings.base_url, "v1/messages"), payload) + content = data.get("content") + if isinstance(content, list): + return "\n".join(str(item.get("text", "")) for item in content if isinstance(item, dict)) + return str(data.get("text") or "") + + def _complete_openai(self, prompt: str) -> str: + payload = { + "model": self.settings.model, + "temperature": 0, + "messages": [ + { + "role": "system", + "content": "You compile local documentation into concise, evidence-grounded wiki pages. Return only JSON.", + }, + {"role": "user", "content": prompt}, + ], + } + data = self._post_json(_join_url(self.settings.base_url, "v1/chat/completions"), payload) + choices = data.get("choices") + if isinstance(choices, list) and choices: + first = choices[0] + if isinstance(first, dict): + message = first.get("message") + if isinstance(message, dict): + return str(message.get("content") or "") + return "" + + def _post_json(self, url: str, payload: dict[str, Any]) -> dict[str, Any]: + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + request = urllib.request.Request( + url, + data=body, + method="POST", + headers={ + "content-type": "application/json", + "accept": "application/json", + "x-api-key": self.settings.api_key, + "authorization": f"Bearer {self.settings.api_key}", + "anthropic-version": "2023-06-01", + }, + ) + try: + with urllib.request.urlopen(request, timeout=60) as response: + return json.loads(response.read().decode("utf-8")) + except urllib.error.HTTPError as exc: + detail = exc.read().decode("utf-8", errors="ignore") + raise RuntimeError(f"D_WIKI_LLM_HTTP_ERROR: {exc.code} {detail[:300]}") from exc + + +def _join_url(base_url: str, suffix: str) -> str: + base = base_url.rstrip("/") + if base.endswith("/v1/messages") or base.endswith("/v1/chat/completions"): + return base + if base.endswith("/v1"): + return f"{base}/{suffix.removeprefix('v1/')}" + return f"{base}/{suffix}" + + +def _extract_json(text: str) -> Any: + cleaned = text.strip() + if cleaned.startswith("```"): + cleaned = cleaned.strip("`") + if cleaned.lower().startswith("json"): + cleaned = cleaned[4:].strip() + decoder = json.JSONDecoder() + for index, char in enumerate(cleaned): + if char != "{": + continue + try: + value, _end = decoder.raw_decode(cleaned[index:]) + except json.JSONDecodeError: + continue + return value + return None + + +def _string_tuple(value: Any) -> tuple[str, ...]: + if not isinstance(value, list): + return () + return tuple(str(item).strip() for item in value if str(item).strip()) diff --git a/build/lib/d_wiki/metadata.py b/build/lib/d_wiki/metadata.py new file mode 100644 index 0000000..dd41dfd --- /dev/null +++ b/build/lib/d_wiki/metadata.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +import re +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .yaml_compat import safe_load +from .tokenize import tokenize + +QUERY_MATCH_STOP_TOKENS = { + "如何", + "怎么", + "使用", + "创建", + "知道", + "功能", + "资产", +} + + +@dataclass(frozen=True) +class AliasGroup: + name: str + terms: tuple[str, ...] + intent: str | None + related: tuple[str, ...] + + +@dataclass(frozen=True) +class QueryEntry: + path: Path + title: str + aliases: tuple[str, ...] + intent: str | None + primary_sources: tuple[str, ...] + supporting_sources: tuple[str, ...] + answer_requirements: tuple[str, ...] + + +def load_alias_groups(path: Path | None) -> list[AliasGroup]: + if path is None or not path.exists(): + return [] + data = safe_load(path.read_text(encoding="utf-8")) or {} + raw_aliases = data.get("aliases", {}) + if not isinstance(raw_aliases, dict): + return [] + groups: list[AliasGroup] = [] + for name, raw in raw_aliases.items(): + if not isinstance(raw, dict): + continue + groups.append( + AliasGroup( + name=str(name), + terms=tuple(str(term).strip() for term in raw.get("terms", []) if str(term).strip()), + intent=str(raw["intent"]) if raw.get("intent") else None, + related=tuple(str(item).strip() for item in raw.get("related", []) if str(item).strip()), + ) + ) + return groups + + +def load_query_entries(directory: Path | None) -> list[QueryEntry]: + if directory is None or not directory.exists(): + return [] + return [_query_entry(path) for path in sorted(directory.rglob("*.md")) if path.is_file()] + + +def frontmatter(text: str) -> tuple[dict[str, Any], str]: + if not text.startswith("---\n"): + return {}, text + end = text.find("\n---", 4) + if end < 0: + return {}, text + meta = safe_load(text[4:end]) or {} + if not isinstance(meta, dict): + meta = {} + return meta, text[end + 4 :].lstrip("\n") + + +def query_matches_entry(query: str, entry: QueryEntry) -> bool: + normalized = normalize(query) + if any(normalize(alias) in normalized or normalized in normalize(alias) for alias in entry.aliases): + return True + query_terms = _meaningful_query_terms(query) + for candidate in (entry.title, *entry.aliases): + candidate_terms = _meaningful_query_terms(candidate) + if len(query_terms & candidate_terms) >= 2: + return True + return False + + +def _meaningful_query_terms(value: str) -> set[str]: + return {term for term in tokenize(value) if term not in QUERY_MATCH_STOP_TOKENS and len(term.strip()) >= 2} + + +def normalize(value: str) -> str: + return re.sub(r"\s+", " ", value.lower()).strip() + + +def _query_entry(path: Path) -> QueryEntry: + meta, body = frontmatter(path.read_text(encoding="utf-8")) + title = str(meta.get("title") or _first_heading(body) or path.stem) + return QueryEntry( + path=path, + title=title, + aliases=tuple(str(item).strip() for item in meta.get("aliases", []) if str(item).strip()), + intent=str(meta["intent"]) if meta.get("intent") else None, + primary_sources=tuple(str(item).strip() for item in meta.get("primary_sources", []) if str(item).strip()), + supporting_sources=tuple(str(item).strip() for item in meta.get("supporting_sources", []) if str(item).strip()), + answer_requirements=tuple(str(item).strip() for item in meta.get("answer_requirements", []) if str(item).strip()), + ) + + +def _first_heading(text: str) -> str | None: + for line in text.splitlines(): + if match := re.match(r"^#{1,6}\s+(.+)$", line): + return match.group(1).strip() + return None diff --git a/build/lib/d_wiki/search.py b/build/lib/d_wiki/search.py new file mode 100644 index 0000000..07e396f --- /dev/null +++ b/build/lib/d_wiki/search.py @@ -0,0 +1,469 @@ +from __future__ import annotations + +import json +import math +import re +from collections import Counter, defaultdict +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .metadata import ( + AliasGroup, + QueryEntry, + frontmatter, + load_alias_groups, + load_query_entries, + normalize, + query_matches_entry, +) +from .dreams import load_dream_query_entries +from .tokenize import tokenize + +SPHINX_SOURCE_SUFFIXES = (".md.txt", ".rst.txt") +MAX_BLOCK_CHARS = 520 + + +@dataclass(frozen=True) +class Chunk: + title: str + wikilink: str + source_path: Path + page_type: str + heading: str + text: str + tokens: tuple[str, ...] + index: int + + +def status_payload(config_path: Path, bases: dict[str, KnowledgeBaseConfig]) -> dict[str, Any]: + return { + "status": "ok", + "config": str(config_path), + "knowledge_bases": { + name: { + "root": str(kb.root), + "source_type": kb.source_type, + "exists": kb.root.exists(), + "aliases": str(kb.aliases_path) if kb.aliases_path else None, + "queries": str(kb.queries_dir) if kb.queries_dir else None, + } + for name, kb in bases.items() + }, + } + + +def index_payload(kb: KnowledgeBaseConfig) -> dict[str, Any]: + chunks = load_chunks(kb) + index_dir = kb.root / ".d_wiki_index" + index_dir.mkdir(exist_ok=True) + payload = { + "kb": kb.name, + "root": str(kb.root), + "source_type": kb.source_type, + "compiled_wiki": str(compiled_wiki_root(kb)) if compiled_wiki_root(kb).exists() else None, + "chunks": len(chunks), + "pages": len({chunk.wikilink for chunk in chunks}), + "indexed_at": datetime.now(timezone.utc).isoformat(), + } + (index_dir / f"{kb.name}.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8") + return {"status": "indexed", **payload} + + +def search(kb: KnowledgeBaseConfig, query: str, max_results: int = 5) -> dict[str, Any]: + aliases = load_alias_groups(kb.aliases_path) + query_entries = [*load_query_entries(kb.queries_dir), *load_dream_query_entries(kb)] + matched_entries = [entry for entry in query_entries if query_matches_entry(query, entry)] + expanded_terms, matched_aliases = expand_query(query, aliases, matched_entries) + chunks = load_chunks(kb) + ranked = rank_chunks(chunks, expanded_terms, matched_aliases, matched_entries) + selected = ranked[: max(1, min(max_results, 8))] + context_pack = build_context_pack(query, selected, matched_aliases, matched_entries) + return { + "status": "found" if selected else "no_match", + "query": query, + "knowledge_base": kb.name, + "backend": "lightweight_bm25", + "quality": quality(selected), + "sources": [source_summary(item[1], item[0]) for item in selected], + "context_pack": context_pack, + } + + +def get_page(kb: KnowledgeBaseConfig, wikilink: str) -> dict[str, Any]: + chunks = [chunk for chunk in load_chunks(kb) if chunk.wikilink == wikilink] + if not chunks: + return {"status": "not_found", "knowledge_base": kb.name, "id": wikilink} + first = chunks[0] + return { + "status": "found", + "knowledge_base": kb.name, + "id": wikilink, + "title": first.title, + "source_path": str(first.source_path), + "blocks": [ + {"heading": chunk.heading, "text": chunk.text, "block_id": f"{chunk.wikilink}#{chunk.index}"} + for chunk in chunks + ], + } + + +def expand_query( + query: str, + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> tuple[list[str], list[AliasGroup]]: + terms = tokenize(query) + normalized_query = normalize(query) + matched: list[AliasGroup] = [] + for group in aliases: + if any(normalize(term) in normalized_query for term in group.terms): + matched.append(group) + for term in group.terms: + terms.extend(tokenize(term)) + for entry in entries: + terms.extend(tokenize(entry.title)) + for alias in entry.aliases: + terms.extend(tokenize(alias)) + return terms, matched + + +def rank_chunks( + chunks: list[Chunk], + terms: list[str], + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> list[tuple[float, Chunk]]: + if not chunks or not terms: + return [] + term_counts = [Counter(chunk.tokens) for chunk in chunks] + doc_freq: Counter[str] = Counter() + for counts in term_counts: + for term in counts: + doc_freq[term] += 1 + avg_len = sum(len(chunk.tokens) for chunk in chunks) / max(1, len(chunks)) + query_counts = Counter(terms) + ranked: list[tuple[float, Chunk]] = [] + related = {item for group in aliases for item in group.related} + primary = {item for entry in entries for item in entry.primary_sources} + supporting = {item for entry in entries for item in entry.supporting_sources} + for chunk, counts in zip(chunks, term_counts): + score = bm25_score(counts, len(chunk.tokens), doc_freq, len(chunks), avg_len, query_counts) + if any(wikilink_matches(chunk.wikilink, item) for item in related): + score += 8.0 + if any(wikilink_matches(chunk.wikilink, item) for item in primary): + score += 16.0 + if any(wikilink_matches(chunk.wikilink, item) for item in supporting): + score += 5.0 + score += heading_score_adjustment(chunk.heading) + if score > 0: + ranked.append((round(score, 3), chunk)) + ranked.sort(key=lambda item: (-item[0], item[1].wikilink, item[1].index)) + return ranked + + +def heading_score_adjustment(heading: str) -> float: + if heading == "Retrieval Hints": + return -80.0 + if heading == "Intent Model": + return -40.0 + if heading == "Answer Blueprint": + return -25.0 + if heading == "Evidence Graph": + return 3.0 + if heading == "Key Evidence": + return 5.0 + return 0.0 + + +def bm25_score( + counts: Counter[str], + doc_len: int, + doc_freq: Counter[str], + doc_count: int, + avg_len: float, + query_counts: Counter[str], +) -> float: + k1 = 1.5 + b = 0.75 + score = 0.0 + for term, qf in query_counts.items(): + tf = counts.get(term, 0) + if tf == 0: + continue + idf = math.log(1 + (doc_count - doc_freq[term] + 0.5) / (doc_freq[term] + 0.5)) + denom = tf + k1 * (1 - b + b * (doc_len / max(avg_len, 1))) + score += idf * ((tf * (k1 + 1)) / denom) * min(qf, 3) + return score + + +def build_context_pack( + query: str, + selected: list[tuple[float, Chunk]], + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> dict[str, Any]: + intent = answer_intent(query, aliases, entries) + grouped: dict[str, list[tuple[float, Chunk]]] = defaultdict(list) + for item in selected: + grouped[item[1].wikilink].append(item) + source_items = sorted(grouped.items(), key=lambda pair: -max(score for score, _chunk in pair[1])) + entry_primary = {item for entry in entries for item in entry.primary_sources} + primary_sources = [ + source_context(wikilink, chunks) + for wikilink, chunks in source_items + if not entry_primary or any(wikilink_matches(wikilink, item) for item in entry_primary) + ] + if not primary_sources: + primary_sources = [source_context(wikilink, chunks) for wikilink, chunks in source_items[:3]] + supporting_sources = [ + source_context(wikilink, chunks, blocks_limit=1) + for wikilink, chunks in source_items + if wikilink not in {source["wikilink"] for source in primary_sources} + ][:3] + coverage = "insufficient" if not selected else ("partial_procedure" if intent == "procedure" else "complete") + return { + "answer_intent": intent, + "coverage": coverage, + "answer_policy": "Use the evidence blocks to synthesize the answer. Do not answer from a single snippet.", + "primary_sources": primary_sources, + "supporting_sources": supporting_sources, + "answer_requirements": answer_requirements(intent, entries), + } + + +def source_context(wikilink: str, chunks: list[tuple[float, Chunk]], blocks_limit: int = 4) -> dict[str, Any]: + top = sorted(chunks, key=lambda item: (-item[0], item[1].index))[:blocks_limit] + chunk = top[0][1] + return { + "title": chunk.title, + "wikilink": wikilink, + "source_path": str(chunk.source_path), + "reason": "Matched query terms and local metadata.", + "blocks": [ + { + "block_id": f"{block.wikilink}#{block.index}", + "heading": block.heading, + "text": trim_block(block.text), + "score": score, + } + for score, block in top + ], + } + + +def answer_intent(query: str, aliases: list[AliasGroup], entries: list[QueryEntry]) -> str: + for entry in entries: + if entry.intent: + return entry.intent + for group in aliases: + if group.intent: + return group.intent + if any(term in query.lower() for term in ("如何", "怎么", "步骤", "点亮", "bring up", "配置")): + return "procedure" + return "fact" + + +def answer_requirements(intent: str, entries: list[QueryEntry]) -> list[str]: + requirements = unique([req for entry in entries for req in entry.answer_requirements]) + if requirements: + return requirements + if intent == "procedure": + return ["基于 primary_sources 综合步骤化回答", "说明关键前提和验证方式", "引用命中的来源"] + return ["直接回答问题", "引用命中的来源"] + + +def unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + if value in seen: + continue + seen.add(value) + output.append(value) + return output + + +def quality(selected: list[tuple[float, Chunk]]) -> dict[str, Any]: + top = selected[0][0] if selected else 0.0 + return { + "confidence": "high" if top >= 8.0 else ("low" if selected else "none"), + "high_confidence": top >= 8.0, + "top_score": top, + "high_confidence_score": 8.0, + } + + +def wikilink_matches(candidate: str, expected: str) -> bool: + return candidate == expected or candidate == f"concepts/{expected}" + + +def source_summary(chunk: Chunk, score: float) -> dict[str, Any]: + return { + "title": chunk.title, + "wikilink": chunk.wikilink, + "source_path": str(chunk.source_path), + "heading": chunk.heading, + "snippet": trim_block(chunk.text, 320), + "score": score, + } + + +def load_chunks(kb: KnowledgeBaseConfig) -> list[Chunk]: + root = compiled_wiki_root(kb) if compiled_wiki_root(kb).is_dir() else kb.root + paths = source_paths(root) + chunks: list[Chunk] = [] + for path in paths: + chunks.extend(chunks_for_path(path, root)) + return chunks + + +def load_source_chunks(kb: KnowledgeBaseConfig) -> list[Chunk]: + chunks: list[Chunk] = [] + for path in source_paths(kb.root): + chunks.extend(chunks_for_path(path, kb.root)) + return chunks + + +def compiled_wiki_root(kb: KnowledgeBaseConfig) -> Path: + return kb.root / ".d_wiki" / "wiki" + + +def source_paths(root: Path) -> list[Path]: + if (root / "_sources").is_dir(): + return sorted( + path + for path in (root / "_sources").rglob("*.txt") + if path.is_file() and path.name.endswith(SPHINX_SOURCE_SUFFIXES) + ) + generated = {"SCHEMA.md", "index.md", "log.md"} + generated_dirs = {".d_wiki", ".d_wiki_index"} + is_compiled_root = root.name == "wiki" and root.parent.name == ".d_wiki" + return sorted( + path + for path in root.rglob("*.md") + if path.is_file() + and path.name not in generated + and (is_compiled_root or not any(part in generated_dirs for part in path.parts)) + ) + + +def chunks_for_path(path: Path, root: Path) -> list[Chunk]: + raw = path.read_text(encoding="utf-8", errors="ignore") + meta, body = frontmatter(raw) + title = str(meta.get("title") or first_heading(body) or path.stem.replace("-", " ").title()) + metadata_text = metadata_terms(meta) + wikilink = wikilink_for(path, root) + sections = split_sections(body, title) + chunks: list[Chunk] = [] + for index, (heading, text) in enumerate(sections): + if heading in {"Source Map", "Related"}: + continue + if not text.strip(): + continue + field_text = " ".join([title, heading, wikilink, metadata_text, text]) + chunks.append( + Chunk( + title=title, + wikilink=wikilink, + source_path=path.resolve(), + page_type="sphinx_source" if "_sources" in path.parts else "markdown", + heading=heading, + text=text.strip(), + tokens=tuple(tokenize(field_text)), + index=index, + ) + ) + return chunks + + +def metadata_terms(meta: dict[str, Any]) -> str: + values: list[str] = [] + for key in ("aliases", "tags", "intents", "related", "retrieval_hints", "answer_requirements"): + raw = meta.get(key) + if isinstance(raw, str): + values.append(raw) + elif isinstance(raw, list): + values.extend(str(item) for item in raw if str(item).strip()) + return " ".join(values) + + +def split_sections(body: str, title: str) -> list[tuple[str, str]]: + heading = title + buffer: list[str] = [] + sections: list[tuple[str, str]] = [] + in_fence = False + for line in body.splitlines(): + stripped = line.strip() + if stripped.startswith("```"): + in_fence = not in_fence + buffer.append(line) + continue + if not in_fence and (match := re.match(r"^#{1,6}\s+(.+)$", line)): + if buffer: + sections.extend(paragraphs(heading, "\n".join(buffer))) + buffer = [] + heading = match.group(1).strip() or title + continue + buffer.append(line) + if buffer: + sections.extend(paragraphs(heading, "\n".join(buffer))) + return sections or [(title, body)] + + +def paragraphs(heading: str, text: str) -> list[tuple[str, str]]: + blocks: list[tuple[str, str]] = [] + for part in re.split(r"\n\s*\n", text): + cleaned = clean_block(part) + if cleaned: + blocks.append((heading, cleaned)) + return blocks + + +def clean_block(text: str) -> str: + stripped = text.strip() + if not stripped: + return "" + if re.fullmatch(r"[-*_]{3,}", stripped): + return "" + compact = " ".join(stripped.split()) + if "📷" in compact and len(compact) <= 80: + return "" + if compact.startswith("> 📷") and len(compact) <= 120: + return "" + return stripped + + +def first_heading(body: str) -> str | None: + in_fence = False + for line in body.splitlines(): + stripped = line.strip() + if stripped.startswith("```"): + in_fence = not in_fence + continue + if in_fence: + continue + if match := re.match(r"^#{1,6}\s+(.+)$", line): + return match.group(1).strip() + return None + + +def wikilink_for(path: Path, root: Path) -> str: + try: + relative = path.relative_to(root) + except ValueError: + return path.stem + if relative.parts and relative.parts[0] == "_sources": + relative = Path(*relative.parts[1:]) + value = relative.as_posix() + for suffix in SPHINX_SOURCE_SUFFIXES: + if value.endswith(suffix): + return value[: -len(suffix)] + return value[:-3] if value.endswith(".md") else path.stem + + +def trim_block(text: str, limit: int = MAX_BLOCK_CHARS) -> str: + compact = " ".join(text.split()) + return compact if len(compact) <= limit else compact[:limit].rstrip() diff --git a/build/lib/d_wiki/tokenize.py b/build/lib/d_wiki/tokenize.py new file mode 100644 index 0000000..09823c6 --- /dev/null +++ b/build/lib/d_wiki/tokenize.py @@ -0,0 +1,22 @@ +from __future__ import annotations + +import re + +STOP_CJK = set("的是多少什么怎么如何吗呢啊了在上") +STOP_TERMS = {"x5", "如何", "怎么", "什么", "多少", "平台"} + + +def tokenize(text: str) -> list[str]: + lowered = text.lower() + terms = re.findall(r"[a-z0-9_./+-]+", lowered) + cjk_chars = re.findall(r"[\u4e00-\u9fff]", text) + terms.extend("".join(cjk_chars[index : index + 2]) for index in range(max(0, len(cjk_chars) - 1))) + return [term for term in terms if _useful(term)] + + +def _useful(term: str) -> bool: + if not term or term in STOP_TERMS: + return False + if re.search(r"[\u4e00-\u9fff]", term): + return not (all(char in STOP_CJK for char in term) or any(char in STOP_CJK for char in term)) + return True diff --git a/build/lib/d_wiki/yaml_compat.py b/build/lib/d_wiki/yaml_compat.py new file mode 100644 index 0000000..61cf7ab --- /dev/null +++ b/build/lib/d_wiki/yaml_compat.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +from typing import Any + +try: + import yaml as _yaml # type: ignore +except Exception: # pragma: no cover - exercised in environments without PyYAML + _yaml = None + + +def safe_load(text: str) -> Any: + if _yaml is not None: + return _yaml.safe_load(text) + lines = [ + (len(line) - len(line.lstrip(" ")), line.strip()) + for line in text.splitlines() + if line.strip() and not line.strip().startswith("#") + ] + value, _index = _parse_node(lines, 0, 0) + return value + + +def _parse_node(lines: list[tuple[int, str]], index: int, indent: int) -> tuple[Any, int]: + if index >= len(lines): + return {}, index + if lines[index][0] < indent: + return {}, index + if lines[index][1].startswith("- "): + values: list[Any] = [] + while index < len(lines) and lines[index][0] == indent and lines[index][1].startswith("- "): + values.append(_scalar(lines[index][1][2:].strip())) + index += 1 + return values, index + mapping: dict[str, Any] = {} + while index < len(lines): + current_indent, stripped = lines[index] + if current_indent < indent: + break + if current_indent > indent: + break + if ":" not in stripped: + index += 1 + continue + key, raw_value = stripped.split(":", 1) + key = key.strip() + raw_value = raw_value.strip() + index += 1 + if raw_value: + mapping[key] = _scalar(raw_value) + continue + child, index = _parse_node(lines, index, indent + 2) + mapping[key] = child + return mapping, index + + +def _scalar(value: str) -> Any: + if value in {"null", "None", "~"}: + return None + if value in {"true", "True"}: + return True + if value in {"false", "False"}: + return False + if value.startswith("[") and value.endswith("]"): + inner = value[1:-1].strip() + if not inner: + return [] + return [_scalar(item.strip()) for item in inner.split(",")] + if (value.startswith('"') and value.endswith('"')) or (value.startswith("'") and value.endswith("'")): + return value[1:-1] + return value diff --git a/d-wiki b/d-wiki new file mode 100755 index 0000000..bb3f6e8 --- /dev/null +++ b/d-wiki @@ -0,0 +1,5 @@ +#!/usr/bin/env python3 +from d_wiki.cli import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/d-wiki.yml b/d-wiki.yml new file mode 100644 index 0000000..17ebf2b --- /dev/null +++ b/d-wiki.yml @@ -0,0 +1,11 @@ +knowledge_bases: + x5: + root: "/Users/d-robotics/Desktop/evb/sdk_management_system/x5_user_manual/latest" + source_type: "sphinx" + aliases: "knowledge/x5/aliases.yml" + queries: "knowledge/x5/queries" + robogo: + root: "/Users/d-robotics/Documents/New project/read/robogo-user-guide" + source_type: "markdown" + aliases: "knowledge/robogo/aliases.yml" + queries: "knowledge/robogo/queries" diff --git a/d_wiki.egg-info/PKG-INFO b/d_wiki.egg-info/PKG-INFO new file mode 100644 index 0000000..36c79f0 --- /dev/null +++ b/d_wiki.egg-info/PKG-INFO @@ -0,0 +1,5 @@ +Metadata-Version: 2.4 +Name: d-wiki +Version: 0.1.0 +Summary: Lightweight local knowledge retrieval with BM25 and metadata context packs. +Requires-Python: >=3.10 diff --git a/d_wiki.egg-info/SOURCES.txt b/d_wiki.egg-info/SOURCES.txt new file mode 100644 index 0000000..589d687 --- /dev/null +++ b/d_wiki.egg-info/SOURCES.txt @@ -0,0 +1,19 @@ +README.md +pyproject.toml +d_wiki/__init__.py +d_wiki/__main__.py +d_wiki/cli.py +d_wiki/compile.py +d_wiki/config.py +d_wiki/dreams.py +d_wiki/llm.py +d_wiki/metadata.py +d_wiki/search.py +d_wiki/tokenize.py +d_wiki/yaml_compat.py +d_wiki.egg-info/PKG-INFO +d_wiki.egg-info/SOURCES.txt +d_wiki.egg-info/dependency_links.txt +d_wiki.egg-info/entry_points.txt +d_wiki.egg-info/top_level.txt +tests/test_d_wiki.py \ No newline at end of file diff --git a/d_wiki.egg-info/dependency_links.txt b/d_wiki.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/d_wiki.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/d_wiki.egg-info/entry_points.txt b/d_wiki.egg-info/entry_points.txt new file mode 100644 index 0000000..44b01d7 --- /dev/null +++ b/d_wiki.egg-info/entry_points.txt @@ -0,0 +1,2 @@ +[console_scripts] +d-wiki = d_wiki.cli:main diff --git a/d_wiki.egg-info/top_level.txt b/d_wiki.egg-info/top_level.txt new file mode 100644 index 0000000..c891388 --- /dev/null +++ b/d_wiki.egg-info/top_level.txt @@ -0,0 +1 @@ +d_wiki diff --git a/d_wiki/__init__.py b/d_wiki/__init__.py new file mode 100644 index 0000000..365f5d0 --- /dev/null +++ b/d_wiki/__init__.py @@ -0,0 +1,3 @@ +"""d-wiki lightweight local knowledge retrieval.""" + +__version__ = "0.1.0" diff --git a/d_wiki/__main__.py b/d_wiki/__main__.py new file mode 100644 index 0000000..bfdcd0c --- /dev/null +++ b/d_wiki/__main__.py @@ -0,0 +1,4 @@ +from .cli import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/d_wiki/__pycache__/__init__.cpython-311.pyc b/d_wiki/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8e3ec3ce3ce1b0cc296d1dc5a139418af0c2755 GIT binary patch literal 260 zcmZ3^%ge<81lzapW_bhY#~=<2FhUuh`GAb+3@Hpz3@MCJj44dP44TYUx+%Klnc0~N zIhpAhCFQ9gQXwZlIWb2eJ1@UHCp9HKRiP-gq$o4BEHOu~iq$~RP|v_mlj#8I!x3B|TN4D7B<0Gqo%+N3V+2K+jOmz)zFu7JGbrN`7*D z{4MVI__EZZ;>`TK`1q9!pFwv0a?}qk28!vY=oaNC<(Fh87wfy^Czs}?=9Lud`=ypE z6cpuWr6!jE6@YBlPl*Rp@$s2?nI-Y@dIgogIBatBQ%ZAE?TXleCW5?B%nKwwFf%eT R-efR-z$e^Md_YD6Ll8p=Ll9#LV-S-vgC=v8Zi;SsW_G4R zPG)*WNqH)WRLIFsPRvor&dV>)Nli&lRVYd=DauSOOU%)$Vl~h+)HCqYWV*#3AD@z+ z93Ov+J3hWFwWv5VKQBIhCBtWsZMPitLyLi8`YF0a`APXDnaRcaF8Rr&xv6<2#rl4! z^hOxYR?3`M+5 z45`dO%(xn=cr_!0(ZpEEtjY2c#M5NF#gdztnRkmLJ|0BJ$NOor++t47$t+?9N`r*+ z5_41I<8N^VR~DC~=DJp7maJs>3^M4Kqkd>{YEiL%if&PUQhrHha2KczG$)vkyeXd=i(#Y#Zp12ZEd n<6Q>P2h7|ZRhO70Z*qxD44E8unM>vZi_8aR1{SFzPM|UXy=F_k literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/__main__.cpython-314.pyc b/d_wiki/__pycache__/__main__.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..142d54ae2014e5ddf81362bb5348a2a833e46a34 GIT binary patch literal 297 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/cli.cpython-312.pyc b/d_wiki/__pycache__/cli.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d891e1bd99f4ccde6cd8f93f969286dbcc5d9187 GIT binary patch literal 4830 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/cli.cpython-314.pyc b/d_wiki/__pycache__/cli.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..795d0356c4a70414e9533b14128cc9608c579e7b GIT binary patch literal 5139 zcmb7IO>7&-6`m!R-n@D9e&+9e%VQ3^g+M7v?wfaPgnWq|t>_yB_swsC*d&WYqzseup%k3Tzo}R?Ws&sx()OO&Q*=F6sL(*)ggn)ysYsP95{nNEIj;RDYrzIMC&JP# zUyf#PN(lu7ZoxWCBx9^eq*Ety8>%f9Yp$LYi_t@%(Fs4fAF56A9XZC?zs9QU^ghP6 z_&n==1H*(xj06@d{8+^A7;t8kF|nG(*!GnpM1+Gi*<7t07vW}M*8U>uqDGB}Yc<(C zoL&O*W^JV1iU!drnkJj}a=M6a7QNb6MB$`nS0B-Lv}+bECpgg}TK8D&tjpHY#Ygy# zy6oVSL-Pqd?<{q2i_VrsL&R_(i=CyqM3>mT$FI&(Jtv4be2o*~^6goR&a!Utkmxy~ zgZh8V9z5Q@R=mcD@j&r*mf9b0XQ_kxb-3l1DPlU1U!A3%*>^rVOZ7+Lp>C8#!xJ~5 zv;4v17-+>IM1%vy(OGJ6UmTsKI{C%T;)}DdL`cgob3ci?wBd+(wp*jyZA;b?b!*)D z-<;H50&DcJ#*IFsQL_UY)ozcFIjiVh)IlsqC;0|n(+!D=3=+wu-4u_JGtf&H& zUeBkfgjtVeJDlIhJ}Q4x&SpT;lvvHC5|T_YXQ&32EDL-ffEkqzArJLpk}a6nx3tYD30NNp)Y5QR!#1qv(9lqGqOF04nmv01_%xkY zEe(LgCL(l^=@~R?(r}Vqx}A{iz#8@KDHJcL%CE;$89D0!h5zXzwa$6W!_Wc&+fQ9b=PRcHCha9^JUj))%D8e^rPOPdau9I z>o1N~d!OIDy2HEb{7{7-+A5STm(FZQ%KT7`fAvw%V7+Io(lb`{RC}J?e07KKs`G;t zesF8K2+bQ2d%XBU)qQF+yu)|bd2faH-Zz$d%e=S7 zpKi0vrQ?iszRfay{_ITo`p+19q0P2GFmInKPln2`McL4e_K>9%DFwHe8T;!0<#?)O zV@|*Pv{;_HSZ|bgwos?q>$g!l$yjIFtY3Wm+V&B~oN6_~*WtHC;MX61GQ~WayFARksdQtOHwfRqN5ssmD5l!L{px?!AS( z3ssl@9pi5IGg~LC-DB^Vz7>eU^4`e%S`&WwdA159R|6#R!`243*%`sP7SgbEdl?CZ0X@>#$-!|6Xeb8h;q{x4?@KtF-~5wkKRJOae`VSmJ{6MDe^CW^O!2B9i+ z!%brM?L;`fF2VgzNbFuwR7)`r797b`f_)(z_rV9w4cY@tcxrp0X?zl}JI1g)t6s)| zA3}wIzKi=Y_cg1_JwJHNh~m#1?Sr=(1JnbuiDvQyk`R2BSV(_n7d1j=8T-jfBximK zpEyS_B}SW2ogh@_pOnKMa9hy6J*p+_;irsu0{!3%`paIsp3`abR#8Tqu%{JuEJjE@ps@v8BCUDgdFOe0HZQ>DwZP20uM?O74Y-y23UFJ% zqdf#ru(`TVwQOLPVN1c|77XfaSu|>};;Gt9d-fRfJu9HC1DFDjG5hZ;Cz~hZsTKrg z0b&Jz;Vd-@Sm*$Q+UI4@?wY}_Hf>M)Oht`o(h2yhJkq)?q}ne45!lw6TwOK}-M6lzd)YfGvn5>Mx)R}i~U{EVdn zR%lAqg9j9Yr1%xgEUN|vgH$VkpjZ_X+(g{t#nS-7}kcGk__irHH? z4_C~?_oqI*^1+p=`S|9=9h3R(!mgvQ-2bCe?*$BmA51^!{Zro``#zof>*8mNHD|OeL^ZL-Y|obN!|@Ns zYtBGf2xvnMkKK2c?v39azn`p+p013Zt~w{n!lWjWubBpRoiO{}mAhA}&XKY(vTNxr zdnQW!C$^7l#kb1tb5+avGJl>ug?=vVKcre>vE@Ac4}*V`;PTPuu<~Jb4l2Yw%4#~b z)IfbkK-Q_u3dO%Q_PpQtkg|itc2hMnd?mNHk!@LHyYY}Pgv7RnJ@U+(27nUI!dc9x zrE~NK$ibEo8U1;z=Q!>mIr=4WenG5X5X(c-_mCX=CprF*cps91e~?R6a_KuG{FC!t Kl*3%Wbp96wJPGmu literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/compile.cpython-311.pyc b/d_wiki/__pycache__/compile.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd4105fa96f10ec9d320217a1a75824cb34f0aa2 GIT binary patch literal 34834 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/compile.cpython-312.pyc b/d_wiki/__pycache__/compile.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd61aebf96252a9295d8c83d0a6382bfc5ba2322 GIT binary patch literal 29961 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/compile.cpython-314.pyc b/d_wiki/__pycache__/compile.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebdd9e157452f318397bef79e0001c89aa92a97d GIT binary patch literal 35866 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 KaLhPkn)2Tk1lRNc literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/config.cpython-314.pyc b/d_wiki/__pycache__/config.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c8e8f1f666c41cc7cc0abaaf56d8209b478d36d GIT binary patch literal 4165 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 Cc-K1s literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/dreams.cpython-314.pyc b/d_wiki/__pycache__/dreams.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3458ba55aebdcb2c7a46ab63e929d56778e37cd2 GIT binary patch literal 15951 zcmb_@dvp`mx$lfLlExbO{RA5$WAiW=L%@`m0|6U?O?YG=rZfiCSi%TwOUy_Ge0y6Z zB#lXvSQK(l5>9a%a_XFQn)ux0+>)d{rMKsgyY9Mw$OvL(N*AnKY~cQLO{f=5{<^c{Hc9miGSkYv$W~fBSpwPYbd#?Hry%9fb$4&EU8{Q^9yFI>6uk5zlcUZZ9YE zP246vz|SPu)MN^nSZ)rOk(--@O_qR#wFynuP1b;QlPzFlWlNK|DI<`SNKAXmyMJbO;fqXe1Z~=o0)TXMgRgtPw*zCP z{fe(U(A5?QcoZ$K)7R#99S(YwV=hm3K=FFiofv9GpB_(ldt&WbX4VV*-Ms)p+#W8# z%N!^pD`2hy#q1Ge(;T!g$jl%Cb(UnEHCbm%LShoiV30jvktM8xLvu7Lp0+NJ`&mLw zGphkb6V%RNhh__E`p>3JUYHO|`F+C7@Bt<#HXs+!f?9l%tyY`@~|YQwx# zUr=dBL!KJ+`+Z8l+uf0@%Wvyek9ZW9;yE1jDxNM3R6pRhR$DdEUhKfR$OQlV0cVWF1@4jHbqqFgO2R&$uT!%so8h+|5Bq8n|SIk@QP!i3p8l!wrVA;iTR?DWwW`pi*MzlO^Hs41|v)N89 zlOCC?ky2GMpI-8tT1?w9cJgB|D8i7Q4hOAIYl5lbK$z+hD|&!$wds90eBY?`n_JAX zdBT^37T$Q98S13o>y>q19o9~f@RL+T7>PH6Z=pJeFWK>>eZTU^l354 zwsZ`(=Nc`kTow(Cjofc(vE*>iS%aopE@;|_74}zC*&Qs0eB@LqA(rtJmBn^U<1!efbP0_JqICOxf0 zIP7Uj&Ox@zQfehOV-x9{SVzYr-&UG@8`la^sy{6jV^z}XY(`yOf^H^$l?0lc4N9bQ zIO&mdS}TmImLvtqxoNd#nWUa)`&&1Df^%{`q<*M_)vDNCVN)w1-X_bwxT}_*tT#fREbz5BWhG(B^k~i#d zHEi3mz3G_^dZT6|L6i_dncj|WpW<Fmdw|o2n zwMUp=+vV;tBl*S>4D4UH0z5^80Q0%Q?Rzrt(Z($s(5hL99S2p-=GNtlQi(Zfc5k;o z7+|bbbNGS*DyRW`Ub83qfqz#QX@cVO1t4Kmm)omo_LjEJpl1UinCR!y+tmZXfR}h) zS3vQ2G)vbZ>TXpbd^~PV=;-wA(QafJ|ikItb*eFot6#7h}>-Un6};^H}Z zXKW{Jk?JcsmHqp#U}sb)yeura;m8X&_1mu$ z%pcBQJe0q9uqc+lBIZ~b+VJIyCu3P_KD7)Aul<)u-51#lKDC6Nj%Ka-(m6MlRsXIn zBJ>4%1Mk|Xvi^@b#l1p2qu^ZiTh)=${)TAryek>=hQ+!evF;Ps#htNb&C%ytqhj3` z;+{KZF1O^mB`3W4iluy5m_H=U|Ci;1OFmIAEc>|UKbBrR@`w7^g6+}g_eF*ImxcE0 zVota^E;@Sm^>v)+h>HcM+auMdy5nNeS#xA_tYltX%sss{eB@L;wH-Lq`LoXRD}Gu3 zZhfq1@o>?qp`ul>qWZB+o5MQB*(}ztzmmA@wO?yl^=cm0`+v+U*f>Y{gUPaSf$#^1 z73l=&Euagy4u97P;9=5x5viRPg?NQdD@=6HMzJTO69?`2G&!vh$4C>>Of0ixDK!vh zB-zaKtL{(|t*9HL{K7O=oG6shmm}h3NUmTbTN8qk<6098GhI+l6wU^F0`k04gW=UC zg=Dv~8p#Jdn+n5pj!vv4Ow-jVc7ndE?8E?uei48WcU78k_TWI?JKY1vu9UBcNh_nm z$`s}XhJT0URY(~~C_oQh*yZSywy?`+C6`6>=g`6~8>nN&6nf~)9?}HZ!Zre+-Tzy) z9eILO#Uh&((k(SBTR~{qov=XE0M?$iPT7GZZME4Zup|xrxRlwq{KWF`?kiGxf5{c8 zdSKHPsV*wirO-E4_i)K2ZqvHI=G*iO)L+4glOOIT3qN1d( znNPYVlCXP>vi<T6v?evjUEeWg z<+rElZc}Q4Ekc^kXOlB(rW<&3NgJX?Y_Tro)B4$E`&9kXdSuAbR6S(J@&uLP%x5Z3 z;9Jmlm?{Pa3soFNT_sa!$24xMW-|mO)An(}`L|2>YBEhHSCmPb716mFg zG2(r0!-v3(Z#XBQB*8gBUWsZ+VSI>KkS26_0&QdjyN~HBmN^M+ef3gHp*bde&z|yH zsB|Xh%t`2APA3y=$~sy!N*K#31-(Ot<(5Tup4lyWJLIU1ITnXDT$6IX%+9}BFsr{VRxmHLRGjscPpV%GG%D&J z|9*L_bn(@)ivF4b<;tujv9hIq$ree65-rxhqo^VB*Hv(ZAQCm-=n50)({OA&Sgt>d z{%QphQkV+){5zCHD#s}6-@&qh-K_F{`66H#lkWc)yWM6c`3_5%YvCQ-67zP{O@0hs z?=!QW{1TIFB4~-J*5o&(D_c9v24^y4f*VJ(i~~0$Wo^<^%gOc>Uxvgn?=Y`KANNk? zwV;E~p4I%bLNn)vUx)Z(i+L$83vhahvXsLaxNU@dFutkFq0ON8a!$5vDInWiwrRnfa}-yl?E^f~73V8MR5fA8SThdX~o9gCxpFLvP&p zwD;!efgq_GBmeZ`jo-d`(mUrkL%MREQQzU| z_8j#qYqW}q+_kp8)7ReCsjjI_cG-uKDzW;%-Ub@cnco{)xqGl+K=>y|Y~}8+?-Fqz z&n@70>fT6{*z>LDp!`>iXR}a#1ZV={%8S%?9EqEnQb^g?3{^cDX$;rBQ6H;%@@wTK zGzW1IxTDK%zWvh856_Ie`p#(NqmlD(j|`p+l2-KHWzO~6pL6O>)z%>C5lb6y{o6}7 zKKtd()8|He!>LW1g|_rfb1rRkruQ6q_1vxFzYWrEjrN`#J^t~{bMN1N;Z*vNrS2&P z5K9_)=il+UrH!et5!(7t9S^h(ygTyqp9aZ!r8kVe`YMe(@ruzye|fceoDRp$7eBr6 z*@xeV`xH1+oIyW48J=!9Gpfx&XYv&zX9vE!Y~<6ANBRbDTzFL=ene1}L#AM&`C zx?Mzjx+VbKJ7#-!Py#_Li}@7(aTs8|}e7lni2j;L5ZW-(`5Lr?!j z#o@B=T`K!tV(_Kn1D8ebHJkmodYKVq%)aIo^%eESRB_n0=8|nqqJOlcb}&0y{M2P} zU0liwZT-&)I}@|35{`i>gxw=eC@&T>Dd7Y@?+%9~l0QaSe*?<~U_qhu5DE9+@sc*v z-yq>kt+1Q)XOh%0L2~enpIaY;pPLd=$IPV8lwS9Rm+xyPQ=btg~_RFu|{OyOzPw;tG*7*zrZw(&5 z_0gNkD`?Inn0>ZpX+)VPZFApbO9h@qT?~%zew46SIIw zfmDuCLZSnXl{v_!^tJh^LI3PMPU2VGp(LV?Q8oY#64{_$x^RrO>Dbfy84oc*hJ66Q z~`Y?C9KwkLoYF`T42QpPwD+`)G>S1vd~9ec{_b`Pt~(FA|ccKN@}Qh0%W?0gSKW zC4fhMb!N1$@7C`I@sg33N!qCh#LqgO1 zS0+o2eT=g}2s$`1D_nZnR;Fd|ii*494rg@MccRkrsIdJ0BSvZfBho7NsfQl130}aI zw4zxs(@ddvJo02Q1+jvC?H*?*uOAY!#*ht~S$08SmG_G*5<3jr|H;O~)yD&v^wcHF zeiO_!rg*2hkDk`eBbmRiWmTdDSJ0%ar;S;dXffZ{;!L#QGI`P%>@RZp zo~*|!^#cqhNbkwgfnGq>nW>B-VlGeXVR#r$y3 zkXUh#vu4a2qa-dBMy5lvyJt3Pu1jV8_91EhJ&RE@X5}1Zk)9!``kpOWCvuMBNY#*3 zelH_gXXhLh{f$G?yn9lz&cQjH{dGgq+_CH_T@M0qWEA6M$Ud09*%ghTiw-6*nCM^v z<59AL)=wpmA-Ngsd>IjM87X1N`r&jymO6Oo#-1c%e?>6_j_yaO58@vlO47Kgm%$nk z%`l~pJL$bm+UU?l;8!qD|Q08+*)^l};w7*3jwx#*U(_d;h-4V=zTb{h+PWxe3lgwc4WDRevYq zlMoN20uHn(0riL%7pWc$*Q{-RKN%;&L7%r99GA8dHVx}6sE6Rw6j*_lpS*m!g|Z(d zg%Y-v^diu8@wCu}xReuWjOP@b$v&C=MNS27F{SLjwI|j_mJLf4m!yh#e({-ACs&=S zk5)cCl>c;Zzax04Zvps1j7&RP+=tBz4NwmNI6tfrDx&0D*wGSRxWbx$=sI8fzn`@P-nw$4t4)MniJvaJ~a%;@kC z?)??depT6q8r6b?d7E`Q>_$EY43#SPGM0GxF-ye9o+Ynr| z%E>N^JZ^<-%${k9yJRN|A#iqix_rtpC+?Y?8ehvKMRf)u7mu}db-GmeJ=+v!>mi1e zRnfIl>ZWJXrI+#^z5u11(dv1?DlM0x-ZTJKC}CvzuK+^abulw;&plle37qSBt0$H> zKbpHBD%Qm9`KOyv_rte-7%QlW<}ZwjwQ+l1xbDpAldHohIpg-yv(5d1;km1a=B|#F z)kjO8jEZaG_VTkm169NG*A2~I7n`|0THX*98{_tw=j{V^!wVXQ7Bs}1jnSDKqT
GavX^MF@%vd}drfP`n%<8~sTyUQ6k;BgxFp-u`0t93R7oNk{-bt2Z> zi7039{$o!4LK4-9Fk~mFJ2@&5apz=FVzoWCh0a6!Ryn_~@!#*sUg*@r=vW&aqlL!d zVbN>|>|5moeZPlEC>xPLuV;Hm+sAe;q0s9QJ4z!}Q^Iy>GXN+)P;sE7Tz6E)9a(Y5 z4=Kg%6D(B@1xV@ms_2 zOP4AJxApUBfy1CnsMq{nF8!Jx4j3MkWKxK=Fp`0d)d?6?7m#Td7VI~H^K?*GN*LN@ z07&o`grEEAHe41Lm-Q|S=f1uoDpd8)LXtw<&>O$a!ZKvimh~v%@F;=(ALx`^RtukX zheHy^DMl7)Vx<&z=*ym@R%>DcJAGMGo@7HIG?X_t=7h!NYO$CTM$lZ@bKeNiFO7gY z$S2gnCt)q|DSui@%uQv(7#5L%K|)=unh+|Nv|b+e1}K+nlgcIVuf<(oB8Hdua?H_; zs}{Rg^>)L6fe6$?FJPKLc9Hp!AQfFnOczl^M~s-*M(jligksAL&pw+!Y@2b(HY1)> z*n6ZmORp;!wv}J9m48{gG?v};fv4Y%Fv_}*kNx_`|N7(M<(n?&RGc=48&72mmEmKO=FbxSF_UnG?x^6U$HexQIN6AejYYA>}}Z8ZnCLUl(=2MkVy|2El@LU zMs>>GHDZsZvUQW+N{jz;;~ix%NZ1`d7!EA$^~|c4jCZH-M;HTZIB+bX$e28)o9L?fE`Rpv1zGQ_sO*E}0(M_{ZGhUdz?If-`e|HYZZl zpMSo6VD@_lV|h;u=Pe(~TOP|>*=xI&T@;yncF~uP0)+7Pi6_Kx@nvyZoWhb%WQIGw z5XpIDe6Dzk&|Y{!~8lBLA)+~%$mgFsk}cx z?%K(wn zmT3I*J*FDxgqvYntEEJKD*z+|baI%AkVGtX^b+AZc?oA`B3wro-aOkc?C6j2Dz>c? zcJxKmYBN&y=oDAQe?}LT_L>FgOmFyf(}w7^vFQ!5+=eSs!^QS1Qd3lDVnkG3 zMgO_nAH*L9>92nvevU~9r5=zbCI1NPQ59M?_7@oa-!J%&P~bqPcOMG@*Q|kKenhM= zH4<@A><_TaVAMnk%B1(OFjM`11LVbEe`H~Q2+$+g*HPU;N)A!dMagTFK$_{!FlLhL zrb-9ZbyC8_593Yj_^@>#=FMiuB$OuB>;EZTqg+D+Et>iZBx7ct=l{gb`ZJgDM=tYE zT*WnR?w`1lKXFAP+}vy2vO8AJB!#Ok^Tqc}HohAF3*oEpnmJR+7%LXgA0dP6&ynMG z_~XU6h(8I8i-=htuR&bl_+kWGjA!9~c)ScZTI18<{U4uBZqsoGoLb{mFn7nxVSS9- Yp)!x>K!+JGAyF|dfu@vicAHH0o_%{1v|D4o~`oyRuq)4ZgZhtLN^26(2 z_rBG`Fg<|R))mcL)zwwi)m8OA^}KJ*r)6ah3c@e`%#Hq~nxg&(ZdrA+b4T9kUJFNLeOkA9D;lXv#zhHlBT8`GlsZ z&){DVCaRC(t?yF2?GqE^!@nLrf#|d48*143jM{dn?RaKw7kP^l%DIf?hRgUGzVcmW zxSaR%RS65N;%#c!U4 z*m6Zoq=a~+&}>^&9&8en`wv0yRwY)UfFsjHh7cP2G@7QszR6At`p4A^8?^XN6I< zL3um5b3o6Wn)6g_Y)D8Zqwx_*GfPQPvt15LLTEyaY3x{n7h;+rImW^_LdnE60l&_o*+QXscuWX|G)E`|O-;lw?Fxl{ zG7*mDpKzg2(U^onVmW+@SOMZU)b}8%r`?_BBteuq`F1gJIgyM;q|T#>$i$csPfDEw z!en4vOpFSVBovs8UW<0}Ari%6V;$o+MH@DU!U_MC@Av-#MLQ%BTCM z``_u$F%{FNrcb?dD(4MMpOBe=ekn{KSM8tfml?l)Da#2Fmc0IkwI>XRdYuU~!&K^0B!Q8b4 zIyyQoX%*qPG%1Lo%drVzT*R4i!SscM>ro!om7rP11U@=3ra2;s_!T{GAjpc9_$6)> z9u!q58c}#rkni+i%D*hIgme^yaZHy-kZF<0r7$fyrb#B3!ZhWo8*m^S^h;Sz=r6#w z*B;38@ML8m`6`|T{W1#-?*+YQO7xuNt9d6px9~pR1+f+4GKg&umqTm^eRV_Z;5{(J ze$8Dn#3=#vK+3BHSwEUZ6p|BSTw?|jaUoIw80ZzIK?msXaXeP%QEms zhVE(Imemyl=>T?jOQZmlP#0GZ>F)>7ff*_Zx65I)P%ev|TNQZP2)pAAFI3xPtUX1) zP;IlZ_6xq7G1i_kz0kW^W9=7wcgbcoWlqx~lQxN_v{`};aOlP6z*^Fmzzcnet)w>1 z+ozbMb!Dnws5J-gG;W2))~8q#m8O!o;_?Bs1HL-Vq}d0qPkjy)Tz^+N0kxl|{^;@E+dH%W?tZ!XM~Y{+>e(%O!e1T!vj6LWF9zh3Zz|nk zwL6@#EmpYiIcCc5mdlMVD;3+-itTd6g@3vH&!hhq|EIXz`>N7)LG8MbVHe$1_qNV- z-0hH?b}8;I)!ik#-}tKe%dKB`e9NNApNBm8s+6%WdTTy(->?0s z;e!Ub^}u7V;_p-aeTw(E>OG!u$5}RuN>!j|Lt3E&t6fu7L{vR;9i>NUQ)Prm21y1i|)oOqqtjC zcT2{)$oXfte7sZPT2-#K2x{EkJ0mmK?q16VmFhONx=pU${?Mejcc|_i3+_Gh?mdco zpX%O+cvW3gt*&*>_j%oK>*QU1O7OTEJg(H8Q0q>}wwguXrtGVqzV_?a9yTZ~2i2B? zitmu>JCtz&PR;s0s{5cW`?})auKKsj{{0WHD&7OC_rQX;ci!8pc>7du--7q_y!W)? z9aO!8fL~6pT;C--@yhv|GX0BOW3H+$SKprVx8!_HOLn%x@f`)?2NX*bYj+ShGXNDX z5du`#ApvBS8iiO7E98%-uMzqudI8ARB!Z&<0^BKS=4c7#84($HFPfJ5ux{@h##-Yva84NO73UA& zqH93JVSRe(VqzkIxE75Gfmk9Ejs^Id%pg=qlm4vpyvPs-NA|@u{yub(0 zc@P)}Yg_6FoFNupAQ6w<4D=5T4s>YD1o$F;14f*fhzXh%+DQV@0*;3}3vpX$&ZICl zE{I_;7Qxb%Zc1>k*~SD(!bVfh>o0dM--ts{OQRhI>kQY^4zwo!77`~Znyjfy-C!#f zafLLUEUY5fR}Ay~xzE5C=(W|72Zxcdo^ediQ!_M8-R>a{EVI~$-`4|T095t}-W)}N zQ%^Po7!y;+HjRnG*A{E#Q+xM_5EpKYi~Cc1o~4`M2Fm-EI=accN&7nrRR`fU(g_g% z3xCs;yg`8L(a!%Gl`mfU?@&Y;;MD;hvOXNjR()FY>zcXE51W;yT`KU-`YshflT;{{ zM2}a#D(KX4Xk{85q49*2-w5rY(L^+kE-{^r;|@p$L1SW3DXB5|n2ZIigu>=09*1JE zae|AFOtgfWN_INJ*TvIto7((*V}gS%{RfC?>RYe>-X+!BnyYQN->%kf&(&?nRZrxa zTOXd6{oQ!g^ej0o9@qdtWUNc&R7KVMKfU$S4{y#@J*ZcM2Oifeje~0Ap#0+t3U^WE zE@qgVyLzVeZtE=UarsTs3A^EkNyWKIb#B7l?g|YMIkV^P9(@!a{|I7bgP?-+2&zYr zUBV*gzO!>?_ubvI#}v;-)w5Cd1hb;TZB@CgvTf^X=tS~Kp!4xFpi>7)gh-yvLnRQV z`(^@_MM?l|<%59`7eghpT!Ob6m;RbiSpe4MS{Q?W*#JENm1qIxLz+pVb(asucZg$Y zM!c2=e=PdA^Z>NBxHkI?pdCoF*|mFQFX@rR(5B@XZEiA{oXx0JpEM}l1FXaIkj9d*TJM$bAJ>r0;R};~Q0Es+861^d?6Lb_Q=p}6C z4HU$*E~ul3ZnqU+3R+8)Q4Hhr2ndb65*2~L@{pDgafx2$38;7qGS)Pn3rr$UP|jfW zKZ7Vz%eoCq7OK7_*ZB4lYp!%JQ7CLwZD8)0T(JW#P)>jOlGTA43Ia5=x>Q5uL+6#o zSJlQ><%@4BTv+A8e_cgcd(Rx$(GUSCoIP}}Khuj$x8>t1h1;xho1r6RJ-OP(kAfcr zvnQ0=4z;%9j&;#fKRfbqQt`B@o;J|)%AUo#hS|xF-umFJxjjnbF12x&+_>+NTdC_- z>$>Ht?i^Q{5s4~mW&}h8xu@l59q0~dIK;RV0i`YkgjAyBe+SA6-o~O`Y=v;9O+5Xe zgs-ekJoyqkamt)5vSCLHD!%q&2JaL2+<6wDgc>c>8^sks0&iJ6|5wz9Cf>^1?z0c< zMw@Jku~X~xU`-nk0KoB}#AmjP0w5?Jmja^#rNMR}h50J+1*9!MgD;-4ylt7JCn^2gf|Ucu z;K0oV=T$(~LSZQqji%U%vuZYu2kmn1@Gy!jmBAr8OBH6A}|i%@Q4nCqw~H3c=(~h*HW|nd0Q6a_7MmY*0Km!Mue0w;T#1r#_Iy{uV9;U^OU5E<(k zJ)vVQ&aY;LGH8vVi67=AV7|~T&B6<$1(x(cv*TNPu``Xrg#I}w~2x@4&X0nX5mHz8%~C!vDIDy5kY@Vcfbl!y9!05EPU`Zwa9sHr)IZ2 zWM!^P;ks0=Yk}*T=XxHEDBLlXJBB`intL4!?$&vCYtF^xD!n<6|J%U!Ty0yfzUlrY zwSIf9>G0gn2R-Ub2j!;2aOGNF2JH5h1F-^Or#!*$D5nRkZ4iLsHLU#-y;$kH*RW8z zWxjIDob{1guH2$jcB_@$0Ig+5=*PB2U){Y_w)NBYU$_55=RbBXH1D2o-u=j@G#^r% z4=KLGs_*cU8H?%_isg5ti64k8&R;M6$2;0=*^QQ7T*8~2`!2Le5vV3BlSDio+EDaH>?ZN-?*70)z)vS&6xJn zn64%1#;RV%{LPL-uA>Lczdyjj4Vod%&clizqT&dqNG(i(eNb{b+6uXvlbqe_3M=lx8YfU3M1l04FbT49OV3c7@F@y( z<4OMtV!H6RWTM$7m?DF)P?pLilZ~B%8CsFwnIZe#*YXdl+$?Ykqi8j=+hFTA2#1S( zX^Aq54OJ{~6{BeLu(%+eC3QQBd=24ZIDlaFPF%SXy+MZ0;Cw;?Yew642@>cl$wIt3 zl=`26>YGrlSBFx+wB%j4WC?G8vp4u@#=50Tb`P;OZGxSKPSfkKk`k{m>_28~U9Y3x z1uX+l>CTj^v&aLGs=~WcBAhZqZpsW#f@U~()}6C9Au|C!z#zl6 zK?eTkFgO~6Ki!aEgptqcRwkjzDBgyD=@tldetF(MaO=SA4#nB1Ivb~t=B&=2PyKA_ z&Krt#lWIkKkFA)incQ_sX+5pBo+f$V5z9E23!hW0b*i-vA9R8JD092unyp^& zx6S+8=FTbp9jbqao-5mS<;vZ%vmUNH=k-`->WhqUTp0#82$D0hR5Y0Q^_Pl~2u2F(pcE2xTA!Eh?-r9!>@tB;U;JfF+3T{Qxk5b4B;YR4fbJ+)<{eU#|0o*dO=ZR zqu}|wp)sI_aC1Ejznak)I7sDJTZV_R3n)nihGml-ULSoPWSsgw|d??aQnc5vt{1dlD(oh+f`>f zXp?FS9S_s#-Fc?cQ8%(?V_Ad~Ms@s}IjTJpb_ggOF0&qt^Dk zcQVs^XXl-rPk=G0+(vvqG_)+BdgeF~61x|6?QglNj0^vu^~_EQe<}34mjg%Krf=Nb zkxlG38)=Z@uOM5j17T2SoK~XFmmy)a0^#=ouqc;^3i#*Zj&s z^8nd#SM`B-RzHB36+ElQN4C@dw2=3<_Mu9Mo1uF^WC#~Q zB@i!ykZ_EaLH%_|rvio}xHY_{_putT`MlS(qF=7)&nCYzKRWvF_Al*Ub6;@E?i1?n z6OjE&&z-Zs@Za;#G~R7gDx1~HX2>kL2wcN{a|D_st`?0Yr+@IFigX@Efsy{goDdiz5Sq zidRJGFb{|xeq~WEt{2E9OA*sLk;6q9ti&H9UYS7eJp9@a5s*NNxC>I6OE-u*h*cv_ zVpe%RYuQ9{7JjlRNFo6%3z&Rx5-O4xq0O)VK&}Z>WcNk9AcIjt0-xHt^u-m#-YvBpa_BRV^DYa8j9^)BZb~ zWZI|DK9%+@nOM3O97wAKoGH?^aHdGt0^Ky#6pB`?Zh@g2m#Ed^JIwn5#YziUsysx~ o$S~KBzSE!mU@UUfY@r*#3^NEfM^`LSMzP6EpM>_GCCL)|KgsBgUjP6A literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/llm.cpython-312.pyc b/d_wiki/__pycache__/llm.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1b0884f531f32e07b0584b52f9ff3fda1de3a02 GIT binary patch literal 9968 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/metadata.cpython-311.pyc b/d_wiki/__pycache__/metadata.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22c1fb9847b2f736599dc1a1da5bab6869a0ffb4 GIT binary patch literal 10041 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/metadata.cpython-312.pyc b/d_wiki/__pycache__/metadata.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..86debc0a3068c419a38eae191cc46e680e4c830c GIT binary patch literal 8126 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/search.cpython-312.pyc b/d_wiki/__pycache__/search.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae836f0de5137852dadf9a60f5f20f540e10f22c GIT binary patch literal 25989 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/search.cpython-314.pyc b/d_wiki/__pycache__/search.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3312bf4a1dd7a73610559221517987a4ae0ac283 GIT binary patch literal 32170 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 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/tokenize.cpython-311.pyc b/d_wiki/__pycache__/tokenize.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..055c5e543a67c657fa30beb05b7c164d57968240 GIT binary patch literal 2505 zcmbtVYiJZ#6ux(6_LWU`6OCQ1wrm^4tdd7{BP67uu}L4%rj1$Kl4zH8?`+(-kMz!L zjmriWNox$DCZ&=fEu^ic3H~t9LbXNcpF;l#voM7)5D=QR`Y#X)l0WUaGn;iMDiwP7 z?wNDX+{ZcRe&3nzD=Nwmw4Z*g82pDr=ubA-XuP4|wYNZ-Mg$QYLvh@PG1Ivi*T->4 zesVfL^=kReQ5BW=rx@zpHal=iTAdADY#!E8QtW=a!G_mf8MJ2f(EGNUo zh~NMx{2?EBtr4sj_-T|uvtW9>&4KB9(L93XLKc~65Hf5uf-`syM%Rm$5$-87xePMT z9OpCKY{{-0dm=Q(M=;?>?Xu&MO=g}K8WH4*4IQD2o9>NR(tri?S>~JVK<4PoZvhq7 zQIz2}&w@L*b*EkZp}KTqU30L$VSnAp{p;@j6Dhyg*jRTW)f|aL%-Obqmj_w4KLq76 zK7ugdFN03*9>L@(dB4bIAg2VUVa2E1j$)W*AKypQfZmBcIudyeJz)9o1~3YP$!NmI zYg~P!W{D<yFj|F(D2Q(YEx?qP;bi42NP;TYd2* zyC>;Y5D)L8`zVW)$_VtEO_N)uJzscccFZ=-H!Z%h(5%$>)g4W_szYkkA!AOdT!Re| zWidWrU^XGz0*0+RqCuHP11!H=0k0*f2aLk#5wmYpW$+X?QQeCc7=dlUlq5z{F&{^( zVGqV88kg8I454ELtJt5lSTNlihYCu4wPQTG71J?%T$v5$GPKz-KW*Gz$$S21JdIhlVviCMJ9WWpz%o>1#xo zp!-UnW9JGWyk75Xy3d+@!%yl1J7bbG1>#{AExEQ_8XO`-q+WEb? z@&ju5fo$h;<(4nYl$~|+a<0;^R{FDVFA0tdN6#NEy^-HK@6`Mr`lBbH9RDcS6I6SG z%BgU!C!FgdY8T0Mh-!xj^K+FE6{HYRg@__Vmh_y=9ETj_oPHHXf?rPqeGy#Kgj306 z%yhXdBmga5TLgtshdMGy27RM_0myp$BC~%0h!81AA^Jx*04(+e^z35&nBc zIqF5k0_DQm{RVZzQKpa>2lbjz3revfREz-Y&4Cp-?jo?=0`6YGn!Pvh?t8)4yN)bu zAXTSz2~z2H*fjlo0nqi2^Kl!zm-d1v(9zSPcv|KIGr~2yvb`4cOaywC=f6)Ky?mM;0;bUxI?z+zbpG7Ov^A+ek_D(N-2{zEIk{F`l z(;Ck>#)lH;d{{@G#EON%b@~FRx~Kw0`WOT-#_3)~*s^WX|8X9wUj10eI#-Eh@1!sdy$+Z&|WE)Z2h~gF% zy9g(Z8I&kcowDy9EoXw&Qm`_rlvwvMt6eJ#1|uo>@{7SBWe_t0<|R?44QvRILwY4J z0^G%htN8 d?MoG%ir%wjt5yqcT1942X~C7u_C%q(^DmgmVEq69 literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/tokenize.cpython-312.pyc b/d_wiki/__pycache__/tokenize.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e1bd7b230c6d3fbee161070c2b717bfc7885ea5 GIT binary patch literal 2062 zcmb_dZERCj7(VCT+pl$7yE3gnFyl*Ba3A2NVUmU6hH>C@ti)tvHszkv(bC>a&b@VO z(0iZ zd!GBA_niB_?|GivA1W%!5RA`0t%&?BAat8Ql!jOUcyTX)NkkCAQ53_y7;`K{g!Yn!*z^}S zg=iBNwilqeuK;g+k{_EfVc|?e7;2V_`N9DRIpGJD;>AYro{=U|3Po10n?VR&E6&4M zFZKnYh*Wg0ng~weYtTtPhJ{DO3Mo{I9hFi-#8%k1+Mbm{n24wCx})UPdB)}-l3r25 zBU0%Wh$RVkS~|DnZC|ON)TEc&8V+leX$_=~sYg{kENczzsvM6|Mb{d- z=wQtWrbei&L%?A8c({QC%t=>|Qze|F^(PX`jy(fZp+hHFYjXXHe@|4EgHf%uer1v0 zlC~Ahz2DKjG`i&uU2h)uOnN807uQ~Co@$=iIlVixw)v;3XJ_4^C5_YS&5c_y`C%n%qgY$2#A7>ycMI;2yD7#0>(2B;y%fXgMa?qxCNful7Gm>L*+*&0BGy;KL=1dp6`S{w|dJy+=&i;P6xj;3FnFRvWy z9O=w>Yp1ql%Xg(a=G~sjvWc?H`noAS>uyTFG$%RE96Wh2>kfU_adY$c!CbdLbNKaa zcOY|Ap6!;iog~{%bM8=13e9cU^rN$B+<$doihK|oZNKGg%1BL1FlpuR=5L;N?^`2% zTP}gUk4wBwrgF~%;4EVH6w(0~#v6#?#G}-@N`Y*fzM?-+9Gv%{W`?ll!RTKt66xV_ z<){ZGETE44jH~s&v^o7u2|Nv8MF3FgFwlH;`bCOY0>u%h_%!aC#)iGe|H`X@7dj72 z3k)=i49R3Qr%FwYd4;SRaB^Ld0`(8l@iAD}xGAvF+cM?9C|$MZo~WJmwk$33zMk?_ zC)#OVVlE?()TpP)@l8lRH>~zlQT7;93PhwBP zWQdy13@f90oGD31G_2`;;OU2Do(|i|%`P4&9aYsR$h<5N2*n|q1_F#TrBIKkQJrn$ zkDN57GR@Sd5#xWL=Cv=|_rz2ZkJ4859Qb&p<~QdL5o7!d+H@N^esxx6Ty0tBzO>z_ T=t!3>S}nNwPqziT&13!nhWYXu literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/tokenize.cpython-314.pyc b/d_wiki/__pycache__/tokenize.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e275cc1fa0cdda733b74ed90783dbe6027dd3347 GIT binary patch literal 2644 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 MXIv}&In_%47xr1XF#rGn literal 0 HcmV?d00001 diff --git a/d_wiki/__pycache__/yaml_compat.cpython-312.pyc b/d_wiki/__pycache__/yaml_compat.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50d28b07fb7ebf49401d9a82c2a07c4429a69c98 GIT binary patch literal 3530 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 literal 0 HcmV?d00001 diff --git a/d_wiki/cli.py b/d_wiki/cli.py new file mode 100644 index 0000000..92d81fc --- /dev/null +++ b/d_wiki/cli.py @@ -0,0 +1,77 @@ +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path +from typing import Any + +from .config import DWikiConfig, load_config +from .compile import compile_kb +from .dreams import dream_kb +from .search import get_page, index_payload, search, status_payload + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(prog="d-wiki") + parser.add_argument("--config", type=Path, default=None) + subparsers = parser.add_subparsers(dest="command", required=True) + + status_parser = subparsers.add_parser("status") + status_parser.add_argument("--format", choices=["json"], default="json") + + index_parser = subparsers.add_parser("index") + index_parser.add_argument("--kb", required=True) + index_parser.add_argument("--format", choices=["json"], default="json") + + compile_parser = subparsers.add_parser("compile") + compile_parser.add_argument("--kb", required=True) + compile_parser.add_argument("--force", action="store_true") + compile_parser.add_argument("--llm", choices=["off", "auto", "require"], default="off") + compile_parser.add_argument("--llm-scope", choices=["queries", "all"], default="queries") + compile_parser.add_argument("--format", choices=["json"], default="json") + + dream_parser = subparsers.add_parser("dream") + dream_parser.add_argument("--kb", required=True) + dream_parser.add_argument("--force", action="store_true") + dream_parser.add_argument("--format", choices=["json"], default="json") + + search_parser = subparsers.add_parser("search") + search_parser.add_argument("--kb", required=True) + search_parser.add_argument("--query", required=True) + search_parser.add_argument("--max-results", type=int, default=5) + search_parser.add_argument("--format", choices=["json"], default="json") + + get_parser = subparsers.add_parser("get") + get_parser.add_argument("--kb", required=True) + get_parser.add_argument("--id", required=True) + get_parser.add_argument("--format", choices=["json"], default="json") + + args = parser.parse_args(argv) + try: + config = load_config(args.config) + payload = dispatch(args, config) + except Exception as exc: + print(json.dumps({"status": "error", "error": str(exc)}, ensure_ascii=False), file=sys.stderr) + return 2 + print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True)) + return 0 + + +def dispatch(args: argparse.Namespace, config: DWikiConfig) -> dict[str, Any]: + if args.command == "status": + return status_payload(config.path, config.knowledge_bases) + kb = config.knowledge_bases.get(args.kb) + if kb is None: + raise ValueError(f"D_WIKI_KB_NOT_FOUND: {args.kb}") + if args.command == "index": + return index_payload(kb) + if args.command == "compile": + return compile_kb(kb, force=args.force, llm_mode=args.llm, llm_scope=args.llm_scope) + if args.command == "dream": + return dream_kb(kb, force=args.force) + if args.command == "search": + return search(kb, args.query, args.max_results) + if args.command == "get": + return get_page(kb, args.id) + raise ValueError(f"D_WIKI_UNKNOWN_COMMAND: {args.command}") diff --git a/d_wiki/compile.py b/d_wiki/compile.py new file mode 100644 index 0000000..bd90cae --- /dev/null +++ b/d_wiki/compile.py @@ -0,0 +1,590 @@ +from __future__ import annotations + +import re +import shutil +import json +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .llm import LlmPageSynthesis, LlmPageSynthesizer +from .metadata import load_alias_groups, load_query_entries +from .search import Chunk, compiled_wiki_root, load_source_chunks, trim_block +from .tokenize import tokenize + + +@dataclass(frozen=True) +class CompiledPage: + wikilink: str + title: str + path: Path + + +@dataclass(frozen=True) +class _EvidenceProfile: + tokens: frozenset[str] + phrases: tuple[str, ...] + + +def compile_kb( + kb: KnowledgeBaseConfig, + *, + force: bool = False, + llm_mode: str = "off", + llm_scope: str = "queries", +) -> dict[str, Any]: + chunks = load_source_chunks(kb) + if not chunks: + raise ValueError("D_WIKI_COMPILE_NO_SOURCE_CHUNKS") + synthesizer = LlmPageSynthesizer.from_environment() if llm_mode in {"auto", "require"} else None + if llm_mode == "require" and synthesizer is None: + raise ValueError("D_WIKI_LLM_CONFIG_REQUIRED") + wiki_root = compiled_wiki_root(kb) + concepts_dir = wiki_root / "concepts" + raw_dir = wiki_root / "raw" + if force: + shutil.rmtree(concepts_dir, ignore_errors=True) + concepts_dir.mkdir(parents=True, exist_ok=True) + raw_dir.mkdir(parents=True, exist_ok=True) + + pages: list[CompiledPage] = [] + grouped = _group_chunks(chunks) + query_entries = load_query_entries(kb.queries_dir) + alias_groups = load_alias_groups(kb.aliases_path) + query_by_source = { + source: entry + for entry in query_entries + for source in entry.primary_sources + } + aliases_by_source = { + related: group + for group in alias_groups + for related in group.related + } + + for wikilink, page_chunks in sorted(grouped.items()): + page = _compile_page( + kb, + wikilink, + page_chunks, + query_entry=query_by_source.get(wikilink), + alias_group=aliases_by_source.get(wikilink), + synthesizer=( + synthesizer + if llm_scope == "all" or query_by_source.get(wikilink) is not None + else None + ), + require_llm=llm_mode == "require", + ) + if force or not page.path.exists(): + page.path.write_text(page.content, encoding="utf-8") + pages.append(CompiledPage(wikilink=wikilink, title=page.title, path=page.path)) + + _write_schema(wiki_root, kb) + _write_index(wiki_root, pages) + _append_log(wiki_root, kb, len(chunks), len(pages)) + return { + "status": "compiled", + "kb": kb.name, + "source_root": str(kb.root), + "wiki_root": str(wiki_root), + "source_chunks": len(chunks), + "pages": len(pages), + "llm_mode": llm_mode, + "llm_scope": llm_scope, + "llm_enabled": synthesizer is not None, + "compiled_at": datetime.now(timezone.utc).isoformat(), + } + + +@dataclass(frozen=True) +class _PageDraft: + title: str + path: Path + content: str + + +def _compile_page( + kb: KnowledgeBaseConfig, + wikilink: str, + chunks: list[Chunk], + *, + query_entry: Any | None, + alias_group: Any | None, + synthesizer: LlmPageSynthesizer | None, + require_llm: bool, +) -> _PageDraft: + first = chunks[0] + title = _title_for(first, query_entry) + slug = _slug(wikilink) + path = compiled_wiki_root(kb) / "concepts" / f"{slug}.md" + evidence_profile = _evidence_profile(title, query_entry, alias_group) + tags = _tags(kb, first, alias_group) + aliases = _aliases(title, query_entry, alias_group) + source_ref = first.wikilink + source_path = str(first.source_path) + key_blocks = _key_blocks(chunks, evidence_profile) + intent = _intent(title, query_entry, alias_group) + summary = _summary(chunks, title, evidence_profile, intent=intent) + requirements = _answer_requirements(intent, query_entry) + synthesis = _llm_synthesis( + synthesizer, + title=title, + wikilink=wikilink, + query_entry=query_entry, + alias_group=alias_group, + key_blocks=key_blocks, + require_llm=require_llm, + ) + if synthesis is not None: + summary = synthesis.summary + retrieval_hints = _retrieval_hints(title, aliases, tags, requirements, alias_group) + blueprint = ( + list(synthesis.answer_blueprint) + if synthesis and synthesis.answer_blueprint + else _deterministic_answer_blueprint(intent, requirements, key_blocks) + ) + links = _related_links(query_entry, alias_group) + content = "\n".join( + [ + "---", + f"llmWikiVersion: \"1\"", + f"conceptId: {_yaml_scalar(slug)}", + f"title: {_yaml_scalar(title)}", + f"summary: {_yaml_scalar(summary)}", + f"sources: {_yaml_list([source_ref])}", + f"source_paths: {_yaml_list([source_path])}", + f"kind: concept", + f"tags: {_yaml_list(tags)}", + f"aliases: {_yaml_list(aliases)}", + f"intents: {_yaml_list([intent])}", + f"retrieval_hints: {_yaml_list(retrieval_hints)}", + f"answer_requirements: {_yaml_list(requirements)}", + f"confidence: {synthesis.confidence if synthesis else 'medium'}", + f"provenanceState: {'llm_compiled' if synthesis else 'compiled'}", + "---", + "", + f"# {title}", + "", + summary, + "", + "## Intent Model", + "", + f"- intent: {intent}", + f"- coverage: {'procedure' if intent == 'procedure' else 'fact'}", + f"- answer_requirements: {';'.join(requirements) if requirements else '直接基于证据回答'}", + "", + "## Retrieval Hints", + "", + *[f"- {hint}" for hint in retrieval_hints], + "", + "## Answer Blueprint", + "", + *[f"- {item}" for item in blueprint], + "", + "## Synthesized Evidence" if synthesis and synthesis.key_evidence else "", + "" if synthesis and synthesis.key_evidence else "", + *[f"- {item}" for item in (synthesis.key_evidence if synthesis else ())], + "" if synthesis and synthesis.key_evidence else "", + "## Evidence Graph", + "", + *_evidence_graph_lines(key_blocks), + "", + "## Key Evidence", + "", + *[f"- {trim_block(block.text, 420)} ^[{block.wikilink}#{block.index}]" for block in key_blocks], + "", + "## Source Map", + "", + f"- 原始来源:`{source_ref}`", + f"- 文件路径:`{source_path}`", + "", + "## Related", + "", + *[f"- [[{link}]]" for link in links], + "", + ] + ) + return _PageDraft(title=title, path=path, content=content) + + +def _llm_synthesis( + synthesizer: LlmPageSynthesizer | None, + *, + title: str, + wikilink: str, + query_entry: Any | None, + alias_group: Any | None, + key_blocks: list[Chunk], + require_llm: bool, +) -> LlmPageSynthesis | None: + if synthesizer is None: + return None + prompt = _llm_compile_prompt( + title=title, + wikilink=wikilink, + query_entry=query_entry, + alias_group=alias_group, + key_blocks=key_blocks, + ) + try: + return synthesizer.synthesize(prompt) + except Exception: + if require_llm: + raise + return None + + +def _llm_compile_prompt( + *, + title: str, + wikilink: str, + query_entry: Any | None, + alias_group: Any | None, + key_blocks: list[Chunk], +) -> str: + aliases = list(getattr(query_entry, "aliases", ()) if query_entry is not None else ()) + terms = list(getattr(alias_group, "terms", ()) if alias_group is not None else ()) + requirements = list(getattr(query_entry, "answer_requirements", ()) if query_entry is not None else ()) + intent = getattr(query_entry, "intent", None) if query_entry is not None else getattr(alias_group, "intent", None) + evidence = [ + { + "block_id": f"{block.wikilink}#{block.index}", + "heading": block.heading, + "text": trim_block(block.text, 700), + } + for block in key_blocks[:8] + ] + return "\n".join( + [ + "Compile a d-wiki concept page from the local evidence below.", + "Do not invent facts. Use only the evidence text. Prefer Chinese output when the title or aliases are Chinese.", + "For procedure intent, make answer_blueprint actionable and ordered. For fact intent, put the direct answer first.", + "Return only JSON with this shape:", + '{"summary": "...", "answer_blueprint": ["..."], "key_evidence": ["..."], "confidence": "low|medium|high"}', + "", + json_dumps( + { + "title": title, + "wikilink": wikilink, + "intent": intent, + "aliases": aliases, + "terms": terms, + "answer_requirements": requirements, + "evidence": evidence, + } + ), + ] + ) + + +def _answer_blueprint_lines(synthesis: LlmPageSynthesis | None) -> list[str]: + if synthesis is None or not synthesis.answer_blueprint: + return [] + return ["## Answer Blueprint", "", *[f"- {item}" for item in synthesis.answer_blueprint], ""] + + +def _intent(title: str, query_entry: Any | None, alias_group: Any | None) -> str: + if query_entry is not None and getattr(query_entry, "intent", ""): + return str(query_entry.intent) + if alias_group is not None and getattr(alias_group, "intent", ""): + return str(alias_group.intent) + lowered = title.lower() + if any(term in lowered for term in ("如何", "怎么", "指南", "debug", "调试", "配置", "bring up", "生成")): + return "procedure" + return "fact" + + +def _answer_requirements(intent: str, query_entry: Any | None) -> list[str]: + if query_entry is not None: + requirements = [str(item) for item in getattr(query_entry, "answer_requirements", ()) if str(item).strip()] + if requirements: + return _unique(requirements) + if intent == "procedure": + return ["按步骤回答", "说明关键前提", "说明验证方式", "引用证据来源"] + return ["直接给出结论", "保留关键数值和单位", "引用证据来源"] + + +def _retrieval_hints( + title: str, + aliases: list[str], + tags: list[str], + requirements: list[str], + alias_group: Any | None, +) -> list[str]: + values = [title, *aliases, *tags, *requirements] + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + hints: list[str] = [] + for value in values: + hints.append(value) + hints.extend(tokenize(value)) + return _unique(hints)[:32] + + +def _deterministic_answer_blueprint(intent: str, requirements: list[str], key_blocks: list[Chunk]) -> list[str]: + if requirements: + return requirements[:6] + if intent == "procedure": + headings = _unique([block.heading for block in key_blocks if block.heading]) + if headings: + return [f"围绕「{heading}」组织步骤和注意事项" for heading in headings[:5]] + return ["按前提、配置、执行、验证的顺序回答"] + return ["先给出直接结论", "补充关键参数、限制和来源"] + + +def _evidence_graph_lines(key_blocks: list[Chunk]) -> list[str]: + lines: list[str] = [] + for block in key_blocks[:8]: + claim = trim_block(block.text, 180) + if not claim: + continue + lines.append(f"- claim: {claim}") + lines.append(f" source: {block.wikilink}#{block.index}") + if block.heading: + lines.append(f" heading: {block.heading}") + return lines or ["- claim: 暂无可用证据", " source: unknown"] + + +def _group_chunks(chunks: list[Chunk]) -> dict[str, list[Chunk]]: + grouped: dict[str, list[Chunk]] = {} + for chunk in chunks: + grouped.setdefault(chunk.wikilink, []).append(chunk) + return grouped + + +def _title_for(chunk: Chunk, query_entry: Any | None) -> str: + if query_entry is not None and getattr(query_entry, "title", ""): + return str(query_entry.title) + return chunk.title + + +def _summary( + chunks: list[Chunk], + title: str, + evidence_profile: _EvidenceProfile | None = None, + *, + intent: str = "fact", +) -> str: + if intent == "procedure": + for chunk in chunks[:12]: + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text) and re.search(r"(概述|流程|过程|用于|帮助|点亮|调试)", text): + return f"{title}:{text}" + ranked = _rank_evidence(chunks, evidence_profile) + for score, chunk in ranked: + if score <= 0: + continue + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text): + return f"{title}:{text}" + for chunk in chunks: + text = trim_block(chunk.text, 220) + if text and not _is_low_signal(text) and len(text) >= 20: + return f"{title}:{text}" + return f"{title} 的编译知识页,来源于本地文档。" + + +def _key_blocks(chunks: list[Chunk], evidence_profile: _EvidenceProfile | None = None) -> list[Chunk]: + preferred = [ + chunk + for chunk in chunks + if _is_evidence_candidate(chunk.text) + ] + ranked = _rank_evidence(preferred, evidence_profile) + if not ranked or ranked[0][0] <= 0: + return (preferred or chunks)[:6] + selected: list[Chunk] = [] + seen: set[tuple[str, int]] = set() + for score, chunk in ranked: + if score <= 0: + continue + key = (chunk.wikilink, chunk.index) + if key in seen: + continue + selected.append(chunk) + seen.add(key) + if len(selected) >= 6: + return selected + for chunk in preferred: + key = (chunk.wikilink, chunk.index) + if key in seen: + continue + selected.append(chunk) + seen.add(key) + if len(selected) >= 6: + break + return selected + + +def _evidence_profile(title: str, query_entry: Any | None, alias_group: Any | None) -> _EvidenceProfile: + values = [title] + if query_entry is not None: + values.extend(str(item) for item in getattr(query_entry, "aliases", ())) + values.extend(str(item) for item in getattr(query_entry, "answer_requirements", ())) + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + phrases = tuple(_unique([_normalize_phrase(value) for value in values if value])) + tokens: set[str] = set() + for value in values: + tokens.update(tokenize(str(value))) + return _EvidenceProfile(tokens=frozenset(tokens), phrases=phrases) + + +def _rank_evidence( + chunks: list[Chunk], + evidence_profile: _EvidenceProfile | None, +) -> list[tuple[float, Chunk]]: + if evidence_profile is None or (not evidence_profile.tokens and not evidence_profile.phrases): + return [] + ranked = [(_evidence_score(chunk, evidence_profile), chunk) for chunk in chunks] + ranked.sort(key=lambda item: (-item[0], item[1].index)) + return ranked + + +def _evidence_score(chunk: Chunk, evidence_profile: _EvidenceProfile) -> float: + text = trim_block(chunk.text, 1000) + normalized = _normalize_phrase(text) + chunk_tokens = set(chunk.tokens) | set(tokenize(text)) + score = 0.0 + score += len(chunk_tokens & evidence_profile.tokens) * 2.0 + for phrase in evidence_profile.phrases: + if len(phrase) >= 2 and phrase in normalized: + score += 5.0 + if "tops" in evidence_profile.tokens and re.search(r"\b\d+(?:\.\d+)?\s*tops\b", normalized): + score += 8.0 + if "算力" in evidence_profile.tokens and "tops" in normalized: + score += 6.0 + if "bpu" in evidence_profile.tokens and "bpu" in normalized: + score += 4.0 + if re.search(r"\b\d+(?:\.\d+)?\s*(tops|ghz|gb|mb|fps|v|a|w)\b", normalized): + score += 2.0 + if _is_low_signal(text): + score -= 8.0 + return score + + +def _is_evidence_candidate(text: str) -> bool: + stripped = text.lstrip() + return not stripped.startswith("|") and not stripped.startswith(">") + + +def _is_low_signal(text: str) -> bool: + stripped = text.strip() + without_marks = re.sub(r"[*_`#\-\s]+", "", stripped) + if len(without_marks) < 8: + return True + if stripped.startswith("```") or "```" in stripped: + return True + if stripped.startswith("|"): + return True + if "![](" in stripped: + return True + if re.search(r"(^|\n)\s*[├│└─]{2,}", stripped): + return True + return False + + +def _tags(kb: KnowledgeBaseConfig, chunk: Chunk, alias_group: Any | None) -> list[str]: + tags = [kb.name] + if alias_group is not None: + tags.append(_slug(str(alias_group.name)).replace("--", "-")) + for token in re.findall(r"[a-zA-Z][a-zA-Z0-9_-]{2,}", chunk.title): + lowered = token.lower() + if lowered not in tags: + tags.append(lowered) + return tags[:8] + + +def _aliases(title: str, query_entry: Any | None, alias_group: Any | None) -> list[str]: + values = [title] + if query_entry is not None: + values.extend(str(item) for item in getattr(query_entry, "aliases", ())) + if alias_group is not None: + values.extend(str(item) for item in getattr(alias_group, "terms", ())) + return _unique(values)[:12] + + +def _related_links(query_entry: Any | None, alias_group: Any | None) -> list[str]: + links: list[str] = [] + if query_entry is not None: + links.extend(str(item) for item in getattr(query_entry, "supporting_sources", ())) + if alias_group is not None: + links.extend(str(item) for item in getattr(alias_group, "related", ())) + return _unique(links)[:10] + + +def _unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + cleaned = value.strip() + if not cleaned or cleaned in seen: + continue + seen.add(cleaned) + output.append(cleaned) + return output + + +def _normalize_phrase(value: str) -> str: + return re.sub(r"\s+", " ", value.lower()).strip() + + +def _write_schema(wiki_root: Path, kb: KnowledgeBaseConfig) -> None: + (wiki_root / "SCHEMA.md").write_text( + "\n".join( + [ + "# Wiki Schema", + "", + "## Domain", + f"Compiled local knowledge for `{kb.name}`.", + "", + "## Conventions", + "- Pages live under `concepts/`.", + "- Every page has frontmatter with title, summary, sources, tags, aliases, confidence, and provenanceState.", + "- Claims in Key Evidence keep provenance markers pointing back to source block ids.", + "- Raw source files remain immutable; compiled pages are generated artifacts.", + "", + ] + ), + encoding="utf-8", + ) + + +def _write_index(wiki_root: Path, pages: list[CompiledPage]) -> None: + lines = ["# Index", "", "> Content catalog for compiled d-wiki pages.", "", "## Concepts", ""] + for page in sorted(pages, key=lambda item: item.title): + rel = page.path.relative_to(wiki_root).as_posix() + lines.append(f"- [[{rel[:-3]}]] — {page.title}") + lines.append("") + (wiki_root / "index.md").write_text("\n".join(lines), encoding="utf-8") + + +def _append_log(wiki_root: Path, kb: KnowledgeBaseConfig, chunks: int, pages: int) -> None: + line = f"- {datetime.now(timezone.utc).isoformat()} compiled `{kb.name}` from {chunks} chunks into {pages} pages.\n" + path = wiki_root / "log.md" + if not path.exists(): + path.write_text("# Log\n\n", encoding="utf-8") + with path.open("a", encoding="utf-8") as handle: + handle.write(line) + + +def _slug(value: str) -> str: + slug = re.sub(r"[^0-9A-Za-z\u4e00-\u9fff]+", "-", value).strip("-").lower() + return slug or "page" + + +def _yaml_scalar(value: str) -> str: + import json + + return json.dumps(value, ensure_ascii=False) + + +def _yaml_list(values: list[str]) -> str: + return "[" + ", ".join(_yaml_scalar(value) for value in values) + "]" + + +def json_dumps(value: Any) -> str: + return json.dumps(value, ensure_ascii=False, indent=2) diff --git a/d_wiki/config.py b/d_wiki/config.py new file mode 100644 index 0000000..b8bee1e --- /dev/null +++ b/d_wiki/config.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import os +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .yaml_compat import safe_load + + +@dataclass(frozen=True) +class KnowledgeBaseConfig: + name: str + root: Path + source_type: str + aliases_path: Path | None + queries_dir: Path | None + + +@dataclass(frozen=True) +class DWikiConfig: + path: Path + knowledge_bases: dict[str, KnowledgeBaseConfig] + + +def default_config_path() -> Path: + return Path(os.environ.get("D_WIKI_CONFIG", Path.cwd() / "d-wiki.yml")).expanduser() + + +def load_config(path: Path | None = None) -> DWikiConfig: + config_path = (path or default_config_path()).expanduser().resolve() + data = safe_load(config_path.read_text(encoding="utf-8")) or {} + raw_kbs = data.get("knowledge_bases") + if not isinstance(raw_kbs, dict): + raise ValueError("D_WIKI_CONFIG_MISSING_KNOWLEDGE_BASES") + bases: dict[str, KnowledgeBaseConfig] = {} + for name, raw in raw_kbs.items(): + if not isinstance(raw, dict): + raise ValueError(f"D_WIKI_KB_INVALID: {name}") + root = Path(str(raw.get("root", ""))).expanduser() + if not root.is_absolute(): + root = (config_path.parent / root).resolve() + aliases_path = _optional_path(config_path.parent, raw.get("aliases")) + queries_dir = _optional_path(config_path.parent, raw.get("queries")) + bases[str(name)] = KnowledgeBaseConfig( + name=str(name), + root=root, + source_type=str(raw.get("source_type", "markdown")), + aliases_path=aliases_path, + queries_dir=queries_dir, + ) + return DWikiConfig(path=config_path, knowledge_bases=bases) + + +def _optional_path(base: Path, value: Any) -> Path | None: + if not value: + return None + path = Path(str(value)).expanduser() + return path if path.is_absolute() else (base / path).resolve() diff --git a/d_wiki/dreams.py b/d_wiki/dreams.py new file mode 100644 index 0000000..ffec505 --- /dev/null +++ b/d_wiki/dreams.py @@ -0,0 +1,227 @@ +from __future__ import annotations + +import re +import shutil +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .metadata import frontmatter, load_query_entries + + +@dataclass(frozen=True) +class DreamedQuery: + slug: str + title: str + aliases: tuple[str, ...] + intent: str + primary_sources: tuple[str, ...] + supporting_sources: tuple[str, ...] + answer_requirements: tuple[str, ...] + + +def dream_kb(kb: KnowledgeBaseConfig, *, force: bool = False) -> dict[str, Any]: + wiki_root = kb.root / ".d_wiki" / "wiki" + if not wiki_root.is_dir(): + raise ValueError("D_WIKI_DREAM_REQUIRES_COMPILED_WIKI") + output_root = dream_root(kb) + queries_dir = output_root / "queries" + if force: + shutil.rmtree(output_root, ignore_errors=True) + queries_dir.mkdir(parents=True, exist_ok=True) + + pages = sorted((wiki_root / "concepts").glob("*.md")) + dreamed = [_dream_page(path, wiki_root) for path in pages] + dreamed = [item for item in dreamed if item is not None] + for item in dreamed: + (queries_dir / f"{item.slug}.md").write_text(_query_markdown(item), encoding="utf-8") + (output_root / "README.md").write_text(_readme(kb, len(pages), len(dreamed)), encoding="utf-8") + return { + "status": "dreamed", + "kb": kb.name, + "input_wiki": str(wiki_root), + "output_store": str(output_root), + "queries": len(dreamed), + "dreamed_at": datetime.now(timezone.utc).isoformat(), + } + + +def load_dream_query_entries(kb: KnowledgeBaseConfig) -> list[Any]: + return load_query_entries(dream_root(kb) / "queries") + + +def dream_root(kb: KnowledgeBaseConfig) -> Path: + return kb.root / ".d_wiki" / "dreams" / "latest" + + +def _dream_page(path: Path, wiki_root: Path) -> DreamedQuery | None: + meta, body = frontmatter(path.read_text(encoding="utf-8", errors="ignore")) + title = str(meta.get("title") or "").strip() + if not title: + return None + curation_body = _curation_body(body) + source = _first(meta.get("sources")) or _wikilink_for_compiled(path, wiki_root) + aliases = _unique([title, *_dream_aliases(title, curation_body)]) + intent = _first(meta.get("intents")) or _dream_intent(title, curation_body) + requirements = _as_list(meta.get("answer_requirements")) or _dream_requirements(title, curation_body, intent) + supporting = _related_sources(body, source) + return DreamedQuery( + slug=path.stem, + title=title, + aliases=tuple(aliases[:18]), + intent=intent, + primary_sources=(source,), + supporting_sources=tuple(supporting[:6]), + answer_requirements=tuple(requirements[:8]), + ) + + +def _dream_aliases(title: str, body: str) -> list[str]: + text = f"{title}\n{body}".lower() + aliases = [ + f"{title}怎么用", + f"如何使用{title}", + ] + if _looks_like_3d_generation(title, text): + aliases.extend( + [ + "3D资产生成怎么用", + "如何使用 3D 资产生成功能", + "我想知道如何使用3d资产生成功能", + "图生3D怎么用", + "如何生成3D模型", + "如何把图片生成3D资产", + ] + ) + if "camera" in text and any(term in text for term in ("点亮", "bring up", "sensor")): + aliases.extend(["如何在X5平台上点亮camera", "X5 camera 点亮", "X5 摄像头 bring up"]) + if any(term in text for term in ("算力", "tops", "bpu")): + aliases.extend(["x5的算力是多少", "X5 BPU 算力"]) + return aliases + + +def _dream_intent(title: str, body: str) -> str: + text = f"{title}\n{body}".lower() + if any(term in text for term in ("如何", "怎么", "步骤", "使用", "创建", "配置", "点亮", "生成", "调试", "bring up")): + return "procedure" + return "fact" + + +def _dream_requirements(title: str, body: str, intent: str) -> list[str]: + text = f"{title}\n{body}".lower() + if _looks_like_3d_generation(title, text): + return [ + "说明 3D 生成是图生 3D 工具,不是镜像资产", + "按准备参考图、生成、保存到 3D 资产的流程回答", + "说明输出默认 glb,生成结果可保存到 3D 资产", + "提醒暂不支持文生 3D,文字描述可先用图像生成产图", + ] + if intent == "procedure": + return ["按步骤回答", "说明关键前提和入口", "引用证据来源"] + return ["直接回答问题", "引用证据来源"] + + +def _looks_like_3d_generation(title: str, text: str) -> bool: + title_text = title.lower() + return ( + "3d 生成" in title_text + or "3d生成" in title_text + or "3d 资产生成" in title_text + or "3d资产生成" in title_text + or "embodygen" in text + or "ai 图生 3d 工具" in text + or "ai 图生3d 工具" in text + ) + + +def _curation_body(body: str) -> str: + lines: list[str] = [] + skip = False + for line in body.splitlines(): + if line.startswith("## "): + skip = line.strip() in {"## Retrieval Hints", "## Related"} + if skip: + continue + if not skip: + lines.append(line) + return "\n".join(lines) + + +def _related_sources(body: str, primary: str) -> list[str]: + links = re.findall(r"\[\[([^\]]+)\]\]", body) + refs = re.findall(r"\^\[([^#\]]+)(?:#[^\]]+)?\]", body) + return _unique([item for item in [*links, *refs] if item and item != primary]) + + +def _query_markdown(item: DreamedQuery) -> str: + lines = [ + "---", + f"title: {_yaml_scalar(item.title)}", + f"aliases: {_yaml_list(item.aliases)}", + f"intent: {item.intent}", + f"primary_sources: {_yaml_list(item.primary_sources)}", + f"supporting_sources: {_yaml_list(item.supporting_sources)}", + f"answer_requirements: {_yaml_list(item.answer_requirements)}", + "provenance: dreamed", + "---", + "", + f"Dreamed query memory for {item.title}.", + "", + ] + return "\n".join(lines) + + +def _readme(kb: KnowledgeBaseConfig, pages: int, queries: int) -> str: + return "\n".join( + [ + "# d-wiki dream output", + "", + "This store is generated from the compiled wiki. It does not modify source documents or compiled concept pages.", + "", + f"- kb: `{kb.name}`", + f"- input_pages: {pages}", + f"- dreamed_queries: {queries}", + "", + ] + ) + + +def _first(value: Any) -> str: + items = _as_list(value) + return items[0] if items else "" + + +def _as_list(value: Any) -> list[str]: + if isinstance(value, str): + return [value] + if isinstance(value, list): + return [str(item).strip() for item in value if str(item).strip()] + return [] + + +def _unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + cleaned = re.sub(r"\s+", " ", str(value)).strip() + if not cleaned or cleaned in seen: + continue + seen.add(cleaned) + output.append(cleaned) + return output + + +def _wikilink_for_compiled(path: Path, wiki_root: Path) -> str: + return path.relative_to(wiki_root).with_suffix("").as_posix() + + +def _yaml_scalar(value: str) -> str: + import json + + return json.dumps(value, ensure_ascii=False) + + +def _yaml_list(values: tuple[str, ...] | list[str]) -> str: + return "[" + ", ".join(_yaml_scalar(value) for value in values) + "]" diff --git a/d_wiki/llm.py b/d_wiki/llm.py new file mode 100644 index 0000000..959e902 --- /dev/null +++ b/d_wiki/llm.py @@ -0,0 +1,156 @@ +from __future__ import annotations + +import json +import os +import urllib.error +import urllib.request +from dataclasses import dataclass +from typing import Any + + +@dataclass(frozen=True) +class LlmSettings: + base_url: str + model: str + api_key: str + api_style: str = "anthropic" + max_tokens: int = 900 + + +@dataclass(frozen=True) +class LlmPageSynthesis: + summary: str + answer_blueprint: tuple[str, ...] + key_evidence: tuple[str, ...] + confidence: str = "medium" + + +class LlmPageSynthesizer: + def __init__(self, settings: LlmSettings) -> None: + self.settings = settings + + @classmethod + def from_environment(cls) -> "LlmPageSynthesizer | None": + base_url = os.environ.get("D_WIKI_LLM_BASE_URL") or os.environ.get("ROBOGO_LLM_BASE_URL") + model = os.environ.get("D_WIKI_LLM_MODEL") or os.environ.get("ROBOGO_LLM_MODEL") + api_key = os.environ.get("D_WIKI_LLM_API_KEY") or os.environ.get("ROBOGO_LLM_API_KEY") + if not base_url or not model or not api_key: + return None + api_style = os.environ.get("D_WIKI_LLM_API_STYLE") or os.environ.get("ROBOGO_LLM_API_STYLE") or "anthropic" + max_tokens = int(os.environ.get("D_WIKI_LLM_MAX_TOKENS", "900")) + return cls(LlmSettings(base_url=base_url, model=model, api_key=api_key, api_style=api_style, max_tokens=max_tokens)) + + def synthesize(self, prompt: str) -> LlmPageSynthesis | None: + text = self._complete(prompt).strip() + payload = _extract_json(text) + if not isinstance(payload, dict): + return None + summary = str(payload.get("summary") or "").strip() + if not summary: + return None + answer_blueprint = _string_tuple(payload.get("answer_blueprint")) + key_evidence = _string_tuple(payload.get("key_evidence")) + confidence = str(payload.get("confidence") or "medium").strip().lower() + if confidence not in {"low", "medium", "high"}: + confidence = "medium" + return LlmPageSynthesis( + summary=summary, + answer_blueprint=answer_blueprint, + key_evidence=key_evidence, + confidence=confidence, + ) + + def _complete(self, prompt: str) -> str: + if self.settings.api_style == "openai": + return self._complete_openai(prompt) + return self._complete_anthropic(prompt) + + def _complete_anthropic(self, prompt: str) -> str: + payload = { + "model": self.settings.model, + "max_tokens": self.settings.max_tokens, + "temperature": 0, + "system": "You compile local documentation into concise, evidence-grounded wiki pages. Return only JSON.", + "messages": [{"role": "user", "content": prompt}], + } + data = self._post_json(_join_url(self.settings.base_url, "v1/messages"), payload) + content = data.get("content") + if isinstance(content, list): + return "\n".join(str(item.get("text", "")) for item in content if isinstance(item, dict)) + return str(data.get("text") or "") + + def _complete_openai(self, prompt: str) -> str: + payload = { + "model": self.settings.model, + "temperature": 0, + "messages": [ + { + "role": "system", + "content": "You compile local documentation into concise, evidence-grounded wiki pages. Return only JSON.", + }, + {"role": "user", "content": prompt}, + ], + } + data = self._post_json(_join_url(self.settings.base_url, "v1/chat/completions"), payload) + choices = data.get("choices") + if isinstance(choices, list) and choices: + first = choices[0] + if isinstance(first, dict): + message = first.get("message") + if isinstance(message, dict): + return str(message.get("content") or "") + return "" + + def _post_json(self, url: str, payload: dict[str, Any]) -> dict[str, Any]: + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + request = urllib.request.Request( + url, + data=body, + method="POST", + headers={ + "content-type": "application/json", + "accept": "application/json", + "x-api-key": self.settings.api_key, + "authorization": f"Bearer {self.settings.api_key}", + "anthropic-version": "2023-06-01", + }, + ) + try: + with urllib.request.urlopen(request, timeout=60) as response: + return json.loads(response.read().decode("utf-8")) + except urllib.error.HTTPError as exc: + detail = exc.read().decode("utf-8", errors="ignore") + raise RuntimeError(f"D_WIKI_LLM_HTTP_ERROR: {exc.code} {detail[:300]}") from exc + + +def _join_url(base_url: str, suffix: str) -> str: + base = base_url.rstrip("/") + if base.endswith("/v1/messages") or base.endswith("/v1/chat/completions"): + return base + if base.endswith("/v1"): + return f"{base}/{suffix.removeprefix('v1/')}" + return f"{base}/{suffix}" + + +def _extract_json(text: str) -> Any: + cleaned = text.strip() + if cleaned.startswith("```"): + cleaned = cleaned.strip("`") + if cleaned.lower().startswith("json"): + cleaned = cleaned[4:].strip() + decoder = json.JSONDecoder() + for index, char in enumerate(cleaned): + if char != "{": + continue + try: + value, _end = decoder.raw_decode(cleaned[index:]) + except json.JSONDecodeError: + continue + return value + return None + + +def _string_tuple(value: Any) -> tuple[str, ...]: + if not isinstance(value, list): + return () + return tuple(str(item).strip() for item in value if str(item).strip()) diff --git a/d_wiki/metadata.py b/d_wiki/metadata.py new file mode 100644 index 0000000..dd41dfd --- /dev/null +++ b/d_wiki/metadata.py @@ -0,0 +1,119 @@ +from __future__ import annotations + +import re +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from .yaml_compat import safe_load +from .tokenize import tokenize + +QUERY_MATCH_STOP_TOKENS = { + "如何", + "怎么", + "使用", + "创建", + "知道", + "功能", + "资产", +} + + +@dataclass(frozen=True) +class AliasGroup: + name: str + terms: tuple[str, ...] + intent: str | None + related: tuple[str, ...] + + +@dataclass(frozen=True) +class QueryEntry: + path: Path + title: str + aliases: tuple[str, ...] + intent: str | None + primary_sources: tuple[str, ...] + supporting_sources: tuple[str, ...] + answer_requirements: tuple[str, ...] + + +def load_alias_groups(path: Path | None) -> list[AliasGroup]: + if path is None or not path.exists(): + return [] + data = safe_load(path.read_text(encoding="utf-8")) or {} + raw_aliases = data.get("aliases", {}) + if not isinstance(raw_aliases, dict): + return [] + groups: list[AliasGroup] = [] + for name, raw in raw_aliases.items(): + if not isinstance(raw, dict): + continue + groups.append( + AliasGroup( + name=str(name), + terms=tuple(str(term).strip() for term in raw.get("terms", []) if str(term).strip()), + intent=str(raw["intent"]) if raw.get("intent") else None, + related=tuple(str(item).strip() for item in raw.get("related", []) if str(item).strip()), + ) + ) + return groups + + +def load_query_entries(directory: Path | None) -> list[QueryEntry]: + if directory is None or not directory.exists(): + return [] + return [_query_entry(path) for path in sorted(directory.rglob("*.md")) if path.is_file()] + + +def frontmatter(text: str) -> tuple[dict[str, Any], str]: + if not text.startswith("---\n"): + return {}, text + end = text.find("\n---", 4) + if end < 0: + return {}, text + meta = safe_load(text[4:end]) or {} + if not isinstance(meta, dict): + meta = {} + return meta, text[end + 4 :].lstrip("\n") + + +def query_matches_entry(query: str, entry: QueryEntry) -> bool: + normalized = normalize(query) + if any(normalize(alias) in normalized or normalized in normalize(alias) for alias in entry.aliases): + return True + query_terms = _meaningful_query_terms(query) + for candidate in (entry.title, *entry.aliases): + candidate_terms = _meaningful_query_terms(candidate) + if len(query_terms & candidate_terms) >= 2: + return True + return False + + +def _meaningful_query_terms(value: str) -> set[str]: + return {term for term in tokenize(value) if term not in QUERY_MATCH_STOP_TOKENS and len(term.strip()) >= 2} + + +def normalize(value: str) -> str: + return re.sub(r"\s+", " ", value.lower()).strip() + + +def _query_entry(path: Path) -> QueryEntry: + meta, body = frontmatter(path.read_text(encoding="utf-8")) + title = str(meta.get("title") or _first_heading(body) or path.stem) + return QueryEntry( + path=path, + title=title, + aliases=tuple(str(item).strip() for item in meta.get("aliases", []) if str(item).strip()), + intent=str(meta["intent"]) if meta.get("intent") else None, + primary_sources=tuple(str(item).strip() for item in meta.get("primary_sources", []) if str(item).strip()), + supporting_sources=tuple(str(item).strip() for item in meta.get("supporting_sources", []) if str(item).strip()), + answer_requirements=tuple(str(item).strip() for item in meta.get("answer_requirements", []) if str(item).strip()), + ) + + +def _first_heading(text: str) -> str | None: + for line in text.splitlines(): + if match := re.match(r"^#{1,6}\s+(.+)$", line): + return match.group(1).strip() + return None diff --git a/d_wiki/search.py b/d_wiki/search.py new file mode 100644 index 0000000..07e396f --- /dev/null +++ b/d_wiki/search.py @@ -0,0 +1,469 @@ +from __future__ import annotations + +import json +import math +import re +from collections import Counter, defaultdict +from dataclasses import dataclass +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from .config import KnowledgeBaseConfig +from .metadata import ( + AliasGroup, + QueryEntry, + frontmatter, + load_alias_groups, + load_query_entries, + normalize, + query_matches_entry, +) +from .dreams import load_dream_query_entries +from .tokenize import tokenize + +SPHINX_SOURCE_SUFFIXES = (".md.txt", ".rst.txt") +MAX_BLOCK_CHARS = 520 + + +@dataclass(frozen=True) +class Chunk: + title: str + wikilink: str + source_path: Path + page_type: str + heading: str + text: str + tokens: tuple[str, ...] + index: int + + +def status_payload(config_path: Path, bases: dict[str, KnowledgeBaseConfig]) -> dict[str, Any]: + return { + "status": "ok", + "config": str(config_path), + "knowledge_bases": { + name: { + "root": str(kb.root), + "source_type": kb.source_type, + "exists": kb.root.exists(), + "aliases": str(kb.aliases_path) if kb.aliases_path else None, + "queries": str(kb.queries_dir) if kb.queries_dir else None, + } + for name, kb in bases.items() + }, + } + + +def index_payload(kb: KnowledgeBaseConfig) -> dict[str, Any]: + chunks = load_chunks(kb) + index_dir = kb.root / ".d_wiki_index" + index_dir.mkdir(exist_ok=True) + payload = { + "kb": kb.name, + "root": str(kb.root), + "source_type": kb.source_type, + "compiled_wiki": str(compiled_wiki_root(kb)) if compiled_wiki_root(kb).exists() else None, + "chunks": len(chunks), + "pages": len({chunk.wikilink for chunk in chunks}), + "indexed_at": datetime.now(timezone.utc).isoformat(), + } + (index_dir / f"{kb.name}.json").write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8") + return {"status": "indexed", **payload} + + +def search(kb: KnowledgeBaseConfig, query: str, max_results: int = 5) -> dict[str, Any]: + aliases = load_alias_groups(kb.aliases_path) + query_entries = [*load_query_entries(kb.queries_dir), *load_dream_query_entries(kb)] + matched_entries = [entry for entry in query_entries if query_matches_entry(query, entry)] + expanded_terms, matched_aliases = expand_query(query, aliases, matched_entries) + chunks = load_chunks(kb) + ranked = rank_chunks(chunks, expanded_terms, matched_aliases, matched_entries) + selected = ranked[: max(1, min(max_results, 8))] + context_pack = build_context_pack(query, selected, matched_aliases, matched_entries) + return { + "status": "found" if selected else "no_match", + "query": query, + "knowledge_base": kb.name, + "backend": "lightweight_bm25", + "quality": quality(selected), + "sources": [source_summary(item[1], item[0]) for item in selected], + "context_pack": context_pack, + } + + +def get_page(kb: KnowledgeBaseConfig, wikilink: str) -> dict[str, Any]: + chunks = [chunk for chunk in load_chunks(kb) if chunk.wikilink == wikilink] + if not chunks: + return {"status": "not_found", "knowledge_base": kb.name, "id": wikilink} + first = chunks[0] + return { + "status": "found", + "knowledge_base": kb.name, + "id": wikilink, + "title": first.title, + "source_path": str(first.source_path), + "blocks": [ + {"heading": chunk.heading, "text": chunk.text, "block_id": f"{chunk.wikilink}#{chunk.index}"} + for chunk in chunks + ], + } + + +def expand_query( + query: str, + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> tuple[list[str], list[AliasGroup]]: + terms = tokenize(query) + normalized_query = normalize(query) + matched: list[AliasGroup] = [] + for group in aliases: + if any(normalize(term) in normalized_query for term in group.terms): + matched.append(group) + for term in group.terms: + terms.extend(tokenize(term)) + for entry in entries: + terms.extend(tokenize(entry.title)) + for alias in entry.aliases: + terms.extend(tokenize(alias)) + return terms, matched + + +def rank_chunks( + chunks: list[Chunk], + terms: list[str], + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> list[tuple[float, Chunk]]: + if not chunks or not terms: + return [] + term_counts = [Counter(chunk.tokens) for chunk in chunks] + doc_freq: Counter[str] = Counter() + for counts in term_counts: + for term in counts: + doc_freq[term] += 1 + avg_len = sum(len(chunk.tokens) for chunk in chunks) / max(1, len(chunks)) + query_counts = Counter(terms) + ranked: list[tuple[float, Chunk]] = [] + related = {item for group in aliases for item in group.related} + primary = {item for entry in entries for item in entry.primary_sources} + supporting = {item for entry in entries for item in entry.supporting_sources} + for chunk, counts in zip(chunks, term_counts): + score = bm25_score(counts, len(chunk.tokens), doc_freq, len(chunks), avg_len, query_counts) + if any(wikilink_matches(chunk.wikilink, item) for item in related): + score += 8.0 + if any(wikilink_matches(chunk.wikilink, item) for item in primary): + score += 16.0 + if any(wikilink_matches(chunk.wikilink, item) for item in supporting): + score += 5.0 + score += heading_score_adjustment(chunk.heading) + if score > 0: + ranked.append((round(score, 3), chunk)) + ranked.sort(key=lambda item: (-item[0], item[1].wikilink, item[1].index)) + return ranked + + +def heading_score_adjustment(heading: str) -> float: + if heading == "Retrieval Hints": + return -80.0 + if heading == "Intent Model": + return -40.0 + if heading == "Answer Blueprint": + return -25.0 + if heading == "Evidence Graph": + return 3.0 + if heading == "Key Evidence": + return 5.0 + return 0.0 + + +def bm25_score( + counts: Counter[str], + doc_len: int, + doc_freq: Counter[str], + doc_count: int, + avg_len: float, + query_counts: Counter[str], +) -> float: + k1 = 1.5 + b = 0.75 + score = 0.0 + for term, qf in query_counts.items(): + tf = counts.get(term, 0) + if tf == 0: + continue + idf = math.log(1 + (doc_count - doc_freq[term] + 0.5) / (doc_freq[term] + 0.5)) + denom = tf + k1 * (1 - b + b * (doc_len / max(avg_len, 1))) + score += idf * ((tf * (k1 + 1)) / denom) * min(qf, 3) + return score + + +def build_context_pack( + query: str, + selected: list[tuple[float, Chunk]], + aliases: list[AliasGroup], + entries: list[QueryEntry], +) -> dict[str, Any]: + intent = answer_intent(query, aliases, entries) + grouped: dict[str, list[tuple[float, Chunk]]] = defaultdict(list) + for item in selected: + grouped[item[1].wikilink].append(item) + source_items = sorted(grouped.items(), key=lambda pair: -max(score for score, _chunk in pair[1])) + entry_primary = {item for entry in entries for item in entry.primary_sources} + primary_sources = [ + source_context(wikilink, chunks) + for wikilink, chunks in source_items + if not entry_primary or any(wikilink_matches(wikilink, item) for item in entry_primary) + ] + if not primary_sources: + primary_sources = [source_context(wikilink, chunks) for wikilink, chunks in source_items[:3]] + supporting_sources = [ + source_context(wikilink, chunks, blocks_limit=1) + for wikilink, chunks in source_items + if wikilink not in {source["wikilink"] for source in primary_sources} + ][:3] + coverage = "insufficient" if not selected else ("partial_procedure" if intent == "procedure" else "complete") + return { + "answer_intent": intent, + "coverage": coverage, + "answer_policy": "Use the evidence blocks to synthesize the answer. Do not answer from a single snippet.", + "primary_sources": primary_sources, + "supporting_sources": supporting_sources, + "answer_requirements": answer_requirements(intent, entries), + } + + +def source_context(wikilink: str, chunks: list[tuple[float, Chunk]], blocks_limit: int = 4) -> dict[str, Any]: + top = sorted(chunks, key=lambda item: (-item[0], item[1].index))[:blocks_limit] + chunk = top[0][1] + return { + "title": chunk.title, + "wikilink": wikilink, + "source_path": str(chunk.source_path), + "reason": "Matched query terms and local metadata.", + "blocks": [ + { + "block_id": f"{block.wikilink}#{block.index}", + "heading": block.heading, + "text": trim_block(block.text), + "score": score, + } + for score, block in top + ], + } + + +def answer_intent(query: str, aliases: list[AliasGroup], entries: list[QueryEntry]) -> str: + for entry in entries: + if entry.intent: + return entry.intent + for group in aliases: + if group.intent: + return group.intent + if any(term in query.lower() for term in ("如何", "怎么", "步骤", "点亮", "bring up", "配置")): + return "procedure" + return "fact" + + +def answer_requirements(intent: str, entries: list[QueryEntry]) -> list[str]: + requirements = unique([req for entry in entries for req in entry.answer_requirements]) + if requirements: + return requirements + if intent == "procedure": + return ["基于 primary_sources 综合步骤化回答", "说明关键前提和验证方式", "引用命中的来源"] + return ["直接回答问题", "引用命中的来源"] + + +def unique(values: list[str]) -> list[str]: + seen: set[str] = set() + output: list[str] = [] + for value in values: + if value in seen: + continue + seen.add(value) + output.append(value) + return output + + +def quality(selected: list[tuple[float, Chunk]]) -> dict[str, Any]: + top = selected[0][0] if selected else 0.0 + return { + "confidence": "high" if top >= 8.0 else ("low" if selected else "none"), + "high_confidence": top >= 8.0, + "top_score": top, + "high_confidence_score": 8.0, + } + + +def wikilink_matches(candidate: str, expected: str) -> bool: + return candidate == expected or candidate == f"concepts/{expected}" + + +def source_summary(chunk: Chunk, score: float) -> dict[str, Any]: + return { + "title": chunk.title, + "wikilink": chunk.wikilink, + "source_path": str(chunk.source_path), + "heading": chunk.heading, + "snippet": trim_block(chunk.text, 320), + "score": score, + } + + +def load_chunks(kb: KnowledgeBaseConfig) -> list[Chunk]: + root = compiled_wiki_root(kb) if compiled_wiki_root(kb).is_dir() else kb.root + paths = source_paths(root) + chunks: list[Chunk] = [] + for path in paths: + chunks.extend(chunks_for_path(path, root)) + return chunks + + +def load_source_chunks(kb: KnowledgeBaseConfig) -> list[Chunk]: + chunks: list[Chunk] = [] + for path in source_paths(kb.root): + chunks.extend(chunks_for_path(path, kb.root)) + return chunks + + +def compiled_wiki_root(kb: KnowledgeBaseConfig) -> Path: + return kb.root / ".d_wiki" / "wiki" + + +def source_paths(root: Path) -> list[Path]: + if (root / "_sources").is_dir(): + return sorted( + path + for path in (root / "_sources").rglob("*.txt") + if path.is_file() and path.name.endswith(SPHINX_SOURCE_SUFFIXES) + ) + generated = {"SCHEMA.md", "index.md", "log.md"} + generated_dirs = {".d_wiki", ".d_wiki_index"} + is_compiled_root = root.name == "wiki" and root.parent.name == ".d_wiki" + return sorted( + path + for path in root.rglob("*.md") + if path.is_file() + and path.name not in generated + and (is_compiled_root or not any(part in generated_dirs for part in path.parts)) + ) + + +def chunks_for_path(path: Path, root: Path) -> list[Chunk]: + raw = path.read_text(encoding="utf-8", errors="ignore") + meta, body = frontmatter(raw) + title = str(meta.get("title") or first_heading(body) or path.stem.replace("-", " ").title()) + metadata_text = metadata_terms(meta) + wikilink = wikilink_for(path, root) + sections = split_sections(body, title) + chunks: list[Chunk] = [] + for index, (heading, text) in enumerate(sections): + if heading in {"Source Map", "Related"}: + continue + if not text.strip(): + continue + field_text = " ".join([title, heading, wikilink, metadata_text, text]) + chunks.append( + Chunk( + title=title, + wikilink=wikilink, + source_path=path.resolve(), + page_type="sphinx_source" if "_sources" in path.parts else "markdown", + heading=heading, + text=text.strip(), + tokens=tuple(tokenize(field_text)), + index=index, + ) + ) + return chunks + + +def metadata_terms(meta: dict[str, Any]) -> str: + values: list[str] = [] + for key in ("aliases", "tags", "intents", "related", "retrieval_hints", "answer_requirements"): + raw = meta.get(key) + if isinstance(raw, str): + values.append(raw) + elif isinstance(raw, list): + values.extend(str(item) for item in raw if str(item).strip()) + return " ".join(values) + + +def split_sections(body: str, title: str) -> list[tuple[str, str]]: + heading = title + buffer: list[str] = [] + sections: list[tuple[str, str]] = [] + in_fence = False + for line in body.splitlines(): + stripped = line.strip() + if stripped.startswith("```"): + in_fence = not in_fence + buffer.append(line) + continue + if not in_fence and (match := re.match(r"^#{1,6}\s+(.+)$", line)): + if buffer: + sections.extend(paragraphs(heading, "\n".join(buffer))) + buffer = [] + heading = match.group(1).strip() or title + continue + buffer.append(line) + if buffer: + sections.extend(paragraphs(heading, "\n".join(buffer))) + return sections or [(title, body)] + + +def paragraphs(heading: str, text: str) -> list[tuple[str, str]]: + blocks: list[tuple[str, str]] = [] + for part in re.split(r"\n\s*\n", text): + cleaned = clean_block(part) + if cleaned: + blocks.append((heading, cleaned)) + return blocks + + +def clean_block(text: str) -> str: + stripped = text.strip() + if not stripped: + return "" + if re.fullmatch(r"[-*_]{3,}", stripped): + return "" + compact = " ".join(stripped.split()) + if "📷" in compact and len(compact) <= 80: + return "" + if compact.startswith("> 📷") and len(compact) <= 120: + return "" + return stripped + + +def first_heading(body: str) -> str | None: + in_fence = False + for line in body.splitlines(): + stripped = line.strip() + if stripped.startswith("```"): + in_fence = not in_fence + continue + if in_fence: + continue + if match := re.match(r"^#{1,6}\s+(.+)$", line): + return match.group(1).strip() + return None + + +def wikilink_for(path: Path, root: Path) -> str: + try: + relative = path.relative_to(root) + except ValueError: + return path.stem + if relative.parts and relative.parts[0] == "_sources": + relative = Path(*relative.parts[1:]) + value = relative.as_posix() + for suffix in SPHINX_SOURCE_SUFFIXES: + if value.endswith(suffix): + return value[: -len(suffix)] + return value[:-3] if value.endswith(".md") else path.stem + + +def trim_block(text: str, limit: int = MAX_BLOCK_CHARS) -> str: + compact = " ".join(text.split()) + return compact if len(compact) <= limit else compact[:limit].rstrip() diff --git a/d_wiki/tokenize.py b/d_wiki/tokenize.py new file mode 100644 index 0000000..09823c6 --- /dev/null +++ b/d_wiki/tokenize.py @@ -0,0 +1,22 @@ +from __future__ import annotations + +import re + +STOP_CJK = set("的是多少什么怎么如何吗呢啊了在上") +STOP_TERMS = {"x5", "如何", "怎么", "什么", "多少", "平台"} + + +def tokenize(text: str) -> list[str]: + lowered = text.lower() + terms = re.findall(r"[a-z0-9_./+-]+", lowered) + cjk_chars = re.findall(r"[\u4e00-\u9fff]", text) + terms.extend("".join(cjk_chars[index : index + 2]) for index in range(max(0, len(cjk_chars) - 1))) + return [term for term in terms if _useful(term)] + + +def _useful(term: str) -> bool: + if not term or term in STOP_TERMS: + return False + if re.search(r"[\u4e00-\u9fff]", term): + return not (all(char in STOP_CJK for char in term) or any(char in STOP_CJK for char in term)) + return True diff --git a/d_wiki/yaml_compat.py b/d_wiki/yaml_compat.py new file mode 100644 index 0000000..61cf7ab --- /dev/null +++ b/d_wiki/yaml_compat.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +from typing import Any + +try: + import yaml as _yaml # type: ignore +except Exception: # pragma: no cover - exercised in environments without PyYAML + _yaml = None + + +def safe_load(text: str) -> Any: + if _yaml is not None: + return _yaml.safe_load(text) + lines = [ + (len(line) - len(line.lstrip(" ")), line.strip()) + for line in text.splitlines() + if line.strip() and not line.strip().startswith("#") + ] + value, _index = _parse_node(lines, 0, 0) + return value + + +def _parse_node(lines: list[tuple[int, str]], index: int, indent: int) -> tuple[Any, int]: + if index >= len(lines): + return {}, index + if lines[index][0] < indent: + return {}, index + if lines[index][1].startswith("- "): + values: list[Any] = [] + while index < len(lines) and lines[index][0] == indent and lines[index][1].startswith("- "): + values.append(_scalar(lines[index][1][2:].strip())) + index += 1 + return values, index + mapping: dict[str, Any] = {} + while index < len(lines): + current_indent, stripped = lines[index] + if current_indent < indent: + break + if current_indent > indent: + break + if ":" not in stripped: + index += 1 + continue + key, raw_value = stripped.split(":", 1) + key = key.strip() + raw_value = raw_value.strip() + index += 1 + if raw_value: + mapping[key] = _scalar(raw_value) + continue + child, index = _parse_node(lines, index, indent + 2) + mapping[key] = child + return mapping, index + + +def _scalar(value: str) -> Any: + if value in {"null", "None", "~"}: + return None + if value in {"true", "True"}: + return True + if value in {"false", "False"}: + return False + if value.startswith("[") and value.endswith("]"): + inner = value[1:-1].strip() + if not inner: + return [] + return [_scalar(item.strip()) for item in inner.split(",")] + if (value.startswith('"') and value.endswith('"')) or (value.startswith("'") and value.endswith("'")): + return value[1:-1] + return value diff --git a/docs/language-decision.md b/docs/language-decision.md new file mode 100644 index 0000000..aaf929d --- /dev/null +++ b/docs/language-decision.md @@ -0,0 +1,56 @@ +# d-wiki CLI language decision + +## Decision + +Use Python for the first implementation of `d-wiki`. + +The CLI is a local knowledge retrieval component that needs predictable file +system traversal, Markdown/Sphinx source parsing, YAML metadata, BM25 ranking, +JSON output, and straightforward integration with `robogo_assistant_service`. +Python is the lower-risk choice for this first version because the surrounding +service code and tests are already Python, and the implementation intentionally +avoids qmd, embeddings, and Node-specific runtime requirements. + +## Python pros + +- Matches the existing `robogo_assistant_service` stack, test style, and local + developer workflow. +- Strong standard library support for CLI parsing, paths, subprocess-friendly + JSON output, dataclasses, and text processing. +- Easy to keep dependency-light; the current package has no required runtime + dependencies and can optionally use PyYAML when present. +- Good fit for future retrieval upgrades such as ranking experiments, + evaluation scripts, corpus analysis, and possible embedding backends. +- Lower integration friction for service tests that call the CLI from Python. + +## Python cons + +- Single-file executable distribution is less natural than Node/npm CLIs unless + extra packaging tools are introduced. +- Startup can be slower than a bundled JS runtime for very small commands, + though this is not a bottleneck for local document search. +- Type safety depends on discipline and tools rather than the language runtime. + +## TypeScript pros + +- Excellent CLI packaging through npm and strong cross-platform installation + conventions for JS-heavy teams. +- Static types are first-class and make API shape evolution explicit. +- Easier future alignment if `d-wiki` becomes a qmd-native or MCP-first Node + package. + +## TypeScript cons + +- Adds a second runtime stack beside the Python service for the first version. +- The plan explicitly avoids qmd/Node runtime complexity in v1; starting with + TypeScript would pull the project toward the complexity it is trying to defer. +- Requires build tooling, lockfiles, module-format decisions, and generated + output conventions before the retrieval logic itself benefits from them. +- Python service integration would still happen through subprocess JSON, so the + main service does not gain much from a TypeScript implementation today. + +## Revisit triggers + +Reconsider TypeScript if `d-wiki` becomes a distributed npm CLI, adopts qmd as +the default backend, ships an MCP server primarily for Node-based agents, or +needs to share substantial code with a TypeScript UI or SDK. diff --git a/knowledge/robogo/aliases.yml b/knowledge/robogo/aliases.yml new file mode 100644 index 0000000..be0351f --- /dev/null +++ b/knowledge/robogo/aliases.yml @@ -0,0 +1,25 @@ +aliases: + dev_machine: + terms: [开发机, 云主机, SSH, Web 应用, 申请开发机, 创建开发机, 远程开发] + intent: procedure + related: [21-dev-machine] + guagan: + terms: [地瓜干, 计费, 充值, 余额, 消费, 价格, 账户] + intent: fact + related: [03-account-and-guagan] + mirror: + terms: [镜像, 镜像资产, 创建镜像, 保存镜像, fork, 公开镜像, 群组镜像] + intent: procedure + related: [11-mirror-center, 20-cloud-desktop] + three_d_generation: + terms: [3D生成, 3D 生成, 图生3D, 图生 3D, 3D资产生成, 3D 资产生成, 资产生成, 3d资产生成功能, EmbodyGen, glb] + intent: procedure + related: [40-3d-generation, 12-3d-assert, 41-image-generation, 42-urdf-studio] + rdk_agent: + terms: [RDK Agent, VS Code 插件, 插件安装] + intent: procedure + related: [51-rdk-agent, 50-openclaw] + openclaw: + terms: [OpenClaw, MagicBox, openclaw-magicbox, rdkclaw, 智能控制, AI 代理, Agent Platform, 设备配对, Skills 管理, 飞书] + intent: procedure + related: [50-openclaw, 51-rdk-agent] diff --git a/knowledge/robogo/queries/3d-generation.md b/knowledge/robogo/queries/3d-generation.md new file mode 100644 index 0000000..b8438b4 --- /dev/null +++ b/knowledge/robogo/queries/3d-generation.md @@ -0,0 +1,25 @@ +--- +title: 3D 资产生成 +aliases: + - 我想知道如何使用3d资产生成功能 + - 如何使用 3D 资产生成功能 + - 3D资产生成怎么用 + - 3D 生成怎么用 + - 图生3D怎么用 + - 如何生成3D模型 + - 如何把图片生成3D资产 +intent: procedure +primary_sources: + - 40-3d-generation +supporting_sources: + - 12-3d-assert + - 41-image-generation + - 42-urdf-studio +answer_requirements: + - 说明 3D 生成是图生 3D 工具,不是镜像资产 + - 按准备参考图、生成、保存到 3D 资产的流程回答 + - 说明输出默认 glb,生成结果可保存到 3D 资产 + - 提醒暂不支持文生 3D,文字描述可先用图像生成产图 +--- + +RoboGo 3D 资产生成 / 图生 3D 的入口问题。 diff --git a/knowledge/robogo/queries/dev-machine.md b/knowledge/robogo/queries/dev-machine.md new file mode 100644 index 0000000..e69b614 --- /dev/null +++ b/knowledge/robogo/queries/dev-machine.md @@ -0,0 +1,7 @@ +--- +title: 开发机使用 +aliases: [开发机怎么用, 如何使用开发机, 怎么创建开发机, 开发机 SSH, 开发机 Web 应用] +intent: procedure +primary_sources: [21-dev-machine] +answer_requirements: [说明开发机定位, 按创建和登录步骤回答, 说明 Web 应用和 SSH 入口] +--- diff --git a/knowledge/robogo/queries/guagan.md b/knowledge/robogo/queries/guagan.md new file mode 100644 index 0000000..3d2d8e1 --- /dev/null +++ b/knowledge/robogo/queries/guagan.md @@ -0,0 +1,7 @@ +--- +title: 地瓜干计费 +aliases: [地瓜干怎么计费, 地瓜干是什么, 怎么充值, 余额在哪里看] +intent: fact +primary_sources: [03-account-and-guagan] +answer_requirements: [说明地瓜干用途, 说明充值和消费路径, 引用计费口径以平台实际页面为准] +--- diff --git a/knowledge/robogo/queries/mirror.md b/knowledge/robogo/queries/mirror.md new file mode 100644 index 0000000..5416423 --- /dev/null +++ b/knowledge/robogo/queries/mirror.md @@ -0,0 +1,8 @@ +--- +title: 镜像资产使用 +aliases: [镜像怎么使用, 如何创建镜像, 怎么保存镜像, 镜像资产怎么用] +intent: procedure +primary_sources: [11-mirror-center] +supporting_sources: [20-cloud-desktop] +answer_requirements: [区分镜像地址导入和地瓜桌面保存, 说明 Fork 和分享, 引用镜像资产来源] +--- diff --git a/knowledge/robogo/queries/openclaw.md b/knowledge/robogo/queries/openclaw.md new file mode 100644 index 0000000..f7be91f --- /dev/null +++ b/knowledge/robogo/queries/openclaw.md @@ -0,0 +1,8 @@ +--- +title: OpenClaw 使用 +aliases: [如何使用openclaw, OpenClaw 怎么用, 如何创建 OpenClaw, MagicBox 怎么用, OpenClaw 设备配对, OpenClaw Skills] +intent: procedure +primary_sources: [50-openclaw] +supporting_sources: [51-rdk-agent] +answer_requirements: [说明 OpenClaw 定位, 说明实例类型和创建入口, 说明 Skills/飞书/设备配对的使用路径] +--- diff --git a/knowledge/robogo/queries/rdk-agent.md b/knowledge/robogo/queries/rdk-agent.md new file mode 100644 index 0000000..c34cc1e --- /dev/null +++ b/knowledge/robogo/queries/rdk-agent.md @@ -0,0 +1,8 @@ +--- +title: RDK Agent 使用 +aliases: [RDK Agent 怎么用, 如何安装 RDK Agent, RDK Agent 插件, RDK 设备怎么接入] +intent: procedure +primary_sources: [51-rdk-agent] +supporting_sources: [50-openclaw] +answer_requirements: [说明 RDK Agent 是 VS Code 插件入口, 区分设备接入在 OpenClaw MagicBox, 引用页面注意事项] +--- diff --git a/knowledge/x5/aliases.yml b/knowledge/x5/aliases.yml new file mode 100644 index 0000000..742138b --- /dev/null +++ b/knowledge/x5/aliases.yml @@ -0,0 +1,33 @@ +aliases: + camera-bring-up: + terms: + - camera + - 摄像头 + - sensor + - mipi + - csi + - vin + - isp + - camsys + - 点亮 + - bring up + - bring-up + - bringup + - 调试 + - 配置 + - 预览 + intent: procedure + related: + - multimedia_development/7-camsys_debug + - samples/sunrise_camera_user_guide + - samples/sample_pipeline + compute: + terms: + - 算力 + - tops + - bpu + - bayes + - bayers + intent: fact + related: + - preface/overview diff --git a/knowledge/x5/queries/camera-bring-up.md b/knowledge/x5/queries/camera-bring-up.md new file mode 100644 index 0000000..9c1f5d9 --- /dev/null +++ b/knowledge/x5/queries/camera-bring-up.md @@ -0,0 +1,19 @@ +--- +title: X5 camera bring up +aliases: + - 如何在X5平台上点亮camera + - X5 camera 点亮 + - X5 摄像头 bring up +intent: procedure +primary_sources: + - multimedia_development/7-camsys_debug +supporting_sources: + - samples/sunrise_camera_user_guide + - samples/sample_pipeline +answer_requirements: + - 说明这是 X5 camera bring up / 点亮流程 + - 按硬件连接、DTS/GPIO、sensor 驱动、MIPI 配置、运行验证组织 + - 引用 Camera调试指南 和 Sunrise camera 用户使用说明等来源 +--- + +X5 平台点亮 camera 的入口问题。 diff --git a/knowledge/x5/queries/compute.md b/knowledge/x5/queries/compute.md new file mode 100644 index 0000000..2d70ab6 --- /dev/null +++ b/knowledge/x5/queries/compute.md @@ -0,0 +1,14 @@ +--- +title: X5 算力 +aliases: + - x5的算力是多少 + - X5 BPU 算力 +intent: fact +primary_sources: + - preface/overview +answer_requirements: + - 直接给出 X5 BPU 算力 + - 保留 TOPS 和 BPU 信息 +--- + +X5 算力参数入口问题。 diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..b7d5d1e --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,17 @@ +[build-system] +requires = ["setuptools>=68"] +build-backend = "setuptools.build_meta" + +[project] +name = "d-wiki" +version = "0.1.0" +description = "Lightweight local knowledge retrieval with BM25 and metadata context packs." +requires-python = ">=3.10" +dependencies = [] + +[project.scripts] +d-wiki = "d_wiki.cli:main" + +[tool.setuptools.packages.find] +where = ["."] +include = ["d_wiki*"] diff --git a/tests/__pycache__/test_d_wiki.cpython-311-pytest-9.0.3.pyc b/tests/__pycache__/test_d_wiki.cpython-311-pytest-9.0.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49c77f29bdbb42ffaace5b3cf25f0326ee66f93d GIT binary patch literal 25064 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 literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_d_wiki.cpython-312.pyc b/tests/__pycache__/test_d_wiki.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a8252177806900df7a53806e2c9aaa9528ea0ff GIT binary patch literal 20696 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 BC{h3b literal 0 HcmV?d00001 diff --git a/tests/__pycache__/test_d_wiki.cpython-314.pyc b/tests/__pycache__/test_d_wiki.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..172982477d6708c2a38eb2823038af55124a8a1e GIT binary patch literal 8503 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 None: + entry = QueryEntry( + path=Path("camera.md"), + title="camera bring up", + aliases=("如何在X5平台上点亮camera",), + intent="procedure", + primary_sources=("multimedia_development/7-camsys_debug",), + supporting_sources=(), + answer_requirements=(), + ) + + self.assertTrue(query_matches_entry("X5平台 点亮 camera 使能", entry)) + + def test_bm25_metadata_context_pack_for_camera_bring_up(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + config = root / "d-wiki.yml" + output = self._run_json( + [ + "--config", + str(config), + "search", + "--kb", + "x5", + "--query", + "如何在X5平台上点亮camera", + "--format", + "json", + ] + ) + + self.assertEqual(output["status"], "found") + self.assertEqual(output["context_pack"]["answer_intent"], "procedure") + self.assertEqual(output["context_pack"]["coverage"], "partial_procedure") + first = output["context_pack"]["primary_sources"][0] + self.assertEqual(first["wikilink"], "multimedia_development/7-camsys_debug") + self.assertGreaterEqual(len(first["blocks"]), 2) + self.assertIn("点亮 camera", json.dumps(first, ensure_ascii=False)) + + def test_rewritten_camera_query_still_uses_query_entry_primary_source(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "x5", + "--query", + "X5平台 点亮 camera 使能", + "--format", + "json", + ] + ) + + self.assertEqual(output["status"], "found") + first = output["context_pack"]["primary_sources"][0] + self.assertEqual(first["wikilink"], "multimedia_development/7-camsys_debug") + + def test_fact_query_for_compute(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "x5", + "--query", + "x5的算力是多少", + "--format", + "json", + ] + ) + + self.assertEqual(output["status"], "found") + self.assertEqual(output["context_pack"]["answer_intent"], "fact") + self.assertIn("10 TOPS", json.dumps(output["context_pack"], ensure_ascii=False)) + + def test_unrelated_query_is_insufficient(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "x5", + "--query", + "火星咖啡机怎么维修", + "--format", + "json", + ] + ) + + self.assertEqual(output["status"], "no_match") + self.assertEqual(output["context_pack"]["coverage"], "insufficient") + + def test_page_frontmatter_metadata_participates_in_retrieval(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "x5", + "--query", + "x5 coredump breadcrumbs", + "--format", + "json", + ] + ) + + self.assertEqual(output["status"], "found") + self.assertEqual(output["sources"][0]["wikilink"], "misc/pstore") + + def test_markdown_cleaning_filters_thematic_breaks_and_screenshot_only_blocks(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + docs = root / "docs" + docs.mkdir() + (docs / "dev-machine.md").write_text( + "# 开发机\n\n" + "> 📷 截图:开发机列表页\n\n" + "---\n\n" + "开发机支持 SSH 登录和 Web 应用访问。\n", + encoding="utf-8", + ) + (root / "d-wiki.yml").write_text( + "knowledge_bases:\n" + " robogo:\n" + f" root: {docs}\n" + " source_type: markdown\n", + encoding="utf-8", + ) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "robogo", + "--query", + "开发机怎么用", + "--format", + "json", + ] + ) + + snippets = [str(source["snippet"]) for source in output["sources"]] + self.assertNotIn("---", snippets) + self.assertFalse(any("📷" in snippet for snippet in snippets)) + self.assertIn("开发机支持 SSH 登录", snippets[0]) + + def test_compile_builds_wiki_pages_and_search_prefers_compiled_wiki(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + config = root / "d-wiki.yml" + compiled = self._run_json( + [ + "--config", + str(config), + "compile", + "--kb", + "x5", + "--force", + "--format", + "json", + ] + ) + indexed = self._run_json( + [ + "--config", + str(config), + "index", + "--kb", + "x5", + "--format", + "json", + ] + ) + output = self._run_json( + [ + "--config", + str(config), + "search", + "--kb", + "x5", + "--query", + "x5的算力是多少", + "--format", + "json", + ] + ) + wiki_root = Path(str(compiled["wiki_root"])) + self.assertEqual(compiled["status"], "compiled") + self.assertTrue((wiki_root / "SCHEMA.md").exists()) + self.assertTrue((wiki_root / "index.md").exists()) + self.assertTrue((wiki_root / "concepts" / "preface-overview.md").exists()) + self.assertEqual(indexed["compiled_wiki"], str(wiki_root)) + self.assertEqual(output["status"], "found") + self.assertIn(".d_wiki/wiki/concepts", output["sources"][0]["source_path"]) + self.assertIn("10 TOPS", json.dumps(output["context_pack"], ensure_ascii=False)) + + def test_compile_emits_llm_wiki_structure_without_breaking_retrieval(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + config = root / "d-wiki.yml" + compiled = self._run_json( + [ + "--config", + str(config), + "compile", + "--kb", + "x5", + "--force", + "--format", + "json", + ] + ) + self._run_json( + [ + "--config", + str(config), + "index", + "--kb", + "x5", + "--format", + "json", + ] + ) + compute = self._run_json( + [ + "--config", + str(config), + "search", + "--kb", + "x5", + "--query", + "x5的算力是多少", + "--format", + "json", + ] + ) + camera = self._run_json( + [ + "--config", + str(config), + "search", + "--kb", + "x5", + "--query", + "如何在X5平台上点亮camera", + "--format", + "json", + ] + ) + + wiki_root = Path(str(compiled["wiki_root"])) + compute_page = (wiki_root / "concepts" / "preface-overview.md").read_text(encoding="utf-8") + camera_page = ( + wiki_root / "concepts" / "multimedia-development-7-camsys-debug.md" + ).read_text(encoding="utf-8") + + self.assertIn("llmWikiVersion: \"1\"", compute_page) + self.assertIn("## Intent Model", compute_page) + self.assertIn("## Retrieval Hints", compute_page) + self.assertIn("## Answer Blueprint", compute_page) + self.assertIn("## Evidence Graph", compute_page) + self.assertIn("## Key Evidence", compute_page) + self.assertIn("X5 算力", compute_page) + self.assertIn("10 TOPS", compute_page) + self.assertIn("- intent: fact", compute_page) + self.assertIn("- intent: procedure", camera_page) + self.assertIn("按步骤回答", camera_page) + self.assertEqual(compute["status"], "found") + self.assertIn("10 TOPS", json.dumps(compute["context_pack"], ensure_ascii=False)) + self.assertIn( + "Key Evidence", + [block["heading"] for block in compute["context_pack"]["primary_sources"][0]["blocks"]], + ) + self.assertEqual(camera["context_pack"]["answer_intent"], "procedure") + self.assertEqual( + camera["context_pack"]["primary_sources"][0]["wikilink"], + "concepts/multimedia-development-7-camsys-debug", + ) + self.assertNotEqual(camera["sources"][0]["heading"], "Retrieval Hints") + + def test_dream_queries_route_without_manual_query_entry(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + docs = root / "docs" + docs.mkdir() + (docs / "11-mirror-center.md").write_text( + "# 镜像资产使用\n\n" + "镜像资产是 RoboGo 的容器环境仓库,用于保存和复用开发环境。\n", + encoding="utf-8", + ) + (docs / "40-3d-generation.md").write_text( + "# 40 · 3D 生成\n\n" + "3D 生成是平台提供的 AI 图生 3D 工具,基于 EmbodyGen,用一张参考图片生成 3D 模型,默认 glb。\n\n" + "生成结果可以保存到 3D 资产继续使用。\n", + encoding="utf-8", + ) + (root / "knowledge" / "robogo").mkdir(parents=True) + (root / "knowledge" / "robogo" / "aliases.yml").write_text( + "aliases:\n" + " mirror:\n" + " terms: [镜像, 镜像资产, 创建镜像]\n" + " intent: procedure\n" + " related: [11-mirror-center]\n", + encoding="utf-8", + ) + (root / "d-wiki.yml").write_text( + "knowledge_bases:\n" + " robogo:\n" + f" root: {docs}\n" + " source_type: markdown\n" + " aliases: knowledge/robogo/aliases.yml\n", + encoding="utf-8", + ) + compiled = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "compile", + "--kb", + "robogo", + "--force", + "--format", + "json", + ] + ) + dreamed = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "dream", + "--kb", + "robogo", + "--force", + "--format", + "json", + ] + ) + self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "index", + "--kb", + "robogo", + "--format", + "json", + ] + ) + output = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "search", + "--kb", + "robogo", + "--query", + "我想知道如何使用3d资产生成功能", + "--format", + "json", + ] + ) + page = Path(str(compiled["wiki_root"])) / "concepts" / "40-3d-generation.md" + page_content = page.read_text(encoding="utf-8") + dreamed_query = Path(str(dreamed["output_store"])) / "queries" / "40-3d-generation.md" + dreamed_content = dreamed_query.read_text(encoding="utf-8") + + self.assertNotIn("dream_queries:", page_content) + self.assertIn("3D资产生成怎么用", dreamed_content) + self.assertIn("provenance: dreamed", dreamed_content) + self.assertEqual(output["status"], "found") + self.assertEqual(output["context_pack"]["primary_sources"][0]["wikilink"], "concepts/40-3d-generation") + self.assertNotIn("镜像资产使用", json.dumps(output["context_pack"]["answer_requirements"], ensure_ascii=False)) + + def test_compile_llm_auto_falls_back_without_llm_config(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = self._fixture(Path(tmp)) + compiled = self._run_json( + [ + "--config", + str(root / "d-wiki.yml"), + "compile", + "--kb", + "x5", + "--force", + "--llm", + "auto", + "--format", + "json", + ] + ) + page = Path(str(compiled["wiki_root"])) / "concepts" / "preface-overview.md" + page_content = page.read_text(encoding="utf-8") + + self.assertEqual(compiled["status"], "compiled") + self.assertEqual(compiled["llm_mode"], "auto") + self.assertEqual(compiled["llm_scope"], "queries") + self.assertFalse(compiled["llm_enabled"]) + self.assertIn("provenanceState: compiled", page_content) + + def _run_json(self, argv: list[str]) -> dict[str, object]: + from contextlib import redirect_stdout + from io import StringIO + + out = StringIO() + with redirect_stdout(out): + code = main(argv) + self.assertEqual(code, 0, out.getvalue()) + return json.loads(out.getvalue()) + + def _fixture(self, root: Path) -> Path: + sources = root / "manual" / "_sources" + (sources / "multimedia_development").mkdir(parents=True) + (sources / "preface").mkdir(parents=True) + (sources / "misc").mkdir(parents=True) + (sources / "multimedia_development" / "7-camsys_debug.md.txt").write_text( + "# Camera调试指南\n\n" + "## 一 范围\n\n" + "本章节概述了 camera bring up 的过程,用于帮助读者快速了解并掌握 X5 camera 框架," + "如何快速的新增camera 配置,并点亮 camera。\n\n" + "## 1.1 sensor gpio 配置\n\n" + "vcon 是 X5 camera 用于管理 sensor 硬件相关的 dts 节点。\n\n" + "## 2 sensor 驱动文件添加\n\n" + "需要将原厂 sensor 驱动转换成 X5 camera 驱动代码,并编译生成 so 库。\n", + encoding="utf-8", + ) + (sources / "preface" / "overview.md.txt").write_text( + "# 前言\n\n## 关键特性\n\n- 贝叶斯架构BPU,提供最高 10 TOPS 算力。\n", + encoding="utf-8", + ) + (sources / "misc" / "pstore.md.txt").write_text( + "---\n" + "title: pstore\n" + "aliases: [coredump breadcrumbs]\n" + "tags: [debug, reboot]\n" + "---\n" + "# pstore\n\n在X5平台上,当系统异常重启时会保存日志。\n", + encoding="utf-8", + ) + (root / "knowledge" / "x5" / "queries").mkdir(parents=True) + (root / "knowledge" / "x5" / "aliases.yml").write_text( + "aliases:\n" + " camera:\n" + " terms: [camera, 摄像头, sensor, mipi, csi, vin, isp, 点亮, bring up, 调试, 配置]\n" + " intent: procedure\n" + " related: [multimedia_development/7-camsys_debug]\n" + " compute:\n" + " terms: [算力, tops, bpu]\n" + " intent: fact\n" + " related: [preface/overview]\n", + encoding="utf-8", + ) + (root / "knowledge" / "x5" / "queries" / "camera.md").write_text( + "---\n" + "title: camera bring up\n" + "aliases: [如何在X5平台上点亮camera]\n" + "intent: procedure\n" + "primary_sources: [multimedia_development/7-camsys_debug]\n" + "answer_requirements: [按步骤回答]\n" + "---\n", + encoding="utf-8", + ) + (root / "knowledge" / "x5" / "queries" / "compute.md").write_text( + "---\n" + "title: X5 算力\n" + "aliases: [x5的算力是多少]\n" + "intent: fact\n" + "primary_sources: [preface/overview]\n" + "---\n", + encoding="utf-8", + ) + (root / "d-wiki.yml").write_text( + "knowledge_bases:\n" + " x5:\n" + f" root: {root / 'manual'}\n" + " source_type: sphinx\n" + " aliases: knowledge/x5/aliases.yml\n" + " queries: knowledge/x5/queries\n", + encoding="utf-8", + ) + return root + + +if __name__ == "__main__": + unittest.main()