sycommon-python-lib 0.2.6a4__py3-none-any.whl → 0.2.6a6__py3-none-any.whl

sycli/acp/__init__.py

@@ -0,0 +1,48 @@
+"""ACP (Agent Communication Protocol) support for sycli.
+
+Dynamically exposes local CLI tools as ACP agents.
+"""
+
+# Patch uvicorn config type aliases for compatibility with uvicorn>=0.34
+# acp-sdk uses uvicorn.config.LoopSetupType etc. which were removed in uvicorn 0.48+
+import uvicorn.config as _uvicorn_config
+
+_TYPE_ALIASES = (
+    "LoopSetupType",
+    "HTTPProtocolType",
+    "WSProtocolType",
+    "LifespanType",
+    "InterfaceType",
+)
+for _alias in _TYPE_ALIASES:
+    if not hasattr(_uvicorn_config, _alias):
+        setattr(_uvicorn_config, _alias, str)
+
+if not hasattr(_uvicorn_config, "LOGGING_CONFIG"):
+    _uvicorn_config.LOGGING_CONFIG = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {},
+        "handlers": {},
+        "loggers": {},
+    }
+
+del _uvicorn_config, _TYPE_ALIASES, _alias
+
+from sycli.acp.config import ACPConfig, ToolArgument, ToolDef
+from sycli.acp.executor import build_cli_command, execute_command, stream_command
+from sycli.acp.registry import CLIToolAgent, build_agents
+from sycli.acp.server import create_acp_server, run_acp_server
+
+__all__ = [
+    "ACPConfig",
+    "CLIToolAgent",
+    "ToolArgument",
+    "ToolDef",
+    "build_agents",
+    "build_cli_command",
+    "create_acp_server",
+    "execute_command",
+    "run_acp_server",
+    "stream_command",
+]

sycli/acp/config.py

