agentweld 0.1.0__py3-none-any.whl

agentweld/__init__.py

@@ -0,0 +1,3 @@
+"""agentweld — Turn any MCP server into a curated, composable, A2A-ready agent."""
+
+__version__ = "0.1.0"

agentweld/cli/add.py

@@ -0,0 +1,142 @@
+"""agentweld add — add a new MCP source to an existing project."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Literal
+
+import anyio
+import typer
+
+from agentweld.config.loader import load_config
+from agentweld.config.writer import add_source
+from agentweld.models.config import SourceConfig
+from agentweld.sources.registry import get_adapter
+from agentweld.utils.console import console, make_tools_table
+from agentweld.utils.errors import AgentweldError, ConfigNotFoundError, SourceConnectionError
+
+app = typer.Typer(
+    help="Add a new MCP source to an existing agentweld project.",
+    invoke_without_command=True,
+)
+
+
+@app.command()
+def add(
+    source: str = typer.Argument(..., help="MCP server command (stdio) or URL (http)"),
+    from_: str = typer.Option("mcp", "--from", help="Source type"),
+    trust: bool = typer.Option(False, "--trust", help="Trust and execute the stdio command"),
+    config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to agentweld.yaml"),
+) -> None:
+    """Load existing agentweld.yaml, introspect new source, and append it."""
+
+    # Determine transport
+    transport: Literal["stdio", "streamable-http"] = (
+        "streamable-http" if source.startswith("http") else "stdio"
+    )
+
+    # Safety gate for stdio
+    if transport == "stdio":
+        if not trust:
+            console.print(
+                "[bold red]ERROR:[/] Spawning a stdio MCP server executes arbitrary code. "
+                "Re-run with [bold]--trust[/] to confirm.",
+                highlight=False,
+            )
+            raise typer.Exit(code=1)
+        console.print(
+            f"[bold yellow]WARNING:[/] --trust flag set. Spawning subprocess: [bold]{source}[/]",
+            highlight=False,
+        )
+
+    # Load existing config to find the yaml path
+    try:
+        cfg = load_config(config_path)
+    except ConfigNotFoundError as e:
+        console.print(f"[red]Config not found:[/] {e}")
+        raise typer.Exit(code=1)
+
+    # Resolve the actual yaml file path
+    yaml_path = _resolve_yaml_path(config_path)
+
+    # Check if source already exists
+    source_id = _derive_source_id(source)
+    existing_ids = {s.id for s in cfg.sources}
+    if source_id in existing_ids:
+        console.print(
+            f"[red]ERROR:[/] Source '[bold]{source_id}[/]' already exists in {yaml_path}. "
+            "Use a different --name or edit the file manually.",
+            highlight=False,
+        )
+        raise typer.Exit(code=1)
+
+    # Build SourceConfig
+    source_config = SourceConfig(
+        id=source_id,
+        type="mcp_server",
+        transport=transport,
+        command=source if transport == "stdio" else None,
+        url=source if transport != "stdio" else None,
+    )
+
+    # Introspect
+    console.print(f"[cyan]Connecting to[/] {source}...")
+    adapter = get_adapter(transport)
+    try:
+        tools = anyio.run(adapter.introspect, source_config)
+    except SourceConnectionError as e:
+        console.print(f"[red]Connection failed:[/] {e}")
+        raise typer.Exit(code=1)
+    except AgentweldError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Discovered {len(tools)} tools.[/]")
+    tool_rows = [
+        {
+            "name": t.name,
+            "source_id": t.source_id,
+            "description": t.description_curated,
+            "quality_score": t.quality_score,
+        }
+        for t in tools
+    ]
+    console.print(make_tools_table(tool_rows))
+
+    # Append to yaml
+    try:
+        add_source(source_config, yaml_path)
+    except ValueError as e:
+        console.print(f"[red]Failed to add source:[/] {e}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Added source '[bold]{source_id}[/]' to[/] {yaml_path}")
+
+
+def _derive_source_id(source: str) -> str:
+    """Derive a short source ID from a command or URL."""
+    parts = source.replace("https://", "").replace("http://", "").split()
+    token = parts[-1] if parts else source
+    slug = re.sub(r"[^a-z0-9]", "-", token.lower())
+    slug = re.sub(r"-+", "-", slug).strip("-")
+    segments = [s for s in slug.split("-") if len(s) > 2]
+    return segments[-1] if segments else slug[:20]
+
+
+def _resolve_yaml_path(config_path: Path | None) -> Path:
+    """Resolve path to agentweld.yaml, searching from cwd if not specified."""
+    if config_path is not None:
+        return Path(config_path)
+
+    current = Path.cwd()
+    while True:
+        candidate = current / "agentweld.yaml"
+        if candidate.exists():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+    return Path.cwd() / "agentweld.yaml"

agentweld/cli/generate.py

@@ -0,0 +1,164 @@
+"""agentweld generate — run the full pipeline and emit artifacts."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import anyio
+import typer
+
+from agentweld.composition.composer import ComposedToolSet, Composer
+from agentweld.config.loader import load_config
+from agentweld.curation.engine import CurationEngine
+from agentweld.generators.runner import run_generators
+from agentweld.models.config import AgentweldConfig, SourceConfig
+from agentweld.models.tool import ToolDefinition
+from agentweld.sources.registry import get_adapter
+from agentweld.utils.console import console
+from agentweld.utils.errors import (
+    AgentweldError,
+    ConfigNotFoundError,
+    QualityGateError,
+    SourceConnectionError,
+)
+
+app = typer.Typer(help="Run the full pipeline and generate artifacts.", invoke_without_command=True)
+
+
+@app.command()
+def generate(
+    force: bool = typer.Option(False, "--force", help="Overwrite existing artifacts"),
+    only: list[str] = typer.Option([], "--only", help="Only generate specific artifacts"),
+    config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to agentweld.yaml"),
+    output_dir: Path | None = typer.Option(
+        None, "--output-dir", "-o", help="Override output directory"
+    ),
+) -> None:
+    """Full pipeline: load config → introspect → curate → compose → generate artifacts."""
+
+    # 1. Load config
+    try:
+        cfg = load_config(config_path)
+    except ConfigNotFoundError as e:
+        console.print(f"[red]Config not found:[/] {e}")
+        console.print("[muted]Run [bold]agentweld init[/] to create an agentweld.yaml first.[/]")
+        raise typer.Exit(code=1)
+
+    if not cfg.sources:
+        console.print("[yellow]No sources configured. Nothing to generate.[/]")
+        raise typer.Exit(code=0)
+
+    # 2. Introspect all sources concurrently
+    console.print("[cyan]Introspecting sources...[/]")
+    all_tools: list[ToolDefinition] = []
+    errors: dict[str, str] = {}
+
+    async def _introspect_all() -> None:
+        async def _introspect_one(src_cfg: SourceConfig) -> None:
+            transport = src_cfg.transport or "stdio"
+            try:
+                adapter = get_adapter(transport)
+                tools = await adapter.introspect(src_cfg)
+                all_tools.extend(tools)
+                console.print(f"  [green]✓[/] {src_cfg.id}: {len(tools)} tool(s)")
+            except SourceConnectionError as e:
+                errors[src_cfg.id] = str(e)
+                console.print(f"  [red]✗[/] {src_cfg.id}: {e}")
+
+        async with anyio.create_task_group() as tg:
+            for src_cfg in cfg.sources:
+                tg.start_soon(_introspect_one, src_cfg)
+
+    anyio.run(_introspect_all)
+
+    if errors and not force:
+        console.print(
+            f"[red]ERROR:[/] {len(errors)} source(s) failed to connect. "
+            "Use [bold]--force[/] to skip failed sources.",
+            highlight=False,
+        )
+        raise typer.Exit(code=1)
+
+    if not all_tools:
+        console.print("[yellow]No tools discovered. Nothing to generate.[/]")
+        raise typer.Exit(code=0)
+
+    console.print(f"[cyan]Total tools discovered:[/] {len(all_tools)}")
+
+    # 3. Curate
+    console.print("[cyan]Running curation engine...[/]")
+    try:
+        engine = CurationEngine(cfg)
+        curated_tools = engine.run(all_tools)
+    except AgentweldError as e:
+        console.print(f"[red]Curation error:[/] {e}")
+        raise typer.Exit(code=1)
+
+    # 4. Quality gate
+    if not force:
+        try:
+            _check_quality_gate(curated_tools, cfg)
+        except QualityGateError as e:
+            console.print(f"[red]Quality gate failed:[/] {e}")
+            raise typer.Exit(code=1)
+
+    # 5. Compose
+    console.print("[cyan]Composing tool namespace...[/]")
+    composed: ComposedToolSet | None = None
+    try:
+        composer = Composer(cfg)
+        composed = composer.compose(curated_tools)
+    except AgentweldError as e:
+        console.print(f"[red]Composition error:[/] {e}")
+        raise typer.Exit(code=1)
+
+    # 6. Generate artifacts
+    out_dir = output_dir or Path(cfg.generate.output_dir)
+    if not force and out_dir.exists() and any(out_dir.iterdir()):
+        console.print(
+            f"[red]ERROR:[/] Output directory [bold]{out_dir}[/] already exists and is non-empty. "
+            "Use [bold]--force[/] to overwrite.",
+            highlight=False,
+        )
+        raise typer.Exit(code=1)
+
+    console.print(f"[cyan]Generating artifacts in[/] {out_dir}...")
+    try:
+        artifacts = run_generators(
+            cfg=cfg,
+            tools=curated_tools,
+            composed=composed,
+            output_dir=out_dir,
+            only=only or None,
+            force=force,
+        )
+        _print_artifact_summary(artifacts, out_dir)
+    except AgentweldError as e:
+        console.print(f"[red]Generator error:[/] {e}")
+        raise typer.Exit(code=1)
+
+
+def _check_quality_gate(tools: list[ToolDefinition], cfg: AgentweldConfig) -> None:
+    """Raise QualityGateError if any tool is below the block_below threshold."""
+    block_below = cfg.quality.block_below
+    blocking = [t for t in tools if t.quality_score is not None and t.quality_score < block_below]
+    if blocking:
+        names = ", ".join(t.name for t in blocking[:5])
+        if len(blocking) > 5:
+            names += f" ... and {len(blocking) - 5} more"
+        raise QualityGateError(
+            f"{len(blocking)} tool(s) below quality threshold "
+            f"({block_below:.2f}): {names}. "
+            "Fix the tools or run with --force to bypass."
+        )
+
+
+def _print_artifact_summary(artifacts: list[Path], output_dir: Path) -> None:
+    """Print a summary of generated artifact files."""
+    console.print(f"\n[green]Generated {len(artifacts)} artifact(s) in[/] {output_dir}:")
+    for path in sorted(artifacts):
+        try:
+            rel = path.relative_to(output_dir)
+        except ValueError:
+            rel = path
+        console.print(f"  [muted]•[/] {rel}")

