Initial commit

ai/.gitignore

@@ -0,0 +1,6 @@
+.env
+__pycache__/
+*.pyc
+fuzzforge_sessions.db
+agentops.log
+*.log

ai/README.md

@@ -0,0 +1,110 @@
+# FuzzForge AI Module
+
+FuzzForge AI is the multi-agent layer that lets you operate the FuzzForge security platform through natural language. It orchestrates local tooling, registered Agent-to-Agent (A2A) peers, and the Prefect-powered backend while keeping long-running context in memory and project knowledge graphs.
+
+## Quick Start
+
+1. **Initialise a project**
+   ```bash
+   cd /path/to/project
+   fuzzforge init
+   ```
+2. **Review environment settings** – copy `.fuzzforge/.env.template` to `.fuzzforge/.env`, then edit the values to match your provider. The template ships with commented defaults for OpenAI-style usage and placeholders for Cognee keys.
+   ```env
+   LLM_PROVIDER=openai
+   LITELLM_MODEL=gpt-5-mini
+   OPENAI_API_KEY=sk-your-key
+   FUZZFORGE_MCP_URL=http://localhost:8010/mcp
+   SESSION_PERSISTENCE=sqlite
+   ```
+   Optional flags you may want to enable early:
+   ```env
+   MEMORY_SERVICE=inmemory
+   AGENTOPS_API_KEY=sk-your-agentops-key   # Enable hosted tracing
+   LOG_LEVEL=INFO                          # CLI / server log level
+   ```
+3. **Populate the knowledge graph**
+   ```bash
+   fuzzforge ingest --path . --recursive
+   # alias: fuzzforge rag ingest --path . --recursive
+   ```
+4. **Launch the agent shell**
+   ```bash
+   fuzzforge ai agent
+   ```
+   Keep the backend running (Prefect API at `FUZZFORGE_MCP_URL`) so workflow commands succeed.
+
+## Everyday Workflow
+
+- Run `fuzzforge ai agent` and start with `list available fuzzforge workflows` or `/memory status` to confirm everything is wired.
+- Use natural prompts for automation (`run fuzzforge workflow …`, `search project knowledge for …`) and fall back to slash commands for precision (`/recall`, `/sendfile`).
+- Keep `/memory datasets` handy to see which Cognee datasets are available after each ingest.
+- Start the HTTP surface with `python -m fuzzforge_ai` when external agents need access to artifacts or graph queries. The CLI stays usable at the same time.
+- Refresh the knowledge graph regularly: `fuzzforge ingest --path . --recursive --force` keeps responses aligned with recent code changes.
+
+## What the Agent Can Do
+
+- **Route requests** – automatically selects the right local tool or remote agent using the A2A capability registry.
+- **Run security workflows** – list, submit, and monitor FuzzForge workflows via MCP wrappers.
+- **Manage artifacts** – create downloadable files for reports, code edits, and shared attachments.
+- **Maintain context** – stores session history, semantic recall, and Cognee project graphs.
+- **Serve over HTTP** – expose the same agent as an A2A server using `python -m fuzzforge_ai`.
+
+## Essential Commands
+
+Inside `fuzzforge ai agent` you can mix slash commands and free-form prompts:
+
+```text
+/list                     # Show registered A2A agents
+/register http://:10201   # Add a remote agent
+/artifacts                 # List generated files
+/sendfile SecurityAgent src/report.md "Please review"
+You> route_to SecurityAnalyzer: scan ./backend for secrets
+You> run fuzzforge workflow static_analysis_scan on ./test_projects/demo
+You> search project knowledge for "prefect status" using INSIGHTS
+```
+
+Artifacts created during the conversation are served from `.fuzzforge/artifacts/` and exposed through the A2A HTTP API.
+
+## Memory & Knowledge
+
+The module layers three storage systems:
+
+- **Session persistence** (SQLite or in-memory) for chat transcripts.
+- **Semantic recall** via the ADK memory service for fuzzy search.
+- **Cognee graphs** for project-wide knowledge built from ingestion runs.
+
+Re-run ingestion after major code changes to keep graph answers relevant. If Cognee variables are not set, graph-specific tools automatically respond with a polite "not configured" message.
+
+## Sample Prompts
+
+Use these to validate the setup once the agent shell is running:
+
+- `list available fuzzforge workflows`
+- `run fuzzforge workflow static_analysis_scan on ./backend with target_branch=main`
+- `show findings for that run once it finishes`
+- `refresh the project knowledge graph for ./backend`
+- `search project knowledge for "prefect readiness" using INSIGHTS`
+- `/recall terraform secrets`
+- `/memory status`
+- `ROUTE_TO SecurityAnalyzer: audit infrastructure_vulnerable`
+
+## Need More Detail?
+
+Dive into the dedicated guides under `ai/docs/advanced/`:
+
+- [Architecture](https://docs.fuzzforge.ai/docs/ai/intro) – High-level architecture with diagrams and component breakdowns.
+- [Ingestion](https://docs.fuzzforge.ai/docs/ai/ingestion.md) – Command options, Cognee persistence, and prompt examples.
+- [Configuration](https://docs.fuzzforge.ai/docs/ai/configuration.md) – LLM provider matrix, local model setup, and tracing options.
+- [Prompts](https://docs.fuzzforge.ai/docs/ai/prompts.md) – Slash commands, workflow prompts, and routing tips.
+- [A2A Services](https://docs.fuzzforge.ai/docs/ai/a2a-services.md) – HTTP endpoints, agent card, and collaboration flow.
+- [Memory Persistence](https://docs.fuzzforge.ai/docs/ai/architecture.md#memory--persistence) – Deep dive on memory storage, datasets, and how `/memory status` inspects them.
+
+## Development Notes
+
+- Entry point for the CLI: `ai/src/fuzzforge_ai/cli.py`
+- A2A HTTP server: `ai/src/fuzzforge_ai/a2a_server.py`
+- Tool routing & workflow glue: `ai/src/fuzzforge_ai/agent_executor.py`
+- Ingestion helpers: `ai/src/fuzzforge_ai/ingest_utils.py`
+
+Install the module in editable mode (`pip install -e ai`) while iterating so CLI changes are picked up immediately.

ai/llm.txt

@@ -0,0 +1,93 @@
+FuzzForge AI LLM Configuration Guide
+===================================
+
+This note summarises the environment variables and libraries that drive LiteLLM (via the Google ADK runtime) inside the FuzzForge AI module. For complete matrices and advanced examples, read `docs/advanced/configuration.md`.
+
+Core Libraries
+--------------
+- `google-adk` – hosts the agent runtime, memory services, and LiteLLM bridge.
+- `litellm` – provider-agnostic LLM client used by ADK and the executor.
+- Provider SDKs – install the SDK that matches your target backend (`openai`, `anthropic`, `google-cloud-aiplatform`, `groq`, etc.).
+- Optional extras: `agentops` for tracing, `cognee[all]` for knowledge-graph ingestion, `ollama` CLI for running local models.
+
+Quick install foundation::
+
+```
+pip install google-adk litellm openai
+```
+
+Add any provider-specific SDKs (for example `pip install anthropic groq`) on top of that base.
+
+Baseline Setup
+--------------
+Copy `.fuzzforge/.env.template` to `.fuzzforge/.env` and set the core fields:
+
+```
+LLM_PROVIDER=openai
+LITELLM_MODEL=gpt-5-mini
+OPENAI_API_KEY=sk-your-key
+FUZZFORGE_MCP_URL=http://localhost:8010/mcp
+SESSION_PERSISTENCE=sqlite
+MEMORY_SERVICE=inmemory
+```
+
+LiteLLM Provider Examples
+-------------------------
+
+OpenAI-compatible (Azure, etc.)::
+```
+LLM_PROVIDER=azure_openai
+LITELLM_MODEL=gpt-4o-mini
+LLM_API_KEY=sk-your-azure-key
+LLM_ENDPOINT=https://your-resource.openai.azure.com
+```
+
+Anthropic::
+```
+LLM_PROVIDER=anthropic
+LITELLM_MODEL=claude-3-haiku-20240307
+ANTHROPIC_API_KEY=sk-your-key
+```
+
+Ollama (local)::
+```
+LLM_PROVIDER=ollama_chat
+LITELLM_MODEL=codellama:latest
+OLLAMA_API_BASE=http://localhost:11434
+```
+Run `ollama pull codellama:latest` so the adapter can respond immediately.
+
+Vertex AI::
+```
+LLM_PROVIDER=vertex_ai
+LITELLM_MODEL=gemini-1.5-pro
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
+```
+
+Provider Checklist
+------------------
+- **OpenAI / Azure OpenAI**: `LLM_PROVIDER`, `LITELLM_MODEL`, API key, optional endpoint + API version (Azure).
+- **Anthropic**: `LLM_PROVIDER=anthropic`, `LITELLM_MODEL`, `ANTHROPIC_API_KEY`.
+- **Google Vertex AI**: `LLM_PROVIDER=vertex_ai`, `LITELLM_MODEL`, `GOOGLE_APPLICATION_CREDENTIALS`, `GOOGLE_CLOUD_PROJECT`.
+- **Groq**: `LLM_PROVIDER=groq`, `LITELLM_MODEL`, `GROQ_API_KEY`.
+- **Ollama / Local**: `LLM_PROVIDER=ollama_chat`, `LITELLM_MODEL`, `OLLAMA_API_BASE`, and the model pulled locally (`ollama pull <model>`).
+
+Knowledge Graph Add-ons
+-----------------------
+Set these only if you plan to use Cognee project graphs:
+
+```
+LLM_COGNEE_PROVIDER=openai
+LLM_COGNEE_MODEL=gpt-5-mini
+LLM_COGNEE_API_KEY=sk-your-key
+```
+
+Tracing & Debugging
+-------------------
+- Provide `AGENTOPS_API_KEY` to enable hosted traces for every conversation.
+- Set `FUZZFORGE_DEBUG=1` (and optionally `LOG_LEVEL=DEBUG`) for verbose executor output.
+- Restart the agent after changing environment variables; LiteLLM loads configuration on boot.
+
+Further Reading
+---------------
+`docs/advanced/configuration.md` – provider comparison, debugging flags, and referenced modules.

ai/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "fuzzforge-ai"
+version = "0.6.0"
+description = "FuzzForge AI orchestration module"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "google-adk",
+    "a2a-sdk",
+    "litellm",
+    "python-dotenv",
+    "httpx",
+    "uvicorn",
+    "rich",
+    "agentops",
+    "fastmcp",
+    "mcp",
+    "typing-extensions",
+    "cognee>=0.3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-asyncio",
+    "black",
+    "ruff",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fuzzforge_ai"]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.uv]
+dev-dependencies = [
+    "pytest",
+    "pytest-asyncio",
+]

ai/src/fuzzforge_ai/__init__.py

@@ -0,0 +1,24 @@
+"""
+FuzzForge AI Module - Agent-to-Agent orchestration system
+
+This module integrates the fuzzforge_ai components into FuzzForge,
+providing intelligent AI agent capabilities for security analysis.
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+__version__ = "0.6.0"
+
+from .agent import FuzzForgeAgent
+from .config_manager import ConfigManager
+
+__all__ = ['FuzzForgeAgent', 'ConfigManager']

ai/src/fuzzforge_ai/__main__.py

@@ -0,0 +1,109 @@
+"""
+FuzzForge A2A Server
+Run this to expose FuzzForge as an A2A-compatible agent
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+import warnings
+import logging
+from dotenv import load_dotenv
+
+from fuzzforge_ai.config_bridge import ProjectConfigManager
+
+# Suppress warnings
+warnings.filterwarnings("ignore")
+logging.getLogger("google.adk").setLevel(logging.ERROR)
+logging.getLogger("google.adk.tools.base_authenticated_tool").setLevel(logging.ERROR)
+
+# Load .env from .fuzzforge directory first, then fallback
+from pathlib import Path
+
+# Ensure Cognee logs stay inside the project workspace
+project_root = Path.cwd()
+default_log_dir = project_root / ".fuzzforge" / "logs"
+default_log_dir.mkdir(parents=True, exist_ok=True)
+log_path = default_log_dir / "cognee.log"
+os.environ.setdefault("COGNEE_LOG_PATH", str(log_path))
+fuzzforge_env = Path.cwd() / ".fuzzforge" / ".env"
+if fuzzforge_env.exists():
+    load_dotenv(fuzzforge_env, override=True)
+else:
+    load_dotenv(override=True)
+
+# Ensure Cognee uses the project-specific storage paths when available
+try:
+    project_config = ProjectConfigManager()
+    project_config.setup_cognee_environment()
+except Exception:
+    # Project may not be initialized; fall through with default settings
+    pass
+
+# Check configuration
+if not os.getenv('LITELLM_MODEL'):
+    print("[ERROR] LITELLM_MODEL not set in .env file")
+    print("Please set LITELLM_MODEL to your desired model (e.g., gpt-4o-mini)")
+    exit(1)
+
+from .agent import get_fuzzforge_agent
+from .a2a_server import create_a2a_app as create_custom_a2a_app
+
+
+def create_a2a_app():
+    """Create the A2A application"""
+    # Get configuration
+    port = int(os.getenv('FUZZFORGE_PORT', 10100))
+    
+    # Get the FuzzForge agent
+    fuzzforge = get_fuzzforge_agent()
+    
+    # Print ASCII banner
+    print("\033[95m")  # Purple color
+    print(" ███████╗██╗   ██╗███████╗███████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗     █████╗ ██╗")
+    print(" ██╔════╝██║   ██║╚══███╔╝╚══███╔╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝    ██╔══██╗██║")
+    print(" █████╗  ██║   ██║  ███╔╝   ███╔╝ █████╗  ██║   ██║██████╔╝██║  ███╗█████╗      ███████║██║")
+    print(" ██╔══╝  ██║   ██║ ███╔╝   ███╔╝  ██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝      ██╔══██║██║")
+    print(" ██║     ╚██████╔╝███████╗███████╗██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗    ██║  ██║██║")
+    print(" ╚═╝      ╚═════╝ ╚══════╝╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝    ╚═╝  ╚═╝╚═╝")
+    print("\033[0m")  # Reset color
+    
+    # Create A2A app
+    print(f"🚀 Starting FuzzForge A2A Server")
+    print(f"   Model: {fuzzforge.model}")
+    if fuzzforge.cognee_url:
+        print(f"   Memory: Cognee at {fuzzforge.cognee_url}")
+    print(f"   Port: {port}")
+    
+    app = create_custom_a2a_app(fuzzforge.adk_agent, port=port, executor=fuzzforge.executor)
+    
+    print(f"\n✅ FuzzForge A2A Server ready!")
+    print(f"   Agent card: http://localhost:{port}/.well-known/agent-card.json")
+    print(f"   A2A endpoint: http://localhost:{port}/")
+    print(f"\n📡 Other agents can register FuzzForge at: http://localhost:{port}")
+    
+    return app
+
+
+def main():
+    """Start the A2A server using uvicorn."""
+    import uvicorn
+
+    app = create_a2a_app()
+    port = int(os.getenv('FUZZFORGE_PORT', 10100))
+
+    print(f"\n🎯 Starting server with uvicorn...")
+    uvicorn.run(app, host="127.0.0.1", port=port)
+
+
+if __name__ == "__main__":
+    main()

ai/src/fuzzforge_ai/a2a_server.py

@@ -0,0 +1,230 @@
+"""Custom A2A wiring so we can access task store and queue manager."""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+from starlette.applications import Starlette
+from starlette.responses import Response, FileResponse
+from starlette.routing import Route
+
+from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
+from google.adk.a2a.utils.agent_card_builder import AgentCardBuilder
+from google.adk.a2a.experimental import a2a_experimental
+from google.adk.agents.base_agent import BaseAgent
+from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
+from google.adk.auth.credential_service.in_memory_credential_service import InMemoryCredentialService
+from google.adk.cli.utils.logs import setup_adk_logger
+from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.request_handlers.default_request_handler import DefaultRequestHandler
+from a2a.server.tasks.inmemory_task_store import InMemoryTaskStore
+from a2a.server.events.in_memory_queue_manager import InMemoryQueueManager
+from a2a.types import AgentCard
+
+from .agent_executor import FuzzForgeExecutor
+
+
+import json
+
+
+async def serve_artifact(request):
+    """Serve artifact files via HTTP for A2A agents"""
+    artifact_id = request.path_params["artifact_id"]
+    
+    # Try to get the executor instance to access artifact cache
+    # We'll store a reference to it during app creation
+    executor = getattr(serve_artifact, '_executor', None)
+    if not executor:
+        return Response("Artifact service not available", status_code=503)
+    
+    try:
+        # Look in the artifact cache directory
+        artifact_cache_dir = executor._artifact_cache_dir
+        artifact_dir = artifact_cache_dir / artifact_id
+        
+        if not artifact_dir.exists():
+            return Response("Artifact not found", status_code=404)
+            
+        # Find the artifact file (should be only one file in the directory)
+        artifact_files = list(artifact_dir.glob("*"))
+        if not artifact_files:
+            return Response("Artifact file not found", status_code=404)
+            
+        artifact_file = artifact_files[0]  # Take the first (and should be only) file
+        
+        # Determine mime type from file extension or default to octet-stream
+        import mimetypes
+        mime_type, _ = mimetypes.guess_type(str(artifact_file))
+        if not mime_type:
+            mime_type = 'application/octet-stream'
+            
+        return FileResponse(
+            path=str(artifact_file),
+            media_type=mime_type,
+            filename=artifact_file.name
+        )
+
+    except Exception as e:
+        return Response(f"Error serving artifact: {str(e)}", status_code=500)
+
+
+async def knowledge_query(request):
+    """Expose knowledge graph search over HTTP for external agents."""
+    executor = getattr(knowledge_query, '_executor', None)
+    if not executor:
+        return Response("Knowledge service not available", status_code=503)
+
+    try:
+        payload = await request.json()
+    except Exception:
+        return Response("Invalid JSON body", status_code=400)
+
+    query = payload.get("query")
+    if not query:
+        return Response("'query' is required", status_code=400)
+
+    search_type = payload.get("search_type", "INSIGHTS")
+    dataset = payload.get("dataset")
+
+    result = await executor.query_project_knowledge_api(
+        query=query,
+        search_type=search_type,
+        dataset=dataset,
+    )
+
+    status = 200 if not isinstance(result, dict) or "error" not in result else 400
+    return Response(
+        json.dumps(result, default=str),
+        status_code=status,
+        media_type="application/json",
+    )
+
+
+async def create_file_artifact(request):
+    """Create an artifact from a project file via HTTP."""
+    executor = getattr(create_file_artifact, '_executor', None)
+    if not executor:
+        return Response("File service not available", status_code=503)
+
+    try:
+        payload = await request.json()
+    except Exception:
+        return Response("Invalid JSON body", status_code=400)
+
+    path = payload.get("path")
+    if not path:
+        return Response("'path' is required", status_code=400)
+
+    result = await executor.create_project_file_artifact_api(path)
+    status = 200 if not isinstance(result, dict) or "error" not in result else 400
+    return Response(
+        json.dumps(result, default=str),
+        status_code=status,
+        media_type="application/json",
+    )
+
+
+def _load_agent_card(agent_card: Optional[Union[AgentCard, str]]) -> Optional[AgentCard]:
+    if agent_card is None:
+        return None
+    if isinstance(agent_card, AgentCard):
+        return agent_card
+
+    import json
+    from pathlib import Path
+
+    path = Path(agent_card)
+    with path.open('r', encoding='utf-8') as handle:
+        data = json.load(handle)
+    return AgentCard(**data)
+
+
+@a2a_experimental
+def create_a2a_app(
+    agent: BaseAgent,
+    *,
+    host: str = "localhost",
+    port: int = 8000,
+    protocol: str = "http",
+    agent_card: Optional[Union[AgentCard, str]] = None,
+    executor=None,  # Accept executor reference
+) -> Starlette:
+    """Variant of google.adk.a2a.utils.to_a2a that exposes task-store handles."""
+
+    setup_adk_logger(logging.INFO)
+
+    async def create_runner() -> Runner:
+        return Runner(
+            agent=agent,
+            app_name=agent.name or "fuzzforge",
+            artifact_service=InMemoryArtifactService(),
+            session_service=InMemorySessionService(),
+            memory_service=InMemoryMemoryService(),
+            credential_service=InMemoryCredentialService(),
+        )
+
+    task_store = InMemoryTaskStore()
+    queue_manager = InMemoryQueueManager()
+
+    agent_executor = A2aAgentExecutor(runner=create_runner)
+    request_handler = DefaultRequestHandler(
+        agent_executor=agent_executor,
+        task_store=task_store,
+        queue_manager=queue_manager,
+    )
+
+    rpc_url = f"{protocol}://{host}:{port}/"
+    provided_card = _load_agent_card(agent_card)
+
+    card_builder = AgentCardBuilder(agent=agent, rpc_url=rpc_url)
+
+    app = Starlette()
+
+    async def setup() -> None:
+        if provided_card is not None:
+            final_card = provided_card
+        else:
+            final_card = await card_builder.build()
+
+        a2a_app = A2AStarletteApplication(
+            agent_card=final_card,
+            http_handler=request_handler,
+        )
+        a2a_app.add_routes_to_app(app)
+        
+        # Add artifact serving route
+        app.router.add_route("/artifacts/{artifact_id}", serve_artifact, methods=["GET"])
+        app.router.add_route("/graph/query", knowledge_query, methods=["POST"])
+        app.router.add_route("/project/files", create_file_artifact, methods=["POST"])
+
+    app.add_event_handler("startup", setup)
+
+    # Expose handles so the executor can emit task updates later
+    FuzzForgeExecutor.task_store = task_store
+    FuzzForgeExecutor.queue_manager = queue_manager
+    
+    # Store reference to executor for artifact serving
+    serve_artifact._executor = executor
+    knowledge_query._executor = executor
+    create_file_artifact._executor = executor
+
+    return app
+
+
+__all__ = ["create_a2a_app"]

ai/src/fuzzforge_ai/agent.py

@@ -0,0 +1,133 @@
+"""
+FuzzForge Agent Definition
+The core agent that combines all components
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+from pathlib import Path
+from typing import Dict, Any, List
+from google.adk import Agent
+from google.adk.models.lite_llm import LiteLlm
+from .agent_card import get_fuzzforge_agent_card
+from .agent_executor import FuzzForgeExecutor
+from .memory_service import FuzzForgeMemoryService, HybridMemoryManager
+
+# Load environment variables from the AI module's .env file
+try:
+    from dotenv import load_dotenv
+    _ai_dir = Path(__file__).parent
+    _env_file = _ai_dir / ".env"
+    if _env_file.exists():
+        load_dotenv(_env_file, override=False)  # Don't override existing env vars
+except ImportError:
+    # dotenv not available, skip loading
+    pass
+
+
+class FuzzForgeAgent:
+    """The main FuzzForge agent that combines card, executor, and ADK agent"""
+    
+    def __init__(
+        self,
+        model: str = None,
+        cognee_url: str = None,
+        port: int = 10100,
+    ):
+        """Initialize FuzzForge agent with configuration"""
+        self.model = model or os.getenv('LITELLM_MODEL', 'gpt-4o-mini')
+        self.cognee_url = cognee_url or os.getenv('COGNEE_MCP_URL')
+        self.port = port
+
+        # Initialize ADK Memory Service for conversational memory
+        memory_type = os.getenv('MEMORY_SERVICE', 'inmemory')
+        self.memory_service = FuzzForgeMemoryService(memory_type=memory_type)
+        
+        # Create the executor (the brain) with memory and session services
+        self.executor = FuzzForgeExecutor(
+            model=self.model,
+            cognee_url=self.cognee_url,
+            debug=os.getenv('FUZZFORGE_DEBUG', '0') == '1',
+            memory_service=self.memory_service,
+            session_persistence=os.getenv('SESSION_PERSISTENCE', 'inmemory'),
+            fuzzforge_mcp_url=os.getenv('FUZZFORGE_MCP_URL'),
+        )
+        
+        # Create Hybrid Memory Manager (ADK + Cognee direct integration)
+        # MCP tools removed - using direct Cognee integration only
+        self.memory_manager = HybridMemoryManager(
+            memory_service=self.memory_service,
+            cognee_tools=None  # No MCP tools, direct integration used instead
+        )
+        
+        # Get the agent card (the identity)
+        self.agent_card = get_fuzzforge_agent_card(f"http://localhost:{self.port}")
+        
+        # Create the ADK agent (for A2A server mode)
+        self.adk_agent = self._create_adk_agent()
+        
+    def _create_adk_agent(self) -> Agent:
+        """Create the ADK agent for A2A server mode"""
+        # Build instruction
+        instruction = f"""You are {self.agent_card.name}, {self.agent_card.description}
+
+Your capabilities include:
+"""
+        for skill in self.agent_card.skills:
+            instruction += f"\n- {skill.name}: {skill.description}"
+        
+        instruction += """
+
+When responding to requests:
+1. Use your registered agents when appropriate
+2. Use Cognee memory tools when available
+3. Provide helpful, concise responses
+4. Maintain context across conversations
+"""
+        
+        # Create ADK agent
+        return Agent(
+            model=LiteLlm(model=self.model),
+            name=self.agent_card.name,
+            description=self.agent_card.description,
+            instruction=instruction,
+            tools=self.executor.agent.tools if hasattr(self.executor.agent, 'tools') else []
+        )
+    
+    async def process_message(self, message: str, context_id: str = None) -> str:
+        """Process a message using the executor"""
+        result = await self.executor.execute(message, context_id or "default")
+        return result.get("response", "No response generated")
+    
+    async def register_agent(self, url: str) -> Dict[str, Any]:
+        """Register a new agent"""
+        return await self.executor.register_agent(url)
+    
+    def list_agents(self) -> List[Dict[str, Any]]:
+        """List registered agents"""
+        return self.executor.list_agents()
+    
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.executor.cleanup()
+
+
+# Create a singleton instance for import
+_instance = None
+
+def get_fuzzforge_agent() -> FuzzForgeAgent:
+    """Get the singleton FuzzForge agent instance"""
+    global _instance
+    if _instance is None:
+        _instance = FuzzForgeAgent()
+    return _instance

ai/src/fuzzforge_ai/agent_card.py

@@ -0,0 +1,183 @@
+"""
+FuzzForge Agent Card and Skills Definition
+Defines what FuzzForge can do and how others can discover it
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+
+@dataclass
+class AgentSkill:
+    """Represents a specific capability of the agent"""
+    id: str
+    name: str
+    description: str
+    tags: List[str]
+    examples: List[str]
+    input_modes: List[str] = None
+    output_modes: List[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "tags": self.tags,
+            "examples": self.examples,
+            "inputModes": self.input_modes or ["text/plain"],
+            "outputModes": self.output_modes or ["text/plain"]
+        }
+
+
+@dataclass
+class AgentCapabilities:
+    """Defines agent capabilities for A2A protocol"""
+    streaming: bool = False
+    push_notifications: bool = False
+    multi_turn: bool = True
+    context_retention: bool = True
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "streaming": self.streaming,
+            "pushNotifications": self.push_notifications,
+            "multiTurn": self.multi_turn,
+            "contextRetention": self.context_retention
+        }
+
+
+@dataclass
+class AgentCard:
+    """The agent's business card - tells others what this agent can do"""
+    name: str
+    description: str
+    version: str
+    url: str
+    skills: List[AgentSkill]
+    capabilities: AgentCapabilities
+    default_input_modes: List[str] = None
+    default_output_modes: List[str] = None
+    preferred_transport: str = "JSONRPC"
+    protocol_version: str = "0.3.0"
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to A2A-compliant agent card JSON"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "version": self.version,
+            "url": self.url,
+            "protocolVersion": self.protocol_version,
+            "preferredTransport": self.preferred_transport,
+            "defaultInputModes": self.default_input_modes or ["text/plain"],
+            "defaultOutputModes": self.default_output_modes or ["text/plain"],
+            "capabilities": self.capabilities.to_dict(),
+            "skills": [skill.to_dict() for skill in self.skills]
+        }
+
+
+# Define FuzzForge's skills
+orchestration_skill = AgentSkill(
+    id="orchestration",
+    name="Agent Orchestration",
+    description="Route requests to appropriate registered agents based on their capabilities",
+    tags=["orchestration", "routing", "coordination"],
+    examples=[
+        "Route this to the calculator",
+        "Send this to the appropriate agent",
+        "Which agent should handle this?"
+    ]
+)
+
+memory_skill = AgentSkill(
+    id="memory",
+    name="Memory Management",
+    description="Store and retrieve information using Cognee knowledge graph",
+    tags=["memory", "knowledge", "storage", "cognee"],
+    examples=[
+        "Remember that my favorite color is blue",
+        "What do you remember about me?",
+        "Search your memory for project details"
+    ]
+)
+
+conversation_skill = AgentSkill(
+    id="conversation",
+    name="General Conversation",
+    description="Engage in general conversation and answer questions using LLM",
+    tags=["chat", "conversation", "qa", "llm"],
+    examples=[
+        "What is the meaning of life?",
+        "Explain quantum computing",
+        "Help me understand this concept"
+    ]
+)
+
+workflow_automation_skill = AgentSkill(
+    id="workflow_automation",
+    name="Workflow Automation",
+    description="Operate project workflows via MCP, monitor runs, and share results",
+    tags=["workflow", "automation", "mcp", "orchestration"],
+    examples=[
+        "Submit the security assessment workflow",
+        "Kick off the infrastructure scan and monitor it",
+        "Summarise findings for run abc123"
+    ]
+)
+
+agent_management_skill = AgentSkill(
+    id="agent_management",
+    name="Agent Registry Management",
+    description="Register, list, and manage connections to other A2A agents",
+    tags=["registry", "management", "discovery"],
+    examples=[
+        "Register agent at http://localhost:10201",
+        "List all registered agents",
+        "Show agent capabilities"
+    ]
+)
+
+# Define FuzzForge's capabilities
+fuzzforge_capabilities = AgentCapabilities(
+    streaming=False,
+    push_notifications=True,
+    multi_turn=True,  # We support multi-turn conversations
+    context_retention=True  # We maintain context across turns
+)
+
+# Create the public agent card
+def get_fuzzforge_agent_card(url: str = "http://localhost:10100") -> AgentCard:
+    """Get FuzzForge's agent card with current configuration"""
+    return AgentCard(
+        name="ProjectOrchestrator",
+        description=(
+            "An A2A-capable project agent that can launch and monitor FuzzForge workflows, "
+            "consult the project knowledge graph, and coordinate with speciality agents."
+        ),
+        version="project-agent",
+        url=url,
+        skills=[
+            orchestration_skill,
+            memory_skill,
+            conversation_skill,
+            workflow_automation_skill,
+            agent_management_skill
+        ],
+        capabilities=fuzzforge_capabilities,
+        default_input_modes=["text/plain", "application/json"],
+        default_output_modes=["text/plain", "application/json"],
+        preferred_transport="JSONRPC",
+        protocol_version="0.3.0"
+    )

ai/src/fuzzforge_ai/cli.py

@@ -0,0 +1,977 @@
+#!/usr/bin/env python3
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+"""
+FuzzForge CLI - Clean modular version
+Uses the separated agent components
+"""
+
+import asyncio
+import shlex
+import os
+import sys
+import signal
+import warnings
+import logging
+import random
+from datetime import datetime
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
+
+from dotenv import load_dotenv
+
+# Ensure Cognee writes logs inside the project workspace
+project_root = Path.cwd()
+default_log_dir = project_root / ".fuzzforge" / "logs"
+default_log_dir.mkdir(parents=True, exist_ok=True)
+log_path = default_log_dir / "cognee.log"
+os.environ.setdefault("COGNEE_LOG_PATH", str(log_path))
+
+# Suppress warnings
+warnings.filterwarnings("ignore")
+logging.basicConfig(level=logging.ERROR)
+
+# Load .env file with explicit path handling
+# 1. First check current working directory for .fuzzforge/.env
+fuzzforge_env = Path.cwd() / ".fuzzforge" / ".env"
+if fuzzforge_env.exists():
+    load_dotenv(fuzzforge_env, override=True)
+else:
+    # 2. Then check parent directories for .fuzzforge projects
+    current_path = Path.cwd()
+    for parent in [current_path] + list(current_path.parents):
+        fuzzforge_dir = parent / ".fuzzforge"
+        if fuzzforge_dir.exists():
+            project_env = fuzzforge_dir / ".env"
+            if project_env.exists():
+                load_dotenv(project_env, override=True)
+                break
+    else:
+        # 3. Fallback to generic load_dotenv
+        load_dotenv(override=True)
+
+# Enhanced readline configuration for Rich Console input compatibility
+try:
+    import readline
+    # Enable Rich-compatible input features
+    readline.parse_and_bind("tab: complete")
+    readline.parse_and_bind("set editing-mode emacs")
+    readline.parse_and_bind("set show-all-if-ambiguous on") 
+    readline.parse_and_bind("set completion-ignore-case on")
+    readline.parse_and_bind("set colored-completion-prefix on")
+    readline.parse_and_bind("set enable-bracketed-paste on")  # Better paste support
+    # Navigation bindings for better editing
+    readline.parse_and_bind("Control-a: beginning-of-line")
+    readline.parse_and_bind("Control-e: end-of-line") 
+    readline.parse_and_bind("Control-u: unix-line-discard")
+    readline.parse_and_bind("Control-k: kill-line")
+    readline.parse_and_bind("Control-w: unix-word-rubout")
+    readline.parse_and_bind("Meta-Backspace: backward-kill-word")
+    # History and completion
+    readline.set_history_length(2000)
+    readline.set_startup_hook(None)
+    # Enable multiline editing hints
+    readline.parse_and_bind("set horizontal-scroll-mode off")
+    readline.parse_and_bind("set mark-symlinked-directories on")
+    READLINE_AVAILABLE = True
+except ImportError:
+    READLINE_AVAILABLE = False
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich import box
+
+from google.adk.events.event import Event
+from google.adk.events.event_actions import EventActions
+from google.genai import types as gen_types
+
+from .agent import FuzzForgeAgent
+from .agent_card import get_fuzzforge_agent_card
+from .config_manager import ConfigManager
+from .config_bridge import ProjectConfigManager
+from .remote_agent import RemoteAgentConnection
+
+console = Console()
+
+# Global shutdown flag
+shutdown_requested = False
+
+# Dynamic status messages for better UX
+THINKING_MESSAGES = [
+    "Thinking", "Processing", "Computing", "Analyzing", "Working", 
+    "Pondering", "Deliberating", "Calculating", "Reasoning", "Evaluating"
+]
+
+WORKING_MESSAGES = [
+    "Working", "Processing", "Handling", "Executing", "Running",
+    "Operating", "Performing", "Conducting", "Managing", "Coordinating" 
+]
+
+SEARCH_MESSAGES = [
+    "Searching", "Scanning", "Exploring", "Investigating", "Hunting",
+    "Seeking", "Probing", "Examining", "Inspecting", "Browsing"
+]
+
+# Cool prompt symbols
+PROMPT_STYLES = [
+    "▶", "❯", "➤", "→", "»", "⟩", "▷", "⇨", "⟶", "◆"
+]
+
+def get_dynamic_status(action_type="thinking"):
+    """Get a random status message based on action type"""
+    if action_type == "thinking":
+        return f"{random.choice(THINKING_MESSAGES)}..."
+    elif action_type == "working":
+        return f"{random.choice(WORKING_MESSAGES)}..."
+    elif action_type == "searching":
+        return f"{random.choice(SEARCH_MESSAGES)}..."
+    else:
+        return f"{random.choice(THINKING_MESSAGES)}..."
+
+def get_prompt_symbol():
+    """Get prompt symbol indicating where to write"""
+    return ">>"
+
+def signal_handler(signum, frame):
+    """Handle Ctrl+C gracefully"""
+    global shutdown_requested
+    shutdown_requested = True
+    console.print("\n\n[yellow]Shutting down gracefully...[/yellow]")
+    sys.exit(0)
+
+signal.signal(signal.SIGINT, signal_handler)
+
+@contextmanager
+def safe_status(message: str):
+    """Safe status context manager"""
+    status = console.status(message, spinner="dots")
+    try:
+        status.start()
+        yield
+    finally:
+        status.stop()
+
+
+class FuzzForgeCLI:
+    """Command-line interface for FuzzForge"""
+    
+    def __init__(self):
+        """Initialize the CLI"""
+        # Ensure .env is loaded from .fuzzforge directory
+        fuzzforge_env = Path.cwd() / ".fuzzforge" / ".env"
+        if fuzzforge_env.exists():
+            load_dotenv(fuzzforge_env, override=True)
+        
+        # Load configuration for agent registry
+        self.config_manager = ConfigManager()
+        
+        # Check environment configuration
+        if not os.getenv('LITELLM_MODEL'):
+            console.print("[red]ERROR: LITELLM_MODEL not set in .env file[/red]")
+            console.print("Please set LITELLM_MODEL to your desired model")
+            sys.exit(1)
+        
+        # Create the agent (uses env vars directly)
+        self.agent = FuzzForgeAgent()
+        
+        # Create a consistent context ID for this CLI session
+        self.context_id = f"cli_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Track registered agents for config persistence
+        self.agents_modified = False
+        
+        # Command handlers
+        self.commands = {
+            "/help": self.cmd_help,
+            "/register": self.cmd_register,
+            "/unregister": self.cmd_unregister,
+            "/list": self.cmd_list,
+            "/memory": self.cmd_memory,
+            "/recall": self.cmd_recall,
+            "/artifacts": self.cmd_artifacts,
+            "/tasks": self.cmd_tasks,
+            "/skills": self.cmd_skills,
+            "/sessions": self.cmd_sessions,
+            "/clear": self.cmd_clear,
+            "/sendfile": self.cmd_sendfile,
+            "/quit": self.cmd_quit,
+            "/exit": self.cmd_quit,
+        }
+
+        self.background_tasks: set[asyncio.Task] = set()
+        
+    def print_banner(self):
+        """Print welcome banner"""
+        card = self.agent.agent_card
+        
+        # Print ASCII banner
+        console.print("[medium_purple3] ███████╗██╗   ██╗███████╗███████╗███████╗ ██████╗ ██████╗  ██████╗ ███████╗     █████╗ ██╗[/medium_purple3]")
+        console.print("[medium_purple3] ██╔════╝██║   ██║╚══███╔╝╚══███╔╝██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝    ██╔══██╗██║[/medium_purple3]")
+        console.print("[medium_purple3] █████╗  ██║   ██║  ███╔╝   ███╔╝ █████╗  ██║   ██║██████╔╝██║  ███╗█████╗      ███████║██║[/medium_purple3]")
+        console.print("[medium_purple3] ██╔══╝  ██║   ██║ ███╔╝   ███╔╝  ██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝      ██╔══██║██║[/medium_purple3]")
+        console.print("[medium_purple3] ██║     ╚██████╔╝███████╗███████╗██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗    ██║  ██║██║[/medium_purple3]")
+        console.print("[medium_purple3] ╚═╝      ╚═════╝ ╚══════╝╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝    ╚═╝  ╚═╝╚═╝[/medium_purple3]")
+        console.print(f"\n[dim]{card.description}[/dim]\n")
+
+        provider = (
+            os.getenv("LLM_PROVIDER")
+            or os.getenv("LLM_COGNEE_PROVIDER")
+            or os.getenv("COGNEE_LLM_PROVIDER")
+            or "unknown"
+        )
+
+        console.print(
+            "LLM Provider: [medium_purple1]{provider}[/medium_purple1]".format(
+                provider=provider
+            )
+        )
+        console.print(
+            "LLM Model: [medium_purple1]{model}[/medium_purple1]".format(
+                model=self.agent.model
+            )
+        )
+        if self.agent.executor.agentops_trace:
+            console.print(f"Tracking: [medium_purple1]AgentOps active[/medium_purple1]")
+
+        # Show skills
+        console.print("\nSkills:")
+        for skill in card.skills:
+            console.print(
+                f"   • [deep_sky_blue1]{skill.name}[/deep_sky_blue1] – {skill.description}"
+            )
+        console.print("\nType /help for commands or just chat\n")
+        
+    async def cmd_help(self, args: str = "") -> None:
+        """Show help"""
+        help_text = """
+[bold]Commands:[/bold]
+  /register <url>  - Register an A2A agent (saves to config)
+  /unregister <name> - Remove agent from registry and config
+  /list           - List registered agents
+  
+[bold]Memory Systems:[/bold]  
+  /recall <query> - Search past conversations (ADK Memory)
+  /memory         - Show knowledge graph (Cognee)
+  /memory save    - Save to knowledge graph
+  /memory search  - Search knowledge graph
+  
+[bold]Other:[/bold]
+  /artifacts      - List created artifacts
+  /artifacts <id> - Show artifact content
+  /tasks [id]     - Show task list or details
+  /skills         - Show FuzzForge skills
+  /sessions       - List active sessions
+  /sendfile <agent> <path> [message] - Attach file as artifact and route to agent
+  /clear          - Clear screen
+  /help           - Show this help
+  /quit           - Exit
+
+[bold]Sample prompts:[/bold]
+  run fuzzforge workflow security_assessment on /absolute/path --volume-mode ro
+  list fuzzforge runs limit=5
+  get fuzzforge summary <run_id>
+  query project knowledge about "unsafe Rust" using GRAPH_COMPLETION
+  export project file src/lib.rs as artifact
+  /memory search "recent findings"
+
+[bold]Input Editing:[/bold]
+  Arrow keys      - Move cursor
+  Ctrl+A/E        - Start/end of line
+  Up/Down         - Command history
+        """
+        console.print(help_text)
+        
+    async def cmd_register(self, args: str) -> None:
+        """Register an agent"""
+        if not args:
+            console.print("Usage: /register <url>")
+            return
+            
+        with safe_status(f"{get_dynamic_status('working')} Registering {args}"):
+            result = await self.agent.register_agent(args.strip())
+            
+        if result["success"]:
+            console.print(f"✅ Registered: [bold]{result['name']}[/bold]")
+            console.print(f"   Capabilities: {result['capabilities']} skills")
+            
+            # Get description from the agent's card
+            agents = self.agent.list_agents()
+            description = ""
+            for agent in agents:
+                if agent['name'] == result['name']:
+                    description = agent.get('description', '')
+                    break
+            
+            # Add to config for persistence
+            self.config_manager.add_registered_agent(
+                name=result['name'],
+                url=args.strip(),
+                description=description
+            )
+            console.print(f"   [dim]Saved to config for auto-registration[/dim]")
+        else:
+            console.print(f"[red]Failed: {result['error']}[/red]")
+            
+    async def cmd_unregister(self, args: str) -> None:
+        """Unregister an agent and remove from config"""
+        if not args:
+            console.print("Usage: /unregister <name or url>")
+            return
+        
+        # Try to find the agent
+        agents = self.agent.list_agents()
+        agent_to_remove = None
+        
+        for agent in agents:
+            if agent['name'].lower() == args.lower() or agent['url'] == args:
+                agent_to_remove = agent
+                break
+        
+        if not agent_to_remove:
+            console.print(f"[yellow]Agent '{args}' not found[/yellow]")
+            return
+        
+        # Remove from config
+        if self.config_manager.remove_registered_agent(name=agent_to_remove['name'], url=agent_to_remove['url']):
+            console.print(f"✅ Unregistered: [bold]{agent_to_remove['name']}[/bold]")
+            console.print(f"   [dim]Removed from config (won't auto-register next time)[/dim]")
+        else:
+            console.print(f"[yellow]Agent unregistered from session but not found in config[/yellow]")
+    
+    async def cmd_list(self, args: str = "") -> None:
+        """List registered agents"""
+        agents = self.agent.list_agents()
+        
+        if not agents:
+            console.print("No agents registered. Use /register <url>")
+            return
+            
+        table = Table(title="Registered Agents", box=box.ROUNDED)
+        table.add_column("Name", style="medium_purple3")
+        table.add_column("URL", style="deep_sky_blue3")
+        table.add_column("Skills", style="plum3")
+        table.add_column("Description", style="dim")
+        
+        for agent in agents:
+            desc = agent['description']
+            if len(desc) > 40:
+                desc = desc[:37] + "..."
+            table.add_row(
+                agent['name'],
+                agent['url'],
+                str(agent['skills']),
+                desc
+            )
+            
+        console.print(table)
+        
+    async def cmd_recall(self, args: str = "") -> None:
+        """Search conversational memory (past conversations)"""
+        if not args:
+            console.print("Usage: /recall <query>")
+            return
+        
+        await self._sync_conversational_memory()
+
+        # First try MemoryService (for ingested memories)
+        with safe_status(get_dynamic_status('searching')):
+            results = await self.agent.memory_manager.search_conversational_memory(args)
+        
+        if results and results.memories:
+            console.print(f"[bold]Found {len(results.memories)} memories:[/bold]\n")
+            for i, memory in enumerate(results.memories, 1):
+                # MemoryEntry has 'text' field, not 'content'
+                text = getattr(memory, 'text', str(memory))
+                if len(text) > 200:
+                    text = text[:200] + "..."
+                console.print(f"{i}. {text}")
+        else:
+            # If MemoryService is empty, search SQLite directly
+            console.print("[yellow]No memories in MemoryService, searching SQLite sessions...[/yellow]")
+            
+            # Check if using DatabaseSessionService
+            if hasattr(self.agent.executor, 'session_service'):
+                service_type = type(self.agent.executor.session_service).__name__
+                if service_type == 'DatabaseSessionService':
+                    # Search SQLite database directly
+                    import sqlite3
+                    import os
+                    db_path = os.getenv('SESSION_DB_PATH', './fuzzforge_sessions.db')
+                    
+                    if os.path.exists(db_path):
+                        conn = sqlite3.connect(db_path)
+                        cursor = conn.cursor()
+                        
+                        # Search in events table
+                        query = f"%{args}%"
+                        cursor.execute(
+                            "SELECT content FROM events WHERE content LIKE ? LIMIT 10",
+                            (query,)
+                        )
+                        
+                        rows = cursor.fetchall()
+                        conn.close()
+                        
+                        if rows:
+                            console.print(f"[green]Found {len(rows)} matches in SQLite sessions:[/green]\n")
+                            for i, (content,) in enumerate(rows, 1):
+                                # Parse JSON content
+                                import json
+                                try:
+                                    data = json.loads(content)
+                                    if 'parts' in data and data['parts']:
+                                        text = data['parts'][0].get('text', '')[:150]
+                                        role = data.get('role', 'unknown')
+                                        console.print(f"{i}. [{role}]: {text}...")
+                                except:
+                                    console.print(f"{i}. {content[:150]}...")
+                        else:
+                            console.print("[yellow]No matches found in SQLite either[/yellow]")
+                    else:
+                        console.print("[yellow]SQLite database not found[/yellow]")
+                else:
+                    console.print(f"[dim]Using {service_type} (not searchable)[/dim]")
+            else:
+                console.print("[yellow]No session history available[/yellow]")
+    
+    async def cmd_memory(self, args: str = "") -> None:
+        """Inspect conversational memory and knowledge graph state."""
+        raw_args = (args or "").strip()
+        lower_args = raw_args.lower()
+
+        if not raw_args or lower_args in {"status", "info"}:
+            await self._show_memory_status()
+            return
+
+        if lower_args == "datasets":
+            await self._show_dataset_summary()
+            return
+
+        if lower_args.startswith("search ") or lower_args.startswith("recall "):
+            query = raw_args.split(" ", 1)[1].strip() if " " in raw_args else ""
+            if not query:
+                console.print("Usage: /memory search <query>")
+                return
+            await self.cmd_recall(query)
+            return
+
+        console.print("Usage: /memory [status|datasets|search <query>]")
+        console.print("[dim]/memory search <query> is an alias for /recall <query>[/dim]")
+
+    async def _sync_conversational_memory(self) -> None:
+        """Ensure the ADK memory service ingests any completed sessions."""
+        memory_service = getattr(self.agent.memory_manager, "memory_service", None)
+        executor_sessions = getattr(self.agent.executor, "sessions", {})
+        metadata_map = getattr(self.agent.executor, "session_metadata", {})
+
+        if not memory_service or not executor_sessions:
+            return
+
+        for context_id, session in list(executor_sessions.items()):
+            meta = metadata_map.get(context_id, {})
+            if meta.get('memory_synced'):
+                continue
+
+            add_session = getattr(memory_service, "add_session_to_memory", None)
+            if not callable(add_session):
+                return
+
+            try:
+                await add_session(session)
+                meta['memory_synced'] = True
+                metadata_map[context_id] = meta
+            except Exception as exc:  # pragma: no cover - defensive logging
+                if os.getenv('FUZZFORGE_DEBUG', '0') == '1':
+                    console.print(f"[yellow]Memory sync failed:[/yellow] {exc}")
+
+    async def _show_memory_status(self) -> None:
+        """Render conversational memory, session store, and knowledge graph status."""
+        await self._sync_conversational_memory()
+
+        status = self.agent.memory_manager.get_status()
+
+        conversational = status.get("conversational_memory", {})
+        conv_type = conversational.get("type", "unknown")
+        conv_active = "yes" if conversational.get("active") else "no"
+        conv_details = conversational.get("details", "")
+
+        session_service = getattr(self.agent.executor, "session_service", None)
+        session_service_name = type(session_service).__name__ if session_service else "Unavailable"
+
+        session_lines = [
+            f"[bold]Service:[/bold] {session_service_name}"
+        ]
+
+        session_count = None
+        event_count = None
+        db_path_display = None
+
+        if session_service_name == "DatabaseSessionService":
+            import sqlite3
+
+            db_path = os.getenv('SESSION_DB_PATH', './fuzzforge_sessions.db')
+            session_path = Path(db_path).expanduser().resolve()
+            db_path_display = str(session_path)
+
+            if session_path.exists():
+                try:
+                    with sqlite3.connect(session_path) as conn:
+                        cursor = conn.cursor()
+                        cursor.execute("SELECT COUNT(*) FROM sessions")
+                        session_count = cursor.fetchone()[0]
+                        cursor.execute("SELECT COUNT(*) FROM events")
+                        event_count = cursor.fetchone()[0]
+                except Exception as exc:
+                    session_lines.append(f"[yellow]Warning:[/yellow] Unable to read session database ({exc})")
+            else:
+                session_lines.append("[yellow]SQLite session database not found yet[/yellow]")
+
+        elif session_service_name == "InMemorySessionService":
+            session_lines.append("[dim]Session data persists for the current process only[/dim]")
+
+        if db_path_display:
+            session_lines.append(f"[bold]Database:[/bold] {db_path_display}")
+        if session_count is not None:
+            session_lines.append(f"[bold]Sessions Recorded:[/bold] {session_count}")
+        if event_count is not None:
+            session_lines.append(f"[bold]Events Logged:[/bold] {event_count}")
+
+        conv_lines = [
+            f"[bold]Type:[/bold] {conv_type}",
+            f"[bold]Active:[/bold] {conv_active}"
+        ]
+        if conv_details:
+            conv_lines.append(f"[bold]Details:[/bold] {conv_details}")
+
+        console.print(Panel("\n".join(conv_lines), title="Conversation Memory", border_style="medium_purple3"))
+        console.print(Panel("\n".join(session_lines), title="Session Store", border_style="deep_sky_blue3"))
+
+        # Knowledge graph section
+        knowledge = status.get("knowledge_graph", {})
+        kg_active = knowledge.get("active", False)
+        kg_lines = [
+            f"[bold]Active:[/bold] {'yes' if kg_active else 'no'}",
+            f"[bold]Purpose:[/bold] {knowledge.get('purpose', 'N/A')}"
+        ]
+
+        cognee_data = None
+        cognee_error = None
+        try:
+            project_config = ProjectConfigManager()
+            cognee_data = project_config.get_cognee_config()
+        except Exception as exc:  # pragma: no cover - defensive
+            cognee_error = str(exc)
+
+        if cognee_data:
+            data_dir = cognee_data.get('data_directory')
+            system_dir = cognee_data.get('system_directory')
+            if data_dir:
+                kg_lines.append(f"[bold]Data dir:[/bold] {data_dir}")
+            if system_dir:
+                kg_lines.append(f"[bold]System dir:[/bold] {system_dir}")
+        elif cognee_error:
+            kg_lines.append(f"[yellow]Config unavailable:[/yellow] {cognee_error}")
+
+        dataset_summary = None
+        if kg_active:
+            try:
+                integration = await self.agent.executor._get_knowledge_integration()
+                if integration:
+                    dataset_summary = await integration.list_datasets()
+            except Exception as exc:  # pragma: no cover - defensive
+                kg_lines.append(f"[yellow]Dataset listing failed:[/yellow] {exc}")
+
+        if dataset_summary:
+            if dataset_summary.get("error"):
+                kg_lines.append(f"[yellow]Dataset listing failed:[/yellow] {dataset_summary['error']}")
+            else:
+                datasets = dataset_summary.get("datasets", [])
+                total = dataset_summary.get("total_datasets")
+                if total is not None:
+                    kg_lines.append(f"[bold]Datasets:[/bold] {total}")
+                if datasets:
+                    preview = ", ".join(sorted(datasets)[:5])
+                    if len(datasets) > 5:
+                        preview += ", …"
+                    kg_lines.append(f"[bold]Samples:[/bold] {preview}")
+        else:
+            kg_lines.append("[dim]Run `fuzzforge ingest` to populate the knowledge graph[/dim]")
+
+        console.print(Panel("\n".join(kg_lines), title="Knowledge Graph", border_style="spring_green4"))
+        console.print("\n[dim]Subcommands: /memory datasets | /memory search <query>[/dim]")
+
+    async def _show_dataset_summary(self) -> None:
+        """List datasets available in the Cognee knowledge graph."""
+        try:
+            integration = await self.agent.executor._get_knowledge_integration()
+        except Exception as exc:
+            console.print(f"[yellow]Knowledge graph unavailable:[/yellow] {exc}")
+            return
+
+        if not integration:
+            console.print("[yellow]Knowledge graph is not initialised yet.[/yellow]")
+            console.print("[dim]Run `fuzzforge ingest --path . --recursive` to create the project dataset.[/dim]")
+            return
+
+        with safe_status(get_dynamic_status('searching')):
+            dataset_info = await integration.list_datasets()
+
+        if dataset_info.get("error"):
+            console.print(f"[red]{dataset_info['error']}[/red]")
+            return
+
+        datasets = dataset_info.get("datasets", [])
+        if not datasets:
+            console.print("[yellow]No datasets found.[/yellow]")
+            console.print("[dim]Run `fuzzforge ingest` to populate the knowledge graph.[/dim]")
+            return
+
+        table = Table(title="Cognee Datasets", box=box.ROUNDED)
+        table.add_column("Dataset", style="medium_purple3")
+        table.add_column("Notes", style="dim")
+
+        for name in sorted(datasets):
+            note = ""
+            if name.endswith("_codebase"):
+                note = "primary project dataset"
+            table.add_row(name, note)
+
+        console.print(table)
+        console.print(
+            "[dim]Use knowledge graph prompts (e.g. `search project knowledge for \"topic\" using INSIGHTS`) to query these datasets.[/dim]"
+        )
+            
+    async def cmd_artifacts(self, args: str = "") -> None:
+        """List or show artifacts"""
+        if args:
+            # Show specific artifact
+            artifacts = await self.agent.executor.get_artifacts(self.context_id)
+            for artifact in artifacts:
+                if artifact['id'] == args or args in artifact['id']:
+                    console.print(Panel(
+                        f"[bold]{artifact['title']}[/bold]\n"
+                        f"Type: {artifact['type']} | Created: {artifact['created_at'][:19]}\n\n"
+                        f"[code]{artifact['content']}[/code]",
+                        title=f"Artifact: {artifact['id']}",
+                        border_style="medium_purple3"
+                    ))
+                    return
+            console.print(f"[yellow]Artifact {args} not found[/yellow]")
+            return
+        
+        # List all artifacts
+        artifacts = await self.agent.executor.get_artifacts(self.context_id)
+        
+        if not artifacts:
+            console.print("No artifacts created yet")
+            console.print("[dim]Artifacts are created when generating code, configs, or documents[/dim]")
+            return
+        
+        table = Table(title="Artifacts", box=box.ROUNDED)
+        table.add_column("ID", style="medium_purple3")
+        table.add_column("Type", style="deep_sky_blue3")
+        table.add_column("Title", style="plum3")
+        table.add_column("Size", style="dim")
+        table.add_column("Created", style="dim")
+        
+        for artifact in artifacts:
+            size = f"{len(artifact['content'])} chars"
+            created = artifact['created_at'][:19]  # Just date and time
+            
+        table.add_row(
+            artifact['id'],
+            artifact['type'],
+            artifact['title'][:40] + "..." if len(artifact['title']) > 40 else artifact['title'],
+            size,
+            created
+        )
+        
+        console.print(table)
+        console.print(f"\n[dim]Use /artifacts <id> to view artifact content[/dim]")
+
+    async def cmd_tasks(self, args: str = "") -> None:
+        """List tasks or show details for a specific task."""
+        store = getattr(self.agent.executor, "task_store", None)
+        if not store or not hasattr(store, "tasks"):
+            console.print("Task store not available")
+            return
+
+        task_id = args.strip()
+
+        async with store.lock:
+            tasks = dict(store.tasks)
+
+        if not tasks:
+            console.print("No tasks recorded yet")
+            return
+
+        if task_id:
+            task = tasks.get(task_id)
+            if not task:
+                console.print(f"Task '{task_id}' not found")
+                return
+
+            state_str = task.status.state.value if hasattr(task.status.state, "value") else str(task.status.state)
+            console.print(f"\n[bold]Task {task.id}[/bold]")
+            console.print(f"Context: {task.context_id}")
+            console.print(f"State: {state_str}")
+            console.print(f"Timestamp: {task.status.timestamp}")
+            if task.metadata:
+                console.print("Metadata:")
+                for key, value in task.metadata.items():
+                    console.print(f"  • {key}: {value}")
+            if task.history:
+                console.print("History:")
+                for entry in task.history[-5:]:
+                    text = getattr(entry, "text", None)
+                    if not text and hasattr(entry, "parts"):
+                        text = " ".join(
+                            getattr(part, "text", "") for part in getattr(entry, "parts", [])
+                        )
+                    console.print(f"  - {text}")
+            return
+
+        table = Table(title="FuzzForge Tasks", box=box.ROUNDED)
+        table.add_column("ID", style="medium_purple3")
+        table.add_column("State", style="white")
+        table.add_column("Workflow", style="deep_sky_blue3")
+        table.add_column("Updated", style="green")
+
+        for task in tasks.values():
+            state_value = task.status.state.value if hasattr(task.status.state, "value") else str(task.status.state)
+            workflow = ""
+            if task.metadata:
+                workflow = task.metadata.get("workflow") or task.metadata.get("workflow_name") or ""
+            timestamp = task.status.timestamp if task.status else ""
+            table.add_row(task.id, state_value, workflow, timestamp)
+
+        console.print(table)
+        console.print("\n[dim]Use /tasks <id> to view task details[/dim]")
+    
+    async def cmd_sessions(self, args: str = "") -> None:
+        """List active sessions"""
+        sessions = self.agent.executor.sessions
+        
+        if not sessions:
+            console.print("No active sessions")
+            return
+            
+        table = Table(title="Active Sessions", box=box.ROUNDED)
+        table.add_column("Context ID", style="medium_purple3")
+        table.add_column("Session ID", style="deep_sky_blue3")
+        table.add_column("User ID", style="plum3")
+        table.add_column("State", style="dim")
+        
+        for context_id, session in sessions.items():
+            # Get session info
+            session_id = getattr(session, 'id', 'N/A')
+            user_id = getattr(session, 'user_id', 'N/A')
+            state = getattr(session, 'state', {})
+            
+            # Format state info
+            agents_count = len(state.get('registered_agents', []))
+            state_info = f"{agents_count} agents registered"
+            
+            table.add_row(
+                context_id[:20] + "..." if len(context_id) > 20 else context_id,
+                session_id[:20] + "..." if len(str(session_id)) > 20 else str(session_id),
+                user_id,
+                state_info
+            )
+            
+        console.print(table)
+        console.print(f"\n[dim]Current session: {self.context_id}[/dim]")
+        
+    async def cmd_skills(self, args: str = "") -> None:
+        """Show FuzzForge skills"""
+        card = self.agent.agent_card
+        
+        table = Table(title=f"{card.name} Skills", box=box.ROUNDED)
+        table.add_column("Skill", style="medium_purple3")
+        table.add_column("Description", style="white")
+        table.add_column("Tags", style="deep_sky_blue3")
+        
+        for skill in card.skills:
+            table.add_row(
+                skill.name,
+                skill.description,
+                ", ".join(skill.tags[:3])
+            )
+            
+        console.print(table)
+        
+    async def cmd_clear(self, args: str = "") -> None:
+        """Clear screen"""
+        console.clear()
+        self.print_banner()
+
+    async def cmd_sendfile(self, args: str) -> None:
+        """Encode a local file as an artifact and route it to a registered agent."""
+        tokens = shlex.split(args)
+        if len(tokens) < 2:
+            console.print("Usage: /sendfile <agent_name> <path> [message]")
+            return
+
+        agent_name = tokens[0]
+        file_arg = tokens[1]
+        note = " ".join(tokens[2:]).strip()
+
+        file_path = Path(file_arg).expanduser()
+        if not file_path.exists():
+            console.print(f"[red]File not found:[/red] {file_path}")
+            return
+
+        session = self.agent.executor.sessions.get(self.context_id)
+        if not session:
+            console.print("[red]No active session available. Try sending a prompt first.[/red]")
+            return
+
+        console.print(f"[dim]Delegating {file_path.name} to {agent_name}...[/dim]")
+
+        async def _delegate() -> None:
+            try:
+                response = await self.agent.executor.delegate_file_to_agent(
+                    agent_name,
+                    str(file_path),
+                    note,
+                    session=session,
+                    context_id=self.context_id,
+                )
+                console.print(f"[{agent_name}]: {response}")
+            except Exception as exc:
+                console.print(f"[red]Failed to delegate file:[/red] {exc}")
+            finally:
+                self.background_tasks.discard(asyncio.current_task())
+
+        task = asyncio.create_task(_delegate())
+        self.background_tasks.add(task)
+        console.print("[dim]Delegation in progress… you can continue working.[/dim]")
+
+    async def cmd_quit(self, args: str = "") -> None:
+        """Exit the CLI"""
+        console.print("\n[green]Shutting down...[/green]")
+        await self.agent.cleanup()
+        if self.background_tasks:
+            for task in list(self.background_tasks):
+                task.cancel()
+            await asyncio.gather(*self.background_tasks, return_exceptions=True)
+        console.print("Goodbye!\n")
+        sys.exit(0)
+
+    async def process_command(self, text: str) -> bool:
+        """Process slash commands"""
+        if not text.startswith('/'):
+            return False
+            
+        parts = text.split(maxsplit=1)
+        cmd = parts[0].lower()
+        args = parts[1] if len(parts) > 1 else ""
+        
+        if cmd in self.commands:
+            await self.commands[cmd](args)
+            return True
+            
+        console.print(f"Unknown command: {cmd}")
+        return True
+        
+    async def auto_register_agents(self):
+        """Auto-register agents from config on startup"""
+        agents_to_register = self.config_manager.get_registered_agents()
+        
+        if agents_to_register:
+            console.print(f"\n[dim]Auto-registering {len(agents_to_register)} agents from config...[/dim]")
+            
+            for agent_config in agents_to_register:
+                url = agent_config.get('url')
+                name = agent_config.get('name', 'Unknown')
+                
+                if url:
+                    try:
+                        with safe_status(f"Registering {name}..."):
+                            result = await self.agent.register_agent(url)
+                        
+                        if result["success"]:
+                            console.print(f"  ✅ {name}: [green]Connected[/green]")
+                        else:
+                            console.print(f"  ⚠️  {name}: [yellow]Failed - {result.get('error', 'Unknown error')}[/yellow]")
+                    except Exception as e:
+                        console.print(f"  ⚠️  {name}: [yellow]Failed - {e}[/yellow]")
+            
+            console.print("")  # Empty line for spacing
+    
+    async def run(self):
+        """Main CLI loop"""
+        self.print_banner()
+        
+        # Auto-register agents from config
+        await self.auto_register_agents()
+        
+        while not shutdown_requested:
+            try:
+                # Use standard input with non-deletable colored prompt
+                prompt_symbol = get_prompt_symbol()
+                try:
+                    # Print colored prompt then use input() for non-deletable behavior
+                    console.print(f"[medium_purple3]{prompt_symbol}[/medium_purple3] ", end="")
+                    user_input = input().strip()
+                except (EOFError, KeyboardInterrupt):
+                    raise
+                
+                if not user_input:
+                    continue
+                    
+                # Check for commands
+                if await self.process_command(user_input):
+                    continue
+                    
+                # Process message
+                with safe_status(get_dynamic_status('thinking')):
+                    response = await self.agent.process_message(user_input, self.context_id)
+                    
+                # Display response
+                console.print(f"\n{response}\n")
+                    
+            except KeyboardInterrupt:
+                await self.cmd_quit()
+                
+            except EOFError:
+                await self.cmd_quit()
+                
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/red]")
+                if os.getenv('FUZZFORGE_DEBUG') == '1':
+                    console.print_exception()
+                console.print("")
+        
+        await self.agent.cleanup()
+
+
+def main():
+    """Main entry point"""
+    try:
+        cli = FuzzForgeCLI()
+        asyncio.run(cli.run())
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted[/yellow]")
+        sys.exit(0)
+    except Exception as e:
+        console.print(f"[red]Fatal error: {e}[/red]")
+        if os.getenv('FUZZFORGE_DEBUG') == '1':
+            console.print_exception()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

ai/src/fuzzforge_ai/cognee_integration.py

@@ -0,0 +1,435 @@
+"""
+Cognee Integration Module for FuzzForge
+Provides standardized access to project-specific knowledge graphs
+Can be reused by external agents and other components
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+import asyncio
+import json
+from typing import Dict, List, Any, Optional, Union
+from pathlib import Path
+
+
+class CogneeProjectIntegration:
+    """
+    Standardized Cognee integration that can be reused across agents
+    Automatically detects project context and provides knowledge graph access
+    """
+    
+    def __init__(self, project_dir: Optional[str] = None):
+        """
+        Initialize with project directory (defaults to current working directory)
+        
+        Args:
+            project_dir: Path to project directory (optional, defaults to cwd)
+        """
+        self.project_dir = Path(project_dir) if project_dir else Path.cwd()
+        self.config_file = self.project_dir / ".fuzzforge" / "config.yaml"
+        self.project_context = None
+        self._cognee = None
+        self._initialized = False
+        
+    async def initialize(self) -> bool:
+        """
+        Initialize Cognee with project context
+        
+        Returns:
+            bool: True if initialization successful
+        """
+        try:
+            # Import Cognee
+            import cognee
+            self._cognee = cognee
+            
+            # Load project context
+            if not self._load_project_context():
+                return False
+                
+            # Configure Cognee for this project
+            await self._setup_cognee_config()
+            
+            self._initialized = True
+            return True
+            
+        except ImportError:
+            print("Cognee not installed. Install with: pip install cognee")
+            return False
+        except Exception as e:
+            print(f"Failed to initialize Cognee: {e}")
+            return False
+    
+    def _load_project_context(self) -> bool:
+        """Load project context from FuzzForge config"""
+        try:
+            if not self.config_file.exists():
+                print(f"No FuzzForge config found at {self.config_file}")
+                return False
+                
+            import yaml
+            with open(self.config_file, 'r') as f:
+                config = yaml.safe_load(f)
+                
+            self.project_context = {
+                "project_name": config.get("project", {}).get("name", "default"),
+                "project_id": config.get("project", {}).get("id", "default"),
+                "tenant_id": config.get("cognee", {}).get("tenant", "default")
+            }
+            return True
+            
+        except Exception as e:
+            print(f"Error loading project context: {e}")
+            return False
+    
+    async def _setup_cognee_config(self):
+        """Configure Cognee for project-specific access"""
+        # Set API key and model
+        api_key = os.getenv('OPENAI_API_KEY')
+        model = os.getenv('LITELLM_MODEL', 'gpt-4o-mini')
+        
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY required for Cognee operations")
+            
+        # Configure Cognee
+        self._cognee.config.set_llm_api_key(api_key)
+        self._cognee.config.set_llm_model(model)
+        self._cognee.config.set_llm_provider("openai")
+        
+        # Set project-specific directories
+        project_cognee_dir = self.project_dir / ".fuzzforge" / "cognee" / f"project_{self.project_context['project_id']}"
+        
+        self._cognee.config.data_root_directory(str(project_cognee_dir / "data"))
+        self._cognee.config.system_root_directory(str(project_cognee_dir / "system"))
+        
+        # Ensure directories exist
+        project_cognee_dir.mkdir(parents=True, exist_ok=True)
+        (project_cognee_dir / "data").mkdir(exist_ok=True)
+        (project_cognee_dir / "system").mkdir(exist_ok=True)
+    
+    async def search_knowledge_graph(self, query: str, search_type: str = "GRAPH_COMPLETION", dataset: str = None) -> Dict[str, Any]:
+        """
+        Search the project's knowledge graph
+        
+        Args:
+            query: Search query
+            search_type: Type of search ("GRAPH_COMPLETION", "INSIGHTS", "CHUNKS", etc.)
+            dataset: Specific dataset to search (optional)
+            
+        Returns:
+            Dict containing search results
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        try:
+            from cognee.modules.search.types import SearchType
+
+            # Resolve search type dynamically; fallback to GRAPH_COMPLETION
+            try:
+                search_type_enum = getattr(SearchType, search_type.upper())
+            except AttributeError:
+                search_type_enum = SearchType.GRAPH_COMPLETION
+                search_type = "GRAPH_COMPLETION"
+
+            # Prepare search kwargs
+            search_kwargs = {
+                "query_type": search_type_enum,
+                "query_text": query
+            }
+            
+            # Add dataset filter if specified
+            if dataset:
+                search_kwargs["datasets"] = [dataset]
+                
+            results = await self._cognee.search(**search_kwargs)
+            
+            return {
+                "query": query,
+                "search_type": search_type,
+                "dataset": dataset,
+                "results": results,
+                "project": self.project_context["project_name"]
+            }
+        except Exception as e:
+            return {"error": f"Search failed: {e}"}
+    
+    async def list_knowledge_data(self) -> Dict[str, Any]:
+        """
+        List available data in the knowledge graph
+        
+        Returns:
+            Dict containing available data
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        try:
+            data = await self._cognee.list_data()
+            return {
+                "project": self.project_context["project_name"],
+                "available_data": data
+            }
+        except Exception as e:
+            return {"error": f"Failed to list data: {e}"}
+    
+    async def ingest_text_to_dataset(self, text: str, dataset: str = None) -> Dict[str, Any]:
+        """
+        Ingest text content into a specific dataset
+        
+        Args:
+            text: Text to ingest
+            dataset: Dataset name (defaults to project_name_codebase)
+            
+        Returns:
+            Dict containing ingest results
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        if not dataset:
+            dataset = f"{self.project_context['project_name']}_codebase"
+            
+        try:
+            # Add text to dataset
+            await self._cognee.add([text], dataset_name=dataset)
+            
+            # Process (cognify) the dataset
+            await self._cognee.cognify([dataset])
+            
+            return {
+                "text_length": len(text),
+                "dataset": dataset,
+                "project": self.project_context["project_name"],
+                "status": "success"
+            }
+        except Exception as e:
+            return {"error": f"Ingest failed: {e}"}
+    
+    async def ingest_files_to_dataset(self, file_paths: list, dataset: str = None) -> Dict[str, Any]:
+        """
+        Ingest multiple files into a specific dataset
+        
+        Args:
+            file_paths: List of file paths to ingest
+            dataset: Dataset name (defaults to project_name_codebase)
+            
+        Returns:
+            Dict containing ingest results
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        if not dataset:
+            dataset = f"{self.project_context['project_name']}_codebase"
+            
+        try:
+            # Validate and filter readable files
+            valid_files = []
+            for file_path in file_paths:
+                try:
+                    path = Path(file_path)
+                    if path.exists() and path.is_file():
+                        # Test if file is readable
+                        with open(path, 'r', encoding='utf-8') as f:
+                            f.read(1)
+                        valid_files.append(str(path))
+                except (UnicodeDecodeError, PermissionError, OSError):
+                    continue
+            
+            if not valid_files:
+                return {"error": "No valid files found to ingest"}
+            
+            # Add files to dataset
+            await self._cognee.add(valid_files, dataset_name=dataset)
+            
+            # Process (cognify) the dataset
+            await self._cognee.cognify([dataset])
+            
+            return {
+                "files_processed": len(valid_files),
+                "total_files_requested": len(file_paths),
+                "dataset": dataset,
+                "project": self.project_context["project_name"],
+                "status": "success"
+            }
+        except Exception as e:
+            return {"error": f"Ingest failed: {e}"}
+    
+    async def list_datasets(self) -> Dict[str, Any]:
+        """
+        List all datasets available in the project
+        
+        Returns:
+            Dict containing available datasets
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        try:
+            # Get available datasets by searching for data
+            data = await self._cognee.list_data()
+            
+            # Extract unique dataset names from the data
+            datasets = set()
+            if isinstance(data, list):
+                for item in data:
+                    if isinstance(item, dict) and 'dataset_name' in item:
+                        datasets.add(item['dataset_name'])
+            
+            return {
+                "project": self.project_context["project_name"],
+                "datasets": list(datasets),
+                "total_datasets": len(datasets)
+            }
+        except Exception as e:
+            return {"error": f"Failed to list datasets: {e}"}
+    
+    async def create_dataset(self, dataset: str) -> Dict[str, Any]:
+        """
+        Create a new dataset (dataset is created automatically when data is added)
+        
+        Args:
+            dataset: Dataset name to create
+            
+        Returns:
+            Dict containing creation result
+        """
+        if not self._initialized:
+            await self.initialize()
+            
+        if not self._initialized:
+            return {"error": "Cognee not initialized"}
+            
+        try:
+            # In Cognee, datasets are created implicitly when data is added
+            # We'll add empty content to create the dataset
+            await self._cognee.add([f"Dataset {dataset} initialized for project {self.project_context['project_name']}"], 
+                                  dataset_name=dataset)
+            
+            return {
+                "dataset": dataset,
+                "project": self.project_context["project_name"],
+                "status": "created"
+            }
+        except Exception as e:
+            return {"error": f"Failed to create dataset: {e}"}
+    
+    def get_project_context(self) -> Optional[Dict[str, str]]:
+        """Get current project context"""
+        return self.project_context
+    
+    def is_initialized(self) -> bool:
+        """Check if Cognee is initialized"""
+        return self._initialized
+
+
+# Convenience functions for easy integration
+async def search_project_codebase(query: str, project_dir: Optional[str] = None, dataset: str = None, search_type: str = "GRAPH_COMPLETION") -> str:
+    """
+    Convenience function to search project codebase
+    
+    Args:
+        query: Search query
+        project_dir: Project directory (optional, defaults to cwd)
+        dataset: Specific dataset to search (optional)
+        search_type: Type of search ("GRAPH_COMPLETION", "INSIGHTS", "CHUNKS")
+        
+    Returns:
+        Formatted search results as string
+    """
+    cognee_integration = CogneeProjectIntegration(project_dir)
+    result = await cognee_integration.search_knowledge_graph(query, search_type, dataset)
+    
+    if "error" in result:
+        return f"Error searching codebase: {result['error']}"
+    
+    project_name = result.get("project", "Unknown")
+    results = result.get("results", [])
+    
+    if not results:
+        return f"No results found for '{query}' in project {project_name}"
+    
+    output = f"Search results for '{query}' in project {project_name}:\n\n"
+    
+    # Format results
+    if isinstance(results, list):
+        for i, item in enumerate(results, 1):
+            if isinstance(item, dict):
+                # Handle structured results
+                output += f"{i}. "
+                if "search_result" in item:
+                    output += f"Dataset: {item.get('dataset_name', 'Unknown')}\n"
+                    for result_item in item["search_result"]:
+                        if isinstance(result_item, dict):
+                            if "name" in result_item:
+                                output += f"   - {result_item['name']}: {result_item.get('description', '')}\n"
+                            elif "text" in result_item:
+                                text = result_item["text"][:200] + "..." if len(result_item["text"]) > 200 else result_item["text"]
+                                output += f"   - {text}\n"
+                            else:
+                                output += f"   - {str(result_item)[:200]}...\n"
+                else:
+                    output += f"{str(item)[:200]}...\n"
+                output += "\n"
+            else:
+                output += f"{i}. {str(item)[:200]}...\n\n"
+    else:
+        output += f"{str(results)[:500]}..."
+    
+    return output
+
+
+async def list_project_knowledge(project_dir: Optional[str] = None) -> str:
+    """
+    Convenience function to list project knowledge
+    
+    Args:
+        project_dir: Project directory (optional, defaults to cwd)
+        
+    Returns:
+        Formatted list of available data
+    """
+    cognee_integration = CogneeProjectIntegration(project_dir)
+    result = await cognee_integration.list_knowledge_data()
+    
+    if "error" in result:
+        return f"Error listing knowledge: {result['error']}"
+    
+    project_name = result.get("project", "Unknown")
+    data = result.get("available_data", [])
+    
+    output = f"Available knowledge in project {project_name}:\n\n"
+    
+    if not data:
+        output += "No data available in knowledge graph"
+    else:
+        for i, item in enumerate(data, 1):
+            output += f"{i}. {item}\n"
+    
+    return output

ai/src/fuzzforge_ai/cognee_service.py

@@ -0,0 +1,416 @@
+"""
+Cognee Service for FuzzForge
+Provides integrated Cognee functionality for codebase analysis and knowledge graphs
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+import asyncio
+import logging
+from pathlib import Path
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+
+class CogneeService:
+    """
+    Service for managing Cognee integration with FuzzForge
+    Handles multi-tenant isolation and project-specific knowledge graphs
+    """
+    
+    def __init__(self, config):
+        """Initialize with FuzzForge config"""
+        self.config = config
+        self.cognee_config = config.get_cognee_config()
+        self.project_context = config.get_project_context()
+        self._cognee = None
+        self._user = None
+        self._initialized = False
+    
+    async def initialize(self):
+        """Initialize Cognee with project-specific configuration"""
+        try:
+            # Ensure environment variables for Cognee are set before import
+            self.config.setup_cognee_environment()
+            logger.debug(
+                "Cognee environment configured",
+                extra={
+                    "data": self.cognee_config.get("data_directory"),
+                    "system": self.cognee_config.get("system_directory"),
+                },
+            )
+
+            import cognee
+            self._cognee = cognee
+            
+            # Configure LLM with API key BEFORE any other cognee operations
+            provider = os.getenv("LLM_PROVIDER", "openai")
+            model = os.getenv("LLM_MODEL") or os.getenv("LITELLM_MODEL", "gpt-4o-mini")
+            api_key = os.getenv("LLM_API_KEY") or os.getenv("OPENAI_API_KEY")
+            endpoint = os.getenv("LLM_ENDPOINT")
+            api_version = os.getenv("LLM_API_VERSION")
+            max_tokens = os.getenv("LLM_MAX_TOKENS")
+
+            if provider.lower() in {"openai", "azure_openai", "custom"} and not api_key:
+                raise ValueError(
+                    "OpenAI-compatible API key is required for Cognee LLM operations. "
+                    "Set OPENAI_API_KEY, LLM_API_KEY, or COGNEE_LLM_API_KEY in your .env"
+                )
+
+            # Expose environment variables for downstream libraries
+            os.environ["LLM_PROVIDER"] = provider
+            os.environ["LITELLM_MODEL"] = model
+            os.environ["LLM_MODEL"] = model
+            if api_key:
+                os.environ["LLM_API_KEY"] = api_key
+                # Maintain compatibility with components still expecting OPENAI_API_KEY
+                if provider.lower() in {"openai", "azure_openai", "custom"}:
+                    os.environ.setdefault("OPENAI_API_KEY", api_key)
+            if endpoint:
+                os.environ["LLM_ENDPOINT"] = endpoint
+            if api_version:
+                os.environ["LLM_API_VERSION"] = api_version
+            if max_tokens:
+                os.environ["LLM_MAX_TOKENS"] = str(max_tokens)
+
+            # Configure Cognee's runtime using its configuration helpers when available
+            if hasattr(cognee.config, "set_llm_provider"):
+                cognee.config.set_llm_provider(provider)
+            if hasattr(cognee.config, "set_llm_model"):
+                cognee.config.set_llm_model(model)
+            if api_key and hasattr(cognee.config, "set_llm_api_key"):
+                cognee.config.set_llm_api_key(api_key)
+            if endpoint and hasattr(cognee.config, "set_llm_endpoint"):
+                cognee.config.set_llm_endpoint(endpoint)
+            if api_version and hasattr(cognee.config, "set_llm_api_version"):
+                cognee.config.set_llm_api_version(api_version)
+            if max_tokens and hasattr(cognee.config, "set_llm_max_tokens"):
+                cognee.config.set_llm_max_tokens(int(max_tokens))
+            
+            # Configure graph database
+            cognee.config.set_graph_db_config({
+                "graph_database_provider": self.cognee_config.get("graph_database_provider", "kuzu"),
+            })
+            
+            # Set data directories
+            data_dir = self.cognee_config.get("data_directory")
+            system_dir = self.cognee_config.get("system_directory")
+            
+            if data_dir:
+                logger.debug("Setting cognee data root", extra={"path": data_dir})
+                cognee.config.data_root_directory(data_dir)
+            if system_dir:
+                logger.debug("Setting cognee system root", extra={"path": system_dir})
+                cognee.config.system_root_directory(system_dir)
+            
+            # Setup multi-tenant user context
+            await self._setup_user_context()
+            
+            self._initialized = True
+            logger.info(f"Cognee initialized for project {self.project_context['project_name']} "
+                       f"with Kuzu at {system_dir}")
+            
+        except ImportError:
+            logger.error("Cognee not installed. Install with: pip install cognee")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to initialize Cognee: {e}")
+            raise
+    
+    async def create_dataset(self):
+        """Create dataset for this project if it doesn't exist"""
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            # Dataset creation is handled automatically by Cognee when adding files
+            # We just ensure we have the right context set up
+            dataset_name = f"{self.project_context['project_name']}_codebase"
+            logger.info(f"Dataset {dataset_name} ready for project {self.project_context['project_name']}")
+            return dataset_name
+        except Exception as e:
+            logger.error(f"Failed to create dataset: {e}")
+            raise
+    
+    async def _setup_user_context(self):
+        """Setup user context for multi-tenant isolation"""
+        try:
+            from cognee.modules.users.methods import create_user, get_user
+            
+            # Always try fallback email first to avoid validation issues
+            fallback_email = f"project_{self.project_context['project_id']}@fuzzforge.example"
+            user_tenant = self.project_context['tenant_id']
+            
+            # Try to get existing fallback user first
+            try:
+                self._user = await get_user(fallback_email)
+                logger.info(f"Using existing user: {fallback_email}")
+                return
+            except:
+                # User doesn't exist, try to create fallback
+                pass
+            
+            # Create fallback user
+            try:
+                self._user = await create_user(fallback_email, user_tenant)
+                logger.info(f"Created fallback user: {fallback_email} for tenant: {user_tenant}")
+                return
+            except Exception as fallback_error:
+                logger.warning(f"Fallback user creation failed: {fallback_error}")
+                self._user = None
+                return
+            
+        except Exception as e:
+            logger.warning(f"Could not setup multi-tenant user context: {e}")
+            logger.info("Proceeding with default context")
+            self._user = None
+    
+    def get_project_dataset_name(self, dataset_suffix: str = "codebase") -> str:
+        """Get project-specific dataset name"""
+        return f"{self.project_context['project_name']}_{dataset_suffix}"
+    
+    async def ingest_text(self, content: str, dataset: str = "fuzzforge") -> bool:
+        """Ingest text content into knowledge graph"""
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            await self._cognee.add([content], dataset)
+            await self._cognee.cognify([dataset])
+            return True
+        except Exception as e:
+            logger.error(f"Failed to ingest text: {e}")
+            return False
+    
+    async def ingest_files(self, file_paths: List[Path], dataset: str = "fuzzforge") -> Dict[str, Any]:
+        """Ingest multiple files into knowledge graph"""
+        if not self._initialized:
+            await self.initialize()
+        
+        results = {
+            "success": 0,
+            "failed": 0,
+            "errors": []
+        }
+        
+        try:
+            ingest_paths: List[str] = []
+            for file_path in file_paths:
+                try:
+                    with open(file_path, 'r', encoding='utf-8'):
+                        ingest_paths.append(str(file_path))
+                    results["success"] += 1
+                except (UnicodeDecodeError, PermissionError) as exc:
+                    results["failed"] += 1
+                    results["errors"].append(f"{file_path}: {exc}")
+                    logger.warning("Skipping %s: %s", file_path, exc)
+
+            if ingest_paths:
+                await self._cognee.add(ingest_paths, dataset_name=dataset)
+                await self._cognee.cognify([dataset])
+            
+        except Exception as e:
+            logger.error(f"Failed to ingest files: {e}")
+            results["errors"].append(f"Cognify error: {str(e)}")
+        
+        return results
+    
+    async def search_insights(self, query: str, dataset: str = None) -> List[str]:
+        """Search for insights in the knowledge graph"""
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            from cognee.modules.search.types import SearchType
+            
+            kwargs = {
+                "query_type": SearchType.INSIGHTS,
+                "query_text": query
+            }
+            
+            if dataset:
+                kwargs["datasets"] = [dataset]
+            
+            results = await self._cognee.search(**kwargs)
+            return results if isinstance(results, list) else []
+            
+        except Exception as e:
+            logger.error(f"Failed to search insights: {e}")
+            return []
+    
+    async def search_chunks(self, query: str, dataset: str = None) -> List[str]:
+        """Search for relevant text chunks"""
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            from cognee.modules.search.types import SearchType
+            
+            kwargs = {
+                "query_type": SearchType.CHUNKS,
+                "query_text": query
+            }
+            
+            if dataset:
+                kwargs["datasets"] = [dataset]
+            
+            results = await self._cognee.search(**kwargs)
+            return results if isinstance(results, list) else []
+            
+        except Exception as e:
+            logger.error(f"Failed to search chunks: {e}")
+            return []
+    
+    async def search_graph_completion(self, query: str) -> List[str]:
+        """Search for graph completion (relationships)"""
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            from cognee.modules.search.types import SearchType
+            
+            results = await self._cognee.search(
+                query_type=SearchType.GRAPH_COMPLETION,
+                query_text=query
+            )
+            return results if isinstance(results, list) else []
+            
+        except Exception as e:
+            logger.error(f"Failed to search graph completion: {e}")
+            return []
+    
+    async def get_status(self) -> Dict[str, Any]:
+        """Get service status and statistics"""
+        status = {
+            "initialized": self._initialized,
+            "enabled": self.cognee_config.get("enabled", True),
+            "provider": self.cognee_config.get("graph_database_provider", "kuzu"),
+            "data_directory": self.cognee_config.get("data_directory"),
+            "system_directory": self.cognee_config.get("system_directory"),
+        }
+        
+        if self._initialized:
+            try:
+                # Check if directories exist and get sizes
+                data_dir = Path(status["data_directory"])
+                system_dir = Path(status["system_directory"])
+                
+                status.update({
+                    "data_dir_exists": data_dir.exists(),
+                    "system_dir_exists": system_dir.exists(),
+                    "kuzu_db_exists": (system_dir / "kuzu_db").exists(),
+                    "lancedb_exists": (system_dir / "lancedb").exists(),
+                })
+                
+            except Exception as e:
+                status["status_error"] = str(e)
+        
+        return status
+    
+    async def clear_data(self, confirm: bool = False):
+        """Clear all ingested data (dangerous!)"""
+        if not confirm:
+            raise ValueError("Must confirm data clearing with confirm=True")
+        
+        if not self._initialized:
+            await self.initialize()
+        
+        try:
+            await self._cognee.prune.prune_data()
+            await self._cognee.prune.prune_system(metadata=True)
+            logger.info("Cognee data cleared")
+        except Exception as e:
+            logger.error(f"Failed to clear data: {e}")
+            raise
+
+
+class FuzzForgeCogneeIntegration:
+    """
+    Main integration class for FuzzForge + Cognee
+    Provides high-level operations for security analysis
+    """
+    
+    def __init__(self, config):
+        self.service = CogneeService(config)
+    
+    async def analyze_codebase(self, path: Path, recursive: bool = True) -> Dict[str, Any]:
+        """
+        Analyze a codebase and extract security-relevant insights
+        """
+        # Collect code files
+        from fuzzforge_ai.ingest_utils import collect_ingest_files
+
+        files = collect_ingest_files(path, recursive, None, [])
+        
+        if not files:
+            return {"error": "No files found to analyze"}
+        
+        # Ingest files
+        results = await self.service.ingest_files(files, "security_analysis")
+        
+        if results["success"] == 0:
+            return {"error": "Failed to ingest any files", "details": results}
+        
+        # Extract security insights
+        security_queries = [
+            "vulnerabilities security risks",
+            "authentication authorization",
+            "input validation sanitization", 
+            "encryption cryptography",
+            "error handling exceptions",
+            "logging sensitive data"
+        ]
+        
+        insights = {}
+        for query in security_queries:
+            insight_results = await self.service.search_insights(query, "security_analysis")
+            if insight_results:
+                insights[query.replace(" ", "_")] = insight_results
+        
+        return {
+            "files_processed": results["success"],
+            "files_failed": results["failed"],
+            "errors": results["errors"],
+            "security_insights": insights
+        }
+    
+    async def query_codebase(self, query: str, search_type: str = "insights") -> List[str]:
+        """Query the ingested codebase"""
+        if search_type == "insights":
+            return await self.service.search_insights(query)
+        elif search_type == "chunks":
+            return await self.service.search_chunks(query)
+        elif search_type == "graph":
+            return await self.service.search_graph_completion(query)
+        else:
+            raise ValueError(f"Unknown search type: {search_type}")
+    
+    async def get_project_summary(self) -> Dict[str, Any]:
+        """Get a summary of the analyzed project"""
+        # Search for general project insights
+        summary_queries = [
+            "project structure components",
+            "main functionality features",
+            "programming languages frameworks",
+            "dependencies libraries"
+        ]
+        
+        summary = {}
+        for query in summary_queries:
+            results = await self.service.search_insights(query)
+            if results:
+                summary[query.replace(" ", "_")] = results[:3]  # Top 3 results
+        
+        return summary

ai/src/fuzzforge_ai/config.yaml

@@ -0,0 +1,9 @@
+# FuzzForge Registered Agents
+# These agents will be automatically registered on startup
+
+registered_agents:
+
+# Example entries:
+# - name: Calculator
+#   url: http://localhost:10201
+#   description: Mathematical calculations agent

ai/src/fuzzforge_ai/config_bridge.py

@@ -0,0 +1,31 @@
+"""Bridge module providing access to the host CLI configuration manager."""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+try:
+    from fuzzforge_cli.config import ProjectConfigManager as _ProjectConfigManager
+except ImportError as exc:  # pragma: no cover - used when CLI not available
+    class _ProjectConfigManager:  # type: ignore[no-redef]
+        """Fallback implementation that raises a helpful error."""
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "ProjectConfigManager is unavailable. Install the FuzzForge CLI "
+                "package or supply a compatible configuration object."
+            ) from exc
+
+    def __getattr__(name):  # pragma: no cover - defensive
+        raise ImportError("ProjectConfigManager unavailable") from exc
+
+ProjectConfigManager = _ProjectConfigManager
+
+__all__ = ["ProjectConfigManager"]

ai/src/fuzzforge_ai/config_manager.py

@@ -0,0 +1,134 @@
+"""
+Configuration manager for FuzzForge
+Handles loading and saving registered agents
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+import yaml
+from typing import Dict, Any, List
+
+class ConfigManager:
+    """Manages FuzzForge agent registry configuration"""
+    
+    def __init__(self, config_path: str = None):
+        """Initialize config manager"""
+        if config_path:
+            self.config_path = config_path
+        else:
+            # Check for local .fuzzforge/agents.yaml first, then fall back to global
+            local_config = os.path.join(os.getcwd(), '.fuzzforge', 'agents.yaml')
+            global_config = os.path.join(os.path.dirname(__file__), 'config.yaml')
+            
+            if os.path.exists(local_config):
+                self.config_path = local_config
+                if os.getenv("FUZZFORGE_DEBUG", "0") == "1":
+                    print(f"[CONFIG] Using local config: {local_config}")
+            else:
+                self.config_path = global_config
+                if os.getenv("FUZZFORGE_DEBUG", "0") == "1":
+                    print(f"[CONFIG] Using global config: {global_config}")
+        
+        self.config = self.load_config()
+    
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from YAML file"""
+        if not os.path.exists(self.config_path):
+            # Create default config if it doesn't exist
+            return {'registered_agents': []}
+        
+        try:
+            with open(self.config_path, 'r') as f:
+                config = yaml.safe_load(f) or {}
+                # Ensure registered_agents is a list
+                if 'registered_agents' not in config or config['registered_agents'] is None:
+                    config['registered_agents'] = []
+                return config
+        except Exception as e:
+            print(f"[WARNING] Failed to load config: {e}")
+            return {'registered_agents': []}
+    
+    def save_config(self):
+        """Save current configuration to file"""
+        try:
+            # Create a clean config with comments
+            config_content = """# FuzzForge Registered Agents
+# These agents will be automatically registered on startup
+
+"""
+            # Add the agents list
+            if self.config.get('registered_agents'):
+                config_content += yaml.dump({'registered_agents': self.config['registered_agents']}, 
+                                           default_flow_style=False, sort_keys=False)
+            else:
+                config_content += "registered_agents: []\n"
+            
+            config_content += """
+# Example entries:
+# - name: Calculator
+#   url: http://localhost:10201
+#   description: Mathematical calculations agent
+"""
+            
+            with open(self.config_path, 'w') as f:
+                f.write(config_content)
+                
+            return True
+        except Exception as e:
+            print(f"[ERROR] Failed to save config: {e}")
+            return False
+    
+    def get_registered_agents(self) -> List[Dict[str, Any]]:
+        """Get list of registered agents from config"""
+        return self.config.get('registered_agents', [])
+    
+    def add_registered_agent(self, name: str, url: str, description: str = "") -> bool:
+        """Add a new registered agent to config"""
+        if 'registered_agents' not in self.config:
+            self.config['registered_agents'] = []
+        
+        # Check if agent already exists
+        for agent in self.config['registered_agents']:
+            if agent.get('url') == url:
+                # Update existing agent
+                agent['name'] = name
+                agent['description'] = description
+                return self.save_config()
+        
+        # Add new agent
+        self.config['registered_agents'].append({
+            'name': name,
+            'url': url,
+            'description': description
+        })
+        
+        return self.save_config()
+    
+    def remove_registered_agent(self, name: str = None, url: str = None) -> bool:
+        """Remove a registered agent from config"""
+        if 'registered_agents' not in self.config:
+            return False
+        
+        original_count = len(self.config['registered_agents'])
+        
+        # Filter out the agent
+        self.config['registered_agents'] = [
+            agent for agent in self.config['registered_agents']
+            if not ((name and agent.get('name') == name) or 
+                   (url and agent.get('url') == url))
+        ]
+        
+        if len(self.config['registered_agents']) < original_count:
+            return self.save_config()
+        
+        return False

ai/src/fuzzforge_ai/ingest_utils.py

@@ -0,0 +1,104 @@
+"""Utilities for collecting files to ingest into Cognee."""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+from typing import Iterable, List, Optional
+
+_DEFAULT_FILE_TYPES = [
+    ".py",
+    ".js",
+    ".ts",
+    ".java",
+    ".cpp",
+    ".c",
+    ".h",
+    ".rs",
+    ".go",
+    ".rb",
+    ".php",
+    ".cs",
+    ".swift",
+    ".kt",
+    ".scala",
+    ".clj",
+    ".hs",
+    ".md",
+    ".txt",
+    ".yaml",
+    ".yml",
+    ".json",
+    ".toml",
+    ".cfg",
+    ".ini",
+]
+
+_DEFAULT_EXCLUDE = [
+    "*.pyc",
+    "__pycache__",
+    ".git",
+    ".svn",
+    ".hg",
+    "node_modules",
+    ".venv",
+    "venv",
+    ".env",
+    "dist",
+    "build",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".tox",
+    "coverage",
+    "*.log",
+    "*.tmp",
+]
+
+
+def collect_ingest_files(
+    path: Path,
+    recursive: bool = True,
+    file_types: Optional[Iterable[str]] = None,
+    exclude: Optional[Iterable[str]] = None,
+) -> List[Path]:
+    """Return a list of files eligible for ingestion."""
+    path = path.resolve()
+    files: List[Path] = []
+
+    extensions = list(file_types) if file_types else list(_DEFAULT_FILE_TYPES)
+    exclusions = list(exclude) if exclude else []
+    exclusions.extend(_DEFAULT_EXCLUDE)
+
+    def should_exclude(file_path: Path) -> bool:
+        file_str = str(file_path)
+        for pattern in exclusions:
+            if fnmatch.fnmatch(file_str, f"*{pattern}*") or fnmatch.fnmatch(file_path.name, pattern):
+                return True
+        return False
+
+    if path.is_file():
+        if not should_exclude(path) and any(str(path).endswith(ext) for ext in extensions):
+            files.append(path)
+        return files
+
+    pattern = "**/*" if recursive else "*"
+    for file_path in path.glob(pattern):
+        if file_path.is_file() and not should_exclude(file_path):
+            if any(str(file_path).endswith(ext) for ext in extensions):
+                files.append(file_path)
+
+    return files
+
+
+__all__ = ["collect_ingest_files"]

ai/src/fuzzforge_ai/memory_service.py

@@ -0,0 +1,247 @@
+"""
+FuzzForge Memory Service
+Implements ADK MemoryService pattern for conversational memory
+Separate from Cognee which will be used for RAG/codebase analysis
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import os
+import json
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+import logging
+
+# ADK Memory imports
+from google.adk.memory import InMemoryMemoryService, BaseMemoryService
+from google.adk.memory.base_memory_service import SearchMemoryResponse
+from google.adk.memory.memory_entry import MemoryEntry
+
+# Optional VertexAI Memory Bank
+try:
+    from google.adk.memory import VertexAiMemoryBankService
+    VERTEX_AVAILABLE = True
+except ImportError:
+    VERTEX_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+
+class FuzzForgeMemoryService:
+    """
+    Manages conversational memory using ADK patterns
+    This is separate from Cognee which will handle RAG/codebase
+    """
+    
+    def __init__(self, memory_type: str = "inmemory", **kwargs):
+        """
+        Initialize memory service
+        
+        Args:
+            memory_type: "inmemory" or "vertexai"
+            **kwargs: Additional args for specific memory service
+                     For vertexai: project, location, agent_engine_id
+        """
+        self.memory_type = memory_type
+        self.service = self._create_service(memory_type, **kwargs)
+        
+    def _create_service(self, memory_type: str, **kwargs) -> BaseMemoryService:
+        """Create the appropriate memory service"""
+        
+        if memory_type == "inmemory":
+            # Use ADK's InMemoryMemoryService for local development
+            logger.info("Using InMemory MemoryService for conversational memory")
+            return InMemoryMemoryService()
+            
+        elif memory_type == "vertexai" and VERTEX_AVAILABLE:
+            # Use VertexAI Memory Bank for production
+            project = kwargs.get('project') or os.getenv('GOOGLE_CLOUD_PROJECT')
+            location = kwargs.get('location') or os.getenv('GOOGLE_CLOUD_LOCATION', 'us-central1')
+            agent_engine_id = kwargs.get('agent_engine_id') or os.getenv('AGENT_ENGINE_ID')
+            
+            if not all([project, location, agent_engine_id]):
+                logger.warning("VertexAI config missing, falling back to InMemory")
+                return InMemoryMemoryService()
+            
+            logger.info(f"Using VertexAI MemoryBank: {agent_engine_id}")
+            return VertexAiMemoryBankService(
+                project=project,
+                location=location,
+                agent_engine_id=agent_engine_id
+            )
+        else:
+            # Default to in-memory
+            logger.info("Defaulting to InMemory MemoryService")
+            return InMemoryMemoryService()
+    
+    async def add_session_to_memory(self, session: Any) -> None:
+        """
+        Add a completed session to long-term memory
+        This extracts meaningful information from the conversation
+        
+        Args:
+            session: The session object to process
+        """
+        try:
+            # Let the underlying service handle the ingestion
+            # It will extract relevant information based on the implementation
+            await self.service.add_session_to_memory(session)
+            
+            logger.debug(f"Added session {session.id} to {self.memory_type} memory")
+            
+        except Exception as e:
+            logger.error(f"Failed to add session to memory: {e}")
+    
+    async def search_memory(self, 
+                          query: str,
+                          app_name: str = "fuzzforge",
+                          user_id: str = None,
+                          max_results: int = 10) -> SearchMemoryResponse:
+        """
+        Search long-term memory for relevant information
+        
+        Args:
+            query: The search query
+            app_name: Application name for filtering
+            user_id: User ID for filtering (optional)
+            max_results: Maximum number of results
+            
+        Returns:
+            SearchMemoryResponse with relevant memories
+        """
+        try:
+            # Search the memory service
+            results = await self.service.search_memory(
+                app_name=app_name,
+                user_id=user_id,
+                query=query
+            )
+            
+            logger.debug(f"Memory search for '{query}' returned {len(results.memories)} results")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Memory search failed: {e}")
+            # Return empty results on error
+            return SearchMemoryResponse(memories=[])
+    
+    async def ingest_completed_sessions(self, session_service) -> int:
+        """
+        Batch ingest all completed sessions into memory
+        Useful for initial memory population
+        
+        Args:
+            session_service: The session service containing sessions
+            
+        Returns:
+            Number of sessions ingested
+        """
+        ingested = 0
+        
+        try:
+            # Get all sessions from the session service
+            sessions = await session_service.list_sessions(app_name="fuzzforge")
+            
+            for session_info in sessions:
+                # Load full session
+                session = await session_service.load_session(
+                    app_name="fuzzforge",
+                    user_id=session_info.get('user_id'),
+                    session_id=session_info.get('id')
+                )
+                
+                if session and len(session.get_events()) > 0:
+                    await self.add_session_to_memory(session)
+                    ingested += 1
+                    
+            logger.info(f"Ingested {ingested} sessions into {self.memory_type} memory")
+            
+        except Exception as e:
+            logger.error(f"Failed to batch ingest sessions: {e}")
+            
+        return ingested
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get memory service status"""
+        return {
+            "type": self.memory_type,
+            "active": self.service is not None,
+            "vertex_available": VERTEX_AVAILABLE,
+            "details": {
+                "inmemory": "Non-persistent, keyword search",
+                "vertexai": "Persistent, semantic search with LLM extraction"
+            }.get(self.memory_type, "Unknown")
+        }
+
+
+class HybridMemoryManager:
+    """
+    Manages both ADK MemoryService (conversational) and Cognee (RAG/codebase)
+    Provides unified interface for both memory systems
+    """
+    
+    def __init__(self, 
+                 memory_service: FuzzForgeMemoryService = None,
+                 cognee_tools = None):
+        """
+        Initialize with both memory systems
+        
+        Args:
+            memory_service: ADK-pattern memory for conversations
+            cognee_tools: Cognee MCP tools for RAG/codebase
+        """
+        # ADK memory for conversations
+        self.memory_service = memory_service or FuzzForgeMemoryService()
+        
+        # Cognee for knowledge graphs and RAG (future)
+        self.cognee_tools = cognee_tools
+        
+    async def search_conversational_memory(self, query: str) -> SearchMemoryResponse:
+        """Search past conversations using ADK memory"""
+        return await self.memory_service.search_memory(query)
+    
+    async def search_knowledge_graph(self, query: str, search_type: str = "GRAPH_COMPLETION"):
+        """Search Cognee knowledge graph (for RAG/codebase in future)"""
+        if not self.cognee_tools:
+            return None
+            
+        try:
+            # Use Cognee's graph search
+            return await self.cognee_tools.search(
+                query=query,
+                search_type=search_type
+            )
+        except Exception as e:
+            logger.debug(f"Cognee search failed: {e}")
+            return None
+    
+    async def store_in_graph(self, content: str):
+        """Store in Cognee knowledge graph (for codebase analysis later)"""
+        if not self.cognee_tools:
+            return None
+            
+        try:
+            # Use cognify to create graph structures
+            return await self.cognee_tools.cognify(content)
+        except Exception as e:
+            logger.debug(f"Cognee store failed: {e}")
+            return None
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get status of both memory systems"""
+        return {
+            "conversational_memory": self.memory_service.get_status(),
+            "knowledge_graph": {
+                "active": self.cognee_tools is not None,
+                "purpose": "RAG/codebase analysis (future)"
+            }
+        }

ai/src/fuzzforge_ai/remote_agent.py

@@ -0,0 +1,148 @@
+"""
+Remote Agent Connection Handler
+Handles A2A protocol communication with remote agents
+"""
+# Copyright (c) 2025 FuzzingLabs
+#
+# Licensed under the Business Source License 1.1 (BSL). See the LICENSE file
+# at the root of this repository for details.
+#
+# After the Change Date (four years from publication), this version of the
+# Licensed Work will be made available under the Apache License, Version 2.0.
+# See the LICENSE-APACHE file or http://www.apache.org/licenses/LICENSE-2.0
+#
+# Additional attribution and requirements are provided in the NOTICE file.
+
+
+import httpx
+import uuid
+from typing import Dict, Any, Optional, List
+
+
+class RemoteAgentConnection:
+    """Handles A2A protocol communication with remote agents"""
+    
+    def __init__(self, url: str):
+        """Initialize connection to a remote agent"""
+        self.url = url.rstrip('/')
+        self.agent_card = None
+        self.client = httpx.AsyncClient(timeout=120.0)
+        self.context_id = None
+        
+    async def get_agent_card(self) -> Optional[Dict[str, Any]]:
+        """Get the agent card from the remote agent"""
+        try:
+            # Try new path first (A2A 0.3.0+)
+            response = await self.client.get(f"{self.url}/.well-known/agent-card.json")
+            response.raise_for_status()
+            self.agent_card = response.json()
+            return self.agent_card
+        except:
+            # Try old path for compatibility
+            try:
+                response = await self.client.get(f"{self.url}/.well-known/agent.json")
+                response.raise_for_status()
+                self.agent_card = response.json()
+                return self.agent_card
+            except Exception as e:
+                print(f"Failed to get agent card from {self.url}: {e}")
+                return None
+                
+    async def send_message(self, message: str | Dict[str, Any] | List[Dict[str, Any]]) -> str:
+        """Send a message to the remote agent using A2A protocol"""
+        try:
+            parts: List[Dict[str, Any]]
+            metadata: Dict[str, Any] | None = None
+            if isinstance(message, dict):
+                metadata = message.get("metadata") if isinstance(message.get("metadata"), dict) else None
+                raw_parts = message.get("parts", [])
+                if not raw_parts:
+                    text_value = message.get("text") or message.get("message")
+                    if isinstance(text_value, str):
+                        raw_parts = [{"type": "text", "text": text_value}]
+                parts = [raw_part for raw_part in raw_parts if isinstance(raw_part, dict)]
+            elif isinstance(message, list):
+                parts = [part for part in message if isinstance(part, dict)]
+                metadata = None
+            else:
+                parts = [{"type": "text", "text": message}]
+                metadata = None
+
+            if not parts:
+                parts = [{"type": "text", "text": ""}]
+
+            # Build JSON-RPC request per A2A spec
+            payload = {
+                "jsonrpc": "2.0",
+                "method": "message/send",
+                "params": {
+                    "message": {
+                        "messageId": str(uuid.uuid4()),
+                        "role": "user",
+                        "parts": parts,
+                    }
+                },
+                "id": 1
+            }
+
+            if metadata:
+                payload["params"]["message"]["metadata"] = metadata
+            
+            # Include context if we have one
+            if self.context_id:
+                payload["params"]["contextId"] = self.context_id
+            
+            # Send to root endpoint per A2A protocol
+            response = await self.client.post(f"{self.url}/", json=payload)
+            response.raise_for_status()
+            result = response.json()
+            
+            # Extract response based on A2A JSON-RPC format
+            if isinstance(result, dict):
+                # Update context for continuity
+                if "result" in result and isinstance(result["result"], dict):
+                    if "contextId" in result["result"]:
+                        self.context_id = result["result"]["contextId"]
+                    
+                    # Extract text from artifacts
+                    if "artifacts" in result["result"]:
+                        texts = []
+                        for artifact in result["result"]["artifacts"]:
+                            if isinstance(artifact, dict) and "parts" in artifact:
+                                for part in artifact["parts"]:
+                                    if isinstance(part, dict) and "text" in part:
+                                        texts.append(part["text"])
+                        if texts:
+                            return " ".join(texts)
+                    
+                    # Extract from message format
+                    if "message" in result["result"]:
+                        msg = result["result"]["message"]
+                        if isinstance(msg, dict) and "parts" in msg:
+                            texts = []
+                            for part in msg["parts"]:
+                                if isinstance(part, dict) and "text" in part:
+                                    texts.append(part["text"])
+                            return " ".join(texts) if texts else str(msg)
+                        return str(msg)
+                    
+                    return str(result["result"])
+                
+                # Handle error response
+                elif "error" in result:
+                    error = result["error"]
+                    if isinstance(error, dict):
+                        return f"Error: {error.get('message', str(error))}"
+                    return f"Error: {error}"
+                
+                # Fallback
+                return result.get("response", result.get("message", str(result)))
+            
+            return str(result)
+            
+        except Exception as e:
+            return f"Error communicating with agent: {e}"
+            
+    async def close(self):
+        """Close the connection properly"""
+        await self.client.aclose()