llm-logparser 1.3.0__py3-none-any.whl

llm_logparser/cli/__main__.py

@@ -0,0 +1,4 @@
+# llm_logparser/__main__.py
+from .cli import main
+if __name__ == "__main__":
+    main()

llm_logparser/cli/cli.py

@@ -0,0 +1,289 @@
+# src/llm_logparser/cli.py
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from llm_logparser.cli.common import (
+    setup_logger,
+    validate_path,
+    validate_split_option,
+)
+from llm_logparser.cli.config_apply import (
+    apply_profile_defaults,
+    missing_required_fields,
+    parse_explicit_flags,
+    resolve_profile,
+    resolve_sanitize_policy,
+)
+from llm_logparser.cli.config_loader import load_config_with_discovery
+from llm_logparser.cli.handlers import (
+    run_analyze_metrics,
+    run_analyze_sqlite_build,
+    run_analyze_stats,
+    run_analyze_tokens,
+    run_analyze_timeline,
+    run_chain,
+    run_config_command,
+    run_export,
+    run_extract,
+    run_parse,
+)
+from llm_logparser.cli.config_model import AppConfig, ConfigProfile
+from llm_logparser.cli.parser_builder import build_parser
+from llm_logparser.cli.prompts import (
+    interactive_enabled,
+    prompt_choice,
+    prompt_existing_file,
+    prompt_text,
+)
+from llm_logparser.core.i18n import _, set_locale
+
+
+def _bootstrap_cli_locale(raw_argv: list[str]) -> str | None:
+    for index, token in enumerate(raw_argv):
+        if token == "--":
+            break
+        if token.startswith("--locale="):
+            return token.split("=", 1)[1] or None
+        if token.startswith("--lang="):
+            return token.split("=", 1)[1] or None
+        if token in {"--locale", "--lang"}:
+            if index + 1 < len(raw_argv):
+                return raw_argv[index + 1]
+            return None
+    return None
+
+
+def _missing_arg_message(command: str, missing: list[str]) -> str:
+    key_hint = {
+        "provider": _("error.missing_required_hint.provider"),
+        "input": _("error.missing_required_hint.input"),
+        "conversation_id": _("error.missing_required_hint.conversation_id"),
+    }
+    lines = [_("error.missing_required", command=command)]
+    for name in missing:
+        lines.append(
+            f"  - {name}: {key_hint.get(name, _('error.missing_required_hint.generic'))}"
+        )
+    return "\n".join(lines)
+
+
+def _resolve_profile(
+    args,
+    *,
+    can_prompt: bool,
+) -> tuple[ConfigProfile | None, dict[str, ConfigProfile], AppConfig | None, Path | None]:
+    config, config_path = load_config_with_discovery(args.config)
+    profile: ConfigProfile | None = None
+    profiles: dict[str, ConfigProfile] = {}
+    if config is not None:
+        profile, profiles = resolve_profile(config, args.profile)
+        if profile is None and can_prompt and len(profiles) > 1:
+            selected = prompt_choice(
+                _("runtime.profile.select"),
+                list(profiles.keys()),
+                allow_skip=True,
+            )
+            if selected is not None:
+                candidate = profiles.get(selected)
+                if candidate is not None:
+                    profile = candidate
+    return profile, profiles, config, config_path
+
+
+def _apply_profile_input_defaults(
+    args,
+    profile: ConfigProfile | None,
+    *,
+    explicit_flags: set[str],
+    config_path,
+) -> None:
+    if profile is None:
+        return
+
+    extra_info = apply_profile_defaults(
+        args,
+        profile,
+        explicit_flags,
+        base_dir=config_path.parent if config_path is not None else None,
+    )
+
+    input_candidates = extra_info.get("input_candidates")
+    can_prompt = interactive_enabled(
+        non_interactive=args.non_interactive
+        or os.getenv("LLM_LOGPARSER_NON_INTERACTIVE") == "1"
+    )
+    if (
+        args.command in ("parse", "export", "chain", "extract")
+        and args.input is None
+        and isinstance(input_candidates, list)
+        and input_candidates
+    ):
+        if can_prompt:
+            selected_input = prompt_choice(
+                _("runtime.profile.select_input"),
+                [str(p) for p in input_candidates],
+            )
+            if selected_input:
+                args.input = Path(selected_input)
+        else:
+            print(
+                _("runtime.profile.multiple_input_paths"),
+                file=sys.stderr,
+            )
+            sys.exit(2)
+
+
+def _prompt_missing_required(
+    args,
+    profile: ConfigProfile | None,
+    *,
+    can_prompt: bool,
+    logger,
+) -> None:
+    missing = missing_required_fields(args)
+    if missing:
+        if can_prompt:
+            if "provider" in missing:
+                provider_default = profile.provider if profile is not None else None
+                args.provider = prompt_text(
+                    _("runtime.prompt.provider"),
+                    default=provider_default,
+                )
+            if "input" in missing:
+                default_input = None
+                if profile is not None:
+                    default_input = profile.input.path or profile.input.parsed
+                args.input = prompt_existing_file(
+                    _("runtime.prompt.input_file_path"),
+                    default=default_input,
+                )
+            if "conversation_id" in missing:
+                conv_default = profile.extract.conversation_id if profile is not None else None
+                args.conversation_id = prompt_text(
+                    _("runtime.prompt.conversation_id"),
+                    default=conv_default,
+                )
+        else:
+            logger.error(_missing_arg_message(args.command, missing))
+            sys.exit(2)
+
+    if (
+        args.command == "analyze"
+        and args.analyze_command in {"stats", "timeline", "tokens", "metrics", "sqlite-build"}
+    ):
+        if args.input is None:
+            if can_prompt:
+                prompt_label = (
+                    _("runtime.prompt.analyze_provider_root")
+                    if args.analyze_command == "sqlite-build"
+                    else _("runtime.prompt.analyze_input")
+                )
+                raw_input = prompt_text(prompt_label)
+                args.input = Path(raw_input) if raw_input else None
+            else:
+                logger.error(_("runtime.analyze.missing_input", command=args.analyze_command))
+                sys.exit(2)
+
+        if args.analyze_command == "sqlite-build" and not args.provider:
+            if can_prompt:
+                args.provider = prompt_text(_("runtime.prompt.provider_id"))
+            else:
+                logger.error(_("runtime.analyze.missing_provider"))
+                sys.exit(2)
+
+
+def _dispatch(args, logger) -> None:
+    if args.command == "parse":
+        run_parse(args, logger)
+    elif args.command == "export":
+        run_export(args, logger)
+    elif args.command == "extract":
+        run_extract(args, logger)
+    elif args.command == "analyze":
+        if args.analyze_command == "stats":
+            run_analyze_stats(args, logger)
+        elif args.analyze_command == "metrics":
+            run_analyze_metrics(args, logger)
+        elif args.analyze_command == "tokens":
+            run_analyze_tokens(args, logger)
+        elif args.analyze_command == "timeline":
+            run_analyze_timeline(args, logger)
+        elif args.analyze_command == "sqlite-build":
+            run_analyze_sqlite_build(args, logger)
+    elif args.command == "chain":
+        run_chain(args, logger)
+    elif args.command == "viewer":
+        logger.warning(_("runtime.viewer.todo"))
+    elif args.command == "config":
+        run_config_command(args, logger)
+
+
+def main(argv: list[str] | None = None):
+    raw_argv = list(sys.argv[1:] if argv is None else argv)
+    set_locale(_bootstrap_cli_locale(raw_argv))
+    parser = build_parser()
+    args = parser.parse_args(raw_argv)
+    explicit_flags = parse_explicit_flags(raw_argv)
+    non_interactive = args.non_interactive or os.getenv("LLM_LOGPARSER_NON_INTERACTIVE") == "1"
+    can_prompt = interactive_enabled(non_interactive=non_interactive)
+
+    if args.command == "config":
+        config, _config_path = load_config_with_discovery(args.config)
+        config_locale = None
+        if config is not None:
+            profile, _profiles = resolve_profile(config, args.profile)
+            if profile is not None:
+                config_locale = profile.locale
+        set_locale(args.locale, config_locale=config_locale)
+        logger = setup_logger(args.log_level)
+        _dispatch(args, logger)
+        return
+
+    profile: ConfigProfile | None = None
+    config_path: Path | None = None
+    config_locale: str | None = None
+    if args.command in {"parse", "export", "chain", "extract", "analyze"}:
+        # Keep analyze on the same locale resolution path as the other runtime
+        # commands. Today it only consumes profile data for locale selection,
+        # but that still needs the documented CLI -> env -> profile -> en-US
+        # precedence instead of a command-specific exception.
+        profile, _profiles, _config, config_path = _resolve_profile(
+            args,
+            can_prompt=can_prompt,
+        )
+        if profile is not None:
+            config_locale = profile.locale
+        _apply_profile_input_defaults(
+            args,
+            profile,
+            explicit_flags=explicit_flags,
+            config_path=config_path,
+        )
+        if args.command == "extract":
+            args.sanitize_policy = resolve_sanitize_policy(profile)
+
+    set_locale(args.locale, config_locale=config_locale)
+    logger = setup_logger(args.log_level)
+    _prompt_missing_required(args, profile, can_prompt=can_prompt, logger=logger)
+
+    try:
+        _dispatch(args, logger)
+    except (FileNotFoundError, IsADirectoryError) as e:
+        logger.error(_("error.path", detail=e))
+        sys.exit(2)
+    except PermissionError as e:
+        logger.error(_("error.permission", detail=e))
+        sys.exit(3)
+    except Exception as e:
+        logger.exception(_("error.unexpected", detail=e))
+        sys.exit(99)
+
+
+__all__ = ["main", "setup_logger", "validate_path", "validate_split_option"]
+
+
+if __name__ == "__main__":
+    main()

