parseforge 0.2.1__py3-none-any.whl

parseforge/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

parseforge/cli/main.py

@@ -0,0 +1,55 @@
+"""parseforge CLI entry point."""
+
+from __future__ import annotations
+
+import click
+
+from parseforge import naming
+
+
+@click.group()
+@click.version_option(package_name="parseforge")
+def main() -> None:
+    """ParseForge — forge, validate, and promote TextFSM templates from CLI output."""
+
+
+@main.command("name")
+@click.option("--vendor", required=True)
+@click.option("--family", required=True)
+@click.option("--os", "os_", required=True)
+@click.option("--version", required=True)
+@click.argument("command", nargs=-1, required=True)
+def name_cmd(
+    vendor: str, family: str, os_: str, version: str, command: tuple[str, ...]
+) -> None:
+    """Print the canonical cli-name for a raw CLI COMMAND.
+
+    Looked up in the local cache first; only sent to an LLM (via a
+    RegexBuilder) on a cache miss. No RegexBuilder is wired into the
+    scaffold yet, so this only succeeds for commands already in
+    ~/.parseforge/.cli-name.json until one is implemented.
+    """
+    context = naming.CliContext(vendor=vendor, family=family, os=os_, version=version)
+    click.echo(naming.cli_name(" ".join(command), context))
+
+
+@main.command("run")
+@click.option("--vendor", required=True)
+@click.option("--family", required=True)
+@click.option("--os", "os_", required=True)
+@click.option("--version", required=True)
+@click.argument("command", nargs=-1, required=True)
+def run_cmd(
+    vendor: str, family: str, os_: str, version: str, command: tuple[str, ...]
+) -> None:
+    """Run the pipeline for a single CLI COMMAND against a device (§5)."""
+    from parseforge.pipeline import run_command_pipeline
+
+    run_command_pipeline(
+        " ".join(command),
+        key_fields={"vendor": vendor, "family": family, "os": os_, "version": version},
+    )
+
+
+if __name__ == "__main__":
+    main()

parseforge/generation.py

