Merge pull request #35 from dreamer-coding/main

Author: dreamer-coding

README.md

@@ -1,117 +1,26 @@
 # ***Jellyfish AI Library by Fossil Logic***
 
-Jellyfish is a lightweight, portable AI library written in pure C with no external dependencies, purpose-built for embedded environments and trust-critical systems. Its architecture centers around transparent AI principles, using blockchain-inspired techniques to make all learning, memory, and reasoning fully auditable. Every interaction—input, decision, or output—is recorded as a cryptographically hashed block, creating an immutable, traceable chain of logic that preserves the system’s decision lineage. This enables developers to inspect exactly how and why the system reached a conclusion, down to the model, token, and rule used. The engine supports memory-based reasoning, adaptive learning from prior inputs, and automatic pruning of obsolete or conflicting knowledge, ensuring the system evolves without accumulating contradiction or noise. These features make Jellyfish a foundation for AI systems where verifiability, traceability, and long-term ethical transparency are non-negotiable.
-
-## 🧠 `.jellyfish` File Example
-
-This file defines a **Jellyfish mindset**, mapping named personalities to model chains (`.fish` files):
-
-```ini
-model('core_logic') {
-  description: 'Fundamental AI reasoning and logic modules'
-  tags: ['core', 'logic', 'reasoning']
-  models: ['logic.fish', 'nlp.fish', 'ethics.fish']
-  priority: 1
-  confidence_threshold: 0.75
-  activation_condition: 'always'
-  source_uri: 'https://fossillogic.ai/models/core_logic'
-  origin_device_id: '00:1A:7D:DA:71:13'
-  version: '1.0.0'
-  content_hash: 'a3f5c7d89b4e1f23a567b9d0c1e2f3456789abcdef0123456789abcdef012345'
-  created_at: 1689004800
-  updated_at: 1689091200
-  trust_score: 0.98
-  immutable: 1
-  state_machine: 'logic_state_v1'
-}
-
-model('persona_trump') {
-  description: 'Personality model for Donald Trump simulation'
-  tags: ['persona', 'politics', 'simulation']
-  models: ['trump_brain.fish', 'debate_logic.fish']
-  priority: 5
-  confidence_threshold: 0.6
-  activation_condition: 'user_request == "trump_mode"'
-  source_uri: 'https://fossillogic.ai/models/persona_trump'
-  origin_device_id: '00:1B:44:11:3A:B7'
-  version: '2.1.4'
-  content_hash: 'b1a2c3d4e5f60718293a4b5c6d7e8f90123456789abcdef0123456789abcdef0'
-  created_at: 1689000000
-  updated_at: 1689050000
-  trust_score: 0.85
-  immutable: 0
-  state_machine: 'persona_v2'
-}
-```
+Jellyfish is the core engine of Truthful Intelligence, a lightweight AI library written in pure C with no external dependencies. Designed for embedded and trust-critical systems, it records every input, output, and decision as a cryptographically hashed block, forming a fully auditable chain of reasoning. With support for adaptive learning, memory-based inference, and automatic pruning, Jellyfish ensures transparent, verifiable AI behavior where every conclusion is traceable to its source.
 
