langchain-agentx-python 1.1.0__tar.gz → 1.1.1__tar.gz

{langchain-agentx-python-1.1.0/langchain_agentx_python.egg-info → langchain-agentx-python-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.1.0
+Version: 1.1.1
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.1.0 → langchain-agentx-python-1.1.1}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.1.0"
+__version__ = "1.1.1"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

langchain-agentx-python-1.1.1/langchain_agentx/command/allowed_tools.py

@@ -0,0 +1,106 @@
+"""
+command/allowed_tools.py — CC 风格 allowed_tools 解析与应用。
+
+职责：
+    解析 Bash(git add:*) / read_file 等条目，写入 session 权限上下文。
+
+链路位置：
+    Session run_slash_command → apply_command_tool_scope。
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from ..tool_runtime.permission_context import (
+    clear_command_tool_scope,
+    merge_auto_approved_union,
+    set_command_bash_allow_rules,
+)
+from ..tool_runtime.session_store import AgentSessionStore
+
+_ALLOWED_TOOL_RE = re.compile(r"^([A-Za-z][A-Za-z0-9_-]*)(?:\((.*)\))?$")
+
+
+@dataclass(frozen=True)
+class ParsedAllowedToolRule:
+    raw: str
+    tool_name: str
+    rule_content: str | None = None
+
+
+def parse_allowed_tool_rule(entry: str) -> ParsedAllowedToolRule | None:
+    text = entry.strip()
+    if not text:
+        return None
+    match = _ALLOWED_TOOL_RE.fullmatch(text)
+    if match is None:
+        return None
+    tool_name = match.group(1).lower()
+    raw_content = match.group(2)
+    rule_content = None if raw_content is None else raw_content.strip()
+    if rule_content == "" or rule_content == "*":
+        rule_content = None
+    return ParsedAllowedToolRule(raw=text, tool_name=tool_name, rule_content=rule_content)
+
+
+def partition_allowed_tools(
+    entries: list[str] | tuple[str, ...] | None,
+) -> tuple[list[str], list[str]]:
+    """返回 (tool_names_for_auto_approve, bash_rule_patterns)。"""
+    tool_names: list[str] = []
+    bash_patterns: list[str] = []
+    seen_tools: set[str] = set()
+    seen_patterns: set[str] = set()
+
+    for entry in entries or []:
+        parsed = parse_allowed_tool_rule(entry)
+        if parsed is None:
+            continue
+        if parsed.tool_name == "bash":
+            if parsed.rule_content is not None:
+                key = parsed.rule_content.lower()
+                if key not in seen_patterns:
+                    seen_patterns.add(key)
+                    bash_patterns.append(parsed.rule_content)
+            elif "bash" not in seen_tools:
+                seen_tools.add("bash")
+                tool_names.append("bash")
+        else:
+            if parsed.tool_name not in seen_tools:
+                seen_tools.add(parsed.tool_name)
+                tool_names.append(parsed.tool_name)
+
+    return tool_names, bash_patterns
+
+
+def apply_command_tool_scope(
+    session_store: AgentSessionStore | None,
+    allowed_tools: list[str] | tuple[str, ...] | None,
+) -> None:
+    if session_store is None or not allowed_tools:
+        return
+    tool_names, bash_patterns = partition_allowed_tools(list(allowed_tools))
+    if tool_names:
+        merge_auto_approved_union(session_store, tool_names)
+    if bash_patterns:
+        set_command_bash_allow_rules(session_store, bash_patterns)
+
+
+def reset_command_tool_scope(session_store: AgentSessionStore | None) -> None:
+    clear_command_tool_scope(session_store)
+
+
+def session_store_from_graph(graph: Any) -> AgentSessionStore | None:
+    config = getattr(graph, "config", None)
+    if not isinstance(config, dict):
+        return None
+    configurable = config.get("configurable")
+    if not isinstance(configurable, dict):
+        return None
+    store = configurable.get("session_store")
+    if store is None:
+        return None
+    return store

{langchain-agentx-python-1.1.0 → langchain-agentx-python-1.1.1}/langchain_agentx/command/builtin/__init__.py

@@ -8,16 +8,20 @@ command/builtin/__init__.py — 内置命令工厂导出。
     被 session/agent_session.py 与 session/conversation_session.py 依赖。
 
 当前裁剪范围：
-    仅导出 P1 阶段四个内置命令。
+    仅导出 P1 阶段内置命令（含 CC 对齐 /commit）。
 """
 
 from .clear import make_clear_command
