qwen-sci 0.2.2__py3-none-any.whl

src/agents/idea_agent/utils/core/logger.py

@@ -0,0 +1,287 @@
+"""Logging setup helpers for Idea Agent console and file output."""
+
+from contextlib import contextmanager
+from datetime import datetime
+import logging
+import os
+from pathlib import Path
+import sys
+from typing import Dict, Iterator, Optional
+
+from loguru import logger as _loguru_logger
+
+
+_LOGGER_NAME = "LigAgent"
+_MANAGED_LOGGER_PREFIX = "LigAgent"
+_DEFAULT_LOG_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "logs")
+_DEFAULT_LOG_DIR = os.path.normpath(_DEFAULT_LOG_DIR)
+_DEFAULT_LOG_FILE = "ligagent.log"
+_FILE_LOG_FORMAT = "{time:YYYY-MM-DD HH:mm:ss.SSS} | {level:<8} | {extra[logger_name]} | {message}"
+_CONSOLE_LOG_FORMAT = (
+    "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+    "<level>{level:<8}</level> | "
+    "<cyan>{extra[logger_name]}</cyan> | "
+    "<level>{message}</level>"
+)
+_logger: Optional["LoguruCompatLogger"] = None
+_loguru_runtime_ready = False
+_fallback_sink_id: Optional[int] = None
+
+
+def _normalize_level(level: int | str) -> str:
+    if isinstance(level, str):
+        text = level.strip().upper()
+        return text or "INFO"
+    if level >= logging.CRITICAL:
+        return "CRITICAL"
+    if level >= logging.ERROR:
+        return "ERROR"
+    if level >= logging.WARNING:
+        return "WARNING"
+    if level >= logging.INFO:
+        return "INFO"
+    if level >= logging.DEBUG:
+        return "DEBUG"
+    return "TRACE"
+
+
+def _ensure_loguru_runtime() -> None:
+    global _fallback_sink_id, _loguru_runtime_ready
+    if _loguru_runtime_ready:
+        return
+    try:
+        _loguru_logger.remove(0)
+    except Exception:
+        pass
+    if _fallback_sink_id is None:
+        _fallback_sink_id = _loguru_logger.add(
+            sys.stderr,
+            level="DEBUG",
+            format=_CONSOLE_LOG_FORMAT,
+            colorize=True,
+            enqueue=True,
+            filter=lambda record: not str(record["extra"].get("logger_name", "")).startswith(
+                _MANAGED_LOGGER_PREFIX
+            ),
+        )
+    _loguru_runtime_ready = True
+
+
+class LoguruCompatLogger:
+    """A small loguru-backed logger that preserves stdlib `%`-style call sites."""
+
+    def __init__(self, name: str, *, level: int | str = logging.INFO) -> None:
+        self.name = name
+        self.level = _normalize_level(level)
+        self._bound_logger = _loguru_logger.bind(logger_name=name)
+        self._desired_file_paths: list[str] = []
+        self._include_console = False
+        self._file_sink_ids: list[int] = []
+        self._console_sink_ids: list[int] = []
+        self._console_suspend_depth = 0
+
+    def setLevel(self, level: int | str) -> None:
+        normalized = _normalize_level(level)
+        if normalized == self.level:
+            return
+        self.level = normalized
+        if self.has_sinks():
+            self._rebuild_sinks()
+
+    def has_sinks(self) -> bool:
+        return bool(self._desired_file_paths or self._include_console)
+
+    def configure_sinks(
+        self,
+        *,
+        file_paths: list[str] | None = None,
+        include_console: bool | None = None,
+    ) -> None:
+        if file_paths is not None:
+            self._desired_file_paths = [str(Path(path)) for path in file_paths]
+        if include_console is not None:
+            self._include_console = bool(include_console)
+        self._rebuild_sinks()
+
+    def clear_sinks(self) -> None:
+        self._remove_sink_ids()
+        self._desired_file_paths = []
+        self._include_console = False
+
+    def _record_matches(self, record: dict) -> bool:
+        return record["extra"].get("logger_name") == self.name
+
+    def _console_filter(self, record: dict) -> bool:
+        return self._record_matches(record) and self._console_suspend_depth == 0
+
+    def _remove_sink_ids(self) -> None:
+        for sink_id in [*self._file_sink_ids, *self._console_sink_ids]:
+            try:
+                _loguru_logger.remove(sink_id)
+            except Exception:
+                pass
+        self._file_sink_ids.clear()
+        self._console_sink_ids.clear()
+
+    def _rebuild_sinks(self) -> None:
+        self._remove_sink_ids()
+        if not self.has_sinks():
+            return
+        _ensure_loguru_runtime()
+        for path in self._desired_file_paths:
+            sink_id = _loguru_logger.add(
+                path,
+                level=self.level,
+                format=_FILE_LOG_FORMAT,
+                rotation="5 MB",
+                retention=5,
+                encoding="utf-8",
+                enqueue=True,
+                filter=self._record_matches,
+            )
+            self._file_sink_ids.append(sink_id)
+        if self._include_console:
+            sink_id = _loguru_logger.add(
+                sys.stderr,
+                level=self.level,
+                format=_CONSOLE_LOG_FORMAT,
+                colorize=True,
+                enqueue=True,
+                filter=self._console_filter,
+            )
+            self._console_sink_ids.append(sink_id)
+
+    def _format_message(self, message: object, args: tuple[object, ...]) -> str:
+        text = str(message)
+        if not args:
+            return text
+        try:
+            return text % args
+        except Exception:
+            return f"{text} | args={args!r}"
+
+    def log(self, level: int | str, message: object, *args: object) -> None:
+        if not self.has_sinks():
+            return
+        _ensure_loguru_runtime()
+        self._bound_logger.log(_normalize_level(level), self._format_message(message, args))
+
+    def debug(self, message: object, *args: object) -> None:
+        self.log("DEBUG", message, *args)
+
+    def info(self, message: object, *args: object) -> None:
+        self.log("INFO", message, *args)
+
+    def warning(self, message: object, *args: object) -> None:
+        self.log("WARNING", message, *args)
+
+    def error(self, message: object, *args: object) -> None:
+        self.log("ERROR", message, *args)
+
+    def critical(self, message: object, *args: object) -> None:
+        self.log("CRITICAL", message, *args)
+
+    def exception(self, message: object, *args: object) -> None:
+        if not self.has_sinks():
+            return
+        _ensure_loguru_runtime()
+        self._bound_logger.opt(exception=True).error(self._format_message(message, args))
+
+    @contextmanager
+    def suspend_console(self) -> Iterator[None]:
+        self._console_suspend_depth += 1
+        try:
+            yield
+        finally:
+            self._console_suspend_depth = max(0, self._console_suspend_depth - 1)
+
+
+def init_logger(
+    log_dir: Optional[str] = None,
+    filename: str = _DEFAULT_LOG_FILE,
+    level: int = logging.DEBUG,
+    include_console: bool = True,
+    include_timestamp: bool = True,
+    timestamp_format: str = "%Y%m%d_%H%M%S",
+    force_reinit: bool = False,
+) -> LoguruCompatLogger:
+    """
+    Initialize or re-configure the process-wide logger.
+    - Rotating file sink (5MB, 5 backups)
+    - Optional console sink
+    - Optional timestamp appended to filename (before file extension)
+    - Set force_reinit=True to rebuild sinks even if the logger already exists.
+    """
+    global _logger
+    logger = _logger or LoguruCompatLogger(_LOGGER_NAME, level=level)
+    logger.setLevel(level)
+
+    if force_reinit or not logger.has_sinks():
+        resolved_log_dir = log_dir or _DEFAULT_LOG_DIR
+        os.makedirs(resolved_log_dir, exist_ok=True)
+
+        resolved_filename = filename
+        if include_timestamp:
+            name, ext = os.path.splitext(filename)
+            if not ext:
+                ext = ".log"
+            ts = datetime.now().strftime(timestamp_format)
+            resolved_filename = f"{name}_{ts}{ext}"
+
+        file_path = os.path.join(resolved_log_dir, resolved_filename)
+        logger.configure_sinks(file_paths=[file_path], include_console=include_console)
+
+    _logger = logger
+    return logger
+
+
+def get_logger() -> LoguruCompatLogger:
+    global _logger
+    if _logger is None:
+        _logger = LoguruCompatLogger(_LOGGER_NAME, level=logging.INFO)
+    return _logger
+
+
+def normalize_mode_log_key(idea_taste_mode: Optional[str]) -> str:
+    return str(idea_taste_mode or "default").strip() or "default"
+
+
+_LEGACY_MODE_TO_ROUTE = {
+    "moonshot_inventor": "premise_inversion",
+    "bridge_builder": "object_substitution",
+    "steady_engineer": "mechanism_replacement",
+    "ambitious_realist": "representation_shift",
+    "evidence_first": "verification_reversal",
+}
+
+
+def mode_log_filename(idea_taste_mode: Optional[str]) -> str:
+    raw_mode = normalize_mode_log_key(idea_taste_mode).lower()
+    route_id = _LEGACY_MODE_TO_ROUTE.get(raw_mode, raw_mode)
+    safe_route = "".join(ch if ch.isalnum() else "_" for ch in route_id).strip("_")
+    return f"mcts_{safe_route or 'default'}.log"
+
+
+def get_or_create_mode_logger(
+    mode_loggers: Dict[str, LoguruCompatLogger],
+    base_logger: LoguruCompatLogger,
+    run_dir: Path,
+    idea_taste_mode: Optional[str],
+) -> LoguruCompatLogger:
+    mode_key = normalize_mode_log_key(idea_taste_mode)
+    existing = mode_loggers.get(mode_key)
+    if existing is not None:
+        return existing
+
+    mode_logger = LoguruCompatLogger(f"LigAgent.{mode_key}", level=base_logger.level)
+    log_path = run_dir / "logs" / mode_log_filename(idea_taste_mode)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    mode_logger.configure_sinks(file_paths=[str(log_path)], include_console=False)
+    mode_loggers[mode_key] = mode_logger
+    return mode_logger
+
+
+@contextmanager
+def suspend_console_handlers(logger: LoguruCompatLogger) -> Iterator[None]:
+    with logger.suspend_console():
+        yield