-* `mindset(name)` declares a named personality or capability.
-* `models` list refers to one or more `.fish` model files.
-* Optional attributes like `tags`, `priority`, and `activation_condition` allow selective and conditional loading.
-
----
-
-## 🧠 `.fish` File Example
-
-A `.fish` file stores learned associations (called *thought blocks*) in JSON format:
-
-```json
-{
-  "signature": "JFS1",
-  "blocks": [
-    {
-      "input": "fire",
-      "output": "hot",
-      "hash": "b1946ac92492d2347c6235b4d2611184",
-      "timestamp": 1620000000,
-      "delta_ms": 0,
-      "duration_ms": 12,
-      "valid": 1,
-      "confidence": 0.98,
-      "usage_count": 5,
-      "device_id": "a1b2c3d4e5f6a7b8",
-      "signature": "00112233445566778899aabbccddeeff"
-    },
-    {
-      "input": "ice",
-      "output": "cold",
-      "hash": "e4da3b7fbbce2345d7772b0674a318d5",
-      "timestamp": 1620001000,
-      "delta_ms": 1000,
-      "duration_ms": 10,
-      "valid": 1,
-      "confidence": 0.95,
-      "usage_count": 3,
-      "device_id": "a1b2c3d4e5f6a7b8",
-      "signature": "00112233445566778899aabbccddeeff"
-    },
-    {
-      "input": "wind",
-      "output": "fast",
-      "hash": "1679091c5a880faf6fb5e6087eb1b2dc",
-      "timestamp": 1620002000,
-      "delta_ms": 1000,
-      "duration_ms": 8,
-      "valid": 1,
-      "confidence": 0.92,
-      "usage_count": 2,
-      "device_id": "a1b2c3d4e5f6a7b8",
-      "signature": "00112233445566778899aabbccddeeff"
-    }
-  ]
-}
-```
+### Key Features
+
+- **Cross-Platform**  
+  Runs reliably on Windows, macOS, Linux, and embedded systems.
+
+- **Zero Dependencies**  
+  Written entirely in pure C for maximum portability, auditability, and minimal footprint.
+
+- **Blockchain-Inspired Memory**  
+  Every input, output, and decision is stored as a cryptographically hashed block, creating a tamper-resistant, traceable chain of logic.
 
-* `signature`: Identifies the file format version (`JFS1`).
-* Each `block` represents a learned input → output association, optionally timestamped for ordering or pruning.
+- **Self-Pruning Engine**  
+  Automatically removes obsolete or conflicting data, preserving clarity and consistency over time.
 
-## Key Features
+- **Fully Auditable Reasoning**  
+  Supports forensic-level inspection of every decision, enabling ethical and transparent AI behavior.
 
-- **Cross-Platform**: Runs consistently on Windows, macOS, and Linux.
-- **No External Dependencies**: Written in pure C for maximum portability and minimal footprint.
-- **Blockchain-Inspired Memory**: Stores each interaction as a cryptographically hashed block, forming a tamper-resistant chain for transparent and verifiable learning.
-- **Self-Pruning**: Automatically removes outdated or irrelevant data to maintain efficiency.
-- **Traceable Reasoning**: Every decision and memory is auditable, supporting trust-critical applications.
-- **Configurable and Modular**: Easily tailored for embedded, desktop, or custom AI projects.
+- **Modular and Configurable**  
+  Built to be embedded, extended, or customized for Truthful Intelligence applications across any platform.
 
 ## Prerequisites
 
@@ -139,7 +48,7 @@ To get started with Jellyfish, ensure you have the following installed:
    # ======================
    [wrap-git]
    url = https://github.com/fossillogic/fossil-jellyfish.git
-   revision = v0.1.1
+   revision = v0.1.2
 
    [provide]
    fossil-jellyfish = fossil_fish_dep

code/logic/fossil/ai/framework.h

@@ -15,5 +15,7 @@
 #define FOSSIL_JELLYFISH_AI_FRAMEWORK_H
 
 #include "jellyfish.h"
+#include "iochat.h"
+#include "language.h"
 
 #endif /* FOSSIL_JELLYFISH_AI_FRAMEWORK_H */

code/logic/fossil/ai/iochat.h

