parseforge 0.2.12__tar.gz → 0.3.1__tar.gz

parseforge-0.3.1/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: parseforge
+Version: 0.3.1
+Summary: LLM-driven pipeline that forges, validates, and promotes TextFSM templates from network CLI output
+Author-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
+Maintainer-email: Tuyen Mathew Duong <tuyen@geekstrident.com>
+License: MIT
+Keywords: textfsm,network automation,cli parsing,template generator,ai,llm,netmiko,device output parsing
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: textfsm>=1.1.0
+Requires-Dist: textfsm-ai>=0.7.1
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == "anthropic"
+Requires-Dist: textfsm-ai[anthropic]>=0.7.1; extra == "anthropic"
+Provides-Extra: deepseek
+Requires-Dist: openai>=1.0.0; extra == "deepseek"
+Requires-Dist: textfsm-ai[deepseek]>=0.7.1; extra == "deepseek"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Requires-Dist: textfsm-ai[openai]>=0.7.1; extra == "openai"
+Provides-Extra: groq
+Requires-Dist: openai>=1.0.0; extra == "groq"
+Requires-Dist: textfsm-ai[groq]>=0.7.1; extra == "groq"
+Provides-Extra: xai
+Requires-Dist: openai>=1.0.0; extra == "xai"
+Requires-Dist: textfsm-ai[xai]>=0.7.1; extra == "xai"
+Provides-Extra: together
+Requires-Dist: openai>=1.0.0; extra == "together"
+Requires-Dist: textfsm-ai[together]>=0.7.1; extra == "together"
+Provides-Extra: fireworks
+Requires-Dist: openai>=1.0.0; extra == "fireworks"
+Requires-Dist: textfsm-ai[fireworks]>=0.7.1; extra == "fireworks"
+Provides-Extra: perplexity
+Requires-Dist: openai>=1.0.0; extra == "perplexity"
+Requires-Dist: textfsm-ai[perplexity]>=0.7.1; extra == "perplexity"
+Provides-Extra: openrouter
+Requires-Dist: openai>=1.0.0; extra == "openrouter"
+Requires-Dist: textfsm-ai[openrouter]>=0.7.1; extra == "openrouter"
+Provides-Extra: moonshot
+Requires-Dist: openai>=1.0.0; extra == "moonshot"
+Requires-Dist: textfsm-ai[moonshot]>=0.7.1; extra == "moonshot"
+Provides-Extra: cerebras
+Requires-Dist: openai>=1.0.0; extra == "cerebras"
+Requires-Dist: textfsm-ai[cerebras]>=0.7.1; extra == "cerebras"
+Provides-Extra: mistral
+Requires-Dist: mistralai==1.10.0; extra == "mistral"
+Requires-Dist: textfsm-ai[mistral]>=0.7.1; extra == "mistral"
+Provides-Extra: cohere
+Requires-Dist: cohere==5.21.1; extra == "cohere"
+Requires-Dist: textfsm-ai[cohere]>=0.7.1; extra == "cohere"
+Provides-Extra: azure
+Requires-Dist: azure-ai-inference>=1.0.0b9; extra == "azure"
+Requires-Dist: textfsm-ai[azure]>=0.7.1; extra == "azure"
+Provides-Extra: gemini
+Requires-Dist: google-genai>=0.2.0; extra == "gemini"
+Requires-Dist: textfsm-ai[gemini]>=0.7.1; extra == "gemini"
+Provides-Extra: vertexai
+Requires-Dist: google-genai>=0.2.0; extra == "vertexai"
+Requires-Dist: textfsm-ai[vertexai]>=0.7.1; extra == "vertexai"
+Provides-Extra: bedrock
+Requires-Dist: boto3==1.42.97; extra == "bedrock"
+Requires-Dist: textfsm-ai[bedrock]>=0.7.1; extra == "bedrock"
+Provides-Extra: oci
+Requires-Dist: oci==2.182.0; extra == "oci"
+Requires-Dist: textfsm-ai[oci]>=0.7.1; extra == "oci"
+Provides-Extra: sampling
+Requires-Dist: netmiko>=4.0; extra == "sampling"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: anthropic>=0.40.0; extra == "dev"
+Requires-Dist: openai>=1.0.0; extra == "dev"
+Requires-Dist: mistralai==1.10.0; extra == "dev"
+Requires-Dist: cohere==5.21.1; extra == "dev"
+Requires-Dist: azure-ai-inference>=1.0.0b9; extra == "dev"
+Requires-Dist: google-genai>=0.2.0; extra == "dev"
+Requires-Dist: boto3==1.42.97; extra == "dev"
+Requires-Dist: oci==2.182.0; extra == "dev"
+Provides-Extra: release
+Requires-Dist: bump2version; extra == "release"
+Requires-Dist: build; extra == "release"
+Dynamic: license-file
+
+# ParseForge
+
+LLM-driven pipeline that forges, cross-validates, and promotes [TextFSM](https://github.com/google/textfsm)
+templates from network device CLI output.
+
+Full design plan: [SPEC.md](SPEC.md).
+
+## Features
+
+- **Trial → integration → promotion: a Human-in-the-Loop review workflow,
+  not a one-shot generator.** Every LLM-generated template starts as
+  unreviewed evidence in `trials/`. `integration` clusters every trial for
+  a command by the *output schema* its parsed records actually have, not
+  exact template text — a command's output can legitimately vary by
+  hardware/firmware, so distinct schemas become separate, independently
+  tracked groups instead of one hand-picked "winner." `promotion` then
+  auto-promotes any group whose match rate against every known sample
+  clears a configurable gate straight into `authoritative/`; anything
+  short of that gate is queued for human review instead of silently
+  shipped. A human-reviewed promotion is recorded as a named snapshot
+  alongside whatever's currently live, never silently overwriting it —
+  so review effort goes only where the evidence is actually ambiguous.
+- **Eighteen LLM providers, one interface.** Anthropic, OpenAI, DeepSeek,
+  Groq, xAI, Together, Fireworks, Perplexity, OpenRouter, Moonshot,
+  Cerebras, Mistral, Cohere, Azure OpenAI, Gemini, Vertex AI, Amazon
+  Bedrock, and Oracle Cloud (OCI) — including four with non-standard auth
+  (deployment names, GCP Application Default Credentials, AWS's
+  credential chain, OCI request-signing) handled transparently. Naming
+  and generation can use two different providers in the same trial. See
+  [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/).
+- **Self-caching cli-name resolution.** A raw CLI command
+  (`show interface GE1.1 status`) only ever costs LLM tokens once — it's
+  resolved to a canonical, indexed name
+  (`show-interface-var1-status`) and cached locally; every later trial for
+  that command is a free lookup.
+- **Self-validation, not just "the LLM said so."** Every generated
+  template is immediately run against its own sample before being
+  recorded as passed — a template that doesn't actually parse the output
+  it was generated from never gets a chance to look good on paper.
+- **Drift monitoring.** An authoritative template is periodically checked
+  against new production samples; a failing sample feeds back into the
+  pipeline as a new trial automatically, closing the loop instead of just
+  logging an alert.
+- **CLI and Python API, same underlying calls.** Everything the CLI does
+  — `run`, `trial`, `integration`, `promotion` — is one function call in
+  Python too. See the
+  [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/).
+
+## Status
+
+Early beta. The full pipeline is implemented and tested end to end — naming,
+sampling, generation, self-validation, integration (output-schema group/variant
+clustering), promotion (auto and human-reviewed), and drift monitoring — and
+wired into the CLI. A few things are intentionally not there yet:
+
+- **`USER_REVIEWED` promotion has a library entry point but no CLI command**
+  (`promotion.promote_user_reviewed()` works today; there's no
+  `parseforge promotion --mode user-reviewed` yet). Deferred until real
+  human-reviewed cases exist to show what a CLI/config shape for a list of
+  case/suffix/gate requests should actually look like, rather than guessing
+  ahead of need.
+- **Batch sampling mode** (collect several samples per command before
+  generating, SPEC.md §4) is designed but not built — the simpler
+  per-command loop mode is the only one implemented.
+- **One sampling connector** (Netmiko/SSH). The CLI's `--connector` registry
+  is built to hold more without a redesign, but nothing else is wired in yet.
+
+## Installation
+
+```bash
+# minimal install, no AI-provider SDK
+pip install parseforge
+
+# with a provider extra, e.g. anthropic
+pip install parseforge[anthropic]
+
+# local development
+pip install -e ".[dev,sampling]"
+```
+
+For the full extras list (all eighteen providers, `sampling`, combining
+extras, per-provider `requirements/` files, and the dev/test/release
+setup), see
+[Installation](https://geeks-trident-llc.github.io/parseforge/getting-started/installation/).
+
+## Reference
+
+- [Documentation site](https://geeks-trident-llc.github.io/parseforge/) ([source](./docs/index.md))
+- [Quickstart](https://geeks-trident-llc.github.io/parseforge/getting-started/quickstart/) — a full walkthrough, from a single lookup to the end-to-end workflow
+- [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/) — every provider's extra, auth requirements, and default model
+- [CLI Guide](https://geeks-trident-llc.github.io/parseforge/guides/cli/) — every command, in full
+- [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/) — calling parseforge from Python instead of the CLI
+- [API Reference](https://geeks-trident-llc.github.io/parseforge/reference/api/) — every public function/class, by pipeline stage
+- [Changelog](https://geeks-trident-llc.github.io/parseforge/changelog/) — what shipped in each release
+- [SPEC.md](SPEC.md) — full design plan and open questions

parseforge-0.3.1/README.md

@@ -0,0 +1,95 @@
+# ParseForge
+
+LLM-driven pipeline that forges, cross-validates, and promotes [TextFSM](https://github.com/google/textfsm)
+templates from network device CLI output.
+
+Full design plan: [SPEC.md](SPEC.md).
+
+## Features
+
+- **Trial → integration → promotion: a Human-in-the-Loop review workflow,
+  not a one-shot generator.** Every LLM-generated template starts as
+  unreviewed evidence in `trials/`. `integration` clusters every trial for
+  a command by the *output schema* its parsed records actually have, not
+  exact template text — a command's output can legitimately vary by
+  hardware/firmware, so distinct schemas become separate, independently
+  tracked groups instead of one hand-picked "winner." `promotion` then
+  auto-promotes any group whose match rate against every known sample
+  clears a configurable gate straight into `authoritative/`; anything
+  short of that gate is queued for human review instead of silently
+  shipped. A human-reviewed promotion is recorded as a named snapshot
+  alongside whatever's currently live, never silently overwriting it —
+  so review effort goes only where the evidence is actually ambiguous.
+- **Eighteen LLM providers, one interface.** Anthropic, OpenAI, DeepSeek,
+  Groq, xAI, Together, Fireworks, Perplexity, OpenRouter, Moonshot,
+  Cerebras, Mistral, Cohere, Azure OpenAI, Gemini, Vertex AI, Amazon
+  Bedrock, and Oracle Cloud (OCI) — including four with non-standard auth
+  (deployment names, GCP Application Default Credentials, AWS's
+  credential chain, OCI request-signing) handled transparently. Naming
+  and generation can use two different providers in the same trial. See
+  [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/).
+- **Self-caching cli-name resolution.** A raw CLI command
+  (`show interface GE1.1 status`) only ever costs LLM tokens once — it's
+  resolved to a canonical, indexed name
+  (`show-interface-var1-status`) and cached locally; every later trial for
+  that command is a free lookup.
+- **Self-validation, not just "the LLM said so."** Every generated
+  template is immediately run against its own sample before being
+  recorded as passed — a template that doesn't actually parse the output
+  it was generated from never gets a chance to look good on paper.
+- **Drift monitoring.** An authoritative template is periodically checked
+  against new production samples; a failing sample feeds back into the
+  pipeline as a new trial automatically, closing the loop instead of just
+  logging an alert.
+- **CLI and Python API, same underlying calls.** Everything the CLI does
+  — `run`, `trial`, `integration`, `promotion` — is one function call in
+  Python too. See the
+  [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/).
+
+## Status
+
+Early beta. The full pipeline is implemented and tested end to end — naming,
+sampling, generation, self-validation, integration (output-schema group/variant
+clustering), promotion (auto and human-reviewed), and drift monitoring — and
+wired into the CLI. A few things are intentionally not there yet:
+
+- **`USER_REVIEWED` promotion has a library entry point but no CLI command**
+  (`promotion.promote_user_reviewed()` works today; there's no
+  `parseforge promotion --mode user-reviewed` yet). Deferred until real
+  human-reviewed cases exist to show what a CLI/config shape for a list of
+  case/suffix/gate requests should actually look like, rather than guessing
+  ahead of need.
+- **Batch sampling mode** (collect several samples per command before
+  generating, SPEC.md §4) is designed but not built — the simpler
+  per-command loop mode is the only one implemented.
+- **One sampling connector** (Netmiko/SSH). The CLI's `--connector` registry
+  is built to hold more without a redesign, but nothing else is wired in yet.
+
+## Installation
+
+```bash
+# minimal install, no AI-provider SDK
+pip install parseforge
+
+# with a provider extra, e.g. anthropic
+pip install parseforge[anthropic]
+
+# local development
+pip install -e ".[dev,sampling]"
+```
+
+For the full extras list (all eighteen providers, `sampling`, combining
+extras, per-provider `requirements/` files, and the dev/test/release
+setup), see
+[Installation](https://geeks-trident-llc.github.io/parseforge/getting-started/installation/).
+
+## Reference
+
+- [Documentation site](https://geeks-trident-llc.github.io/parseforge/) ([source](./docs/index.md))
+- [Quickstart](https://geeks-trident-llc.github.io/parseforge/getting-started/quickstart/) — a full walkthrough, from a single lookup to the end-to-end workflow
+- [Providers](https://geeks-trident-llc.github.io/parseforge/guides/providers/) — every provider's extra, auth requirements, and default model
+- [CLI Guide](https://geeks-trident-llc.github.io/parseforge/guides/cli/) — every command, in full
+- [Python API guide](https://geeks-trident-llc.github.io/parseforge/guides/python-api/) — calling parseforge from Python instead of the CLI
+- [API Reference](https://geeks-trident-llc.github.io/parseforge/reference/api/) — every public function/class, by pipeline stage
+- [Changelog](https://geeks-trident-llc.github.io/parseforge/changelog/) — what shipped in each release
+- [SPEC.md](SPEC.md) — full design plan and open questions

{parseforge-0.2.12 → parseforge-0.3.1}/SPEC.md

@@ -79,7 +79,7 @@ Keep the timestamp+shortid directories (not `result1..N`) — chronological orde
 | `derive/template.textfsm` | Cleaned, DSL-compiled TextFSM template candidate (`.textfsm` extension — recognized by TextFSM tooling/linters, unlike `textfsm.template`) |
 | `derive/readable-dsl.txt` | Human-readable description of what the template captures |
 | `derive/recognizers.txt` | Heuristics/signatures for detecting this output type at runtime |
-| `summary.json` | Everything else about the run: `created_at`/`ended_at`/`duration_ms`, `passed`, `error` (when `passed` is false), `metadata` (project/username/email/description), `command_info` (vendor/family/os/version/device_type/command), `usage` (naming + generation token counts/cost), and `provider_info` (the generation provider/model) |
+| `summary.json` | Everything else about the run: `created_at`/`ended_at`/`duration_ms`, `passed`, `error` (when `passed` is false), `metadata` (project/username/email/description), `command_info` (vendor/family/os/version/device_type/command), `usage` (naming + generation token counts), and `provider_info` (the generation provider/model) |
 
 ### 3.2 `integration/` (no human review yet)
 
@@ -180,4 +180,4 @@ Where a fourth tier is tempting but better handled as **metadata instead of a ne
 - Do you want a **registry/index file** (e.g. `catalog.json`) at the repo root listing every `<vendor>/<family>/<os>/<cli-name>` combination that exists, plus its authoritative status, for fast lookup without walking the filesystem?
 - What **confidence threshold** (match-rate %, sample count minimum) should gate auto-promotion vs. human review in step 9 — worth making this configurable per-project rather than hardcoded?
 - Should `recognizers.txt` support **one-of-many matching** from day one (per the multi-variant note in §6), or is that a v2 concern?
-- What's the **LLM provider/model** for generation — worth pinning per-project so `summary.json`'s usage costs are comparable across runs?
+- What's the **LLM provider/model** for generation — worth pinning per-project so `summary.json`'s token usage is comparable across runs?

parseforge-0.3.1/parseforge/__init__.py

@@ -0,0 +1,96 @@
+__version__ = "0.3.1"
+version = __version__
+
+from .api import (  # noqa: E402
+    DEFAULT_STORE_ROOT,
+    CliContext,
+    DeviceConnection,
+    DeviceKey,
+    DriftCheckResult,
+    DriftGate,
+    GenerationResult,
+    GenerationTokenUsage,
+    GroupEvaluation,
+    LLMCLIResponse,
+    LLMProviderConfig,
+    Mode,
+    NamingResolution,
+    NamingTokenUsage,
+    ParseResult,
+    PromotionDecision,
+    PromotionGate,
+    PromotionMetadata,
+    PromotionMode,
+    PromotionRunResult,
+    Reference,
+    ReferenceGroup,
+    ReferenceVariant,
+    RegexBuilder,
+    Sampler,
+    TrialMetadata,
+    TrialResult,
+    UserReviewedRequest,
+    build_integration,
+    build_reference_summary,
+    check_drift,
+    cli_name,
+    decide_promotion,
+    discover_device_keys,
+    evaluate_cases,
+    generate,
+    parse,
+    promote_auto,
+    promote_user_reviewed,
+    resolve_cli_name,
+    run_command_pipeline,
+    sample,
+    write_reference_summary,
+)
+
+__all__ = [
+    "version",
+    "__version__",
+    "cli_name",
+    "resolve_cli_name",
+    "NamingResolution",
+    "CliContext",
+    "RegexBuilder",
+    "LLMCLIResponse",
+    "NamingTokenUsage",
+    "sample",
+    "DeviceConnection",
+    "Sampler",
+    "generate",
+    "GenerationResult",
+    "GenerationTokenUsage",
+    "parse",
+    "ParseResult",
+    "run_command_pipeline",
+    "LLMProviderConfig",
+    "TrialMetadata",
+    "TrialResult",
+    "Mode",
+    "build_integration",
+    "build_reference_summary",
+    "write_reference_summary",
+    "Reference",
+    "ReferenceGroup",
+    "ReferenceVariant",
+    "promote_auto",
+    "promote_user_reviewed",
+    "decide_promotion",
+    "evaluate_cases",
+    "PromotionGate",
+    "PromotionMetadata",
+    "UserReviewedRequest",
+    "GroupEvaluation",
+    "PromotionRunResult",
+    "PromotionDecision",
+    "PromotionMode",
+    "check_drift",
+    "DriftGate",
+    "DriftCheckResult",
+    "DEFAULT_STORE_ROOT",
+    "DeviceKey",
+    "discover_device_keys",
+]

parseforge-0.3.1/parseforge/api.py

@@ -0,0 +1,127 @@
+"""Public Python API — the single place to import parseforge's stable,
+supported surface from. Mirrors textfsm-ai's own api.py convention
+(https://github.com/Geeks-Trident-LLC/textfsm-ai): one entry point per
+pipeline stage (SPEC.md §5), plus the types each one returns or accepts.
+
+Provider-specific naming builders (``AnthropicRegexBuilder``,
+``OCIRegexBuilder``, ...) aren't re-exported here — they're already a
+clean, documented import path via :mod:`parseforge.naming` directly, and
+listing all eighteen here would bloat this module without adding
+anything. Anything not listed in ``__all__`` (module-internal helpers,
+provider implementation details, CLI plumbing) isn't part of the public
+API and may change without notice.
+
+``naming``'s and ``generation``'s ``TokenUsage`` classes are separate
+types that happen to share a name (naming makes one call per cache
+miss; generation's is already accumulated across every LLM call in its
+own pipeline, see ``GenerationResult.usage``) — aliased here as
+``NamingTokenUsage``/``GenerationTokenUsage`` to avoid the collision,
+the same convention this package's own test suite already uses.
+"""
+
+from __future__ import annotations
+
+from .drift import DriftCheckResult, DriftGate, check_drift
+from .generation import GenerationResult, generate
+from .generation import TokenUsage as GenerationTokenUsage
+from .integration import (
+    Reference,
+    ReferenceGroup,
+    ReferenceVariant,
+    build_integration,
+    build_reference_summary,
+    write_reference_summary,
+)
+from .naming import (
+    CliContext,
+    LLMCLIResponse,
+    NamingResolution,
+    RegexBuilder,
+    cli_name,
+    resolve_cli_name,
+)
+from .naming import TokenUsage as NamingTokenUsage
+from .paths import DEFAULT_STORE_ROOT, DeviceKey, discover_device_keys
+from .pipeline import (
+    LLMProviderConfig,
+    Mode,
+    TrialMetadata,
+    TrialResult,
+    run_command_pipeline,
+)
+from .promotion import (
+    GroupEvaluation,
+    PromotionDecision,
+    PromotionGate,
+    PromotionMetadata,
+    PromotionMode,
+    PromotionRunResult,
+    UserReviewedRequest,
+    decide_promotion,
+    evaluate_cases,
+    promote_auto,
+    promote_user_reviewed,
+)
+from .sampling import DeviceConnection, Sampler, sample
+from .validation import ParseResult, parse
+
+__all__ = [
+    # Naming (SPEC.md §2) — resolve a raw CLI command to its canonical
+    # cli-name, cached after the first LLM call.
+    "cli_name",
+    "resolve_cli_name",
+    "NamingResolution",
+    "CliContext",
+    "RegexBuilder",
+    "LLMCLIResponse",
+    "NamingTokenUsage",
+    # Sampling (SPEC.md §3) — capture raw command output from a device.
+    "sample",
+    "DeviceConnection",
+    "Sampler",
+    # Generation (SPEC.md §5 steps 5-6) — sample -> candidate TextFSM
+    # template, via textfsm-ai's delivery pipeline.
+    "generate",
+    "GenerationResult",
+    "GenerationTokenUsage",
+    # Validation (SPEC.md §5 step 7) — self-validate a template against
+    # its own sample.
+    "parse",
+    "ParseResult",
+    # Pipeline orchestration (SPEC.md §5) — one call runs steps 1-7
+    # (naming -> sampling -> generation -> validation) for a single trial.
+    "run_command_pipeline",
+    "LLMProviderConfig",
+    "TrialMetadata",
+    "TrialResult",
+    "Mode",
+    # Integration (SPEC.md §5 step 8) — cluster trials by output schema.
+    "build_integration",
+    "build_reference_summary",
+    "write_reference_summary",
+    "Reference",
+    "ReferenceGroup",
+    "ReferenceVariant",
+    # Promotion (SPEC.md §5 step 9) — auto-promote groups that clear
+    # their gate; queue everything else for human review.
+    "promote_auto",
+    "promote_user_reviewed",
+    "decide_promotion",
+    "evaluate_cases",
+    "PromotionGate",
+    "PromotionMetadata",
+    "UserReviewedRequest",
+    "GroupEvaluation",
+    "PromotionRunResult",
+    "PromotionDecision",
+    "PromotionMode",
+    # Drift monitoring (SPEC.md §5 step 11) — check an authoritative
+    # template against new production samples.
+    "check_drift",
+    "DriftGate",
+    "DriftCheckResult",
+    # Store-root layout helpers.
+    "DEFAULT_STORE_ROOT",
+    "DeviceKey",
+    "discover_device_keys",
+]

{parseforge-0.2.12 → parseforge-0.3.1}/parseforge/cli/main.py

@@ -659,6 +659,7 @@ def run_cmd(
     click.echo(f"cli_name : {result.cli_name}")
     click.echo(f"passed   : {result.passed}")
     click.echo(f"run_dir  : {result.run_dir}")
+    click.echo(f"usage    : {result.total_usage}")
 
 
 def _check_connector(
@@ -1200,7 +1201,7 @@ def trial_cmd(config_path: str, store_root_opt: str | None) -> None:
     for command, result in zip(cfg.commands, results):
         click.echo(
             f"{command} -> cli_name={result.cli_name} passed={result.passed} "
-            f"run_dir={result.run_dir}"
+            f"run_dir={result.run_dir} usage={result.total_usage}"
         )
         passed_count += int(result.passed)
     click.echo(f"{passed_count}/{len(results)} passed")

{parseforge-0.2.12 → parseforge-0.3.1}/parseforge/generation.py

@@ -44,7 +44,6 @@ class TokenUsage:
     input_tokens: int
     output_tokens: int
     total_tokens: int
-    estimated_cost: float
 
 
 @dataclass(frozen=True)
@@ -95,7 +94,6 @@ def generate(
         input_tokens=usage_data.get("input_tokens", 0),
         output_tokens=usage_data.get("output_tokens", 0),
         total_tokens=usage_data.get("total_tokens", 0),
-        estimated_cost=usage_data.get("estimated_cost", 0.0),
     )
 
     gen_stage = (debug.get("generation_pipeline") or {}).get("last_stage") or {}

{parseforge-0.2.12 → parseforge-0.3.1}/parseforge/naming/llm.py

@@ -37,7 +37,6 @@ class TokenUsage:
     input_tokens: int
     output_tokens: int
     total_tokens: int
-    estimated_cost: float
 
 
 @dataclass(frozen=True)

{parseforge-0.2.12 → parseforge-0.3.1}/parseforge/naming/providers/anthropic.py

@@ -6,7 +6,6 @@ import time
 from typing import TYPE_CHECKING, Any
 
 from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
-from .cost import estimate_cost
 from .errors import format_llm_error_reason, is_retryable
 from .models import default_model
 from .text import extract_pattern
@@ -89,9 +88,7 @@ class AnthropicRegexBuilder:
             return LLMCLIResponse(
                 content="",
                 raw=exc,
-                usage=TokenUsage(
-                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
-                ),
+                usage=TokenUsage(input_tokens=0, output_tokens=0, total_tokens=0),
                 duration_ms=(time.monotonic() - start) * 1000,
                 reason=format_llm_error_reason(exc),
                 ready=False,
@@ -111,13 +108,6 @@ class AnthropicRegexBuilder:
                 input_tokens=response.usage.input_tokens,
                 output_tokens=response.usage.output_tokens,
                 total_tokens=total_tokens,
-                estimated_cost=estimate_cost(
-                    input_tokens=response.usage.input_tokens,
-                    output_tokens=response.usage.output_tokens,
-                    total_tokens=total_tokens,
-                    provider=self.provider,
-                    model=self.model,
-                ),
             ),
             duration_ms=duration_ms,
             reason=response.stop_reason or "",

{parseforge-0.2.12 → parseforge-0.3.1}/parseforge/naming/providers/azure.py

@@ -17,7 +17,6 @@ import time
 from typing import TYPE_CHECKING, Any
 
 from ..llm import CliContext, LLMCLIResponse, TokenUsage, build_prompt
-from .cost import estimate_cost
 from .text import extract_pattern
 
 if TYPE_CHECKING:
@@ -161,9 +160,7 @@ class AzureRegexBuilder:
             return LLMCLIResponse(
                 content="",
                 raw=exc,
-                usage=TokenUsage(
-                    input_tokens=0, output_tokens=0, total_tokens=0, estimated_cost=0.0
-                ),
+                usage=TokenUsage(input_tokens=0, output_tokens=0, total_tokens=0),
                 duration_ms=(time.monotonic() - start) * 1000,
                 reason=_format_error_reason(exc),
                 ready=False,
@@ -178,18 +175,6 @@ class AzureRegexBuilder:
                 input_tokens=response.usage.prompt_tokens,
                 output_tokens=response.usage.completion_tokens,
                 total_tokens=response.usage.total_tokens,
-                estimated_cost=estimate_cost(
-                    input_tokens=response.usage.prompt_tokens,
-                    output_tokens=response.usage.completion_tokens,
-                    total_tokens=response.usage.total_tokens,
-                    provider=self.provider,
-                    # No public pricing table for a customer's own Azure
-                    # deployment — estimate_cost() falls back to 0.0 with
-                    # a warning for an unrecognized (provider, model) pair,
-                    # which is the correct/expected outcome here, not an
-                    # error condition.
-                    model=self._resolved_deployment or "",
-                ),
             ),
             duration_ms=duration_ms,
             reason=choice.finish_reason or "",