mycelium-cli 0.1.0__py3-none-any.whl

mycelium_cli/commands/test.py

@@ -0,0 +1,72 @@
+"""
+`mycelium test` — dry-run the agent against a simulated ledger.
+
+Runs the project's agent script exactly as `mycelium run` would, but with
+dry-run mode forced on (MYCELIUM_DRY_RUN=1): every state-changing contract call
+the agent makes is *simulated* (no signature, no fee, no on-chain mutation) and
+recorded. Afterwards it prints a summary of every on-chain action the agent
+would have taken, with the simulated return value and estimated fee — so you can
+see what your agent does before it spends real lumens on testnet.
+
+Read-only calls behave identically to a live run, so views still return real data.
+"""
+
+import os
+import sys
+from typing import Optional
+
+from mycelium_cli.config import get_value
+from mycelium_cli.commands.agent import run_agent
+
+
+def _stroops_to_xlm(stroops: Optional[int]) -> str:
+    if stroops is None:
+        return "—"
+    return f"{stroops / 1e7:.7f}"
+
+
+def _print_summary() -> None:
+    from mycelium_sdk import context as ctx_mod
+
+    log = ctx_mod.DRY_RUN_LOG
+    print("\n──────── dry-run summary ────────")
+    if not log:
+        print("  No state-changing contract calls were attempted.")
+        print("  (Read-only calls run normally and are not listed here.)\n")
+        return
+
+    total_fee = 0
+    for i, rec in enumerate(log, 1):
+        args = ", ".join(map(repr, rec["args"]))
+        print(f"  {i}. {rec['function']}({args})")
+        print(f"     contract : {rec['contract_id']}")
+        print(f"     returns  : {rec['sim_return']}")
+        print(f"     est fee  : {_stroops_to_xlm(rec['est_fee_stroops'])} XLM")
+        if rec["est_fee_stroops"]:
+            total_fee += rec["est_fee_stroops"]
+    print(f"\n  {len(log)} action(s) simulated · est. total fees {_stroops_to_xlm(total_fee)} XLM")
+    print("  Nothing was signed or submitted. Run `mycelium run` to execute for real.\n")
+
+
+def run_test(file: Optional[str] = None, contract: Optional[str] = None) -> list:
+    from mycelium_sdk import context as ctx_mod
+
+    file = file or get_value("agent", "script", "agent.py")
+    contract = contract or get_value("onchain", "contract_id") or ""
+    network = get_value("onchain", "network", "testnet")
+
+    if not os.path.exists(file):
+        print(f"Error: agent script {file} not found. Pass it explicitly or run from the project dir.")
+        sys.exit(1)
+
+    print(f"[test] Dry-running {file} ({network}) — state changes will be simulated only.\n")
+    os.environ["MYCELIUM_DRY_RUN"] = "1"
+    os.environ.setdefault("MYCELIUM_NETWORK", network)
+    ctx_mod.reset_dry_run_log()
+
+    try:
+        run_agent(file, contract)
+    finally:
+        _print_summary()
+
+    return list(ctx_mod.DRY_RUN_LOG)

mycelium_cli/config.py

