Implement OpenCog transformation foundation structure

Co-authored-by: drzo <[email protected]>

Author: Copilot

Argcfile.sh

@@ -74,6 +74,20 @@ build() {
     if [[ -f mcp.json ]]; then
         argc mcp merge-functions -S
     fi
+    # Build OpenCog components if available
+    if [[ -f CMakeLists.txt ]]; then
+        echo 'Building OpenCog components...'
+        argc build@opencog
+    fi
+}
+
+# @cmd Build OpenCog module
+# @alias opencog:build
+build@opencog() {
+    if [[ ! -f build-opencog.sh ]]; then
+        _die "error: build-opencog.sh not found"
+    fi
+    ./build-opencog.sh
 }
 
 # @cmd Build tools
@@ -584,6 +598,31 @@ create@tool() {
     ./scripts/create-tool.sh "$@"
 }
 
+# @cmd Test OpenCog module structure
+# @alias opencog:test
+test@opencog() {
+    if [[ ! -f test-structure.sh ]]; then
+        _die "error: test-structure.sh not found"
+    fi
+    ./test-structure.sh
+}
+
+# @cmd Run OpenCog example
+# @alias opencog:example  
+example@opencog() {
+    if [[ ! -f example.scm ]]; then
+        _die "error: example.scm not found"
+    fi
+    if command -v guile &> /dev/null; then
+        guile example.scm
+    else
+        echo "Guile not installed. Install it to run examples:"
+        echo "  Ubuntu/Debian: sudo apt-get install guile-3.0"
+        echo "  Fedora: sudo dnf install guile"
+        echo "  macOS: brew install guile"
+    fi
+}
+
 # @cmd Displays version information for required tools
 version() {
     uname -a

CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.10)
+project(caichat-opencog VERSION 1.0.0)
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Find required packages
+find_package(PkgConfig REQUIRED)
+
+# Find OpenCog (optional for now)
+find_package(PkgConfig QUIET)
+if(PKG_CONFIG_FOUND)
+    pkg_check_modules(OPENCOG opencog)
+endif()
+
+# Find Guile
+pkg_check_modules(GUILE REQUIRED guile-3.0)
+if(NOT GUILE_FOUND)
+    pkg_check_modules(GUILE REQUIRED guile-2.2)
+endif()
+
+# Find other dependencies
+find_package(CURL REQUIRED)
+pkg_check_modules(JSONCPP REQUIRED jsoncpp)
+
+# Include directories
+include_directories(${GUILE_INCLUDE_DIRS})
+include_directories(${JSONCPP_INCLUDE_DIRS})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/opencog)
+
+# Add subdirectories
+add_subdirectory(opencog)
+
+# Install Scheme modules
+install(DIRECTORY scm/ DESTINATION ${CMAKE_INSTALL_PREFIX}/share/guile/site/3.0/opencog
+        FILES_MATCHING PATTERN "*.scm")
+
+# Configuration
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/caichat-config.cmake.in
+               ${CMAKE_CURRENT_BINARY_DIR}/caichat-config.cmake @ONLY)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/caichat-config.cmake
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/cmake/caichat)

