indiciumforge-cli 2.0.0__py3-none-any.whl

indiciumforge_cli/__init__.py

@@ -0,0 +1 @@
+"""Reference CLI for IndiciumForge."""

indiciumforge_cli/artifact.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_core.artifacts.comparator import GATE_ARTIFACTS
+from indiciumforge_core.artifacts.manifest import (
+    DAILY_REVIEW_REQUIRED_FILES,
+    format_audit_report,
+    is_daily_review_stage_dir,
+    is_factor_scan_stage_dir,
+    list_daily_review_stages,
+    list_market_gate_stages,
+    resolve_daily_review_audit_target,
+    resolve_factor_scan_audit_target,
+    resolve_market_gate_audit_target,
+    validate_daily_review_stage,
+    validate_factor_scan_stage,
+    validate_market_gate_stage,
+)
+
+artifact_app = typer.Typer(help="Artifact commands.")
+
+ARTIFACT_ROOT_OPTION = typer.Option(..., "--artifact-root")
+TRADE_DATE_OPTION = typer.Option(None, "--trade-date")
+STAGE_DIR_OPTION = typer.Option(None, "--stage-dir")
+META_PATH_OPTION = typer.Option(None, "--meta-path")
+STAGE_TYPE_OPTION = typer.Option(
+    "market_gate",
+    "--stage-type",
+    help="Stage domain: market_gate, daily_review, or factor_scan.",
+)
+
+
+@artifact_app.command("list")
+def artifact_list(artifact_root: Path = ARTIFACT_ROOT_OPTION) -> None:
+    gate_stages = list_market_gate_stages(artifact_root)
+    review_stages = list_daily_review_stages(artifact_root)
+    if not gate_stages and not review_stages:
+        typer.echo(f"No artifact stages found under {artifact_root}")
+        raise typer.Exit(code=0)
+
+    for ref in gate_stages:
+        typer.echo(
+            f"market_gate\t{ref.trade_date}\t"
+            f"{ref.core_artifact_count}/{len(GATE_ARTIFACTS)}\t{ref.stage_dir}"
+        )
+    for ref in review_stages:
+        typer.echo(
+            f"daily_review\t{ref.trade_date}\t"
+            f"{ref.core_artifact_count}/{len(DAILY_REVIEW_REQUIRED_FILES)}\t{ref.stage_dir}"
+        )
+
+
+@artifact_app.command("audit")
+def artifact_audit(
+    artifact_root: Path | None = typer.Option(None, "--artifact-root"),
+    trade_date: str | None = TRADE_DATE_OPTION,
+    stage_dir: Path | None = STAGE_DIR_OPTION,
+    meta_path: Path | None = META_PATH_OPTION,
+    stage_type: str = STAGE_TYPE_OPTION,
+) -> None:
+    parsed_trade_date = None
+    if trade_date is not None:
+        parsed_trade_date = datetime.strptime(trade_date, "%Y-%m-%d").date()
+
+    if stage_dir is None and (artifact_root is None or parsed_trade_date is None):
+        typer.echo("Provide --stage-dir or both --artifact-root and --trade-date.", err=True)
+        raise typer.Exit(code=2)
+
+    use_daily_review = stage_dir is not None and is_daily_review_stage_dir(stage_dir)
+    use_factor_scan = stage_dir is not None and is_factor_scan_stage_dir(stage_dir)
+    if stage_dir is None and stage_type == "daily_review":
+        use_daily_review = True
+    if stage_dir is None and stage_type == "factor_scan":
+        use_factor_scan = True
+
+    try:
+        if use_factor_scan:
+            target_dir, expected_trade_date = resolve_factor_scan_audit_target(
+                artifact_root=artifact_root,
+                trade_date=parsed_trade_date,
+                stage_dir=stage_dir,
+            )
+            if stage_dir is not None and parsed_trade_date is not None:
+                expected_trade_date = parsed_trade_date.isoformat()
+            manifest = validate_factor_scan_stage(
+                target_dir,
+                expected_trade_date=expected_trade_date,
+            )
+        elif use_daily_review:
+            target_dir, expected_trade_date = resolve_daily_review_audit_target(
+                artifact_root=artifact_root,
+                trade_date=parsed_trade_date,
+                stage_dir=stage_dir,
+            )
+            if stage_dir is not None and parsed_trade_date is not None:
+                expected_trade_date = parsed_trade_date.isoformat()
+            manifest = validate_daily_review_stage(
+                target_dir,
+                expected_trade_date=expected_trade_date,
+            )
+        else:
+            target_dir, expected_trade_date = resolve_market_gate_audit_target(
+                artifact_root=artifact_root,
+                trade_date=parsed_trade_date,
+                stage_dir=stage_dir,
+            )
+            if stage_dir is not None and parsed_trade_date is not None:
+                expected_trade_date = parsed_trade_date.isoformat()
+            manifest = validate_market_gate_stage(
+                target_dir,
+                expected_trade_date=expected_trade_date,
+                meta_path=meta_path,
+            )
+    except ValueError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    typer.echo(format_audit_report(manifest))
+    if not manifest.ok:
+        raise typer.Exit(code=1)

