fabricatio-agent 0.2.4.dev7__cp314-cp314-win_amd64.whl

fabricatio_agent/__init__.py

@@ -0,0 +1 @@
+"""An extension of fabricatio."""

fabricatio_agent/actions/__init__.py

@@ -0,0 +1 @@
+"""Actions defined in fabricatio-agent."""

fabricatio_agent/actions/code.py

@@ -0,0 +1,96 @@
+"""Built-in actions."""
+
+from typing import ClassVar, List, Optional, Set
+
+from fabricatio_core import Action, Task, logger
+from fabricatio_core.models.containers import CodeSnippet
+from fabricatio_core.utils import ok
+from fabricatio_tool.capabilities.handle_task import HandleTask
+from fabricatio_tool.models.tool import ToolBox
+from fabricatio_tool.rust import treeview
+from fabricatio_tool.toolboxes import fs_toolbox
+from pydantic import Field
+
+from fabricatio_agent.capabilities.agent import Agent
+
+
+class WriteCode(Action, Agent):
+    """Write code. output the code as a string."""
+
+    ctx_override: ClassVar[bool] = True
+
+    toolboxes: Set[ToolBox] = Field(default={fs_toolbox})
+
+    output_key: str = "code"
+
+    coding_language: Optional[str] = None
+    """The coding language to use, will automatically be inferred from the prompt if not specified."""
+
+    async def _execute(self, task_input: Task, **cxt) -> Optional[List[CodeSnippet]]:
+        c_seq = ok(
+            await self.acode_snippets(
+                f"current directory tree:\n{treeview()}\n\n{task_input.assembled_prompt}",
+                code_language=self.coding_language,
+            )
+        )
+
+        for c in c_seq:
+            c.write()
+
+        return c_seq
+
+
+class CleanUp(Action, Agent, HandleTask):
+    """Clean up the workspace."""
+
+    toolboxes: Set[ToolBox] = Field(default={fs_toolbox})
+
+    async def _execute(self, task_input: Task, **cxt) -> None:
+        """Execute the action."""
+        await self.handle_task(task_input, {})
+
+
+class MakeSpecification(Action, Agent):
+    """Make a specification for a task."""
+
+    ctx_override: ClassVar[bool] = True
+
+    output_key: str = "specification"
+
+    async def _execute(self, prompt: str, **cxt) -> Optional[str]:
+        """Execute the action."""
+
+
+class Planning(Action, Agent):
+    """Architectural design and planning action."""
+
+    ctx_override: ClassVar[bool] = True
+
+    sequential_thinking: bool = False
+    """Whether to use sequential thinking."""
+
+    async def _execute(self, task_input: Task, **cxt) -> bool:
+        """Execute the action."""
+        req = f"Current directory tree:\n{treeview()}\n\n{task_input.assembled_prompt}"
+        if self.sequential_thinking:
+            planning = await self.thinking(req)
+            req += f"\n\n{planning.export_branch_string()}"
+
+        tk = ok(await self.cooperative_digest(req, False))
+        logger.debug(f"Execute tasklist:\n{tk.explain()}")
+        await (
+            tk.inject_context(sequential_thinking=self.sequential_thinking)
+            .inject_description(f"This task is a sub task of {task_input.name}.")
+            .execute()
+        )
+        return True
+
+
+class ReviewCode(Action, Agent):
+    """Review code and suggest improvements."""
+
+    ctx_override: ClassVar[bool] = True
+
+    async def _execute(self, prompt: str, **cxt) -> Optional[str]:
+        """Execute the action."""
+        return self.save_checkpoint()

fabricatio_agent/capabilities/__init__.py

@@ -0,0 +1 @@
+"""Capabilities defined in fabricatio-agent."""

fabricatio_agent/capabilities/agent.py

