gd-specflow 0.2.0__py3-none-any.whl

cli.py

@@ -0,0 +1,577 @@
+"""SpecFlow CLI — local-only, no-auth, localhost-default.
+
+A thin client over existing mcp_server service code. Intended for users who
+cannot use the MCP server (Cursor / Claude Code). All backend interaction
+reuses SpecFlowBackendService; all path resolution reuses session.py.
+
+Entry point: specflow <command> [options]
+Also runnable as: python -m cli
+
+Commands:
+  run-generation      Upload specs and start code generation
+  check-status        Poll the status of the current generation
+  retry-generation    Retry a failed generation
+  download-outputs    Download and extract completed generation outputs
+  clear-workspace     Free a CLEANING workspace set early
+  sessions            List active generation sessions
+
+Local-only invariant: refuses to connect to non-localhost URLs unless --force
+is passed.  No API key is ever sent in local mode.
+"""
+
+import argparse
+import asyncio
+import datetime
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Config resolution
+# ---------------------------------------------------------------------------
+
+_MCP_CONFIG_FILENAME = ".specflow-local/mcp-config.json"
+_DEFAULT_BACKEND_URL = "http://127.0.0.1:8000"
+_LOCALHOST_HOSTS = {"localhost", "127.0.0.1"}
+
+
+def _load_mcp_config(root: Path) -> dict[str, Any]:
+    """Load .specflow-local/mcp-config.json from the project root, if present."""
+    config_path = root / _MCP_CONFIG_FILENAME
+    try:
+        if config_path.exists():
+            data = json.loads(config_path.read_text())
+            env_block = (
+                data.get("mcpServers", {})
+                    .get("specflow", {})
+                    .get("env", {})
+            )
+            return env_block if isinstance(env_block, dict) else {}
+    except Exception as exc:
+        logger.debug("Could not read mcp-config.json: %s", exc)
+    return {}
+
+
+def resolve_backend_config(
+    backend_url_flag: str | None,
+    user_email_flag: str | None,
+    workspace_count_flag: int | None,
+    root: Path,
+) -> tuple[str, str | None, int | None]:
+    """Resolve backend URL, user email, and workspace count.
+
+    Priority: CLI flag → env var → mcp-config.json → default.
+
+    Returns (backend_url, user_email, workspace_count).
+    """
+    mcp_env = _load_mcp_config(root)
+
+    backend_url = (
+        backend_url_flag
+        or os.getenv("BACKEND_URL")
+        or mcp_env.get("BACKEND_URL")
+        or _DEFAULT_BACKEND_URL
+    )
+    user_email = (
+        user_email_flag
+        or os.getenv("USER_EMAIL")
+        or mcp_env.get("USER_EMAIL")
+        or None
+    )
+
+    workspace_count: int | None = None
+    if workspace_count_flag is not None:
+        workspace_count = workspace_count_flag
+    else:
+        wc_env = os.getenv("WORKSPACE_COUNT") or mcp_env.get("WORKSPACE_COUNT")
+        if wc_env is not None:
+            try:
+                parsed = int(wc_env)
+                if parsed in (1, 2, 3):
+                    workspace_count = parsed
+            except (ValueError, TypeError):
+                pass
+
+    return backend_url, user_email, workspace_count
+
+
+def _is_localhost(url: str) -> bool:
+    """Return True if the URL host is localhost or 127.0.0.1."""
+    try:
+        host = urlparse(url).hostname or ""
+        return host.lower() in _LOCALHOST_HOSTS
+    except Exception:
+        return False
+
+
+def check_localhost_guard(backend_url: str, force: bool) -> None:
+    """Print a warning and exit non-zero if backend_url is not localhost and --force not set."""
+    if force or _is_localhost(backend_url):
+        return
+    print(
+        f"ERROR: The CLI is local-only (no API key is sent).\n"
+        f"  Resolved BACKEND_URL: {backend_url}\n"
+        f"  This URL is not localhost — it will NOT authenticate against a remote backend.\n"
+        f"  Use the MCP server for remote deployments.\n"
+        f"  Pass --force to bypass this check.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Environment setup — must be called before importing service modules
+# ---------------------------------------------------------------------------
+
+
+def _configure_env(backend_url: str, user_email: str | None) -> None:
+    """Push resolved config into the environment so service singletons pick it up."""
+    os.environ["BACKEND_URL"] = backend_url
+    if user_email:
+        os.environ["USER_EMAIL"] = user_email
+    else:
+        os.environ.pop("USER_EMAIL", None)
+    # Never set SPECFLOW_API_KEY in local mode — service omits X-API-Key when unset.
+    os.environ.pop("SPECFLOW_API_KEY", None)
+
+
+# ---------------------------------------------------------------------------
+# Root resolution
+# ---------------------------------------------------------------------------
+
+
+def resolve_root(root_path_arg: str | None) -> Path:
+    """Return absolute project root. Defaults to cwd; --root-path overrides."""
+    if root_path_arg:
+        return Path(root_path_arg).expanduser().resolve()
+    return Path.cwd().resolve()
+
+
+# ---------------------------------------------------------------------------
+# Command implementations (async)
+# ---------------------------------------------------------------------------
+
+
+async def cmd_run_generation(args: argparse.Namespace) -> int:
+    """run-generation: upload specs and start generation."""
+    from services.session import set_project_root, resolve_generation_id, write_session
+    from services.generation_orchestrator import GenerationOrchestrator
+    from services.run_generation_precheck import precheck as run_precheck
+    from services.tool_helpers import check_status_safe, is_generation_in_progress
+    from services.cli_service import fetch_pool_status, render_capacity_message
+
+    root = resolve_root(args.root_path)
+    print(f"Using project root: {root}")
+    set_project_root(root)
+
+    spec_dir = root / args.spec_dir
+    src_dir = root / args.src_dir
+    outputs_dir = args.outputs_dir
+
+    # Pre-run notice (FR-8, LV4.2)
+    print(
+        f"\nNote: outputs land in {root / outputs_dir}/{{generation_id}}/... and are\n"
+        f"archived in the artifact store — nothing is lost on workspace recycle.\n"
+        f"Retrieve them any time with: specflow download-outputs\n"
+    )
+
+    rejection = run_precheck(root, args.spec_dir, outputs_dir)
+    if rejection is not None:
+        print(f"ERROR: {rejection.to_dict().get('error', rejection.code.value)}", file=sys.stderr)
+        return 1
+
+    generation_id = resolve_generation_id(None, root)
+    if generation_id:
+        status_data = await check_status_safe(generation_id)
+        if is_generation_in_progress(status_data):
+            print(
+                "ERROR: A generation is already running. "
+                "Wait for the email notification before starting another one.",
+                file=sys.stderr,
+            )
+            return 1
+
+    workspace_count = args.workspace_count  # may be None
+
+    try:
+        response_data = await GenerationOrchestrator.run_generation(
+            spec_dir=spec_dir,
+            src_dir=src_dir,
+            outputs_dir=outputs_dir,
+            generation_id=generation_id,
+            workspace_count=workspace_count,
+        )
+    except Exception as exc:
+        error_msg = str(exc)
+        # Capacity UX (LV4.1): if allocation failed, show cleaning sets
+        if "no" in error_msg.lower() and "workspace" in error_msg.lower():
+            try:
+                pool = await fetch_pool_status()
+                cleaning = pool.get("cleaning_sets") or []
+                if cleaning:
+                    print(render_capacity_message(cleaning))
+                    return 1
+            except Exception:
+                pass
+        print(f"ERROR: {error_msg}", file=sys.stderr)
+        return 1
+
+    new_id = response_data.get("generation_id")
+    if new_id:
+        write_session(new_id, root)
+
+    print(json.dumps(response_data, indent=2))
+    print(
+        "\nFiles uploaded and generation started (usually 2-8 hours).\n"
+        "Run `specflow check-status` to poll progress, or `specflow sessions --watch` for\n"
+        "continuous monitoring with a desktop notification on completion.\n"
+        "(Email/Slack notifications fire only if configured in .env.)"
+    )
+    return 0
+
+
+async def cmd_check_status(args: argparse.Namespace) -> int:
+    """check-status: poll status of the current generation."""
+    from services.session import set_project_root, resolve_generation_id
+    from services.specflow_backend import call_backend_endpoint
+
+    root = resolve_root(args.root_path)
+    print(f"Using project root: {root}")
+    set_project_root(root)
+
+    generation_id = resolve_generation_id(None, root)
+    if not generation_id:
+        print("No active generation in this project. Run `specflow run-generation` to start one.")
+        return 0
+
+    response_text = await call_backend_endpoint(
+        endpoint=f"/api/v1/generation-sessions/{generation_id}/status",
+        method="GET",
+        timeout_seconds=30,
+    )
+    data = json.loads(response_text)
+    print(json.dumps(data, indent=2))
+    return 0
+
+
+async def cmd_retry_generation(args: argparse.Namespace) -> int:
+    """retry-generation: retry a failed generation."""
+    from services.session import set_project_root, resolve_generation_id
+    from services.specflow_backend import call_backend_endpoint
+    from services.tool_helpers import check_status_safe, is_generation_in_progress
+
+    root = resolve_root(args.root_path)
+    print(f"Using project root: {root}")
+    set_project_root(root)
+
+    generation_id = resolve_generation_id(None, root)
+    if not generation_id:
+        print("No previous generation found. Run `specflow run-generation` to start one.")
+        return 0
+
+    status_data = await check_status_safe(generation_id)
+    if is_generation_in_progress(status_data):
+        print(
+            "ERROR: A generation is already running. Wait for it to finish before retrying.",
+            file=sys.stderr,
+        )
+        return 1
+
+    response_text = await call_backend_endpoint(
+        endpoint=f"/api/v1/generation-sessions/{generation_id}/retry",
+        method="POST",
+        timeout_seconds=30,
+    )
+    data = json.loads(response_text)
+    print(json.dumps(data, indent=2))
+    print("\nRetry queued. Generation will resume from the last checkpoint on the same workspaces.")
+    return 0
+
+
+async def cmd_download_outputs(args: argparse.Namespace) -> int:
+    """download-outputs: download and extract completed generation outputs."""
+    from services.session import set_project_root, resolve_generation_id
+    from services.cli_service import download_and_extract_outputs
+
+    root = resolve_root(args.root_path)
+    print(f"Using project root: {root}")
+    set_project_root(root)
+
+    generation_id = resolve_generation_id(args.generation_id, root)
+    if not generation_id:
+        print("ERROR: No generation_id found. Pass --generation-id or run run-generation first.", file=sys.stderr)
+        return 1
+
+    outputs_dir = args.outputs_dir
+    try:
+        result = await download_and_extract_outputs(generation_id, outputs_dir)
+    except Exception as exc:
+        print(f"ERROR: Couldn't download outputs: {exc}", file=sys.stderr)
+        return 1
+
+    if result.get("status") == "success":
+        dest = result.get("outputs_dir", "")
+        count = result.get("files_extracted", 0)
+        print(f"Downloaded {count} files to: {dest}")
+    else:
+        print(json.dumps(result, indent=2))
+    return 0
+
+
+def _render_sessions_table(sessions: list[dict]) -> None:
+    """Print a sessions table to stdout."""
+    if not sessions:
+        print("No active generation sessions.")
+        return
+    header = f"{'GENERATION ID':<40}  {'STATUS':<16}  {'CHECKPOINT'}"
+    print(header)
+    print("-" * len(header))
+    for s in sessions:
+        print(f"{s['generation_id']:<40}  {s['status']:<16}  {s.get('checkpoint', '')}")
+
+
+async def cmd_sessions(args: argparse.Namespace) -> int:
+    """sessions: list active generation sessions (no new backend route)."""
+    from services.cli_service import fetch_sessions, notify_desktop, _TERMINAL_STATUSES
+
+    watch = getattr(args, "watch", False)
+    interval = getattr(args, "interval", 15)
+
+    if not watch:
+        sessions = await fetch_sessions()
+        _render_sessions_table(sessions)
+        return 0
+
+    # --watch: poll, refresh screen, notify on terminal state
+    notified: set[str] = set()
+    print(f"Watching sessions (every {interval}s) — Ctrl+C to stop\n")
+    while True:
+        try:
+            sessions = await fetch_sessions()
+        except Exception as exc:
+            print(f"Error fetching sessions: {exc}")
+        else:
+            # Clear terminal and reprint
+            print("\033[2J\033[H", end="", flush=True)
+            now = datetime.datetime.now().strftime("%H:%M:%S")
+            print(f"SpecFlow sessions — every {interval}s — {now}   (Ctrl+C to stop)\n")
+            _render_sessions_table(sessions)
+
+            for s in sessions:
+                gid = s["generation_id"]
+                status = s["status"]
+                if status in _TERMINAL_STATUSES and gid not in notified:
+                    notified.add(gid)
+                    title = (
+                        "SpecFlow: generation completed"
+                        if status == "completed"
+                        else "SpecFlow: generation failed"
+                    )
+                    msg = f"{gid[:12]}... {status}"
+                    notify_desktop(title=title, message=msg)
+                    print(f"\n[Desktop notification sent: {gid} → {status}]")
+
+        try:
+            await asyncio.sleep(interval)
+        except asyncio.CancelledError:
+            break
+    return 0
+
+
+async def cmd_clear_workspace(args: argparse.Namespace) -> int:
+    """clear-workspace --set N: clear all 3 members of a CLEANING workspace set."""
+    from services.cli_service import clear_workspace_set
+
+    set_number = args.set
+    if not args.yes:
+        answer = input(f"Clear all 3 workspaces in set {set_number}? This cannot be undone. [y/N] ")
+        if answer.strip().lower() not in ("y", "yes"):
+            print("Aborted.")
+            return 0
+
+    results = await clear_workspace_set(set_number)
+    all_ok = True
+    for r in results:
+        status = "OK" if r["success"] else "FAIL"
+        print(f"  {r['workspace_id']}: {status} — {r['message']}")
+        if not r["success"]:
+            all_ok = False
+
+    if all_ok:
+        print(f"\nSet {set_number} cleared. Workspaces are available for the next generation.")
+    else:
+        print("\nSome workspaces failed to clear. See errors above.", file=sys.stderr)
+        return 1
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Argument parser
+# ---------------------------------------------------------------------------
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="specflow",
+        description=(
+            "SpecFlow CLI — local-only tool for managing code-generation sessions.\n"
+            "Use the MCP server for remote/hosted deployments."
+        ),
+    )
+    parser.add_argument(
+        "--backend-url",
+        default=None,
+        help="Backend URL (default: BACKEND_URL env or http://127.0.0.1:8000)",
+    )
+    parser.add_argument(
+        "--user-email",
+        default=None,
+        help="User email (default: USER_EMAIL env)",
+    )
+    parser.add_argument(
+        "--root-path",
+        default=None,
+        help="Project root directory (default: current working directory)",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Bypass the localhost guard for non-local backend URLs",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", metavar="COMMAND")
+    subparsers.required = True
+
+    # run-generation
+    p_run = subparsers.add_parser("run-generation", help="Upload specs and start code generation")
+    p_run.add_argument("--spec-dir", default="specs", help="Spec directory (default: specs)")
+    p_run.add_argument("--outputs-dir", default="docs", help="Outputs directory (default: docs)")
+    p_run.add_argument("--src-dir", default="src", help="Source directory (default: src)")
+    p_run.add_argument(
+        "--workspace-count",
+        type=int,
+        choices=[1, 2, 3],
+        default=None,
+        dest="workspace_count",
+        help="Number of active workspaces (1-3; default from env/config)",
+    )
+
+    # check-status
+    subparsers.add_parser("check-status", help="Check progress of a running generation")
+
+    # retry-generation
+    subparsers.add_parser("retry-generation", help="Retry a failed generation")
+
+    # download-outputs
+    p_dl = subparsers.add_parser(
+        "download-outputs", help="Download and extract completed generation outputs"
+    )
+    p_dl.add_argument(
+        "--generation-id",
+        default=None,
+        dest="generation_id",
+        help="Generation ID (default: from specflow_session.json)",
+    )
+    p_dl.add_argument(
+        "--outputs-dir",
+        default="docs",
+        help="Local directory to extract outputs into (default: docs)",
+    )
+
+    # clear-workspace
+    p_clear = subparsers.add_parser(
+        "clear-workspace",
+        help="Free a CLEANING workspace set early (all 3 members)",
+    )
+    p_clear.add_argument("--set", type=int, required=True, dest="set", help="Set number to clear")
+    p_clear.add_argument("--yes", action="store_true", help="Skip confirmation prompt")
+
+    # sessions
+    p_sessions = subparsers.add_parser("sessions", help="List active generation sessions")
+    p_sessions.add_argument(
+        "--watch",
+        action="store_true",
+        help="Poll continuously and send a desktop notification on completion",
+    )
+    p_sessions.add_argument(
+        "--interval",
+        type=int,
+        default=15,
+        metavar="SECONDS",
+        help="Polling interval in seconds for --watch mode (default: 15)",
+    )
+
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+_COMMAND_MAP = {
+    "run-generation": cmd_run_generation,
+    "check-status": cmd_check_status,
+    "retry-generation": cmd_retry_generation,
+    "download-outputs": cmd_download_outputs,
+    "clear-workspace": cmd_clear_workspace,
+    "sessions": cmd_sessions,
+}
+
+# Commands that operate on files and print the project root
+_FILE_OPERATING_COMMANDS = {
+    "run-generation",
+    "check-status",
+    "retry-generation",
+    "download-outputs",
+}
+
+
+def main() -> None:
+    """CLI entry point."""
+    logging.basicConfig(
+        level=os.getenv("LOG_LEVEL", "WARNING").upper(),
+        format="%(levelname)s - %(message)s",
+    )
+
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    # Determine root early so config resolution can read mcp-config.json
+    root = resolve_root(getattr(args, "root_path", None))
+
+    # Resolve backend config (flag → env → mcp-config.json → default)
+    workspace_count_flag = getattr(args, "workspace_count", None)
+    backend_url, user_email, workspace_count = resolve_backend_config(
+        backend_url_flag=getattr(args, "backend_url", None),
+        user_email_flag=getattr(args, "user_email", None),
+        workspace_count_flag=workspace_count_flag,
+        root=root,
+    )
+
+    # Propagate resolved workspace_count back to args so cmd_run_generation picks it up
+    if not hasattr(args, "workspace_count") or args.workspace_count is None:
+        args.workspace_count = workspace_count
+
+    # Localhost guard
+    check_localhost_guard(backend_url, force=args.force)
+
+    # Push config into env before importing service singletons
+    _configure_env(backend_url, user_email)
+
+    handler = _COMMAND_MAP[args.command]
+    try:
+        exit_code = asyncio.run(handler(args))
+    except KeyboardInterrupt:
+        print("\nStopped.")
+        exit_code = 0
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