@@ -0,0 +1,112 @@
+"""ACP configuration models.
+
+Defines the Pydantic models for declaring which CLI tools to expose
+as ACP agents. Configuration is loaded from a YAML or JSON file.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ToolArgument(BaseModel):
+    """Definition of a named argument that the CLI tool accepts."""
+
+    name: str = Field(description="Argument name (used for key=value parsing)")
+    description: str = Field(default="", description="Human-readable description")
+    required: bool = Field(default=False, description="Whether this argument is required")
+    default: str | None = Field(default=None, description="Default value if not provided")
+    flag: str | None = Field(
+        default=None,
+        description="CLI flag (e.g. '--path', '-v'); None means positional",
+    )
+    separator: str = Field(
+        default=" ",
+        description="Separator between flag and value: ' ' for '--flag value', '=' for '--flag=value'",
+    )
+
+
+class ToolDef(BaseModel):
+    """Definition of a single CLI tool to expose as an ACP agent."""
+
+    name: str = Field(description="ACP agent name")
+    command: str = Field(description="The actual CLI command to run")
+    description: str = Field(default="", description="Agent description for ACP discovery")
+    args: list[str] = Field(default_factory=list, description="Fixed arguments always appended")
+    tool_args: list[ToolArgument] = Field(
+        default_factory=list, description="Dynamic arguments mapped from ACP message input"
+    )
+    timeout: int = Field(default=120, description="Execution timeout in seconds")
+    working_dir: str | None = Field(default=None, description="Override working directory")
+    env: dict[str, str] = Field(default_factory=dict, description="Extra environment variables")
+    stream_output: bool = Field(default=True, description="Stream stdout line-by-line")
+    input_mode: str = Field(
+        default="args",
+        description="How to pass input: 'args' (parse into CLI args) | 'stdin' (pipe to stdin)",
+    )
+    output_content_type: str = Field(
+        default="text/plain", description="ACP content type for output"
+    )
+    allowed_exit_codes: list[int] = Field(
+        default_factory=lambda: [0], description="Exit codes considered success"
+    )
+
+
+class ACPConfig(BaseModel):
+    """Root ACP server configuration."""
+
+    host: str = Field(default="127.0.0.1", description="Server bind host")
+    port: int = Field(default=8100, description="Server bind port")
+    tools: list[ToolDef] = Field(default_factory=list, description="Registered CLI tools")
+    global_timeout: int = Field(default=300, description="Global maximum execution timeout")
+    max_output_bytes: int = Field(
+        default=100_000, description="Maximum output size in bytes (matches sandbox.py)"
+    )
+
+    @classmethod
+    def load(cls, path: Path) -> ACPConfig:
+        """Load ACP configuration from a YAML or JSON file.
+
+        Args:
+            path: Path to the configuration file.
+
+        Returns:
+            Parsed ACPConfig instance.
+
+        Raises:
+            FileNotFoundError: If the config file doesn't exist.
+            ValueError: If the file cannot be parsed.
+        """
+        if not path.exists():
+            raise FileNotFoundError(f"ACP config file not found: {path}")
+
+        text = path.read_text(encoding="utf-8")
+
+        if path.suffix in (".yaml", ".yml"):
+            try:
+                data = yaml.safe_load(text)
+            except yaml.YAMLError as e:
+                raise ValueError(f"Failed to parse YAML config: {e}") from e
+        elif path.suffix == ".json":
+            try:
+                data = json.loads(text)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Failed to parse JSON config: {e}") from e
+        else:
+            # Try YAML first, then JSON
+            try:
+                data = yaml.safe_load(text)
+            except yaml.YAMLError:
+                try:
+                    data = json.loads(text)
+                except json.JSONDecodeError as e:
+                    raise ValueError(f"Failed to parse config file: {e}") from e
+
+        if not isinstance(data, dict):
+            raise ValueError("Config file must contain a mapping (dict)")
+
+        return cls.model_validate(data)

sycli/acp/executor.py

@@ -0,0 +1,332 @@
+"""Async subprocess executor for ACP tool agents.
+
+Provides command execution with process isolation, timeout handling,
+output truncation, and line-by-line streaming — reusing patterns from
+sycommon's sandbox service.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import signal
+import sys
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from sycli.acp.config import ToolDef
+
+# Process group isolation on Unix
+_SUBPROCESS_NEW_SESSION = sys.platform != "win32"
+
+# Maximum output size per stream (matches sandbox.py)
+MAX_OUTPUT_BYTES = 100_000
+
+
+class ExecutionResult(BaseModel):
+    """Result of a CLI command execution."""
+
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+    truncated: bool = False
+    timed_out: bool = False
+
+
+def _kill_process_tree(process: asyncio.subprocess.Process) -> None:
+    """Kill a process and its entire process group.
+
+    Mirrors sandbox.py's _kill_process_tree pattern.
+    """
+    try:
+        if sys.platform == "win32":
+            process.kill()
+        else:
+            pgid = os.getpgid(process.pid)
+            os.killpg(pgid, signal.SIGKILL)
+    except (ProcessLookupError, PermissionError, OSError):
+        try:
+            process.kill()
+        except ProcessLookupError:
+            pass
+
+
+def _truncate_output(output: str, max_bytes: int = MAX_OUTPUT_BYTES) -> tuple[str, bool]:
+    """Truncate output to max_bytes, returning (truncated_output, was_truncated)."""
+    encoded = output.encode("utf-8", errors="replace")
+    if len(encoded) <= max_bytes:
+        return output, False
+    truncated = encoded[:max_bytes].decode("utf-8", errors="replace")
+    return truncated + f"\n... (truncated, {len(encoded)} bytes total)", True
+
+
+async def execute_command(
+    command: str,
+    *,
+    cwd: str | None = None,
+    timeout: int = 120,
+    env: dict[str, str] | None = None,
+    max_output_bytes: int = MAX_OUTPUT_BYTES,
+    stdin_input: str | None = None,
+) -> ExecutionResult:
+    """Execute a CLI command asynchronously.
+
+    Mirrors sandbox.py execute endpoint logic:
+    - asyncio.create_subprocess_shell with process group isolation
+    - Timeout with process tree kill
+    - Output truncation at max_output_bytes
+
+    Args:
+        command: Shell command string to execute.
+        cwd: Working directory for the command.
+        timeout: Maximum execution time in seconds.
+        env: Additional environment variables (merged with os.environ).
+        max_output_bytes: Maximum output size before truncation.
+        stdin_input: Optional text to pipe to stdin.
+
+    Returns:
+        ExecutionResult with stdout, stderr, exit_code, and status flags.
+    """
+    full_env = None
+    if env:
+        full_env = {**os.environ, **env}
+
+    stdin_data = stdin_input.encode("utf-8") if stdin_input else None
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.PIPE if stdin_data else asyncio.subprocess.DEVNULL,
+        start_new_session=_SUBPROCESS_NEW_SESSION,
+        cwd=cwd,
+        env=full_env,
+    )
+
+    timed_out = False
+    try:
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            process.communicate(input=stdin_data),
+            timeout=timeout,
+        )
+    except asyncio.TimeoutError:
+        _kill_process_tree(process)
+        try:
+            await process.wait()
+        except Exception:
+            pass
+        timed_out = True
+        stdout_bytes = b""
+        stderr_bytes = b""
+
+    stdout_raw = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+    stderr_raw = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+
+    stdout, stdout_truncated = _truncate_output(stdout_raw, max_output_bytes)
+    stderr, stderr_truncated = _truncate_output(stderr_raw, max_output_bytes)
+
+    return ExecutionResult(
+        stdout=stdout,
+        stderr=stderr,
+        exit_code=process.returncode if process.returncode is not None else -1,
+        truncated=stdout_truncated or stderr_truncated,
+        timed_out=timed_out,
+    )
+
+
+async def stream_command(
+    command: str,
+    *,
+    cwd: str | None = None,
+    timeout: int = 120,
+    env: dict[str, str] | None = None,
+    max_output_bytes: int = MAX_OUTPUT_BYTES,
+) -> AsyncGenerator[str, None]:
+    """Execute a CLI command and yield stdout lines as they arrive.
+
+    For ACP stream mode: each yielded line becomes a MessagePart.
+    Uses asyncio.create_subprocess_shell with stdout=PIPE and
+    iterates process.stdout line by line.
+
+    Args:
+        command: Shell command string to execute.
+        cwd: Working directory for the command.
+        timeout: Maximum execution time in seconds.
+        env: Additional environment variables.
+        max_output_bytes: Maximum total output before stopping.
+
+    Yields:
+        Each line from stdout as a string.
+    """
+    full_env = None
+    if env:
+        full_env = {**os.environ, **env}
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        start_new_session=_SUBPROCESS_NEW_SESSION,
+        cwd=cwd,
+        env=full_env,
+    )
+
+    total_bytes = 0
+    try:
+        try:
+            async with asyncio.timeout(timeout):
+                if process.stdout is not None:
+                    async for raw_line in process.stdout:
+                        line = raw_line.decode("utf-8", errors="replace")
+                        total_bytes += len(raw_line)
+                        if total_bytes > max_output_bytes:
+                            yield "... (output truncated)"
+                            break
+                        yield line
+        except asyncio.TimeoutError:
+            _kill_process_tree(process)
+            yield f"\n... (timed out after {timeout}s)"
+
+        # Wait for process to finish
+        try:
+            await asyncio.wait_for(process.wait(), timeout=5)
+        except asyncio.TimeoutError:
+            _kill_process_tree(process)
+    finally:
+        try:
+            if process.returncode is None:
+                _kill_process_tree(process)
+                try:
+                    await process.wait()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+
+def build_cli_command(tool_def: ToolDef, input_text: str) -> str:
+    """Build the full CLI command string from a ToolDef and user input.
+
+    Parses the input message text to extract tool_args values.
+
+    For input_mode="args":
+        Parses key=value pairs or positional args from message text.
+        Example: "target=tests/test_api.py verbose=true"
+        -> "pytest tests/test_api.py -v"
+
+    For input_mode="stdin":
+        Returns the command as-is (input will be piped to stdin).
+
+    Args:
+        tool_def: Tool configuration.
+        input_text: Raw text extracted from ACP input messages.
+
+    Returns:
+        Complete shell command string ready for execution.
+    """
+    parts = [tool_def.command]
+
+    # Add fixed arguments
+    if tool_def.args:
+        parts.extend(tool_def.args)
+
+    if tool_def.input_mode == "stdin":
+        # Input will be piped separately; no arg mapping needed
+        return " ".join(parts)
+
+    # Parse input text into key-value pairs
+    parsed_args = _parse_input_text(input_text)
+
+    # Map tool_args to CLI flags/positionals
+    for arg_def in tool_def.tool_args:
+        value = parsed_args.get(arg_def.name)
+
+        if value is None:
+            if arg_def.required and arg_def.default is None:
+                # Required arg missing — skip gracefully, let the CLI tool report the error
+                continue
+            if arg_def.default is not None:
+                value = arg_def.default
+            else:
+                continue
+
+        if arg_def.flag is not None:
+            if _is_truthy(value):
+                # Boolean flag present — only emit the flag itself (e.g. -v, --verbose)
+                parts.append(arg_def.flag)
+            else:
+                # Value flag (e.g. --path /some/dir, -e PATTERN)
+                parts.append(f"{arg_def.flag}{arg_def.separator}{value}")
+        else:
+            # Positional argument
+            parts.append(value)
+
+    # Any remaining unparsed input text becomes trailing positional args
+    remaining = _get_remaining_input(parsed_args, tool_def.tool_args)
+    if remaining:
+        parts.append(remaining)
+
+    return " ".join(parts)
+
+
+def _parse_input_text(text: str) -> dict[str, str]:
+    """Parse input text into key=value pairs.
+
+    Supports:
+    - "key=value" pairs (space or newline separated)
+    - Bare values are stored under the key "__positional__"
+
+    Args:
+        text: Raw input text from ACP message.
+
+    Returns:
+        Dict mapping argument names to values.
+    """
+    result: dict[str, str] = {}
+    positional: list[str] = []
+
+    # Split on whitespace (spaces, newlines, tabs)
+    tokens = text.strip().split()
+
+    for token in tokens:
+        if "=" in token:
+            key, _, val = token.partition("=")
+            key = key.strip()
+            val = val.strip()
+            if key:
+                result[key] = val
+        else:
+            positional.append(token)
+
+    if positional:
+        result["__positional__"] = " ".join(positional)
+
+    return result
+
+
+def _is_truthy(value: str) -> bool:
+    """Check if a string value represents a boolean 'true' (flag present, no value needed)."""
+    return value.lower() in ("true", "yes", "1", "")
+
+
+def _get_remaining_input(
+    parsed: dict[str, str], tool_args: list
+) -> str:
+    """Get remaining input that wasn't matched to any tool_arg definition."""
+    known_keys = {arg.name for arg in tool_args}
+    known_keys.add("__positional__")
+
+    remaining = []
+    for key, value in parsed.items():
+        if key not in known_keys:
+            remaining.append(f"{key}={value}" if "=" in f"{key}={value}" else value)
+
+    # Also include positional text
+    positional = parsed.get("__positional__")
+    if positional:
+        remaining.insert(0, positional)
+
+    return " ".join(remaining)

