this.me 2.9.4 → 2.9.5

package/notes/Index.md

@@ -0,0 +1,134 @@
+### **Index of `this.me` Structure**
+Here’s a comprehensive list of the components and their purposes within the `this.me` class:
+
+#### **1. Identity**
+- **Description:** Immutable attributes defining the core identity of the user.
+#### **2. Attributes**
+- **Description:** Flexible traits and descriptive properties of the user.
+#### **3. Relationships**
+- **Description:** Connections and associations with others.
+#### **4. Reactions**
+- **Description:** User’s interactions and engagements with the world.
+#### **5. Properties**
+- **Description:** Items owned or managed by the user.
+
+------
+
+### **1. The Me Structure Overview**
+#### **Core Components**
+- **Identity:** The foundation of the `this.me` object.
+  - Immutable attributes: `username`, `DID`.
+  - Core methods for validation and setup.
+
+------
+
+- **Attributes:** Fundamental identity traits.
+  Store and manage user traits dynamically:
+  - Examples: Name, age, location, pronouns, bio.
+    **Use `.be()` to add or update attributes.**
+
+    Example: 
+    ```json
+    { name: 'John Doe', age: 30, location: 'Earth' }
+    ```
+    Implement `be()` as a flexible key-value store.
+    Add validation for specific attributes (if required).
+
+------
+
+- **Relationships:** Connections with others.
+  - Examples: Friends, groups, networks, organizations.
+    **Contacts:** Individual connections.
+    **Groups:** Collections of users with shared context.
+
+    ```js
+    .relationships.addContact({ username: 'alice', status: 'friend' });
+    .relationships.createGroup({ name: 'Family', members: ['alice', 'bob'] });
+    ```
+
+  Define `addContact` and `createGroup` methods.
+  Enable nested relationship structures (e.g., groups of groups).
+
+------
+
+- **Reactions:** How a user interacts with the world.
+  Streamline all user engagements under `.react()`
+  - Examples: Likes, comments, shares, emotions.
+  - Categorization Rationale:
+    - Keeps all engagements unified.
+    - Expands easily (adding emojis, advanced reactions).
+
+  ```js
+  .react.add({ type: 'like', target: 'PostID' });
+  .react.add({ type: 'comment', target: 'PhotoID', content: 'Great pic!' });
+  ```
+  Design a structure to store and retrieve reactions efficiently.
+  Define a `log` system for reaction history.
+
+------
+
+- **Properties:** Things the user owns or manages.
+  Attach external, modular objects as user-owned assets:
+  - Use `this.me.properties` as a unified interface for ownership.
+  - Modular objects like `Wallet`, `Device`, `File`.
+  - Examples: Wallets, devices, digital files, accounts.
+  - **Sub-Methods:** Add, Share, Transfer Ownership, Revoke Access.
+
+```js
+const jabellae = new Me('jabellae'); // Create a new Me instance
+const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+jabellae.addProperty(wallet); // Add wallet as a property to Me
+```
+
+​	Implement `add`, `share`, `transferOwnership`, and `revokeAccess` methods for properties. Define modular objects (`Wallet`, `Device`) independently.
+
+1. **Creating a Wallet**
+    The wallet is created independently and then added to the `Me` instance's properties.
+   ```javascript
+   const jabellae = new Me('jabellae'); // Create a new Me instance
+   const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+   jabellae.addProperty(wallet); // Add wallet as a property to Me
+   ```
+
+2. **Sharing the Wallet**
+    Sharing logic is handled by the `Me` instance, not the property itself.
+   ```javascript
+   jabellae.shareProperty(wallet, 'otherMe', { permissions: 'view' });
+   ```
+
+3. **Transferring Ownership**
+    Ownership transfer is also managed by the `Me` instance.
+   ```javascript
+   jabellae.transferOwnership(wallet, 'otherMe');
+   ```
+
+------
+------
+------
+
+### **2. Why Independent Objects?**
+#### **Modularity**
+- Keeps the `this.me` instance *agnostic* of specifics.
+- Allows new property types to integrate seamlessly.
+
+#### **Reusability**
+- Each property (e.g., `this.wallet`, `this.device`) operates independently.
+- Can be ported across `this.me` instances without coupling.
+
+#### **Transferability**
+- Ownership is a property-level concern.
+- Example:
+
+  ```javascript
+  const wallet = new Wallet(owner = "me");
+  wallet.transferOwnership("otherMeInstance");
+  ```
+
+#### **Separation of Concerns**
+- Identity (`this.me`) manages relationships, attributes, and higher-level user interactions.
+- Objects like `Wallet` or `Device` manage their specific functionality.
+
+#### **Scalability**
+- Adding a new property type is as simple as:
+  1. Defining the object (e.g., `Vehicle`).
+  2. Registering it with `this.me`.