llm_logparser/cli/common.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from datetime import timezone as _dt_timezone
+from pathlib import Path
+
+from zoneinfo import ZoneInfo
+
+from llm_logparser.core.i18n import _
+
+
+def setup_logger(level: str | None = None) -> logging.Logger:
+    """Configure the shared CLI logger once."""
+    logger = logging.getLogger("llm_logparser")
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter("[%(levelname)s] %(message)s"))
+        logger.addHandler(handler)
+    env_level = os.getenv("LLM_LOGPARSER_LOGLEVEL")
+    raw_level = level or env_level or "INFO"
+    logger.setLevel(getattr(logging, raw_level.upper(), logging.INFO))
+    return logger
+
+
+def validate_path(
+    path: Path,
+    *,
+    must_exist: bool = True,
+    expect_file: bool = False,
+    expect_dir: bool = False,
+) -> Path:
+    """Validate input and output paths."""
+    target = path.expanduser()
+    if must_exist and not target.exists():
+        raise FileNotFoundError(_("error.path_not_found", path=target))
+    if expect_file and target.is_dir():
+        raise IsADirectoryError(_("error.path_expected_file", path=target))
+    if expect_dir and not target.is_dir():
+        raise NotADirectoryError(_("error.path_expected_dir", path=target))
+    return target
+
+
+def validate_split_option(raw: str | None) -> str | None:
+    if raw is None:
+        return None
+    normalized = raw.strip()
+    if not normalized:
+        return None
+    lowered = normalized.lower()
+    if lowered == "auto" or lowered.startswith("size=") or lowered.startswith("count="):
+        return normalized
+    raise SystemExit(_("runtime.split_invalid", raw=raw))
+
+
+def resolve_timezone(timezone_name: str, logger: logging.Logger):
+    try:
+        return ZoneInfo(timezone_name)
+    except Exception:
+        logger.warning(_("runtime.timezone_unknown", timezone_name=timezone_name))
+        return _dt_timezone.utc
+
+
+def write_or_print(rendered: str, out: Path | None) -> None:
+    if out:
+        if out.exists() and out.is_dir():
+            raise IsADirectoryError(_("error.path_expected_file", path=out))
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(f"{rendered}\n", encoding="utf-8")
+    else:
+        print(rendered)