@@ -0,0 +1,100 @@
+"""Agent capability implementation."""
+
+from abc import ABC
+from typing import Any, List, Optional, Unpack
+
+from fabricatio_capabilities.capabilities.task import DispatchTask
+from fabricatio_capable.capabilities.capable import Capable
+from fabricatio_checkpoint.capabilities.checkpoint import Checkpoint
+from fabricatio_core.models.kwargs_types import GenerateKwargs
+from fabricatio_core.rust import TEMPLATE_MANAGER
+from fabricatio_core.utils import ok
+from fabricatio_diff.capabilities.diff_edit import DiffEdit
+from fabricatio_judge.capabilities.advanced_judge import EvidentlyJudge
+from fabricatio_memory.capabilities.remember import Remember
+from fabricatio_question.capabilities.questioning import Questioning
+from fabricatio_rule.capabilities.censor import Censor
+from fabricatio_team.capabilities.digest import CooperativeDigest
+from fabricatio_thinking.capabilities.thinking import Thinking
+from fabricatio_tool.capabilities.handle import Handle
+
+from fabricatio_agent.config import agent_config
+
+
+class Agent(
+    Checkpoint,
+    Capable,
+    CooperativeDigest,
+    Remember,
+    Censor,
+    EvidentlyJudge,
+    DispatchTask,
+    DiffEdit,
+    Questioning,
+    Thinking,
+    Handle,
+    ABC,
+):
+    """Main agent class that integrates multiple capabilities to fulfill requests.
+
+    This class combines various capabilities like memory, thinking, task dispatching,
+    and team cooperation to process and fulfill user requests.
+    """
+
+    async def fulfill(
+        self,
+        request: str,
+        sequential_thinking: Optional[bool] = None,
+        check_capable: bool = False,
+        memory: bool = False,
+        top_k: int = 100,
+        boost_recent: bool = True,
+        **kwargs: Unpack[GenerateKwargs],
+    ) -> None | List[Any]:
+        """Process and fulfill a request using various agent capabilities.
+
+        Args:
+            request (str): The request to be fulfilled.
+            sequential_thinking (Optional[bool], optional): Whether to use sequential thinking.
+                Defaults to None.
+            check_capable (bool, optional): Whether to check agent capabilities before processing.
+                Defaults to False.
+            memory (bool, optional): Whether to use memory in processing. Defaults to False.
+            top_k (int, optional): Number of top memories to recall. Defaults to 100.
+            boost_recent (bool, optional): Whether to boost recent memories. Defaults to True.
+            **kwargs (Unpack[GenerateKwargs]): Additional keyword arguments for generation.
+
+        Returns:
+            None | List[Any]: None if not capable, otherwise a list of execution results.
+
+        Note:
+            The method integrates multiple capabilities:
+
+            - Checks capabilities if required
+            - Recalls memories if enabled
+            - Performs sequential thinking if enabled
+            - Digests the request into tasks
+            - Executes the generated task list
+        """
+        if (check_capable or agent_config.check_capable) and not await self.capable(request, **kwargs):  # pyright: ignore [reportCallIssue]
+            return None
+        mem = ""
+        thought = ""
+        if memory or agent_config.memory:
+            mem = await self.recall(request, top_k, boost_recent, **kwargs)
+
+        if sequential_thinking or agent_config.sequential_thinking:
+            thought = (await self.thinking(request, **kwargs)).export_branch_string()
+
+        task_list = ok(
+            await self.digest(
+                TEMPLATE_MANAGER.render_template(
+                    agent_config.fulfill_prompt_template, {"request": request, "mem": mem, "thoughts": thought}
+                ),
+                ok(self.team_roster),
+                **kwargs,
+            )
+        )
+        task_list.add_before_exec_hook(lambda: self.save_checkpoint(f"{request[:50]}..."))
+
+        return await task_list.execute()

fabricatio_agent/cli.py