package/{md/context.md → notes/Inmutabilidad_de_la_Identidad_basica.md}

@@ -1,7 +1,9 @@
-Lo que estás describiendo sobre **this.me** y el proceso de autenticación con **Cleaker** como una red de identificación descentralizada (**DID**) tiene sentido dentro de un marco de criptografía y autenticación distribuida. A continuación, desgloso los puntos importantes para asegurarnos de que el concepto sea claro y funcional:
+ El mayor acto de rebelión en un mundo que busca controlarte es ser libre de verdad.
+ 
+ **this.me** y el proceso de autenticación con **Cleaker** como una red de identificación descentralizada (**DID**) tiene sentido dentro de un marco de criptografía y autenticación distribuida. A continuación, desgloso los puntos importantes para asegurarnos de que el concepto sea claro y funcional:
 
 ### **Inmutabilidad de la Identidad Básica**
-Tu sistema **this.me** se basa en la creación de una identidad criptográficamente segura. Los componentes inmutables que mencionas (nombre de usuario, email y la red de autenticación) son fundamentales para que el sistema garantice que la identidad siempre se pueda verificar a partir de un hash único.
+**this.me** se basa en la creación de una identidad. Los componentes inmutables que mencionas (nombre de usuario, email y la red de autenticación) son fundamentales para que el sistema garantice que la identidad siempre se pueda verificar a partir de un hash único.
 
 1. **Nombre de Usuario (username)**: El nombre de usuario es clave en la identidad. No puede cambiar una vez creado porque el hash que lo representa depende de esta cadena de caracteres.
 2. **Correo Electrónico (email)**: Esto actúa como otra pieza inmutable, probablemente porque es un dato importante para autenticar usuarios a través de redes o servicios.

package/notes/Questions.md

