source-kb 0.2.26__tar.gz → 0.2.28__tar.gz

{source_kb-0.2.26/source_kb.egg-info → source_kb-0.2.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: source-kb
-Version: 0.2.26
+Version: 0.2.28
 Summary: Auto-generate structured knowledge base documents from source code. Supports AI agent mode (skill-based) and standalone CLI.
 License-Expression: MIT
 Keywords: knowledge-base,documentation,code-analysis,llm,rag

source_kb-0.2.28/cli/commands/cross_graph.py

@@ -0,0 +1,27 @@
+"""source-kb cross-graph — Query cross-module call graph."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("cross-graph", help="Query cross-module call graph")
+    p.add_argument("--knowledge-dir", required=True, help="Knowledge base directory")
+    p.add_argument("action", choices=["stats", "callers", "callees", "dependents", "rebuild"],
+                   help="Cross-graph query action")
+    p.add_argument("--module", help="Module name (for callers/callees/dependents)")
+    p.add_argument("--target", help="Target class name (for callers/callees)")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_cross_graph import cmd_cross_graph
+
+    cmd_cross_graph(
+        knowledge_dir=Path(args.knowledge_dir),
+        action=args.action,
+        module=args.module,
+        target=args.target,
+    )

source_kb-0.2.28/cli/commands/dispatch_preview.py

@@ -0,0 +1,28 @@
+"""source-kb dispatch-preview — Generate dispatch plan preview (lightweight)."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("dispatch-preview", help="Generate dispatch plan preview (lightweight)")
+    p.add_argument("--config", help="kb-project.yaml path")
+    p.add_argument("--kb", required=True, help="Knowledge base name")
+    p.add_argument("--module", required=True, help="Module name")
+    p.add_argument("--mode", default="readwrite", choices=["readwrite", "output-only"])
+    p.add_argument("--module-type", help="Module type override")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_dispatch_preview import cmd_dispatch_preview
+
+    cmd_dispatch_preview(
+        config=Path(args.config) if args.config else None,
+        kb=args.kb,
+        module=args.module,
+        mode=args.mode or "readwrite",
+        module_type=args.module_type,
+    )

source_kb-0.2.28/cli/commands/graph.py

@@ -0,0 +1,27 @@
+"""source-kb graph — Query module call graph."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("graph", help="Query module call graph")
+    p.add_argument("--module-dir", required=True, help="Module knowledge directory")
+    p.add_argument("action", choices=["stats", "callers", "callees", "dependents", "dependencies"],
+                   help="Graph query action")
+    p.add_argument("--target", help="Target class name for query")
+    p.add_argument("--depth", type=int, default=2, help="Traversal depth (default: 2)")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_graph import cmd_graph
+
+    cmd_graph(
+        module_dir=Path(args.module_dir),
+        action=args.action,
+        target=args.target,
+        depth=args.depth,
+    )

source_kb-0.2.28/cli/commands/impact.py

@@ -0,0 +1,32 @@
+"""source-kb impact — Analyze change impact at section level."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("impact", help="Analyze change impact at section level")
+    p.add_argument("--module-dir", required=True, help="Module knowledge directory")
+    p.add_argument("--preset", required=True, help="Preset name")
+    p.add_argument("--source-cache", help="Source cache directory")
+    p.add_argument("--files", nargs="+", required=True, help="Changed file paths")
+    p.add_argument("--changes-json", help="Path to change details JSON")
+    p.add_argument("--include-cross-module", action="store_true", help="Enable cross-module impact")
+    p.add_argument("--knowledge-dir", help="Knowledge dir (required for cross-module)")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_impact import cmd_impact
+
+    cmd_impact(
+        module_dir=Path(args.module_dir),
+        preset=args.preset,
+        source_cache=Path(args.source_cache) if args.source_cache else None,
+        files=args.files,
+        changes_json=Path(args.changes_json) if args.changes_json else None,
+        knowledge_dir=Path(args.knowledge_dir) if args.knowledge_dir else None,
+        include_cross_module=args.include_cross_module,
+    )

source_kb-0.2.28/cli/commands/inject_version.py

@@ -0,0 +1,22 @@
+"""source-kb inject-version — Inject version headers into generated docs."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("inject-version", help="Inject version headers into generated docs")
+    p.add_argument("--module-dir", required=True, help="Module knowledge directory")
+    p.add_argument("--source-commit", default="", help="Source commit hash")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_inject_version import cmd_inject_version
+
+    cmd_inject_version(
+        module_dir=Path(args.module_dir),
+        source_commit=args.source_commit or "",
+    )

source_kb-0.2.28/cli/commands/sync_prompt.py

@@ -0,0 +1,20 @@
+"""source-kb sync-prompt — Generate section-level sync prompts from impact JSON."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser("sync-prompt", help="Generate section-level sync prompts from impact analysis")
+    p.add_argument("--module-dir", required=True, help="Module knowledge directory")
+    p.add_argument("--source-cache", help="Source cache directory")
+    p.add_argument("--impact-json", help="Path to impact analysis JSON (or stdin)")
+    p.add_argument("--output-dir", help="Output directory for prompt files")
+    p.add_argument("--force", action="store_true", help="Skip fingerprint check, regenerate all")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> None:
+    from core.skeleton.cmd_sync_prompt import run as _impl
+    _impl(args)

{source_kb-0.2.26 → source_kb-0.2.28}/core/__init__.py

@@ -17,6 +17,8 @@ Layers:
     core.docs        — Shared document generation
 """
 
+from __future__ import annotations
+
 import logging
 from importlib.metadata import version, PackageNotFoundError
 

{source_kb-0.2.26 → source_kb-0.2.28}/core/docs/__init__.py

@@ -5,3 +5,5 @@ Generates cross-module summary documents in _shared/ directory:
 - cross-module-calls.md
 - error-codes.md (if applicable)
 """
+
+from __future__ import annotations

{source_kb-0.2.26 → source_kb-0.2.28}/core/docs/shared.py

@@ -134,7 +134,7 @@ def _generate_error_codes(shared_dir: Path, modules: list[Path]) -> bool:
     import re
 
     error_code_re = re.compile(r'^\|\s*(\w+[-_]?\d+)\s*\|')
-    header_re = re.compile(r'^#{2,4}\s+.*错误码|error.?code', re.IGNORECASE)
+    header_re = re.compile(r'^#{2,4}\s+.*错误码|error.?code', re.IGNORECASE)  # matches Chinese "error code" or English
 
     all_codes: list[tuple[str, str, str]] = []  # (module, code, line)
 

{source_kb-0.2.26 → source_kb-0.2.28}/core/monitor/__init__.py

@@ -3,3 +3,5 @@
 Provides structured progress file read/write and heartbeat timeout detection.
 Used by both CLI (automatic heartbeat) and Agent (manual progress check).
 """
+
+from __future__ import annotations

{source_kb-0.2.26 → source_kb-0.2.28}/core/paths.py

@@ -98,6 +98,36 @@ def cross_module_graph_path(knowledge_dir: Path) -> Path:
     return knowledge_dir / "_shared" / "cross-module-graph.json"
 
 
+def dispatch_tasks_path(module_dir: Path) -> Path:
+    """Path to dispatch tasks manifest."""
+    return meta_dir(module_dir) / "dispatch-tasks.json"
+
+
+def dispatch_plan_path(module_dir: Path) -> Path:
+    """Path to dispatch plan markdown."""
+    return meta_dir(module_dir) / "dispatch-plan.md"
+
+
+def heartbeat_path(module_dir: Path) -> Path:
+    """Path to generation heartbeat file."""
+    return meta_dir(module_dir) / "heartbeat.txt"
+
+
+def outlines_dir(module_dir: Path) -> Path:
+    """Path to outlines directory for two-phase generation."""
+    return meta_dir(module_dir) / "outlines"
+
+
+def classify_cache_path(module_dir: Path) -> Path:
+    """Path to LLM classification cache."""
+    return meta_dir(module_dir) / ".llm-classify-cache.json"
+
+
+def impact_result_path(module_dir: Path) -> Path:
+    """Path to impact analysis result."""
+    return meta_dir(module_dir) / "impact-result.json"
+
+
 def shard_file_list_path(module_dir: Path, doc_type: str, shard_name: str) -> Path:
     """File list path for a shard: .meta/file-lists/{doc_type}-{shard_name}.txt"""
     return file_list_dir(module_dir) / f"{doc_type}-{shard_name}.txt"

{source_kb-0.2.26 → source_kb-0.2.28}/core/prompt/__init__.py

@@ -5,3 +5,5 @@ Sub-modules:
     content     — Source reading, skeleton reading, context building
     templates   — PromptTemplate dataclass + registry
 """
+
+from __future__ import annotations

{source_kb-0.2.26 → source_kb-0.2.28}/core/prompt/__main__.py

@@ -14,78 +14,81 @@ from pathlib import Path
 sys.stdout.reconfigure(encoding="utf-8")
 
 
-def cmd_render(args: argparse.Namespace) -> None:
+def cmd_render(
+    module: str,
+    kb: str,
+    doc_type: str,
+    config: Path | None = None,
+    template: str | None = None,
+    mode: str = "readwrite",
+    output: Path | None = None,
+    extra: list[str] | None = None,
+) -> None:
     """Render a sub-agent prompt from template."""
     from core.config import load_config
     from core.preset import load_preset
     from core.prompt.renderer import render_prompt
 
-    config = load_config(Path(args.config) if args.config else None)
-    kb_config = config.get_kb(args.kb)
+    cfg = load_config(config)
+    kb_config = cfg.get_kb(kb)
     preset_name = kb_config.get("preset", "generic")
     preset = load_preset(preset_name)
 
-    # In Agent mode, use ReferenceAssembler (paths only, no inline content)
     from core.prompt.variables import ReferencePromptAssembler
     assembler = ReferencePromptAssembler(project_root=Path(".").resolve(), preset=preset)
 
-    # Resolve template: explicit --template takes priority, otherwise lookup from doc_types.yaml
-    template_name = args.template
+    template_name = template
     if not template_name:
         doc_types = preset.get("doc_types", {})
-        dt_cfg = doc_types.get(args.doc_type, {})
+        dt_cfg = doc_types.get(doc_type, {})
         template_name = dt_cfg.get("template")
         if not template_name:
-            print(f"Error: no template mapping for doc-type '{args.doc_type}' in {preset_name}/doc_types.yaml. "
+            print(f"Error: no template mapping for doc-type '{doc_type}' in {preset_name}/doc_types.yaml. "
                   f"Specify --template explicitly.", file=sys.stderr)
             sys.exit(1)
 
-    # Find template
     template_path = _find_template(template_name, preset_name)
     if not template_path:
         print(f"Error: template not found: {template_name}", file=sys.stderr)
         sys.exit(1)
 
-    # Parse extras
     extras = {}
-    if args.extra:
-        for item in args.extra:
+    if extra:
+        for item in extra:
             if "=" in item:
                 k, v = item.split("=", 1)
                 extras[k] = v
 
-    # Load execution snippet
     execution_snippet = ""
-    if args.mode == "readwrite":
+    if mode == "readwrite":
         snippet_path = _find_execution_snippet("readwrite.md")
         if snippet_path:
             execution_snippet = snippet_path.read_text(encoding="utf-8")
-    elif args.mode == "output-only":
+    elif mode == "output-only":
         snippet_path = _find_execution_snippet("output-only.md")
         if snippet_path:
             execution_snippet = snippet_path.read_text(encoding="utf-8")
 
     rendered = render_prompt(
         template_path=template_path,
-        config=config.raw,
-        kb_name=args.kb,
-        module_name=args.module,
-        doc_type=args.doc_type,
+        config=cfg.raw,
+        kb_name=kb,
+        module_name=module,
+        doc_type=doc_type,
         assembler=assembler,
         extras=extras,
         execution_snippet=execution_snippet,
         preset=preset,
     )
 
-    if args.output:
-        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
-        Path(args.output).write_text(rendered, encoding="utf-8")
-        print(f"Rendered to: {args.output} ({len(rendered)} chars)")
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(rendered, encoding="utf-8")
+        print(f"Rendered to: {output} ({len(rendered)} chars)")
     else:
-        # Default: write to .meta/prompts/{doc_type}.md to avoid flooding stdout
-        meta_prompts = Path(f"knowledge/{args.module}/.meta/prompts")
+        meta_prompts = Path(f"knowledge/{module}/.meta/prompts")
         meta_prompts.mkdir(parents=True, exist_ok=True)
-        out_path = meta_prompts / f"{args.doc_type}.md"
+        out_path = meta_prompts / f"{doc_type}.md"
         out_path.write_text(rendered, encoding="utf-8")
         print(f"Rendered to: {out_path} ({len(rendered)} chars)")
 
@@ -121,7 +124,7 @@ def _find_execution_snippet(filename: str) -> Path | None:
     return None
 
 
-def main():
+def main() -> None:
     import warnings
     warnings.warn(
         "Use 'source-kb render' instead of 'python -m core.prompt render'",
@@ -151,7 +154,16 @@ def main():
         sys.exit(1)
 
     if args.command == "render":
-        cmd_render(args)
+        cmd_render(
+            module=args.module,
+            kb=args.kb,
+            doc_type=args.doc_type,
+            config=Path(args.config) if args.config else None,
+            template=args.template,
+            mode=args.mode,
+            output=Path(args.output) if args.output else None,
+            extra=args.extra,
+        )
     elif args.command == "validate-parity":
         from core.prompt.validate_parity import main as parity_main
         # Re-parse with validate_parity's own parser

{source_kb-0.2.26 → source_kb-0.2.28}/core/prompt/content.py

@@ -95,10 +95,18 @@ def build_prior_docs_context(
     remaining = max_chars
     for dep_type in dep_docs:
         filename = _doc_type_to_filename(dep_type)
-        doc_path = module_dir / filename
-        if not doc_path.exists():
-            continue
-        summary = _extract_doc_summary(doc_path)
+        # Prefer pre-computed summary (fast, no full-file read)
+        summary_file = module_dir / ".meta" / "summaries" / f"{dep_type}.txt"
+        if summary_file.exists():
+            try:
+                summary = summary_file.read_text(encoding="utf-8").strip()
+            except (OSError, UnicodeDecodeError):
+                summary = ""
+        else:
+            doc_path = module_dir / filename
+            if not doc_path.exists():
+                continue
+            summary = _extract_doc_summary(doc_path)
         if not summary:
             continue
         section = f"### {filename}\n{summary}"
@@ -293,6 +301,11 @@ def _extract_doc_summary(path: Path, max_lines: int = 15) -> str:
         content = path.read_text(encoding="utf-8")
     except (OSError, UnicodeDecodeError):
         return ""
+    return _summarize_content(content)
+
+
+def _summarize_content(content: str) -> str:
+    """Extract title + heading list from document content string."""
     lines = content.splitlines()
     title = ""
     for line in lines[:5]:
@@ -308,6 +321,19 @@ def _extract_doc_summary(path: Path, max_lines: int = 15) -> str:
     return "\n".join(parts)
 
 
+def write_doc_summary(module_dir: Path, doc_type: str, content: str) -> None:
+    """Write pre-computed summary for a generated document.
+
+    Stored at .meta/summaries/{doc_type}.txt for fast lookup by build_prior_docs_context.
+    """
+    summary = _summarize_content(content)
+    if not summary:
+        return
+    summaries_dir = module_dir / ".meta" / "summaries"
+    summaries_dir.mkdir(parents=True, exist_ok=True)
+    (summaries_dir / f"{doc_type}.txt").write_text(summary, encoding="utf-8")
+
+
 def _extract_shard_summary(path: Path) -> str:
     """Extract heading list from a shard document."""
     try:

{source_kb-0.2.26 → source_kb-0.2.28}/core/prompt/renderer.py

@@ -89,14 +89,22 @@ def render_prompt(
     # Delegate content assembly to the injected strategy
     file_list_override = (extras or {}).get("file_list_override")
     file_list = assembler.resolve_file_list(module_dir, doc_type, file_list_override=file_list_override)
+    skeleton_content = assembler.resolve_skeleton_content(module_dir)
+
+    # Budget-based source reading: estimate fixed overhead, cap source to remaining budget
+    source_budget = _compute_source_budget(template, skeleton_content, assembler)
+    budget_kwargs = {"budget_bytes": source_budget} if source_budget is not None else {}
+
     if file_list_override and Path(file_list_override).exists():
         override_content = Path(file_list_override).read_text(encoding="utf-8").strip()
         source_content = assembler.resolve_source_content_from_paths(
-            module_dir, doc_type, source_cache, override_content.splitlines()
+            module_dir, doc_type, source_cache, override_content.splitlines(),
+            **budget_kwargs,
         )
     else:
-        source_content = assembler.resolve_source_content(module_dir, doc_type, source_cache)
-    skeleton_content = assembler.resolve_skeleton_content(module_dir)
+        source_content = assembler.resolve_source_content(
+            module_dir, doc_type, source_cache, **budget_kwargs,
+        )
 
     # Compute metadata
     from core.skeleton.metadata import load_pregenerated
@@ -172,6 +180,13 @@ def render_prompt(
     if prior:
         variables["prior_docs_context"] = prior
 
+    # Load shared common-rules snippet from preset directory
+    preset_dir = preset.get("_preset_dir", "") if preset else ""
+    if preset_dir:
+        common_rules_path = Path(preset_dir) / "common-rules.md"
+        if common_rules_path.exists():
+            variables["common_rules"] = common_rules_path.read_text(encoding="utf-8").strip()
+
     # Merge extras (user-provided overrides)
     variables.update({k: v for k, v in extras.items() if not k.startswith("__")})
 
@@ -234,3 +249,40 @@ def _find_repo(config: dict, kb_name: str, module_name: str) -> dict:
             if repo["name"] == module_name:
                 return repo
     return {"name": module_name}
+
+
+def _compute_source_budget(template: str, skeleton_content: str, assembler) -> int | None:
+    """Estimate remaining byte budget for source content.
+
+    Uses context_manager.estimate_tokens to calculate how much of the 128K context
+    is already consumed by template + skeleton, then returns remaining bytes.
+    Returns None if budget is not constraining (plenty of room).
+    """
+    from core.prompt.context_manager import estimate_tokens
+
+    max_context_tokens = 128_000
+    reserve_output_tokens = 16_000
+    available_tokens = max_context_tokens - reserve_output_tokens
+
+    template_tokens = estimate_tokens(template)
+    skeleton_tokens = estimate_tokens(skeleton_content)
+    overhead_tokens = 2000  # metadata, prior_docs, file_list, etc.
+
+    used_tokens = template_tokens + skeleton_tokens + overhead_tokens
+    remaining_tokens = available_tokens - used_tokens
+
+    if remaining_tokens <= 0:
+        return 10_000  # minimum floor
+
+    # Convert tokens to bytes (conservative: ~3 bytes per token for code)
+    remaining_bytes = remaining_tokens * 3
+
+    # Only constrain if budget is tighter than the assembler's own max
+    if not hasattr(assembler, '_max_source'):
+        return None
+    try:
+        if remaining_bytes >= assembler._max_source:
+            return None
+    except TypeError:
+        return None
+    return remaining_bytes

{source_kb-0.2.26 → source_kb-0.2.28}/core/rag/__init__.py

@@ -4,6 +4,8 @@ Provides document loading, chunking, index building, and retrieval.
 Embedding backend is configurable via Config (ollama, openai, dashscope, chromadb-default).
 """
 
+from __future__ import annotations
+
 from core.rag.loader import Document, load_documents
 from core.rag.chunker import Chunk, chunk_documents
 from core.rag.embedder import get_embeddings

{source_kb-0.2.26 → source_kb-0.2.28}/core/rag/__main__.py

@@ -16,17 +16,17 @@ from pathlib import Path
 sys.stdout.reconfigure(encoding="utf-8")
 
 
-def cmd_search(args: argparse.Namespace) -> None:
+def cmd_search(query: str, kb: str, config: Path | None = None) -> None:
     """Search knowledge base."""
     from core.config import load_config, find_config
     from core.rag.retriever import retrieve
 
-    config_path = Path(args.config) if args.config else find_config()
-    config = load_config(config_path)
+    config_path = config if config else find_config()
+    cfg = load_config(config_path)
 
-    results = retrieve(args.query, config, kb_name=args.kb)
+    results = retrieve(query, cfg, kb_name=kb)
     if not results:
-        print(f"No results for '{args.query}'")
+        print(f"No results for '{query}'")
         print(json.dumps({"status": "ok", "matches": 0}, ensure_ascii=False), file=sys.stderr)
         return
 
@@ -44,16 +44,16 @@ def cmd_search(args: argparse.Namespace) -> None:
     print(json.dumps({"status": "ok", "matches": len(results)}, ensure_ascii=False), file=sys.stderr)
 
 
-def cmd_index(args: argparse.Namespace) -> None:
+def cmd_index(kb: str, config: Path | None = None) -> None:
     """Build/rebuild full vector index."""
     from core.config import load_config, find_config
     from core.rag.loader import load_documents
     from core.rag.chunker import chunk_documents
     from core.rag.indexer import build_index
 
-    config_path = Path(args.config) if args.config else find_config()
-    config = load_config(config_path)
-    kb_cfg = config.get_kb(args.kb)
+    config_path = config if config else find_config()
+    cfg = load_config(config_path)
+    kb_cfg = cfg.get_kb(kb)
     knowledge_dir = kb_cfg["knowledge_dir"]
     collection_name = kb_cfg["collection"]
 
@@ -65,30 +65,30 @@ def cmd_index(args: argparse.Namespace) -> None:
 
     chunks = chunk_documents(docs)
     print(f"Indexing {len(docs)} docs, {len(chunks)} chunks...")
-    build_index(chunks, collection_name, config, kb_name=args.kb)
+    build_index(chunks, collection_name, cfg, kb_name=kb)
     print(f"Index built: {len(chunks)} chunks -> collection '{collection_name}'")
     print(json.dumps({"status": "ok", "docs": len(docs), "chunks": len(chunks),
                       "collection": collection_name}, ensure_ascii=False), file=sys.stderr)
 
 
-def cmd_rebuild(args: argparse.Namespace) -> None:
+def cmd_rebuild(kb: str, config: Path | None = None, module: str | None = None, files: list[str] | None = None) -> None:
     """Incremental rebuild — re-index only specified files."""
     from core.config import load_config, find_config
     from core.rag.loader import load_documents
     from core.rag.chunker import chunk_documents
     from core.rag.indexer import build_index
 
-    config_path = Path(args.config) if args.config else find_config()
-    config = load_config(config_path)
-    kb_cfg = config.get_kb(args.kb)
+    config_path = config if config else find_config()
+    cfg = load_config(config_path)
+    kb_cfg = cfg.get_kb(kb)
     knowledge_dir = Path(kb_cfg["knowledge_dir"])
     collection_name = kb_cfg["collection"]
 
-    files = args.files or []
-    if files:
-        docs = load_documents(knowledge_dir, module=args.module, files=files)
+    resolved_files = files or []
+    if resolved_files:
+        docs = load_documents(knowledge_dir, module=module, files=resolved_files)
     else:
-        docs = load_documents(knowledge_dir, module=args.module)
+        docs = load_documents(knowledge_dir, module=module)
 
     if not docs:
         print(f"No documents to rebuild")
@@ -97,13 +97,13 @@ def cmd_rebuild(args: argparse.Namespace) -> None:
 
     chunks = chunk_documents(docs)
     print(f"Rebuilding {len(docs)} docs, {len(chunks)} chunks...")
-    build_index(chunks, collection_name, config, kb_name=args.kb, module=args.module, files=args.files or None)
+    build_index(chunks, collection_name, cfg, kb_name=kb, module=module, files=resolved_files or None)
     print(f"Rebuilt: {len(chunks)} chunks -> collection '{collection_name}'")
     print(json.dumps({"status": "ok", "docs": len(docs), "chunks": len(chunks)},
                      ensure_ascii=False), file=sys.stderr)
 
 
-def main():
+def main() -> None:
     parser = argparse.ArgumentParser(prog="python -m core.rag", description="RAG tools")
     parser.add_argument("--config", help="kb-project.yaml path (auto-detected)")
     sub = parser.add_subparsers(dest="command")
@@ -125,8 +125,13 @@ def main():
         parser.print_help()
         sys.exit(1)
 
-    commands = {"search": cmd_search, "index": cmd_index, "rebuild": cmd_rebuild}
-    commands[args.command](args)
+    config_path = Path(args.config) if args.config else None
+    if args.command == "search":
+        cmd_search(query=args.query, kb=args.kb, config=config_path)
+    elif args.command == "index":
+        cmd_index(kb=args.kb, config=config_path)
+    elif args.command == "rebuild":
+        cmd_rebuild(kb=args.kb, config=config_path, module=args.module, files=args.files)
 
 
 if __name__ == "__main__":

{source_kb-0.2.26 → source_kb-0.2.28}/core/skeleton/__init__.py

@@ -9,3 +9,5 @@ Sub-modules:
     metadata    — Global metadata pre-generation
     merge       — Shard merge (fast) + post-merge refinement
 """
+
+from __future__ import annotations