agentweld/cli/init.py

@@ -0,0 +1,197 @@
+"""agentweld init — scaffold a new project from an MCP source."""
+
+from __future__ import annotations
+
+import datetime
+import re
+from pathlib import Path
+from typing import Literal
+
+import anyio
+import typer
+
+from agentweld.config.writer import write_new
+from agentweld.models.config import (
+    AgentConfig,
+    AgentweldConfig,
+    CompositionConfig,
+    EnrichmentConfig,
+    GenerateConfig,
+    MetaConfig,
+    QualityConfig,
+    SourceConfig,
+    ToolsConfig,
+)
+from agentweld.sources.registry import get_adapter
+from agentweld.utils.console import console, make_tools_table
+from agentweld.utils.errors import AgentweldError, SourceConnectionError
+
+app = typer.Typer(
+    help="Initialize a new agentweld project from an MCP source.",
+    invoke_without_command=True,
+)
+
+
+@app.command()
+def init(
+    source: str = typer.Argument(..., help="MCP server command (stdio) or URL (http)"),
+    from_: str = typer.Option("mcp", "--from", help="Source type"),
+    trust: bool = typer.Option(False, "--trust", help="Trust and execute the stdio command"),
+    output: Path = typer.Option(Path("."), "--output", "-o", help="Output directory"),
+    name: str | None = typer.Option(None, "--name", "-n", help="Agent name"),
+) -> None:
+    """Connect to MCP server, introspect tools, scaffold agentweld.yaml."""
+
+    # Determine transport
+    transport: Literal["stdio", "streamable-http"] = (
+        "streamable-http" if source.startswith("http") else "stdio"
+    )
+
+    # Safety gate for stdio
+    if transport == "stdio":
+        if not trust:
+            console.print(
+                "[bold red]ERROR:[/] Spawning a stdio MCP server executes arbitrary code. "
+                "Re-run with [bold]--trust[/] to confirm.",
+                highlight=False,
+            )
+            raise typer.Exit(code=1)
+        console.print(
+            f"[bold yellow]WARNING:[/] --trust flag set. Spawning subprocess: [bold]{source}[/]",
+            highlight=False,
+        )
+
+    # Build a minimal SourceConfig
+    source_id = _derive_source_id(source)
+    source_config = SourceConfig(
+        id=source_id,
+        type="mcp_server",
+        transport=transport,
+        command=source if transport == "stdio" else None,
+        url=source if transport != "stdio" else None,
+    )
+
+    # Introspect
+    console.print(f"[cyan]Connecting to[/] {source}...")
+    adapter = get_adapter(transport)
+    try:
+        tools = anyio.run(adapter.introspect, source_config)
+    except SourceConnectionError as e:
+        console.print(f"[red]Connection failed:[/] {e}")
+        raise typer.Exit(code=1)
+    except AgentweldError as e:
+        console.print(f"[red]Error:[/] {e}")
+        raise typer.Exit(code=1)
+
+    console.print(f"[green]Discovered {len(tools)} tools.[/]")
+    tool_rows = [
+        {
+            "name": t.name,
+            "source_id": t.source_id,
+            "description": t.description_curated,
+            "quality_score": t.quality_score,
+        }
+        for t in tools
+    ]
+    console.print(make_tools_table(tool_rows))
+
+    # Build config
+    agent_name = name or _derive_agent_name(source)
+    config = _build_initial_config(agent_name, source_config)
+
+    # Write agentweld.yaml
+    output.mkdir(parents=True, exist_ok=True)
+    yaml_path = output / "agentweld.yaml"
+    write_new(config, yaml_path)
+    console.print(f"[green]Created[/] {yaml_path}")
+
+
+def _derive_source_id(source: str) -> str:
+    """Derive a short source ID from a command or URL.
+
+    Examples:
+        "npx @modelcontextprotocol/server-github" -> "github"
+        "docker run -i --rm -e TOKEN ghcr.io/github/github-mcp-server" -> "github"
+        "https://api.example.com/mcp" -> "example"
+    """
+    parts = source.replace("https://", "").replace("http://", "").split()
+    # For docker commands, find the image argument (last non-flag token after "run")
+    if parts and parts[0] == "docker":
+        image = _extract_docker_image(parts)
+        token = image.split("/")[-1] if image else parts[-1]
+    else:
+        token = parts[-1] if parts else source
+    slug = re.sub(r"[^a-z0-9]", "-", token.lower())
+    slug = re.sub(r"-+", "-", slug).strip("-")
+    segments = [s for s in slug.split("-") if len(s) > 2]
+    # For docker images and similar "name-type-suffix" patterns, prefer the first
+    # meaningful segment (e.g. "github-mcp-server" -> "github").
+    # For npx packages like "server-github", prefer the last (-> "github").
+    if parts and parts[0] == "docker":
+        return segments[0] if segments else slug[:20]
+    return segments[-1] if segments else slug[:20]
+
+
+def _extract_docker_image(parts: list[str]) -> str:
+    """Return the image name from a 'docker run ...' token list.
+
+    Skips flags (starting with '-') and their values for known value-taking flags.
+    """
+    _VALUE_FLAGS = {
+        "-e",
+        "--env",
+        "-p",
+        "--publish",
+        "--name",
+        "-v",
+        "--volume",
+        "--network",
+        "-u",
+        "--user",
+        "--entrypoint",
+        "-w",
+        "--workdir",
+    }
+    skip_next = False
+    past_run = False
+    for token in parts:
+        if token == "run":
+            past_run = True
+            continue
+        if not past_run:
+            continue
+        if skip_next:
+            skip_next = False
+            continue
+        if token in _VALUE_FLAGS:
+            skip_next = True
+            continue
+        if token.startswith("-"):
+            continue
+        # First non-flag token after 'run' is the image
+        return token
+    return ""
+
+
+def _derive_agent_name(source: str) -> str:
+    sid = _derive_source_id(source)
+    return f"{sid.title()} Agent"
+
+
+def _build_initial_config(agent_name: str, source: SourceConfig) -> AgentweldConfig:
+    now = datetime.datetime.now(tz=datetime.UTC).replace(microsecond=0)
+    return AgentweldConfig(
+        meta=MetaConfig(created_at=now, updated_at=now),
+        agent=AgentConfig(
+            name=agent_name,
+            description=f"Agent powered by {source.id}",
+            version="0.1.0",
+        ),
+        sources=[source],
+        tools=ToolsConfig(),
+        quality=QualityConfig(),
+        enrichment=EnrichmentConfig(),
+        composition=CompositionConfig(),
+        a2a=None,
+        generate=GenerateConfig(),
+    )