@@ -0,0 +1,148 @@
+"""CLI entry point."""
+
+from fabricatio_core.utils import cfg
+
+cfg(feats=["cli"])
+from enum import StrEnum
+from typing import Dict
+
+from fabricatio_core import Event, Role, Task, WorkFlow
+from fabricatio_core.rust import is_installed
+from fabricatio_team.capabilities.team import Cooperate
+from fabricatio_team.models.team import Team
+from pydantic import Field
+from typer import Argument, Option, Typer
+
+from fabricatio_agent.actions.code import CleanUp, Planning, WriteCode
+
+
+class TaskType(StrEnum):
+    """Task types."""
+
+    Coding = "coding"
+    Orchestrate = "orchestrate"
+    CleanUp = "cleanup"
+    Plot = "plot"
+    Synthesize = "synthesize"
+    Test = "test"
+    Documentation = "documentation"
+
+
+app = Typer()
+
+dev_reg = {
+    Event.quick_instantiate(TaskType.Coding): WorkFlow(
+        name="WriteCodeWorkFlow",
+        description="Generate desired code and then write that code to a file",
+        steps=(WriteCode().to_task_output(),),
+    ),
+    Event.quick_instantiate(TaskType.CleanUp): WorkFlow(
+        name="CleanWorkFlow",
+        description="Clean unwanted files or directories.",
+        steps=(CleanUp().to_task_output(),),
+    ),
+}
+
+if is_installed("fabricatio_plot"):
+    from fabricatio_plot.actions.fs import SaveDataCSV
+    from fabricatio_plot.actions.plot import MakeCharts
+    from fabricatio_plot.actions.synthesize import MakeSynthesizedData
+
+    dev_reg.update(
+        {
+            Event.quick_instantiate(TaskType.Plot): WorkFlow(
+                name="PlotWorkFlow",
+                description="Generate plots and charts using matplotlib and save to fs.",
+                steps=(MakeCharts().to_task_output(),),
+            ),
+            Event.quick_instantiate(TaskType.Synthesize): WorkFlow(
+                name="SynthesizeWorkFlow",
+                description="Synthesize data using synthesize data capabilities.",
+                steps=(
+                    MakeSynthesizedData(output_key="data_to_save"),
+                    SaveDataCSV().to_task_output(),
+                ),
+            ),
+        }
+    )
+
+
+class Developer(Role, Cooperate):
+    """A developer role capable of handling coding tasks."""
+
+    skills: Dict[Event, WorkFlow] = Field(
+        default_factory=lambda: dev_reg,
+        frozen=True,
+    )
+    """The registry of events and workflows."""
+
+
+class TestEngineer(Role, Cooperate):
+    """A test engineer role for generating test cases."""
+
+    skills: Dict[Event, WorkFlow] = Field(
+        default_factory=lambda: {
+            Event.quick_instantiate(TaskType.Test): WorkFlow(
+                name="GenerateTestcasesWorkFlow",
+                description="Generate test cases for the given task.",
+                steps=(WriteCode().to_task_output(),),
+            )
+        }
+    )
+
+
+class DocumentationWriter(Role, Cooperate):
+    """A documentation writer role for writing documentation."""
+
+    skills: Dict[Event, WorkFlow] = Field(
+        default_factory=lambda: {
+            Event.quick_instantiate(TaskType.Test): WorkFlow(
+                name="GenerateDocumentationWorkFlow",
+                description="Generate documentation for the given task.",
+                steps=(WriteCode().to_task_output(),),
+            )
+        }
+    )
+
+
+class ProjectLeader(Role, Cooperate):
+    """A project leader role capable of handling planning tasks.
+
+    This role implements the Cooperate capability and maintains a registry of workflows
+    for different task types. The project leader can execute planning tasks through the
+    PlanningWorkFlow which breaks down complex tasks into smaller subtasks.
+    """
+
+    skills: Dict[Event, WorkFlow] = Field(
+        default_factory=lambda: {
+            Event.quick_instantiate(TaskType.Orchestrate): WorkFlow(
+                name="OrchestrateWorkFlow",
+                description="This workflow is extremely expensive, so YOU SHALL use this as less as possible, you can use this only when necessary. Capable to finish task that is completely beyond your reach, but do add enough detailed context into task metadata. ",
+                steps=(Planning().to_task_output(),),
+            ),
+        },
+        frozen=True,
+    )
+    """The registry of events and workflows."""
+
+
+@app.command(no_args_is_help=True)
+def code(
+    prompt: str = Argument(..., help="The prompt to generate code from."),
+    sequential_thinking: bool = Option(
+        False, "-sq", "--sequential-thinking", help="Whether to use sequential thinking."
+    ),
+) -> None:
+    """Generate code based on the provided prompt.
+
+    This function creates a development team with a Developer role and dispatches
+    a coding task. If the task is complex, it will be broken down into smaller
+    subtasks through the architect workflow.
+    """
+    Team().join(Developer()).join(ProjectLeader()).join(TestEngineer()).join(DocumentationWriter()).inform().dispatch()
+    task = Task(name="Write code", description=prompt).update_init_context(sequential_thinking=sequential_thinking)
+    task.delegate_blocking(TaskType.Orchestrate)
+
+
+if __name__ == "__main__":
+    app()

fabricatio_agent/config.py

@@ -0,0 +1,24 @@
+"""Module containing configuration classes for fabricatio-agent."""
+
+from dataclasses import dataclass
+
+from fabricatio_core import CONFIG
+
+
+@dataclass(frozen=True)
+class AgentConfig:
+    """Configuration for fabricatio-agent."""
+
+    memory: bool = False
+    """Whether to use memory."""
+    sequential_thinking: bool = False
+    """Whether to think sequentially."""
+    check_capable: bool = False
+    """Whether to check if the agent is capable of performing the task."""
+    fulfill_prompt_template: str = "built-in/fulfill_prompt"
+    """The prompt template to use for fulfill."""
+
+
+agent_config = CONFIG.load("agent", AgentConfig)
+
+__all__ = ["agent_config"]

