this.me 2.7.7 → 2.7.8

package/README.md

@@ -1,68 +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  
-I decided to circumvent the monotony of user session code and dive into the cryptographic labyrinth.
- 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.
+# This.Me  
 
-# 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.
-Continue reading about this:
-https://www.mlearning.studio/data-formats/this-me
 
-## Quickstart Guide: Understanding `Me`
-Run node **demo.js** for quick example.
+**This.Me** is a digital identity representation of **Me** as it encapsulates the essence of an entity which is then passed for cryptographic guarantees.
+
+Users no longer depend on centralized authorities for **identity and 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 authorities.
+
+Here, you don't just own your identity; you seal it with cryptographic brilliance, untouched and ungoverned by any other. 
+
+## Getting Started: 
+
+```bash
+npm i -g this.me
+```
+
+### Require it:
 
 ```js
-const Me = require('this.me');
+const me = require('this.me');
 ```
 
+### Usage Example:
+
+Use it like this:
+
 ```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
-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);
+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
 ```
 
-**`Me`** is a digital identity representation. `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.
-
-### 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.
-
-# Context of Abstraction for Machine Learning Standardization
-[neurons.me](https://www.neurons.me)
-[neurons.me/this](https://www.neurons.me/this)
-
-**## 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)
+## Understanding .ME
+
+##### Structure of this.me Package:
+
+**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.
+
+
+
+
+# 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.
+
+
+
+-----
+
+
+
+`.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:
+
+### Local and Network Identity Management
+
+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.
+
+### 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.
+
+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.