src/agents/idea_agent/utils/core/progress.py

@@ -0,0 +1,58 @@
+"""Rich progress helpers shared across Idea Agent workflows."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from typing import Optional, TypeVar
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+)
+
+
+T = TypeVar("T")
+
+_PROGRESS_CONSOLE = Console(stderr=False)
+
+
+def create_progress(*, transient: bool = False) -> Progress:
+    return Progress(
+        SpinnerColumn(style="cyan"),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+        TimeRemainingColumn(),
+        console=_PROGRESS_CONSOLE,
+        transient=transient,
+    )
+
+
+def iter_with_progress(
+    iterable: Iterable[T],
+    *,
+    description: str,
+    total: Optional[int] = None,
+    transient: bool = False,
+) -> Iterator[T]:
+    resolved_total = total
+    if resolved_total is None:
+        try:
+            resolved_total = len(iterable)  # type: ignore[arg-type]
+        except TypeError:
+            resolved_total = None
+
+    with create_progress(transient=transient) as progress:
+        task_id = progress.add_task(description, total=resolved_total)
+        for item in iterable:
+            yield item
+            progress.advance(task_id)

src/agents/idea_agent/utils/core/response_parsing.py

@@ -0,0 +1,57 @@
+"""Shared response parsing helpers for Idea Agent LLM outputs."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any, Dict
+
+
+class JsonObjectResponseError(ValueError):
+    """Raised when a structured stage did not return one JSON object."""
+
+
+def _strip_json_fence(raw: str) -> str:
+    text = (raw or "").strip()
+    if text.startswith("```"):
+        fence_end = text.find("\n")
+        if fence_end != -1:
+            text = text[fence_end + 1 :]
+        if text.endswith("```"):
+            text = text[: -3]
+    return text.strip()
+
+
+def parse_json_response(raw: str) -> Any:
+    text = _strip_json_fence(raw)
+    if not text:
+        raise ValueError("Empty response")
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        decoder = json.JSONDecoder()
+        for idx, ch in enumerate(text):
+            if ch in "{[":
+                try:
+                    parsed, _ = decoder.raw_decode(text[idx:])
+                    return parsed
+                except json.JSONDecodeError:
+                    continue
+    raise ValueError(f"Unable to parse JSON from response: {text[:200]}")
+
+
+def parse_json_object_response(raw: str) -> Dict[str, Any]:
+    """Parse exactly one top-level JSON object without permissive fragment recovery."""
+
+    text = _strip_json_fence(raw)
+    if not text:
+        raise JsonObjectResponseError("advanced analysis response was empty; expected one JSON object")
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise JsonObjectResponseError(
+            "advanced analysis response must be one complete JSON object without prose or JSON fragments"
+        ) from exc
+    if not isinstance(parsed, Mapping):
+        raise JsonObjectResponseError("advanced analysis response must be a JSON object")
+    return dict(parsed)