@@ -0,0 +1,40 @@
+"""Generation stage — LLM call and template extraction (SPEC.md §5 steps 5-6).
+
+Writes raw-llm-response.txt / usage.txt (step 5), then extracts and
+cleans the template into raw-template / template.textfsm (step 6).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class GenerationResult:
+    raw_response: str
+    usage: str
+    raw_template: str
+    template: str
+
+
+class Generator(Protocol):
+    """An LLM backend capable of producing a TextFSM template from sample input.
+
+    ``prior_context`` carries additional samples of the same command when
+    running in Mode 1 (batch) per §4.
+    """
+
+    def generate(
+        self, input_text: str, prior_context: list[str] | None = None
+    ) -> GenerationResult: ...
+
+
+def extract_template(raw_response: str) -> str:
+    """Pull the template body out of a raw LLM response (step 6, pre-cleanup)."""
+    raise NotImplementedError("extraction rule TBD — see SPEC.md §5 step 6")
+
+
+def clean_template(raw_template: str) -> str:
+    """Normalize an extracted template into a valid template.textfsm body."""
+    raise NotImplementedError("cleanup rule TBD — see SPEC.md §5 step 6")

parseforge/naming/__init__.py

@@ -0,0 +1,15 @@
+from .assemble import pattern_to_cli_name
+from .cache import DEFAULT_INDEX_PATH, NameIndex
+from .llm import CliContext, RegexBuilder, UnimplementedRegexBuilder, build_prompt
+from .resolver import cli_name
+
+__all__ = [
+    "cli_name",
+    "CliContext",
+    "RegexBuilder",
+    "UnimplementedRegexBuilder",
+    "build_prompt",
+    "NameIndex",
+    "DEFAULT_INDEX_PATH",
+    "pattern_to_cli_name",
+]

parseforge/naming/assemble.py

@@ -0,0 +1,35 @@
+"""Turn a validated regex pattern into a canonical, kebab-case cli-name.
+
+Fixed-text segments pass through as-is; named capture groups
+(``(?P<var1>...)``) become their group name. Tokens are joined with
+``-`` and lowercased, matching SPEC.md §2's naming convention.
+"""
+
+from __future__ import annotations
+
+import re
+
+_LEADING_FLAGS = re.compile(r"^\(\?[a-zA-Z]+\)")
+_NAMED_GROUP = re.compile(r"^\(\?P<(?P<name>\w+)>.*\)$")
+_ESCAPED_CHAR = re.compile(r"\\(.)")
+
+
+def pattern_to_cli_name(pattern: str) -> str:
+    """
+    >>> pattern_to_cli_name(r"(?i)show\\s+version")
+    'show-version'
+    >>> pattern_to_cli_name(r"(?i)show\\s+interface\\s+(?P<var1>\\S+)\\s+status")
+    'show-interface-var1-status'
+    """
+    body = _LEADING_FLAGS.sub("", pattern)
+    tokens = [t for t in re.split(r"\\s\+", body) if t.strip()]
+
+    parts: list[str] = []
+    for token in tokens:
+        token = token.strip()
+        group = _NAMED_GROUP.match(token)
+        if group:
+            parts.append(group.group("name"))
+        else:
+            parts.append(_ESCAPED_CHAR.sub(r"\1", token))
+    return "-".join(parts).lower()

parseforge/naming/cache.py

@@ -0,0 +1,48 @@
+"""On-disk cli-name -> regex index, so a CLI is only ever sent to the LLM once.
+
+Persisted as a flat JSON dict (SPEC.md naming discussion):
+    {"show-version": "(?i)show\\s+version", ...}
+
+The cli-name segment is vendor/OS-agnostic by design — vendor, family, os,
+and version are already distinguishing directory levels in the storage
+layout (SPEC.md §3), so a single global index is intentional rather than
+one index per device context.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+DEFAULT_INDEX_PATH = Path.home() / ".parseforge" / ".cli-name.json"
+
+
+class NameIndex:
+    """Loads, queries, and persists the cli-name -> regex mapping."""
+
+    def __init__(self, path: Path = DEFAULT_INDEX_PATH) -> None:
+        self.path = path
+        self._entries: dict[str, str] = self._load()
+
+    def _load(self) -> dict[str, str]:
+        if not self.path.exists():
+            return {}
+        return json.loads(self.path.read_text(encoding="utf-8"))
+
+    def match(self, command: str) -> str | None:
+        """Return the cli-name of the first stored pattern that fully matches
+        ``command``, or None if this command hasn't been named before."""
+        for cli_name, pattern in self._entries.items():
+            if re.fullmatch(pattern, command):
+                return cli_name
+        return None
+
+    def add(self, cli_name: str, pattern: str) -> None:
+        self._entries[cli_name] = pattern
+
+    def save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(
+            json.dumps(self._entries, indent=2, sort_keys=True), encoding="utf-8"
+        )

parseforge/naming/llm.py