sycli/acp/registry.py

@@ -0,0 +1,155 @@
+"""Dynamic ACP agent registry.
+
+Creates CLIToolAgent (AgentManifest subclass) instances at runtime,
+one per ToolDef in the configuration. Each agent wraps a CLI tool
+and executes it via the executor module when a run is requested.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING
+
+from acp_sdk.models import Message, MessagePart, Metadata
+from acp_sdk.server.agent import AgentManifest
+from acp_sdk.server.context import Context
+from acp_sdk.server.types import RunYield, RunYieldResume
+
+from sycli.acp.executor import build_cli_command, execute_command, stream_command
+
+if TYPE_CHECKING:
+    from sycli.acp.config import ACPConfig, ToolDef
+
+
+class CLIToolAgent(AgentManifest):
+    """An AgentManifest that wraps a CLI tool.
+
+    Each instance is configured with a ToolDef. The run() method
+    is an async generator, enabling both streaming and batch modes
+    via the ACP SDK executor.
+    """
+
+    def __init__(self, tool_def: ToolDef, project_root: str) -> None:
+        self._tool_def = tool_def
+        self._project_root = project_root
+
+    @property
+    def name(self) -> str:
+        return self._tool_def.name
+
+    @property
+    def description(self) -> str:
+        return self._tool_def.description or f"CLI tool: {self._tool_def.command}"
+
+    @property
+    def input_content_types(self) -> list[str]:
+        return ["text/plain"]
+
+    @property
+    def output_content_types(self) -> list[str]:
+        return [self._tool_def.output_content_type]
+
+    @property
+    def metadata(self) -> Metadata:
+        return Metadata(
+            tags=["cli-tool", self._tool_def.command],
+        )
+
+    async def run(
+        self, input: list[Message], context: Context
+    ) -> AsyncGenerator[RunYield, RunYieldResume]:
+        """Execute the CLI tool and yield results.
+
+        Async generator enabling:
+        - Stream mode: yields MessagePart per stdout line
+        - Sync/async mode: yields complete Message at the end
+
+        Flow:
+            1. Extract text from input Messages (concatenate text/plain parts)
+            2. Build CLI command via build_cli_command()
+            3. If stream_output=True: stream_command(), yield MessagePart per line
+            4. Otherwise: execute_command(), yield single Message
+        """
+        # Step 1: Extract input text
+        input_text = _extract_input_text(input)
+
+        # Step 2: Build command
+        command = build_cli_command(self._tool_def, input_text)
+
+        # Step 3: Determine working directory
+        cwd = self._tool_def.working_dir or self._project_root
+
+        # Step 4: Build environment
+        env = None
+        if self._tool_def.env:
+            env = {**os.environ, **self._tool_def.env}
+
+        if self._tool_def.stream_output:
+            # Streaming: yield MessagePart per stdout line
+            async for line in stream_command(
+                command,
+                cwd=cwd,
+                timeout=self._tool_def.timeout,
+                env=env,
+            ):
+                yield MessagePart(
+                    content=line,
+                    content_type="text/plain",
+                )
+        else:
+            # Batch: execute and yield complete output
+            result = await execute_command(
+                command,
+                cwd=cwd,
+                timeout=self._tool_def.timeout,
+                env=env,
+                max_output_bytes=100_000,
+                stdin_input=input_text if self._tool_def.input_mode == "stdin" else None,
+            )
+
+            if result.timed_out:
+                output = f"Error: Command timed out after {self._tool_def.timeout}s\n{result.stdout}"
+            elif result.exit_code not in self._tool_def.allowed_exit_codes:
+                parts = []
+                if result.stdout:
+                    parts.append(result.stdout)
+                if result.stderr:
+                    parts.append(f"[stderr]\n{result.stderr}")
+                parts.append(f"Exit code: {result.exit_code}")
+                output = "\n".join(parts)
+            else:
+                output = result.stdout or "(no output)"
+
+            yield Message(
+                role="agent",
+                parts=[MessagePart(content=output, content_type="text/plain")],
+            )
+
+
+def _extract_input_text(messages: list[Message]) -> str:
+    """Extract and concatenate all text/plain content from input messages."""
+    parts: list[str] = []
+    for msg in messages:
+        for part in msg.parts:
+            content_type = getattr(part, "content_type", None) or "text/plain"
+            content = getattr(part, "content", None)
+            if content_type in ("text/plain", None) and content:
+                parts.append(content)
+    return "\n".join(parts)
+
+
+def build_agents(config: ACPConfig, project_root: str) -> list[AgentManifest]:
+    """Create AgentManifest instances for all tools in config.
+
+    Args:
+        config: ACP configuration with tool definitions.
+        project_root: Project root directory for command execution.
+
+    Returns:
+        List of CLIToolAgent instances ready for Server.register().
+    """
+    return [
+        CLIToolAgent(tool_def=tool_def, project_root=project_root)
+        for tool_def in config.tools
+    ]

sycli/acp/server.py

@@ -0,0 +1,69 @@
+"""ACP server bootstrap for sycli.
+
+Creates and starts an ACP server with all CLI tool agents registered.
+Uses the acp_sdk FastAPI app directly with uvicorn to avoid version
+compatibility issues between acp-sdk and uvicorn's positional parameters.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from acp_sdk.server.app import create_app
+import uvicorn
+
+from sycli.acp.registry import build_agents
+
+if TYPE_CHECKING:
+    from acp_sdk.server import Server
+    from sycli.acp.config import ACPConfig
+
+
+def create_acp_app(config: ACPConfig, project_root: str):
+    """Create a FastAPI app with all registered tool agents.
+
+    Args:
+        config: ACP configuration (loaded from .sycli/acp.yaml).
+        project_root: Project root directory for command execution.
+
+    Returns:
+        FastAPI application instance with ACP routes.
+    """
+    agents = build_agents(config, project_root)
+    app = create_app(*agents)
+    return app
+
+
+def create_acp_server(config: ACPConfig, project_root: str) -> Server:
+    """Create and configure an ACP Server with all registered tool agents.
+
+    Args:
+        config: ACP configuration (loaded from .sycli/acp.yaml).
+        project_root: Project root directory for command execution.
+
+    Returns:
+        Configured Server instance (not yet started).
+    """
+    from acp_sdk.server import Server
+
+    server = Server()
+    agents = build_agents(config, project_root)
+    server.register(*agents)
+    return server
+
+
+def run_acp_server(config: ACPConfig, project_root: str) -> None:
+    """Create and start the ACP server (blocking until shutdown).
+
+    This is the main entry point called from acp_cmd.py.
+    Uses uvicorn directly to avoid acp-sdk / uvicorn version mismatches.
+    """
+    app = create_acp_app(config, project_root)
+
+    uvicorn.run(
+        app,
+        host=config.host,
+        port=config.port,
+        log_level="info",
+        headers=[("server", "acp")],
+    )