gd_specflow-0.2.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: gd-specflow
+Version: 0.2.0
+Summary: SpecFlow MCP Server and CLI — spec-driven AI code generation
+Author-email: Adam Wrobel <awrobel@griddynamics.com>, Artsiom Kozak <akozak@griddynamics.com>
+License: MIT
+Project-URL: Homepage, https://github.com/griddynamics/gd-specflow
+Project-URL: Repository, https://github.com/griddynamics/gd-specflow
+Keywords: mcp,ai,code-generation,specflow,llm,claude
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: ==3.13.*
+Requires-Dist: fastmcp>=0.2.0
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: pydantic>=2.5.3
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: PyMuPDF>=1.25.0
+Requires-Dist: python-docx>=1.1.0
+Requires-Dist: python-pptx>=1.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: plyer>=2.1.0

gd_specflow-0.2.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+cli.py,sha256=NxcMAHEnM0umpq5_ZbODCLyAkT7bEtjpUERZ5WsFvAk,20270
+server.py,sha256=sx3b1f8Wjy4Ct3ggjYzvCE7ftJ8z30TDt_-WWSTeSws,24713
+schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemas/gain_json.py,sha256=7TBwMGpkhXWhgBGRuLV0kZ7XRyGDHnp-7XZubP6ebio,1809
+schemas/generation_workflow_enums.py,sha256=a45hLJbgmeebwGUllmulOudLcfrc0C3ngpwrzMur3dM,855
+schemas/specification.py,sha256=MBa8Hn4dlKAKzlEBqtMfhfQwh1dBCQ1tlRPel1471UY,777
+services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+services/archive_builder.py,sha256=fW7ACDKIPGugvjktkJC4pBmY8LKjO9gBjYgg_kha2bA,6498
+services/bundled_skills.py,sha256=WxzknWX7_7Ad3D5tYCaJseePXV2TU9NvntU8MoYWVHo,2790
+services/cli_service.py,sha256=TMF4hP57gCY8jlo6zybgDlHkwcVOHiHqnZOnZrlAiKg,9131
+services/document_reader.py,sha256=myET7r57vH4ibm0Xmc9SDGh30SN9NAFXzx1y0mi0mmU,13926
+services/file_sync.py,sha256=s_Ad12T_Rk_HIy3RQWLJvh1Y0Nzlhov21-Yf5ynoQLI,8269
+services/file_sync_orchestrator.py,sha256=VIG0oasX8EAYbuZynyiVR0VWjeioghsFzxhJvIAPYkQ,5561
+services/generation_orchestrator.py,sha256=00SozQNhQzonZFBAdK6wjIlYXgIDd9QV9prsA-md6ow,9049
+services/llm_tiers.py,sha256=Z2RAAlhETCi_efSyTHU1-Y3UOcMjVg3RcwtLTidNVG8,1368
+services/run_generation_precheck.py,sha256=gxz2elZR-TvDrU1FTyeMyAZDSGqcRxyLTl_1IUOUZzY,8309
+services/server_instructions.py,sha256=DsotO4oHoY5eBA9ofzKazlKQD7QLQU4OW7QjiNTkiZw,4261
+services/session.py,sha256=9zHIdjqC_FiJO4hcN8AY3Mra3vHZrba2lvdipE7dDJE,7761
+services/specflow_backend.py,sha256=kNtlXrNjRkJnr272rzb6uvOGNu3Ng2vG-PY0SIF6zEk,7965
+services/tool_helpers.py,sha256=s5yxVPDjlNC6zGzW-elcWMdHTj6ihJJ5PjiFBcDEss4,4096
+services/user_response.py,sha256=tQ2txv8TIyBL09IMjyJtfxFoPVnI8VE8nH8pLf13D4w,1235
+services/skills/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+services/skills/specflow-analysis/SKILL.md,sha256=e-gB_kDWFX8uQgajthPxps4nwe0VTevk-m-pK1_VGCY,27872
+services/skills/specflow-compare-variants/SKILL.md,sha256=Qip8lKxiub_uy9M18P_qjOWeyL2y8wgT7_FVTgJt8hk,9719
+services/skills/specflow-diagnose/SKILL.md,sha256=uYyZtyZ_qenZv_9avky9kQAUzucJy5Oe2JV5ygSeM3A,7224
+services/skills/specflow-planning/SKILL.md,sha256=MA6WJ-BXgpuxWVUlz2lgehp1TCXKxfwyuX0K9o6IRF4,14015
+gd_specflow-0.2.0.dist-info/METADATA,sha256=XqmLJMmHZcakYWN9qA3UUfVjVk79yGSD4tdOQhU9LqY,1098
+gd_specflow-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gd_specflow-0.2.0.dist-info/entry_points.txt,sha256=l5523E6i-dE7vtK3WoTorbZTXkSQbzrD1mLy9JB3xJk,65
+gd_specflow-0.2.0.dist-info/top_level.txt,sha256=FdqXan9EmfUaoz3P8q-vS939F4pSAY5H03ABRdnwZ_Y,28
+gd_specflow-0.2.0.dist-info/RECORD,,

gd_specflow-0.2.0.dist-info/WHEEL

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

gd_specflow-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+specflow = cli:main
+specflow-mcp = server:main

gd_specflow-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+cli
+schemas
+server
+services