@@ -0,0 +1,62 @@
+"""LLM-driven regex construction for a CLI command.
+
+Only called on a cache miss (see resolver.py) — once a command's pattern
+is in the index, matching is pure regex and costs no tokens.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+PROMPT_TEMPLATE = """\
+This is CLI "{command}" of {vendor} {family} {os} version {version}.
+Create a regex pattern to match it:
+- If a token is fixed text, use it as-is.
+- If a token is variable text, use a regex to match it, and name the \
+capture group var1, var2, ... in left-to-right order of appearance.
+- Use \\s+ to match whitespace between tokens.
+
+Example 1: "show version" -> "show" and "version" are fixed text ->
+r"(?i)show\\s+version"
+
+Example 2: "show interface Ge1.1 status" -> "show", "interface", and \
+"status" are fixed text ->
+r"(?i)show\\s+interface\\s+(?P<var1>\\S+)\\s+status"
+
+Respond with only the regex pattern, nothing else.
+"""
+
+
+@dataclass(frozen=True)
+class CliContext:
+    vendor: str
+    family: str
+    os: str
+    version: str
+
+
+def build_prompt(command: str, context: CliContext) -> str:
+    return PROMPT_TEMPLATE.format(
+        command=command,
+        vendor=context.vendor,
+        family=context.family,
+        os=context.os,
+        version=context.version,
+    )
+
+
+class RegexBuilder(Protocol):
+    """An LLM backend that turns a raw CLI command into a regex pattern."""
+
+    def build_pattern(self, command: str, context: CliContext) -> str: ...
+
+
+class UnimplementedRegexBuilder:
+    """Default RegexBuilder — no LLM client is wired into the scaffold yet."""
+
+    def build_pattern(self, command: str, context: CliContext) -> str:
+        raise NotImplementedError(
+            "no RegexBuilder configured — wire an LLM client that sends "
+            "build_prompt(command, context) and returns the regex pattern"
+        )

parseforge/naming/resolver.py

@@ -0,0 +1,45 @@
+"""Resolve a raw CLI command to its canonical cli-name, LLM-backed with caching.
+
+Flow:
+1. Check the on-disk index (:mod:`parseforge.naming.cache`) for a stored
+   pattern that already matches this command — no LLM call on a hit.
+2. On a miss, ask the LLM to build a regex for it
+   (:mod:`parseforge.naming.llm`).
+3. Validate the LLM's pattern actually matches its own source command via
+   ``re.fullmatch`` before trusting it.
+4. Assemble the cli-name from the pattern (:mod:`parseforge.naming.assemble`)
+   and persist the new cli-name -> pattern entry to the index.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .assemble import pattern_to_cli_name
+from .cache import DEFAULT_INDEX_PATH, NameIndex
+from .llm import CliContext, RegexBuilder, UnimplementedRegexBuilder
+
+
+def cli_name(
+    command: str,
+    context: CliContext,
+    builder: RegexBuilder = UnimplementedRegexBuilder(),
+    index_path: Path = DEFAULT_INDEX_PATH,
+) -> str:
+    index = NameIndex(index_path)
+
+    cached = index.match(command)
+    if cached is not None:
+        return cached
+
+    pattern = builder.build_pattern(command, context)
+    if not re.fullmatch(pattern, command):
+        raise ValueError(
+            f"LLM-built pattern {pattern!r} does not match its own command {command!r}"
+        )
+
+    name = pattern_to_cli_name(pattern)
+    index.add(name, pattern)
+    index.save()
+    return name

parseforge/paths.py

