kstudiochat 1.0.0__py3-none-any.whl

deployments/cli.py

@@ -0,0 +1,318 @@
+"""
+K-CHAT CLI entry point.
+
+Usage:
+    python -m kchat chat --data ./examples/government
+    python -m kchat serve --data ./examples/government --port 8000
+    python -m kchat init ./my_industry
+    python -m kchat validate ./examples/government
+    python -m kchat info ./examples/government
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import sys
+from pathlib import Path
+
+from engine.config import IndustryPack
+from engine.retrieval import DocumentLoader
+
+
+def _init_readline():
+    """Enable readline-style history if available."""
+    try:
+        import readline
+        import atexit
+        histfile = Path.home() / ".kchat_history"
+        try:
+            readline.read_history_file(histfile)
+        except (FileNotFoundError, OSError):
+            pass
+        atexit.register(readline.write_history_file, histfile)
+    except ImportError:
+        pass
+
+
+def _color(text: str, code: str) -> str:
+    """Wrap text in ANSI color code (no-op on Windows without colorama)."""
+    try:
+        import colorama
+        colorama.just_fix_windows_console()
+    except ImportError:
+        pass
+    import os
+    if os.environ.get("NO_COLOR"):
+        return text
+    codes = {"green": "32", "yellow": "33", "blue": "34", "cyan": "36", "bold": "1", "dim": "2"}
+    c = codes.get(code, "")
+    return f"\033[{c}m{text}\033[0m" if c else text
+
+
+async def _async_chat_loop(bot) -> int:
+    _init_readline()
+    name = bot.config.name
+    print(f"{_color('K-CHAT', 'cyan')} — {_color(name, 'bold')}")
+    print(f"Persona: {bot.config.persona}")
+    print(f"LLM: {_color(bot.llm.provider_name, 'green')}")
+    n_chunks = len(bot.retriever.store._chunks) if hasattr(bot.retriever.store, '_chunks') else 'n/a'
+    print(f"Knowledge chunks: {_color(str(n_chunks), 'yellow')}")
+    print(f"Commands: {_color('/help', 'dim')}  {_color('/clear', 'dim')}  {_color('/quit', 'dim')}\n")
+
+    user_history = []
+
+    while True:
+        try:
+            prompt = _color(f"({name}) ", "dim") + _color("You", "green") + " > "
+            user_input = input(prompt)
+        except (EOFError, KeyboardInterrupt):
+            print(f"\n{_color('Bot', 'cyan')}: Goodbye!")
+            break
+        if not user_input.strip():
+            continue
+
+        # Multiline: if line ends with """, keep reading
+        if user_input.rstrip().endswith("\"\"\""):
+            lines = [user_input]
+            while True:
+                try:
+                    line = input(_color("... ", "dim"))
+                except (EOFError, KeyboardInterrupt):
+                    break
+                if line.rstrip().startswith("\"\"\""):
+                    lines.append(line)
+                    break
+                lines.append(line)
+            user_input = "\n".join(lines)
+
+        cmd = user_input.strip().lower()
+        if cmd in ("/quit", "/exit", "/bye", "quit", "exit", "bye"):
+            print(f"{_color('Bot', 'cyan')}: Goodbye!")
+            break
+        if cmd == "/clear":
+            user_history.clear()
+            import os as _os
+            _os.system("cls" if _os.name == "nt" else "clear")
+            continue
+        if cmd == "/help":
+            print(f"Commands:")
+            print(f"  {_color('/quit', 'bold')}   - Exit the chat")
+            print(f"  {_color('/clear', 'bold')}  - Clear screen")
+            print(f"  {_color('/multiline', 'bold')}  - Enter multiline mode (end line with \"\"\")")
+            print(f"  {_color('/help', 'bold')}   - Show this help")
+            continue
+        try:
+            r = await bot.chat(user_input, user_id="cli_user")
+        except Exception as e:
+            print(f"{_color('Error', 'yellow')}: {e}")
+            logging.exception("chat failed")
+            continue
+        user_history.append((user_input, r.answer))
+        print(f"{_color('Bot', 'cyan')}: {r.answer}")
+        extras = []
+        if r.citations:
+            extras.append(f"sources: {', '.join(r.citations[:3])}")
+        if r.confidence:
+            extras.append(f"confidence: {r.confidence} ({r.confidence_score:.2f})")
+        if r.intent:
+            extras.append(f"intent: {r.intent}")
+        if extras:
+            print(f"  {_color(' | '.join(extras), 'dim')}")
+        print()
+    return 0
+
+
+def cmd_chat(args) -> int:
+    from engine import Bot
+    try:
+        bot = Bot(data=args.data)
+    except (FileNotFoundError, NotADirectoryError, ValueError) as e:
+        print(f"Error loading industry pack '{args.data}': {e}")
+        return 2
+    return asyncio.run(_async_chat_loop(bot))
+
+
+def cmd_serve(args) -> int:
+    from deployments.server import run_server
+    return run_server(data=args.data, host=args.host, port=args.port)
+
+
+def cmd_templates(args) -> int:
+    """List available industry pack templates."""
+    from engine.templates import TEMPLATE_DESCRIPTIONS
+    print("Available templates:")
+    for name, desc in TEMPLATE_DESCRIPTIONS.items():
+        print(f"  {name:15s} {desc}")
+    print("\nUsage: kchat init ./my-bot --template <name>")
+    return 0
+
+
+def cmd_init(args) -> int:
+    target = Path(args.path).resolve()
+    if target.exists() and any(target.iterdir()):
+        if not args.force:
+            print(f"'{target}' exists and is not empty. Use --force to overwrite.")
+            return 1
+    tmpl = getattr(args, "template", None)
+    pack = IndustryPack(path=target, config=None)  # type: ignore[arg-type]
+    pack.init_template(template_name=tmpl)
+    print(f"Initialized industry pack at: {target}")
+    if tmpl:
+        print(f"Template: {tmpl}")
+        print("Start chatting immediately:")
+        print(f"  python -m kchat chat --data {target}")
+    else:
+        print("Next steps:")
+        print(f"  1. Edit {target / 'config.json'}")
+        print(f"  2. Add documents to {target / 'knowledge'}/")
+        print(f"  3. Run: python -m kchat chat --data {target}")
+    return 0
+
+
+def cmd_validate(args) -> int:
+    """Validate an industry pack: check files, count chunks, dry-run a query."""
+    target = Path(args.data)
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    if not target.exists():
+        print(f"FAIL: path does not exist: {target}")
+        return 1
+    if not target.is_dir():
+        print(f"FAIL: not a directory: {target}")
+        return 1
+
+    # config.json
+    config_path = target / "config.json"
+    if not config_path.exists():
+        errors.append("missing config.json")
+    else:
+        try:
+            pack = IndustryPack.load(target)
+            print(f"OK: config.json loaded — bot='{pack.config.name}'")
+        except Exception as e:
+            errors.append(f"config.json invalid: {e}")
+            pack = None  # type: ignore
+
+    if pack:
+        # Knowledge
+        if not pack.knowledge_path or not pack.knowledge_path.exists():
+            warnings.append("no knowledge/ directory — bot will only have general config")
+        else:
+            loader = DocumentLoader()
+            chunks = loader.load_directory(pack.knowledge_path)
+            print(f"OK: knowledge/ — {len(chunks)} chunks indexed")
+            if len(chunks) == 0:
+                warnings.append("knowledge/ is empty — add .md or .txt files")
+        # Refusal
+        if not pack.refusal:
+            warnings.append("no refusal.json — using built-in defaults")
+        # Intents
+        if not pack.intents:
+            warnings.append("no intents.json — using built-in defaults")
+
+    # Print summary
+    print()
+    if errors:
+        print("ERRORS:")
+        for e in errors:
+            print(f"  - {e}")
+    if warnings:
+        print("WINTS:")
+        for w in warnings:
+            print(f"  - {w}")
+    if not errors and not warnings:
+        print("All checks passed.")
+    return 1 if errors else 0
+
+
+def cmd_curate(args) -> int:
+    """Audit an industry pack's knowledge/ for quality issues."""
+    from engine.curator import Curator
+    target = Path(args.data)
+    knowledge = target / "knowledge"
+    if not knowledge.exists() or not knowledge.is_dir():
+        print(f"FAIL: knowledge directory not found at: {knowledge}")
+        return 1
+    curator = Curator(knowledge)
+    report = curator.audit()
+    print(report.format())
+    return 0 if report.passed else 1
+
+
+def cmd_info(args) -> int:
+    pack = IndustryPack.load(args.data)
+    print(json.dumps(pack.config.to_dict(), indent=2, ensure_ascii=False))
+    return 0
+
+
+def cmd_audit(args) -> int:
+    """Run self-audit on an industry pack."""
+    from engine import Bot
+    try:
+        bot = Bot(data=args.data)
+    except (FileNotFoundError, NotADirectoryError, ValueError) as e:
+        print(f"Error loading industry pack '{args.data}': {e}")
+        return 2
+
+    report = bot.audit()
+    print(report.summary)
+    return 0 if report.status == "healthy" else (1 if report.status == "degraded" else 2)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="kchat",
+        description="K-CHAT — Universal Chatbot Engine (anti-hallucination by construction)",
+    )
+    parser.add_argument("--log-level", default="WARNING", choices=["DEBUG", "INFO", "WARNING", "ERROR"])
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_chat = sub.add_parser("chat", help="Interactive chat in the terminal")
+    p_chat.add_argument("--data", required=True, help="Path to industry pack folder")
+    p_chat.set_defaults(func=cmd_chat)
+
+    p_serve = sub.add_parser("serve", help="Run as REST API server")
+    p_serve.add_argument("--data", required=True, help="Path to industry pack folder")
+    p_serve.add_argument("--host", default="0.0.0.0")
+    p_serve.add_argument("--port", type=int, default=8000)
+    p_serve.set_defaults(func=cmd_serve)
+
+    p_init = sub.add_parser("init", help="Initialize a new industry pack")
+    p_init.add_argument("path", help="Folder to create")
+    p_init.add_argument("--force", action="store_true")
+    p_init.add_argument("--template", choices=["government", "restaurant", "healthcare"],
+                        help="Pre-built template to use (creates a working pack immediately)")
+    p_init.set_defaults(func=cmd_init)
+
+    p_tpl = sub.add_parser("templates", help="List available industry pack templates")
+    p_tpl.set_defaults(func=cmd_templates)
+
+    p_val = sub.add_parser("validate", help="Validate an industry pack")
+    p_val.add_argument("--data", required=True)
+    p_val.set_defaults(func=cmd_validate)
+
+    p_curate = sub.add_parser("curate", help="Audit knowledge/ for quality issues (duplicates, low-signal, etc.)")
+    p_curate.add_argument("--data", required=True, help="Path to industry pack folder")
+    p_curate.set_defaults(func=cmd_curate)
+
+    p_info = sub.add_parser("info", help="Print the resolved config")
+    p_info.add_argument("--data", required=True)
+    p_info.set_defaults(func=cmd_info)
+
+    p_audit = sub.add_parser("audit", help="Run self-audit (health, knowledge, skills, config)")
+    p_audit.add_argument("--data", required=True, help="Path to industry pack folder")
+    p_audit.set_defaults(func=cmd_audit)
+
+    args = parser.parse_args(argv)
+    logging.basicConfig(
+        level=getattr(logging, args.log_level),
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())