abelworkflow 1.0.0-rc.1 → 1.1.0

package/skills/prompt-enhancer/scripts/enhance.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""Prompt Enhancer CLI for OpenAI-compatible endpoints."""
-
-import argparse
-import os
-import sys
-from typing import Tuple
-
-from _dotenv import load_dotenv
-
-load_dotenv()
-
-
-SYSTEM_PROMPT = """
-You are an expert Prompt Engineer for Coding Agents (Claude Code, Codex, Gemini CLI).
-Your goal is to rewrite the user's raw input into a structured, high-context prompt that maximizes the agent's effectiveness.
-
-Guidelines:
-1. Structure: Use a clear Markdown structure with headers.
-2. Chain of Thought: Explicitly ask the agent to "Think step-by-step" or "Analyze the file structure first".
-3. Context: If the user's prompt is vague, add placeholders like "[Insert relevant file(s)]" or "[Specify tech stack]" in the rewritten prompt, or simply infer them if obvious.
-4. Format:
-   - Context: What is the current state? What files are involved?
-   - Objective: What exactly should be done?
-   - Constraints: specific libraries, coding styles, or "no placeholders".
-   - Response Format: e.g., "Return only the code block" or "Explain step-by-step".
-
-Output Template:
-
-# Context
-[Refined context description]
-
-# Objective
-[Precise task definition]
-
-# Step-by-Step Instructions
-1. [Step 1]
-2. [Step 2]
-...
-
-# Constraints
-- [Constraint 1]
-- [Constraint 2]
-"""
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        prog="prompt_enhancer_entry.py",
-        description="Enhance a prompt through a third-party OpenAI-compatible API.",
-    )
-    parser.add_argument("--url", dest="api_url", help="Third-party OpenAI-compatible base URL.")
-    parser.add_argument("--api-key", dest="api_key", help="Third-party OpenAI-compatible API key.")
-    parser.add_argument("--model", help="Model name on the third-party endpoint.")
-    parser.add_argument("--prompt", help="Prompt text to enhance.")
-    parser.add_argument("prompt_parts", nargs="*", help=argparse.SUPPRESS)
-    return parser.parse_args()
-
-
-def debug_enabled() -> bool:
-    value = os.environ.get("PE_DEBUG", "")
-    return value.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def resolve_prompt(args: argparse.Namespace) -> str:
-    prompt = args.prompt.strip() if args.prompt else ""
-    if prompt:
-        return prompt
-    joined = " ".join(args.prompt_parts).strip()
-    if joined:
-        return joined
-    raise ValueError("Missing prompt. Pass --prompt \"...\" or a positional prompt.")
-
-
-def resolve_config(args: argparse.Namespace) -> Tuple[str, str, str]:
-    api_url = (args.api_url or os.environ.get("PE_API_URL", "")).strip()
-    api_key = (args.api_key or os.environ.get("PE_API_KEY", "")).strip()
-    model = (args.model or os.environ.get("PE_MODEL", "")).strip()
-
-    missing = []
-    if not api_url:
-        missing.append("url")
-    if not api_key:
-        missing.append("apiKey")
-    if not model:
-        missing.append("model")
-    if missing:
-        raise ValueError(
-            "Missing third-party OpenAI-compatible config: "
-            + ", ".join(missing)
-            + ". If these fields are unavailable, use the current agent directly."
-        )
-    return api_url, api_key, model
-
-
-def _extract_response_text(response) -> str:
-    content = response.choices[0].message.content
-    if isinstance(content, str):
-        return content
-    if content is None:
-        raise RuntimeError("The provider returned an empty response.")
-    return str(content)
-
-
-def enhance_with_openai(prompt: str, api_key: str, model: str, api_url: str = "") -> str:
-    try:
-        from openai import OpenAI
-    except ImportError:
-        raise RuntimeError("Missing dependency: openai. Install dependencies for the configured provider.") from None
-
-    kwargs = {"api_key": api_key}
-    if api_url:
-        kwargs["base_url"] = api_url
-    client = OpenAI(**kwargs)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": prompt},
-        ],
-    )
-    return _extract_response_text(response)
-
-
-def main() -> None:
-    try:
-        args = parse_args()
-        prompt = resolve_prompt(args)
-        api_url, api_key, model = resolve_config(args)
-        print(enhance_with_openai(prompt, api_key, model, api_url))
-    except Exception as exc:
-        if debug_enabled():
-            print(f"Error: {exc}", file=sys.stderr)
-        else:
-            msg = str(exc)
-            if "Missing third-party OpenAI-compatible config" in msg:
-                print("Missing API configuration. Use the current agent directly instead, or set PE_API_URL, PE_API_KEY, PE_MODEL.", file=sys.stderr)
-            else:
-                print(msg, file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

package/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py

@@ -1,238 +0,0 @@
-#!/usr/bin/env python3
-"""Cross-platform bootstrap entrypoint for Prompt Enhancer."""
-
-import os
-import re
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-from typing import List, Optional
-
-from _dotenv import load_dotenv
-
-
-ROOT_DIR = Path(__file__).resolve().parent.parent
-REQ_FILE = ROOT_DIR / "requirements.txt"
-CLI_PY = ROOT_DIR / "scripts" / "enhance.py"
-
-
-def debug_enabled() -> bool:
-    value = os.environ.get("PE_DEBUG", "")
-    return value.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def venv_dir() -> Path:
-    configured = os.environ.get("PROMPT_ENHANCER_VENV_DIR")
-    if not configured:
-        return ROOT_DIR / ".venv"
-    dir_path = Path(configured).expanduser()
-    if dir_path.is_absolute():
-        return dir_path
-    return ROOT_DIR / dir_path
-
-
-def venv_python() -> Optional[Path]:
-    dir_path = venv_dir()
-    candidates = []
-    if sys.platform == "win32":
-        candidates.extend(
-            [
-                dir_path / "Scripts" / "python.exe",
-                dir_path / "Scripts" / "python",
-            ]
-        )
-    candidates.append(dir_path / "bin" / "python")
-    for candidate in candidates:
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def python_spec() -> Optional[str]:
-    for name in ("PROMPT_ENHANCER_PYTHON", "AGENTS_SKILLS_PYTHON"):
-        value = os.environ.get(name)
-        if value:
-            return value
-    return None
-
-
-def has_uv() -> bool:
-    return shutil.which("uv") is not None
-
-
-def find_system_python() -> Optional[str]:
-    env_python = os.environ.get("AGENTS_SKILLS_PYTHON")
-    if env_python and Path(env_python).is_file():
-        return env_python
-    if sys.executable and Path(sys.executable).is_file():
-        return sys.executable
-    for command in ("python3", "python"):
-        found = shutil.which(command)
-        if found:
-            return found
-    return None
-
-
-def create_venv() -> None:
-    dir_path = venv_dir()
-    if has_uv():
-        command = ["uv", "venv"]
-        spec = python_spec()
-        if spec:
-            command.extend(["--python", spec])
-        command.append(str(dir_path))
-        subprocess.run(command, check=True)
-        return
-    python_bin = find_system_python()
-    if not python_bin:
-        print("Error: No usable uv or python found. Cannot create virtual environment.", file=sys.stderr)
-        sys.exit(1)
-    subprocess.run([python_bin, "-m", "venv", str(dir_path)], check=True)
-
-
-def first_non_empty(*values: str) -> str:
-    for value in values:
-        stripped = value.strip()
-        if stripped:
-            return stripped
-    return ""
-
-
-def argv_value(flag: str, argv: Optional[List[str]] = None) -> str:
-    argv = sys.argv[1:] if argv is None else argv
-    for index, token in enumerate(argv):
-        if token == flag:
-            if index + 1 < len(argv):
-                return argv[index + 1].strip()
-            return ""
-        if token.startswith(f"{flag}="):
-            return token.split("=", 1)[1].strip()
-    return ""
-
-
-def resolved_provider(argv: Optional[List[str]] = None) -> Optional[str]:
-    argv = sys.argv[1:] if argv is None else argv
-    api_url = first_non_empty(argv_value("--url", argv), os.environ.get("PE_API_URL", ""))
-    api_key = first_non_empty(argv_value("--api-key", argv), os.environ.get("PE_API_KEY", ""))
-    model = first_non_empty(argv_value("--model", argv), os.environ.get("PE_MODEL", ""))
-
-    if api_url and api_key and model:
-        return "openai"
-    return None
-
-
-def required_modules() -> List[str]:
-    return ["openai"] if resolved_provider() == "openai" else []
-
-
-def install_targets(modules: List[str]) -> List[str]:
-    if not REQ_FILE.is_file():
-        return modules
-
-    requirements = {}
-    for raw_line in REQ_FILE.read_text(encoding="utf-8").splitlines():
-        line = raw_line.split("#", 1)[0].strip()
-        if not line:
-            continue
-        package = re.split(r"[<>=!~\\[; ]", line, maxsplit=1)[0].strip().lower()
-        if package:
-            requirements[package] = line
-
-    return [requirements.get(module.lower(), module) for module in modules]
-
-
-def has_required_modules(python_bin: str, modules: List[str]) -> bool:
-    if not modules:
-        return True
-    check = subprocess.run(
-        [python_bin, "-c", "; ".join(f"import {module}" for module in modules)],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    return check.returncode == 0
-
-
-def install_deps(python_bin: Path, modules: Optional[List[str]] = None) -> None:
-    modules = required_modules() if modules is None else modules
-    if not modules:
-        return
-    targets = install_targets(modules)
-    if has_required_modules(str(python_bin), modules):
-        return
-    try:
-        kwargs = {
-            "check": True,
-            "stdout": subprocess.DEVNULL,
-            "stderr": subprocess.PIPE,
-            "text": True,
-        }
-        if has_uv():
-            subprocess.run(["uv", "pip", "install", "--python", str(python_bin), *targets], **kwargs)
-            return
-        subprocess.run([str(python_bin), "-m", "pip", "install", *targets], **kwargs)
-    except subprocess.CalledProcessError as exc:
-        if debug_enabled():
-            details = (exc.stderr or "").strip()
-            if details:
-                print(details, file=sys.stderr)
-            print(
-                "Warning: Failed to install prompt enhancer dependencies; continuing with existing environment.",
-                file=sys.stderr,
-            )
-
-
-def validate_venv_dir() -> None:
-    dir_path = venv_dir()
-    if dir_path.exists() and not dir_path.is_dir():
-        print(f"Error: {dir_path} exists but is not a directory.", file=sys.stderr)
-        sys.exit(1)
-    if dir_path.is_dir() and not (dir_path / "pyvenv.cfg").exists() and venv_python() is None:
-        print(f"Error: {dir_path} exists but is not a valid venv.", file=sys.stderr)
-        sys.exit(1)
-
-
-def should_passthrough_cli() -> bool:
-    return len(sys.argv) < 2
-
-
-def passthrough_python() -> Optional[str]:
-    if sys.executable and Path(sys.executable).is_file():
-        return sys.executable
-    return find_system_python()
-
-
-def runtime_python() -> str:
-    modules = required_modules()
-    current_python = passthrough_python()
-    if current_python and has_required_modules(current_python, modules):
-        return current_python
-
-    validate_venv_dir()
-    python_bin = venv_python()
-    if python_bin is None:
-        create_venv()
-        python_bin = venv_python()
-        if python_bin is None:
-            print("Error: Failed to locate python in venv after creation.", file=sys.stderr)
-            sys.exit(1)
-    install_deps(python_bin, modules)
-    return str(python_bin)
-
-
-def main() -> None:
-    if should_passthrough_cli():
-        python_bin = passthrough_python()
-        if not python_bin:
-            print("Error: No usable python found for CLI usage output.", file=sys.stderr)
-            sys.exit(1)
-        result = subprocess.run([python_bin, str(CLI_PY)] + sys.argv[1:])
-        sys.exit(result.returncode)
-    load_dotenv()
-    python_bin = runtime_python()
-    result = subprocess.run([python_bin, str(CLI_PY)] + sys.argv[1:])
-    sys.exit(result.returncode)
-
-
-if __name__ == "__main__":
-    main()