+from .commit import make_commit_command
+from .commit_push_pr import make_commit_push_pr_command
 from .compact import make_compact_command
 from .memory import make_memory_command
 from .reload_plugins import make_reload_plugins_command
 
 __all__ = [
     "make_clear_command",
+    "make_commit_command",
+    "make_commit_push_pr_command",
     "make_compact_command",
     "make_memory_command",
     "make_reload_plugins_command",

langchain-agentx-python-1.1.1/langchain_agentx/command/builtin/commit.py

@@ -0,0 +1,96 @@
+"""
+command/builtin/commit.py — 内置 /commit 命令。
+
+职责：
+    对齐 CC commands/commit.ts：预执行 git 上下文 + Git Safety Protocol + 专用任务流程。
+
+链路位置：
+    由 CommandRegistry 注册；用户输入 /commit 时由 dispatcher 注入 prompt。
+
+当前裁剪范围：
+    allowed_tools 为 CC 风格 Bash(git *:*) pattern；由 Session.run_slash_command 写入 command scope。
+"""
+
+from __future__ import annotations
+
+from ..context import CommandContext
+from ..git_settings import should_include_git_instructions
+from ..prompt_shell import execute_shell_commands_in_prompt
+from ..result import CommandResult
+from ..types import CommandDefinition
+from .git_prompt_common import (
+    COMMIT_ALLOWED_TOOLS,
+    GIT_SAFETY_PROTOCOL_SECTION,
+    commit_attribution_suffix,
+)
+from ..allowed_tools import partition_allowed_tools
+
+
+def _commit_prompt_template() -> str:
+    attribution = commit_attribution_suffix()
+    attribution_block = f"\n\n{attribution}" if attribution else ""
+    return f"""## Context
+
+- Current git status: !`git status`
+- Current git diff (staged and unstaged changes): !`git diff HEAD`
+- Current branch: !`git branch --show-current`
+- Recent commits: !`git log --oneline -10`
+
+{GIT_SAFETY_PROTOCOL_SECTION}
+
+## Your task
+
+Based on the above changes, create a single git commit:
+
+1. Analyze all staged changes and draft a commit message:
+   - Look at the recent commits above to follow this repository's commit message style
+   - Summarize the nature of the changes (new feature, enhancement, bug fix, refactoring, test, docs, etc.)
+   - Ensure the message accurately reflects the changes and their purpose (i.e. "add" means a wholly new feature, "update" means an enhancement to an existing feature, "fix" means a bug fix, etc.)
+   - Draft a concise (1-2 sentences) commit message that focuses on the "why" rather than the "what"
+
+2. Stage relevant files and create the commit using HEREDOC syntax:
+```
+git commit -m "$(cat <<'EOF'
+Commit message here.{attribution_block}
+EOF
+)"
+```
+
+You have the capability to call multiple tools in a single response. Stage and create the commit using a single message. Do not use any other tools or do anything else. Do not send any other text or messages besides these tool calls.
+
+{{args}}"""
+
+
+async def _handle_commit(ctx: CommandContext) -> CommandResult:
+    if not should_include_git_instructions(ctx.workspace_cfg):
+        return CommandResult(
+            error="[command/execute] /commit: git instructions are disabled "
+            "(LANGCHAIN_AGENTX_DISABLE_GIT_INSTRUCTIONS=1 or settings.json)",
+        )
+    args = str(ctx.extra.get("args", "")).strip()
+    template = _commit_prompt_template()
+    _tool_names, bash_patterns = partition_allowed_tools(COMMIT_ALLOWED_TOOLS)
+    rendered = await execute_shell_commands_in_prompt(
+        template,
+        cwd=str(ctx.workspace_cfg.workspace_root),
+        bash_allow_rules=bash_patterns,
+    )
+    if args:
+        rendered = f"{rendered.rstrip()}\n\nUser args: {args}"
+    return CommandResult(
+        should_query=True,
+        injected_prompt=rendered,
+        allowed_tools=list(COMMIT_ALLOWED_TOOLS),
+    )
+
+
+def make_commit_command() -> CommandDefinition:
+    return CommandDefinition(
+        name="commit",
+        description="Create a git commit",
+        command_type="prompt",
+        handler=_handle_commit,
+        source="builtin",
+        allowed_tools=COMMIT_ALLOWED_TOOLS,
+        execution_context="fork",
+    )

langchain-agentx-python-1.1.1/langchain_agentx/command/builtin/commit_push_pr.py

@@ -0,0 +1,106 @@
+"""
+command/builtin/commit_push_pr.py — 内置 /commit-push-pr 命令。
+
+职责：
+    对齐 CC commands/commit-push-pr.ts：commit + push + gh pr create/edit。
+
+链路位置：
+    由 CommandRegistry 注册；用户显式调用 /commit-push-pr 时注入 prompt。
+"""
+
+from __future__ import annotations
+
+from ..context import CommandContext
+from ..git_settings import should_include_git_instructions
+from ..prompt_shell import execute_shell_commands_in_prompt
+from ..result import CommandResult
+from ..types import CommandDefinition
+from .git_prompt_common import (
+    COMMIT_PUSH_PR_ALLOWED_TOOLS,
+    GIT_SAFETY_PROTOCOL_SECTION,
+    commit_attribution_suffix,
+    pr_attribution_suffix,
+)
+from ..allowed_tools import partition_allowed_tools
+
+
+def _commit_push_pr_prompt_template() -> str:
+    commit_attr = commit_attribution_suffix()
+    pr_attr = pr_attribution_suffix()
+    commit_attr_block = f"\n\n{commit_attr}" if commit_attr else ""
+    pr_attr_block = f"\n\n{pr_attr}" if pr_attr else ""
+    return f"""## Context
+
+- `git status`: !`git status`
+- `git diff HEAD`: !`git diff HEAD`
+- `git branch --show-current`: !`git branch --show-current`
+- `default branch`: !`git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo main`
+- `git diff against default`: !`git diff $(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@' || echo main)...HEAD`
+- `existing PR`: !`gh pr view --json number,url 2>/dev/null || true`
+
+{GIT_SAFETY_PROTOCOL_SECTION}
+
+## Your task
+
+Analyze all changes that will be included in the pull request, making sure to look at all relevant commits (NOT just the latest commit, but ALL commits that will be included in the pull request).
+
+Based on the above changes:
+1. Create a new branch if you are on the default branch
+2. Create a single commit with an appropriate message using heredoc syntax:
+```
+git commit -m "$(cat <<'EOF'
+Commit message here.{commit_attr_block}
+EOF
+)"
+```
+3. Push the branch to origin with -u if needed
+4. If a PR already exists for this branch, update it with `gh pr edit`. Otherwise create one:
+```
+gh pr create --title "Short, descriptive title" --body "$(cat <<'EOF'
+## Summary
+<1-3 bullet points>
+
+## Test plan
+[Bulleted markdown checklist of TODOs for testing the pull request...]{pr_attr_block}
+EOF
+)"
+```
+
+You have the capability to call multiple tools in a single response. You MUST do all of the above in a single message.
+Return the PR URL when you're done, so the user can see it.
+
+{{args}}"""
+
+
+async def _handle_commit_push_pr(ctx: CommandContext) -> CommandResult:
+    if not should_include_git_instructions(ctx.workspace_cfg):
+        return CommandResult(
+            error="[command/execute] /commit-push-pr: git instructions are disabled "
+            "(LANGCHAIN_AGENTX_DISABLE_GIT_INSTRUCTIONS=1 or settings.json)",
+        )
+    args = str(ctx.extra.get("args", "")).strip()
+    template = _commit_push_pr_prompt_template()
+    _tool_names, bash_patterns = partition_allowed_tools(COMMIT_PUSH_PR_ALLOWED_TOOLS)
+    rendered = await execute_shell_commands_in_prompt(
+        template,
+        cwd=str(ctx.workspace_cfg.workspace_root),
+        bash_allow_rules=bash_patterns,
+    )
+    if args:
+        rendered = f"{rendered.rstrip()}\n\nUser args: {args}"
+    return CommandResult(
+        should_query=True,
+        injected_prompt=rendered,
+        allowed_tools=list(COMMIT_PUSH_PR_ALLOWED_TOOLS),
+    )
+
+
+def make_commit_push_pr_command() -> CommandDefinition:
+    return CommandDefinition(
+        name="commit-push-pr",
+        description="Commit, push, and open a pull request",
+        command_type="prompt",
+        handler=_handle_commit_push_pr,
+        source="builtin",
+        allowed_tools=COMMIT_PUSH_PR_ALLOWED_TOOLS,
+    )

langchain-agentx-python-1.1.1/langchain_agentx/command/builtin/git_prompt_common.py

@@ -0,0 +1,48 @@
+"""
+command/builtin/git_prompt_common.py — Git builtin 命令共享文案与 allowed_tools。
+
+职责：
+    为 /commit、/commit-push-pr 提供 CC 对齐的 Git Safety 与工具白名单常量。
+
+链路位置：
+    被 command/builtin/commit*.py 引用。
+"""
+
+from __future__ import annotations
+
+from ...utils.git_settings import commit_attribution_suffix, pr_attribution_suffix
+
+COMMIT_ALLOWED_TOOLS: tuple[str, ...] = (
+    "Bash(git add:*)",
+    "Bash(git status:*)",
+    "Bash(git commit:*)",
+)
+
+COMMIT_PUSH_PR_ALLOWED_TOOLS: tuple[str, ...] = (
+    "Bash(git add:*)",
+    "Bash(git status:*)",
+    "Bash(git commit:*)",
+    "Bash(git push:*)",
+    "Bash(gh pr create:*)",
+    "Bash(gh pr edit:*)",
+    "Bash(gh pr view:*)",
+)
+
+GIT_SAFETY_PROTOCOL_SECTION = """## Git Safety Protocol
+
+- NEVER update the git config
+- NEVER skip hooks (--no-verify, --no-gpg-sign, etc) unless the user explicitly requests it
+- CRITICAL: ALWAYS create NEW commits. NEVER use git commit --amend, unless the user explicitly requests it
+- NEVER run destructive git commands (push --force, reset --hard, checkout ., restore ., clean -f, branch -D) unless the user explicitly requests them
+- NEVER run force push to main/master; warn the user if they request it
+- Do not commit files that likely contain secrets (.env, credentials.json, etc). Warn the user if they specifically request to commit those files
+- If there are no changes to commit (i.e., no untracked files and no modifications), do not create an empty commit
+- Never use git commands with the -i flag (like git rebase -i or git add -i) since they require interactive input which is not supported"""
+
+__all__ = [
+    "COMMIT_ALLOWED_TOOLS",
+    "COMMIT_PUSH_PR_ALLOWED_TOOLS",
+    "GIT_SAFETY_PROTOCOL_SECTION",
+    "commit_attribution_suffix",
+    "pr_attribution_suffix",
+]

{langchain-agentx-python-1.1.0 → langchain-agentx-python-1.1.1}/langchain_agentx/command/dispatcher.py

@@ -82,7 +82,7 @@ class CommandDispatcher:
         context: CommandContext,
     ) -> CommandResult:
         if command.command_type == "prompt":