@@ -0,0 +1,62 @@
+Key Questions to Address
+Identity Core: What defines the essence of .me?
+Relationships: How does .me relate to others, groups, or larger entities?
+Belongings: What does .me own or have as personal items?
+Modularity: How do we allow external objects to seamlessly integrate with .me?
+Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?
+---
+
+### **1. Identity Core: What defines the essence of `.me`?**
+   - **Essence Defined:**
+     - **Immutable Core Attributes:** `username` and `DID` (Decentralized Identifier).
+     - Clearly distinguishes the user's unique existence in the digital realm.
+   - **Practical Implementation:**
+     - Identity core is foundational and unchangeable, ensuring trust and consistency across systems.
+
+---
+
+### **2. Relationships: How does `.me` relate to others, groups, or larger entities?**
+   - **Connections Defined:**
+     - **Contacts:** Direct relationships (e.g., friends, acquaintances).
+     - **Groups:** Collections with shared contexts (e.g., family, organizations, societies).
+   - **Methods:**
+     - `.relationships.addContact()` to add individual connections.
+     - `.relationships.createGroup()` to organize groups dynamically.
+   - **Hierarchy:**
+     - Nested structures enable relationships at various tiers (e.g., groups of groups, organizations within societies).
+
+---
+
+### **3. Belongings: What does `.me` own or have as personal items?**
+   - **Properties Defined:**
+     - Everything the user owns or manages (e.g., wallets, devices, digital files).
+   - **Methods for Ownership:**
+     - `.properties.add()`, `.properties.share()`, `.properties.transferOwnership()`, `.properties.revokeAccess()`.
+   - **Modular Approach:**
+     - Allows external objects like `Wallet`, `Device`, or `Vehicle` to integrate without hardcoding.
+
+---
+
+### **4. Modularity: How do we allow external objects to seamlessly integrate with `.me`?**
+   - **Independent Objects:**
+     - Objects like `Wallet`, `Device`, etc., are designed and managed outside the `this.me` instance.
+   - **Integration:**
+     - These objects are registered to `this.me` via methods like `.addProperty()`.
+     - They maintain their internal logic while adhering to the ownership and interaction protocols defined by `.me`.
+   - **Advantages:**
+     - Scalability: Easy to introduce new objects without modifying the `this.me` core.
+     - Transferability: Ownership can move across `.me` instances seamlessly.
+
+---
+
+### **5. Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?**
+   - **Tiers of Interactions:**
+     - **Reactions:** Personal engagements (`like`, `comment`, `share`).
+     - **Relationships:** Broader social connections (individuals, groups, organizations).
+     - **Attributes:** How `.me` defines itself (e.g., status, bio, pronouns).
+     - **Properties:** Interaction with owned or managed items.
+   - **Unified Structure:**
+     - Centralized under `.reactions` and `.relationships`.
+     - Interaction types remain modular and expandable, allowing for a hierarchy to emerge naturally through usage (e.g., personal to societal interactions).
+
+---

package/notes/Summary.md

