hegelion 0.4.0__py3-none-any.whl

hegelion/training/mlx_trainer.py

@@ -0,0 +1,181 @@
+"""
+Hegelion MLX Trainer for Apple Silicon
+
+Fine-tunes an OLMo/Llama/Qwen model on Hegelion reasoning traces using LoRA.
+Optimized for M-series chips (M1/M2/M3/M4).
+
+Requirements:
+    pip install mlx-lm
+"""
+
+import argparse
+import importlib.util
+import sys
+from pathlib import Path
+
+if importlib.util.find_spec("mlx_lm") is None:
+    print("Error: mlx-lm not installed. Run: pip install mlx-lm", file=sys.stderr)
+    sys.exit(1)
+
+
+def train_hegelion_adapter(
+    model_path: str,
+    data_path: str,
+    adapter_path: str = "artifacts/adapters",
+    iters: int = 600,
+    batch_size: int = 1,
+    lora_layers: int = 8,
+    learning_rate: float = 1e-5,
+    **kwargs,
+):
+    print("--- Hegelion MLX Trainer ---")
+    print(f"Model: {model_path}")
+    print(f"Data: {data_path}")
+
+    # We shell out to the mlx_lm CLI for robustness,
+    # as it handles the complex training loop, validation, and saving perfectly.
+    # This is the standard recommended way to use MLX for LoRA.
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "mlx_lm.lora",
+        "--model",
+        model_path,
+        "--train",
+        "--data",
+        data_path,  # Expects directory with train.jsonl / valid.jsonl
+        "--iters",
+        str(iters),
+        "--batch-size",
+        str(batch_size),
+        "--num-layers",
+        str(lora_layers),
+        "--learning-rate",
+        str(learning_rate),
+        "--adapter-path",
+        adapter_path,
+        "--save-every",
+        "100",
+        "--steps-per-eval",
+        "50",
+    ]
+
+    if kwargs.get("max_seq_length"):
+        cmd.extend(["--max-seq-length", str(kwargs["max_seq_length"])])
+
+    if kwargs.get("grad_checkpoint"):
+        cmd.append("--grad-checkpoint")
+
+    print(f"Running: {' '.join(cmd)}")
+
+    import subprocess
+
+    try:
+        subprocess.run(cmd, check=True)
+        print(f"\nSuccess! Adapters saved to {adapter_path}")
+        print("To fuse and upload:")
+        print(
+            f"  python -m mlx_lm.fuse --model {model_path} --adapter-path {adapter_path} --upload-name my-hegelion-model"
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"Training failed with error: {e}")
+        sys.exit(1)
+
+
+def prepare_data_for_mlx(jsonl_path: str, output_dir: str = "artifacts/data/mlx"):
+    """
+    MLX expects a directory with 'train.jsonl' and 'valid.jsonl'.
+    This helper converts our single generator output to that format.
+    """
+    import json
+    import random
+
+    path = Path(jsonl_path)
+    if not path.exists():
+        print(f"Data file not found: {jsonl_path}")
+        return
+
+    out_path = Path(output_dir)
+    out_path.mkdir(exist_ok=True)
+
+    print(f"Preparing data from {jsonl_path}...")
+
+    data = []
+    with open(path, "r") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            try:
+                obj = json.loads(line)
+
+                # Standardize reasoning tags for DeepSeek R1 models
+                # R1 expects <think>...</think> but our data might have <thought>
+                output_text = obj.get("output", "")
+                output_text = output_text.replace("<thought>", "<think>").replace(
+                    "</thought>", "</think>"
+                )
+
+                # MLX format: {"text": "..."}
+                # We need to construct the full prompt text including system/user/assistant tokens
+                # Simple ChatML-like format for now
+
+                text = (
+                    "<|im_start|>system\n"
+                    f"{obj.get('system', '')}<|im_end|>\n"
+                    "<|im_start|>user\n"
+                    f"{obj.get('instruction', '')}<|im_end|>\n"
+                    "<|im_start|>assistant\n"
+                    f"{output_text}<|im_end|>\n"
+                )
+                data.append({"text": text})
+            except Exception:
+                pass
+
+    random.shuffle(data)
+    split_idx = int(len(data) * 0.9)
+    train_data = data[:split_idx]
+    valid_data = data[split_idx:]
+
+    with open(out_path / "train.jsonl", "w") as f:
+        for entry in train_data:
+            json.dump(entry, f, ensure_ascii=False)
+            f.write("\n")
+
+    with open(out_path / "valid.jsonl", "w") as f:
+        for entry in valid_data:
+            json.dump(entry, f, ensure_ascii=False)
+            f.write("\n")
+
+    print(
+        f"Saved {len(train_data)} training and {len(valid_data)} validation examples to {output_dir}/"
+    )
+    return str(out_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B")
+    parser.add_argument("--data", required=True, help="Path to generated hegelion_kimi_data.jsonl")
+    parser.add_argument("--iters", type=int, default=600)
+    parser.add_argument("--batch-size", type=int, default=1, help="Batch size per step")
+    parser.add_argument("--lora-layers", type=int, default=8, help="Number of LoRA layers")
+    parser.add_argument("--max-seq-length", type=int, default=2048, help="Maximum sequence length")
+    parser.add_argument(
+        "--grad-checkpoint",
+        action="store_true",
+        help="Enable gradient checkpointing to save memory",
+    )
+    args = parser.parse_args()
+
+    data_dir = prepare_data_for_mlx(args.data)
+    if data_dir:
+        train_hegelion_adapter(
+            args.model,
+            data_dir,
+            iters=args.iters,
+            batch_size=args.batch_size,
+            lora_layers=args.lora_layers,
+            max_seq_length=args.max_seq_length,
+            grad_checkpoint=args.grad_checkpoint,
+        )

hegelion/training/unsloth_trainer.py

@@ -0,0 +1,136 @@
+"""
+Hegelion Unsloth Trainer
+
+This script fine-tunes a Llama-3 model to internalize the dialectical process.
+It uses Unsloth for memory-efficient 4-bit training.
+
+Requirements:
+    pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
+    pip install --no-deps "xformers<0.0.27" "trl<0.9.0" peft accelerate bitsandbytes
+
+Usage:
+    python -m hegelion.training.unsloth_trainer --dataset hegelion_data.jsonl
+"""
+
+import torch
+import sys
+
+
+def train(
+    dataset_path: str,
+    model_name: str = "unsloth/llama-3-8b-Instruct-bnb-4bit",
+    output_dir: str = "hegelion_lora_model",
+    max_seq_length: int = 2048,
+):
+    # Check for CUDA
+    if not torch.cuda.is_available():
+        print("WARNING: CUDA not detected. Unsloth requires an NVIDIA GPU.", file=sys.stderr)
+        print(
+            "This script is intended to run on Linux with GPUs (e.g. Lambda Labs, RunPod).",
+            file=sys.stderr,
+        )
+        return
+
+    from unsloth import FastLanguageModel
+    from trl import SFTTrainer
+    from transformers import TrainingArguments
+    from datasets import load_dataset
+
+    print(f"Loading model: {model_name}")
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name=model_name,
+        max_seq_length=max_seq_length,
+        dtype=None,
+        load_in_4bit=True,
+    )
+
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=16,
+        target_modules=[
+            "q_proj",
+            "k_proj",
+            "v_proj",
+            "o_proj",
+            "gate_proj",
+            "up_proj",
+            "down_proj",
+        ],
+        lora_alpha=16,
+        lora_dropout=0,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=3407,
+        use_rslora=False,
+        loftq_config=None,
+    )
+
+    # Load Dataset
+    # Format: {"instruction": "...", "output": "..."}
+    dataset = load_dataset("json", data_files=dataset_path, split="train")
+
+    # Formatting function
+    prompt_style = """Below is an instruction that describes a task. Write a response that appropriately completes the request.
+
+### Instruction:
+{}
+
+### Response:
+{}"""
+
+    def formatting_prompts_func(examples):
+        instructions = examples["instruction"]
+        outputs = examples["output"]
+        texts = []
+        for instruction, output in zip(instructions, outputs):
+            text = prompt_style.format(instruction, output) + tokenizer.eos_token
+            texts.append(text)
+        return {"text": texts}
+
+    dataset = dataset.map(formatting_prompts_func, batched=True)
+
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=dataset,
+        dataset_text_field="text",
+        max_seq_length=max_seq_length,
+        dataset_num_proc=2,
+        packing=False,
+        args=TrainingArguments(
+            per_device_train_batch_size=2,
+            gradient_accumulation_steps=4,
+            warmup_steps=5,
+            max_steps=60,  # Increase for real training
+            learning_rate=2e-4,
+            fp16=not torch.cuda.is_bf16_supported(),
+            bf16=torch.cuda.is_bf16_supported(),
+            logging_steps=1,
+            optim="adamw_8bit",
+            weight_decay=0.01,
+            lr_scheduler_type="linear",
+            seed=3407,
+            output_dir=output_dir,
+        ),
+    )
+
+    print("Starting training...")
+    trainer.train()
+
+    print(f"Saving model to {output_dir}...")
+    model.save_pretrained(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+    # Save GGUF for local use
+    # model.save_pretrained_gguf(output_dir, tokenizer, quantization_method = "q4_k_m")
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset", required=True, help="Path to JSONL dataset")
+    parser.add_argument("--output", default="hegelion_adapter")
+    args = parser.parse_args()
+
+    train(args.dataset, output_dir=args.output)

hegelion-0.4.0.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: hegelion
+Version: 0.4.0
+Summary: Dialectical reasoning harness for LLMs (thesis → antithesis → synthesis)
+Author-email: Hunter Bown <hunter@shannonlabs.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Hmbown/Hegelion
+Project-URL: Repository, https://github.com/Hmbown/Hegelion
+Project-URL: Documentation, https://github.com/Hmbown/Hegelion/blob/main/docs/HEGELION_SPEC.md
+Project-URL: Bug Tracker, https://github.com/Hmbown/Hegelion/issues
+Keywords: ai,llm,reasoning,dialectical,hegelian,mcp,anthropic,openai,claude,gpt,ollama,gemini
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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 :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.21.1
+Requires-Dist: openai>=1.0.0
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: google-generativeai>=0.8.3
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: jsonschema>=4.22.0
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scikit-learn>=1.2.0
+Requires-Dist: datasets>=4.4.1
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: duckduckgo-search>=6.0.0
+Requires-Dist: instructor>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: search
+Requires-Dist: tavily-python>=0.3.0; extra == "search"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Provides-Extra: monitoring
+Requires-Dist: psutil>=5.9.0; extra == "monitoring"
+Dynamic: license-file
+
+# Hegelion
+
+> "The True is the whole." — G.W.F. Hegel
+
+Hegelion applies dialectical reasoning to LLMs: forcing models to argue with themselves before reaching conclusions. This produces better reasoning for questions and better code for implementations.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) ![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg) [![PyPI version](https://badge.fury.io/py/hegelion.svg)](https://badge.fury.io/py/hegelion)
+
+---
+
+## Two Modes
+
+| Mode | Pattern | Use Case |
+|------|---------|----------|
+| **Dialectical Reasoning** | Thesis → Antithesis → Synthesis | Deep analysis of questions, philosophy, strategy |
+| **Autocoding** | Player → Coach → Iterate | Verified code implementations with independent review |
+
+Both modes use the same principle: **force the model to oppose itself** before concluding. This catches blind spots that single-pass approaches miss.
+
+---
+
+## Autocoding: Player-Coach Loop
+
+**New in v0.4.0** — Based on [Block AI's g3 agent research](https://block.xyz/documents/adversarial-cooperation-in-code-synthesis.pdf).
+
+### The Problem
+
+Single-agent coding tools often:
+- Declare success prematurely ("I have successfully implemented all requirements!")
+- Accumulate context pollution over long sessions
+- Miss edge cases because they verify their own work
+
+### The Solution
+
+Two roles iterate until requirements are verified:
+
+```
+REQUIREMENTS (Source of Truth)
+        │
+        ▼
+┌───────────────┐     ┌───────────────┐     ┌───────────────┐
+│    PLAYER     │────▶│     COACH     │────▶│    ADVANCE    │
+│  Implements   │     │   Verifies    │     │    State      │
+│  code & tests │     │ independently │     │               │
+└───────────────┘     └───────────────┘     └───────┬───────┘
+        ▲                                           │
+        │              ┌───────────┐                │
+        └──────────────│ APPROVED? │◀───────────────┘
+                       └───────────┘
+                         │       │
+                        No      Yes
+                         │       │
+                         ▼       ▼
+                     Continue   Done
+```
+
+**Player**: Implements requirements, writes tests, responds to feedback. Does NOT declare success.
+
+**Coach**: Independently verifies each requirement, ignores player's self-assessment, outputs structured checklist.
+
+### Key Insight
+
+> "Discard the player's self-report of success. Have the coach perform independent evaluation."
+
+The coach catches issues by re-reading requirements and actually running tests—not by trusting what the player says it did.
+
+### Quick Start
+
+In Claude Code, Cursor, or any MCP-enabled editor:
+
+```
+You: Use autocoding_init with these requirements:
+     - Add user authentication to src/api.py
+     - Add tests in tests/test_auth.py
+     - All tests must pass
+
+[Session initializes]
+
+You: Generate player_prompt and implement
+
+[Player writes code and tests]
+
+You: Generate coach_prompt and verify
+
+[Coach: ✓ auth endpoint exists, ✗ missing password validation test]
+
+You: Call autocoding_advance and continue
+
+[Loop until COACH APPROVED]
+```
+
+### MCP Tools
+
+| Tool | Purpose |
+|------|---------|
+| `autocoding_init` | Start session with requirements checklist |
+| `player_prompt` | Generate implementation prompt |
+| `coach_prompt` | Generate verification prompt |
+| `autocoding_advance` | Update state after coach review |
+| `autocoding_single_shot` | Combined prompt for simpler tasks |
+| `autocoding_save` / `autocoding_load` | Persist and resume sessions |
+
+### Why It Works
+
+| Problem | Single Agent | Coach-Player |
+|---------|--------------|--------------|
+| **Anchoring** | Drifts from requirements | Requirements anchor every turn |
+| **Verification** | Self-assessment (unreliable) | Independent verification |
+| **Context** | Accumulates pollution | Fresh context each turn |
+| **Completion** | Open-ended | Explicit approval gates |
+
+---
+
+## Dialectical Reasoning: Thesis → Antithesis → Synthesis
+
+For questions requiring deep analysis, Hegelion forces three separate LLM calls:
+
+```
+[Call 1] Thesis     → LLM commits to a position
+[Call 2] Antithesis → LLM attacks that position (separate call, no hedging)
+[Call 3] Synthesis  → LLM reconciles the opposition
+```
+
+### Why Separate Calls Matter
+
+| Method | Calls | Result |
+|--------|:-----:|--------|
+| **Raw** | 1 | "It depends on definitions..." |
+| **Enhanced** | 1 | "Hold both views in tension..." |
+| **Hegelion** | 3 | Novel framework with testable predictions |
+
+When the model must commit to a thesis, then genuinely attack it in a separate call, the synthesis surfaces insights that single-call approaches shortcut.
+
+<details>
+<summary><b>Example: "Is free will compatible with determinism?"</b></summary>
+
+**Hegelion synthesis** (after thesis and antithesis):
+
+> The deadlock dissolves when we recognize free will exists on a **spectrum of self-authorship**:
+>
+> 1. **Minimal freedom**: Acting on desires without external coercion
+> 2. **Reflective freedom**: Second-order endorsement—I want to want this
+> 3. **Narrative freedom**: Acting consistently with a coherent life narrative
+> 4. **Constitutive freedom**: Recursive self-modification through deliberate habituation
+>
+> **Research proposal**: Use fMRI to scan participants under (1) snap judgments, (2) brief reflection, (3) extended deliberation. Hypothesis: Condition (3) shows strongest correlation with self-reported decision "ownership."
+
+This 4-level framework emerged from actually arguing with itself—not from asking for "thesis/antithesis/synthesis" in one prompt.
+</details>
+
+### Quick Start
+
+```bash
+pip install hegelion
+
+# MCP setup for Claude Desktop (macOS)
+hegelion-setup-mcp --write "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
+```
+
+Or use the Python API:
+
+```python
+import asyncio
+from hegelion import run_dialectic
+
+async def main():
+    result = await run_dialectic("Is AI conscious?")
+    print(result.synthesis)
+
+asyncio.run(main())
+```
+
+Or CLI:
+
+```bash
+hegelion --stream "Is consciousness fundamental or emergent?"
+```
+
+### Feature Toggles
+
+| Option | Description |
+|--------|-------------|
+| `use_council` | Three critics: Logician, Empiricist, Ethicist |
+| `use_judge` | Final quality evaluation |
+| `use_search` | Grounds arguments with web search |
+| `response_style` | `sections`, `json`, or `synthesis_only` |
+
+---
+
+## Installation
+
+```bash
+pip install hegelion
+```
+
+For MCP integration (Claude Desktop, Cursor, VS Code):
+
+```bash
+# Claude Desktop (macOS)
+hegelion-setup-mcp --write "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
+
+# Then restart Claude Desktop
+```
+
+See [MCP Integration Guide](docs/guides/mcp-integration.md) for other editors.
+
+---
+
+## Documentation
+
+- **[MCP Integration](docs/guides/mcp-integration.md)** — Setup for Claude Desktop, Cursor, VS Code, Gemini CLI
+- **[Python API](docs/guides/python-api.md)** — Full API reference
+- **[CLI Reference](docs/guides/cli-reference.md)** — Command-line usage
+- **[Configuration](docs/getting-started/configuration.md)** — Backends and feature toggles
+- **[Technical Specification](docs/HEGELION_SPEC.md)** — Output schemas, phase specs
+
+---
+
+## Contributing
+
+Issues and PRs welcome. For significant changes, open a discussion first.
+
+---
+
+## Recent Changes
+
+### v0.4.0 (December 2025)
+
+- **Autocoding system**: Player-coach dialectical loop based on Block AI's g3 agent
+- MCP tools: `autocoding_init`, `player_prompt`, `coach_prompt`, `autocoding_advance`
+- Session persistence with `autocoding_save` / `autocoding_load`
+- Single-shot mode for simpler use cases
+
+### v0.3.x
+
+- CLI streaming with `--stream` flag
+- MCP progress notifications
+- 470+ tests passing
+
+---
+
+**License:** MIT

hegelion-0.4.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+hegelion/__init__.py,sha256=lG58sxyEbRLBJT4BVJeMcJkcNDrqibyG_KXOXm_ruYc,1216
+hegelion/council.py,sha256=iJvGxgHs6Mp3c2481QLIkmcnBeHTBQqjZQW0u0gerfs,8627
+hegelion/judge.py,sha256=mU9k8nWZ-u5z2-mOczD9TKVW819vMMQoBt1_kHHqip0,8310
+hegelion/search_providers.py,sha256=hkSfqhe1MfGucSL7dMnQgcfhDm59Q4DhS3glyDo5zUU,4654
+hegelion/core/__init__.py,sha256=2hgRsatEUk0ELXyrAtAjiPj8xcl7KV78cYHod0fn6Fk,617
+hegelion/core/agent.py,sha256=5UyOzalNO3Z0zjnbhke4i2h_hTtV9Zf6JEPL6fdeXEw,5771
+hegelion/core/autocoding_state.py,sha256=ezAonYljkEruWEMgEugor9yrf_6mPC7XsDiLgj6anok,9975
+hegelion/core/backends.py,sha256=4-b03sz_Yv_fKJ1Fk32CcbObAKzKNEe7-MDcoYVSfpw,14897
+hegelion/core/cache.py,sha256=B1CprAuaotCMMwaHjMOD1uBY1K7Ev-3cfTrT9C9pK38,2603
+hegelion/core/config.py,sha256=jINgrD0PryUs2miOdgYKa0tofWxBb22yAm9qDBSJRkQ,8905
+hegelion/core/core.py,sha256=k7TTQYqXZ2KlzZdW-ayiP3C4BBoz8bMKboAi6qPkvUw,23431
+hegelion/core/engine.py,sha256=og7ooHQLJvI1z7dCwodgZsCxDVbD4ozA-mAZrNahjHw,33192
+hegelion/core/logging_utils.py,sha256=rx7N1u6u5nn3N65rcFHIckGYWhiFl3we2iG549CBZbo,2074
+hegelion/core/models.py,sha256=w5wI9lnU3vGdDiQARU_5IkdiEKQkVYNXYtvX1VEvF-k,9722
+hegelion/core/parsing.py,sha256=mhWvSemyQNvEDg7OGRZJl22AzoRyxBooRhs-7plj0wY,9385
+hegelion/core/personas.py,sha256=2bjhIb8RWNQEfXgM8uU4ynPY76zt7OmrNjh6fhKKD0o,2955
+hegelion/core/prompt_autocoding.py,sha256=3N59Gv_7Li3qXYZXze_jPjbdnNltchTuL_35bY73rIg,11971
+hegelion/core/prompt_dialectic.py,sha256=wUHwHTBQjd8OdjXkg04FzEiVSxyChy4PCX6cv_qrgv4,14979
+hegelion/core/prompts.py,sha256=Y2Exw_DKgp_5uUs1oQxfQElIu6sCkkJ_qNnmtObJQu0,3534
+hegelion/core/schema.py,sha256=PknWdeMuv_pRclBF1AwJ0xS6qB14HyLXoiwielMSMjk,2247
+hegelion/core/validation.py,sha256=ZGirtkPzsJaSuojXAGR7pKfSUz6kbJV4kxc1Sy_VQwg,2427
+hegelion/examples_data/__init__.py,sha256=EK4nTRY5gHtvn6CTD_w5FOxwQmYdDyMlMzQ3S7QaslE,219
+hegelion/examples_data/glm4_6_examples.jsonl,sha256=XAFfg1ZAloM4czEI2PPUk5K_m2eeCymZ9qFrmV952ek,16986
+hegelion/mcp/__init__.py,sha256=so0b-cG2q0sZWH8Cx50qEIlldFVCXrd8YZeZyicyifA,67
+hegelion/mcp/server.py,sha256=NCLIH_FcPD_f50EtvYpxXgK4WSUT-ceSU6B1LH6qQi0,34056
+hegelion/scripts/hegelion_agent_cli.py,sha256=0hNeX6grKv5mrypYCeJZ1Fb_7LKbsBrVdtX7gLSxbr0,3224
+hegelion/scripts/hegelion_bench.py,sha256=ihyPqMe_9zjryiiqWEqiw_IZTXNw1hY7n9sc-t-5xMg,3828
+hegelion/scripts/hegelion_cli.py,sha256=HISVUgg65U5NFpFPuG6q5HnBUl-8RztqjxsR9fNkubM,18445
+hegelion/scripts/hegelion_dataset.py,sha256=UPDXzLRFXwC4j6O_1tzKr3YqSwDcpxrQjjiHnnnr4Po,3129
+hegelion/scripts/hegelion_eval.py,sha256=ZKjxlB0O1Haq2IgieQ0UtQRVwkcy7flGTw-_x44tqeU,4354
+hegelion/scripts/mcp_setup.py,sha256=D5a0EPp4u_IHxxokrvNj5FdCn425-pnS7Ppu69Z17MQ,4740
+hegelion/training/__init__.py,sha256=gqjIQk1WRBMbys280HPp3ioC7DPriva0uS7gBAhwDYk,192
+hegelion/training/datasets.py,sha256=qJ3n3hxJgHd5_B3j5uOPYHQy1ylwpvPv-zwnNjD8hsA,4169
+hegelion/training/generator.py,sha256=3wjtC20aaNrfV8hWcUZ5otBmXeyVcth1nsoHt69XBX4,9029
+hegelion/training/mlx_scu_trainer.py,sha256=ME_LqyjyZ_DGxEotF4BrYfTXp9lpM_rCHgq2M-exhWA,12782
+hegelion/training/mlx_trainer.py,sha256=i9ikEYEsKUI9c8lTu-ox5IGW8RlWUHjBNNWSGrX65L4,5613
+hegelion/training/unsloth_trainer.py,sha256=NUEkZv1lwYITFK7JJ0LeR8VCNrXUm_2kJRnhdk5ZxB0,3968
+hegelion-0.4.0.dist-info/licenses/LICENSE,sha256=VYjQbIKaDFQapkzZI3KjymsIQvh-Cj-UzP3BRQBotao,1077
+hegelion-0.4.0.dist-info/METADATA,sha256=qe-0I4plfBc1dsJkWH9P6-xuVTgz4TUocbTpN9VoFJg,10448
+hegelion-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hegelion-0.4.0.dist-info/entry_points.txt,sha256=DxG1r3fF9-qQZ0zUmjI_M5fMQx2eKUhlon5kNm9KdpM,382
+hegelion-0.4.0.dist-info/top_level.txt,sha256=f7kLwRsjAK5wh2bJGdPmbc4A8SYKkr_GRNtYvHaYxzI,9
+hegelion-0.4.0.dist-info/RECORD,,

hegelion-0.4.0.dist-info/WHEEL

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

hegelion-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+hegelion = hegelion.scripts.hegelion_cli:main
+hegelion-agent = hegelion.scripts.hegelion_agent_cli:main
+hegelion-bench = hegelion.scripts.hegelion_bench:main
+hegelion-dataset = hegelion.scripts.hegelion_dataset:main
+hegelion-eval = hegelion.scripts.hegelion_eval:main
+hegelion-server = hegelion.mcp.server:main
+hegelion-setup-mcp = hegelion.scripts.mcp_setup:main

hegelion-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hegelion Contributors
+
+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.