indiciumforge_cli/daily_review.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_workflow.market_awareness.runner import run_daily_review_skeleton
+
+TRADE_DATE_OPTION = typer.Option(..., "--trade-date")
+ARTIFACT_ROOT_OPTION = typer.Option(..., "--artifact-root")
+FIXTURE_PATH_OPTION = typer.Option(..., "--fixture-path")
+
+
+def workflow_daily_review(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    fixture_path: Path = FIXTURE_PATH_OPTION,
+) -> None:
+    parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+    result = run_daily_review_skeleton(
+        trade_date=parsed,
+        artifact_root=artifact_root,
+        fixture_path=fixture_path,
+    )
+    typer.echo(f"Wrote daily-review artifacts: {result.state_path.parent}")
+    typer.echo(f"  theme_state_ranking: {result.theme_state_ranking_path}")
+    typer.echo(f"  state: {result.state_path}")

indiciumforge_cli/factor.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_core.artifacts.manifest import validate_factor_scan_stage
+from indiciumforge_core.factors.loading import DetectorLoadError
+from indiciumforge_core.factors.universe import load_assets_from_fixture_list, parse_asset_codes
+from indiciumforge_workflow.factor_scan.runner import FactorScanStageConfig, run_factor_scan_stage
+
+TRADE_DATE_OPTION = typer.Option(..., "--trade-date")
+ARTIFACT_ROOT_OPTION = typer.Option(..., "--artifact-root")
+OHLCV_FIXTURE_ROOT_OPTION = typer.Option(
+    ...,
+    "--ohlcv-fixture-root",
+    help="Directory with synthetic OHLCV CSV fixtures.",
+)
+ASSET_FIXTURE_LIST_OPTION = typer.Option(
+    None,
+    "--asset-fixture-list",
+    help="YAML asset universe list (default when --codes omitted).",
+)
+CODES_OPTION = typer.Option(
+    None,
+    "--codes",
+    help="Local convenience: comma-separated asset codes (not a production universe).",
+)
+FACTOR_PACK_OPTION = typer.Option(None, "--factor-pack")
+DETECTORS_CONFIG_OPTION = typer.Option(None, "--detectors-config")
+INCLUDE_ENTRY_POINTS_OPTION = typer.Option(
+    False,
+    "--include-entry-points",
+    help="Also load detectors from installed indiciumforge.factor_detectors entry points.",
+)
+
+
+def factor_scan(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    ohlcv_fixture_root: Path = OHLCV_FIXTURE_ROOT_OPTION,
+    asset_fixture_list: Path | None = ASSET_FIXTURE_LIST_OPTION,
+    codes: str | None = CODES_OPTION,
+    factor_pack: Path | None = FACTOR_PACK_OPTION,
+    detectors_config: Path | None = DETECTORS_CONFIG_OPTION,
+    include_entry_points: bool = INCLUDE_ENTRY_POINTS_OPTION,
+) -> None:
+    if factor_pack is None and detectors_config is None and not include_entry_points:
+        typer.echo(
+            "Provide --factor-pack, --detectors-config, or --include-entry-points.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+
+    parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+
+    if codes is not None:
+        assets = tuple(parse_asset_codes(codes))
+        asset_universe_source = "cli_codes"
+    elif asset_fixture_list is not None:
+        assets = tuple(load_assets_from_fixture_list(asset_fixture_list))
+        asset_universe_source = "fixture_asset_list"
+    else:
+        typer.echo("Provide --asset-fixture-list or --codes.", err=True)
+        raise typer.Exit(code=2)
+
+    try:
+        result = run_factor_scan_stage(
+            trade_date=parsed,
+            artifact_root=artifact_root,
+            config=FactorScanStageConfig(
+                pack_config=factor_pack,
+                detectors_config=detectors_config,
+                include_entry_points=include_entry_points,
+                ohlcv_fixture_root=ohlcv_fixture_root,
+                asset_fixture_list=asset_fixture_list,
+                assets=assets,
+                asset_universe_source=asset_universe_source,
+            ),
+        )
+    except (ValueError, OSError, DetectorLoadError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    audit = validate_factor_scan_stage(result.stage_dir, expected_trade_date=parsed.isoformat())
+    typer.echo(f"factor-scan stage: {result.stage_dir}")
+    typer.echo(f"pack_id: {result.pack.pack_id or '(none)'}")
+    typer.echo(f"detectors: {', '.join(result.pack.registry.list_detectors())}")
+    typer.echo(f"signals: {result.signal_count}")
+    typer.echo(f"factor_scan audit: {'ok' if audit.ok else 'failed'}")
+
+    if not audit.ok:
+        raise typer.Exit(code=1)

indiciumforge_cli/main.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_workflow.market_gate.runner import run_market_gate
+
+from indiciumforge_cli.artifact import artifact_app
+from indiciumforge_cli.daily_review import workflow_daily_review
+from indiciumforge_cli.factor import factor_scan
+from indiciumforge_cli.parity import parity_report, parity_run
+from indiciumforge_cli.provider import provider_fetch, provider_inspect
+from indiciumforge_cli.synthetic_e2e import workflow_synthetic_e2e
+from indiciumforge_cli.workflow_chain import workflow_chain
+
+app = typer.Typer(help="IndiciumForge reference CLI.")
+workflow_app = typer.Typer(help="Workflow commands.")
+factor_app = typer.Typer(help="Factor commands.")
+provider_app = typer.Typer(help="Data provider commands.")
+parity_app = typer.Typer(help="Private-local parity harness (research audit only).")
+app.add_typer(workflow_app, name="workflow")
+app.add_typer(artifact_app, name="artifact")
+app.add_typer(factor_app, name="factor")
+app.add_typer(provider_app, name="provider")
+app.add_typer(parity_app, name="parity")
+
+TRADE_DATE_OPTION = typer.Option(..., "--trade-date")
+ARTIFACT_ROOT_OPTION = typer.Option(..., "--artifact-root")
+
+
+@workflow_app.command("market-gate")
+def workflow_market_gate(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+) -> None:
+    parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+    result = run_market_gate(trade_date=parsed, artifact_root=artifact_root)
+    typer.echo(f"Wrote market-gate artifacts: {result.stage_dir}")
+
+
+@workflow_app.command("daily-review", help="Run skeleton daily-review from a synthetic fixture.")
+def workflow_daily_review_command(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    fixture_path: Path = typer.Option(..., "--fixture-path"),
+) -> None:
+    workflow_daily_review(
+        trade_date=trade_date,
+        artifact_root=artifact_root,
+        fixture_path=fixture_path,
+    )
+
+
+@workflow_app.command(
+    "synthetic-e2e",
+    help="Run synthetic end-to-end workflow: daily-review -> market-gate -> audit summary.",
+)
+def workflow_synthetic_e2e_command(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    daily_review_fixture: Path = typer.Option(..., "--daily-review-fixture"),
+    preopen_review_fixture: Path = typer.Option(..., "--preopen-review-fixture"),
+) -> None:
+    workflow_synthetic_e2e(
+        trade_date=trade_date,
+        artifact_root=artifact_root,
+        daily_review_fixture=daily_review_fixture,
+        preopen_review_fixture=preopen_review_fixture,
+    )
+
+
+@workflow_app.command(
+    "chain",
+    help="Run workflow chain: skeleton fixtures or recipe-driven private extension pack.",
+)
+def workflow_chain_command(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    daily_review_fixture: Path = typer.Option(..., "--daily-review-fixture"),
+    post_close_review_fixture: Path | None = typer.Option(
+        None, "--post-close-review-fixture"
+    ),
+    preopen_review_fixture: Path | None = typer.Option(None, "--preopen-review-fixture"),
+    recipe: Path | None = typer.Option(None, "--recipe"),
+    recipe_extension_pack: Path | None = typer.Option(None, "--recipe-extension-pack"),
+    factor_pack: Path | None = typer.Option(None, "--factor-pack"),
+    detectors_config: Path | None = typer.Option(None, "--detectors-config"),
+    include_entry_points: bool = typer.Option(False, "--include-entry-points"),
+    ohlcv_fixture_root: Path | None = typer.Option(None, "--ohlcv-fixture-root"),
+    asset_fixture_list: Path | None = typer.Option(None, "--asset-fixture-list"),
+    codes: str | None = typer.Option(
+        None,
+        "--codes",
+        help="Local convenience only; not a production universe mechanism.",
+    ),
+) -> None:
+    workflow_chain(
+        trade_date=trade_date,
+        artifact_root=artifact_root,
+        daily_review_fixture=daily_review_fixture,
+        post_close_review_fixture=post_close_review_fixture,
+        preopen_review_fixture=preopen_review_fixture,
+        recipe=recipe,
+        recipe_extension_pack=recipe_extension_pack,
+        factor_pack=factor_pack,
+        detectors_config=detectors_config,
+        include_entry_points=include_entry_points,
+        ohlcv_fixture_root=ohlcv_fixture_root,
+        asset_fixture_list=asset_fixture_list,
+        codes=codes,
+    )
+
+
+@provider_app.command("inspect", help="List loaded providers and capability matrix.")
+def provider_inspect_command(
+    provider_pack: Path | None = typer.Option(None, "--provider-pack"),
+    providers_config: Path | None = typer.Option(None, "--providers-config"),
+    include_entry_points: bool = typer.Option(False, "--include-entry-points"),
+    ohlcv_fixture_root: Path | None = typer.Option(None, "--ohlcv-fixture-root"),
+) -> None:
+    provider_inspect(
+        provider_pack=provider_pack,
+        providers_config=providers_config,
+        include_entry_points=include_entry_points,
+        ohlcv_fixture_root=ohlcv_fixture_root,
+    )
+
+
+@provider_app.command("fetch", help="Single-query provider smoke (fixture/fake only).")
+def provider_fetch_command(
+    trade_date: str = TRADE_DATE_OPTION,
+    code: str = typer.Option(..., "--code"),
+    data_kind: str = typer.Option("ohlcv", "--data-kind"),
+    provider_pack: Path | None = typer.Option(None, "--provider-pack"),
+    providers_config: Path | None = typer.Option(None, "--providers-config"),
+    include_entry_points: bool = typer.Option(False, "--include-entry-points"),
+    ohlcv_fixture_root: Path | None = typer.Option(None, "--ohlcv-fixture-root"),
+    recipe_id: str = typer.Option("indiciumforge.recipe.ashare_daily_research.v1", "--recipe-id"),
+    cycle_id: str | None = typer.Option(None, "--cycle-id"),
+    checkpoint_id: str | None = typer.Option(None, "--checkpoint-id"),
+) -> None:
+    provider_fetch(
+        trade_date=trade_date,
+        code=code,
+        data_kind=data_kind,
+        provider_pack=provider_pack,
+        providers_config=providers_config,
+        include_entry_points=include_entry_points,
+        ohlcv_fixture_root=ohlcv_fixture_root,
+        recipe_id=recipe_id,
+        cycle_id=cycle_id,
+        checkpoint_id=checkpoint_id,
+    )
+
+
+@factor_app.command("scan", help="Run factor scan from a local private pack or detectors config.")
+def factor_scan_command(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    ohlcv_fixture_root: Path = typer.Option(..., "--ohlcv-fixture-root"),
+    asset_fixture_list: Path | None = typer.Option(None, "--asset-fixture-list"),
+    codes: str | None = typer.Option(None, "--codes"),
+    factor_pack: Path | None = typer.Option(None, "--factor-pack"),
+    detectors_config: Path | None = typer.Option(None, "--detectors-config"),
+    include_entry_points: bool = typer.Option(False, "--include-entry-points"),
+) -> None:
+    factor_scan(
+        trade_date=trade_date,
+        artifact_root=artifact_root,
+        ohlcv_fixture_root=ohlcv_fixture_root,
+        asset_fixture_list=asset_fixture_list,
+        codes=codes,
+        factor_pack=factor_pack,
+        detectors_config=detectors_config,
+        include_entry_points=include_entry_points,
+    )
+
+
+@parity_app.command(
+    "run",
+    help="Run recipe chain then compare against a local reference artifact root.",
+)
+def parity_run_command(
+    parity_config: Path = typer.Option(..., "--parity-config"),
+    artifact_root: Path | None = typer.Option(None, "--artifact-root"),
+) -> None:
+    parity_run(parity_config=parity_config, artifact_root=artifact_root)
+
+
+@parity_app.command("report", help="Summarize an existing parity_run_report.json.")
+def parity_report_command(
+    report: Path = typer.Option(..., "--report"),
+    output_format: str = typer.Option("table", "--format", help="table or json"),
+) -> None:
+    parity_report(report_path=report, output_format=output_format)

indiciumforge_cli/parity.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from indiciumforge_core.parity.config import ParityConfigError, load_parity_config
+from indiciumforge_workflow.parity.runner import run_parity_after_recipe_chain
+
+
+def parity_run(
+    *,
+    parity_config: Path,
+    artifact_root: Path | None = None,
+) -> None:
+    try:
+        config = load_parity_config(parity_config)
+        result = run_parity_after_recipe_chain(config=config, artifact_root=artifact_root)
+    except (ParityConfigError, FileNotFoundError, ValueError, OSError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    typer.echo(f"recipe chain summary: {result.chain.summary_path}")
+    typer.echo(f"parity report: {result.report.report_path}")
+    for check in result.report.results:
+        typer.echo(f"{check.dimension.value}: {check.verdict.value} - {check.message}")
+
+    if not result.report.all_match:
+        raise typer.Exit(code=1)
+
+
+def parity_report(*, report_path: Path, output_format: str = "table") -> None:
+    if not report_path.is_file():
+        typer.echo(f"report not found: {report_path}", err=True)
+        raise typer.Exit(code=2)
+
+    payload = json.loads(report_path.read_text(encoding="utf-8-sig"))
+    if output_format == "json":
+        typer.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+
+    typer.echo(f"trade_date: {payload.get('trade_date')}")
+    typer.echo(f"all_match: {payload.get('all_match')}")
+    typer.echo(f"disclaimer: {payload.get('disclaimer')}")
+    for item in payload.get("results", []):
+        typer.echo(
+            f"- {item.get('dimension')}: {item.get('verdict')} ({item.get('message')})"
+        )
+
+    if not payload.get("all_match"):
+        raise typer.Exit(code=1)

indiciumforge_cli/provider.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_core.domain.models import AssetID, AssetType, Exchange
+from indiciumforge_core.providers.capabilities import DataKind
+from indiciumforge_core.providers.config import ProviderLoadError, load_provider_pack
+from indiciumforge_core.providers.local_fixture_v2 import LocalFixtureProviderV2
+from indiciumforge_core.providers.query import DataQuery
+from indiciumforge_core.providers.registry_v2 import ProviderRegistryV2
+from indiciumforge_core.workflow.model import (
+    AssetDomain,
+    SessionModel,
+    WorkflowSessionMetadata,
+    ashare_cycle_id,
+)
+
+PROVIDER_PACK_OPTION = typer.Option(None, "--provider-pack")
+PROVIDERS_CONFIG_OPTION = typer.Option(None, "--providers-config")
+INCLUDE_ENTRY_POINTS_OPTION = typer.Option(
+    False,
+    "--include-entry-points",
+    help="Also load providers from installed indiciumforge.data_providers entry points.",
+)
+OHLCV_FIXTURE_ROOT_OPTION = typer.Option(
+    None,
+    "--ohlcv-fixture-root",
+    help="Fixture root when no pack/config is supplied (local_fixture only).",
+)
+TRADE_DATE_OPTION = typer.Option(..., "--trade-date")
+CODE_OPTION = typer.Option(..., "--code", help="Asset code (SSE stock for smoke tests).")
+DATA_KIND_OPTION = typer.Option("ohlcv", "--data-kind")
+RECIPE_ID_OPTION = typer.Option(
+    "indiciumforge.recipe.ashare_daily_research.v1",
+    "--recipe-id",
+)
+CYCLE_ID_OPTION = typer.Option(None, "--cycle-id")
+CHECKPOINT_ID_OPTION = typer.Option(None, "--checkpoint-id")
+
+
+def _load_registry(
+    *,
+    provider_pack: Path | None,
+    providers_config: Path | None,
+    include_entry_points: bool,
+    ohlcv_fixture_root: Path | None,
+) -> ProviderRegistryV2:
+    if provider_pack is not None or providers_config is not None or include_entry_points:
+        loaded = load_provider_pack(
+            pack_config=provider_pack,
+            providers_config=providers_config,
+            include_entry_points=include_entry_points,
+        )
+        return ProviderRegistryV2(list(loaded.providers))
+
+    if ohlcv_fixture_root is None:
+        raise ProviderLoadError(
+            "provide --provider-pack, --providers-config, --include-entry-points, "
+            "or --ohlcv-fixture-root"
+        )
+    return ProviderRegistryV2([LocalFixtureProviderV2(ohlcv_fixture_root)])
+
+
+def provider_inspect(
+    provider_pack: Path | None = PROVIDER_PACK_OPTION,
+    providers_config: Path | None = PROVIDERS_CONFIG_OPTION,
+    include_entry_points: bool = INCLUDE_ENTRY_POINTS_OPTION,
+    ohlcv_fixture_root: Path | None = OHLCV_FIXTURE_ROOT_OPTION,
+) -> None:
+    try:
+        if provider_pack is not None or providers_config is not None or include_entry_points:
+            loaded = load_provider_pack(
+                pack_config=provider_pack,
+                providers_config=providers_config,
+                include_entry_points=include_entry_points,
+            )
+            if loaded.pack_id:
+                typer.echo(f"pack_id: {loaded.pack_id}")
+            if loaded.version:
+                typer.echo(f"version: {loaded.version}")
+            typer.echo(f"sources: {', '.join(loaded.sources)}")
+            providers = loaded.providers
+        elif ohlcv_fixture_root is not None:
+            providers = (LocalFixtureProviderV2(ohlcv_fixture_root),)
+        else:
+            typer.echo(
+                "Provide --provider-pack, --providers-config, --include-entry-points, "
+                "or --ohlcv-fixture-root.",
+                err=True,
+            )
+            raise typer.Exit(code=2)
+    except ProviderLoadError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    for provider in providers:
+        typer.echo(f"provider_id: {provider.provider_id}")
+        typer.echo(f"  authority_level: {provider.authority_level.value}")
+        for capability in provider.capabilities:
+            venues = ",".join(capability.venues) if capability.venues else "-"
+            typer.echo(
+                "  capability: "
+                f"{capability.asset_domain.value}/"
+                f"{capability.data_kind.value}/"
+                f"{capability.latency_profile.value} venues={venues}"
+            )
+
+
+def provider_fetch(
+    trade_date: str = TRADE_DATE_OPTION,
+    code: str = CODE_OPTION,
+    data_kind: str = DATA_KIND_OPTION,
+    provider_pack: Path | None = PROVIDER_PACK_OPTION,
+    providers_config: Path | None = PROVIDERS_CONFIG_OPTION,
+    include_entry_points: bool = INCLUDE_ENTRY_POINTS_OPTION,
+    ohlcv_fixture_root: Path | None = OHLCV_FIXTURE_ROOT_OPTION,
+    recipe_id: str = RECIPE_ID_OPTION,
+    cycle_id: str | None = CYCLE_ID_OPTION,
+    checkpoint_id: str | None = CHECKPOINT_ID_OPTION,
+) -> None:
+    try:
+        parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+        kind = DataKind(data_kind)
+        registry = _load_registry(
+            provider_pack=provider_pack,
+            providers_config=providers_config,
+            include_entry_points=include_entry_points,
+            ohlcv_fixture_root=ohlcv_fixture_root,
+        )
+    except (ProviderLoadError, ValueError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    session = WorkflowSessionMetadata(
+        recipe_id=recipe_id,
+        asset_domain=AssetDomain.CHINA_A_SHARE,
+        session_model=SessionModel.CALENDAR_DAY_CYCLE,
+        cycle_id=cycle_id or ashare_cycle_id(parsed),
+    )
+    query = DataQuery.from_session(
+        asset=AssetID(code, Exchange.SSE, AssetType.STOCK),
+        data_kind=kind,
+        session=session,
+        as_of=parsed,
+        checkpoint_id=checkpoint_id,
+    )
+    result = registry.fetch(query)
+    payload = {
+        "rows": len(result.frame),
+        "provenance": result.provenance.to_payload(),
+        "attempted_providers": list(result.attempted_providers),
+    }
+    typer.echo(json.dumps(payload, indent=2, default=str))

indiciumforge_cli/synthetic_e2e.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_workflow.e2e.synthetic import run_synthetic_e2e
+
+TRADE_DATE_OPTION = typer.Option(..., "--trade-date")
+ARTIFACT_ROOT_OPTION = typer.Option(..., "--artifact-root")
+DAILY_REVIEW_FIXTURE_OPTION = typer.Option(..., "--daily-review-fixture")
+PREOPEN_REVIEW_FIXTURE_OPTION = typer.Option(..., "--preopen-review-fixture")
+
+
+def workflow_synthetic_e2e(
+    trade_date: str = TRADE_DATE_OPTION,
+    artifact_root: Path = ARTIFACT_ROOT_OPTION,
+    daily_review_fixture: Path = DAILY_REVIEW_FIXTURE_OPTION,
+    preopen_review_fixture: Path = PREOPEN_REVIEW_FIXTURE_OPTION,
+) -> None:
+    parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+    try:
+        result = run_synthetic_e2e(
+            trade_date=parsed,
+            artifact_root=artifact_root,
+            daily_review_fixture=daily_review_fixture,
+            preopen_review_fixture=preopen_review_fixture,
+        )
+    except FileNotFoundError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    typer.echo(f"daily-review stage: {result.daily_review_stage_dir}")
+    typer.echo(
+        "  theme_state_ranking: "
+        f"{result.daily_review_stage_dir / 'theme_state_ranking.csv'}"
+    )
+    typer.echo(f"market-gate stage: {result.market_gate_stage_dir}")
+    typer.echo(
+        f"daily_review audit: {'ok' if result.daily_review_audit_ok else 'failed'}"
+    )
+    typer.echo(f"market_gate audit: {'ok' if result.market_gate_audit_ok else 'failed'}")
+    typer.echo(f"audit: {'ok' if result.audit_ok else 'failed'}")
+    typer.echo(f"summary: {result.summary_path}")
+
+    if not result.audit_ok:
+        raise typer.Exit(code=1)

indiciumforge_cli/workflow_chain.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from indiciumforge_core.factors.loading import DetectorLoadError
+from indiciumforge_core.factors.universe import load_assets_from_fixture_list, parse_asset_codes
+from indiciumforge_core.recipes.pack import RecipeExtensionLoadError
+from indiciumforge_workflow.factor_scan.runner import FactorScanStageConfig
+from indiciumforge_workflow.workflow_chain.runner import (
+    WorkflowChainRecipeConfig,
+    run_workflow_chain_recipe,
+    run_workflow_chain_skeleton,
+)
+
+
+def _build_factor_scan_config(
+    *,
+    factor_pack: Path | None,
+    detectors_config: Path | None,
+    include_entry_points: bool,
+    ohlcv_fixture_root: Path | None,
+    asset_fixture_list: Path | None,
+    codes: str | None,
+) -> FactorScanStageConfig | None:
+    if factor_pack is None and detectors_config is None and not include_entry_points:
+        return None
+
+    if ohlcv_fixture_root is None:
+        raise ValueError(
+            "--ohlcv-fixture-root is required when factor scan flags are set."
+        )
+
+    if codes is not None:
+        assets = tuple(parse_asset_codes(codes))
+        asset_universe_source = "cli_codes"
+    elif asset_fixture_list is not None:
+        assets = tuple(load_assets_from_fixture_list(asset_fixture_list))
+        asset_universe_source = "fixture_asset_list"
+    else:
+        raise ValueError(
+            "Provide --asset-fixture-list or --codes when enabling factor scan."
+        )
+
+    return FactorScanStageConfig(
+        pack_config=factor_pack,
+        detectors_config=detectors_config,
+        include_entry_points=include_entry_points,
+        ohlcv_fixture_root=ohlcv_fixture_root,
+        asset_fixture_list=asset_fixture_list,
+        assets=assets,
+        asset_universe_source=asset_universe_source,
+    )
+
+
+def _echo_chain_result(result) -> None:  # noqa: ANN001
+    typer.echo(f"daily-review stage: {result.daily_review_stage_dir}")
+    if result.factor_scan_enabled and result.factor_scan_stage_dir is not None:
+        typer.echo(f"factor-scan stage: {result.factor_scan_stage_dir}")
+        typer.echo(f"factor signals: {result.signal_count}")
+        typer.echo(
+            "factor_scan audit: "
+            f"{'ok' if result.factor_scan_audit_ok else 'failed'}"
+        )
+    typer.echo(f"post-close stage: {result.post_close_stage_dir}")
+    typer.echo(f"preopen stage: {result.preopen_stage_dir}")
+    typer.echo(f"market-gate stage: {result.market_gate_stage_dir}")
+    if result.recipe_id is not None:
+        typer.echo(f"recipe_id: {result.recipe_id}")
+    if result.extension_pack_id is not None:
+        typer.echo(f"extension_pack_id: {result.extension_pack_id}")
+    if result.recipe_run_summary_path is not None:
+        typer.echo(f"recipe_run_summary: {result.recipe_run_summary_path}")
+    typer.echo(f"workflow_review_source_stage: {result.workflow_review_source_stage}")
+    typer.echo(f"strict_count: {result.strict_count}")
+    typer.echo(
+        f"daily_review audit: {'ok' if result.daily_review_audit_ok else 'failed'}"
+    )
+    typer.echo(f"market_gate audit: {'ok' if result.market_gate_audit_ok else 'failed'}")
+    typer.echo(f"chain: {'ok' if result.chain_ok else 'failed'}")
+    typer.echo(f"summary: {result.summary_path}")
+
+
+def workflow_chain(
+    *,
+    trade_date: str,
+    artifact_root: Path,
+    daily_review_fixture: Path,
+    post_close_review_fixture: Path | None = None,
+    preopen_review_fixture: Path | None = None,
+    recipe: Path | None = None,
+    recipe_extension_pack: Path | None = None,
+    factor_pack: Path | None = None,
+    detectors_config: Path | None = None,
+    include_entry_points: bool = False,
+    ohlcv_fixture_root: Path | None = None,
+    asset_fixture_list: Path | None = None,
+    codes: str | None = None,
+) -> None:
+    parsed = datetime.strptime(trade_date, "%Y-%m-%d").date()
+    try:
+        factor_scan_config = _build_factor_scan_config(
+            factor_pack=factor_pack,
+            detectors_config=detectors_config,
+            include_entry_points=include_entry_points,
+            ohlcv_fixture_root=ohlcv_fixture_root,
+            asset_fixture_list=asset_fixture_list,
+            codes=codes,
+        )
+        if recipe is not None:
+            if recipe_extension_pack is None:
+                raise ValueError("--recipe-extension-pack is required with --recipe")
+            result = run_workflow_chain_recipe(
+                trade_date=parsed,
+                artifact_root=artifact_root,
+                config=WorkflowChainRecipeConfig(
+                    recipe_path=recipe,
+                    recipe_extension_pack=recipe_extension_pack,
+                    daily_review_fixture=daily_review_fixture,
+                    factor_scan_config=factor_scan_config,
+                ),
+            )
+        else:
+            if post_close_review_fixture is None or preopen_review_fixture is None:
+                raise ValueError(
+                    "skeleton chain requires --post-close-review-fixture and "
+                    "--preopen-review-fixture (or use --recipe)"
+                )
+            result = run_workflow_chain_skeleton(
+                trade_date=parsed,
+                artifact_root=artifact_root,
+                daily_review_fixture=daily_review_fixture,
+                post_close_review_fixture=post_close_review_fixture,
+                preopen_review_fixture=preopen_review_fixture,
+                factor_scan_config=factor_scan_config,
+            )
+    except FileNotFoundError as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+    except (ValueError, OSError, DetectorLoadError, RecipeExtensionLoadError) as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=2) from exc
+
+    _echo_chain_result(result)
+
+    if not result.chain_ok:
+        raise typer.Exit(code=1)

indiciumforge_cli-2.0.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: indiciumforge-cli
+Version: 2.0.0
+Summary: Reference CLI for IndiciumForge research audit workflows (indiciumforge command).
+Author: IndiciumForge contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Cavaradossi/indiciumforge
+Project-URL: Repository, https://github.com/Cavaradossi/indiciumforge
+Project-URL: Documentation, https://github.com/Cavaradossi/indiciumforge/tree/master/docs
+Project-URL: Issues, https://github.com/Cavaradossi/indiciumforge/issues
+Project-URL: Changelog, https://github.com/Cavaradossi/indiciumforge/blob/master/RELEASE_NOTES.md
+Keywords: cli,workflow,research,audit,open-core
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: indiciumforge-workflow<3.0.0,>=2.0.0
+Requires-Dist: typer>=0.9
+
+# indiciumforge-cli
+
+Reference CLI for [IndiciumForge](https://github.com/Cavaradossi/indiciumforge).
+
+Entry point: `indiciumforge` — workflow, artifact audit, factor scan, provider inspect, parity harness.
+
+Research audit only — not investment advice, not broker execution.
+
+## Install
+
+PyPI publish is pending. Install from the monorepo:
+
+```bash
+pip install -e packages/indiciumforge-core -e packages/indiciumforge-workflow -e packages/indiciumforge-cli
+```
+
+See [docs/PYPI_RELEASE_CHECKLIST.md](https://github.com/Cavaradossi/indiciumforge/blob/master/docs/PYPI_RELEASE_CHECKLIST.md).

indiciumforge_cli-2.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+indiciumforge_cli/__init__.py,sha256=21pWuZ3WTTEHKu94yAtymHSnRMBHkJwlrBlDHuihcHE,39
+indiciumforge_cli/artifact.py,sha256=vBP8ZRox0J7ZHlQe9kcNg2iYWm6uP_YDCmZRv0NEYqQ,4684
+indiciumforge_cli/daily_review.py,sha256=m4ExnbSy8EHu4UptCvAoISjlSbMUXFRT7EjBDzVR-_Q,945
+indiciumforge_cli/factor.py,sha256=r2YCG4r3Ty3_wAIfGmOMfITyhfLNC3MphvKfqGsxWrk,3628
+indiciumforge_cli/main.py,sha256=aWDb875TdANPAEw8Fk9UUiMUouz_uTwNCoN64kUmba4,8018
+indiciumforge_cli/parity.py,sha256=WOApkAia5wMxt7LBwL87LNYgqXj6pAlmf5SrbG34Uqo,1800
+indiciumforge_cli/provider.py,sha256=Wxjw4RjLpOo0KtJl5_vavLPKv7mGPt4cNgv2LR7YOY4,5975
+indiciumforge_cli/synthetic_e2e.py,sha256=X05e2MNT91S9Xa8rcSqBlUNrhrYHyKjQzUb2Il20gPw,1760
+indiciumforge_cli/workflow_chain.py,sha256=HYbmuAzGouUV2QfED6LiXqUR-x4igfo8oP-Jp0C7TUI,5903
+indiciumforge_cli-2.0.0.dist-info/METADATA,sha256=Z4gf9wpfRLPMOnyk2P01iVGtSfIZrwho65EwZJxos-E,1955
+indiciumforge_cli-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+indiciumforge_cli-2.0.0.dist-info/entry_points.txt,sha256=5avLhPwpgZvM3G5rDxwmctIRiOlGr2hGuNKoxipuSNk,61
+indiciumforge_cli-2.0.0.dist-info/top_level.txt,sha256=qMRjR2PXPf11HfVPJe8gz8mDRP7xiETFjJzIBeZPsSA,18
+indiciumforge_cli-2.0.0.dist-info/RECORD,,

indiciumforge_cli-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

indiciumforge_cli-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+indiciumforge = indiciumforge_cli.main:app

indiciumforge_cli-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+indiciumforge_cli