@@ -0,0 +1,68 @@
+"""Storage layout — three-tier promotion path resolution (SPEC.md §3).
+
+Shared path prefix under all three tiers:
+    <vendor>/<device-family>/<os>/<version>/<cli-name>/
+
+Use hyphenated OS family names (``ios-xe``, ``nx-os``) once multiple
+Cisco OS families share the tree, per §3's note.
+"""
+
+from __future__ import annotations
+
+import random
+import string
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+
+TRIALS = "trials"
+INTEGRATION = "integration"
+AUTHORITATIVE = "authoritative"
+
+
+@dataclass(frozen=True)
+class DeviceKey:
+    """Identifies a template family: vendor/device-family/os/version/cli-name."""
+
+    vendor: str
+    family: str
+    os: str
+    version: str
+    cli_name: str
+
+    def relative_path(self) -> Path:
+        return Path(self.vendor, self.family, self.os, self.version, self.cli_name)
+
+
+def tier_root(store_root: Path, tier: str) -> Path:
+    if tier not in (TRIALS, INTEGRATION, AUTHORITATIVE):
+        raise ValueError(f"unknown tier: {tier!r}")
+    return store_root / tier
+
+
+def tier_path(store_root: Path, tier: str, key: DeviceKey) -> Path:
+    """Resolve the directory for ``key`` under the given tier."""
+    return tier_root(store_root, tier) / key.relative_path()
+
+
+def new_run_id() -> str:
+    """Timestamp+shortid run identifier (§3.1) — chronological, collision-safe."""
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    shortid = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+    return f"{timestamp}-{shortid}"
+
+
+def trial_run_dir(store_root: Path, key: DeviceKey, run_id: str | None = None) -> Path:
+    """Directory for a single trial run: trials/.../<cli-name>/<run-id>/."""
+    run_id = run_id or new_run_id()
+    return tier_path(store_root, TRIALS, key) / run_id
+
+
+def integration_result_dir(store_root: Path, key: DeviceKey) -> Path:
+    """The single common-result candidate directory for a cli-name (§3.2)."""
+    return tier_path(store_root, INTEGRATION, key) / "common-result"
+
+
+def authoritative_dir(store_root: Path, key: DeviceKey) -> Path:
+    """The approved, in-production directory for a cli-name (§3.3)."""
+    return tier_path(store_root, AUTHORITATIVE, key)

parseforge/pipeline.py

@@ -0,0 +1,49 @@
+"""Pipeline orchestration (SPEC.md §4, §5).
+
+Mode 2 (loop: sample -> generate, per command) is the MVP per §4's
+recommendation. Mode 1 (batch: gather-then-generate) is a config flag
+that only changes the sampling stage — generation, storage, and
+validation stay identical between modes.
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from parseforge import naming, paths
+
+
+class Mode(str, Enum):
+    LOOP = "loop"  # MVP: sample -> generate, per command (§4)
+    BATCH = "batch"  # collect N samples per command before generation (§4)
+
+
+def run_command_pipeline(
+    command: str,
+    key_fields: dict,
+    regex_builder: naming.RegexBuilder = naming.UnimplementedRegexBuilder(),
+    mode: Mode = Mode.LOOP,
+) -> None:
+    """Execute steps 1-7 of the pipeline for a single CLI command.
+
+    1. Input intake is the caller's responsibility (device info, auth,
+       command list, mode selection already resolved into ``key_fields``,
+       which must supply vendor/family/os/version).
+    2. Name generation — :func:`parseforge.naming.cli_name` (LLM-backed,
+       cached — see :mod:`parseforge.naming`).
+    3. Path resolution — :mod:`parseforge.paths`.
+    4. Sampling — :mod:`parseforge.sampling`.
+    5-6. Generation — :mod:`parseforge.generation`.
+    7. Self-validation — :mod:`parseforge.validation`.
+
+    Steps 8-11 (integration selection, authoritative promotion, drift
+    monitoring, repeat/loop) run out-of-band across all trials for a
+    cli-name, not per single pipeline invocation — see
+    :mod:`parseforge.validation` and :mod:`parseforge.promotion`.
+    """
+    context = naming.CliContext(**key_fields)
+    name = naming.cli_name(command, context, builder=regex_builder)
+    key = paths.DeviceKey(cli_name=name, **key_fields)
+    raise NotImplementedError(
+        f"wire sampling -> generation -> validation for {key!r} (mode={mode.value})"
+    )

parseforge/promotion.py

@@ -0,0 +1,43 @@
+"""Authoritative promotion and drift monitoring (SPEC.md §3.3, §5 steps 9-10)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class PromotionDecision(str, Enum):
+    AUTO_PROMOTED = "auto_promoted"
+    QUEUED_FOR_REVIEW = "queued_for_review"
+
+
+@dataclass(frozen=True)
+class PromotionGate:
+    """Confidence threshold gating auto-promotion vs. human review (§3.3, §7).
+
+    Left configurable per-project rather than hardcoded — see the open
+    question in SPEC.md §7.
+    """
+
+    match_rate_threshold: float = 1.0
+    min_sample_count: int = 1
+
+
+def decide_promotion(
+    match_rate: float, sample_count: int, gate: PromotionGate
+) -> PromotionDecision:
+    if (
+        sample_count >= gate.min_sample_count
+        and match_rate >= gate.match_rate_threshold
+    ):
+        return PromotionDecision.AUTO_PROMOTED
+    return PromotionDecision.QUEUED_FOR_REVIEW
+
+
+@dataclass(frozen=True)
+class DriftStatus:
+    match_rate: float
+    status: str  # "ok" | "drifting" | "superseded" — see SPEC.md §6
+
+    def breached(self, threshold: float) -> bool:
+        return self.match_rate < threshold