fabricatio_agent/models/__init__.py

@@ -0,0 +1 @@
+"""Models defined in fabricatio-agent."""

fabricatio_agent/models/agent.py

@@ -0,0 +1 @@
+"""This module contains the models for the agent."""

fabricatio_agent/rust.pyi

@@ -0,0 +1 @@
+"""Rust bindings for the Rust API of fabricatio-agent."""

fabricatio_agent/workflows/__init__.py

@@ -0,0 +1 @@
+"""Workflows defined in fabricatio-agent."""

fabricatio_agent-0.2.4.dev7.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: fabricatio-agent
+Version: 0.2.4.dev7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Typing :: Typed
+Requires-Dist: fabricatio-core
+Requires-Dist: fabricatio-digest
+Requires-Dist: fabricatio-memory
+Requires-Dist: fabricatio-improve
+Requires-Dist: fabricatio-rule
+Requires-Dist: fabricatio-judge
+Requires-Dist: fabricatio-capabilities
+Requires-Dist: fabricatio-diff
+Requires-Dist: fabricatio-thinking
+Requires-Dist: fabricatio-question
+Requires-Dist: fabricatio-tool
+Requires-Dist: fabricatio-team
+Requires-Dist: fabricatio-capable
+Requires-Dist: fabricatio-checkpoint
+Requires-Dist: typer-slim[standard]>=0.15.2 ; extra == 'cli'
+Requires-Dist: fabricatio-actions ; extra == 'cli'
+Requires-Dist: fabricatio-agent[cli] ; extra == 'cli-plot'
+Requires-Dist: fabricatio-plot ; extra == 'cli-plot'
+Requires-Dist: fabricatio-agent[cli] ; extra == 'cli-full'
+Requires-Dist: fabricatio-agent[cli-plot] ; extra == 'cli-full'
+Provides-Extra: cli
+Provides-Extra: cli-plot
+Provides-Extra: cli-full
+Summary: An extension of fabricatio
+Author-email: Whth <zettainspector@foxmail.com>
+License-Expression: MIT
+Requires-Python: >=3.12, <3.15
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/Whth/fabricatio
+Project-URL: Repository, https://github.com/Whth/fabricatio
+Project-URL: Issues, https://github.com/Whth/fabricatio/issues
+
+# `fabricatio-agent`
+
+[MIT](https://img.shields.io/badge/license-MIT-blue.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/fabricatio-agent)
+[![PyPI Version](https://img.shields.io/pypi/v/fabricatio-agent)](https://pypi.org/project/fabricatio-agent/)
+[![PyPI Downloads](https://static.pepy.tech/badge/fabricatio-agent/week)](https://pepy.tech/projects/fabricatio-agent)
+[![PyPI Downloads](https://static.pepy.tech/badge/fabricatio-agent)](https://pepy.tech/projects/fabricatio-agent)
+[![Bindings: PyO3](https://img.shields.io/badge/bindings-pyo3-green)](https://github.com/PyO3/pyo3)
+[![Build Tool: uv + maturin](https://img.shields.io/badge/built%20with-uv%20%2B%20maturin-orange)](https://github.com/astral-sh/uv)
+
+An extension of fabricatio.
+
+---
+
+## 📦 Installation
+
+This package is part of the `fabricatio` monorepo and can be installed as an optional dependency using either pip or uv:
+
+```bash
+pip install fabricatio[agent]
+# or
+uv pip install fabricatio[agent]
+```
+
+For a full installation that includes this package and all other components of `fabricatio`:
+
+```bash
+pip install fabricatio[full]
+# or
+uv pip install fabricatio[full]
+```
+
+## 🔍 Overview
+
+Provides a comprehensive AI agent framework that integrates multiple capabilities for autonomous task fulfillment. The
+agent combines thinking, memory, team cooperation, and various specialized capabilities to process and execute complex
+requests, making it a central orchestrator in the fabricatio ecosystem for intelligent workflow automation.
+
+## 🧩 Key Features
+
+- **Multi-Capability Integration**: Combines thinking, memory, judgment, task dispatching, and team cooperation
+  capabilities
+- **Autonomous Task Fulfillment**: Processes requests through sequential thinking and task decomposition
+- **Memory-Augmented Processing**: Recalls relevant information to enhance decision making and context awareness
+- **Team Collaboration**: Supports cooperative workflows with multiple specialized agents
+- **Configurable Behavior**: Customizable settings for thinking mode, memory usage, and capability checking
+- **Template-Driven Execution**: Uses configurable prompt templates for consistent and adaptable behavior
+
+## 🔗 Dependencies
+
+Core dependencies:
+
+- `fabricatio-core` - Core interfaces and utilities
+- `fabricatio-digest` - Request digestion and task planning
+- `fabricatio-memory` - Memory management and recall
+- `fabricatio-improve` - Content improvement capabilities
+- `fabricatio-rule` - Rule-based content processing
+- `fabricatio-judge` - Advanced judgment and evaluation
+- `fabricatio-capabilities` - Base capability patterns
+- `fabricatio-diff` - Difference editing operations
+- `fabricatio-thinking` - Sequential thinking processes
+- `fabricatio-question` - Interactive questioning
+- `fabricatio-tool` - Tool handling and execution
+- `fabricatio-team` - Team cooperation mechanisms
+- `fabricatio-capable` - Capability assessment
+
+## 📄 License
+
+MIT – see [LICENSE](../../LICENSE)
+
+

fabricatio_agent-0.2.4.dev7.dist-info/RECORD

@@ -0,0 +1,17 @@
+fabricatio_agent-0.2.4.dev7.dist-info/METADATA,sha256=69xHb_ffiJ3RkyeXS3t_YjorrGMSbv2rX59z1XhBq50,4702
+fabricatio_agent-0.2.4.dev7.dist-info/WHEEL,sha256=ZrAiv7lKoKZh206bhSq4g-n3q3ySUOJQmQ4WXAA7TE8,97
+fabricatio_agent-0.2.4.dev7.dist-info/entry_points.txt,sha256=3KDr1lHnm25WWKwwD_3J9QE1DGzaSpUtpcKQfx6deAQ,50
+fabricatio_agent/__init__.py,sha256=gumbL2CwfKm4bnxOVpyhYxAIwfVldHTB30OCZBtxxMw,35
+fabricatio_agent/actions/__init__.py,sha256=GECfG19Lfbvqx67Fx2i25naQKq1ikTp7Lvu3ZGYdohY,44
+fabricatio_agent/actions/code.py,sha256=hATW88iwvfC9gprJGrZWLgN25neNHkofZsvG7N2X_Ms,3044
+fabricatio_agent/capabilities/__init__.py,sha256=qpalNLgxQnKNcYTw1HdeCPcgV4edsqtQcM7YWYoa9ak,49
+fabricatio_agent/capabilities/agent.py,sha256=iuLeBhuQZ4TFJpJYVCwi95jJhIQ_j-dsUzNeUS9aC7E,3992
+fabricatio_agent/cli.py,sha256=9FkKnLh-QOIQPWCgZ74t1vX5MmxO9qLS7vyrB3GrVq8,5209
+fabricatio_agent/config.py,sha256=w1tVP2sci0yGAK_tgF9KGowiOA0QUFPzT-TG21jQ49Y,689
+fabricatio_agent/models/__init__.py,sha256=c0QznffHLV2_7YYd32u0X6MNaqvW1lr8chDZRznFU8o,43
+fabricatio_agent/models/agent.py,sha256=hX3DdWT99VK2AdqKK0_NZGfRnci8M7c05OY9eaBcIkc,54
+fabricatio_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fabricatio_agent/rust.cp314-win_amd64.pyd,sha256=lwbWGaqar8VqdqwA67b1EQwuzzDhiKm_a40tECdwi8g,284672
+fabricatio_agent/rust.pyi,sha256=96hRXiP7K2n2ztjK6mLENMF4GMgMWySvR7sjvWiO7bg,59
+fabricatio_agent/workflows/__init__.py,sha256=eWbhVVtOrwYxioz0UZ5u6sBqVZtXKmTCeQCQDfKH5Ns,46
+fabricatio_agent-0.2.4.dev7.dist-info/RECORD,,

fabricatio_agent-0.2.4.dev7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.2)
+Root-Is-Purelib: false
+Tag: cp314-cp314-win_amd64

fabricatio_agent-0.2.4.dev7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+falcon=fabricatio_agent.cli:app