@@ -0,0 +1,125 @@
+# this.me — Identity System
+
+## ✨ Summary
+`this.me` is a decentralized identity system designed to allow users to manage their own identities locally, with optional validation by external authorities such as Cleaker. It combines privacy, user control, and secure interoperability.
+
+
+## 🔐 Identity Model Comparison
+| **Model**            | **Where your identity lives** | **Local signing** | **Real freedom**        |
+|----------------------|-------------------------------|-------------------|--------------------------|
+| Web2 (Facebook, etc) | On their servers              | ❌                | ❌                       |
+| Web3 (wallets)       | In extensions or apps         | ✅                | 🟡 (fragmented)          |
+| `this.me`            | In your OS `.this/me/`        | ✅✅              | ✅✅✅                   |
+
+---
+
+## 🔍 Core Principles
+1. **Freedom to Declare**
+   Anyone can generate a `.me` identity locally without external approval.
+2. **Trusted Endorsements**
+   Authorities (e.g., Cleaker) can endorse `.me` identities without controlling them.
+3. **Local Ownership**
+   All sensitive data (including private keys) stays on the user's machine.
+
+---
+## 📁 File Structure
+* `~/.this/me/username.me.json` — Encrypted identity file
+* `.me` includes:
+
+  * `username`
+  * `publicKey`, `privateKey` (encrypted)
+  * `attributes`, `relationships`, `reactions`, `properties`, `relationships`
+  * `endorsements`
+
+---
+
+## 🔎 Identity Lifecycle
+
+### 1. Create Identity
+```bash
+me create jabellae
+# Prompts for hash (e.g. 4242)
+# Generates encrypted .me file
+```
+
+### 2. Register/Endorse with Authority
+```bash
+me endorse --with cleaker
+# Signs and shares publicKey with Cleaker
+```
+
+### 3. Verify Identity
+```bash
+me verify --with cleaker
+# Validates signature and authority endorsement
+```
+
+### 4. Migrate Across Devices
+```bash
+me restore --from-seed
+# Or use encrypted backup file + hash
+```
+
+### 5. Rotate Keys
+```bash
+me rotate
+# Generates new key pair, requires re-endorsement
+```
+
+---
+
+## 🔐 Cryptographic Model
+* Identity is unlocked using a user-defined `hash` (password).
+* This hash decrypts the local `.me` file.
+* The identity includes:
+
+  * A **key pair** (public/private) for signing and verification.
+  * Optional **endorsements** signed by Cleaker or other authorities.
+
+---
+
+## 🛡️ Security Model
+* No private key ever leaves the local `.me` file.
+* Endorsements are public and verifiable using the public key.
+* If compromised, user can rotate keys and notify authorities.
+
+---
+
+## 🌐 Multi-Device Support
+* `.me` can be restored using a seed phrase or backup.
+* New devices can be authorized using signatures from old devices.
+
+---
+
+## ⚖️ Responsibilities
+
+* **this.me**
+  * Local file management, encryption, signing.
+  * CLI + API for usage.
+
+* **Cleaker / Authorities**
+
+  * Store trusted records of `username` + `publicKey`
+  * Provide validation/endorsement services.
+
+---
+
+## 🌍 Future Use Cases
+* Digital signature of documents
+* Smart contract interaction
+* Federated profiles with trust anchors
+* Group identity and shared contexts (`me && you && them in context/friends`)
+
+---
+
+## 📖 Glossary
+* `hash`: A password-like string used to unlock `.me`
+* `endorsement`: Signature from a recognized authority on the identity
+* `publicKey/privateKey`: Cryptographic key pair for identity signing
+* `Cleaker`: Example identity authority ledger
+
+---
+
+**Author:** suiGn / neurons.me
+**License:** MIT
+**Project:** [this.me](https://www.npmjs.com/package/this.me)

package/notes/The Problem: Decentralized Yet Trustworthy.md

@@ -0,0 +1,13 @@
+The Problem: Decentralized Yet Trustworthy
+Identity, by its nature, is both personal and relational. On the one hand, we want the freedom to define ourselves without external constraints. On the other, our identities must often be validated by trusted authorities to engage in meaningful transactions, whether signing a digital contract or interacting with a service.
+
+Traditional centralized systems — such as social media platforms, government IDs, or corporate logins — often prioritize control over freedom. These systems require users to surrender their data and identities to be recognized. While decentralized technologies like blockchains have emerged to challenge this model, they introduce their own complexities and limitations, such as over-reliance on cryptographic keys or lack of intuitive identity frameworks.
+
+The question arises:How can we create an identity system that respects personal sovereignty while ensuring trust and usability in a networked world?
+
+Enter This.me: A New Paradigm for Identity
+This.me offers a framework for identity creation and interaction that revolves around two core principles:
+
+1. Freedom to Declare: Anyone can create a `.me` instance and define their identity without external permissions. This identity exists as a standalone object, enabling users to interact in a purely self-declared state.
+
+2. Trust Anchors: When needed, central authorities or networks, such as Cleaker, can validate the identity. These authorities provide the infrastructure for authentication, signing, and verification without compromising the user’s control over their identity.

package/notes/Understanding me && you && himContext.md

@@ -0,0 +1,11 @@
+This structure implies:
+
+1. Logical Grouping of Entities: me && you && him represents a logical grouping, where each entity is included as part of a broader relationship.
+
+2. Contextual Scoping: Context/mexicans provides a scope within which this relationship exists, giving meaning to the relationship without establishing a strict hierarchy among me, you, and him.
+
+3. Dynamic Meaning: The meaning can change based on context. For example:
+
+• me && you && himContext/mexicans could mean a group of entities (me, you, him) sharing a “Mexican” attribute.
+
+Context/friends might represent the same group within a “friends” context, applying different attributes or significance.

package/notes/hot_encoding.md

@@ -0,0 +1,44 @@
+### Neural Networks - **One-Hot Encoding**
+--------
+To represent the combinations of **“me, you, him, her, it, us, them”** in a neural network, we need to convert the elements into a suitable format for neural network processing, such as one-hot encoding, and design a neural network architecture that can process these inputs.
+
+Here’s a step-by-step approach to achieve this:
+1.	**One-Hot Encoding:** Convert each element (“me”, “you”, “him”, “her”, “it”, “us”, “them”) into a one-hot encoded vector.
+2.	**Combination Representation:** Create input vectors for each combination by combining the one-hot encoded vectors.
+3.	**Neural Network Design:** Design a simple neural network to process these input vectors.
+
+#### Step 1: One-Hot Encoding
+One-hot encoding represents each element as a binary vector with a single high (1) value and the rest low (0). For the elements “me”, “you”, “him”, “her”, “it”, “us”, “them”, we can assign the following one-hot encoded vectors:
+
+```js
+// Create Me instances
+const meInstance = new Me('me');
+const youInstance = new Me('you');
+const himInstance = new Me('him');
+const herInstance = new Me('her');
+const itInstance = new Me('it');
+const usInstance = new Me('us');
+const themInstance = new Me('them');
+
+// One-hot encoding representation
+const subjects = {
+  'me': [1, 0, 0, 0, 0, 0, 0],
+  'you': [0, 1, 0, 0, 0, 0, 0],
+  'him': [0, 0, 1, 0, 0, 0, 0],
+  'her': [0, 0, 0, 1, 0, 0, 0],
+  'it': [0, 0, 0, 0, 1, 0, 0],
+  'us': [0, 0, 0, 0, 0, 1, 0],
+  'them': [0, 0, 0, 0, 0, 0, 1]
+};
+```
+
+#### Step 2: Combination Representation
+For each combination, we can create an input vector by combining the one-hot encoded vectors of its elements. For example:
+Combination “me, you” would be represented as the sum of the one-hot vectors for “me” and “you”:
+
+```
+[1, 0, 0, 0, 0, 0, 0] + [0, 1, 0, 0, 0, 0, 0] = [1, 1, 0, 0, 0, 0, 0]
+```
+---
+### Me Deviation Formula
+**How Spread Out the data Points are around the .me?**

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "this.me",
-  "version": "2.9.4",
+  "version": "2.9.5",
   "description": "_me-Centric.",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",
-    "test": "test"
+    "test": "test",
+    "postinstall": "node src/scripts/setup.js"
   },
   "bin": {
-    ".me": "src/.me.cli.js"
+    "me": "bin/me.cli.js"
   },
   "keywords": [
     "this.me",

package/src/example.js

@@ -1,6 +1,6 @@
+//this.me/src/example.js
 import Me from './me.js';
 import chalk from 'chalk';
-
 // Create a new Me instance
 let me = new Me('suign');
 // Add attributes to the identity

package/src/me.js

@@ -1,56 +1,148 @@
-//this.me/src/me.js
+// src/me.js
+import fs from 'fs';
+import path from 'path';
 import crypto from 'crypto';
 import os from 'os';
 
-// Define the .me class
-class Me{
-  // Static property to keep track of all users globally
-  static registry = {};
+const ROOT_DIR = path.join(os.homedir(), '.this', 'me');
 
-  constructor(username = 'monad') {
-    if (Me.registry[username]) {
-      throw new Error(`Username ${username} already exists in the registry.`);
-    }
-    this.username = this.validateMe(username);
-    this.identity = {
-      username: this.username,
-      hash: this.sha256(),
-      host: this.getHostInfo()
-    };
-    Me.registry[username] = this; // Add to global registry
+class Me {
+  constructor(username) {
+    this.username = username;
+    this.filePath = path.join(ROOT_DIR, `${username}.me`); // encrypted .me file path
+    this.unlocked = false; // will become true after decrypting with correct hash
+    this.data = null; // holds decrypted data (identity, keys, attributes, etc.)
+  }
+
+  /**
+   * Encrypt and write the current `this.data` to disk.
+   */
+  save(hash) {
+    if (!this.data) throw new Error('No data to save');
+    const iv = crypto.randomBytes(16);
+    const key = crypto.createHash('sha256').update(hash).digest();
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    const encrypted = Buffer.concat([
+      iv,
+      cipher.update(JSON.stringify(this.data)),
+      cipher.final()
+    ]);
+    fs.writeFileSync(this.filePath, encrypted);
   }
 
-  validateMe(username) {
-    const regex = /^[a-zA-Z0-9]{1,21}$/;
-    if (regex.test(username)) {
-      return username;
-    } else {
-      throw new Error('Incorrect username. Only letters and numbers are allowed, and it must be between 1 and 21 characters.');
+  /**
+   * Unlock the .me file by decrypting it using the provided hash.
+   */
+  unlock(hash) {
+    const fileBuffer = fs.readFileSync(this.filePath);
+    const iv = fileBuffer.slice(0, 16);
+    const encryptedData = fileBuffer.slice(16);
+    const key = crypto.createHash('sha256').update(hash).digest();
+    try {
+      const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+      const decrypted = Buffer.concat([
+        decipher.update(encryptedData),
+        decipher.final()
+      ]);
+      this.data = JSON.parse(decrypted.toString('utf-8'));
+      this.unlocked = true;
+      return true;
+    } catch (err) {
+      return false; // incorrect hash or corrupted file
     }
   }
 
-  sha256() {
-    return crypto.createHash('sha256').update(this.username).digest('hex');
+  /**
+   * Locks the session by wiping in-memory data.
+   */
+  lock() {
+    this.data = null;
+    this.unlocked = false;
   }
 
-  getHostInfo() {
-    return {
-      hostname: os.hostname(),
-      platform: os.platform(),
-      networkInterfaces: os.networkInterfaces()
-    };
+ /**
+   * Create a new identity file for the given username.
+   * Called only if it doesn't already exist.
+   */
+ static create(username, hash) {
+  const me = new Me(username);
+  if (fs.existsSync(me.filePath)) {
+    throw new Error('Identity already exists');
   }
 
-  be(attributes) {
-    for (const [key, value] of Object.entries(attributes)) {
-      this.identity[key] = value;
+  // Generate keys or initial structure
+  me.data = {
+    identity: {
+      username,
+      publicKey: 'publicKeyPlaceholder', // later generate real keypair
+      privateKey: 'privateKeyPlaceholder'
+    },
+    attributes: {},
+    relationships: [],
+    reactions: [],
+    endorsements: []
+  };
+
+  me.save(hash);
+  return me;
+}
+
+  /**
+   * Create a new identity file for the given username.
+   * Called only if it doesn't already exist.
+   */
+  static create(username, hash) {
+    const me = new Me(username);
+    if (fs.existsSync(me.filePath)) {
+      throw new Error('Identity already exists');
     }
+
+    // Generate keys or initial structure
+    me.data = {
+      identity: {
+        username,
+        publicKey: 'publicKeyPlaceholder', // later generate real keypair
+        privateKey: 'privateKeyPlaceholder'
+      },
+      attributes: {},
+      relationships: [],
+      reactions: [],
+      endorsements: []
+    };
+
+    me.save(hash);
+    return me;
+  }
+
+  /**
+   * Load and decrypt an existing identity.
+   */
+  static load(username, hash) {
+    const me = new Me(username);
+    const success = me.unlock(hash);
+    if (!success) throw new Error('Invalid hash or corrupted file');
+    return me;
+  }
+  /**
+   * Add an endorsement (external signature asserting trust in this identity).
+   */
+  addEndorsement(endorsement) {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    this.data.endorsements.push(endorsement);
+  }
+
+  /**
+   * Example: add an attribute to this.me (like `.be("artist")`).
+   */
+  be(key, value) {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    this.data.attributes[key] = value;
   }
 
-  // Static method to retrieve all users
-  static getAllUsers() {
-    return Me.registry;
+  getAttributes() {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    return this.data.attributes;
   }
 }
 
-export default Me;
+export default Me;