@@ -0,0 +1,153 @@
+/*
+ * -----------------------------------------------------------------------------
+ * Project: Fossil Logic
+ *
+ * This file is part of the Fossil Logic project, which aims to develop high-
+ * performance, cross-platform applications and libraries. The code contained
+ * herein is subject to the terms and conditions defined in the project license.
+ *
+ * Author: Michael Gene Brockus (Dreamer)
+ *
+ * Copyright (C) 2024 Fossil Logic. All rights reserved.
+ * -----------------------------------------------------------------------------
+ */
+#ifndef FOSSIL_JELLYFISH_IOCHAT_H
+#define FOSSIL_JELLYFISH_IOCHAT_H
+
+#include "jellyfish.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// *****************************************************************************
+// Function prototypes
+// *****************************************************************************
+
+/**
+ * @brief Starts a new conversation session.
+ *
+ * Initializes a context for handling multi-turn dialogue.
+ *
+ * @param context_name Optional name for the context/session.
+ * @return 0 on success, non-zero on failure.
+ */
+int fossil_io_chat_start(const char *context_name, fossil_jellyfish_chain *chain);
+
+/**
+ * @brief Processes a user input and generates a chatbot response.
+ *
+ * Leverages the Jellyfish memory chain to reason about the input.
+ *
+ * @param chain   Pointer to Jellyfish chain.
+ * @param input   User input string.
+ * @param output  Output buffer to receive response.
+ * @param size    Size of output buffer.
+ * @return        0 if response found, -1 if unknown.
+ */
+int fossil_io_chat_respond(fossil_jellyfish_chain *chain, const char *input, char *output, size_t size);
+
+/**
+ * @brief Ends the current conversation session and performs cleanup.
+ *
+ * Frees temporary memory, flushes session logs, or persists updates.
+ *
+ * @return 0 on success.
+ */
+int fossil_io_chat_end(fossil_jellyfish_chain *chain);
+
+/**
+ * @brief Injects a system message into the chain (e.g. "Hello", "System Ready").
+ *
+ * System messages are logged as immutable memory blocks with device signature.
+ *
+ * @param chain  Jellyfish chain.
+ * @param message System-level message.
+ * @return 0 on success.
+ */
+int fossil_io_chat_inject_system_message(fossil_jellyfish_chain *chain, const char *message);
+
+/**
+ * @brief Appends a chatbot-generated response to the chain memory.
+ *
+ * Treats this as a new output associated with the latest user input.
+ *
+ * @param chain   Chain to add memory to.
+ * @param input   Original user input.
+ * @param output  Chatbot response to learn.
+ * @return 0 on success.
+ */
+int fossil_io_chat_learn_response(fossil_jellyfish_chain *chain, const char *input, const char *output);
+
+/**
+ * @brief Returns the number of conversational turns remembered.
+ *
+ * @param chain Jellyfish chain.
+ * @return Number of user-input/output pairs.
+ */
+int fossil_io_chat_turn_count(const fossil_jellyfish_chain *chain);
+
+/**
+ * @brief Summarizes the session into a concise text form.
+ *
+ * This scans the chat blocks and returns a summary paragraph based on user turns.
+ *
+ * @param chain     Jellyfish chain to summarize.
+ * @param summary   Output buffer to store summary.
+ * @param size      Size of the output buffer.
+ * @return 0 on success, -1 if summary couldn't be generated.
+ */
+int fossil_io_chat_summarize_session(const fossil_jellyfish_chain *chain, char *summary, size_t size);
+
+/**
+ * @brief Filters the most recent N turns into a temporary sub-chain.
+ *
+ * Useful for generating context-limited decisions.
+ *
+ * @param chain     Original chat chain.
+ * @param out_chain Output chain filled with most recent turns.
+ * @param turn_count Number of recent user turns to include.
+ * @return 0 on success.
+ */
+int fossil_io_chat_filter_recent(const fossil_jellyfish_chain *chain, fossil_jellyfish_chain *out_chain, int turn_count);
+
+/**
+ * @brief Exports the current conversation history to a text file.
+ *
+ * @param chain     Chain to serialize.
+ * @param filepath  Destination path for output.
+ * @return 0 on success, -1 on error.
+ */
+int fossil_io_chat_export_history(const fossil_jellyfish_chain *chain, const char *filepath);
+
+/**
+ * @brief Imports a context file and loads it into the chain.
+ *
+ * Useful for bootstrapping or restoring previous sessions.
+ *
+ * @param chain     Destination Jellyfish chain.
+ * @param filepath  Source path of saved context.
+ * @return 0 on success, -1 if parsing fails.
+ */
+int fossil_io_chat_import_context(fossil_jellyfish_chain *chain, const char *filepath);
+
+#ifdef __cplusplus
+}
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+namespace fossil {
+
+namespace ai {
+
+
+
+} // namespace ai
+
+} // namespace fossil
+
+#endif
+
+#endif /* fossil_fish_FRAMEWORK_H */