src/agents/idea_agent/utils/core/run_inputs.py

@@ -0,0 +1,198 @@
+import os
+import re
+from typing import Any, Dict, Optional
+
+from src.agents.idea_agent.agent.base import AgentBase
+from src.agents.idea_agent.agent.prompts.input_interpreter import INPUT_INTERPRETER_PROMPT
+from src.agents.idea_agent.utils.core.config_loader import get_config_value
+from src.agents.idea_agent.utils.core.response_parsing import parse_json_response
+from src.agents.idea_agent.utils.workflow.idea_contract import (
+    mature_idea_legacy_text,
+    normalize_mature_ideas,
+)
+
+
+def clean_optional_text(value: Optional[str]) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
+def load_topic(topic: Optional[str]) -> str:
+    value = topic.strip() if isinstance(topic, str) else ""
+    if not value:
+        raise ValueError("run.topic must be a non-empty string.")
+    return value
+
+
+def load_run_defaults(config: Optional[object], *, default_output_root: str) -> dict:
+    ablation_results_path = clean_optional_text(os.getenv("IDEA_AGENT_ABLATION_RESULTS_PATH"))
+    if not ablation_results_path:
+        ablation_results_path = clean_optional_text(
+            str(get_config_value(config, "run.ablation_results_path", "") or "")
+        )
+    return {
+        "input": get_config_value(config, "run.input", ""),
+        "topic": get_config_value(config, "run.topic", ""),
+        "mature_idea": get_config_value(config, "run.mature_idea", ""),
+        "mature_ideas": get_config_value(config, "run.mature_ideas", []),
+        "refinement_scope": get_config_value(config, "run.refinement_scope", ""),
+        "survey_manifest": clean_optional_text(
+            os.getenv("IDEA_AGENT_SURVEY_MANIFEST")
+            or str(get_config_value(config, "run.survey_manifest", "") or "")
+        ),
+        "ablation_results_path": ablation_results_path,
+        "output_root": get_config_value(config, "run.output_root", default_output_root),
+        "console_logs": get_config_value(config, "run.console_logs", False),
+        "rag_config": get_config_value(
+            config,
+            "run.rag_config",
+            "src/config/default.yaml",
+        ),
+    }
+
+
+def _normalize_interpreter_source(value: Optional[str], *, allow_empty: bool = False) -> str:
+    cleaned = clean_optional_text(value).lower()
+    allowed = {"explicit", "inferred"}
+    if allow_empty:
+        allowed.add("empty")
+    return cleaned if cleaned in allowed else ("empty" if allow_empty else "inferred")
+
+
+def _fallback_topic_from_input(input_text: str) -> str:
+    candidate = re.split(r"(?<=[.!?])\s+", input_text.strip(), maxsplit=1)[0].strip()
+    words = candidate.split()
+    if len(words) > 12:
+        candidate = " ".join(words[:12])
+    return candidate or "unspecified topic"
+
+
+def _interpret_input_text(input_text: str, config: Optional[object]) -> Dict[str, object]:
+    normalized_input = clean_optional_text(input_text)
+    if not normalized_input:
+        return {
+            "topic": "",
+            "topic_source": "empty",
+            "mature_idea": "",
+            "mature_ideas": [],
+            "mature_idea_source": "empty",
+            "refinement_scope": "",
+            "refinement_scope_source": "empty",
+            "needs_grounding": True,
+        }
+
+    model = (
+        clean_optional_text(get_config_value(config, "run.input_interpreter_model", ""))
+        or clean_optional_text(get_config_value(config, "agent.model", ""))
+        or None
+    )
+    prompt = INPUT_INTERPRETER_PROMPT.format(input_text=normalized_input)
+    agent = AgentBase()
+    try:
+        response = agent.chat(prompt, model=model, temperature=0.1, max_output_tokens=4096)
+        payload = parse_json_response(response)
+    except Exception:
+        return {
+            "topic": _fallback_topic_from_input(normalized_input),
+            "topic_source": "inferred",
+            "mature_idea": "",
+            "mature_ideas": [],
+            "mature_idea_source": "empty",
+            "refinement_scope": "",
+            "refinement_scope_source": "empty",
+            "needs_grounding": True,
+        }
+
+    topic = clean_optional_text(payload.get("topic") if isinstance(payload, dict) else "")
+    if not topic:
+        topic = _fallback_topic_from_input(normalized_input)
+    interpreted_ideas = normalize_mature_ideas(
+        payload.get("mature_ideas") if isinstance(payload, dict) else [],
+        legacy_value=payload.get("mature_idea") if isinstance(payload, dict) else "",
+        default_source="input_interpreted",
+    )
+    return {
+        "topic": topic,
+        "topic_source": _normalize_interpreter_source(
+            payload.get("topic_source") if isinstance(payload, dict) else None
+        ),
+        "mature_idea": clean_optional_text(payload.get("mature_idea") if isinstance(payload, dict) else ""),
+        "mature_ideas": interpreted_ideas,
+        "mature_idea_source": _normalize_interpreter_source(
+            payload.get("mature_idea_source") if isinstance(payload, dict) else None,
+            allow_empty=True,
+        ),
+        "refinement_scope": clean_optional_text(
+            payload.get("refinement_scope") if isinstance(payload, dict) else ""
+        ),
+        "refinement_scope_source": _normalize_interpreter_source(
+            payload.get("refinement_scope_source") if isinstance(payload, dict) else None,
+            allow_empty=True,
+        ),
+        "needs_grounding": bool(payload.get("needs_grounding")) if isinstance(payload, dict) else True,
+    }
+
+
+def resolve_run_inputs(config: Optional[object], *, default_output_root: str) -> Dict[str, object]:
+    defaults = load_run_defaults(config, default_output_root=default_output_root)
+    input_text = clean_optional_text(defaults["input"])
+    explicit_topic = clean_optional_text(defaults["topic"])
+    explicit_mature_idea = clean_optional_text(defaults["mature_idea"])
+    explicit_mature_ideas = normalize_mature_ideas(
+        defaults.get("mature_ideas"),
+        legacy_value=explicit_mature_idea,
+        default_source="config_explicit",
+    )
+    explicit_refinement_scope = clean_optional_text(defaults["refinement_scope"])
+    interpreted = (
+        _interpret_input_text(input_text, config)
+        if input_text and (not explicit_topic or not explicit_mature_ideas or not explicit_refinement_scope)
+        else {
+            "topic": "",
+            "topic_source": "empty",
+            "mature_idea": "",
+            "mature_ideas": [],
+            "mature_idea_source": "empty",
+            "refinement_scope": "",
+            "refinement_scope_source": "empty",
+            "needs_grounding": True,
+        }
+    )
+
+    topic = explicit_topic or clean_optional_text(str(interpreted.get("topic") or ""))
+    if not topic and not clean_optional_text(str(defaults.get("survey_manifest") or "")):
+        raise ValueError("run.topic must be non-empty, or run.input must contain an interpretable topic.")
+
+    interpreted_ideas = normalize_mature_ideas(
+        interpreted.get("mature_ideas"),
+        legacy_value=interpreted.get("mature_idea"),
+        default_source="input_interpreted",
+    )
+    mature_ideas = explicit_mature_ideas or interpreted_ideas
+    mature_idea = explicit_mature_idea or mature_idea_legacy_text(mature_ideas)
+    refinement_scope = explicit_refinement_scope or clean_optional_text(
+        str(interpreted.get("refinement_scope") or "")
+    )
+    interpreted_topic_source = str(interpreted.get("topic_source") or "inferred")
+    interpreted_mature_source = str(interpreted.get("mature_idea_source") or "empty")
+    interpreted_scope_source = str(interpreted.get("refinement_scope_source") or "empty")
+    return {
+        **defaults,
+        "topic": topic,
+        "mature_idea": mature_idea,
+        "mature_ideas": mature_ideas,
+        "refinement_scope": refinement_scope,
+        "ablation_results_path": clean_optional_text(str(defaults.get("ablation_results_path") or "")),
+        "input_text": input_text,
+        "topic_source": "config_explicit" if explicit_topic else f"input_{interpreted_topic_source}",
+        "mature_idea_source": (
+            "config_explicit"
+            if explicit_mature_idea or explicit_mature_ideas
+            else ("empty" if interpreted_mature_source == "empty" else f"input_{interpreted_mature_source}")
+        ),
+        "refinement_scope_source": (
+            "config_explicit"
+            if explicit_refinement_scope
+            else ("empty" if interpreted_scope_source == "empty" else f"input_{interpreted_scope_source}")
+        ),
+        "needs_grounding": bool(interpreted.get("needs_grounding", True)),
+    }

src/agents/idea_agent/utils/mcts/__init__.py

@@ -0,0 +1 @@
+"""Monte Carlo Tree Search support utilities for Idea Agent."""