build-opencog.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+# Build script for CAIChat OpenCog module
+
+set -e
+
+echo "Building CAIChat OpenCog Module..."
+
+# Check dependencies
+check_dependencies() {
+    echo "Checking dependencies..."
+    
+    local missing_deps=()
+    
+    if ! command -v cmake &> /dev/null; then
+        missing_deps+=("cmake")
+    fi
+    
+    if ! command -v pkg-config &> /dev/null; then
+        missing_deps+=("pkg-config")
+    fi
+    
+    if ! pkg-config --exists guile-3.0 && ! pkg-config --exists guile-2.2; then
+        missing_deps+=("guile-dev")
+    fi
+    
+    if ! pkg-config --exists libcurl; then
+        missing_deps+=("libcurl-dev")
+    fi
+    
+    if ! pkg-config --exists jsoncpp; then
+        missing_deps+=("libjsoncpp-dev")
+    fi
+    
+    if [ ${#missing_deps[@]} -ne 0 ]; then
+        echo "Missing dependencies: ${missing_deps[*]}"
+        echo "Please install them first:"
+        echo "  Ubuntu/Debian: sudo apt-get install cmake build-essential pkg-config guile-3.0-dev libcurl4-openssl-dev libjsoncpp-dev"
+        echo "  Fedora: sudo dnf install cmake gcc-c++ pkg-config guile-devel libcurl-devel jsoncpp-devel"
+        echo "  macOS: brew install cmake pkg-config guile curl jsoncpp"
+        exit 1
+    fi
+    
+    echo "All dependencies found!"
+}
+
+# Build function
+build_project() {
+    echo "Creating build directory..."
+    mkdir -p build
+    cd build
+    
+    echo "Running CMake..."
+    cmake ..
+    
+    echo "Building..."
+    make -j$(nproc 2>/dev/null || echo 4)
+    
+    echo "Build completed successfully!"
+    echo "To install: sudo make install"
+}
+
+# Test function (if Guile is available)
+test_modules() {
+    if command -v guile &> /dev/null; then
+        echo "Testing Scheme modules..."
+        cd ..
+        guile test-caichat.scm
+    else
+        echo "Guile not found, skipping tests"
+    fi
+}
+
+# Main execution
+main() {
+    check_dependencies
+    build_project
+    test_modules
+}
+
+# Run only if executed directly
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+    main "$@"
+fi

caichat-config.cmake.in

@@ -0,0 +1,11 @@
+@PACKAGE_INIT@
+
+find_dependency(PkgConfig REQUIRED)
+find_dependency(CURL REQUIRED)
+
+pkg_check_modules(GUILE REQUIRED guile-3.0)
+pkg_check_modules(JSONCPP REQUIRED jsoncpp)
+
+include("${CMAKE_CURRENT_LIST_DIR}/caichat-targets.cmake")
+
+check_required_components(caichat)

example.scm

@@ -0,0 +1,49 @@
+#!/usr/bin/env guile
+!#
+
+;; Example usage of CAIChat OpenCog module
+
+(use-modules (opencog caichat init)
+             (opencog caichat config)
+             (opencog caichat repl)
+             (opencog caichat rag))
+
+;; Initialize configuration
+(caichat-config-init)
+
+;; Example 1: Simple question
+(display "Example 1: Simple question\n")
+(display "Question: What is cognitive architecture?\n")
+(display "Answer: ")
+(display (caichat-ask "What is cognitive architecture in 2 sentences?"))
+(newline)
+(newline)
+
+;; Example 2: Configuration
+(display "Example 2: Configuration\n")
+(caichat-config-set! 'default-provider "openai")
+(display (format #f "Default provider: ~a\n" 
+                (caichat-config-get 'default-provider)))
+(newline)
+
+;; Example 3: RAG system
+(display "Example 3: RAG system\n")
+(caichat-rag-create-kb "ai-research" "AI research knowledge base")
+(caichat-rag-add-doc "ai-research" "paper1" 
+                     "Cognitive architecture is a framework for understanding intelligence. It provides a blueprint for building AI systems." 
+                     '(("author" . "Smith") ("year" . "2024")))
+(caichat-rag-add-doc "ai-research" "paper2" 
+                     "OpenCog is an open-source cognitive architecture platform. It uses AtomSpace for knowledge representation." 
+                     '(("author" . "Goertzel") ("year" . "2023")))
+
+(display "RAG Query: What is OpenCog?\n")
+(display "Answer: ")
+(display (caichat-rag-query "ai-research" "What is OpenCog?"))
+(newline)
+(newline)
+
+;; Example 4: Interactive REPL (commented out for non-interactive execution)
+;; (display "Starting interactive REPL...\n")
+;; (caichat-repl-start)
+
+(display "Examples completed successfully!\n")

opencog/CMakeLists.txt

@@ -0,0 +1,33 @@
+# C++ Core Library
+
+add_library(caichat SHARED
+    caichat/LLMClient.cc
+    caichat/ChatCompletion.cc
+    caichat/SchemeBindings.cc
+)
+
+# Include directories
+target_include_directories(caichat PRIVATE 
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${GUILE_INCLUDE_DIRS}
+    ${JSONCPP_INCLUDE_DIRS}
+)
+
+# Link libraries
+target_link_libraries(caichat
+    ${GUILE_LIBRARIES}
+    ${JSONCPP_LIBRARIES}
+    ${CURL_LIBRARIES}
+)
+
+# Compile flags
+target_compile_options(caichat PRIVATE ${GUILE_CFLAGS_OTHER})
+
+# Install library
+install(TARGETS caichat
+        LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
+
+# Install headers
+install(FILES caichat/LLMClient.h caichat/ChatCompletion.h
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/include/opencog/caichat)

opencog/README.md

@@ -0,0 +1,38 @@
+# CAIChat OpenCog Module
+
+This directory contains the OpenCog implementation of CAIChat, transforming the original LLM Functions tools into a cognitive architecture component.
+
+## Structure
+
+- `caichat/` - C++ core library
+  - `LLMClient.h/cc` - LLM provider interfaces and implementations
+  - `ChatCompletion.h/cc` - Conversation management
+  - `SchemeBindings.cc` - Guile Scheme bindings
+
+## Building
+
+```bash
+mkdir build
+cd build
+cmake ..
+make
+```
+
+## Dependencies
+
+- CMake 3.10+
+- C++14 compiler
+- Guile 3.0 (or 2.2)
+- libcurl
+- jsoncpp
+
+## Usage
+
+After building and installing, the module can be used in Guile:
+
+```scheme
+(use-modules (opencog caichat init))
+(caichat-ask "Hello, how are you?")
+```
+
+See `../example.scm` for more comprehensive examples.

opencog/caichat/ChatCompletion.cc

@@ -0,0 +1,47 @@
+#include "ChatCompletion.h"
+
+namespace opencog {
+namespace caichat {
+
+ChatCompletion::ChatCompletion(std::unique_ptr<LLMClient> llmClient, const std::string& model)
+    : client(std::move(llmClient)), defaultModel(model) {
+}
+
+std::string ChatCompletion::sendMessage(const std::string& message, const std::string& role) {
+    // Add user message to history
+    conversationHistory.emplace_back(role, message);
+    
+    // Get response from LLM
+    std::string response = client->chatCompletion(conversationHistory, defaultModel);
+    
+    // Add assistant response to history
+    conversationHistory.emplace_back("assistant", response);
+    
+    return response;
+}
+
+const std::vector<Message>& ChatCompletion::getHistory() const {
+    return conversationHistory;
+}
+
+void ChatCompletion::clearHistory() {
+    conversationHistory.clear();
+}
+
+void ChatCompletion::setSystemMessage(const std::string& message) {
+    // Remove existing system message if any
+    auto it = conversationHistory.begin();
+    if (it != conversationHistory.end() && it->role == "system") {
+        conversationHistory.erase(it);
+    }
+    
+    // Add new system message at the beginning
+    conversationHistory.insert(conversationHistory.begin(), Message("system", message));
+}
+
+LLMClient* ChatCompletion::getClient() const {
+    return client.get();
+}
+
+} // namespace caichat
+} // namespace opencog