parseforge/sampling.py

@@ -0,0 +1,36 @@
+"""Sampling stage — connect to a device and capture raw CLI output (SPEC.md §5 step 4).
+
+Kept as a separable stage so that Mode 1 (batch: collect N samples per
+command before generation) and Mode 2 (loop: sample-then-generate per
+command) share the same generation/storage/validation stages and differ
+only in how many samples this stage collects before handing off — see
+§4.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class DeviceConnection:
+    host: str
+    username: str
+    password: str
+    device_type: str  # e.g. "cisco_ios", "cisco_nxos"
+
+
+class Sampler(Protocol):
+    """A backend capable of running a command on a device and returning raw text.
+
+    A Netmiko-backed implementation is the expected default; see the
+    optional ``sampling`` extra in pyproject.toml.
+    """
+
+    def run_command(self, connection: DeviceConnection, command: str) -> str: ...
+
+
+def sample(sampler: Sampler, connection: DeviceConnection, command: str) -> str:
+    """Run ``command`` against ``connection`` and return raw output for input.txt."""
+    return sampler.run_command(connection, command)

parseforge/validation.py

@@ -0,0 +1,50 @@
+"""Validation — self-validation (SPEC.md §5 step 7) and cross-validation
+for integration selection (§3.2, §5 step 8).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ParseResult:
+    records: list[dict]
+    errors: list[str]
+
+    @property
+    def passed(self) -> bool:
+        return not self.errors
+
+
+def parse(template_text: str, input_text: str) -> ParseResult:
+    """Run a template.textfsm against an input.txt sample.
+
+    Used both for self-validation (a template against its own sample,
+    step 7) and cross-validation (every candidate against every known
+    sample for a cli-name, step 8).
+    """
+    raise NotImplementedError("wrap textfsm.TextFSM — see SPEC.md §5 steps 7-8")
+
+
+@dataclass(frozen=True)
+class CandidateScore:
+    run_id: str
+    match_rate: float
+    failed_samples: list[str]
+
+
+def select_common_result(
+    candidates: dict[str, str], samples: dict[str, str]
+) -> CandidateScore:
+    """Cross-validate every candidate template against every known sample.
+
+    ``candidates`` maps trial run_id -> template.textfsm text.
+    ``samples`` maps sample id -> input.txt text.
+
+    Promotes whichever template parses the largest share of *all* known
+    samples correctly (not just the sample it was generated from) — an
+    overfit template that only matches its own source sample must lose
+    to a template that generalizes, per §3.2.
+    """
+    raise NotImplementedError("scoring/selection rule — see SPEC.md §3.2")