-            return self._execute_prompt(command, args)
+            return await self._execute_prompt(command, args, context)
         return await self._execute_local(command, context)
 
     async def _execute_local(
@@ -108,17 +108,64 @@ class CommandDispatcher:
             logger.error("command /%s execution failed: %s", command.name, exc, exc_info=True)
             return CommandResult(error=self._format_error("execute", f"/{command.name} failed: {exc}"))
 
-    @staticmethod
-    def _execute_prompt(command: CommandDefinition, args: str) -> CommandResult:
+    async def _execute_prompt(
+        self,
+        command: CommandDefinition,
+        args: str,
+        context: CommandContext,
+    ) -> CommandResult:
+        if command.handler is not None:
+            try:
+                result = command.handler(context)
+                if inspect.isawaitable(result):
+                    result = await result
+                if not isinstance(result, CommandResult):
+                    return CommandResult(
+                        error=self._format_error(
+                            "execute",
+                            f"/{command.name}: prompt handler returned unexpected type",
+                        )
+                    )
+                if result.allowed_tools is None and command.allowed_tools:
+                    result = CommandResult(
+                        should_query=result.should_query,
+                        output=result.output,
+                        injected_prompt=result.injected_prompt,
+                        error=result.error,
+                        allowed_tools=list(command.allowed_tools),
+                        execution_context=command.execution_context,
+                    )
+                elif result.execution_context == "main" and command.execution_context != "main":
+                    result = CommandResult(
+                        should_query=result.should_query,
+                        output=result.output,
+                        injected_prompt=result.injected_prompt,
+                        error=result.error,
+                        allowed_tools=result.allowed_tools,
+                        execution_context=command.execution_context,
+                    )
+                return result
+            except Exception as exc:  # pragma: no cover - defensive path
+                logger.error("command /%s prompt failed: %s", command.name, exc, exc_info=True)
+                return CommandResult(
+                    error=self._format_error("execute", f"/{command.name} failed: {exc}")
+                )
+
         if command.prompt_template is None:
             return CommandResult(
-                error=CommandDispatcher._format_error(
+                error=self._format_error(
                     "execute",
                     f"/{command.name}: prompt_template not set",
                 )
             )
         rendered = command.prompt_template.replace("{args}", args)
-        return CommandResult(should_query=True, injected_prompt=rendered)
+        allowed = list(command.allowed_tools) if command.allowed_tools else None
+        return CommandResult(
+            should_query=True,
+            injected_prompt=rendered,
+            allowed_tools=allowed,
+            execution_context=command.execution_context,
+        )
 
     def _find_plugin_command(
         self,

langchain-agentx-python-1.1.1/langchain_agentx/command/fork_executor.py

@@ -0,0 +1,107 @@
+"""
+command/fork_executor.py — slash 命令 fork 子 loop 执行（对齐 CC executeForkedSlashCommand）。
+
+职责：
+    在隔离子 agent 中执行 prompt 类 slash 命令，不污染主 session messages。
+
+链路位置：
+    AgentSession.run_slash_command → run_forked_slash_command。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_agentx.command.allowed_tools import apply_command_tool_scope, reset_command_tool_scope
+from langchain_agentx.tool_runtime.models import ToolExecutionContext
+from langchain_agentx.tools.agent.builtin_subagent_loader import DefaultSubagentRegistryProvider
+from langchain_agentx.tools.agent.models import AgentToolInput
+from dataclasses import replace
+from langchain_agentx.workspace.config import ResolvedAgentStateConfig
+
+
+def _bash_only_tool_filter(all_tools: list[Any]) -> list[Any]:
+    return [tool for tool in all_tools if getattr(tool, "name", "") == "bash"]
+
+
+def _commit_fork_subagent_config() -> SubagentConfig:
+    base = DefaultSubagentRegistryProvider.get().get("general-purpose")
+    return replace(
+        base,
+        name="slash-command-fork",
+        description="Isolated slash-command fork worker",
+        when_to_use="Internal fork execution for slash commands",
+        tool_filter=_bash_only_tool_filter,
+        tools_description="bash",
+        default_max_steps=8,
+        allow_async=False,
+        tags={"fork", "slash-command"},
+    )
+
+
+def _build_ctx_from_graph(
+    graph: Any,
+    *,
+    workspace_cfg: ResolvedAgentStateConfig,
+    session_id: str,
+) -> ToolExecutionContext:
+    config = getattr(graph, "config", None)
+    configurable: dict[str, Any] = {}
+    if isinstance(config, dict):
+        raw = config.get("configurable")
+        if isinstance(raw, dict):
+            configurable = raw
+    loop_config = configurable.get("loop_config")
+    model = getattr(loop_config, "model", None) if loop_config is not None else None
+    workspace_root = str(workspace_cfg.workspace_root)
+    return ToolExecutionContext(
+        tool_name="slash_command_fork",
+        tool_call_id="slash-fork",
+        input_args={},
+        state={"messages": [], "cwd": workspace_root},
+        model=model,
+        available_tools=list(configurable.get("available_tools") or []),
+        session_id=session_id,
+        session_store=configurable.get("session_store"),
+        tool_loader=configurable.get("tool_loader"),
+        tool_registry=configurable.get("tool_registry"),
+        workspace_root=workspace_root,
+        agent_home_segment=workspace_cfg.agent_home_segment,
+        cwd=workspace_root,
+        original_cwd=workspace_root,
+        runnable_config=config,
+    )
+
+
+def run_forked_slash_command(
+    *,
+    prompt: str,
+    allowed_tools: list[str],
+    graph: Any,
+    workspace_cfg: ResolvedAgentStateConfig,
+    session_id: str,
+) -> str:
+    from langchain_agentx.loop.subagent.orchestrator import SubagentOrchestrator
+
+    ctx = _build_ctx_from_graph(graph, workspace_cfg=workspace_cfg, session_id=session_id)
+    store = ctx.session_store
+    try:
+        apply_command_tool_scope(store, allowed_tools)
+        orchestrator = SubagentOrchestrator(mode="fork")
+        inp = AgentToolInput(
+            prompt=prompt,
+            description="slash command fork",
+            subagent_type="general-purpose",
+            run_in_background=False,
+        )
+        out = orchestrator.invoke_subagent(
+            inp,
+            ctx,
+            _commit_fork_subagent_config(),
+            skill_allowed_tools=allowed_tools or None,
+            force_sync=True,
+        )
+        text = (out.content or "").strip()
+        return text or "Slash command fork completed."
+    finally:
+        reset_command_tool_scope(store)

langchain-agentx-python-1.1.1/langchain_agentx/command/git_settings.py

@@ -0,0 +1,7 @@
+"""command/git_settings.py — re-export utils.git_settings（避免循环依赖入口分散）。"""
+
+from __future__ import annotations
+
+from ..utils.git_settings import should_include_git_instructions
+
+__all__ = ["should_include_git_instructions"]