codepromptforge 0.0.7

A tool to combine code files into a single prompt

CodePromptForge ToolKit for Agent Development

Overview

The CodePromptForge ToolKit provides a set of LangChain-compatible tools for developing AI agents that can read, analyze, modify, and write code. These tools enable agents to explore a codebase, extract insights, generate new content, and modify files dynamically.

Features

• File and Directory Inspection: Retrieve file contents, list directory structures, and analyze project organization.
• Automated Code Processing: Identify and manipulate specific code files based on extensions.
• Code Modification: Write and update files programmatically.
• Cleanup and Maintenance: Remove unnecessary files from results folders.
• Seamless Integration: Designed to work with LangChain's agent framework.
• Optional Assistant Module: Allows users to create and register AI assistants.

---

Installation

Core Installation

To install the core functionality of CodePromptForge:

pip install codepromptforge

Installing with Assistant Module

To use the AI Assistant framework, install the package with the assistant extra:

pip install codepromptforge[assistant]

This includes dependencies such as:

• langchain_ollama
• langgraph

---

Available Tools

🔍 1. get_directory_tree

Retrieve the structure of a directory
Returns a list of all files in a specified directory, ignoring files in .gitignore or explicitly excluded.

Usage

tool = GetDirectoryTreeTool()
tool.run(folder_path="src")

Response

["src/main.py", "src/utils/helpers.py", "src/config/settings.json"]

---

📄 2. get_file_content

Read the content of a specific file
Retrieves the contents of a file for analysis or processing.

Usage

tool = GetFileContentTool()
tool.run(file_path="src/main.py")

Response

"def main():\n    print('Hello, world!')"

---

📂 3. get_files_in_folder

List all files in a specific folder with their contents
Provides a dictionary where keys are file names and values are their contents.

Usage

tool = GetFilesInFolderTool()
tool.run(folder_path="src")

Response

{
    "main.py": "def main():\n    print('Hello, world!')",
    "config.json": "{'debug': true, 'version': '1.0'}"
}

---

📁 4. get_files_recursively

Retrieve all files in a folder and its subdirectories
Useful for analyzing an entire project structure.

Usage

tool = GetFilesRecursivelyTool()
tool.run(folder_path="src")

Response

{
    "src/main.py": "def main():\n    print('Hello, world!')",
    "src/utils/helpers.py": "def helper():\n    return 'Helper function'"
}

---

🔎 5. find_files

Find all files matching specific extensions in the base directory
Helpful for searching for specific types of files, such as Python scripts or Markdown documentation.

Usage

tool = FindFilesTool()
tool.run(extensions=["py", "md"])

Response

["src/main.py", "docs/readme.md"]

---

✍️ 6. write_file

Write or modify a file
Creates or modifies a file inside the .result folder.

Usage

tool = WriteFileTool()
tool.run(file_path="output.txt", content="New content for the file")

Response

"File written successfully: .result/output.txt"

---

🧹 7. clean_result_folder

Remove unnecessary files from the .result folder
Ensures that old files don’t clutter the workspace.

Usage

tool = CleanResultFolderTool()
tool.run(excluded_files=["output.txt"])

Response

"Cleaned .result folder. Removed files: ['output.txt']"

---

🛠 8. forge_prompt

Merge multiple files into a single prompt
Key feature for creating context-rich inputs for LLMs.

Usage

tool = ForgePromptTool()
tool.run(extensions=["py", "md"])

Response

"Merged files: ['src/main.py', 'docs/readme.md']"

---

🚀 9. run

Runs the forge process on specified file extensions
Automates the process of finding, merging, and generating code prompts.

Usage

tool = RunTool()
tool.run(extensions=["py", "txt"])

Response

"Generated combined prompt in output.txt"

---

Building AI Agents with the ToolKit

The CodePromptForge ToolKit is designed to be integrated into LangChain agents for intelligent code analysis. Here’s how you can create a React agent that uses these tools:

from langchain.agents import initialize_agent
from langchain.chat_models import ChatOpenAI
from codepromptforge.main import CodePromptForge

# Initialize the CodePromptForge toolkit
forge = CodePromptForge(base_dir=".")

# Create an agent with the tools
agent = initialize_agent(
    tools=forge.get_tools(),
    llm=ChatOpenAI(temperature=0),
    agent="zero-shot-react-description",
    verbose=True
)

# Example: Ask the agent to analyze the project directory
agent.run("List all Python files in the project and summarize their content.")

Expected Behavior

1. The agent will call get_directory_tree() to explore the project structure.
2. It will filter files using find_files(["py"]) to locate Python scripts.
3. It will use get_file_content() to analyze each file.
4. Based on the retrieved content, it will generate a summary.

---

Using the Assistant Module

If installed with [assistant], you can leverage AI assistants to process and generate code.

Example Usage

from codepromptforge.assistant import AssistantRegistry

# List available assistants
print(AssistantRegistry.list_assistants())  
# Expected output: ['react_assistant']

from langchain_ollama import ChatOllama

# Initialize an LLM
llm = ChatOllama(
    model="qwen2.5:14b",
    temperature=0,
    num_ctx=80000,
    num_gpu=1,
)

# Retrieve and use the assistant
agent = AssistantRegistry.get_assistant('react_assistant', llm)

def print_stream(stream):
    for s in stream:
        message = s["messages"][-1]
        if isinstance(message, tuple):
            print(message)
        else:
            message.pretty_print()

# Provide a query for the assistant
inputs = {
    "messages": [("user", "This is my package named CodePromptForge. Your job is to describe what needs to be modified to improve the current code")]
}

print_stream(agent.stream(inputs, stream_mode="values"))

Expected Output

The assistant will analyze the package and suggest improvements based on best practices.

---

Conclusion

The CodePromptForge ToolKit provides a ready-to-use suite of tools that can be seamlessly integrated into AI agents for code reading, modification, and generation. Whether you're building LLM-based code assistants, automated reviewers, or code refactoring agents, these tools simplify and automate complex workflows.

---

🚀 Start developing with CodePromptForge today! 🚀