agentweld/cli/inspect.py

@@ -0,0 +1,171 @@
+"""agentweld inspect — inspect tools from configured MCP sources."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+
+import anyio
+import typer
+
+from agentweld.config.loader import load_config
+from agentweld.models.config import AgentweldConfig, SourceConfig
+from agentweld.models.tool import ToolDefinition
+from agentweld.sources.registry import get_adapter
+from agentweld.utils.console import console, make_sources_table, make_tools_table
+from agentweld.utils.errors import ConfigNotFoundError, SourceConnectionError
+
+# STUB: replace with real import after phase-4/5 merge
+try:
+    from agentweld.composition.composer import ComposedToolSet, Composer
+    from agentweld.curation.engine import CurationEngine
+except ImportError:
+    CurationEngine = None  # type: ignore[assignment,misc]
+    Composer = None  # type: ignore[assignment,misc]
+    ComposedToolSet = None  # type: ignore[assignment,misc]
+
+app = typer.Typer(help="Inspect tools from configured MCP sources.", invoke_without_command=True)
+
+
+@app.command()
+def inspect(
+    source: bool = typer.Option(False, "--source", help="Show raw tools from each source"),
+    final: bool = typer.Option(False, "--final", help="Show post-curation tools"),
+    conflicts: bool = typer.Option(False, "--conflicts", help="Show naming conflicts"),
+    config_path: Path | None = typer.Option(None, "--config", "-c", help="Path to agentweld.yaml"),
+) -> None:
+    """Inspect and display tools from all configured MCP sources."""
+
+    try:
+        cfg = load_config(config_path)
+    except ConfigNotFoundError as e:
+        console.print(f"[red]Config not found:[/] {e}")
+        raise typer.Exit(code=1)
+
+    if not cfg.sources:
+        console.print("[yellow]No sources configured in agentweld.yaml.[/]")
+        raise typer.Exit(code=0)
+
+    # Introspect all sources concurrently
+    all_tools: list[ToolDefinition] = []
+    tools_by_source: dict[str, list[ToolDefinition]] = {}
+    errors: dict[str, str] = {}
+
+    async def _introspect_all() -> None:
+        async def _introspect_one(src_cfg: SourceConfig) -> None:
+            transport = src_cfg.transport or "stdio"
+            try:
+                adapter = get_adapter(transport)
+                tools = await adapter.introspect(src_cfg)
+                tools_by_source[src_cfg.id] = tools
+                all_tools.extend(tools)
+            except SourceConnectionError as e:
+                errors[src_cfg.id] = str(e)
+                tools_by_source[src_cfg.id] = []
+
+        async with anyio.create_task_group() as tg:
+            for src_cfg in cfg.sources:
+                tg.start_soon(_introspect_one, src_cfg)
+
+    anyio.run(_introspect_all)
+
+    # Report connection errors
+    for src_id, err in errors.items():
+        console.print(f"[red]ERROR[/] [{src_id}]: {err}")
+
+    if not source and not final and not conflicts:
+        # Default: show summary table
+        _show_summary(tools_by_source)
+        return
+
+    if source:
+        _show_raw_tools(tools_by_source)
+
+    if conflicts:
+        _show_conflicts(all_tools)
+
+    if final:
+        _show_final_tools(all_tools, cfg)
+
+
+def _show_summary(tools_by_source: dict[str, list[ToolDefinition]]) -> None:
+    """Display a summary table: one row per source."""
+    rows = []
+    for src_id, tools in tools_by_source.items():
+        scored = [t for t in tools if t.quality_score is not None]
+        scores = [t.quality_score for t in scored if t.quality_score is not None]
+        avg_quality: float | None = sum(scores) / len(scores) if scores else None
+        rows.append({"source": src_id, "tools": len(tools), "avg_quality": avg_quality})
+    console.print(make_sources_table(rows))
+
+
+def _show_raw_tools(tools_by_source: dict[str, list[ToolDefinition]]) -> None:
+    """Display raw (pre-curation) tools per source."""
+    for src_id, tools in tools_by_source.items():
+        console.print(f"\n[bold cyan]Source: {src_id}[/] ({len(tools)} tools)")
+        if tools:
+            tool_rows = [
+                {
+                    "name": t.name,
+                    "source_id": t.source_id,
+                    "description": t.description_original,
+                    "quality_score": t.quality_score,
+                }
+                for t in tools
+            ]
+            console.print(make_tools_table(tool_rows, show_quality=True))
+        else:
+            console.print("[muted]  (no tools)[/]")
+
+
+def _show_conflicts(all_tools: list[ToolDefinition]) -> None:
+    """Detect and display tools with duplicate names across sources."""
+    name_to_tools: dict[str, list[ToolDefinition]] = defaultdict(list)
+    for t in all_tools:
+        name_to_tools[t.name].append(t)
+
+    conflicts_found = {name: tools for name, tools in name_to_tools.items() if len(tools) > 1}
+
+    if not conflicts_found:
+        console.print("[green]No naming conflicts detected.[/]")
+        return
+
+    console.print(f"[bold yellow]Found {len(conflicts_found)} naming conflict(s):[/]")
+    for name, tools in conflicts_found.items():
+        sources_list = ", ".join(t.source_id for t in tools)
+        console.print(f"  [bold]{name}[/] — appears in: {sources_list}")
+
+
+def _show_final_tools(all_tools: list[ToolDefinition], cfg: AgentweldConfig) -> None:
+    """Display post-curation tools (requires Phase 4 CurationEngine)."""
+    if CurationEngine is None:
+        console.print(
+            "[yellow]WARNING:[/] CurationEngine not available (Phase 4 not merged). "
+            "Showing raw tools instead.",
+            highlight=False,
+        )
+        tool_rows = [
+            {
+                "name": t.name,
+                "source_id": t.source_id,
+                "description": t.description_curated,
+                "quality_score": t.quality_score,
+            }
+            for t in all_tools
+        ]
+        console.print(make_tools_table(tool_rows, show_quality=True))
+        return
+
+    engine = CurationEngine(cfg)
+    curated = engine.run(all_tools)
+    tool_rows = [
+        {
+            "name": t.name,
+            "source_id": t.source_id,
+            "description": t.description_curated,
+            "quality_score": t.quality_score,
+        }
+        for t in curated
+    ]
+    console.print(f"\n[bold cyan]Post-curation tools[/] ({len(curated)} tools)")
+    console.print(make_tools_table(tool_rows, show_quality=True))