sycli/cli.py

@@ -168,6 +168,13 @@ def _create_parser() -> argparse.ArgumentParser:
     # interactive
     cdp_sub.add_parser("interactive", help="Start interactive CDP REPL")
 
+    # ── acp ──
+    p_acp = sub.add_parser("acp", help="Start ACP server exposing CLI tools as agents")
+    p_acp.add_argument("--config", "-c", help="Path to ACP config file (default: .sycli/acp.yaml)")
+    p_acp.add_argument("--host", help="Override server host")
+    p_acp.add_argument("--port", "-p", type=int, help="Override server port")
+    p_acp.add_argument("--project-root", "-r", default=".", help="Project root directory")
+
     # ── version ──
     sub.add_parser("version", help="Show version")
 
@@ -234,6 +241,10 @@ def main() -> None:
         from sycli.commands.cdp_cmd import handle_cdp
         sys.exit(handle_cdp(args))
 
+    elif args.command == "acp":
+        from sycli.commands.acp_cmd import handle_acp
+        sys.exit(handle_acp(args))
+
 
 def _handle_status(args) -> None:
     """Show current RL state."""

sycli/commands/acp_cmd.py

@@ -0,0 +1,116 @@
+"""sycli acp command — start ACP server exposing CLI tools as agents."""
+
+from __future__ import annotations
+
+import signal
+import sys
+from pathlib import Path
+
+from sycli.core.display import error, header, info, success, warning
+
+
+def handle_acp(args) -> int:
+    """Handle `sycli acp` command.
+
+    Flow:
+        1. Resolve project root
+        2. Load .sycli/acp.yaml (or --config path)
+        3. Validate tool definitions
+        4. Print registered agents summary
+        5. Start ACP server (blocking)
+
+    Args:
+        args: Parsed argparse namespace with config, host, port, project_root.
+
+    Returns:
+        Exit code (0 for success, 1 for error).
+    """
+    project_root = Path(args.project_root or ".").resolve()
+    sycli_dir = project_root / ".sycli"
+
+    if not sycli_dir.exists():
+        error(".sycli/ not found. Run `sycli init` first.")
+        return 1
+
+    # Determine config path
+    config_path = Path(args.config) if args.config else sycli_dir / "acp.yaml"
+    if not config_path.exists():
+        config_path = sycli_dir / "acp.json"
+
+    if not config_path.exists():
+        error(f"ACP config not found at {sycli_dir / 'acp.yaml'}")
+        error("Create one with your tool definitions. Example:")
+        error("""
+  # .sycli/acp.yaml
+  host: "127.0.0.1"
+  port: 8100
+  tools:
+    - name: "git-status"
+      command: "git"
+      args: ["status", "--porcelain"]
+      description: "Show git working tree status"
+      timeout: 30
+""")
+        return 1
+
+    # Load config
+    from sycli.acp.config import ACPConfig
+
+    try:
+        config = ACPConfig.load(config_path)
+    except Exception as e:
+        error(f"Failed to load ACP config: {e}")
+        return 1
+
+    # Override port/host from CLI args
+    if args.host:
+        config.host = args.host
+    if args.port:
+        config.port = args.port
+
+    if not config.tools:
+        error("No tools defined in ACP config. Add tools to acp.yaml.")
+        return 1
+
+    # Print summary
+    header("ACP Server Configuration")
+    info(f"Config:  {config_path}")
+    info(f"Host:    {config.host}")
+    info(f"Port:    {config.port}")
+    info(f"Agents:  {len(config.tools)} registered")
+    print()
+    for tool in config.tools:
+        desc = tool.description or "(no description)"
+        info(f"  {tool.name}: {tool.command} {' '.join(tool.args) if tool.args else ''}")
+        info(f"    {desc}")
+    print()
+
+    # Start server
+    from sycli.acp.server import run_acp_server
+
+    # Graceful shutdown on SIGINT
+    _shutdown = False
+
+    def _signal_handler(sig, frame):
+        nonlocal _shutdown
+        if _shutdown:
+            sys.exit(1)
+        _shutdown = True
+        warning("\nShutting down ACP server...")
+
+    signal.signal(signal.SIGINT, _signal_handler)
+
+    try:
+        success(f"Starting ACP server on http://{config.host}:{config.port}")
+        run_acp_server(config, str(project_root))
+    except KeyboardInterrupt:
+        warning("ACP server stopped.")
+        return 0
+    except Exception as e:
+        error(f"ACP server failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    return 0

{sycommon_python_lib-0.2.6a4.dist-info → sycommon_python_lib-0.2.6a6.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a4
+Version: 0.2.6a6
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika==9.6.2
-Requires-Dist: aiohttp==3.13.5
+Requires-Dist: aiohttp==3.14.1
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
@@ -13,10 +13,10 @@ Requires-Dist: deepagents==0.6.8
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==2.3.1
-Requires-Dist: langchain==1.3.4
-Requires-Dist: langchain-core==1.4.0
-Requires-Dist: langchain-openai==1.2.2
+Requires-Dist: kafka-python==2.3.2
+Requires-Dist: langchain==1.3.7
+Requires-Dist: langchain-core==1.4.4
+Requires-Dist: langchain-openai==1.3.0
 Requires-Dist: langfuse==4.7.1
 Requires-Dist: langgraph==1.2.4
 Requires-Dist: langgraph-checkpoint-postgres==3.1.0
@@ -29,20 +29,21 @@ Requires-Dist: psutil==7.2.2
 Requires-Dist: pyxxl==0.4.7
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-dotenv==1.2.2
-Requires-Dist: python-multipart==0.0.30
+Requires-Dist: python-multipart==0.0.32
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: redis==7.4.0
-Requires-Dist: sentry-sdk[fastapi]==2.61.1
+Requires-Dist: sentry-sdk[fastapi]==2.62.0
 Requires-Dist: sqlalchemy[asyncio]==2.0.50
 Requires-Dist: starlette[full]==1.2.1
 Requires-Dist: tiktoken==0.13.0
-Requires-Dist: uvicorn==0.48.0
+Requires-Dist: uvicorn==0.49.0
 Requires-Dist: wecom-aibot-python-sdk==1.0.2
 Requires-Dist: twine==6.2.0
 Requires-Dist: minio==7.2.20
-Requires-Dist: langchain-mcp-adapters==0.2.2
+Requires-Dist: langchain-mcp-adapters==0.3.0
 Requires-Dist: fastapi-mcp==0.4.0
 Requires-Dist: psycopg[binary,pool]==3.3.4
+Requires-Dist: acp-sdk>=1.0.3
 
 # sycommon-python-lib
 

{sycommon_python_lib-0.2.6a4.dist-info → sycommon_python_lib-0.2.6a6.dist-info}/RECORD

@@ -61,7 +61,12 @@ command/templates/web/tools/mq.py.tpl,sha256=FQpV_dXpDzC-b7kWtSLylhqBCLgUN6GyRhr
 nexus/__init__.py,sha256=MDZdgwMEFUSPvQ2ovibj7GE-4X4JX6ihNAB6GwVPa9g,1225
 sycli/__init__.py,sha256=mKtD5rrPbg4cF_FrYku5KJrcovLjVdJHvOPW8dit3zY,81
 sycli/__main__.py,sha256=sYL4dyeRvAN2ef71s2_K8plLCzlaVcuYo7_y6VGz9Tg,115
-sycli/cli.py,sha256=Uk0y6I8IK1PlPkwW6rqC93yOkgaCZnj7f39C-sv18d0,21642
+sycli/cli.py,sha256=nlThDw1yqtnXoI_jJgF4Zc1ipArTTQefrTE3IvZNotI,22208
+sycli/acp/__init__.py,sha256=wDhvqqIUNvCor3K47ymrdIltVdn-oTJ9AaOBgtNQEgY,1331
+sycli/acp/config.py,sha256=1BLgj2Dao7233ZfSYG9NhIVkJGFL46bm2LkBsTQ5XUk,4360
+sycli/acp/executor.py,sha256=D2XOoaSfksdit72AiSWiyekaBOIJLsX1k85aSIaagSI,10247
+sycli/acp/registry.py,sha256=qaPN9RGdu5YWI3axgPV-vSGVlRGxSqCMrYBPJWnHFNo,5281
+sycli/acp/server.py,sha256=guMLa6yzP3eMyzaHOpciwoSw9VYJszrv_D2oS2N4rmo,1955
 sycli/agents/__init__.py,sha256=th-UR3Upcb0xHhjmt_x1b26q80wZGxt_HJMjxyuTV7g,31
 sycli/agents/factory.py,sha256=huSwOSw1hHsl_XJs1YVMo47EcW5SqAK3hivI_aV1glE,8999
 sycli/agents/prompts.py,sha256=YVVm9kEsoSSOWxvoEDa3DiKPDdkH6KtC18R5euqylW8,16466
@@ -78,6 +83,7 @@ sycli/cdp/capabilities/page_errors.py,sha256=bZlyJHC09hMuYN04X_Z60Nh4Nq2V8v65xxg
 sycli/cdp/capabilities/performance.py,sha256=z_OQNnd8n2luhOURY-RpkuLG3JpjpAqkK3yTjZxDS5g,1971
 sycli/cdp/capabilities/screenshot.py,sha256=qCi2niTs0vNMJtu2bFuwAPH7FRQpJPoQTgWNKHQC2VU,1736
 sycli/commands/__init__.py,sha256=ikkj1Ig33tgxEK9Sm9IQp3DwyCe2WzgawSB5vtER9SU,30
+sycli/commands/acp_cmd.py,sha256=XOzczk8IIxHIXNDmN29SALM_Dt7vF1lsSQgkdMCxr94,3138
 sycli/commands/cdp_cmd.py,sha256=7Jziye60Vwqz0jD1sUU9z0Iry7NsMJ8m5MTRsaE4UV0,8790
 sycli/commands/chat_cmd.py,sha256=kdT2WIAIF2zXBiA53iHKMjAH1jK4e4LwQstfflBiSaI,8812
 sycli/commands/create_cmd.py,sha256=VU9ZJs6NPcgi_TKe2YjOi-zaplnVdckwNu8JF8wRw6M,3698
@@ -284,8 +290,8 @@ sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,561
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
 sycommon/xxljob/__init__.py,sha256=7eoBlQxv-B39IfRSCY2bkqdGYs1QRe1umAWd88VMEEM,86
 sycommon/xxljob/xxljob_service.py,sha256=JIEJaGXhqrTLcyxlyynSrsHg9bBnDNzX-D4qIWLRPUE,6815
-sycommon_python_lib-0.2.6a4.dist-info/METADATA,sha256=og-e-U_j2lvFePetXDCzD_KIp4M0yYWh5WoieUyPXbY,7913
-sycommon_python_lib-0.2.6a4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-sycommon_python_lib-0.2.6a4.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
-sycommon_python_lib-0.2.6a4.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
-sycommon_python_lib-0.2.6a4.dist-info/RECORD,,
+sycommon_python_lib-0.2.6a6.dist-info/METADATA,sha256=KeXzYptn5kE7K0wLGFB9BCCPErPbMzcIu-U0Oaj5bkM,7943
+sycommon_python_lib-0.2.6a6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sycommon_python_lib-0.2.6a6.dist-info/entry_points.txt,sha256=gsR4SssKxDWjRU8ggidzNcdMXDPRSKRS7UaGyNP84Qg,92
+sycommon_python_lib-0.2.6a6.dist-info/top_level.txt,sha256=RgphKrg7nJyZ7irJqbxFr-5H2LUYTvI7ivoWZH2hcD0,29
+sycommon_python_lib-0.2.6a6.dist-info/RECORD,,