732642856
369 lines
15 KiB
Python
369 lines
15 KiB
Python
#!/usr/bin/env python3
|
||
"""User-level VedAstro + strict-workflow entrypoint for Codex sessions."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import json
|
||
import os
|
||
import subprocess
|
||
import sys
|
||
from pathlib import Path
|
||
from typing import Any
|
||
|
||
try:
|
||
from scripts.diagnose_vedastro_mode import build_report as build_runtime_mode_report
|
||
from scripts.local_env import load_local_env
|
||
except ModuleNotFoundError: # pragma: no cover - direct script execution
|
||
from diagnose_vedastro_mode import build_report as build_runtime_mode_report
|
||
from local_env import load_local_env
|
||
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
RUNNER = ROOT / "scripts" / "vedastro_official_capability_runner.py"
|
||
|
||
|
||
def _bool_env(name: str) -> bool:
|
||
return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}
|
||
|
||
|
||
def _int_env(name: str, default: int = 0) -> int:
|
||
raw = os.environ.get(name, "").strip()
|
||
if not raw:
|
||
return default
|
||
try:
|
||
return int(float(raw))
|
||
except ValueError:
|
||
return default
|
||
|
||
|
||
def _themes(raw: str) -> list[str]:
|
||
aliases = {
|
||
"relationship": "marriage",
|
||
"relationships": "marriage",
|
||
"finance": "wealth",
|
||
"money": "wealth",
|
||
"事业": "career",
|
||
"婚恋": "marriage",
|
||
"婚姻": "marriage",
|
||
"财富": "wealth",
|
||
"健康": "health",
|
||
"教育": "education",
|
||
"房产": "property",
|
||
"子女": "children",
|
||
"迁移": "migration",
|
||
"问卜": "prashna",
|
||
"校时": "rectification",
|
||
"应期": "timing",
|
||
}
|
||
values: list[str] = []
|
||
for item in raw.replace("，", ",").split(","):
|
||
key = aliases.get(item.strip().lower(), item.strip().lower())
|
||
if key and key not in values:
|
||
values.append(key)
|
||
return values or ["career", "marriage", "wealth"]
|
||
|
||
|
||
def _primary_route(question: str, themes: list[str]) -> str:
|
||
text = f"{question} {' '.join(themes)}".lower()
|
||
route_aliases = [
|
||
("career", ("career", "job", "work", "profession", "事业", "工作", "职业", "项目")),
|
||
("relationship", ("marriage", "relationship", "spouse", "partner", "婚恋", "婚姻", "伴侣")),
|
||
("finance", ("wealth", "finance", "money", "income", "财富", "金钱", "收入")),
|
||
]
|
||
for route, tokens in route_aliases:
|
||
if any(token in text for token in tokens):
|
||
return route
|
||
return "general"
|
||
|
||
|
||
def _case_from_args(args: argparse.Namespace, themes: list[str]) -> dict[str, Any]:
|
||
return {
|
||
"year": args.year,
|
||
"month": args.month,
|
||
"day": args.day,
|
||
"hour": args.hour,
|
||
"minute": args.minute,
|
||
"second": args.second,
|
||
"lat": args.lat,
|
||
"lon": args.lon,
|
||
"tz": args.tz,
|
||
"reference_date": args.reference_date,
|
||
"themes": themes,
|
||
"ayanamsa_policy": args.ayanamsa,
|
||
"node_policy": args.node_mode,
|
||
}
|
||
|
||
|
||
def _run_capability_catalog(case: dict[str, Any]) -> dict[str, Any]:
|
||
try:
|
||
completed = subprocess.run(
|
||
[
|
||
sys.executable,
|
||
str(RUNNER),
|
||
"--bundle",
|
||
"official_full_capability_catalog",
|
||
"--birth-json",
|
||
json.dumps(case, ensure_ascii=False),
|
||
],
|
||
cwd=ROOT,
|
||
text=True,
|
||
capture_output=True,
|
||
timeout=max(5.0, float(os.environ.get("VEDASTRO_TIMEOUT_SECONDS", "20") or 20)),
|
||
check=False,
|
||
env=os.environ.copy(),
|
||
)
|
||
except subprocess.TimeoutExpired:
|
||
return {
|
||
"available": False,
|
||
"status": "official_full_capability_catalog_timeout",
|
||
"summary": {},
|
||
"domain_routing": {},
|
||
"sample_outputs": {},
|
||
}
|
||
if completed.returncode != 0:
|
||
return {
|
||
"available": False,
|
||
"status": "official_full_capability_catalog_runtime_error",
|
||
"summary": {},
|
||
"domain_routing": {},
|
||
"dynamic_selection": {},
|
||
"stderr": (completed.stderr or "").strip(),
|
||
}
|
||
try:
|
||
return json.loads(completed.stdout)
|
||
except json.JSONDecodeError:
|
||
return {
|
||
"available": False,
|
||
"status": "official_full_capability_catalog_invalid_json",
|
||
"summary": {},
|
||
"domain_routing": {},
|
||
"dynamic_selection": {},
|
||
"stdout_excerpt": (completed.stdout or "").strip()[:500],
|
||
}
|
||
|
||
|
||
def _official_raw_requested(args: argparse.Namespace) -> bool:
|
||
return (
|
||
bool(getattr(args, "require_official_raw_response", False))
|
||
or _bool_env("VEDASTRO_REQUIRE_OFFICIAL_RAW_RESPONSE")
|
||
or _bool_env("VEDASTRO_GATEWAY_REQUIRE_OFFICIAL_RAW_RESPONSE")
|
||
)
|
||
|
||
|
||
def _run_official_full_snapshot(case: dict[str, Any]) -> dict[str, Any]:
|
||
stub = os.environ.get("VEDASTRO_OFFICIAL_FULL_SNAPSHOT_STUB", "").strip()
|
||
if stub:
|
||
try:
|
||
parsed = json.loads(stub)
|
||
except json.JSONDecodeError as exc:
|
||
return {
|
||
"available": False,
|
||
"status": "official_full_snapshot_stub_invalid_json",
|
||
"error": {"type": type(exc).__name__, "message": str(exc)},
|
||
}
|
||
return parsed if isinstance(parsed, dict) else {"available": False, "status": "official_full_snapshot_stub_not_object"}
|
||
|
||
try:
|
||
from scripts.vedastro_service_adapter import run_official_full_snapshot_for_case
|
||
except ModuleNotFoundError: # pragma: no cover - direct script execution
|
||
from vedastro_service_adapter import run_official_full_snapshot_for_case
|
||
|
||
try:
|
||
result = run_official_full_snapshot_for_case(case, case_id="user_chart")
|
||
except Exception as exc: # pragma: no cover - runtime boundary
|
||
return {
|
||
"available": False,
|
||
"status": "official_full_snapshot_runtime_error",
|
||
"error": {"type": type(exc).__name__, "message": str(exc)},
|
||
}
|
||
return result if isinstance(result, dict) else {"available": False, "status": "official_full_snapshot_invalid_result"}
|
||
|
||
|
||
def _extract_official_raw_response(snapshot: dict[str, Any]) -> dict[str, Any]:
|
||
raw = (
|
||
snapshot.get("official_raw_response")
|
||
or snapshot.get("raw_response")
|
||
or snapshot.get("vedastro_official_raw_response")
|
||
)
|
||
return raw if isinstance(raw, dict) else {}
|
||
|
||
|
||
def _snapshot_summary(snapshot: dict[str, Any], raw_response: dict[str, Any]) -> dict[str, Any]:
|
||
metadata = snapshot.get("source_metadata") if isinstance(snapshot.get("source_metadata"), dict) else {}
|
||
return {
|
||
"status": snapshot.get("status") or "not_requested",
|
||
"available": bool(snapshot.get("available")) or bool(raw_response),
|
||
"operation": snapshot.get("operation") or "official_full_snapshot",
|
||
"raw_response_available": bool(raw_response),
|
||
"artifact_path": metadata.get("artifact_path"),
|
||
"reason": snapshot.get("reason"),
|
||
"error": snapshot.get("error") if isinstance(snapshot.get("error"), dict) else {},
|
||
"boundary": "official_raw_response must be present before claiming VedAstro official cloud closure.",
|
||
}
|
||
|
||
|
||
def _strict_workflow_summary(route: str, catalog: dict[str, Any]) -> dict[str, Any]:
|
||
dynamic_selection = catalog.get("dynamic_selection") if isinstance(catalog.get("dynamic_selection"), dict) else {}
|
||
theme_for_route = {"relationship": "marriage", "finance": "wealth"}.get(route, route)
|
||
return {
|
||
"triggered": route in {"career", "relationship", "finance"},
|
||
"primary_route": route,
|
||
"routes_available": ["career", "relationship", "finance"],
|
||
"source": "strict_workflow_contract_summary",
|
||
"official_capability_selection": dynamic_selection.get(theme_for_route) or {},
|
||
"boundary": (
|
||
"This entrypoint triggers the strict workflow contract lane and passes VedAstro official catalog "
|
||
"selection metadata; it does not claim every official method was executed."
|
||
),
|
||
}
|
||
|
||
|
||
def _cache_and_queue_report() -> dict[str, Any]:
|
||
queue_enabled = (
|
||
_bool_env("VEDASTRO_FREE_TIER_QUEUE")
|
||
or _bool_env("VEDASTRO_FREE_TIER_QUEUE_ENABLED")
|
||
or _bool_env("VEDASTRO_ENABLE_FREE_TIER_QUEUE")
|
||
)
|
||
using_free_tier = not bool(os.environ.get("VEDASTRO_API_KEY", "").strip())
|
||
return {
|
||
"official_full_snapshot_cache_scope": "official_full_snapshot_semantic_cache",
|
||
"official_full_snapshot_cache_ttl_seconds": _int_env("VEDASTRO_OFFICIAL_FULL_SNAPSHOT_CACHE_TTL_SECONDS", 0),
|
||
"range_scan_cache_scope": "vedastro_range_scan_request_cache",
|
||
"range_scan_cache_ttl_seconds": _int_env("VEDASTRO_CACHE_TTL_SECONDS", 0),
|
||
"free_tier_queue_enabled": queue_enabled,
|
||
"free_tier_strategy": {
|
||
"using_free_tier": using_free_tier,
|
||
"queue_enabled": queue_enabled,
|
||
"guard_status": "within_free_tier_strategy" if using_free_tier else "premium_key_present",
|
||
},
|
||
"sample_limit": _int_env("VEDASTRO_FULL_CATALOG_SAMPLE_LIMIT", 0),
|
||
"artifact_root": "scratch/local/vedastro_adapter",
|
||
}
|
||
|
||
|
||
def build_report(args: argparse.Namespace) -> dict[str, Any]:
|
||
load_local_env(ROOT)
|
||
themes = _themes(args.themes)
|
||
case = _case_from_args(args, themes)
|
||
runtime = build_runtime_mode_report()
|
||
catalog = _run_capability_catalog(case)
|
||
snapshot = _run_official_full_snapshot(case) if _official_raw_requested(args) else {"status": "not_requested"}
|
||
raw_response = _extract_official_raw_response(snapshot)
|
||
route = _primary_route(args.question, themes)
|
||
report = {
|
||
"scope": "vedastro_user_entrypoint",
|
||
"schema_version": 1,
|
||
"input": {
|
||
"question": args.question,
|
||
"themes": themes,
|
||
"birth": {key: case[key] for key in ("year", "month", "day", "hour", "minute", "second", "lat", "lon", "tz")},
|
||
"reference_date": args.reference_date,
|
||
},
|
||
"runtime_mode": runtime,
|
||
"vedastro_official_full_snapshot": _snapshot_summary(snapshot, raw_response),
|
||
"official_capability_catalog": {
|
||
"status": catalog.get("status") or "blocked",
|
||
"available": bool(catalog.get("available")),
|
||
"summary": catalog.get("summary") or {},
|
||
"coverage": catalog.get("coverage") or {},
|
||
"domain_routing": catalog.get("domain_routing") or {},
|
||
"dynamic_selection": catalog.get("dynamic_selection") or {},
|
||
},
|
||
"cache_and_queue": _cache_and_queue_report(),
|
||
"strict_workflow": _strict_workflow_summary(route, catalog),
|
||
"honesty_boundary": {
|
||
"all_641_methods_executed": False,
|
||
"official_catalog_classified": bool(catalog.get("summary")),
|
||
"official_extended_ready": bool(runtime.get("official_ready")),
|
||
"rule": (
|
||
"Use official catalog domain routing and dynamic selection as evidence metadata. "
|
||
"Methods requiring user context/text/rectification remain blocked or secondary until inputs exist."
|
||
),
|
||
},
|
||
"user_commands": {
|
||
"json": (
|
||
"python3 scripts/vedastro_user_entrypoint.py --year YYYY --month MM --day DD "
|
||
"--hour HH --minute MM --lat LAT --lon LON --tz TZ --question '...' "
|
||
"--themes career,marriage,wealth --reference-date YYYY-MM-DD "
|
||
"--require-official-raw-response --format json "
|
||
"# includes official_full_capability_catalog and official_raw_response when verified"
|
||
),
|
||
"markdown": (
|
||
"python3 scripts/vedastro_user_entrypoint.py --year YYYY --month MM --day DD "
|
||
"--hour HH --minute MM --lat LAT --lon LON --tz TZ --question '...' --format markdown"
|
||
),
|
||
},
|
||
}
|
||
if raw_response:
|
||
report["official_raw_response"] = raw_response
|
||
return report
|
||
|
||
|
||
def render_markdown(report: dict[str, Any]) -> str:
|
||
runtime = report["runtime_mode"]
|
||
snapshot = report.get("vedastro_official_full_snapshot") or {}
|
||
catalog = report["official_capability_catalog"]
|
||
cache = report["cache_and_queue"]
|
||
strict = report["strict_workflow"]
|
||
summary = catalog.get("summary") or {}
|
||
lines = [
|
||
"# VedAstro 用户级入口",
|
||
"",
|
||
f"- runtime_mode: `{runtime.get('mode')}`",
|
||
f"- official_full_snapshot: `{snapshot.get('status')}`",
|
||
f"- official_raw_response_available: `{str(bool(snapshot.get('raw_response_available'))).lower()}`",
|
||
f"- official_ready: `{str(runtime.get('official_ready')).lower()}`",
|
||
f"- catalog_status: `{catalog.get('status')}`",
|
||
f"- catalog_method_count: `{summary.get('catalog_method_count', 0)}`",
|
||
f"- unknown_method_count: `{summary.get('unknown_method_count', 0)}`",
|
||
f"- misrouted_general_method_count: `{summary.get('misrouted_general_method_count', 0)}`",
|
||
f"- strict workflow triggered: `{str(strict.get('triggered')).lower()}`",
|
||
f"- primary_route: `{strict.get('primary_route')}`",
|
||
"",
|
||
"## Cache / Free-Tier Queue",
|
||
"",
|
||
f"- official_full_snapshot_cache_ttl_seconds: `{cache['official_full_snapshot_cache_ttl_seconds']}`",
|
||
f"- range_scan_cache_ttl_seconds: `{cache['range_scan_cache_ttl_seconds']}`",
|
||
f"- free_tier_queue_enabled: `{str(cache['free_tier_queue_enabled']).lower()}`",
|
||
"",
|
||
"## Boundary",
|
||
"",
|
||
"- 这个入口会启动 VedAstro official capability catalog 分类、动态主题选择和 strict workflow 合同摘要。",
|
||
"- 它不会把 641 项全部当作已执行；需要用户上下文、文本问题或校时画像的方法会保持 blocked/secondary。",
|
||
"- 如果 runtime 是 `fast_local_fallback`，解盘必须诚实降级，不得声称 official extended 已闭环。",
|
||
]
|
||
return "\n".join(lines) + "\n"
|
||
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser(description=__doc__)
|
||
parser.add_argument("--year", type=int, required=True)
|
||
parser.add_argument("--month", type=int, required=True)
|
||
parser.add_argument("--day", type=int, required=True)
|
||
parser.add_argument("--hour", type=int, required=True)
|
||
parser.add_argument("--minute", type=int, required=True)
|
||
parser.add_argument("--second", type=int, default=0)
|
||
parser.add_argument("--lat", type=float, required=True)
|
||
parser.add_argument("--lon", type=float, required=True)
|
||
parser.add_argument("--tz", type=float, required=True)
|
||
parser.add_argument("--question", default="")
|
||
parser.add_argument("--themes", default="career,marriage,wealth")
|
||
parser.add_argument("--reference-date", required=True)
|
||
parser.add_argument("--ayanamsa", default="lahiri")
|
||
parser.add_argument("--node-mode", default="mean")
|
||
parser.add_argument("--require-official-raw-response", action="store_true")
|
||
parser.add_argument("--format", choices=["json", "markdown"], default="markdown")
|
||
args = parser.parse_args()
|
||
|
||
report = build_report(args)
|
||
if args.format == "json":
|
||
print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
|
||
else:
|
||
print(render_markdown(report), end="")
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|