this.me 2.7.6 → 2.7.8

package/README.md

@@ -1,230 +1,92 @@
-<img src="./_._.svg" alt="SVG Image" width="123" height="123" style="width123px; height:123px;">
+<img src="https://suign.github.io/neurons.me/neurons_logo.png" alt="SVG Image" width="123" height="123" style="width123px; height:123px;">
 
-# .me Suite - Your AI Playground
-For every recursive action, there's a repercussion.
+# This.Me  
 
-```
-npm install this.me
-```
-
-Add to your project:
-
-```js
-let me = require('this.me');
-```
-**Docs:** [this.me](https://www.neurons.me/this-me)
-### Conceptual Flow:
-- [ ] Set up your context with [this.me.](https://www.npmjs.com/package/this.me)
-- [ ] Create a neural network using [neurons.me](https://www.neurons.me).
-- [ ] Define the data you'd like your neural network to recognize or process with [this.](https://www.neurons.me/this) modules.
-- [ ] Use [this.be](https://www.npmjs.com/package/this.be) to maintain a state or context, - watching over  [This](https://www.neurons.me/this) and any other states you define for example.
-- [ ] Define desired status and handlers, [be.this](https://www.npmjs.com/package/be.this).
-- [ ] Keep [i.mlearning](https://www.npmjs.com/package/i.mlearning).
 
-# Quick Start with Sandbox.
+**This.Me** is a digital identity representation of **Me** as it encapsulates the essence of an entity which is then passed for cryptographic guarantees.
 
-1. **Clone this Sandbox Demo Repository**
+Users no longer depend on centralized authorities for **identity and data management**. They hold the keys (literally) to their identity and data. 
 
-  ```bash
-  git clone https://github.com/suiGn/sandbox.git
-  ```
-2. **Navigate to the Project Directory**
+Services become more **user-centric,** providing services based on cryptographic proofs rather than centralized authorities.
 
-  ```bash
-  cd .me
-  ```
-3. **Install Dependencies**
-You can use either Yarn or npm to install the necessary dependencies.
+Here, you don't just own your identity; you seal it with cryptographic brilliance, untouched and ungoverned by any other. 
 
-**Using Yarn:**
+## Getting Started: 
 
 ```bash
-yarn install
+npm i -g this.me
 ```
 
-**Using npm:**
+### Require it:
 
-```bash
-npm install
+```js
+const me = require('this.me');
 ```
 
-4. **Launch the Application**
-
-  ```bash
-  npx electron index.js
-  ```
-
-  This model turns the traditional web model on its head. Users no longer depend on centralized authorities for identity or data management. They hold the keys (literally) to their identity and data. Services become more user-centric, providing services based on cryptographic proofs rather than centralized databases.
-
-  While this approach offers many benefits, including enhanced privacy and user sovereignty, it's still nascent and requires a paradigm shift in development, deployment, and user education.
-
-In an audacious twist of fate, I decided to circumvent the monotony of user session code and dive into the cryptographic labyrinth. Rather than getting bogged down by yawn-worthy password management and playing custodian to a sea of data, I embraced a vision where every individual holds the scepter to their digital kingdom. Centralized authorities? Toss 'em out the window. Here, you own your identity, seal it with cryptographic flair, and let no one else govern it. Sure, crafting a cryptographic symphony is no walk in the park, but compared to the drudgery of traditional server management, it feels like reinventing the wheel... but in a world where wheels were never round to begin with. Behold a system where every user is a master, every piece of data a treasure, all guarded by codes and ciphers. A little unorthodox, perhaps, but in an age of digital renaissance, who wants orthodox anyway?
-
- I'd sooner recode the Old and New Testaments, heck, throw in the Qabala too, in ASCII, before willingly plunging into the dull abyss of server-side user session management. Why swim in those murky waters when I can bask in the cryptographic labyrinth? Ditching the monotony of password management, I decided to champion a world where every individual becomes the keeper of their digital realms. Centralized authorities? More like relics of a bygone era. Here, you don't just own your identity; you seal it with cryptographic brilliance, untouched and ungoverned by any other. Crafting this cryptographic symphony may seem daunting, but compared to the tedium of server management? 
-
-POC || GTFO but for now I am traveling to new york.
-
-# Setting up your Context. 	👋🏻👋🏼👋🏽👋🏾👋🏿
-Defining the **environment** and context in which your code runs, especially when you're interacting with intelligent agents or services like **me.**
-Having a clear declaration of the environment and the context can have a series of implications for security, interoperability, and clarity. The codebase is often vast, dynamic, and continually evolving. Given the dynamic nature of such environments, ensuring the integrity of the code and data becomes paramount. You wouldn't want an agent to execute or rely on code that has been tampered with or is different from the expected version. This is where hashing comes into play.
-
-The **SHA256 cryptographic hash function** is used to produce a unique, fixed-length sequence of characters (a hash) for the data. This setup does a thorough job of hashing the content of files or entire directories.
-Even a tiny change in the content will result in a completely different hash.
- [Read More.](https://www.neurons.me/this-me#h.sg59uu9ka8i8)
+### Usage Example:
 
-## Quickstart Guide: Understanding `Me`
-
-### Introduction:
-
-Run node **demo.js** for quick example.
+Use it like this:
 
 ```js
-const Me = require('./me.js');
+const ThisMe = require('this.me');
+const user = new ThisMe('John', 'Doe', '1990-01-01', 'mypassword123', '1234');
+const identityObject = user.getIdentityObject();
+// identityObject can now be passed to Cleaker for hashing
 ```
 
-```js
-// Create a new Me instance
-const suign = new Me('Suign Name', 'suign@email.com', '01/01/1990', { city: 'SampleCity', country: 'SampleCountry' }, { theme: 'dark', notifications: true });
-// Print out the public key (for demonstration purposes)
-console.log("Suign's Public Key:", suign.getPublicKey());
-// Example: Sign some data
-const dataToSign = "Hello, World!";
-const signature = suign.signData(dataToSign);
-console.log("Signature for 'Hello, World!':", signature.toString('base64')); // Base64 encoding just to make the signature more readable in console.
-// Example: Verify the signature
-const isValidSignature = suign.verifySignature(dataToSign, signature);
-console.log("Is the signature valid?", isValidSignature);
-```
+## Understanding .ME
 
-**`Me`** is a digital identity representation. Rather than relying on traditional methods like username-password combinations, `Me` encapsulates the essence of an entity with cryptographic guarantees.
-
-### Key Features:
-
-1. **Cryptographic Identity**:
-   - Every instance of `Me` has a private and public key pair.
-   - These keys provide cryptographic proof of identity, allowing entities to sign and verify messages securely.
-2. **Profile Management**:
-   - `Me` contains information attributes such as name, email, birthdate, location, and preferences.
-   - These attributes can be updated and managed within the entity's lifecycle.
-3. **Network Interactions**:
-   - Being cryptographically unique, `Me` can safely interact with services on a network.
-   - It can register, authenticate, and perform actions with a guarantee of its identity.
-
-### Purpose:
-
-1. **Enhanced Security**
-   - Traditional authentication systems have vulnerabilities (e.g., password breaches). `Me` ensures that without the private key, impersonation is nearly impossible.
-2. **Decentralization Ready**
-   - `Me` fits perfectly in a decentralized environment, where trust is established not by central entities, but by cryptographic proofs.
-3. **User Centricity**
-   - The user has full control over their `Me` entity. They manage their keys and therefore their identity, making it resistant to censorship and external control.
-4. **Simplicity**
-   - Instead of managing multiple credentials for different services, `Me` offers a unified identity that's recognized across the network.
-
-### Getting Started:
-
-1. **Initialization**:
-   - Create an instance: `const myProfile = new Me('Name', 'email@email.com', 'birthdate', {location}, {preferences});`
-2. **Key Management**:
-   - Use integrated cryptographic methods to sign and verify data.
-   - Always ensure the private key remains confidential.
-3. **Interactions**:
-   - With the public key as an identifier, use `Me` to interact with services, sign transactions, or prove identity in network communications.
-
-------
-
-Remember, while `Me` provides enhanced security, the principle of key management is paramount. **Losing access to the private key might mean losing access to the associated identity.**
-
-Let's delve into the importance of such declarations:
-
-### Security Context:
-Defining the environment ensures that both the user and the IA have a clear understanding of the boundary within which interactions take place.
-Explicitly stating the environment can prevent unintended cross-boundary actions. For instance, without a clear declaration, an IA might access files or services that are beyond its permitted scope, leading to potential security vulnerabilities.
-A well-defined environment acts as a sandbox that can restrict unauthorized or unintended activities. For instance, browsers use a similar principle to run JavaScript in a sandboxed environment for security reasons.
-
-**Interoperability:**
-As the ecosystem of software and services becomes increasingly diverse, ensuring your code can interact smoothly with other systems becomes crucial.
-Declaring the environment or context helps ensure that all systems are on the "same page". For example, if an IA knows it's operating within the ".me" context, it can adjust its behavior, assumptions, and dependencies accordingly.
-
-**Auditability and Compliance:**
-For industries or applications where audit trails and compliance are important, having a clear declaration of the environment ensures that every interaction and operation can be traced back to a defined context.
-Such clear demarcations can aid in forensic analysis if something goes wrong or if there's a need to understand the context of an interaction.
-
-### Conclusion:
-In the broader context of a dynamic and interactive environment like the one you're building, hashing becomes a powerful tool. It's not just about verifying code; it's about ensuring the entire ecosystem's security, integrity, and seamless operation. By employing a hashing mechanism, you're taking a proactive step towards establishing trust in the code and data that powers your system.
-
-### Dependencies:   
-```json
-"dependencies": {
-    "be.this": "^1.1.3",
-    "cleaker": "^2.2.9",
-    "i.mlearning": "^2.1.7",
-    "netget": "^2.1.6",
-    "neurons.me": "^2.6.3",
-    "this.atom": "^1.0.3",
-    "this.audio": "^1.0.0",
-    "this.be": "^2.1.3",
-    "this.dom": "^1.0.0",
-    "this.pixel": "^3.3.5",
-    "this.pixelgrid": "^3.3.2",
-    "this.text": "^1.0.0",
-    "v.path": "^2.1.7"
-  },
-```
+##### Structure of this.me Package:
 
-# Context of Abstraction for Machine Learning Standardization
+**User Data Model:** Define a class or object structure to hold the user's data.
+**Data Validation:** Functions to validate the input data.
+**Data Processing:** Preparing data for hashing (by Cleaker).
+**Exporting Data:** A method to export the processed data in a format that Cleaker can accept.
 
-Traditional web development elements, from images to audio, are designed mainly for display and interaction. But what if they could be seamlessly converted into standardized formats primed for machine learning? That's the vision behind the **this.** modules.
 
-An Introduction to the this. JavaScript Library: Standardizing Web Development Elements for Machine Learning.
 
-## Principles Behind the this. Library:
 
-- ### **Abstraction for ML:**
+# Setting up your Context. 	👋🏻👋🏼👋🏽👋🏾👋🏿
+Defining the **environment** and context in which your code runs, especially when you're interacting with intelligent agents or services like **me.**
 
- The library's core principle is to abstract traditional web elements so that they're immediately primed for machine learning. It's about viewing web content not just as data but as structured, consistent, and standardized data.
+Having a clear declaration of the environment and the context can have a series of implications for security, interoperability, and clarity. The codebase is often vast, dynamic, and continually evolving. Given the dynamic nature of such environments, ensuring the integrity of the code and data becomes paramount. You wouldn't want an agent to execute or rely on code that has been tampered with or is different from the expected version. This is where hashing comes into play.
 
-- ### **Built on Web Standards:** 
 
-Rooted in JavaScript, the this. library builds upon public web development standards. The aim is to ensure that developers remain within familiar territories, even as they venture into the world of machine learning.
 
-- ### **Open and Collaborative:** 
+-----
 
-The this. library champions open standards. By leveraging public web standards, it invites collaboration, hoping to create a community that continually refines and enhances the bridge between web development and machine learning.
 
-[neurons.me](https://www.neurons.me)
 
-[neurons.me/this](https://www.neurons.me/this)
+`.me` objects to serve as both a local identity on the user's host machine and as an identity within a larger network. When a `.me` object is authenticated on a network, it can access data not only on the local host but also from other nodes within that network. Conversely, if it's not authenticated or recognized by the network, it should only access local data. Here's how this could be structured:
 
-# Clone THIS DEMO Playground
-Welcome to the THIS.ME Playground, where the entire THIS.ME suite comes together with NEURONS.ME to provide a rich development and execution environment for your AI adventures.
+### Local and Network Identity Management
 
-## Sandbox Demo Quick Start
-### 1. Clone the Repository
+1. **Local Identity**:
+   - When a `.me` object is created, it's initially configured with access to local host resources.
+   - Users can manage their local profile, which includes their personal settings, preferences, and local data access permissions.
+2. **Network Identity**:
+   - To access resources on the network, a `.me` object must be authenticated against the network, possibly by a central authority or a decentralized consensus mechanism.
+   - Once authenticated, the `.me` object's hash is recognized across the network, granting the user access to network resources according to their permissions.
+3. **Access Control**:
+   - Both local and network resources use access control lists (ACLs) that are tied to the `.me` object's hash.
+   - These ACLs determine what resources the `.me` object can access and the level of interaction permitted (read, write, execute).
+4. **Data Fetching**:
+   - When fetching data, the system checks if the `.me` object is authenticated within the network.
+   - If authenticated, the `.me` object can retrieve data from across the network based on the established ACLs.
+   - If not authenticated, the `.me` object is limited to retrieving data from the local host.
+5. **CLI Functionality**:
+   - The CLI tool facilitates the creation of `.me` objects, management of profiles, and authentication processes.
+   - It could include commands to "login" to the network, "logout", or "sync" local profiles with network profiles.
+6. **Data Sharing and Security**:
+   - Data sharing across the network should be secure, with encryption mechanisms in place to protect data in transit and at rest.
+   - The `.me` object's unique hash can be part of the encryption key, ensuring that only the intended `.me` object can decrypt and access the shared data.
 
-```bash
-git clone https://github.com/suiGn/.me.git
-```
-### 2. Navigate to the Project Directory
-```bash
-cd .me
-```
-### 3. Install Dependencies
-You can use either Yarn or npm to install the necessary dependencies.
-Using Yarn:
-```bash
-yarn install 
-```
-Using npm:
-```bash
-npm install
-```
-### 4. Launch the Application
-```
-npx electron index.js
-```
+### Example CLI Commands
+
+- `me init`: Initializes a new `.me` object on the local host.
+- `me login`: Authenticates the `.me` object against the network to access network resources.
+- `me logout`: De-authenticates the `.me` object from the network, reverting to local-only access.
+- `me sync`: Synchronizes local `.me` object data with the network profile.
+- `me fetch`: Retrieves data from the local host or network based on authentication status.
 
-**## License & Policies**
-\- ***\*License\****: MIT License (see LICENSE for details).
-\- ***\*Privacy Policy\****: Respects user privacy; no collection/storage of personal data.
-\- ***\*Terms of Usage\****: Use responsibly. No guarantees/warranties provided. [Terms](https://www.neurons.me/terms-of-use) | [Privacy](https://www.neurons.me/privacy-policy)
+By implementing this dual identity system, you enable a seamless transition for users between operating solely on their local device and engaging with a broader network, all while maintaining strict control over their data access rights.