weftai-cli 0.1.0a1__tar.gz

weftai_cli-0.1.0a1/.gitignore

@@ -0,0 +1,30 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+.eggs/
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.pyright/
+.tox/
+.env
+.env.*
+!.env.example
+uv.lock.bak
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.tsbuildinfo
+.coverage.*
+htmlcov/

weftai_cli-0.1.0a1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.5
+Name: weftai-cli
+Version: 0.1.0a1
+Summary: Weftai command-line interface
+Author: Rex Technologies
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: weftai
+Requires-Dist: weftai-mcp
+Description-Content-Type: text/markdown
+
+# weftai-cli
+
+Command-line interface. Install: `pip install weftai-cli`. Console script: `weftai`.

weftai_cli-0.1.0a1/README.md

@@ -0,0 +1,3 @@
+# weftai-cli
+
+Command-line interface. Install: `pip install weftai-cli`. Console script: `weftai`.

weftai_cli-0.1.0a1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling", "hatch-cada>=1.0.3"]
+build-backend = "hatchling.build"
+
+[project]
+name = "weftai-cli"
+version = "0.1.0a1"
+description = "Weftai command-line interface"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Rex Technologies" }]
+dependencies = ["weftai", "weftai-mcp"]
+
+[project.scripts]
+weftai = "weftai.cli:main"
+
+[tool.hatch.build]
+dev-mode-dirs = ["src"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/weftai"]
+
+[tool.hatch.metadata.hooks.cada]
+strategy = "pin"
+
+[tool.uv.sources]
+weftai = { workspace = true }
+weftai-mcp = { workspace = true }

weftai_cli-0.1.0a1/src/weftai/cli/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+from weftai.cli.commands import USAGE, Io, dispatch
+from weftai.cli.parse import parse_argv
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_argv(sys.argv[1:] if argv is None else argv)
+    io = Io(sys.stdout, sys.stderr)
+    return asyncio.run(dispatch(args, io))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

weftai_cli-0.1.0a1/src/weftai/cli/commands.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, TextIO
+
+from weftai import create_runtime, format_issues, validate_plan
+from weftai.cli.domain import load_domain
+from weftai.cli.parse import CliArgs, bool_flag, flag, parse_argv
+from weftai.cli.scaffold import write_scaffold
+
+USAGE = """Usage:
+  weftai run <plan.json> --domain <file> [--fixture <file>] [--trace out.json] [--format text|json]
+  weftai validate <plan.json> --domain <file>
+  weftai describe --domain <file> [--json]
+  weftai trace <trace.json>
+  weftai mcp --domain <file> [--fixture <file>] [--name <name>]
+  weftai init [dir]
+"""
+
+
+class Io:
+    def __init__(self, stdout: Any, stderr: Any) -> None:
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+async def dispatch(args: CliArgs, io: Io, options: dict[str, Any] | None = None) -> int:
+    opts = options or {}
+    command = args.command
+    if command is None or command == "help":
+        io.stdout.write(USAGE)
+        return 0
+    if command == "run":
+        return await _run(args, io)
+    if command == "validate":
+        return await _validate(args, io)
+    if command == "describe":
+        return await _describe(args, io)
+    if command == "trace":
+        return _trace(args, io)
+    if command == "mcp":
+        return await _mcp(args, io, opts.get("mcpTransport"))
+    if command == "init":
+        return _init(args, io)
+    io.stderr.write(f"Unknown command '{command}'.\n{USAGE}")
+    return 2
+
+
+async def _run(args: CliArgs, io: Io) -> int:
+    plan_path = args.positionals[0] if args.positionals else None
+    domain_path = flag(args, "domain")
+    if plan_path is None or domain_path is None:
+        io.stderr.write("run requires <plan.json> and --domain <file>.\n")
+        return 2
+    domain = load_domain(domain_path)
+    runtime = create_runtime({"registry": domain.registry})
+    ctx = domain.create_context(flag(args, "fixture"))
+    if hasattr(ctx, "__await__"):
+        ctx = await ctx
+    plan = _read_json(plan_path)
+    result = await runtime.execute(plan, {"ctx": ctx})
+    fmt = flag(args, "format") or "text"
+    if fmt == "json":
+        io.stdout.write(json.dumps(_public_result(result), indent=2) + "\n")
+    else:
+        io.stdout.write(f"{result['text']}\n")
+    trace_path = flag(args, "trace")
+    if trace_path is not None:
+        Path(trace_path).resolve().write_text(json.dumps(result["trace"], indent=2) + "\n", encoding="utf-8")
+    return 0 if result["ok"] else 1
+
+
+async def _validate(args: CliArgs, io: Io) -> int:
+    plan_path = args.positionals[0] if args.positionals else None
+    domain_path = flag(args, "domain")
+    if plan_path is None or domain_path is None:
+        io.stderr.write("validate requires <plan.json> and --domain <file>.\n")
+        return 2
+    domain = load_domain(domain_path)
+    plan = _read_json(plan_path)
+    validation = validate_plan(plan, domain.registry)
+    if validation["ok"]:
+        io.stdout.write(f"OK: {len(validation['plan'].steps)} step(s).\n")
+        return 0
+    io.stderr.write(f"{format_issues(validation['issues'])}\n")
+    return 1
+
+
+async def _describe(args: CliArgs, io: Io) -> int:
+    domain_path = flag(args, "domain")
+    if domain_path is None:
+        io.stderr.write("describe requires --domain <file>.\n")
+        return 2
+    domain = load_domain(domain_path)
+    if bool_flag(args, "json"):
+        io.stdout.write(
+            json.dumps(domain.registry.plan_schema({"style": "union", "strict": True}), indent=2) + "\n"
+        )
+    else:
+        io.stdout.write(f"{domain.registry.describe()}\n")
+    return 0
+
+
+def _trace(args: CliArgs, io: Io) -> int:
+    path = args.positionals[0] if args.positionals else None
+    if path is None:
+        io.stderr.write("trace requires <trace.json>.\n")
+        return 2
+    trace = _read_json(path)
+    io.stdout.write(f"{format_trace(trace)}\n")
+    return 0
+
+
+async def _mcp(args: CliArgs, io: Io, transport: Any) -> int:
+    domain_path = flag(args, "domain")
+    if domain_path is None:
+        io.stderr.write("mcp requires --domain <file>.\n")
+        return 2
+    from weftai.mcp import create_mcp_server
+
+    domain = load_domain(domain_path)
+    runtime = create_runtime({"registry": domain.registry})
+    ctx = domain.create_context(flag(args, "fixture"))
+    if hasattr(ctx, "__await__"):
+        ctx = await ctx
+    mcp = create_mcp_server(runtime, {"name": flag(args, "name") or "weftai", "ctx": ctx})
+    io.stderr.write("Serving MCP on stdio. Press Ctrl+C to stop.\n")
+    await mcp.connect_stdio(transport)
+    return 0
+
+
+def _init(args: CliArgs, io: Io) -> int:
+    directory = str(Path(args.positionals[0] if args.positionals else ".").resolve())
+    written = write_scaffold(directory)
+    io.stdout.write(f"Wrote {len(written)} files in {directory}.\n")
+    return 0
+
+
+def _read_json(path: str) -> Any:
+    return json.loads(Path(path).resolve().read_text(encoding="utf-8"))
+
+
+def _public_result(result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "ok": result["ok"],
+        "text": result["text"],
+        "durationMs": result["durationMs"],
+        "steps": [
+            {
+                "id": step["id"],
+                "operation": step["operation"],
+                "status": step["status"],
+                "count": step.get("count"),
+                "notices": step.get("notices"),
+                "error": step.get("error"),
+            }
+            for step in result["steps"]
+        ],
+        "trace": result["trace"],
+    }
+
+
+def format_trace(trace: dict[str, Any]) -> str:
+    header = _pad("STEP", 12) + _pad("OP", 24) + _pad("STATUS", 10) + _pad("COUNT", 8) + _pad("MS", 8) + "NOTICES"
+    rows = []
+    for step in trace.get("steps") or []:
+        notices = "; ".join(step.get("notices") or [])
+        count = step.get("output", {}) or {}
+        count_val = count.get("count") if isinstance(count, dict) else None
+        rows.append(
+            _pad(step["id"], 12)
+            + _pad(step["operation"], 24)
+            + _pad(step["status"], 10)
+            + _pad("-" if count_val is None else str(count_val), 8)
+            + _pad(str(step.get("durationMs", 0)), 8)
+            + notices
+        )
+    ok = "ok" if trace.get("ok") else "failed"
+    return "\n".join([f"{ok}  {trace.get('durationMs', 0)}ms  {len(trace.get('steps') or [])} step(s)", header, *rows])
+
+
+def _pad(value: str, width: int) -> str:
+    return f"{value} " if len(value) >= width else value.ljust(width)

weftai_cli-0.1.0a1/src/weftai/cli/domain.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from typing import Any
+
+
+def load_domain(path: str) -> Any:
+    resolved = Path(path).resolve()
+    spec = importlib.util.spec_from_file_location("weftai_domain", resolved)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Could not load domain file '{resolved}'.")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    registry = getattr(module, "registry", None)
+    if registry is None:
+        registry = getattr(module, "default", None)
+    create_context = getattr(module, "create_context", None)
+    if create_context is None:
+        create_context = getattr(module, "createContext", None)
+    if registry is None or create_context is None:
+        raise RuntimeError(
+            f"Domain file '{resolved}' must export registry and create_context(fixture_path=None)."
+        )
+    return type("Domain", (), {"registry": registry, "create_context": create_context})()

weftai_cli-0.1.0a1/src/weftai/cli/parse.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class CliArgs:
+    def __init__(self, command: str | None, positionals: list[str], flags: dict[str, str | bool]) -> None:
+        self.command = command
+        self.positionals = positionals
+        self.flags = flags
+
+
+def parse_argv(argv: list[str]) -> CliArgs:
+    positionals: list[str] = []
+    flags: dict[str, str | bool] = {}
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
+        if arg == "--":
+            positionals.extend(argv[i + 1 :])
+            break
+        if arg.startswith("--"):
+            eq = arg.find("=")
+            if eq >= 0:
+                flags[arg[2:eq]] = arg[eq + 1 :]
+                i += 1
+                continue
+            key = arg[2:]
+            nxt = argv[i + 1] if i + 1 < len(argv) else None
+            if nxt is not None and not nxt.startswith("-"):
+                flags[key] = nxt
+                i += 2
+            else:
+                flags[key] = True
+                i += 1
+            continue
+        positionals.append(arg)
+        i += 1
+    command = positionals[0] if positionals else None
+    return CliArgs(command, positionals[1:], flags)
+
+
+def flag(args: CliArgs, name: str) -> str | None:
+    value = args.flags.get(name)
+    return value if isinstance(value, str) else None
+
+
+def bool_flag(args: CliArgs, name: str) -> bool:
+    return args.flags.get(name) is True or args.flags.get(name) == "true"

weftai_cli-0.1.0a1/src/weftai/cli/scaffold.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+DOMAIN = '''from weftai import (
+    BaseModel,
+    collection,
+    create_registry,
+    define_operation_for,
+    object_schema,
+    ref,
+    string_schema,
+    standard_operations,
+)
+from weftai.schema.spec import object_schema as obj
+from weftai.schema.types import FieldSpec
+
+
+class Item(BaseModel):
+    id: str
+    label: str
+
+
+Items = collection(
+    "items",
+    Item,
+    label=lambda item: item.label,
+    key=lambda item: item.id,
+    fields=lambda _ctx: [FieldSpec("label", lambda item: item.label)],
+)
+
+define = define_operation_for()
+
+find = define(
+    {
+        "name": "items.find",
+        "description": "Find items by label.",
+        "input": obj({"query": string_schema()}),
+        "output": Items,
+        "run": lambda ctx: [item for item in ctx.ctx["items"] if ctx.input["query"].lower() in item.label.lower()],
+    }
+)
+
+registry = create_registry({"operations": [find, *standard_operations(Items)]})
+
+
+def create_context(fixture_path: str | None = None) -> dict:
+    return {"items": [Item(id="1", label="Example")]}
+'''
+
+TEST = '''import pytest
+from weftai.testing import create_test_runtime, format_snapshot, to_have_matched
+
+
+@pytest.mark.asyncio
+async def test_find():
+    from domain import registry, create_context
+
+    harness = create_test_runtime(registry, create_context())
+    result = await harness.run_steps([{"id": "hit", "op": "items.find", "input": {"query": "Example"}}])
+    to_have_matched(result, "hit", 1)
+    assert "Example" in format_snapshot(result)
+'''
+
+
+def write_scaffold(directory: str) -> list[str]:
+    root = Path(directory)
+    root.mkdir(parents=True, exist_ok=True)
+    written = []
+    for name, contents in (("domain.py", DOMAIN), ("test_domain.py", TEST)):
+        path = root / name
+        path.write_text(contents, encoding="utf-8", newline="\n")
+        written.append(str(path))
+    return written