llm_logparser/cli/config_apply.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+from argparse import Namespace
+from pathlib import Path
+from typing import Any
+
+from llm_logparser.cli.config_model import AppConfig, ConfigProfile
+from llm_logparser.core.i18n import _
+from llm_logparser.core.sanitize import SanitizePolicy
+
+REQUIRED_FIELDS_BY_COMMAND: dict[str, list[str]] = {
+    "parse": ["provider", "input"],
+    "export": ["input"],
+    "chain": ["provider", "input"],
+    "extract": ["provider", "input", "conversation_id"],
+}
+
+
+def parse_explicit_flags(argv: list[str]) -> set[str]:
+    flags: set[str] = set()
+    for token in argv:
+        if token == "--":
+            break
+        if not token.startswith("-"):
+            continue
+        if token.startswith("--"):
+            flags.add(token.split("=", 1)[0])
+        else:
+            flags.add(token)
+    return flags
+
+
+def cli_provided(explicit_flags: set[str], *flags: str) -> bool:
+    return any(flag in explicit_flags for flag in flags)
+
+
+def resolve_profile(
+    config: AppConfig,
+    profile_name: str | None,
+) -> tuple[ConfigProfile | None, dict[str, ConfigProfile]]:
+    profiles = config.profiles
+    if profile_name:
+        profile = profiles.get(profile_name)
+        if profile is None:
+            raise SystemExit(_("runtime.config.profile_not_found", name=profile_name))
+        return profile, profiles
+
+    active = config.active_profile
+    if active:
+        profile = profiles.get(active)
+        if profile is None:
+            raise SystemExit(_("runtime.config.profile_not_found", name=active))
+        return profile, profiles
+
+    if len(profiles) == 1:
+        return next(iter(profiles.values())), profiles
+
+    return None, profiles
+
+
+def missing_required_fields(args: Namespace) -> list[str]:
+    required = REQUIRED_FIELDS_BY_COMMAND.get(args.command, [])
+    missing: list[str] = []
+    for field in required:
+        value = getattr(args, field, None)
+        if value is None:
+            missing.append(field)
+        elif isinstance(value, str) and not value.strip():
+            missing.append(field)
+    return missing
+
+
+def _resolve_path(value: Any, base_dir: Path | None) -> Path | None:
+    if isinstance(value, Path):
+        p = value
+    elif isinstance(value, str) and value.strip():
+        p = Path(value)
+    else:
+        return None
+    if p.is_absolute() or base_dir is None:
+        return p
+    return (base_dir / p).resolve()
+
+
+def _input_candidates(profile: ConfigProfile, command: str, base_dir: Path | None) -> list[str]:
+    if command == "export":
+        if profile.input.parsed:
+            resolved = _resolve_path(profile.input.parsed, base_dir)
+            return [str(resolved)] if resolved is not None else []
+
+    if profile.input.path:
+        resolved = _resolve_path(profile.input.path, base_dir)
+        return [str(resolved)] if resolved is not None else []
+
+    if profile.input.paths:
+        out: list[str] = []
+        for item in profile.input.paths:
+            resolved = _resolve_path(item, base_dir)
+            if resolved is not None:
+                out.append(str(resolved))
+        return out
+
+    return []
+
+
+def _set_if_not_cli(
+    args: Namespace,
+    explicit_flags: set[str],
+    attr: str,
+    flags: tuple[str, ...],
+    value: Any,
+    *,
+    transform=lambda x: x,
+) -> None:
+    if value is None:
+        return
+    if cli_provided(explicit_flags, *flags):
+        return
+    setattr(args, attr, transform(value))
+
+
+def apply_profile_defaults(
+    args: Namespace,
+    profile: ConfigProfile,
+    explicit_flags: set[str],
+    *,
+    base_dir: Path | None = None,
+) -> dict[str, Any]:
+    info: dict[str, Any] = {}
+    _set_if_not_cli(
+        args,
+        explicit_flags,
+        "log_level",
+        ("--log-level",),
+        profile.logging.level,
+        transform=lambda v: str(v).upper(),
+    )
+
+    if args.command in ("export", "chain"):
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "timezone",
+            ("--timezone", "--tz"),
+            profile.timezone,
+        )
+
+    if args.command in ("parse", "chain", "extract"):
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "provider",
+            ("--provider",),
+            profile.provider,
+        )
+
+    if args.command in ("parse", "export", "chain", "extract") and not cli_provided(explicit_flags, "--input"):
+        candidates = _input_candidates(profile, args.command, base_dir)
+        if len(candidates) == 1:
+            args.input = Path(candidates[0])
+        elif len(candidates) > 1:
+            info["input_candidates"] = candidates
+
+    if args.command == "parse":
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "outdir",
+            ("--outdir",),
+            profile.parse.outdir,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+
+        for attr, flag in (("dry_run", "--dry-run"), ("fail_fast", "--fail-fast"), ("validate_schema", "--validate-schema")):
+            value = getattr(profile.parse, attr)
+            if value is not None:
+                _set_if_not_cli(args, explicit_flags, attr, (flag,), value)
+
+    elif args.command == "export":
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "out",
+            ("--out",),
+            profile.output.path,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "formatting",
+            ("--formatting",),
+            profile.output.formatting,
+        )
+        _set_if_not_cli(args, explicit_flags, "split", ("--split",), profile.output.split)
+
+        for attr, flag in (("split_soft_overflow", "--split-soft-overflow"), ("tiny_tail_threshold", "--tiny-tail-threshold")):
+            value = getattr(profile.output, attr)
+            if value is not None:
+                _set_if_not_cli(args, explicit_flags, attr, (flag,), value)
+
+        for attr, flag in (("split_hard", "--split-hard"), ("split_preview", "--split-preview")):
+            value = getattr(profile.output, attr)
+            if value is not None:
+                _set_if_not_cli(args, explicit_flags, attr, (flag,), value)
+
+    elif args.command == "chain":
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "outdir",
+            ("--outdir",),
+            profile.chain.outdir,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "export_outdir",
+            ("--export-outdir",),
+            profile.chain.export_outdir,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "parsed_root",
+            ("--parsed-root",),
+            profile.chain.parsed_root,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "formatting",
+            ("--formatting",),
+            profile.output.formatting,
+        )
+        _set_if_not_cli(args, explicit_flags, "split", ("--split",), profile.output.split)
+
+        for attr, flag in (("split_soft_overflow", "--split-soft-overflow"), ("tiny_tail_threshold", "--tiny-tail-threshold")):
+            value = getattr(profile.output, attr)
+            if value is not None:
+                _set_if_not_cli(args, explicit_flags, attr, (flag,), value)
+
+        for attr, flag in (("split_hard", "--split-hard"), ("split_preview", "--split-preview"), ("dry_run", "--dry-run"), ("fail_fast", "--fail-fast"), ("validate_schema", "--validate-schema")):
+            value = getattr(profile.chain, attr) if attr in {"dry_run", "fail_fast", "validate_schema"} else getattr(profile.output, attr)
+            if value is not None:
+                _set_if_not_cli(args, explicit_flags, attr, (flag,), value)
+
+    elif args.command == "extract":
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "outdir",
+            ("--outdir",),
+            profile.extract.outdir,
+            transform=lambda v: _resolve_path(v, base_dir) or Path(v),
+        )
+        _set_if_not_cli(
+            args,
+            explicit_flags,
+            "conversation_id",
+            ("--conversation-id",),
+            profile.extract.conversation_id,
+        )
+
+        dry = profile.extract.dry_run
+        if dry is not None:
+            _set_if_not_cli(args, explicit_flags, "dry_run", ("--dry-run",), dry)
+
+    return info
+
+
+def resolve_sanitize_policy(profile: ConfigProfile | None) -> SanitizePolicy:
+    sanitize = profile.sanitize if profile is not None else None
+    if sanitize is None:
+        return SanitizePolicy.defaults()
+    return SanitizePolicy.from_settings(
+        enabled=sanitize.enabled,
+        replacement=sanitize.replacement,
+        scope=sanitize.scope,
+        extra_keywords=sanitize.extra_keywords,
+        mask_patterns=sanitize.mask_patterns,
+    )