parseforge-0.2.1.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: parseforge
+Version: 0.2.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
+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"
+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).
+
+## Layout
+
+```
+parseforge/
+  naming.py       CLI command -> canonical cli-name (SPEC §2)
+  paths.py        trials/integration/authoritative path resolution (SPEC §3)
+  sampling.py     device connection + command capture (SPEC §5 step 4)
+  generation.py   LLM call + template extraction (SPEC §5 steps 5-6)
+  validation.py   self-validation + cross-validation scoring (SPEC §5 steps 7-8)
+  promotion.py    authoritative promotion gate + drift status (SPEC §3.3, §5 steps 9-10)
+  pipeline.py     orchestrates the above; Mode LOOP (MVP) vs Mode BATCH (SPEC §4)
+  cli/            `parseforge` command-line entry point
+
+store/            runtime template tree: trials/ -> integration/ -> authoritative/
+                  (generated at runtime, not checked in — see .gitignore)
+```
+
+`naming.py` and `paths.py` are implemented and tested. `sampling.py`, `generation.py`,
+`validation.py`, `promotion.py`, and `pipeline.py` are stub interfaces — the SPEC.md
+section cited in each docstring is the next thing to implement.
+
+## Development
+
+```
+pip install -e ".[dev,sampling]"
+pytest
+```
+
+## CLI
+
+```
+parseforge name show interface GE1.1 status
+# -> show-interface-var1-status
+```

parseforge-0.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+parseforge/__init__.py,sha256=HfjVOrpTnmZ-xVFCYSVmX50EXaBQeJteUHG-PD6iQs8,22
+parseforge/generation.py,sha256=bGUZqUramOJP5M4buqQY3iOcLG1v32tQ_QScUP_XkOg,1215
+parseforge/paths.py,sha256=CWqAKL7oTMGTS7pxgcj_JCHKGd2EOLdOwVb-ATBObCA,2205
+parseforge/pipeline.py,sha256=NDRt4Ennexz4mzhXkdiJ-btvI8JNU4iTXytb1k2Mypo,1905
+parseforge/promotion.py,sha256=QZGatglsUzP3b-l00o0m97mAa_8DYcqA4er8ANqXMXc,1154
+parseforge/sampling.py,sha256=iXQ5iVPoyVxIvms-A9m9Xh7qz4QP66ZrKqVceD81K-8,1182
+parseforge/validation.py,sha256=GJYO2BibehU6zN5kBNsqC2zomgzOCDnLcqur-Gwgzy8,1518
+parseforge/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parseforge/cli/main.py,sha256=bhOmXezGt4eqntTDmVpnffNSQupP3FCHt_n-tyWQsUE,1779
+parseforge/naming/__init__.py,sha256=UTN8x94Xc9vi2ESiLfOjbmBTG27z-KMRAKl7GBoRhq0,397
+parseforge/naming/assemble.py,sha256=jjta415g5oQRRs6HB8mAAdH--Iw5DsSVvdKFmHSf67I,1114
+parseforge/naming/cache.py,sha256=6UYRN_bBAnnfrh6XwuCBxGdRauBwbtEyFuF2t8UI2Fo,1661
+parseforge/naming/llm.py,sha256=2uRaVp4x0JEedGMEGsMCMoooTR6_adhRO5GeDoVOlFQ,1868
+parseforge/naming/resolver.py,sha256=PzWLAsvxIcdyfXdonOMWvHTLy836noSss-VwXtM_VPE,1421
+parseforge-0.2.1.dist-info/licenses/LICENSE,sha256=LOxmz9EcTI5ykp5TQZioE-5QY7tsUinZjlXwrEEGkgc,1074
+parseforge-0.2.1.dist-info/METADATA,sha256=SUXrIV2dRuogsmUL08k65YAkf3hTvzY18S_iU9Rls34,2983
+parseforge-0.2.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+parseforge-0.2.1.dist-info/entry_points.txt,sha256=NhSC-qotioae8Lpw2TR2WY_ibzLJog-Bhu2IrYM7l0I,56
+parseforge-0.2.1.dist-info/top_level.txt,sha256=IVTjnydw5oh5ylVuUAzW-BONPa82JP0hHJrhypCw8G0,11
+parseforge-0.2.1.dist-info/RECORD,,

parseforge-0.2.1.dist-info/WHEEL

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

parseforge-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parseforge = parseforge.cli.main:main

parseforge-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Geeks Trident LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parseforge-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+parseforge