@@ -0,0 +1,47 @@
+"""
+mycelium.toml read/write helpers.
+
+Reading uses the stdlib `tomllib` (Python 3.11+); writing uses `tomli-w`. We
+only ever patch flat values (e.g. `onchain.contract_id` after deploy), so the
+lack of comment preservation is acceptable.
+"""
+
+import os
+import tomllib
+
+import tomli_w
+
+DEFAULT_CONFIG_PATH = "mycelium.toml"
+
+
+def load_config(path: str = DEFAULT_CONFIG_PATH) -> dict:
+    """Load and parse a mycelium.toml file. Raises FileNotFoundError if absent."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"{path} not found. Run `mycelium init <name>` first, or run from a project directory."
+        )
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def save_config(data: dict, path: str = DEFAULT_CONFIG_PATH) -> None:
+    """Serialize a config dict back to TOML."""
+    with open(path, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def set_value(table: str, key: str, value, path: str = DEFAULT_CONFIG_PATH) -> dict:
+    """Set `[table].key = value` in the config file, creating the table if needed."""
+    data = load_config(path)
+    data.setdefault(table, {})[key] = value
+    save_config(data, path)
+    return data
+
+
+def get_value(table: str, key: str, default=None, path: str = DEFAULT_CONFIG_PATH):
+    """Read `[table].key`, returning `default` if missing."""
+    try:
+        data = load_config(path)
+    except FileNotFoundError:
+        return default
+    return data.get(table, {}).get(key, default)

mycelium_cli/main.py

@@ -0,0 +1,298 @@
+"""Mycelium CLI entry point (Typer)."""
+
+import os
+
+import typer
+
+from mycelium_sdk.banner import show_startup_banner
+from mycelium_cli.commands.init import run_init, validate_unique_name, VALID_FRAMEWORKS
+from mycelium_cli.commands.newwallet import run_newwallet, DEFAULT_WALLET_PATH
+from mycelium_cli.commands.compile import run_compile
+from mycelium_cli.commands.deploy import run_deploy
+from mycelium_cli.commands.register import run_register
+from mycelium_cli.commands.check import run_check
+from mycelium_cli.commands.agent import run_agent
+from mycelium_cli.commands.discover import run_discover
+from mycelium_cli.commands.resolve import run_resolve
+from mycelium_cli.commands.status import run_status
+from mycelium_cli.commands.fund import run_fund
+from mycelium_cli.commands.call import run_call
+from mycelium_cli.commands.pay import run_pay
+from mycelium_cli.commands.doctor import run_doctor
+from mycelium_cli.commands.events import run_events
+from mycelium_cli.commands.run import run_run
+from mycelium_cli.commands.test import run_test
+
+app = typer.Typer(help="Mycelium Developer Framework CLI")
+
+PASSPHRASE_ENV_VAR = "MYCELIUM_DECRYPT_KEY"
+
+
+@app.callback(invoke_without_command=True)
+def _root(ctx: typer.Context):
+    """Mycelium Developer Framework CLI."""
+    show_startup_banner()
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+def _resolve_passphrase(label: str, confirm: bool = False) -> str:
+    """Use MYCELIUM_DECRYPT_KEY if set, otherwise prompt interactively."""
+    env_value = os.environ.get(PASSPHRASE_ENV_VAR)
+    if env_value:
+        return env_value
+    return typer.prompt(label, hide_input=True, confirmation_prompt=confirm)
+
+
+def _select_model(framework: str) -> tuple[str, str | None]:
+    """
+    Resolve the target model for `framework`, returning (model, api_key).
+
+    For API-backed frameworks we NEVER let the developer free-type a model name
+    (a hallucinated id fails at runtime). Instead we take their API key, query
+    the provider's live model catalogue, and have them pick from the real list.
+    If discovery fails (bad key / offline) we fall back to manual entry so the
+    wizard never hard-blocks. `api_key` is None for non-API frameworks.
+    """
+    from mycelium_sdk import models as model_discovery
+
+    if not model_discovery.supports_discovery(framework):
+        return typer.prompt("Target model", default="custom"), None
+
+    # Cloud providers need a key; local runtimes (ollama) need a base URL instead.
+    api_key = None
+    base_url = None
+    if model_discovery.requires_api_key(framework):
+        api_key = typer.prompt(f"{framework.capitalize()} API key", hide_input=True).strip()
+    else:
+        base_url = typer.prompt(
+            f"{framework.capitalize()} server URL",
+            default=model_discovery.DEFAULT_OLLAMA_URL,
+        ).strip()
+
+    typer.echo(f"  Fetching available {framework} models...")
+    try:
+        available = model_discovery.list_models(framework, api_key, base_url=base_url)
+    except model_discovery.ModelDiscoveryError as exc:
+        typer.echo(f"  ⚠ Could not list models ({exc}).")
+        return typer.prompt("Enter the model id manually"), api_key
+
+    typer.echo(f"  {len(available)} models available:")
+    for i, name in enumerate(available, 1):
+        typer.echo(f"    [{i}] {name}")
+    while True:
+        choice = typer.prompt("Select a model by number")
+        try:
+            idx = int(choice)
+            if 1 <= idx <= len(available):
+                return available[idx - 1], api_key
+        except ValueError:
+            pass
+        typer.echo(f"  Enter a number between 1 and {len(available)}.")
+
+
+@app.command()
+def init(
+    project_name: str = typer.Argument(..., help="Name of the new project"),
+    non_interactive: bool = typer.Option(
+        False, "--yes", "--non-interactive", help="Skip prompts, use defaults"
+    ),
+):
+    """Initialize a new Mycelium agent project."""
+    framework, model, unique_name, api_key = "custom", "custom", project_name, None
+
+    if not non_interactive:
+        framework = typer.prompt(f"AI framework {list(VALID_FRAMEWORKS)}", default="custom")
+        while framework not in VALID_FRAMEWORKS:
+            typer.echo(f"  Must be one of {list(VALID_FRAMEWORKS)}.")
+            framework = typer.prompt("AI framework", default="custom")
+        model, api_key = _select_model(framework)
+        unique_name = typer.prompt("Unique name (^[a-zA-Z0-9_]{3,30}$)", default=project_name)
+        while not validate_unique_name(unique_name):
+            typer.echo("  Invalid: 3-30 chars, alphanumeric/underscore only.")
+            unique_name = typer.prompt("Unique name", default=project_name)
+
+    path = run_init(
+        project_name, framework=framework, model=model, unique_name=unique_name, api_key=api_key
+    )
+    typer.echo(f"✓ Project '{path}' initialized.")
+    typer.echo("  Next: cd into it, run `mycelium newwallet`, then `mycelium compile`.")
+
+
+@app.command()
+def newwallet(
+    path: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet output path"),
+    force: bool = typer.Option(False, "--force", help="Overwrite an existing wallet"),
+):
+    """Generate an encrypted Ed25519 wallet."""
+    passphrase = _resolve_passphrase("Encryption passphrase", confirm=True)
+    public_key = run_newwallet(path=path, passphrase=passphrase, force=force)
+    typer.echo(f"✓ Wallet created at {path}")
+    typer.echo(f"  Public key: {public_key}")
+
+
+@app.command()
+def compile(
+    file: str = typer.Argument(None, help="Contract file (defaults to mycelium.toml)"),
+    output: str = typer.Option(None, "-o", "--output", help="Output WASM path"),
+    optimize: bool = typer.Option(False, "--optimize", help="Size-optimize the WASM"),
+):
+    """Compile a Python contract to Soroban WASM."""
+    run_compile(file, output, optimize=optimize)
+
+
+@app.command()
+def check(file: str = typer.Argument(..., help="Python contract file to validate")):
+    """Validate a contract's AST and types without compiling."""
+    run_check(file)
+
+
+@app.command()
+def deploy(
+    network: str = typer.Option("testnet", help="testnet or mainnet"),
+    wasm: str = typer.Option(None, help="WASM path (defaults to mycelium.toml)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path"),
+):
+    """Deploy the compiled contract to Stellar/Soroban."""
+    passphrase = _resolve_passphrase("Wallet passphrase")
+    run_deploy(network=network, wasm_path=wasm, wallet_path=wallet, passphrase=passphrase)
+
+
+@app.command()
+def register(
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path"),
+):
+    """Register the agent's unique name on the Hive Registry."""
+    passphrase = _resolve_passphrase("Wallet passphrase")
+    run_register(network=network, wallet_path=wallet, passphrase=passphrase)
+
+
+@app.command()
+def agent(
+    file: str = typer.Argument(..., help="Agent runtime script"),
+    contract: str = typer.Option(..., "--contract", help="On-chain contract id to bind"),
+):
+    """Start a Mycelium agent runtime."""
+    run_agent(file, contract)
+
+
+@app.command()
+def agents(
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    registry: str = typer.Option(None, "--registry", help="Hive Registry contract id override"),
+    start_ledger: int = typer.Option(
+        None, "--start-ledger", help="First ledger to scan (defaults to the RPC retention horizon)"
+    ),
+    no_resolve: bool = typer.Option(
+        False, "--no-resolve", help="Skip per-agent resolution (faster; names + addresses only)"
+    ),
+):
+    """Discover every agent registered on the Hive Registry (read-only, no wallet)."""
+    run_discover(
+        network=network, registry=registry, start_ledger=start_ledger, resolve=not no_resolve
+    )
+
+
+@app.command()
+def resolve(
+    name: str = typer.Argument(..., help="Unique agent name to look up"),
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    registry: str = typer.Option(None, "--registry", help="Hive Registry contract id override"),
+):
+    """Resolve a single agent name to its Hive Registry entry (read-only, no wallet)."""
+    run_resolve(name, network=network, registry=registry)
+
+
+@app.command()
+def status(
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path"),
+):
+    """Show wallet, balance, network, deploy, and registry state in one screen."""
+    run_status(network=network, wallet_path=wallet)
+
+
+@app.command()
+def fund(
+    address: str = typer.Option(None, "--address", help="Address to fund (defaults to project wallet)"),
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path"),
+):
+    """Top up a testnet wallet from Friendbot."""
+    run_fund(address=address, network=network, wallet_path=wallet)
+
+
+@app.command()
+def call(
+    function_name: str = typer.Argument(..., help="Contract function to invoke"),
+    args: list[str] = typer.Argument(None, help="Positional arguments (ints/bools/addresses auto-typed)"),
+    contract: str = typer.Option(None, "--contract", help="Contract id (defaults to mycelium.toml)"),
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    send: bool = typer.Option(False, "--send", help="Sign & submit a state-changing tx (default: read-only)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path (only with --send)"),
+):
+    """Invoke a deployed contract function (read-only by default)."""
+    passphrase = _resolve_passphrase("Wallet passphrase") if send else None
+    run_call(
+        function_name, args=args, contract=contract, network=network,
+        send=send, wallet_path=wallet, passphrase=passphrase,
+    )
+
+
+@app.command()
+def pay(
+    recipient: str = typer.Argument(..., help="Registry name or G... address to pay"),
+    amount: str = typer.Argument(..., help="Amount of XLM to send"),
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    wallet: str = typer.Option(DEFAULT_WALLET_PATH, help="Wallet path"),
+):
+    """Send an XLM payment to a registry name or address (M2M settlement)."""
+    passphrase = _resolve_passphrase("Wallet passphrase")
+    run_pay(recipient, amount, network=network, wallet_path=wallet, passphrase=passphrase)
+
+
+@app.command()
+def doctor(
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+):
+    """Verify the toolchain (stellar-cli, rust+wasm, RPC) and print fixes."""
+    run_doctor(network=network)
+
+
+@app.command()
+def events(
+    contract: str = typer.Option(None, "--contract", help="Contract id (defaults to mycelium.toml)"),
+    network: str = typer.Option(None, help="testnet or mainnet (defaults to mycelium.toml)"),
+    start_ledger: int = typer.Option(None, "--start-ledger", help="First ledger to scan"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Stream new events until interrupted"),
+):
+    """Show (or stream with --follow) a contract's on-chain events."""
+    run_events(contract=contract, network=network, start_ledger=start_ledger, follow=follow)
+
+
+@app.command()
+def run(
+    file: str = typer.Argument(None, help="Agent script (defaults to agent.py)"),
+    contract: str = typer.Option(None, "--contract", help="Contract id (defaults to mycelium.toml)"),
+):
+    """Run the project's agent, auto-reading contract id + network from mycelium.toml."""
+    run_run(file=file, contract=contract)
+
+
+@app.command()
+def test(
+    file: str = typer.Argument(None, help="Agent script (defaults to agent.py)"),
+    contract: str = typer.Option(None, "--contract", help="Contract id (defaults to mycelium.toml)"),
+):
+    """Dry-run the agent: simulate every on-chain action without signing or spending."""
+    run_test(file=file, contract=contract)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

mycelium_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: mycelium-cli
+Version: 0.1.0
+Summary: Mycelium CLI — init, newwallet, compile, deploy, register
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9
+Requires-Dist: tomli-w>=1.0
+Requires-Dist: stellar-sdk<15,>=14
+
+# Mycelium CLI
+
+The Mycelium CLI (`mycelium` command-line tool) is the developer command center for the Mycelium framework. It provides interactive scaffolding, local wallet/keypair management, contract checking and compilation, Soroban blockchain deployments, agent directory registration in the Hive registry, and execution runners for autonomous agent loops.
+
+---
+
+## 🚀 Installation & Setup
+
+Install the CLI toolchain directly from PyPI (packaged within `mycelium-cli` or bundled inside the parent `mycelium-stellar` wrapper):
+
+```bash
+pip install mycelium-cli
+```
+
+Verify that the installation was successful by running:
+```bash
+mycelium --help
+```
+
+---
+
+## ⚙️ Configuration Reference (`mycelium.toml`)
+
+All Mycelium CLI operations run relative to a project root containing a `mycelium.toml` file. This configuration serves as the single source of truth for the local agent and its corresponding on-chain contract.
+
+```toml
+[project]
+name = "sentinel_agent"
+version = "0.1.0"
+author = "Developer"
+
+[agent]
+framework = "gemini"             # Options: "langgraph" | "gemini" | "anthropic" | "custom"
+model = "gemini-2.0-flash"        # Target LLM model string
+unique_name = "sentinel_alpha"   # Alphanumeric agent registry name
+
+[onchain]
+source_contract = "contract.py"  # Path to smart contract source file
+target_wasm = "build/contract.wasm" # Output binary path
+network = "testnet"             # Default ledger target: "testnet" | "mainnet"
+contract_id = "CC..."            # Automatically populated after deployment
+wallet_public_key = "GD..."      # Automatically populated after deployment
+
+[registry]
+hive_registry_address = "CCQ..." # Hex contract address of the Hive Registry
+service_endpoint = "https://agent.sentinel.mycelium.sh" # Agent API URL
+capabilities = ["data-analysis", "stellar-arbitrage"] # List of capability tags
+```
+
+---
+
+## 🛠️ Complete CLI Command Reference
+
+### 1. `mycelium init`
+Scaffolds a new Mycelium project from scratch. It launches an interactive setup wizard that prompts you for project properties.
+
+* **Syntax**:
+  ```bash
+  mycelium init <project_name> [options]
+  ```
+* **Interactive Wizard Options**:
+  - **AI Core Framework**: Select from `langgraph`, `gemini`, `anthropic`, or `custom`.
+  - **Target LLM Model**: Pick from recommended defaults or input a custom string.
+  - **Unique Name**: Choose a registry name (regex validated against `^[a-zA-Z0-9_]{3,30}$`).
+* **Flags**:
+  - `--yes` / `-y`: Skip all interactive questions and initialize using standard default configurations.
+  - `--force` / `-f`: Overwrite the destination directory if it already exists.
+
+### 2. `mycelium newwallet`
+Generates a new secure Stellar keypair (Ed25519) and saves it to `.mycelium/wallet.json`.
+
+* **Syntax**:
+  ```bash
+  mycelium newwallet [options]
+  ```
+* **Security Details**:
+  - The secret seed is encrypted at rest using PBKDF2-HMAC-SHA256 (600,000 iterations) + AES-256-GCM.
+  - Prompts securely for an encryption passphrase.
+  - Filesystem permissions on `.mycelium/wallet.json` are automatically restricted to `0600` (read/write by owner only).
+* **Flags**:
+  - `--passphrase <text>`: Provide the encryption passphrase directly (convenient for automated environments).
+  - `--force`: Force generation, overwriting any existing wallet configuration.
+
+### 3. `mycelium compile`
+Parses and compiles a Python-DSL contract file into a WebAssembly contract binary.
+
+* **Syntax**:
+  ```bash
+  mycelium compile [source_file] [options]
+  ```
+* **Flags**:
+  - `--output <path>` / `-o <path>`: Specify the output WASM file path (defaults to `build/contract.wasm`).
+  - `--optimize`: Enable maximum optimization passes (release profile, targeting size reduction).
+
+### 4. `mycelium check`
+Performs static evaluation and type verification on a contract script without generating a WASM binary. Useful for checking syntax in IDEs, git pre-commit hooks, or CI pipelines.
+
+* **Syntax**:
+  ```bash
+  mycelium check [source_file]
+  ```
+
+### 5. `mycelium deploy`
+Deploys the compiled WASM binary directly to Stellar/Soroban.
+
+* **Syntax**:
+  ```bash
+  mycelium deploy [options]
+  ```
+* **Behaviors**:
+  - **Testnet**: Checks the balance. If the balance is zero, the CLI automatically requests funds from the Stellar Friendbot API, waits for ledger confirmation, and broadcasts the deployment transaction.
+  - **Mainnet**: Asserts the wallet has a minimum balance of `5 XLM` (to satisfy reserves). If insufficient, it halts with an error and displays the public key.
+  - On success, updates `contract_id` and `wallet_public_key` in `mycelium.toml`.
+* **Flags**:
+  - `--network <name>`: Override the network target (`testnet` or `mainnet`).
+  - `--wasm <path>`: Override the WASM file path to deploy.
+
+### 6. `mycelium register`
+Submits a signed transaction to the global Hive Registry mapping your agent's configuration parameters.
+
+* **Syntax**:
+  ```bash
+  mycelium register [options]
+  ```
+* **Details**:
+  - Packages the agent name, service endpoint, public address, and the SHA-256 hash of capability tags.
+  - Verifies that local keys match the owner keys if updating an existing registration.
+
+### 7. `mycelium status`
+Displays the comprehensive deployment and configuration status of the active project in a single screen.
+
+* **Syntax**:
+  ```bash
+  mycelium status
+  ```
+* **Output Fields**:
+  - **Wallet Address**: G-address extracted from local wallet config.
+  - **Wallet Balance**: Balance retrieved from Horizon RPC.
+  - **Network**: Deployed target network passphrase identifier.
+  - **Contract Deployment**: Verification status of the contract ID on the ledger.
+  - **Registry Entry**: Name verification, registration state, reputation score, and API endpoint details.
+
+### 8. `mycelium fund`
+Explicitly requests Friendbot funding for the agent's wallet. Used to top up testnet gas balances.
+
+* **Syntax**:
+  ```bash
+  mycelium fund [options]
+  ```
+* **Flags**:
+  - `--amount <number>`: Request a specific amount (if supported by network node limits).
+
+### 9. `mycelium call`
+Invokes an on-chain contract function directly from your terminal.
+
+* **Syntax**:
+  ```bash
+  mycelium call <function_name> [args...] [options]
+  ```
+* **Details**:
+  - Automatically maps plain argument strings to the correct Soroban type based on the contract specification.
+* **Flags**:
+  - `--read-only`: Execute as a simulate-only view invocation (free, does not require passphrase or signature).
+  - `--contract <id>`: Override the target contract ID.
+
+### 10. `mycelium resolve`
+Queries the on-chain Hive Registry to resolve details of another agent by its name.
+
+* **Syntax**:
+  ```bash
+  mycelium resolve <agent_name>
+  ```
+
+### 11. `mycelium pay`
+Triggers an agent-to-agent XLM settlement payment. It resolves the destination agent's wallet address from the registry.
+
+* **Syntax**:
+  ```bash
+  mycelium pay <recipient_name_or_address> <amount_xlm>
+  ```
+
+### 12. `mycelium events` / `mycelium logs`
+Streams on-chain event topics emitted by the agent's smart contract.
+
+* **Syntax**:
+  ```bash
+  mycelium events [options]
+  ```
+* **Flags**:
+  - `--contract <id>`: Override the contract ID to monitor.
+  - `--start-ledger <number>`: Begin streaming historical events from a specific ledger sequence.
+
+### 13. `mycelium doctor`
+Runs a suite of sanity checks to verify the state of your local toolchain:
+1. Asserts `stellar-cli` is present on your system path.
+2. Checks if local cargo/wasm targets are properly configured.
+3. Tests network connectivity and latency to Horizon and Soroban RPC nodes.
+4. Identifies version mismatches and prints corrective shell actions.
+
+* **Syntax**:
+  ```bash
+  mycelium doctor
+  ```
+
+### 14. `mycelium run`
+Spins up the agent's execution loop (`agent.py`) in your terminal, pre-loading context configurations, wallet files, and contract IDs from the project directory.
+
+* **Syntax**:
+  ```bash
+  mycelium run [options]
+  ```
+* **Flags**:
+  - `--steps <number>`: Limit the maximum number of steps the LLM loop is permitted to run.
+
+### 15. `mycelium test`
+Performs a simulation dry-run of the agent loop. It intercepts all state-changing contract calls, executes them via simulation, logs estimated resource fees, and returns without signing or broadcasting transactions.
+
+* **Syntax**:
+  ```bash
+  mycelium test
+  ```
+
+---
+
+## 🔐 Environment Variables
+
+* `MYCELIUM_DECRYPT_KEY`: Set this env variable to bypass interactive wallet decryption password prompts. Essential for CI/CD and non-interactive workflows.
+* `MYCELIUM_CONTRACT_ID`: Override default contract target.
+* `STELLAR_NETWORK`: Overrides default network selection (`testnet` / `mainnet`).

mycelium_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+mycelium_cli/__init__.py,sha256=tpCzAXMonpTR8IZGY0iylQ4F7z53U94PimWsUmz9WkE,23
+mycelium_cli/config.py,sha256=6sGrJxXgRfC6PkpgZneDRAi41NFKxl3jjInsHiWWR98,1469
+mycelium_cli/main.py,sha256=a-YO4uwn_9mud3LrIvFr0Hx7koNf0RKPdAfDoTCNlFg,12174
+mycelium_cli/commands/__init__.py,sha256=2bKymwd1hBv5CD-sr9Fi7PRbj6EfrtzlFX9CoKerQtU,26
+mycelium_cli/commands/agent.py,sha256=c-lzZhN3F9kCP_NCAE3abcSdAIUG09KXtCXkaoKDcxI,2869
+mycelium_cli/commands/call.py,sha256=1lJKLv-dPLMyPQQGjQ0c5EHJhpazPy33LqYgvBa-UrM,3117
+mycelium_cli/commands/check.py,sha256=4jn47BAtpUwqajFeE4_lwozEbA8seURz2medy0mXsNc,662
+mycelium_cli/commands/compile.py,sha256=uM1OCN9s0w1TKPYH7I6-tCFwc3cG7ztk15-TsrlnTQs,1962
+mycelium_cli/commands/deploy.py,sha256=0o7uSyEJd1uuUQn7aeeWBeegyab5uKz-AQ4BtM0D8Ws,4993
+mycelium_cli/commands/discover.py,sha256=SNNyeZzc-G8WqvGi5oQx0A9dI7CiZiJBNLPwF_RWxW0,2495
+mycelium_cli/commands/doctor.py,sha256=TzKR14VHSGVD0BBDIDo1QqG1j8frUlQJpsxHgYkDbSs,3586
+mycelium_cli/commands/events.py,sha256=M2jvIMJSZRFHWViawxLu3TrHJqmBhMOXuD1PMPKhik0,4068
+mycelium_cli/commands/fund.py,sha256=CmXjmSOS7L3zJbuC1ZfcLE8P-NWclomG8nU8wCCTxp4,2148
+mycelium_cli/commands/init.py,sha256=qXdp0N6-gFHp3MYP0yY6odh8J9p8VQXPDVSFiXOyA4A,6579
+mycelium_cli/commands/newwallet.py,sha256=Fmu_GDVjeZyWX3S8dyMHzDw4j-65FtQKwaqKPO-zH-A,2053
+mycelium_cli/commands/pay.py,sha256=8On-vC-5IAeBb8VEXNfZU0lTLfpVPpn_JfwTLCbNmGw,2905
+mycelium_cli/commands/register.py,sha256=rKYPk4-EUcUDEV4O6OAy1z-NO3bO-BuA78Xlpr8x8Kg,2425
+mycelium_cli/commands/resolve.py,sha256=NOsUOqV-Pe_P8nz_3agHbEUzEK5t8FyAI7i5vcMN-Do,1939
+mycelium_cli/commands/run.py,sha256=foQSkQxq4qcft6hZXr68mzxQq00B-3fbPLiRUv5b5hs,1208
+mycelium_cli/commands/status.py,sha256=ydVsmbTefvfP08doUXB1dPWerRjfSbWZOY89an1nJYQ,4295
+mycelium_cli/commands/test.py,sha256=wmltJEVD8GQnKBoUwxPv3P9gxQVU1tURqsc3ijze-W0,2703
+mycelium_cli-0.1.0.dist-info/METADATA,sha256=kpBlnMOZYNwT88E8lVxWFpp4RiloAiyijyXErztqhXU,8901
+mycelium_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mycelium_cli-0.1.0.dist-info/entry_points.txt,sha256=i9ViGx8gDutPLaEaPtl77T2u-WVOVZFWz3I8Bo1viqg,52
+mycelium_cli-0.1.0.dist-info/top_level.txt,sha256=TiBW8eXzuqoNq1iHWzrjkpZ1RK2TXNd144SXBzcICds,13
+mycelium_cli-0.1.0.dist-info/RECORD,,